blob: c9f0c2de6ac70645dbd8ec48690ac5cdc9fe56b3 [file] [log] [blame]
Willy Tarreaudd815982007-10-16 12:25:14 +02001/*
Willy Tarreaud1d54542012-09-12 22:58:11 +02002 * Listener management functions.
Willy Tarreaudd815982007-10-16 12:25:14 +02003 *
Willy Tarreau0ccb7442013-01-07 22:54:17 +01004 * Copyright 2000-2013 Willy Tarreau <w@1wt.eu>
Willy Tarreaudd815982007-10-16 12:25:14 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Willy Tarreau6ae1ba62014-05-07 19:01:58 +020013#include <ctype.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020014#include <errno.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020015#include <stdio.h>
16#include <string.h>
Willy Tarreau95ccdde2014-02-01 09:28:36 +010017#include <unistd.h>
18#include <fcntl.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020019
Willy Tarreaudcc048a2020-06-04 19:11:43 +020020#include <haproxy/acl.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020021#include <haproxy/api.h>
Willy Tarreau6be78492020-06-05 00:00:29 +020022#include <haproxy/cfgparse.h>
Willy Tarreau7ea393d2020-06-04 18:02:10 +020023#include <haproxy/connection.h>
Willy Tarreau8d366972020-05-27 16:10:29 +020024#include <haproxy/errors.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020025#include <haproxy/fd.h>
26#include <haproxy/freq_ctr.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020027#include <haproxy/global.h>
Willy Tarreau853b2972020-05-27 18:01:47 +020028#include <haproxy/list.h>
Willy Tarreau213e9902020-06-04 14:58:24 +020029#include <haproxy/listener.h>
Willy Tarreauaeed4a82020-06-04 22:01:04 +020030#include <haproxy/log.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020031#include <haproxy/protocol-t.h>
32#include <haproxy/protocol.h>
33#include <haproxy/sample.h>
Willy Tarreaudfd3de82020-06-04 23:46:14 +020034#include <haproxy/stream.h>
Willy Tarreaucea0e1b2020-06-04 17:25:40 +020035#include <haproxy/task.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020036#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020037#include <haproxy/tools.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020038
Willy Tarreaub648d632007-10-28 22:13:50 +010039
Willy Tarreau26982662012-09-12 23:17:10 +020040/* List head of all known bind keywords */
41static struct bind_kw_list bind_keywords = {
42 .list = LIST_HEAD_INIT(bind_keywords.list)
43};
44
Willy Tarreaua1d97f82019-12-10 11:18:41 +010045/* list of the temporarily limited listeners because of lack of resource */
46static struct mt_list global_listener_queue = MT_LIST_HEAD_INIT(global_listener_queue);
47static struct task *global_listener_queue_task;
48static struct task *manage_global_listener_queue(struct task *t, void *context, unsigned short state);
49
50
Willy Tarreau1efafce2019-01-27 15:37:19 +010051#if defined(USE_THREAD)
52
53struct accept_queue_ring accept_queue_rings[MAX_THREADS] __attribute__((aligned(64))) = { };
54
55/* dequeue and process a pending connection from the local accept queue (single
Willy Tarreau83efc322020-10-14 17:37:17 +020056 * consumer). Returns the accepted connection or NULL if none was found.
Willy Tarreau1efafce2019-01-27 15:37:19 +010057 */
Willy Tarreau83efc322020-10-14 17:37:17 +020058struct connection *accept_queue_pop_sc(struct accept_queue_ring *ring)
Willy Tarreau1efafce2019-01-27 15:37:19 +010059{
Willy Tarreau1efafce2019-01-27 15:37:19 +010060 unsigned int pos, next;
Willy Tarreau83efc322020-10-14 17:37:17 +020061 struct connection *ptr;
62 struct connection **e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010063
64 pos = ring->head;
65
66 if (pos == ring->tail)
Willy Tarreau83efc322020-10-14 17:37:17 +020067 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010068
69 next = pos + 1;
70 if (next >= ACCEPT_QUEUE_SIZE)
71 next = 0;
72
73 e = &ring->entry[pos];
74
75 /* wait for the producer to update the listener's pointer */
76 while (1) {
Willy Tarreau83efc322020-10-14 17:37:17 +020077 ptr = *e;
Willy Tarreau1efafce2019-01-27 15:37:19 +010078 __ha_barrier_load();
79 if (ptr)
80 break;
81 pl_cpu_relax();
82 }
83
Willy Tarreau1efafce2019-01-27 15:37:19 +010084 /* release the entry */
Willy Tarreau83efc322020-10-14 17:37:17 +020085 *e = NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +010086
87 __ha_barrier_store();
88 ring->head = next;
Willy Tarreau83efc322020-10-14 17:37:17 +020089 return ptr;
Willy Tarreau1efafce2019-01-27 15:37:19 +010090}
91
92
Willy Tarreau83efc322020-10-14 17:37:17 +020093/* tries to push a new accepted connection <conn> into ring <ring>. Returns
94 * non-zero if it succeeds, or zero if the ring is full. Supports multiple
95 * producers.
Willy Tarreau1efafce2019-01-27 15:37:19 +010096 */
Willy Tarreau83efc322020-10-14 17:37:17 +020097int accept_queue_push_mp(struct accept_queue_ring *ring, struct connection *conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +010098{
Willy Tarreau1efafce2019-01-27 15:37:19 +010099 unsigned int pos, next;
100
101 pos = ring->tail;
102 do {
103 next = pos + 1;
104 if (next >= ACCEPT_QUEUE_SIZE)
105 next = 0;
106 if (next == ring->head)
107 return 0; // ring full
Olivier Houchard64213e92019-03-08 18:52:57 +0100108 } while (unlikely(!_HA_ATOMIC_CAS(&ring->tail, &pos, next)));
Willy Tarreau1efafce2019-01-27 15:37:19 +0100109
Willy Tarreau83efc322020-10-14 17:37:17 +0200110 ring->entry[pos] = conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100111 __ha_barrier_store();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100112 return 1;
113}
114
115/* proceed with accepting new connections */
116static struct task *accept_queue_process(struct task *t, void *context, unsigned short state)
117{
118 struct accept_queue_ring *ring = context;
Willy Tarreau83efc322020-10-14 17:37:17 +0200119 struct connection *conn;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100120 struct listener *li;
Christopher Faulet102854c2019-04-30 12:17:13 +0200121 unsigned int max_accept;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100122 int ret;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100123
Christopher Faulet102854c2019-04-30 12:17:13 +0200124 /* if global.tune.maxaccept is -1, then max_accept is UINT_MAX. It
125 * is not really illimited, but it is probably enough.
126 */
127 max_accept = global.tune.maxaccept ? global.tune.maxaccept : 64;
128 for (; max_accept; max_accept--) {
Willy Tarreau83efc322020-10-14 17:37:17 +0200129 conn = accept_queue_pop_sc(ring);
130 if (!conn)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100131 break;
132
Willy Tarreau83efc322020-10-14 17:37:17 +0200133 li = __objt_listener(conn->target);
Olivier Houchard64213e92019-03-08 18:52:57 +0100134 _HA_ATOMIC_ADD(&li->thr_conn[tid], 1);
Willy Tarreau83efc322020-10-14 17:37:17 +0200135 ret = li->accept(conn);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100136 if (ret <= 0) {
137 /* connection was terminated by the application */
138 continue;
139 }
140
141 /* increase the per-process number of cumulated sessions, this
142 * may only be done once l->accept() has accepted the connection.
143 */
144 if (!(li->options & LI_O_UNLIMITED)) {
145 HA_ATOMIC_UPDATE_MAX(&global.sps_max,
146 update_freq_ctr(&global.sess_per_sec, 1));
147 if (li->bind_conf && li->bind_conf->is_ssl) {
148 HA_ATOMIC_UPDATE_MAX(&global.ssl_max,
149 update_freq_ctr(&global.ssl_per_sec, 1));
150 }
151 }
152 }
153
154 /* ran out of budget ? Let's come here ASAP */
Christopher Faulet102854c2019-04-30 12:17:13 +0200155 if (!max_accept)
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200156 tasklet_wakeup(ring->tasklet);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100157
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200158 return NULL;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100159}
160
161/* Initializes the accept-queues. Returns 0 on success, otherwise ERR_* flags */
162static int accept_queue_init()
163{
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200164 struct tasklet *t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100165 int i;
166
167 for (i = 0; i < global.nbthread; i++) {
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200168 t = tasklet_new();
Willy Tarreau1efafce2019-01-27 15:37:19 +0100169 if (!t) {
170 ha_alert("Out of memory while initializing accept queue for thread %d\n", i);
171 return ERR_FATAL|ERR_ABORT;
172 }
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200173 t->tid = i;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100174 t->process = accept_queue_process;
175 t->context = &accept_queue_rings[i];
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200176 accept_queue_rings[i].tasklet = t;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100177 }
178 return 0;
179}
180
181REGISTER_CONFIG_POSTPARSER("multi-threaded accept queue", accept_queue_init);
182
183#endif // USE_THREAD
184
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200185/* adjust the listener's state and its proxy's listener counters if needed.
186 * It must be called under the listener's lock, but uses atomic ops to change
187 * the proxy's counters so that the proxy lock is not needed.
188 */
Willy Tarreaua37b2442020-09-24 07:23:45 +0200189void listener_set_state(struct listener *l, enum li_state st)
190{
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200191 struct proxy *px = l->bind_conf->frontend;
192
193 if (px) {
194 /* from state */
195 switch (l->state) {
196 case LI_NEW: /* first call */
197 _HA_ATOMIC_ADD(&px->li_all, 1);
198 break;
199 case LI_INIT:
200 case LI_ASSIGNED:
201 break;
202 case LI_PAUSED:
203 _HA_ATOMIC_SUB(&px->li_paused, 1);
204 break;
205 case LI_LISTEN:
206 _HA_ATOMIC_SUB(&px->li_bound, 1);
207 break;
208 case LI_READY:
209 case LI_FULL:
210 case LI_LIMITED:
211 _HA_ATOMIC_SUB(&px->li_ready, 1);
212 break;
213 }
214
215 /* to state */
216 switch (st) {
217 case LI_NEW:
218 case LI_INIT:
219 case LI_ASSIGNED:
220 break;
221 case LI_PAUSED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200222 BUG_ON(l->rx.fd == -1);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200223 _HA_ATOMIC_ADD(&px->li_paused, 1);
224 break;
225 case LI_LISTEN:
Willy Tarreau95a34602020-10-08 15:32:21 +0200226 BUG_ON(l->rx.fd == -1);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200227 _HA_ATOMIC_ADD(&px->li_bound, 1);
228 break;
229 case LI_READY:
230 case LI_FULL:
231 case LI_LIMITED:
Willy Tarreau95a34602020-10-08 15:32:21 +0200232 BUG_ON(l->rx.fd == -1);
Willy Tarreauefc0eec2020-09-24 07:27:06 +0200233 _HA_ATOMIC_ADD(&px->li_ready, 1);
234 break;
235 }
236 }
Willy Tarreaua37b2442020-09-24 07:23:45 +0200237 l->state = st;
238}
239
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100240/* This function adds the specified listener's file descriptor to the polling
241 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Ilya Shipitsin6fb0f212020-04-02 15:25:26 +0500242 * LI_FULL state depending on its number of connections. In daemon mode, we
Willy Tarreauae302532014-05-07 19:22:24 +0200243 * also support binding only the relevant processes to their respective
244 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100245 */
Willy Tarreau7834a3f2020-09-25 16:40:18 +0200246void enable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100247{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100248 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200249
250 /* If this listener is supposed to be only in the master, close it in
251 * the workers. Conversely, if it's supposed to be only in the workers
252 * close it in the master.
253 */
Willy Tarreau18c20d22020-10-09 16:11:46 +0200254 if (!!master != !!(listener->rx.flags & RX_F_MWORKER))
Willy Tarreau75c98d12020-10-09 15:55:23 +0200255 do_unbind_listener(listener);
Willy Tarreaud6afb532020-10-09 10:35:40 +0200256
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100257 if (listener->state == LI_LISTEN) {
Willy Tarreau95a34602020-10-08 15:32:21 +0200258 BUG_ON(listener->rx.fd == -1);
William Lallemand095ba4c2017-06-01 17:38:50 +0200259 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau38dba272020-11-04 13:54:00 +0100260 (!!master != !!(listener->rx.flags & RX_F_MWORKER) ||
261 !(proc_mask(listener->rx.settings->bind_proc) & pid_bit))) {
Willy Tarreauae302532014-05-07 19:22:24 +0200262 /* we don't want to enable this listener and don't
263 * want any fd event to reach it.
264 */
Willy Tarreau75c98d12020-10-09 15:55:23 +0200265 do_unbind_listener(listener);
Willy Tarreauae302532014-05-07 19:22:24 +0200266 }
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100267 else if (!listener->maxconn || listener->nbconn < listener->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200268 listener->rx.proto->enable(listener);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200269 listener_set_state(listener, LI_READY);
Willy Tarreauae302532014-05-07 19:22:24 +0200270 }
271 else {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200272 listener_set_state(listener, LI_FULL);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100273 }
274 }
Willy Tarreaud6afb532020-10-09 10:35:40 +0200275
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100276 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100277}
278
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200279/*
280 * This function completely stops a listener. It will need to operate under the
281 * proxy's lock, the protocol's lock, and the listener's lock. The caller is
282 * responsible for indicating in lpx, lpr, lli whether the respective locks are
283 * already held (non-zero) or not (zero) so that the function picks the missing
284 * ones, in this order. The proxy's listeners count is updated and the proxy is
285 * disabled and woken up after the last one is gone.
286 */
287void stop_listener(struct listener *l, int lpx, int lpr, int lli)
288{
289 struct proxy *px = l->bind_conf->frontend;
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200290
291 if (l->options & LI_O_NOSTOP) {
292 /* master-worker sockpairs are never closed but don't count as a
293 * job.
294 */
295 return;
296 }
297
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200298 if (!lpx)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200299 HA_RWLOCK_WRLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200300
301 if (!lpr)
302 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
303
304 if (!lli)
305 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
306
307 if (l->state > LI_INIT) {
Willy Tarreau75c98d12020-10-09 15:55:23 +0200308 do_unbind_listener(l);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200309
310 if (l->state >= LI_ASSIGNED)
311 __delete_listener(l);
312
Willy Tarreauacde1522020-10-07 16:31:39 +0200313 proxy_cond_disable(px);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200314 }
315
316 if (!lli)
317 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
318
319 if (!lpr)
320 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
321
322 if (!lpx)
Willy Tarreauac66d6b2020-10-20 17:24:27 +0200323 HA_RWLOCK_WRUNLOCK(PROXY_LOCK, &px->lock);
Willy Tarreaucaa7df12020-10-07 15:58:50 +0200324}
325
Willy Tarreaue03204c2020-10-09 17:02:21 +0200326/* default function called to suspend a listener: it simply passes the call to
327 * the underlying receiver. This is find for most socket-based protocols. This
328 * must be called under the listener's lock. It will return non-zero on success,
329 * 0 on failure. If no receiver-level suspend is provided, the operation is
330 * assumed to succeed.
331 */
332int default_suspend_listener(struct listener *l)
333{
334 int ret = 1;
335
336 if (!l->rx.proto->rx_suspend)
337 return 1;
338
339 ret = l->rx.proto->rx_suspend(&l->rx);
340 return ret > 0 ? ret : 0;
341}
342
343
344/* Tries to resume a suspended listener, and returns non-zero on success or
345 * zero on failure. On certain errors, an alert or a warning might be displayed.
346 * It must be called with the listener's lock held. Depending on the listener's
347 * state and protocol, a listen() call might be used to resume operations, or a
348 * call to the receiver's resume() function might be used as well. This is
349 * suitable as a default function for TCP and UDP. This must be called with the
350 * listener's lock held.
351 */
352int default_resume_listener(struct listener *l)
353{
354 int ret = 1;
355
356 if (l->state == LI_ASSIGNED) {
357 char msg[100];
358 int err;
359
360 err = l->rx.proto->listen(l, msg, sizeof(msg));
361 if (err & ERR_ALERT)
362 ha_alert("Resuming listener: %s\n", msg);
363 else if (err & ERR_WARN)
364 ha_warning("Resuming listener: %s\n", msg);
365
366 if (err & (ERR_FATAL | ERR_ABORT)) {
367 ret = 0;
368 goto end;
369 }
370 }
371
372 if (l->state < LI_PAUSED) {
373 ret = 0;
374 goto end;
375 }
376
377 if (l->state == LI_PAUSED && l->rx.proto->rx_resume &&
378 l->rx.proto->rx_resume(&l->rx) <= 0)
379 ret = 0;
380 end:
381 return ret;
382}
383
384
Willy Tarreaube58c382011-07-24 18:28:10 +0200385/* This function tries to temporarily disable a listener, depending on the OS
386 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
387 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
388 * closes upon SHUT_WR and refuses to rebind. So a common validation path
389 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
390 * is disabled. It normally returns non-zero, unless an error is reported.
391 */
392int pause_listener(struct listener *l)
393{
Willy Tarreau58651b42020-09-24 16:03:29 +0200394 struct proxy *px = l->bind_conf->frontend;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200395 int ret = 1;
396
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100397 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200398
Willy Tarreau02e19752020-09-23 17:17:22 +0200399 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
400 !(proc_mask(l->rx.settings->bind_proc) & pid_bit))
401 goto end;
402
Willy Tarreau9b3a9322020-09-24 14:46:34 +0200403 if (l->state <= LI_PAUSED)
404 goto end;
405
Willy Tarreaue03204c2020-10-09 17:02:21 +0200406 if (l->rx.proto->suspend)
407 ret = l->rx.proto->suspend(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200408
Olivier Houchard859dc802019-08-08 15:47:21 +0200409 MT_LIST_DEL(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200410
Willy Tarreaua37b2442020-09-24 07:23:45 +0200411 listener_set_state(l, LI_PAUSED);
Willy Tarreau58651b42020-09-24 16:03:29 +0200412
413 if (px && !px->li_ready) {
414 ha_warning("Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
415 send_log(px, LOG_WARNING, "Paused %s %s.\n", proxy_cap_str(px->cap), px->id);
416 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200417 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100418 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200419 return ret;
Willy Tarreaube58c382011-07-24 18:28:10 +0200420}
421
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200422/* This function tries to resume a temporarily disabled listener. Paused, full,
423 * limited and disabled listeners are handled, which means that this function
424 * may replace enable_listener(). The resulting state will either be LI_READY
425 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200426 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200427 * foreground mode, and are ignored. If the listener was only in the assigned
428 * state, it's totally rebound. This can happen if a pause() has completely
429 * stopped it. If the resume fails, 0 is returned and an error might be
430 * displayed.
Willy Tarreaube58c382011-07-24 18:28:10 +0200431 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100432int resume_listener(struct listener *l)
Willy Tarreaube58c382011-07-24 18:28:10 +0200433{
Willy Tarreau58651b42020-09-24 16:03:29 +0200434 struct proxy *px = l->bind_conf->frontend;
435 int was_paused = px && px->li_paused;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200436 int ret = 1;
437
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100438 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200439
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200440 /* check that another thread didn't to the job in parallel (e.g. at the
441 * end of listen_accept() while we'd come from dequeue_all_listeners().
442 */
Olivier Houchard859dc802019-08-08 15:47:21 +0200443 if (MT_LIST_ADDED(&l->wait_queue))
Willy Tarreauf2cb1692019-07-11 10:08:31 +0200444 goto end;
445
William Lallemand095ba4c2017-06-01 17:38:50 +0200446 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau818a92e2020-09-03 07:50:19 +0200447 !(proc_mask(l->rx.settings->bind_proc) & pid_bit))
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200448 goto end;
Willy Tarreau3569df32017-03-15 12:47:46 +0100449
Willy Tarreau5d7f9ce2020-09-24 18:54:11 +0200450 if (l->state == LI_READY)
451 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200452
Willy Tarreaue03204c2020-10-09 17:02:21 +0200453 if (l->rx.proto->resume)
454 ret = l->rx.proto->resume(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200455
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100456 if (l->maxconn && l->nbconn >= l->maxconn) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200457 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200458 listener_set_state(l, LI_FULL);
Willy Tarreau58651b42020-09-24 16:03:29 +0200459 goto done;
Willy Tarreaube58c382011-07-24 18:28:10 +0200460 }
461
Willy Tarreau4b51f422020-09-25 20:32:28 +0200462 l->rx.proto->enable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200463 listener_set_state(l, LI_READY);
Willy Tarreau58651b42020-09-24 16:03:29 +0200464
465 done:
466 if (was_paused && !px->li_paused) {
467 ha_warning("Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
468 send_log(px, LOG_WARNING, "Resumed %s %s.\n", proxy_cap_str(px->cap), px->id);
469 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200470 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100471 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200472 return ret;
473}
474
Willy Tarreau87b09662015-04-03 00:22:06 +0200475/* Marks a ready listener as full so that the stream code tries to re-enable
Willy Tarreau62793712011-07-24 19:23:38 +0200476 * it upon next close() using resume_listener().
477 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200478static void listener_full(struct listener *l)
Willy Tarreau62793712011-07-24 19:23:38 +0200479{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100480 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200481 if (l->state >= LI_READY) {
Olivier Houchard859dc802019-08-08 15:47:21 +0200482 MT_LIST_DEL(&l->wait_queue);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100483 if (l->state != LI_FULL) {
Willy Tarreau4b51f422020-09-25 20:32:28 +0200484 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200485 listener_set_state(l, LI_FULL);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100486 }
Willy Tarreau62793712011-07-24 19:23:38 +0200487 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100488 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200489}
490
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200491/* Marks a ready listener as limited so that we only try to re-enable it when
492 * resources are free again. It will be queued into the specified queue.
493 */
Olivier Houchard859dc802019-08-08 15:47:21 +0200494static void limit_listener(struct listener *l, struct mt_list *list)
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200495{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100496 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200497 if (l->state == LI_READY) {
Willy Tarreaude4db172020-07-10 08:10:29 +0200498 MT_LIST_TRY_ADDQ(list, &l->wait_queue);
Willy Tarreau4b51f422020-09-25 20:32:28 +0200499 l->rx.proto->disable(l);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200500 listener_set_state(l, LI_LIMITED);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200501 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100502 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200503}
504
Willy Tarreau241797a2019-12-10 14:10:52 +0100505/* Dequeues all listeners waiting for a resource the global wait queue */
506void dequeue_all_listeners()
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200507{
Willy Tarreau01abd022019-02-28 10:27:18 +0100508 struct listener *listener;
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200509
Willy Tarreau241797a2019-12-10 14:10:52 +0100510 while ((listener = MT_LIST_POP(&global_listener_queue, struct listener *, wait_queue))) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200511 /* This cannot fail because the listeners are by definition in
Willy Tarreau01abd022019-02-28 10:27:18 +0100512 * the LI_LIMITED state.
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200513 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100514 resume_listener(listener);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200515 }
516}
517
Willy Tarreau241797a2019-12-10 14:10:52 +0100518/* Dequeues all listeners waiting for a resource in proxy <px>'s queue */
519void dequeue_proxy_listeners(struct proxy *px)
520{
521 struct listener *listener;
522
523 while ((listener = MT_LIST_POP(&px->listener_queue, struct listener *, wait_queue))) {
524 /* This cannot fail because the listeners are by definition in
525 * the LI_LIMITED state.
526 */
527 resume_listener(listener);
528 }
529}
530
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200531
532/* default function used to unbind a listener. This is for use by standard
533 * protocols working on top of accepted sockets. The receiver's rx_unbind()
534 * will automatically be used after the listener is disabled if the socket is
535 * still bound. This must be used under the listener's lock.
Christopher Faulet510c0d62018-03-16 10:04:47 +0100536 */
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200537void default_unbind_listener(struct listener *listener)
Willy Tarreaub648d632007-10-28 22:13:50 +0100538{
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200539 if (listener->state <= LI_ASSIGNED)
540 goto out_close;
541
542 if (listener->rx.fd == -1) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200543 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200544 goto out_close;
545 }
546
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200547 if (listener->state >= LI_READY) {
548 listener->rx.proto->disable(listener);
549 if (listener->rx.flags & RX_F_BOUND)
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200550 listener_set_state(listener, LI_LISTEN);
Willy Tarreaub6607bf2020-09-23 16:24:23 +0200551 }
552
Willy Tarreau87acd4e2020-10-08 15:36:46 +0200553 out_close:
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200554 if (listener->rx.flags & RX_F_BOUND)
555 listener->rx.proto->rx_unbind(&listener->rx);
Willy Tarreau7b2febd2020-10-09 17:18:29 +0200556}
557
558/* This function closes the listening socket for the specified listener,
559 * provided that it's already in a listening state. The protocol's unbind()
560 * is called to put the listener into LI_ASSIGNED or LI_LISTEN and handle
561 * the unbinding tasks. The listener enters then the LI_ASSIGNED state if
562 * the receiver is unbound. Must be called with the lock held.
563 */
564void do_unbind_listener(struct listener *listener)
565{
566 MT_LIST_DEL(&listener->wait_queue);
567
568 if (listener->rx.proto->unbind)
569 listener->rx.proto->unbind(listener);
Willy Tarreau374e9af2020-10-09 15:47:17 +0200570
Willy Tarreauf58b8db2020-10-09 16:32:08 +0200571 /* we may have to downgrade the listener if the rx was closed */
572 if (!(listener->rx.flags & RX_F_BOUND) && listener->state > LI_ASSIGNED)
Willy Tarreau374e9af2020-10-09 15:47:17 +0200573 listener_set_state(listener, LI_ASSIGNED);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100574}
575
Olivier Houchard1fc05162017-04-06 01:05:05 +0200576/* This function closes the listening socket for the specified listener,
577 * provided that it's already in a listening state. The listener enters the
Willy Tarreau75c98d12020-10-09 15:55:23 +0200578 * LI_ASSIGNED state, except if the FD is not closed, in which case it may
579 * remain in LI_LISTEN. This function is intended to be used as a generic
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100580 * function for standard protocols.
Olivier Houchard1fc05162017-04-06 01:05:05 +0200581 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100582void unbind_listener(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200583{
Christopher Faulet510c0d62018-03-16 10:04:47 +0100584 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau75c98d12020-10-09 15:55:23 +0200585 do_unbind_listener(listener);
Christopher Faulet510c0d62018-03-16 10:04:47 +0100586 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200587}
588
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200589/* creates one or multiple listeners for bind_conf <bc> on sockaddr <ss> on port
590 * range <portl> to <porth>, and possibly attached to fd <fd> (or -1 for auto
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200591 * allocation). The address family is taken from ss->ss_family, and the protocol
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200592 * passed in <proto> must be usable on this family. The protocol's default iocb
593 * is automatically preset as the receivers' iocb. The number of jobs and
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200594 * listeners is automatically increased by the number of listeners created. It
595 * returns non-zero on success, zero on error with the error message set in <err>.
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200596 */
597int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
Willy Tarreau9b3178d2020-09-16 17:58:55 +0200598 int portl, int porth, int fd, struct protocol *proto, char **err)
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200599{
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200600 struct listener *l;
601 int port;
602
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200603 for (port = portl; port <= porth; port++) {
604 l = calloc(1, sizeof(*l));
605 if (!l) {
606 memprintf(err, "out of memory");
607 return 0;
608 }
609 l->obj_type = OBJ_TYPE_LISTENER;
610 LIST_ADDQ(&bc->frontend->conf.listeners, &l->by_fe);
611 LIST_ADDQ(&bc->listeners, &l->by_bind);
612 l->bind_conf = bc;
Willy Tarreau0fce6bc2020-09-03 07:46:06 +0200613 l->rx.settings = &bc->settings;
Willy Tarreaueef45422020-09-03 10:05:03 +0200614 l->rx.owner = l;
Willy Tarreaud2fb99f2020-10-15 21:22:29 +0200615 l->rx.iocb = proto->default_iocb;
Willy Tarreau38ba6472020-08-27 08:16:52 +0200616 l->rx.fd = fd;
Willy Tarreau37159062020-08-27 07:48:42 +0200617 memcpy(&l->rx.addr, ss, sizeof(*ss));
Olivier Houchard859dc802019-08-08 15:47:21 +0200618 MT_LIST_INIT(&l->wait_queue);
Willy Tarreaua37b2442020-09-24 07:23:45 +0200619 listener_set_state(l, LI_INIT);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200620
621 proto->add(l, port);
622
Willy Tarreau909c23b2020-09-15 13:50:58 +0200623 if (fd != -1)
Willy Tarreau43046fa2020-09-01 15:41:59 +0200624 l->rx.flags |= RX_F_INHERITED;
William Lallemand75ea0a02017-11-15 19:02:58 +0100625
Amaury Denoyelle7f8f6cb2020-11-10 14:24:31 +0100626 l->extra_counters = NULL;
627
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100628 HA_SPIN_INIT(&l->lock);
Olivier Houchard64213e92019-03-08 18:52:57 +0100629 _HA_ATOMIC_ADD(&jobs, 1);
630 _HA_ATOMIC_ADD(&listeners, 1);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200631 }
632 return 1;
633}
634
Willy Tarreau1a64d162007-10-28 22:26:05 +0100635/* Delete a listener from its protocol's list of listeners. The listener's
636 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
Willy Tarreau2cc5bae2017-09-15 08:18:11 +0200637 * number of listeners is updated, as well as the global number of listeners
638 * and jobs. Note that the listener must have previously been unbound. This
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200639 * is a low-level function expected to be called with the proto_lock and the
640 * listener's lock held.
Willy Tarreau1a64d162007-10-28 22:26:05 +0100641 */
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200642void __delete_listener(struct listener *listener)
Willy Tarreau1a64d162007-10-28 22:26:05 +0100643{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100644 if (listener->state == LI_ASSIGNED) {
Willy Tarreaua37b2442020-09-24 07:23:45 +0200645 listener_set_state(listener, LI_INIT);
Willy Tarreaub7436612020-08-28 19:51:44 +0200646 LIST_DEL(&listener->rx.proto_list);
Willy Tarreaud7f331c2020-09-25 17:01:43 +0200647 listener->rx.proto->nb_receivers--;
Olivier Houchard64213e92019-03-08 18:52:57 +0100648 _HA_ATOMIC_SUB(&jobs, 1);
649 _HA_ATOMIC_SUB(&listeners, 1);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100650 }
Willy Tarreaub4c083f2020-10-07 15:36:16 +0200651}
652
653/* Delete a listener from its protocol's list of listeners (please check
654 * __delete_listener() above). The proto_lock and the listener's lock will
655 * be grabbed in this order.
656 */
657void delete_listener(struct listener *listener)
658{
659 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
660 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
661 __delete_listener(listener);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100662 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau6ee9f8d2019-08-26 10:55:52 +0200663 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau1a64d162007-10-28 22:26:05 +0100664}
665
Willy Tarreaue2711c72019-02-27 15:39:41 +0100666/* Returns a suitable value for a listener's backlog. It uses the listener's,
667 * otherwise the frontend's backlog, otherwise the listener's maxconn,
668 * otherwise the frontend's maxconn, otherwise 1024.
669 */
670int listener_backlog(const struct listener *l)
671{
672 if (l->backlog)
673 return l->backlog;
674
675 if (l->bind_conf->frontend->backlog)
676 return l->bind_conf->frontend->backlog;
677
678 if (l->maxconn)
679 return l->maxconn;
680
681 if (l->bind_conf->frontend->maxconn)
682 return l->bind_conf->frontend->maxconn;
683
684 return 1024;
685}
686
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200687/* This function is called on a read event from a listening socket, corresponding
688 * to an accept. It tries to accept as many connections as possible, and for each
689 * calls the listener's accept handler (generally the frontend's accept handler).
690 */
Willy Tarreaua74cb382020-10-15 21:29:49 +0200691void listener_accept(struct listener *l)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200692{
Willy Tarreau83efc322020-10-14 17:37:17 +0200693 struct connection *cli_conn;
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100694 struct proxy *p;
Christopher Faulet102854c2019-04-30 12:17:13 +0200695 unsigned int max_accept;
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100696 int next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100697 int next_feconn = 0;
698 int next_actconn = 0;
Willy Tarreaubb660302014-05-07 19:47:02 +0200699 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200700 int ret;
701
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100702 p = l->bind_conf->frontend;
Christopher Faulet102854c2019-04-30 12:17:13 +0200703
704 /* if l->maxaccept is -1, then max_accept is UINT_MAX. It is not really
705 * illimited, but it is probably enough.
706 */
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100707 max_accept = l->maxaccept ? l->maxaccept : 1;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200708
Willy Tarreau93e7c002013-10-07 18:51:07 +0200709 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
710 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200711
712 if (unlikely(!max)) {
713 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200714 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100715 goto limit_global;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200716 }
717
718 if (max_accept > max)
719 max_accept = max;
720 }
721
722 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200723 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
724
725 if (unlikely(!max)) {
726 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200727 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100728 goto limit_global;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200729 }
730
731 if (max_accept > max)
732 max_accept = max;
733 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200734#ifdef USE_OPENSSL
735 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim && l->bind_conf && l->bind_conf->is_ssl) {
736 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200737
Willy Tarreaue43d5322013-10-07 20:01:52 +0200738 if (unlikely(!max)) {
739 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200740 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreau0591bf72019-12-10 12:01:21 +0100741 goto limit_global;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200742 }
743
744 if (max_accept > max)
745 max_accept = max;
746 }
747#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200748 if (p && p->fe_sps_lim) {
749 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
750
751 if (unlikely(!max)) {
752 /* frontend accept rate limit was reached */
Willy Tarreau0591bf72019-12-10 12:01:21 +0100753 expire = tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0));
754 goto limit_proxy;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200755 }
756
757 if (max_accept > max)
758 max_accept = max;
759 }
760
761 /* Note: if we fail to allocate a connection because of configured
762 * limits, we'll schedule a new attempt worst 1 second later in the
763 * worst case. If we fail due to system limits or temporary resource
764 * shortage, we try again 100ms later in the worst case.
765 */
Christopher Faulet102854c2019-04-30 12:17:13 +0200766 for (; max_accept; next_conn = next_feconn = next_actconn = 0, max_accept--) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200767 unsigned int count;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200768 int status;
Willy Tarreau0aa5a5b2020-10-16 17:43:04 +0200769 __decl_thread(unsigned long mask);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200770
Willy Tarreau82c97892019-02-27 19:32:32 +0100771 /* pre-increase the number of connections without going too far.
772 * We process the listener, then the proxy, then the process.
773 * We know which ones to unroll based on the next_xxx value.
774 */
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100775 do {
776 count = l->nbconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100777 if (unlikely(l->maxconn && count >= l->maxconn)) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100778 /* the listener was marked full or another
779 * thread is going to do it.
780 */
781 next_conn = 0;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100782 listener_full(l);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100783 goto end;
784 }
785 next_conn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000786 } while (!_HA_ATOMIC_CAS(&l->nbconn, (int *)(&count), next_conn));
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100787
Willy Tarreau82c97892019-02-27 19:32:32 +0100788 if (p) {
789 do {
790 count = p->feconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100791 if (unlikely(count >= p->maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100792 /* the frontend was marked full or another
793 * thread is going to do it.
794 */
795 next_feconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100796 expire = TICK_ETERNITY;
797 goto limit_proxy;
Willy Tarreau82c97892019-02-27 19:32:32 +0100798 }
799 next_feconn = count + 1;
Olivier Houchard64213e92019-03-08 18:52:57 +0100800 } while (!_HA_ATOMIC_CAS(&p->feconn, &count, next_feconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200801 }
802
Willy Tarreau82c97892019-02-27 19:32:32 +0100803 if (!(l->options & LI_O_UNLIMITED)) {
804 do {
805 count = actconn;
Willy Tarreau93604ed2019-11-15 10:20:07 +0100806 if (unlikely(count >= global.maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100807 /* the process was marked full or another
808 * thread is going to do it.
809 */
810 next_actconn = 0;
Willy Tarreau0591bf72019-12-10 12:01:21 +0100811 expire = tick_add(now_ms, 1000); /* try again in 1 second */
812 goto limit_global;
Willy Tarreau82c97892019-02-27 19:32:32 +0100813 }
814 next_actconn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000815 } while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200816 }
817
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200818 cli_conn = l->rx.proto->accept_conn(l, &status);
819 if (!cli_conn) {
820 switch (status) {
821 case CO_AC_DONE:
822 goto end;
Willy Tarreau818dca52014-01-31 19:40:19 +0100823
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200824 case CO_AC_RETRY: /* likely a signal */
Olivier Houchard64213e92019-03-08 18:52:57 +0100825 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100826 if (p)
Olivier Houchard64213e92019-03-08 18:52:57 +0100827 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100828 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +0100829 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreaua593ec52014-01-20 21:21:30 +0100830 continue;
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200831
832 case CO_AC_YIELD:
Willy Tarreau92079932019-12-10 09:30:05 +0100833 max_accept = 0;
834 goto end;
William Lallemandd9138002018-11-27 12:02:39 +0100835
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200836 default:
837 goto transient_error;
Willy Tarreau83efc322020-10-14 17:37:17 +0200838 }
839 }
840
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100841 /* The connection was accepted, it must be counted as such */
842 if (l->counters)
843 HA_ATOMIC_UPDATE_MAX(&l->counters->conn_max, next_conn);
844
Willy Tarreau82c97892019-02-27 19:32:32 +0100845 if (p)
846 HA_ATOMIC_UPDATE_MAX(&p->fe_counters.conn_max, next_feconn);
847
848 proxy_inc_fe_conn_ctr(l, p);
849
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100850 if (!(l->options & LI_O_UNLIMITED)) {
851 count = update_freq_ctr(&global.conn_per_sec, 1);
852 HA_ATOMIC_UPDATE_MAX(&global.cps_max, count);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100853 }
854
Willy Tarreau64a9c052019-04-12 15:27:17 +0200855 _HA_ATOMIC_ADD(&activity[tid].accepted, 1);
856
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200857 if (unlikely(cli_conn->handle.fd >= global.maxsock)) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200858 send_log(p, LOG_EMERG,
859 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
860 p->id);
Willy Tarreau9378bbe2020-10-15 10:09:31 +0200861 close(cli_conn->handle.fd);
William Dauchy835712a2020-10-18 18:37:43 +0200862 conn_free(cli_conn);
Willy Tarreau0591bf72019-12-10 12:01:21 +0100863 expire = tick_add(now_ms, 1000); /* try again in 1 second */
864 goto limit_global;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200865 }
866
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100867 /* past this point, l->accept() will automatically decrement
Willy Tarreau82c97892019-02-27 19:32:32 +0100868 * l->nbconn, feconn and actconn once done. Setting next_*conn=0
869 * allows the error path not to rollback on nbconn. It's more
870 * convenient than duplicating all exit labels.
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100871 */
872 next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100873 next_feconn = 0;
874 next_actconn = 0;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200875
Willy Tarreau83efc322020-10-14 17:37:17 +0200876
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100877#if defined(USE_THREAD)
Willy Tarreau818a92e2020-09-03 07:50:19 +0200878 mask = thread_mask(l->rx.settings->bind_thread) & all_threads_mask;
Willy Tarreaua7da5e82020-03-12 17:33:29 +0100879 if (atleast2(mask) && (global.tune.options & GTUNE_LISTENER_MQ) && !stopping) {
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100880 struct accept_queue_ring *ring;
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100881 unsigned int t, t0, t1, t2;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100882
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100883 /* The principle is that we have two running indexes,
884 * each visiting in turn all threads bound to this
885 * listener. The connection will be assigned to the one
886 * with the least connections, and the other one will
887 * be updated. This provides a good fairness on short
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100888 * connections (round robin) and on long ones (conn
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100889 * count), without ever missing any idle thread.
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100890 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100891
892 /* keep a copy for the final update. thr_idx is composite
893 * and made of (t2<<16) + t1.
894 */
Willy Tarreau0cf33172019-03-06 15:26:33 +0100895 t0 = l->thr_idx;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100896 do {
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100897 unsigned long m1, m2;
898 int q1, q2;
899
900 t2 = t1 = t0;
901 t2 >>= 16;
902 t1 &= 0xFFFF;
903
904 /* t1 walks low to high bits ;
905 * t2 walks high to low.
906 */
907 m1 = mask >> t1;
908 m2 = mask & (t2 ? nbits(t2 + 1) : ~0UL);
909
Willy Tarreau85d04242019-04-16 18:09:13 +0200910 if (unlikely(!(m1 & 1))) {
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100911 m1 &= ~1UL;
912 if (!m1) {
913 m1 = mask;
914 t1 = 0;
915 }
916 t1 += my_ffsl(m1) - 1;
917 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100918
Willy Tarreau85d04242019-04-16 18:09:13 +0200919 if (unlikely(!(m2 & (1UL << t2)) || t1 == t2)) {
920 /* highest bit not set */
921 if (!m2)
922 m2 = mask;
923
924 t2 = my_flsl(m2) - 1;
925 }
926
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100927 /* now we have two distinct thread IDs belonging to the mask */
928 q1 = accept_queue_rings[t1].tail - accept_queue_rings[t1].head + ACCEPT_QUEUE_SIZE;
929 if (q1 >= ACCEPT_QUEUE_SIZE)
930 q1 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100931
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100932 q2 = accept_queue_rings[t2].tail - accept_queue_rings[t2].head + ACCEPT_QUEUE_SIZE;
933 if (q2 >= ACCEPT_QUEUE_SIZE)
934 q2 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100935
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100936 /* we have 3 possibilities now :
937 * q1 < q2 : t1 is less loaded than t2, so we pick it
938 * and update t2 (since t1 might still be
939 * lower than another thread)
940 * q1 > q2 : t2 is less loaded than t1, so we pick it
941 * and update t1 (since t2 might still be
942 * lower than another thread)
943 * q1 = q2 : both are equally loaded, thus we pick t1
944 * and update t1 as it will become more loaded
945 * than t2.
946 */
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100947
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100948 q1 += l->thr_conn[t1];
949 q2 += l->thr_conn[t2];
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100950
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100951 if (q1 - q2 < 0) {
952 t = t1;
953 t2 = t2 ? t2 - 1 : LONGBITS - 1;
954 }
955 else if (q1 - q2 > 0) {
956 t = t2;
957 t1++;
958 if (t1 >= LONGBITS)
959 t1 = 0;
960 }
961 else {
962 t = t1;
963 t1++;
964 if (t1 >= LONGBITS)
965 t1 = 0;
966 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100967
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100968 /* new value for thr_idx */
969 t1 += (t2 << 16);
Olivier Houchard64213e92019-03-08 18:52:57 +0100970 } while (unlikely(!_HA_ATOMIC_CAS(&l->thr_idx, &t0, t1)));
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100971
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100972 /* We successfully selected the best thread "t" for this
973 * connection. We use deferred accepts even if it's the
974 * local thread because tests show that it's the best
975 * performing model, likely due to better cache locality
976 * when processing this loop.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100977 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100978 ring = &accept_queue_rings[t];
Willy Tarreau83efc322020-10-14 17:37:17 +0200979 if (accept_queue_push_mp(ring, cli_conn)) {
Olivier Houchard64213e92019-03-08 18:52:57 +0100980 _HA_ATOMIC_ADD(&activity[t].accq_pushed, 1);
Willy Tarreau2bd65a72019-09-24 06:55:18 +0200981 tasklet_wakeup(ring->tasklet);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100982 continue;
983 }
984 /* If the ring is full we do a synchronous accept on
985 * the local thread here.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100986 */
Olivier Houchard64213e92019-03-08 18:52:57 +0100987 _HA_ATOMIC_ADD(&activity[t].accq_full, 1);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100988 }
989#endif // USE_THREAD
990
Olivier Houchard64213e92019-03-08 18:52:57 +0100991 _HA_ATOMIC_ADD(&l->thr_conn[tid], 1);
Willy Tarreau83efc322020-10-14 17:37:17 +0200992 ret = l->accept(cli_conn);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200993 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +0200994 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200995 * we just have to ignore it (ret == 0) or it's a critical
996 * error due to a resource shortage, and we must stop the
997 * listener (ret < 0).
998 */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200999 if (ret == 0) /* successful termination */
1000 continue;
1001
Willy Tarreaubb660302014-05-07 19:47:02 +02001002 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001003 }
1004
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001005 /* increase the per-process number of cumulated sessions, this
1006 * may only be done once l->accept() has accepted the connection.
1007 */
Willy Tarreau93e7c002013-10-07 18:51:07 +02001008 if (!(l->options & LI_O_UNLIMITED)) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001009 count = update_freq_ctr(&global.sess_per_sec, 1);
1010 HA_ATOMIC_UPDATE_MAX(&global.sps_max, count);
Willy Tarreau93e7c002013-10-07 18:51:07 +02001011 }
Willy Tarreaue43d5322013-10-07 20:01:52 +02001012#ifdef USE_OPENSSL
1013 if (!(l->options & LI_O_UNLIMITED) && l->bind_conf && l->bind_conf->is_ssl) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001014 count = update_freq_ctr(&global.ssl_per_sec, 1);
1015 HA_ATOMIC_UPDATE_MAX(&global.ssl_max, count);
Willy Tarreaue43d5322013-10-07 20:01:52 +02001016 }
1017#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +02001018
Willy Tarreau8d2c98b2020-05-01 09:51:11 +02001019 ti->flags &= ~TI_FL_STUCK; // this thread is still running
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001020 } /* end of for (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001021
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001022 end:
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001023 if (next_conn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001024 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau741b4d62019-02-25 15:02:04 +01001025
Willy Tarreau82c97892019-02-27 19:32:32 +01001026 if (p && next_feconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001027 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001028
1029 if (next_actconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001030 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001031
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001032 if ((l->state == LI_FULL && (!l->maxconn || l->nbconn < l->maxconn)) ||
Willy Tarreaucdcba112019-12-11 15:06:30 +01001033 (l->state == LI_LIMITED &&
1034 ((!p || p->feconn < p->maxconn) && (actconn < global.maxconn) &&
1035 (!tick_isset(global_listener_queue_task->expire) ||
1036 tick_is_expired(global_listener_queue_task->expire, now_ms))))) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001037 /* at least one thread has to this when quitting */
1038 resume_listener(l);
1039
1040 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001041 dequeue_all_listeners();
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001042
Olivier Houchard859dc802019-08-08 15:47:21 +02001043 if (p && !MT_LIST_ISEMPTY(&p->listener_queue) &&
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001044 (!p->fe_sps_lim || freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0) > 0))
Willy Tarreau241797a2019-12-10 14:10:52 +01001045 dequeue_proxy_listeners(p);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001046 }
Willy Tarreau0591bf72019-12-10 12:01:21 +01001047 return;
1048
1049 transient_error:
1050 /* pause the listener for up to 100 ms */
1051 expire = tick_add(now_ms, 100);
1052
Willy Tarreau258b3512020-10-13 17:46:05 +02001053 /* This may be a shared socket that was paused by another process.
1054 * Let's put it to pause in this case.
1055 */
1056 if (l->rx.proto && l->rx.proto->rx_listening(&l->rx) == 0) {
1057 pause_listener(l);
1058 goto end;
1059 }
1060
Willy Tarreau0591bf72019-12-10 12:01:21 +01001061 limit_global:
1062 /* (re-)queue the listener to the global queue and set it to expire no
1063 * later than <expire> ahead. The listener turns to LI_LIMITED.
1064 */
1065 limit_listener(l, &global_listener_queue);
1066 task_schedule(global_listener_queue_task, expire);
1067 goto end;
1068
1069 limit_proxy:
1070 /* (re-)queue the listener to the proxy's queue and set it to expire no
1071 * later than <expire> ahead. The listener turns to LI_LIMITED.
1072 */
1073 limit_listener(l, &p->listener_queue);
Willy Tarreaueeea8082020-01-08 19:15:07 +01001074 if (p->task && tick_isset(expire))
1075 task_schedule(p->task, expire);
Willy Tarreau0591bf72019-12-10 12:01:21 +01001076 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001077}
1078
Willy Tarreau05f50472017-09-15 09:19:58 +02001079/* Notify the listener that a connection initiated from it was released. This
1080 * is used to keep the connection count consistent and to possibly re-open
1081 * listening when it was limited.
1082 */
1083void listener_release(struct listener *l)
1084{
1085 struct proxy *fe = l->bind_conf->frontend;
1086
1087 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +01001088 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001089 if (fe)
Olivier Houchard64213e92019-03-08 18:52:57 +01001090 _HA_ATOMIC_SUB(&fe->feconn, 1);
1091 _HA_ATOMIC_SUB(&l->nbconn, 1);
1092 _HA_ATOMIC_SUB(&l->thr_conn[tid], 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001093
1094 if (l->state == LI_FULL || l->state == LI_LIMITED)
Willy Tarreau05f50472017-09-15 09:19:58 +02001095 resume_listener(l);
1096
1097 /* Dequeues all of the listeners waiting for a resource */
Willy Tarreau241797a2019-12-10 14:10:52 +01001098 dequeue_all_listeners();
Willy Tarreau05f50472017-09-15 09:19:58 +02001099
Olivier Houchard859dc802019-08-08 15:47:21 +02001100 if (!MT_LIST_ISEMPTY(&fe->listener_queue) &&
Willy Tarreau05f50472017-09-15 09:19:58 +02001101 (!fe->fe_sps_lim || freq_ctr_remain(&fe->fe_sess_per_sec, fe->fe_sps_lim, 0) > 0))
Willy Tarreau241797a2019-12-10 14:10:52 +01001102 dequeue_proxy_listeners(fe);
Willy Tarreau05f50472017-09-15 09:19:58 +02001103}
1104
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001105/* Initializes the listener queues. Returns 0 on success, otherwise ERR_* flags */
1106static int listener_queue_init()
1107{
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001108 global_listener_queue_task = task_new(MAX_THREADS_MASK);
1109 if (!global_listener_queue_task) {
1110 ha_alert("Out of memory when initializing global listener queue\n");
1111 return ERR_FATAL|ERR_ABORT;
1112 }
1113 /* very simple initialization, users will queue the task if needed */
1114 global_listener_queue_task->context = NULL; /* not even a context! */
1115 global_listener_queue_task->process = manage_global_listener_queue;
1116
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001117 return 0;
1118}
1119
1120static void listener_queue_deinit()
1121{
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001122 task_destroy(global_listener_queue_task);
1123 global_listener_queue_task = NULL;
Willy Tarreauf2cb1692019-07-11 10:08:31 +02001124}
1125
1126REGISTER_CONFIG_POSTPARSER("multi-threaded listener queue", listener_queue_init);
1127REGISTER_POST_DEINIT(listener_queue_deinit);
1128
Willy Tarreaua1d97f82019-12-10 11:18:41 +01001129
1130/* This is the global management task for listeners. It enables listeners waiting
1131 * for global resources when there are enough free resource, or at least once in
1132 * a while. It is designed to be called as a task.
1133 */
1134static struct task *manage_global_listener_queue(struct task *t, void *context, unsigned short state)
1135{
1136 /* If there are still too many concurrent connections, let's wait for
1137 * some of them to go away. We don't need to re-arm the timer because
1138 * each of them will scan the queue anyway.
1139 */
1140 if (unlikely(actconn >= global.maxconn))
1141 goto out;
1142
1143 /* We should periodically try to enable listeners waiting for a global
1144 * resource here, because it is possible, though very unlikely, that
1145 * they have been blocked by a temporary lack of global resource such
1146 * as a file descriptor or memory and that the temporary condition has
1147 * disappeared.
1148 */
1149 dequeue_all_listeners();
1150
1151 out:
1152 t->expire = TICK_ETERNITY;
1153 task_queue(t);
1154 return t;
1155}
1156
Willy Tarreau26982662012-09-12 23:17:10 +02001157/*
1158 * Registers the bind keyword list <kwl> as a list of valid keywords for next
1159 * parsing sessions.
1160 */
1161void bind_register_keywords(struct bind_kw_list *kwl)
1162{
1163 LIST_ADDQ(&bind_keywords.list, &kwl->list);
1164}
1165
1166/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
1167 * keyword is found with a NULL ->parse() function, then an attempt is made to
1168 * find one with a valid ->parse() function. This way it is possible to declare
1169 * platform-dependant, known keywords as NULL, then only declare them as valid
1170 * if some options are met. Note that if the requested keyword contains an
1171 * opening parenthesis, everything from this point is ignored.
1172 */
1173struct bind_kw *bind_find_kw(const char *kw)
1174{
1175 int index;
1176 const char *kwend;
1177 struct bind_kw_list *kwl;
1178 struct bind_kw *ret = NULL;
1179
1180 kwend = strchr(kw, '(');
1181 if (!kwend)
1182 kwend = kw + strlen(kw);
1183
1184 list_for_each_entry(kwl, &bind_keywords.list, list) {
1185 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1186 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1187 kwl->kw[index].kw[kwend-kw] == 0) {
1188 if (kwl->kw[index].parse)
1189 return &kwl->kw[index]; /* found it !*/
1190 else
1191 ret = &kwl->kw[index]; /* may be OK */
1192 }
1193 }
1194 }
1195 return ret;
1196}
1197
Willy Tarreau8638f482012-09-18 18:01:17 +02001198/* Dumps all registered "bind" keywords to the <out> string pointer. The
1199 * unsupported keywords are only dumped if their supported form was not
1200 * found.
1201 */
1202void bind_dump_kws(char **out)
1203{
1204 struct bind_kw_list *kwl;
1205 int index;
1206
Christopher Faulet784063e2020-05-18 12:14:18 +02001207 if (!out)
1208 return;
1209
Willy Tarreau8638f482012-09-18 18:01:17 +02001210 *out = NULL;
1211 list_for_each_entry(kwl, &bind_keywords.list, list) {
1212 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1213 if (kwl->kw[index].parse ||
1214 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +02001215 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
1216 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +02001217 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +02001218 kwl->kw[index].skip ? " <arg>" : "",
1219 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +02001220 }
1221 }
1222 }
1223}
1224
Willy Tarreau645513a2010-05-24 20:55:15 +02001225/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001226/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +02001227/************************************************************************/
1228
Willy Tarreaua5e37562011-12-16 17:06:15 +01001229/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +02001230static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001231smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +02001232{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001233 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001234 smp->data.u.sint = smp->sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +02001235 return 1;
1236}
1237
Willy Tarreaua5e37562011-12-16 17:06:15 +01001238/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +02001239static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001240smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +02001241{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001242 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001243 smp->data.u.sint = smp->sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +02001244 return 1;
1245}
Jerome Magnineb421b22020-03-27 22:08:40 +01001246static int
1247smp_fetch_so_name(const struct arg *args, struct sample *smp, const char *kw, void *private)
1248{
1249 smp->data.u.str.area = smp->sess->listener->name;
1250 if (!smp->data.u.str.area)
1251 return 0;
1252
1253 smp->data.type = SMP_T_STR;
1254 smp->flags = SMP_F_CONST;
1255 smp->data.u.str.data = strlen(smp->data.u.str.area);
1256 return 1;
1257}
Willy Tarreau645513a2010-05-24 20:55:15 +02001258
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001259/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001260static int bind_parse_accept_proxy(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001261{
1262 struct listener *l;
1263
Willy Tarreau4348fad2012-09-20 16:48:07 +02001264 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001265 l->options |= LI_O_ACC_PROXY;
1266
1267 return 0;
1268}
1269
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001270/* parse the "accept-netscaler-cip" bind keyword */
1271static int bind_parse_accept_netscaler_cip(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1272{
1273 struct listener *l;
1274 uint32_t val;
1275
1276 if (!*args[cur_arg + 1]) {
1277 memprintf(err, "'%s' : missing value", args[cur_arg]);
1278 return ERR_ALERT | ERR_FATAL;
1279 }
1280
1281 val = atol(args[cur_arg + 1]);
1282 if (val <= 0) {
Willy Tarreaue2711c72019-02-27 15:39:41 +01001283 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001284 return ERR_ALERT | ERR_FATAL;
1285 }
1286
1287 list_for_each_entry(l, &conf->listeners, by_bind) {
1288 l->options |= LI_O_ACC_CIP;
1289 conf->ns_cip_magic = val;
1290 }
1291
1292 return 0;
1293}
1294
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001295/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001296static int bind_parse_backlog(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001297{
1298 struct listener *l;
1299 int val;
1300
1301 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001302 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001303 return ERR_ALERT | ERR_FATAL;
1304 }
1305
1306 val = atol(args[cur_arg + 1]);
Willy Tarreaue2711c72019-02-27 15:39:41 +01001307 if (val < 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001308 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001309 return ERR_ALERT | ERR_FATAL;
1310 }
1311
Willy Tarreau4348fad2012-09-20 16:48:07 +02001312 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001313 l->backlog = val;
1314
1315 return 0;
1316}
1317
1318/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001319static int bind_parse_id(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001320{
1321 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +02001322 struct listener *l, *new;
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001323 char *error;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001324
Willy Tarreau4348fad2012-09-20 16:48:07 +02001325 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001326 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001327 return ERR_ALERT | ERR_FATAL;
1328 }
1329
1330 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001331 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001332 return ERR_ALERT | ERR_FATAL;
1333 }
1334
Willy Tarreau4348fad2012-09-20 16:48:07 +02001335 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001336 new->luid = strtol(args[cur_arg + 1], &error, 10);
1337 if (*error != '\0') {
1338 memprintf(err, "'%s' : expects an integer argument, found '%s'", args[cur_arg], args[cur_arg + 1]);
1339 return ERR_ALERT | ERR_FATAL;
1340 }
Willy Tarreau4348fad2012-09-20 16:48:07 +02001341 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001342
Willy Tarreau4348fad2012-09-20 16:48:07 +02001343 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001344 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001345 return ERR_ALERT | ERR_FATAL;
1346 }
1347
Willy Tarreau4348fad2012-09-20 16:48:07 +02001348 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001349 if (node) {
1350 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001351 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
1352 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
1353 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001354 return ERR_ALERT | ERR_FATAL;
1355 }
1356
Willy Tarreau4348fad2012-09-20 16:48:07 +02001357 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001358 return 0;
1359}
1360
1361/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001362static int bind_parse_maxconn(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001363{
1364 struct listener *l;
1365 int val;
1366
1367 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001368 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001369 return ERR_ALERT | ERR_FATAL;
1370 }
1371
1372 val = atol(args[cur_arg + 1]);
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001373 if (val < 0) {
1374 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001375 return ERR_ALERT | ERR_FATAL;
1376 }
1377
Willy Tarreau4348fad2012-09-20 16:48:07 +02001378 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001379 l->maxconn = val;
1380
1381 return 0;
1382}
1383
1384/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001385static int bind_parse_name(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001386{
1387 struct listener *l;
1388
1389 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001390 memprintf(err, "'%s' : missing name", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001391 return ERR_ALERT | ERR_FATAL;
1392 }
1393
Willy Tarreau4348fad2012-09-20 16:48:07 +02001394 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001395 l->name = strdup(args[cur_arg + 1]);
1396
1397 return 0;
1398}
1399
1400/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001401static int bind_parse_nice(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001402{
1403 struct listener *l;
1404 int val;
1405
1406 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001407 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001408 return ERR_ALERT | ERR_FATAL;
1409 }
1410
1411 val = atol(args[cur_arg + 1]);
1412 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001413 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001414 return ERR_ALERT | ERR_FATAL;
1415 }
1416
Willy Tarreau4348fad2012-09-20 16:48:07 +02001417 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001418 l->nice = val;
1419
1420 return 0;
1421}
1422
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001423/* parse the "process" bind keyword */
1424static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1425{
Christopher Fauletc644fa92017-11-23 22:44:11 +01001426 char *slash;
1427 unsigned long proc = 0, thread = 0;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001428
Christopher Fauletc644fa92017-11-23 22:44:11 +01001429 if ((slash = strchr(args[cur_arg + 1], '/')) != NULL)
1430 *slash = 0;
1431
Willy Tarreauff9c9142019-02-07 10:39:36 +01001432 if (parse_process_number(args[cur_arg + 1], &proc, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +01001433 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001434 return ERR_ALERT | ERR_FATAL;
1435 }
1436
Christopher Fauletc644fa92017-11-23 22:44:11 +01001437 if (slash) {
Willy Tarreauc9a82e42019-01-26 13:25:14 +01001438 if (parse_process_number(slash+1, &thread, MAX_THREADS, NULL, err)) {
Christopher Fauletc644fa92017-11-23 22:44:11 +01001439 memprintf(err, "'%s' : %s", args[cur_arg], *err);
1440 return ERR_ALERT | ERR_FATAL;
1441 }
1442 *slash = '/';
1443 }
1444
Willy Tarreaue26993c2020-09-03 07:18:55 +02001445 conf->settings.bind_proc |= proc;
1446 conf->settings.bind_thread |= thread;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001447 return 0;
1448}
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001449
Christopher Fauleta717b992018-04-10 14:43:00 +02001450/* parse the "proto" bind keyword */
1451static int bind_parse_proto(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1452{
1453 struct ist proto;
1454
1455 if (!*args[cur_arg + 1]) {
1456 memprintf(err, "'%s' : missing value", args[cur_arg]);
1457 return ERR_ALERT | ERR_FATAL;
1458 }
1459
1460 proto = ist2(args[cur_arg + 1], strlen(args[cur_arg + 1]));
1461 conf->mux_proto = get_mux_proto(proto);
1462 if (!conf->mux_proto) {
1463 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[cur_arg], args[cur_arg+1]);
1464 return ERR_ALERT | ERR_FATAL;
1465 }
Christopher Fauleta717b992018-04-10 14:43:00 +02001466 return 0;
1467}
1468
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001469/* config parser for global "tune.listener.multi-queue", accepts "on" or "off" */
1470static int cfg_parse_tune_listener_mq(char **args, int section_type, struct proxy *curpx,
1471 struct proxy *defpx, const char *file, int line,
1472 char **err)
1473{
1474 if (too_many_args(1, args, err, NULL))
1475 return -1;
1476
1477 if (strcmp(args[1], "on") == 0)
1478 global.tune.options |= GTUNE_LISTENER_MQ;
1479 else if (strcmp(args[1], "off") == 0)
1480 global.tune.options &= ~GTUNE_LISTENER_MQ;
1481 else {
1482 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
1483 return -1;
1484 }
1485 return 0;
1486}
1487
Willy Tarreau61612d42012-04-19 18:42:05 +02001488/* Note: must not be declared <const> as its list will be overwritten.
1489 * Please take care of keeping this list alphabetically sorted.
1490 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001491static struct sample_fetch_kw_list smp_kws = {ILH, {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001492 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
1493 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
Jerome Magnineb421b22020-03-27 22:08:40 +01001494 { "so_name", smp_fetch_so_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001495 { /* END */ },
1496}};
1497
Willy Tarreau0108d902018-11-25 19:14:37 +01001498INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1499
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001500/* Note: must not be declared <const> as its list will be overwritten.
1501 * Please take care of keeping this list alphabetically sorted.
1502 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001503static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001504 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +02001505}};
1506
Willy Tarreau0108d902018-11-25 19:14:37 +01001507INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
1508
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001509/* Note: must not be declared <const> as its list will be overwritten.
1510 * Please take care of keeping this list alphabetically sorted, doing so helps
1511 * all code contributors.
1512 * Optional keywords are also declared with a NULL ->parse() function so that
1513 * the config parser can report an appropriate error when a known keyword was
1514 * not enabled.
1515 */
Willy Tarreau51fb7652012-09-18 18:24:39 +02001516static struct bind_kw_list bind_kws = { "ALL", { }, {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001517 { "accept-netscaler-cip", bind_parse_accept_netscaler_cip, 1 }, /* enable NetScaler Client IP insertion protocol */
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001518 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
1519 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
1520 { "id", bind_parse_id, 1 }, /* set id of listening socket */
1521 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
1522 { "name", bind_parse_name, 1 }, /* set name of listening socket */
1523 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001524 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Christopher Fauleta717b992018-04-10 14:43:00 +02001525 { "proto", bind_parse_proto, 1 }, /* set the proto to use for all incoming connections */
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001526 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001527}};
1528
Willy Tarreau0108d902018-11-25 19:14:37 +01001529INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
1530
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001531/* config keyword parsers */
1532static struct cfg_kw_list cfg_kws = {ILH, {
1533 { CFG_GLOBAL, "tune.listener.multi-queue", cfg_parse_tune_listener_mq },
1534 { 0, NULL, NULL }
1535}};
1536
1537INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1538
Willy Tarreau645513a2010-05-24 20:55:15 +02001539/*
1540 * Local variables:
1541 * c-indent-level: 8
1542 * c-basic-offset: 8
1543 * End:
1544 */