blob: b68eb8cebb24bebbf1ed0734f0f30650959b7c3a [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 Tarreau44489252014-01-14 17:52:01 +010013#define _GNU_SOURCE
Willy Tarreau6ae1ba62014-05-07 19:01:58 +020014#include <ctype.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020015#include <errno.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020016#include <stdio.h>
17#include <string.h>
Willy Tarreau95ccdde2014-02-01 09:28:36 +010018#include <unistd.h>
19#include <fcntl.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020020
Willy Tarreau1bc4aab2012-10-08 20:11:03 +020021#include <common/accept4.h>
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +010022#include <common/cfgparse.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020023#include <common/config.h>
Willy Tarreaudabf2e22007-10-28 21:59:24 +010024#include <common/errors.h>
Willy Tarreau0108d902018-11-25 19:14:37 +010025#include <common/initcall.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020026#include <common/mini-clist.h>
27#include <common/standard.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020028#include <common/time.h>
29
30#include <types/global.h>
Willy Tarreaud1d54542012-09-12 22:58:11 +020031#include <types/protocol.h>
Willy Tarreaudd815982007-10-16 12:25:14 +020032
Willy Tarreau645513a2010-05-24 20:55:15 +020033#include <proto/acl.h>
Christopher Fauleta717b992018-04-10 14:43:00 +020034#include <proto/connection.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010035#include <proto/fd.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020036#include <proto/freq_ctr.h>
37#include <proto/log.h>
Willy Tarreau7a798e52016-04-14 11:13:20 +020038#include <proto/listener.h>
Willy Tarreau0de59fd2017-09-15 08:10:44 +020039#include <proto/protocol.h>
William Lallemand2fe7dd02018-09-11 16:51:29 +020040#include <proto/proto_sockpair.h>
Willy Tarreau0ccb7442013-01-07 22:54:17 +010041#include <proto/sample.h>
Willy Tarreaufb0afa72015-04-03 14:46:27 +020042#include <proto/stream.h>
Willy Tarreaubbebbbf2012-05-07 21:22:09 +020043#include <proto/task.h>
Willy Tarreaub648d632007-10-28 22:13:50 +010044
Willy Tarreau26982662012-09-12 23:17:10 +020045/* List head of all known bind keywords */
46static struct bind_kw_list bind_keywords = {
47 .list = LIST_HEAD_INIT(bind_keywords.list)
48};
49
Olivier Houchardf73629d2017-04-05 22:33:04 +020050struct xfer_sock_list *xfer_sock_list = NULL;
51
Willy Tarreau413e9262019-07-11 10:08:31 +020052/* there is one listener queue per thread so that a thread unblocking the
53 * global queue can wake up listeners bound only to foreing threads by
54 * moving them to the remote queues and waking up the associated task.
55 */
56static struct work_list *local_listener_queue;
57
Willy Tarreau1efafce2019-01-27 15:37:19 +010058#if defined(USE_THREAD)
59
60struct accept_queue_ring accept_queue_rings[MAX_THREADS] __attribute__((aligned(64))) = { };
61
62/* dequeue and process a pending connection from the local accept queue (single
63 * consumer). Returns the accepted fd or -1 if none was found. The listener is
64 * placed into *li. The address is copied into *addr for no more than *addr_len
65 * bytes, and the address length is returned into *addr_len.
66 */
67int accept_queue_pop_sc(struct accept_queue_ring *ring, struct listener **li, void *addr, int *addr_len)
68{
69 struct accept_queue_entry *e;
70 unsigned int pos, next;
71 struct listener *ptr;
72 int len;
73 int fd;
74
75 pos = ring->head;
76
77 if (pos == ring->tail)
78 return -1;
79
80 next = pos + 1;
81 if (next >= ACCEPT_QUEUE_SIZE)
82 next = 0;
83
84 e = &ring->entry[pos];
85
86 /* wait for the producer to update the listener's pointer */
87 while (1) {
88 ptr = e->listener;
89 __ha_barrier_load();
90 if (ptr)
91 break;
92 pl_cpu_relax();
93 }
94
95 fd = e->fd;
96 len = e->addr_len;
97 if (len > *addr_len)
98 len = *addr_len;
99
100 if (likely(len > 0))
101 memcpy(addr, &e->addr, len);
102
103 /* release the entry */
104 e->listener = NULL;
105
106 __ha_barrier_store();
107 ring->head = next;
108
109 *addr_len = len;
110 *li = ptr;
111
112 return fd;
113}
114
115
116/* tries to push a new accepted connection <fd> into ring <ring> for listener
117 * <li>, from address <addr> whose length is <addr_len>. Returns non-zero if it
118 * succeeds, or zero if the ring is full. Supports multiple producers.
119 */
120int accept_queue_push_mp(struct accept_queue_ring *ring, int fd,
121 struct listener *li, const void *addr, int addr_len)
122{
123 struct accept_queue_entry *e;
124 unsigned int pos, next;
125
126 pos = ring->tail;
127 do {
128 next = pos + 1;
129 if (next >= ACCEPT_QUEUE_SIZE)
130 next = 0;
131 if (next == ring->head)
132 return 0; // ring full
Olivier Houchard64213e92019-03-08 18:52:57 +0100133 } while (unlikely(!_HA_ATOMIC_CAS(&ring->tail, &pos, next)));
Willy Tarreau1efafce2019-01-27 15:37:19 +0100134
135
136 e = &ring->entry[pos];
137
138 if (addr_len > sizeof(e->addr))
139 addr_len = sizeof(e->addr);
140
141 if (addr_len)
142 memcpy(&e->addr, addr, addr_len);
143
144 e->addr_len = addr_len;
145 e->fd = fd;
146
147 __ha_barrier_store();
148 /* now commit the change */
149
150 e->listener = li;
151 return 1;
152}
153
154/* proceed with accepting new connections */
155static struct task *accept_queue_process(struct task *t, void *context, unsigned short state)
156{
157 struct accept_queue_ring *ring = context;
158 struct listener *li;
159 struct sockaddr_storage addr;
Christopher Faulet102854c2019-04-30 12:17:13 +0200160 unsigned int max_accept;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100161 int addr_len;
162 int ret;
163 int fd;
164
Christopher Faulet102854c2019-04-30 12:17:13 +0200165 /* if global.tune.maxaccept is -1, then max_accept is UINT_MAX. It
166 * is not really illimited, but it is probably enough.
167 */
168 max_accept = global.tune.maxaccept ? global.tune.maxaccept : 64;
169 for (; max_accept; max_accept--) {
Willy Tarreau1efafce2019-01-27 15:37:19 +0100170 addr_len = sizeof(addr);
171 fd = accept_queue_pop_sc(ring, &li, &addr, &addr_len);
172 if (fd < 0)
173 break;
174
Olivier Houchard64213e92019-03-08 18:52:57 +0100175 _HA_ATOMIC_ADD(&li->thr_conn[tid], 1);
Willy Tarreau1efafce2019-01-27 15:37:19 +0100176 ret = li->accept(li, fd, &addr);
177 if (ret <= 0) {
178 /* connection was terminated by the application */
179 continue;
180 }
181
182 /* increase the per-process number of cumulated sessions, this
183 * may only be done once l->accept() has accepted the connection.
184 */
185 if (!(li->options & LI_O_UNLIMITED)) {
186 HA_ATOMIC_UPDATE_MAX(&global.sps_max,
187 update_freq_ctr(&global.sess_per_sec, 1));
188 if (li->bind_conf && li->bind_conf->is_ssl) {
189 HA_ATOMIC_UPDATE_MAX(&global.ssl_max,
190 update_freq_ctr(&global.ssl_per_sec, 1));
191 }
192 }
193 }
194
195 /* ran out of budget ? Let's come here ASAP */
Christopher Faulet102854c2019-04-30 12:17:13 +0200196 if (!max_accept)
Willy Tarreau1efafce2019-01-27 15:37:19 +0100197 task_wakeup(t, TASK_WOKEN_IO);
198
199 return t;
200}
201
202/* Initializes the accept-queues. Returns 0 on success, otherwise ERR_* flags */
203static int accept_queue_init()
204{
205 struct task *t;
206 int i;
207
208 for (i = 0; i < global.nbthread; i++) {
209 t = task_new(1UL << i);
210 if (!t) {
211 ha_alert("Out of memory while initializing accept queue for thread %d\n", i);
212 return ERR_FATAL|ERR_ABORT;
213 }
Willy Tarreau0d858442019-04-12 15:25:04 +0200214 t->nice = -1024;
Willy Tarreau1efafce2019-01-27 15:37:19 +0100215 t->process = accept_queue_process;
216 t->context = &accept_queue_rings[i];
217 accept_queue_rings[i].task = t;
218 }
219 return 0;
220}
221
222REGISTER_CONFIG_POSTPARSER("multi-threaded accept queue", accept_queue_init);
223
224#endif // USE_THREAD
225
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100226/* This function adds the specified listener's file descriptor to the polling
227 * lists if it is in the LI_LISTEN state. The listener enters LI_READY or
Willy Tarreauae302532014-05-07 19:22:24 +0200228 * LI_FULL state depending on its number of connections. In deamon mode, we
229 * also support binding only the relevant processes to their respective
230 * listeners. We don't do that in debug mode however.
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100231 */
Christopher Fauletf5b8adc2017-06-02 10:00:35 +0200232static void enable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100233{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100234 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100235 if (listener->state == LI_LISTEN) {
William Lallemand095ba4c2017-06-01 17:38:50 +0200236 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau6daac192019-02-02 17:39:53 +0100237 !(proc_mask(listener->bind_conf->bind_proc) & pid_bit)) {
Willy Tarreauae302532014-05-07 19:22:24 +0200238 /* we don't want to enable this listener and don't
239 * want any fd event to reach it.
240 */
Olivier Houchard1fc05162017-04-06 01:05:05 +0200241 if (!(global.tune.options & GTUNE_SOCKET_TRANSFER))
Christopher Faulet510c0d62018-03-16 10:04:47 +0100242 do_unbind_listener(listener, 1);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200243 else {
Christopher Faulet510c0d62018-03-16 10:04:47 +0100244 do_unbind_listener(listener, 0);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200245 listener->state = LI_LISTEN;
246 }
Willy Tarreauae302532014-05-07 19:22:24 +0200247 }
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100248 else if (!listener->maxconn || listener->nbconn < listener->maxconn) {
Willy Tarreau49b046d2012-08-09 12:11:58 +0200249 fd_want_recv(listener->fd);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100250 listener->state = LI_READY;
Willy Tarreauae302532014-05-07 19:22:24 +0200251 }
252 else {
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100253 listener->state = LI_FULL;
254 }
255 }
William Lallemande22f11f2018-09-11 10:06:27 +0200256 /* if this listener is supposed to be only in the master, close it in the workers */
257 if ((global.mode & MODE_MWORKER) &&
258 (listener->options & LI_O_MWORKER) &&
259 master == 0) {
260 do_unbind_listener(listener, 1);
261 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100262 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100263}
264
265/* This function removes the specified listener's file descriptor from the
266 * polling lists if it is in the LI_READY or in the LI_FULL state. The listener
267 * enters LI_LISTEN.
268 */
Christopher Fauletf5b8adc2017-06-02 10:00:35 +0200269static void disable_listener(struct listener *listener)
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100270{
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100271 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100272 if (listener->state < LI_READY)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200273 goto end;
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100274 if (listener->state == LI_READY)
Willy Tarreau49b046d2012-08-09 12:11:58 +0200275 fd_stop_recv(listener->fd);
Willy Tarreau01abd022019-02-28 10:27:18 +0100276 LIST_DEL_LOCKED(&listener->wait_queue);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100277 listener->state = LI_LISTEN;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200278 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100279 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100280}
281
Willy Tarreaube58c382011-07-24 18:28:10 +0200282/* This function tries to temporarily disable a listener, depending on the OS
283 * capabilities. Linux unbinds the listen socket after a SHUT_RD, and ignores
284 * SHUT_WR. Solaris refuses either shutdown(). OpenBSD ignores SHUT_RD but
285 * closes upon SHUT_WR and refuses to rebind. So a common validation path
286 * involves SHUT_WR && listen && SHUT_RD. In case of success, the FD's polling
287 * is disabled. It normally returns non-zero, unless an error is reported.
288 */
289int pause_listener(struct listener *l)
290{
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200291 int ret = 1;
292
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100293 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200294
Olivier Houchard1fc05162017-04-06 01:05:05 +0200295 if (l->state <= LI_ZOMBIE)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200296 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200297
Willy Tarreau092d8652014-07-07 20:22:12 +0200298 if (l->proto->pause) {
299 /* Returns < 0 in case of failure, 0 if the listener
300 * was totally stopped, or > 0 if correctly paused.
301 */
302 int ret = l->proto->pause(l);
Willy Tarreaube58c382011-07-24 18:28:10 +0200303
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200304 if (ret < 0) {
305 ret = 0;
306 goto end;
307 }
Willy Tarreau092d8652014-07-07 20:22:12 +0200308 else if (ret == 0)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200309 goto end;
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200310 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200311
Willy Tarreau01abd022019-02-28 10:27:18 +0100312 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200313
Willy Tarreau49b046d2012-08-09 12:11:58 +0200314 fd_stop_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200315 l->state = LI_PAUSED;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200316 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100317 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200318 return ret;
Willy Tarreaube58c382011-07-24 18:28:10 +0200319}
320
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200321/* This function tries to resume a temporarily disabled listener. Paused, full,
322 * limited and disabled listeners are handled, which means that this function
323 * may replace enable_listener(). The resulting state will either be LI_READY
324 * or LI_FULL. 0 is returned in case of failure to resume (eg: dead socket).
Willy Tarreauae302532014-05-07 19:22:24 +0200325 * Listeners bound to a different process are not woken up unless we're in
Willy Tarreauaf2fd582015-04-14 12:07:16 +0200326 * foreground mode, and are ignored. If the listener was only in the assigned
327 * state, it's totally rebound. This can happen if a pause() has completely
328 * stopped it. If the resume fails, 0 is returned and an error might be
329 * displayed.
Willy Tarreaube58c382011-07-24 18:28:10 +0200330 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100331int resume_listener(struct listener *l)
Willy Tarreaube58c382011-07-24 18:28:10 +0200332{
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200333 int ret = 1;
334
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100335 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200336
Willy Tarreau413e9262019-07-11 10:08:31 +0200337 /* check that another thread didn't to the job in parallel (e.g. at the
338 * end of listen_accept() while we'd come from dequeue_all_listeners().
339 */
340 if (LIST_ADDED(&l->wait_queue))
341 goto end;
342
William Lallemand095ba4c2017-06-01 17:38:50 +0200343 if ((global.mode & (MODE_DAEMON | MODE_MWORKER)) &&
Willy Tarreau6daac192019-02-02 17:39:53 +0100344 !(proc_mask(l->bind_conf->bind_proc) & pid_bit))
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200345 goto end;
Willy Tarreau3569df32017-03-15 12:47:46 +0100346
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200347 if (l->state == LI_ASSIGNED) {
348 char msg[100];
349 int err;
350
351 err = l->proto->bind(l, msg, sizeof(msg));
352 if (err & ERR_ALERT)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100353 ha_alert("Resuming listener: %s\n", msg);
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200354 else if (err & ERR_WARN)
Christopher Faulet767a84b2017-11-24 16:50:31 +0100355 ha_warning("Resuming listener: %s\n", msg);
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200356
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200357 if (err & (ERR_FATAL | ERR_ABORT)) {
358 ret = 0;
359 goto end;
360 }
Willy Tarreau1c4b8142014-07-07 21:06:24 +0200361 }
362
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200363 if (l->state < LI_PAUSED || l->state == LI_ZOMBIE) {
364 ret = 0;
365 goto end;
366 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200367
Willy Tarreaub3fb60b2012-10-04 08:56:31 +0200368 if (l->proto->sock_prot == IPPROTO_TCP &&
369 l->state == LI_PAUSED &&
Willy Tarreaue2711c72019-02-27 15:39:41 +0100370 listen(l->fd, listener_backlog(l)) != 0) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200371 ret = 0;
372 goto end;
373 }
Willy Tarreaube58c382011-07-24 18:28:10 +0200374
375 if (l->state == LI_READY)
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200376 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200377
Willy Tarreau01abd022019-02-28 10:27:18 +0100378 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200379
Willy Tarreaua8cf66b2019-02-27 16:49:00 +0100380 if (l->maxconn && l->nbconn >= l->maxconn) {
Willy Tarreaube58c382011-07-24 18:28:10 +0200381 l->state = LI_FULL;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200382 goto end;
Willy Tarreaube58c382011-07-24 18:28:10 +0200383 }
384
Willy Tarreau413e9262019-07-11 10:08:31 +0200385 if (!(thread_mask(l->bind_conf->bind_thread) & tid_bit)) {
386 /* we're not allowed to touch this listener's FD, let's requeue
387 * the listener into one of its owning thread's queue instead.
388 */
Willy Tarreau51232032020-02-12 10:01:29 +0100389 int first_thread = my_flsl(thread_mask(l->bind_conf->bind_thread) & all_threads_mask) - 1;
Willy Tarreau413e9262019-07-11 10:08:31 +0200390 work_list_add(&local_listener_queue[first_thread], &l->wait_queue);
391 goto end;
392 }
393
Willy Tarreau49b046d2012-08-09 12:11:58 +0200394 fd_want_recv(l->fd);
Willy Tarreaube58c382011-07-24 18:28:10 +0200395 l->state = LI_READY;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200396 end:
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100397 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200398 return ret;
399}
400
Willy Tarreau87b09662015-04-03 00:22:06 +0200401/* Marks a ready listener as full so that the stream code tries to re-enable
Willy Tarreau62793712011-07-24 19:23:38 +0200402 * it upon next close() using resume_listener().
403 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200404static void listener_full(struct listener *l)
Willy Tarreau62793712011-07-24 19:23:38 +0200405{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100406 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200407 if (l->state >= LI_READY) {
Willy Tarreau01abd022019-02-28 10:27:18 +0100408 LIST_DEL_LOCKED(&l->wait_queue);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100409 if (l->state != LI_FULL) {
410 fd_stop_recv(l->fd);
411 l->state = LI_FULL;
412 }
Willy Tarreau62793712011-07-24 19:23:38 +0200413 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100414 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreau62793712011-07-24 19:23:38 +0200415}
416
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200417/* Marks a ready listener as limited so that we only try to re-enable it when
418 * resources are free again. It will be queued into the specified queue.
419 */
Christopher Faulet5580ba22017-08-28 15:29:20 +0200420static void limit_listener(struct listener *l, struct list *list)
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200421{
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100422 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200423 if (l->state == LI_READY) {
Willy Tarreau01abd022019-02-28 10:27:18 +0100424 LIST_ADDQ_LOCKED(list, &l->wait_queue);
Willy Tarreau49b046d2012-08-09 12:11:58 +0200425 fd_stop_recv(l->fd);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200426 l->state = LI_LIMITED;
427 }
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100428 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200429}
430
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100431/* This function adds all of the protocol's listener's file descriptors to the
432 * polling lists when they are in the LI_LISTEN state. It is intended to be
433 * used as a protocol's generic enable_all() primitive, for use after the
434 * fork(). It puts the listeners into LI_READY or LI_FULL states depending on
435 * their number of connections. It always returns ERR_NONE.
Willy Tarreau937604b2019-07-24 16:45:02 +0200436 *
437 * Must be called with proto_lock held.
438 *
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100439 */
440int enable_all_listeners(struct protocol *proto)
441{
442 struct listener *listener;
443
444 list_for_each_entry(listener, &proto->listeners, proto_list)
445 enable_listener(listener);
446 return ERR_NONE;
447}
448
449/* This function removes all of the protocol's listener's file descriptors from
450 * the polling lists when they are in the LI_READY or LI_FULL states. It is
451 * intended to be used as a protocol's generic disable_all() primitive. It puts
452 * the listeners into LI_LISTEN, and always returns ERR_NONE.
Willy Tarreau937604b2019-07-24 16:45:02 +0200453 *
454 * Must be called with proto_lock held.
455 *
Willy Tarreaudabf2e22007-10-28 21:59:24 +0100456 */
457int disable_all_listeners(struct protocol *proto)
458{
459 struct listener *listener;
460
461 list_for_each_entry(listener, &proto->listeners, proto_list)
462 disable_listener(listener);
463 return ERR_NONE;
464}
465
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200466/* Dequeues all of the listeners waiting for a resource in wait queue <queue>. */
467void dequeue_all_listeners(struct list *list)
468{
Willy Tarreau01abd022019-02-28 10:27:18 +0100469 struct listener *listener;
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200470
Willy Tarreau01abd022019-02-28 10:27:18 +0100471 while ((listener = LIST_POP_LOCKED(list, struct listener *, wait_queue))) {
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200472 /* This cannot fail because the listeners are by definition in
Willy Tarreau01abd022019-02-28 10:27:18 +0100473 * the LI_LIMITED state.
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200474 */
Willy Tarreau01abd022019-02-28 10:27:18 +0100475 resume_listener(listener);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200476 }
477}
478
Christopher Faulet510c0d62018-03-16 10:04:47 +0100479/* Must be called with the lock held. Depending on <do_close> value, it does
480 * what unbind_listener or unbind_listener_no_close should do.
481 */
482void do_unbind_listener(struct listener *listener, int do_close)
Willy Tarreaub648d632007-10-28 22:13:50 +0100483{
Olivier Houcharda5188562019-03-08 15:35:42 +0100484 if (listener->state == LI_READY && fd_updt)
Willy Tarreau49b046d2012-08-09 12:11:58 +0200485 fd_stop_recv(listener->fd);
Willy Tarreaub648d632007-10-28 22:13:50 +0100486
Willy Tarreau01abd022019-02-28 10:27:18 +0100487 LIST_DEL_LOCKED(&listener->wait_queue);
Willy Tarreaue6ca1fc2011-07-24 22:03:52 +0200488
Willy Tarreaube58c382011-07-24 18:28:10 +0200489 if (listener->state >= LI_PAUSED) {
Olivier Houchard1fc05162017-04-06 01:05:05 +0200490 if (do_close) {
491 fd_delete(listener->fd);
492 listener->fd = -1;
493 }
494 else
495 fd_remove(listener->fd);
Willy Tarreaub648d632007-10-28 22:13:50 +0100496 listener->state = LI_ASSIGNED;
497 }
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100498}
499
Olivier Houchard1fc05162017-04-06 01:05:05 +0200500/* This function closes the listening socket for the specified listener,
501 * provided that it's already in a listening state. The listener enters the
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100502 * LI_ASSIGNED state. This function is intended to be used as a generic
503 * function for standard protocols.
Olivier Houchard1fc05162017-04-06 01:05:05 +0200504 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100505void unbind_listener(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200506{
Christopher Faulet510c0d62018-03-16 10:04:47 +0100507 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100508 do_unbind_listener(listener, 1);
Christopher Faulet510c0d62018-03-16 10:04:47 +0100509 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200510}
511
512/* This function pretends the listener is dead, but keeps the FD opened, so
513 * that we can provide it, for conf reloading.
514 */
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100515void unbind_listener_no_close(struct listener *listener)
Olivier Houchard1fc05162017-04-06 01:05:05 +0200516{
Christopher Faulet510c0d62018-03-16 10:04:47 +0100517 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaubbd09b92017-11-05 11:38:44 +0100518 do_unbind_listener(listener, 0);
Christopher Faulet510c0d62018-03-16 10:04:47 +0100519 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Olivier Houchard1fc05162017-04-06 01:05:05 +0200520}
521
Willy Tarreau3acf8c32007-10-28 22:35:41 +0100522/* This function closes all listening sockets bound to the protocol <proto>,
523 * and the listeners end in LI_ASSIGNED state if they were higher. It does not
524 * detach them from the protocol. It always returns ERR_NONE.
Willy Tarreau937604b2019-07-24 16:45:02 +0200525 *
526 * Must be called with proto_lock held.
527 *
Willy Tarreau3acf8c32007-10-28 22:35:41 +0100528 */
529int unbind_all_listeners(struct protocol *proto)
530{
531 struct listener *listener;
532
533 list_for_each_entry(listener, &proto->listeners, proto_list)
534 unbind_listener(listener);
535 return ERR_NONE;
536}
537
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200538/* creates one or multiple listeners for bind_conf <bc> on sockaddr <ss> on port
539 * range <portl> to <porth>, and possibly attached to fd <fd> (or -1 for auto
540 * allocation). The address family is taken from ss->ss_family. The number of
541 * jobs and listeners is automatically increased by the number of listeners
William Lallemand75ea0a02017-11-15 19:02:58 +0100542 * created. If the <inherited> argument is set to 1, it specifies that the FD
543 * was obtained from a parent process.
544 * It returns non-zero on success, zero on error with the error message
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200545 * set in <err>.
546 */
547int create_listeners(struct bind_conf *bc, const struct sockaddr_storage *ss,
William Lallemand75ea0a02017-11-15 19:02:58 +0100548 int portl, int porth, int fd, int inherited, char **err)
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200549{
550 struct protocol *proto = protocol_by_family(ss->ss_family);
551 struct listener *l;
552 int port;
553
554 if (!proto) {
555 memprintf(err, "unsupported protocol family %d", ss->ss_family);
556 return 0;
557 }
558
559 for (port = portl; port <= porth; port++) {
560 l = calloc(1, sizeof(*l));
561 if (!l) {
562 memprintf(err, "out of memory");
563 return 0;
564 }
565 l->obj_type = OBJ_TYPE_LISTENER;
566 LIST_ADDQ(&bc->frontend->conf.listeners, &l->by_fe);
567 LIST_ADDQ(&bc->listeners, &l->by_bind);
568 l->bind_conf = bc;
569
570 l->fd = fd;
571 memcpy(&l->addr, ss, sizeof(*ss));
Willy Tarreau01abd022019-02-28 10:27:18 +0100572 LIST_INIT(&l->wait_queue);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200573 l->state = LI_INIT;
574
575 proto->add(l, port);
576
William Lallemand75ea0a02017-11-15 19:02:58 +0100577 if (inherited)
578 l->options |= LI_O_INHERITED;
579
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100580 HA_SPIN_INIT(&l->lock);
Olivier Houchard64213e92019-03-08 18:52:57 +0100581 _HA_ATOMIC_ADD(&jobs, 1);
582 _HA_ATOMIC_ADD(&listeners, 1);
Willy Tarreau0de59fd2017-09-15 08:10:44 +0200583 }
584 return 1;
585}
586
Willy Tarreau1a64d162007-10-28 22:26:05 +0100587/* Delete a listener from its protocol's list of listeners. The listener's
588 * state is automatically updated from LI_ASSIGNED to LI_INIT. The protocol's
Willy Tarreau2cc5bae2017-09-15 08:18:11 +0200589 * number of listeners is updated, as well as the global number of listeners
590 * and jobs. Note that the listener must have previously been unbound. This
591 * is the generic function to use to remove a listener.
Willy Tarreau937604b2019-07-24 16:45:02 +0200592 *
593 * Will grab the proto_lock.
594 *
Willy Tarreau1a64d162007-10-28 22:26:05 +0100595 */
596void delete_listener(struct listener *listener)
597{
Willy Tarreaub10c8d72019-08-26 10:55:52 +0200598 HA_SPIN_LOCK(PROTO_LOCK, &proto_lock);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100599 HA_SPIN_LOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100600 if (listener->state == LI_ASSIGNED) {
601 listener->state = LI_INIT;
602 LIST_DEL(&listener->proto_list);
603 listener->proto->nb_listeners--;
Olivier Houchard64213e92019-03-08 18:52:57 +0100604 _HA_ATOMIC_SUB(&jobs, 1);
605 _HA_ATOMIC_SUB(&listeners, 1);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100606 }
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100607 HA_SPIN_UNLOCK(LISTENER_LOCK, &listener->lock);
Willy Tarreaub10c8d72019-08-26 10:55:52 +0200608 HA_SPIN_UNLOCK(PROTO_LOCK, &proto_lock);
Willy Tarreau1a64d162007-10-28 22:26:05 +0100609}
610
Willy Tarreaue2711c72019-02-27 15:39:41 +0100611/* Returns a suitable value for a listener's backlog. It uses the listener's,
612 * otherwise the frontend's backlog, otherwise the listener's maxconn,
613 * otherwise the frontend's maxconn, otherwise 1024.
614 */
615int listener_backlog(const struct listener *l)
616{
617 if (l->backlog)
618 return l->backlog;
619
620 if (l->bind_conf->frontend->backlog)
621 return l->bind_conf->frontend->backlog;
622
623 if (l->maxconn)
624 return l->maxconn;
625
626 if (l->bind_conf->frontend->maxconn)
627 return l->bind_conf->frontend->maxconn;
628
629 return 1024;
630}
631
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200632/* This function is called on a read event from a listening socket, corresponding
633 * to an accept. It tries to accept as many connections as possible, and for each
634 * calls the listener's accept handler (generally the frontend's accept handler).
635 */
Willy Tarreauafad0e02012-08-09 14:45:22 +0200636void listener_accept(int fd)
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200637{
638 struct listener *l = fdtab[fd].owner;
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100639 struct proxy *p;
Christopher Faulet102854c2019-04-30 12:17:13 +0200640 unsigned int max_accept;
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100641 int next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100642 int next_feconn = 0;
643 int next_actconn = 0;
Willy Tarreaubb660302014-05-07 19:47:02 +0200644 int expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200645 int cfd;
646 int ret;
Willy Tarreau818dca52014-01-31 19:40:19 +0100647#ifdef USE_ACCEPT4
648 static int accept4_broken;
649#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200650
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100651 if (!l)
652 return;
653 p = l->bind_conf->frontend;
Christopher Faulet102854c2019-04-30 12:17:13 +0200654
655 /* if l->maxaccept is -1, then max_accept is UINT_MAX. It is not really
656 * illimited, but it is probably enough.
657 */
Olivier Houchardd16a9df2019-02-25 16:18:16 +0100658 max_accept = l->maxaccept ? l->maxaccept : 1;
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200659
Willy Tarreau93e7c002013-10-07 18:51:07 +0200660 if (!(l->options & LI_O_UNLIMITED) && global.sps_lim) {
661 int max = freq_ctr_remain(&global.sess_per_sec, global.sps_lim, 0);
Willy Tarreau93e7c002013-10-07 18:51:07 +0200662
663 if (unlikely(!max)) {
664 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200665 expire = tick_add(now_ms, next_event_delay(&global.sess_per_sec, global.sps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200666 goto wait_expire;
Willy Tarreau93e7c002013-10-07 18:51:07 +0200667 }
668
669 if (max_accept > max)
670 max_accept = max;
671 }
672
673 if (!(l->options & LI_O_UNLIMITED) && global.cps_lim) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200674 int max = freq_ctr_remain(&global.conn_per_sec, global.cps_lim, 0);
675
676 if (unlikely(!max)) {
677 /* frontend accept rate limit was reached */
Willy Tarreau93e7c002013-10-07 18:51:07 +0200678 expire = tick_add(now_ms, next_event_delay(&global.conn_per_sec, global.cps_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200679 goto wait_expire;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200680 }
681
682 if (max_accept > max)
683 max_accept = max;
684 }
Willy Tarreaue43d5322013-10-07 20:01:52 +0200685#ifdef USE_OPENSSL
686 if (!(l->options & LI_O_UNLIMITED) && global.ssl_lim && l->bind_conf && l->bind_conf->is_ssl) {
687 int max = freq_ctr_remain(&global.ssl_per_sec, global.ssl_lim, 0);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200688
Willy Tarreaue43d5322013-10-07 20:01:52 +0200689 if (unlikely(!max)) {
690 /* frontend accept rate limit was reached */
Willy Tarreaue43d5322013-10-07 20:01:52 +0200691 expire = tick_add(now_ms, next_event_delay(&global.ssl_per_sec, global.ssl_lim, 0));
Willy Tarreaubb660302014-05-07 19:47:02 +0200692 goto wait_expire;
Willy Tarreaue43d5322013-10-07 20:01:52 +0200693 }
694
695 if (max_accept > max)
696 max_accept = max;
697 }
698#endif
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200699 if (p && p->fe_sps_lim) {
700 int max = freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0);
701
702 if (unlikely(!max)) {
703 /* frontend accept rate limit was reached */
704 limit_listener(l, &p->listener_queue);
705 task_schedule(p->task, tick_add(now_ms, next_event_delay(&p->fe_sess_per_sec, p->fe_sps_lim, 0)));
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200706 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200707 }
708
709 if (max_accept > max)
710 max_accept = max;
711 }
712
713 /* Note: if we fail to allocate a connection because of configured
714 * limits, we'll schedule a new attempt worst 1 second later in the
715 * worst case. If we fail due to system limits or temporary resource
716 * shortage, we try again 100ms later in the worst case.
717 */
Christopher Faulet102854c2019-04-30 12:17:13 +0200718 for (; max_accept; next_conn = next_feconn = next_actconn = 0, max_accept--) {
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200719 struct sockaddr_storage addr;
720 socklen_t laddr = sizeof(addr);
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200721 unsigned int count;
Willy Tarreau57cb5062019-03-15 17:16:34 +0100722 __decl_hathreads(unsigned long mask);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200723
Willy Tarreau82c97892019-02-27 19:32:32 +0100724 /* pre-increase the number of connections without going too far.
725 * We process the listener, then the proxy, then the process.
726 * We know which ones to unroll based on the next_xxx value.
727 */
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100728 do {
729 count = l->nbconn;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100730 if (unlikely(l->maxconn && count >= l->maxconn)) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100731 /* the listener was marked full or another
732 * thread is going to do it.
733 */
734 next_conn = 0;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100735 listener_full(l);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100736 goto end;
737 }
738 next_conn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000739 } while (!_HA_ATOMIC_CAS(&l->nbconn, (int *)(&count), next_conn));
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100740
Willy Tarreau82c97892019-02-27 19:32:32 +0100741 if (p) {
742 do {
743 count = p->feconn;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100744 if (unlikely(count >= p->maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100745 /* the frontend was marked full or another
746 * thread is going to do it.
747 */
748 next_feconn = 0;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100749 limit_listener(l, &p->listener_queue);
Willy Tarreau82c97892019-02-27 19:32:32 +0100750 goto end;
751 }
752 next_feconn = count + 1;
Olivier Houchard64213e92019-03-08 18:52:57 +0100753 } while (!_HA_ATOMIC_CAS(&p->feconn, &count, next_feconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200754 }
755
Willy Tarreau82c97892019-02-27 19:32:32 +0100756 if (!(l->options & LI_O_UNLIMITED)) {
757 do {
758 count = actconn;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100759 if (unlikely(count >= global.maxconn)) {
Willy Tarreau82c97892019-02-27 19:32:32 +0100760 /* the process was marked full or another
761 * thread is going to do it.
762 */
763 next_actconn = 0;
Willy Tarreaueb1d4862019-11-15 10:20:07 +0100764 limit_listener(l, &global_listener_queue);
765 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Willy Tarreau82c97892019-02-27 19:32:32 +0100766 goto end;
767 }
768 next_actconn = count + 1;
David Carlier56716622019-03-27 16:08:42 +0000769 } while (!_HA_ATOMIC_CAS(&actconn, (int *)(&count), next_actconn));
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200770 }
771
William Lallemand2fe7dd02018-09-11 16:51:29 +0200772 /* with sockpair@ we don't want to do an accept */
773 if (unlikely(l->addr.ss_family == AF_CUST_SOCKPAIR)) {
774 if ((cfd = recv_fd_uxst(fd)) != -1)
William Lallemandd9138002018-11-27 12:02:39 +0100775 fcntl(cfd, F_SETFL, O_NONBLOCK);
Willy Tarreau888d5672019-01-27 18:34:12 +0100776 /* just like with UNIX sockets, only the family is filled */
777 addr.ss_family = AF_UNIX;
778 laddr = sizeof(addr.ss_family);
William Lallemand2fe7dd02018-09-11 16:51:29 +0200779 } else
780
Willy Tarreau1bc4aab2012-10-08 20:11:03 +0200781#ifdef USE_ACCEPT4
Willy Tarreau818dca52014-01-31 19:40:19 +0100782 /* only call accept4() if it's known to be safe, otherwise
783 * fallback to the legacy accept() + fcntl().
784 */
785 if (unlikely(accept4_broken ||
William Lallemandd9138002018-11-27 12:02:39 +0100786 ((cfd = accept4(fd, (struct sockaddr *)&addr, &laddr, SOCK_NONBLOCK)) == -1 &&
Willy Tarreau818dca52014-01-31 19:40:19 +0100787 (errno == ENOSYS || errno == EINVAL || errno == EBADF) &&
788 (accept4_broken = 1))))
789#endif
Willy Tarreau6b3b0d42012-10-22 19:32:55 +0200790 if ((cfd = accept(fd, (struct sockaddr *)&addr, &laddr)) != -1)
William Lallemandd9138002018-11-27 12:02:39 +0100791 fcntl(cfd, F_SETFL, O_NONBLOCK);
Willy Tarreau818dca52014-01-31 19:40:19 +0100792
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200793 if (unlikely(cfd == -1)) {
794 switch (errno) {
795 case EAGAIN:
Willy Tarreaubbee29c2019-12-10 08:42:21 +0100796 if (fdtab[fd].ev & (FD_POLL_HUP|FD_POLL_ERR)) {
Willy Tarreaubb660302014-05-07 19:47:02 +0200797 /* the listening socket might have been disabled in a shared
798 * process and we're a collateral victim. We'll just pause for
799 * a while in case it comes back. In the mean time, we need to
800 * clear this sticky flag.
801 */
Willy Tarreaubbee29c2019-12-10 08:42:21 +0100802 _HA_ATOMIC_AND(&fdtab[fd].ev, ~(FD_POLL_HUP|FD_POLL_ERR));
Willy Tarreaubb660302014-05-07 19:47:02 +0200803 goto transient_error;
804 }
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200805 goto end; /* nothing more to accept */
Willy Tarreaubb660302014-05-07 19:47:02 +0200806 case EINVAL:
807 /* might be trying to accept on a shut fd (eg: soft stop) */
808 goto transient_error;
Willy Tarreaua593ec52014-01-20 21:21:30 +0100809 case EINTR:
810 case ECONNABORTED:
Olivier Houchard64213e92019-03-08 18:52:57 +0100811 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100812 if (p)
Olivier Houchard64213e92019-03-08 18:52:57 +0100813 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +0100814 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +0100815 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreaua593ec52014-01-20 21:21:30 +0100816 continue;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200817 case ENFILE:
818 if (p)
819 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100820 "Proxy %s reached system FD limit (maxsock=%d). Please check system tunables.\n",
821 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200822 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200823 case EMFILE:
824 if (p)
825 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100826 "Proxy %s reached process FD limit (maxsock=%d). Please check 'ulimit-n' and restart.\n",
827 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200828 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200829 case ENOBUFS:
830 case ENOMEM:
831 if (p)
832 send_log(p, LOG_EMERG,
Willy Tarreauc5532ac2018-01-29 15:06:04 +0100833 "Proxy %s reached system memory limit (maxsock=%d). Please check system tunables.\n",
834 p->id, global.maxsock);
Willy Tarreaubb660302014-05-07 19:47:02 +0200835 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200836 default:
Willy Tarreaua593ec52014-01-20 21:21:30 +0100837 /* unexpected result, let's give up and let other tasks run */
Willy Tarreau07e13222019-12-10 09:30:05 +0100838 max_accept = 0;
839 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200840 }
841 }
842
William Lallemandd9138002018-11-27 12:02:39 +0100843 /* we don't want to leak the FD upon reload if it's in the master */
844 if (unlikely(master == 1))
845 fcntl(cfd, F_SETFD, FD_CLOEXEC);
846
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100847 /* The connection was accepted, it must be counted as such */
848 if (l->counters)
849 HA_ATOMIC_UPDATE_MAX(&l->counters->conn_max, next_conn);
850
Willy Tarreau82c97892019-02-27 19:32:32 +0100851 if (p)
852 HA_ATOMIC_UPDATE_MAX(&p->fe_counters.conn_max, next_feconn);
853
854 proxy_inc_fe_conn_ctr(l, p);
855
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100856 if (!(l->options & LI_O_UNLIMITED)) {
857 count = update_freq_ctr(&global.conn_per_sec, 1);
858 HA_ATOMIC_UPDATE_MAX(&global.cps_max, count);
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100859 }
860
Willy Tarreau64a9c052019-04-12 15:27:17 +0200861 _HA_ATOMIC_ADD(&activity[tid].accepted, 1);
862
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200863 if (unlikely(cfd >= global.maxsock)) {
864 send_log(p, LOG_EMERG,
865 "Proxy %s reached the configured maximum connection limit. Please check the global 'maxconn' value.\n",
866 p->id);
867 close(cfd);
868 limit_listener(l, &global_listener_queue);
869 task_schedule(global_listener_queue_task, tick_add(now_ms, 1000)); /* try again in 1 second */
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +0200870 goto end;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200871 }
872
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100873 /* past this point, l->accept() will automatically decrement
Willy Tarreau82c97892019-02-27 19:32:32 +0100874 * l->nbconn, feconn and actconn once done. Setting next_*conn=0
875 * allows the error path not to rollback on nbconn. It's more
876 * convenient than duplicating all exit labels.
Willy Tarreau3f0d02b2019-02-25 19:23:37 +0100877 */
878 next_conn = 0;
Willy Tarreau82c97892019-02-27 19:32:32 +0100879 next_feconn = 0;
880 next_actconn = 0;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200881
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100882#if defined(USE_THREAD)
Willy Tarreau897e2c52019-03-13 15:03:53 +0100883 mask = thread_mask(l->bind_conf->bind_thread) & all_threads_mask;
Willy Tarreauc72d2642020-03-12 17:33:29 +0100884 if (atleast2(mask) && (global.tune.options & GTUNE_LISTENER_MQ) && !stopping) {
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100885 struct accept_queue_ring *ring;
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100886 unsigned int t, t0, t1, t2;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100887
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100888 /* The principle is that we have two running indexes,
889 * each visiting in turn all threads bound to this
890 * listener. The connection will be assigned to the one
891 * with the least connections, and the other one will
892 * be updated. This provides a good fairness on short
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100893 * connections (round robin) and on long ones (conn
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100894 * count), without ever missing any idle thread.
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100895 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100896
897 /* keep a copy for the final update. thr_idx is composite
898 * and made of (t2<<16) + t1.
899 */
Willy Tarreau0cf33172019-03-06 15:26:33 +0100900 t0 = l->thr_idx;
Willy Tarreaufc630bd2019-03-04 19:57:34 +0100901 do {
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100902 unsigned long m1, m2;
903 int q1, q2;
904
905 t2 = t1 = t0;
906 t2 >>= 16;
907 t1 &= 0xFFFF;
908
909 /* t1 walks low to high bits ;
910 * t2 walks high to low.
911 */
912 m1 = mask >> t1;
913 m2 = mask & (t2 ? nbits(t2 + 1) : ~0UL);
914
Willy Tarreau85d04242019-04-16 18:09:13 +0200915 if (unlikely(!(m1 & 1))) {
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100916 m1 &= ~1UL;
917 if (!m1) {
918 m1 = mask;
919 t1 = 0;
920 }
921 t1 += my_ffsl(m1) - 1;
922 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100923
Willy Tarreau85d04242019-04-16 18:09:13 +0200924 if (unlikely(!(m2 & (1UL << t2)) || t1 == t2)) {
925 /* highest bit not set */
926 if (!m2)
927 m2 = mask;
928
929 t2 = my_flsl(m2) - 1;
930 }
931
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100932 /* now we have two distinct thread IDs belonging to the mask */
933 q1 = accept_queue_rings[t1].tail - accept_queue_rings[t1].head + ACCEPT_QUEUE_SIZE;
934 if (q1 >= ACCEPT_QUEUE_SIZE)
935 q1 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100936
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100937 q2 = accept_queue_rings[t2].tail - accept_queue_rings[t2].head + ACCEPT_QUEUE_SIZE;
938 if (q2 >= ACCEPT_QUEUE_SIZE)
939 q2 -= ACCEPT_QUEUE_SIZE;
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100940
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100941 /* we have 3 possibilities now :
942 * q1 < q2 : t1 is less loaded than t2, so we pick it
943 * and update t2 (since t1 might still be
944 * lower than another thread)
945 * q1 > q2 : t2 is less loaded than t1, so we pick it
946 * and update t1 (since t2 might still be
947 * lower than another thread)
948 * q1 = q2 : both are equally loaded, thus we pick t1
949 * and update t1 as it will become more loaded
950 * than t2.
951 */
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100952
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100953 q1 += l->thr_conn[t1];
954 q2 += l->thr_conn[t2];
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100955
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100956 if (q1 - q2 < 0) {
957 t = t1;
958 t2 = t2 ? t2 - 1 : LONGBITS - 1;
959 }
960 else if (q1 - q2 > 0) {
961 t = t2;
962 t1++;
963 if (t1 >= LONGBITS)
964 t1 = 0;
965 }
966 else {
967 t = t1;
968 t1++;
969 if (t1 >= LONGBITS)
970 t1 = 0;
971 }
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100972
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100973 /* new value for thr_idx */
974 t1 += (t2 << 16);
Olivier Houchard64213e92019-03-08 18:52:57 +0100975 } while (unlikely(!_HA_ATOMIC_CAS(&l->thr_idx, &t0, t1)));
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100976
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100977 /* We successfully selected the best thread "t" for this
978 * connection. We use deferred accepts even if it's the
979 * local thread because tests show that it's the best
980 * performing model, likely due to better cache locality
981 * when processing this loop.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100982 */
Willy Tarreau0fe703b2019-03-05 08:46:28 +0100983 ring = &accept_queue_rings[t];
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100984 if (accept_queue_push_mp(ring, cfd, l, &addr, laddr)) {
Olivier Houchard64213e92019-03-08 18:52:57 +0100985 _HA_ATOMIC_ADD(&activity[t].accq_pushed, 1);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100986 task_wakeup(ring->task, TASK_WOKEN_IO);
987 continue;
988 }
989 /* If the ring is full we do a synchronous accept on
990 * the local thread here.
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100991 */
Olivier Houchard64213e92019-03-08 18:52:57 +0100992 _HA_ATOMIC_ADD(&activity[t].accq_full, 1);
Willy Tarreaue0e9c482019-01-27 15:37:19 +0100993 }
994#endif // USE_THREAD
995
Olivier Houchard64213e92019-03-08 18:52:57 +0100996 _HA_ATOMIC_ADD(&l->thr_conn[tid], 1);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +0200997 ret = l->accept(l, cfd, &addr);
998 if (unlikely(ret <= 0)) {
Willy Tarreau87b09662015-04-03 00:22:06 +0200999 /* The connection was closed by stream_accept(). Either
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001000 * we just have to ignore it (ret == 0) or it's a critical
1001 * error due to a resource shortage, and we must stop the
1002 * listener (ret < 0).
1003 */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001004 if (ret == 0) /* successful termination */
1005 continue;
1006
Willy Tarreaubb660302014-05-07 19:47:02 +02001007 goto transient_error;
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001008 }
1009
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001010 /* increase the per-process number of cumulated sessions, this
1011 * may only be done once l->accept() has accepted the connection.
1012 */
Willy Tarreau93e7c002013-10-07 18:51:07 +02001013 if (!(l->options & LI_O_UNLIMITED)) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001014 count = update_freq_ctr(&global.sess_per_sec, 1);
1015 HA_ATOMIC_UPDATE_MAX(&global.sps_max, count);
Willy Tarreau93e7c002013-10-07 18:51:07 +02001016 }
Willy Tarreaue43d5322013-10-07 20:01:52 +02001017#ifdef USE_OPENSSL
1018 if (!(l->options & LI_O_UNLIMITED) && l->bind_conf && l->bind_conf->is_ssl) {
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001019 count = update_freq_ctr(&global.ssl_per_sec, 1);
1020 HA_ATOMIC_UPDATE_MAX(&global.ssl_max, count);
Willy Tarreaue43d5322013-10-07 20:01:52 +02001021 }
1022#endif
Willy Tarreau93e7c002013-10-07 18:51:07 +02001023
Willy Tarreau9fbaa3c2020-05-01 09:51:11 +02001024 ti->flags &= ~TI_FL_STUCK; // this thread is still running
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001025 } /* end of for (max_accept--) */
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001026
Willy Tarreauaece46a2012-07-06 12:25:58 +02001027 /* we've exhausted max_accept, so there is no need to poll again */
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001028 goto end;
Willy Tarreaubb660302014-05-07 19:47:02 +02001029
1030 transient_error:
Willy Tarreau07e13222019-12-10 09:30:05 +01001031 /* pause the listener for up to 100 ms */
Willy Tarreaubb660302014-05-07 19:47:02 +02001032 expire = tick_add(now_ms, 100);
1033
1034 wait_expire:
Willy Tarreau07e13222019-12-10 09:30:05 +01001035 /* switch the listener to LI_LIMITED and wait until up to <expire> in the global queue */
Willy Tarreaubb660302014-05-07 19:47:02 +02001036 limit_listener(l, &global_listener_queue);
1037 task_schedule(global_listener_queue_task, tick_first(expire, global_listener_queue_task->expire));
Christopher Faulet8d8aa0d2017-05-30 15:36:50 +02001038 end:
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001039 if (next_conn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001040 _HA_ATOMIC_SUB(&l->nbconn, 1);
Willy Tarreau741b4d62019-02-25 15:02:04 +01001041
Willy Tarreau82c97892019-02-27 19:32:32 +01001042 if (p && next_feconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001043 _HA_ATOMIC_SUB(&p->feconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001044
1045 if (next_actconn)
Olivier Houchard64213e92019-03-08 18:52:57 +01001046 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001047
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001048 if ((l->state == LI_FULL && (!l->maxconn || l->nbconn < l->maxconn)) ||
Willy Tarreau5de8d1f2019-12-11 15:06:30 +01001049 (l->state == LI_LIMITED &&
1050 ((!p || p->feconn < p->maxconn) && (actconn < global.maxconn) &&
1051 (!tick_isset(global_listener_queue_task->expire) ||
1052 tick_is_expired(global_listener_queue_task->expire, now_ms))))) {
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001053 /* at least one thread has to this when quitting */
1054 resume_listener(l);
1055
1056 /* Dequeues all of the listeners waiting for a resource */
1057 if (!LIST_ISEMPTY(&global_listener_queue))
1058 dequeue_all_listeners(&global_listener_queue);
1059
Christopher Fauletbe2c1062019-09-10 10:01:26 +02001060 if (p && !LIST_ISEMPTY(&p->listener_queue) &&
Willy Tarreau3f0d02b2019-02-25 19:23:37 +01001061 (!p->fe_sps_lim || freq_ctr_remain(&p->fe_sess_per_sec, p->fe_sps_lim, 0) > 0))
1062 dequeue_all_listeners(&p->listener_queue);
1063 }
Willy Tarreau79116102019-12-05 07:40:32 +01001064
Willy Tarreau07e13222019-12-10 09:30:05 +01001065 /* Now it's getting tricky. The listener was supposed to be in LI_READY
1066 * state but in the mean time we might have changed it to LI_FULL or
1067 * LI_LIMITED, and another thread might also have turned it to
1068 * LI_PAUSED, LI_LISTEN or even LI_INI when stopping a proxy. We must
1069 * be certain to keep the FD enabled when in the READY state but we
1070 * must also stop it for other states that we might have switched to
1071 * while others re-enabled polling.
1072 */
1073 HA_SPIN_LOCK(LISTENER_LOCK, &l->lock);
1074 if (l->state == LI_READY) {
1075 if (max_accept > 0)
1076 fd_cant_recv(fd);
1077 else
1078 fd_done_recv(fd);
1079 } else if (l->state > LI_ASSIGNED) {
Willy Tarreau79116102019-12-05 07:40:32 +01001080 fd_stop_recv(l->fd);
Willy Tarreau07e13222019-12-10 09:30:05 +01001081 }
1082 HA_SPIN_UNLOCK(LISTENER_LOCK, &l->lock);
Willy Tarreaubbebbbf2012-05-07 21:22:09 +02001083}
1084
Willy Tarreau05f50472017-09-15 09:19:58 +02001085/* Notify the listener that a connection initiated from it was released. This
1086 * is used to keep the connection count consistent and to possibly re-open
1087 * listening when it was limited.
1088 */
1089void listener_release(struct listener *l)
1090{
1091 struct proxy *fe = l->bind_conf->frontend;
1092
1093 if (!(l->options & LI_O_UNLIMITED))
Olivier Houchard64213e92019-03-08 18:52:57 +01001094 _HA_ATOMIC_SUB(&actconn, 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001095 if (fe)
Olivier Houchard64213e92019-03-08 18:52:57 +01001096 _HA_ATOMIC_SUB(&fe->feconn, 1);
1097 _HA_ATOMIC_SUB(&l->nbconn, 1);
1098 _HA_ATOMIC_SUB(&l->thr_conn[tid], 1);
Willy Tarreau82c97892019-02-27 19:32:32 +01001099
1100 if (l->state == LI_FULL || l->state == LI_LIMITED)
Willy Tarreau05f50472017-09-15 09:19:58 +02001101 resume_listener(l);
1102
1103 /* Dequeues all of the listeners waiting for a resource */
1104 if (!LIST_ISEMPTY(&global_listener_queue))
1105 dequeue_all_listeners(&global_listener_queue);
1106
1107 if (!LIST_ISEMPTY(&fe->listener_queue) &&
1108 (!fe->fe_sps_lim || freq_ctr_remain(&fe->fe_sess_per_sec, fe->fe_sps_lim, 0) > 0))
1109 dequeue_all_listeners(&fe->listener_queue);
1110}
1111
Willy Tarreau413e9262019-07-11 10:08:31 +02001112/* resume listeners waiting in the local listener queue. They are still in LI_LIMITED state */
1113static struct task *listener_queue_process(struct task *t, void *context, unsigned short state)
1114{
1115 struct work_list *wl = context;
1116 struct listener *l;
1117
1118 while ((l = LIST_POP_LOCKED(&wl->head, struct listener *, wait_queue))) {
1119 /* The listeners are still in the LI_LIMITED state */
1120 resume_listener(l);
1121 }
1122 return t;
1123}
1124
1125/* Initializes the listener queues. Returns 0 on success, otherwise ERR_* flags */
1126static int listener_queue_init()
1127{
1128 local_listener_queue = work_list_create(global.nbthread, listener_queue_process, NULL);
1129 if (!local_listener_queue) {
1130 ha_alert("Out of memory while initializing listener queues.\n");
1131 return ERR_FATAL|ERR_ABORT;
1132 }
1133 return 0;
1134}
1135
1136static void listener_queue_deinit()
1137{
1138 work_list_destroy(local_listener_queue, global.nbthread);
1139}
1140
1141REGISTER_CONFIG_POSTPARSER("multi-threaded listener queue", listener_queue_init);
1142REGISTER_POST_DEINIT(listener_queue_deinit);
1143
Willy Tarreau26982662012-09-12 23:17:10 +02001144/*
1145 * Registers the bind keyword list <kwl> as a list of valid keywords for next
1146 * parsing sessions.
1147 */
1148void bind_register_keywords(struct bind_kw_list *kwl)
1149{
1150 LIST_ADDQ(&bind_keywords.list, &kwl->list);
1151}
1152
1153/* Return a pointer to the bind keyword <kw>, or NULL if not found. If the
1154 * keyword is found with a NULL ->parse() function, then an attempt is made to
1155 * find one with a valid ->parse() function. This way it is possible to declare
1156 * platform-dependant, known keywords as NULL, then only declare them as valid
1157 * if some options are met. Note that if the requested keyword contains an
1158 * opening parenthesis, everything from this point is ignored.
1159 */
1160struct bind_kw *bind_find_kw(const char *kw)
1161{
1162 int index;
1163 const char *kwend;
1164 struct bind_kw_list *kwl;
1165 struct bind_kw *ret = NULL;
1166
1167 kwend = strchr(kw, '(');
1168 if (!kwend)
1169 kwend = kw + strlen(kw);
1170
1171 list_for_each_entry(kwl, &bind_keywords.list, list) {
1172 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1173 if ((strncmp(kwl->kw[index].kw, kw, kwend - kw) == 0) &&
1174 kwl->kw[index].kw[kwend-kw] == 0) {
1175 if (kwl->kw[index].parse)
1176 return &kwl->kw[index]; /* found it !*/
1177 else
1178 ret = &kwl->kw[index]; /* may be OK */
1179 }
1180 }
1181 }
1182 return ret;
1183}
1184
Willy Tarreau8638f482012-09-18 18:01:17 +02001185/* Dumps all registered "bind" keywords to the <out> string pointer. The
1186 * unsupported keywords are only dumped if their supported form was not
1187 * found.
1188 */
1189void bind_dump_kws(char **out)
1190{
1191 struct bind_kw_list *kwl;
1192 int index;
1193
1194 *out = NULL;
1195 list_for_each_entry(kwl, &bind_keywords.list, list) {
1196 for (index = 0; kwl->kw[index].kw != NULL; index++) {
1197 if (kwl->kw[index].parse ||
1198 bind_find_kw(kwl->kw[index].kw) == &kwl->kw[index]) {
Willy Tarreau51fb7652012-09-18 18:24:39 +02001199 memprintf(out, "%s[%4s] %s%s%s\n", *out ? *out : "",
1200 kwl->scope,
Willy Tarreau8638f482012-09-18 18:01:17 +02001201 kwl->kw[index].kw,
Willy Tarreau51fb7652012-09-18 18:24:39 +02001202 kwl->kw[index].skip ? " <arg>" : "",
1203 kwl->kw[index].parse ? "" : " (not supported)");
Willy Tarreau8638f482012-09-18 18:01:17 +02001204 }
1205 }
1206 }
1207}
1208
Willy Tarreau645513a2010-05-24 20:55:15 +02001209/************************************************************************/
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001210/* All supported sample and ACL keywords must be declared here. */
Willy Tarreau645513a2010-05-24 20:55:15 +02001211/************************************************************************/
1212
Willy Tarreaua5e37562011-12-16 17:06:15 +01001213/* set temp integer to the number of connexions to the same listening socket */
Willy Tarreau645513a2010-05-24 20:55:15 +02001214static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001215smp_fetch_dconn(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau645513a2010-05-24 20:55:15 +02001216{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001217 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001218 smp->data.u.sint = smp->sess->listener->nbconn;
Willy Tarreau645513a2010-05-24 20:55:15 +02001219 return 1;
1220}
1221
Willy Tarreaua5e37562011-12-16 17:06:15 +01001222/* set temp integer to the id of the socket (listener) */
Willy Tarreau645513a2010-05-24 20:55:15 +02001223static int
Thierry FOURNIER0786d052015-05-11 15:42:45 +02001224smp_fetch_so_id(const struct arg *args, struct sample *smp, const char *kw, void *private)
Willy Tarreau37406352012-04-23 16:16:37 +02001225{
Thierry FOURNIER8c542ca2015-08-19 09:00:18 +02001226 smp->data.type = SMP_T_SINT;
Thierry FOURNIER136f9d32015-08-19 09:07:19 +02001227 smp->data.u.sint = smp->sess->listener->luid;
Willy Tarreau645513a2010-05-24 20:55:15 +02001228 return 1;
1229}
Jerome Magnin28b90332020-03-27 22:08:40 +01001230static int
1231smp_fetch_so_name(const struct arg *args, struct sample *smp, const char *kw, void *private)
1232{
1233 smp->data.u.str.area = smp->sess->listener->name;
1234 if (!smp->data.u.str.area)
1235 return 0;
1236
1237 smp->data.type = SMP_T_STR;
1238 smp->flags = SMP_F_CONST;
1239 smp->data.u.str.data = strlen(smp->data.u.str.area);
1240 return 1;
1241}
Willy Tarreau645513a2010-05-24 20:55:15 +02001242
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001243/* parse the "accept-proxy" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001244static 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 +02001245{
1246 struct listener *l;
1247
Willy Tarreau4348fad2012-09-20 16:48:07 +02001248 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001249 l->options |= LI_O_ACC_PROXY;
1250
1251 return 0;
1252}
1253
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001254/* parse the "accept-netscaler-cip" bind keyword */
1255static int bind_parse_accept_netscaler_cip(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1256{
1257 struct listener *l;
1258 uint32_t val;
1259
1260 if (!*args[cur_arg + 1]) {
1261 memprintf(err, "'%s' : missing value", args[cur_arg]);
1262 return ERR_ALERT | ERR_FATAL;
1263 }
1264
1265 val = atol(args[cur_arg + 1]);
1266 if (val <= 0) {
Willy Tarreaue2711c72019-02-27 15:39:41 +01001267 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001268 return ERR_ALERT | ERR_FATAL;
1269 }
1270
1271 list_for_each_entry(l, &conf->listeners, by_bind) {
1272 l->options |= LI_O_ACC_CIP;
1273 conf->ns_cip_magic = val;
1274 }
1275
1276 return 0;
1277}
1278
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001279/* parse the "backlog" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001280static 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 +02001281{
1282 struct listener *l;
1283 int val;
1284
1285 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001286 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001287 return ERR_ALERT | ERR_FATAL;
1288 }
1289
1290 val = atol(args[cur_arg + 1]);
Willy Tarreaue2711c72019-02-27 15:39:41 +01001291 if (val < 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001292 memprintf(err, "'%s' : invalid value %d, must be > 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001293 return ERR_ALERT | ERR_FATAL;
1294 }
1295
Willy Tarreau4348fad2012-09-20 16:48:07 +02001296 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001297 l->backlog = val;
1298
1299 return 0;
1300}
1301
1302/* parse the "id" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001303static 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 +02001304{
1305 struct eb32_node *node;
Willy Tarreau4348fad2012-09-20 16:48:07 +02001306 struct listener *l, *new;
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001307 char *error;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001308
Willy Tarreau4348fad2012-09-20 16:48:07 +02001309 if (conf->listeners.n != conf->listeners.p) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001310 memprintf(err, "'%s' can only be used with a single socket", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001311 return ERR_ALERT | ERR_FATAL;
1312 }
1313
1314 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001315 memprintf(err, "'%s' : expects an integer argument", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001316 return ERR_ALERT | ERR_FATAL;
1317 }
1318
Willy Tarreau4348fad2012-09-20 16:48:07 +02001319 new = LIST_NEXT(&conf->listeners, struct listener *, by_bind);
Thierry Fourniere7fe8eb2016-02-26 08:45:58 +01001320 new->luid = strtol(args[cur_arg + 1], &error, 10);
1321 if (*error != '\0') {
1322 memprintf(err, "'%s' : expects an integer argument, found '%s'", args[cur_arg], args[cur_arg + 1]);
1323 return ERR_ALERT | ERR_FATAL;
1324 }
Willy Tarreau4348fad2012-09-20 16:48:07 +02001325 new->conf.id.key = new->luid;
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001326
Willy Tarreau4348fad2012-09-20 16:48:07 +02001327 if (new->luid <= 0) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001328 memprintf(err, "'%s' : custom id has to be > 0", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001329 return ERR_ALERT | ERR_FATAL;
1330 }
1331
Willy Tarreau4348fad2012-09-20 16:48:07 +02001332 node = eb32_lookup(&px->conf.used_listener_id, new->luid);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001333 if (node) {
1334 l = container_of(node, struct listener, conf.id);
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001335 memprintf(err, "'%s' : custom id %d already used at %s:%d ('bind %s')",
1336 args[cur_arg], l->luid, l->bind_conf->file, l->bind_conf->line,
1337 l->bind_conf->arg);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001338 return ERR_ALERT | ERR_FATAL;
1339 }
1340
Willy Tarreau4348fad2012-09-20 16:48:07 +02001341 eb32_insert(&px->conf.used_listener_id, &new->conf.id);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001342 return 0;
1343}
1344
1345/* parse the "maxconn" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001346static 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 +02001347{
1348 struct listener *l;
1349 int val;
1350
1351 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001352 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001353 return ERR_ALERT | ERR_FATAL;
1354 }
1355
1356 val = atol(args[cur_arg + 1]);
Willy Tarreaua8cf66b2019-02-27 16:49:00 +01001357 if (val < 0) {
1358 memprintf(err, "'%s' : invalid value %d, must be >= 0", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001359 return ERR_ALERT | ERR_FATAL;
1360 }
1361
Willy Tarreau4348fad2012-09-20 16:48:07 +02001362 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001363 l->maxconn = val;
1364
1365 return 0;
1366}
1367
1368/* parse the "name" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001369static 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 +02001370{
1371 struct listener *l;
1372
1373 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001374 memprintf(err, "'%s' : missing name", args[cur_arg]);
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->name = strdup(args[cur_arg + 1]);
1380
1381 return 0;
1382}
1383
1384/* parse the "nice" bind keyword */
Willy Tarreau4348fad2012-09-20 16:48:07 +02001385static 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 +02001386{
1387 struct listener *l;
1388 int val;
1389
1390 if (!*args[cur_arg + 1]) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001391 memprintf(err, "'%s' : missing value", args[cur_arg]);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001392 return ERR_ALERT | ERR_FATAL;
1393 }
1394
1395 val = atol(args[cur_arg + 1]);
1396 if (val < -1024 || val > 1024) {
Willy Tarreaueb6cead2012-09-20 19:43:14 +02001397 memprintf(err, "'%s' : invalid value %d, allowed range is -1024..1024", args[cur_arg], val);
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001398 return ERR_ALERT | ERR_FATAL;
1399 }
1400
Willy Tarreau4348fad2012-09-20 16:48:07 +02001401 list_for_each_entry(l, &conf->listeners, by_bind)
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001402 l->nice = val;
1403
1404 return 0;
1405}
1406
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001407/* parse the "process" bind keyword */
1408static int bind_parse_process(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1409{
Christopher Fauletc644fa92017-11-23 22:44:11 +01001410 char *slash;
1411 unsigned long proc = 0, thread = 0;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001412
Christopher Fauletc644fa92017-11-23 22:44:11 +01001413 if ((slash = strchr(args[cur_arg + 1], '/')) != NULL)
1414 *slash = 0;
1415
Willy Tarreauff9c9142019-02-07 10:39:36 +01001416 if (parse_process_number(args[cur_arg + 1], &proc, MAX_PROCS, NULL, err)) {
Christopher Fauletf1f0c5f2017-11-22 12:06:43 +01001417 memprintf(err, "'%s' : %s", args[cur_arg], *err);
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001418 return ERR_ALERT | ERR_FATAL;
1419 }
1420
Christopher Fauletc644fa92017-11-23 22:44:11 +01001421 if (slash) {
Willy Tarreauc9a82e42019-01-26 13:25:14 +01001422 if (parse_process_number(slash+1, &thread, MAX_THREADS, NULL, err)) {
Christopher Fauletc644fa92017-11-23 22:44:11 +01001423 memprintf(err, "'%s' : %s", args[cur_arg], *err);
1424 return ERR_ALERT | ERR_FATAL;
1425 }
1426 *slash = '/';
1427 }
1428
1429 conf->bind_proc |= proc;
Willy Tarreaua36b3242019-02-02 13:14:34 +01001430 conf->bind_thread |= thread;
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001431 return 0;
1432}
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001433
Christopher Fauleta717b992018-04-10 14:43:00 +02001434/* parse the "proto" bind keyword */
1435static int bind_parse_proto(char **args, int cur_arg, struct proxy *px, struct bind_conf *conf, char **err)
1436{
1437 struct ist proto;
1438
1439 if (!*args[cur_arg + 1]) {
1440 memprintf(err, "'%s' : missing value", args[cur_arg]);
1441 return ERR_ALERT | ERR_FATAL;
1442 }
1443
1444 proto = ist2(args[cur_arg + 1], strlen(args[cur_arg + 1]));
1445 conf->mux_proto = get_mux_proto(proto);
1446 if (!conf->mux_proto) {
1447 memprintf(err, "'%s' : unknown MUX protocol '%s'", args[cur_arg], args[cur_arg+1]);
1448 return ERR_ALERT | ERR_FATAL;
1449 }
Christopher Fauleta717b992018-04-10 14:43:00 +02001450 return 0;
1451}
1452
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001453/* config parser for global "tune.listener.multi-queue", accepts "on" or "off" */
1454static int cfg_parse_tune_listener_mq(char **args, int section_type, struct proxy *curpx,
1455 struct proxy *defpx, const char *file, int line,
1456 char **err)
1457{
1458 if (too_many_args(1, args, err, NULL))
1459 return -1;
1460
1461 if (strcmp(args[1], "on") == 0)
1462 global.tune.options |= GTUNE_LISTENER_MQ;
1463 else if (strcmp(args[1], "off") == 0)
1464 global.tune.options &= ~GTUNE_LISTENER_MQ;
1465 else {
1466 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
1467 return -1;
1468 }
1469 return 0;
1470}
1471
Willy Tarreau61612d42012-04-19 18:42:05 +02001472/* Note: must not be declared <const> as its list will be overwritten.
1473 * Please take care of keeping this list alphabetically sorted.
1474 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001475static struct sample_fetch_kw_list smp_kws = {ILH, {
Thierry FOURNIER07ee64e2015-07-06 23:43:03 +02001476 { "dst_conn", smp_fetch_dconn, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
1477 { "so_id", smp_fetch_so_id, 0, NULL, SMP_T_SINT, SMP_USE_FTEND, },
Jerome Magnin28b90332020-03-27 22:08:40 +01001478 { "so_name", smp_fetch_so_name, 0, NULL, SMP_T_STR, SMP_USE_FTEND, },
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001479 { /* END */ },
1480}};
1481
Willy Tarreau0108d902018-11-25 19:14:37 +01001482INITCALL1(STG_REGISTER, sample_register_fetches, &smp_kws);
1483
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001484/* Note: must not be declared <const> as its list will be overwritten.
1485 * Please take care of keeping this list alphabetically sorted.
1486 */
Willy Tarreaudc13c112013-06-21 23:16:39 +02001487static struct acl_kw_list acl_kws = {ILH, {
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001488 { /* END */ },
Willy Tarreau645513a2010-05-24 20:55:15 +02001489}};
1490
Willy Tarreau0108d902018-11-25 19:14:37 +01001491INITCALL1(STG_REGISTER, acl_register_keywords, &acl_kws);
1492
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001493/* Note: must not be declared <const> as its list will be overwritten.
1494 * Please take care of keeping this list alphabetically sorted, doing so helps
1495 * all code contributors.
1496 * Optional keywords are also declared with a NULL ->parse() function so that
1497 * the config parser can report an appropriate error when a known keyword was
1498 * not enabled.
1499 */
Willy Tarreau51fb7652012-09-18 18:24:39 +02001500static struct bind_kw_list bind_kws = { "ALL", { }, {
Bertrand Jacquin93b227d2016-06-04 15:11:10 +01001501 { "accept-netscaler-cip", bind_parse_accept_netscaler_cip, 1 }, /* enable NetScaler Client IP insertion protocol */
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001502 { "accept-proxy", bind_parse_accept_proxy, 0 }, /* enable PROXY protocol */
1503 { "backlog", bind_parse_backlog, 1 }, /* set backlog of listening socket */
1504 { "id", bind_parse_id, 1 }, /* set id of listening socket */
1505 { "maxconn", bind_parse_maxconn, 1 }, /* set maxconn of listening socket */
1506 { "name", bind_parse_name, 1 }, /* set name of listening socket */
1507 { "nice", bind_parse_nice, 1 }, /* set nice of listening socket */
Willy Tarreau6ae1ba62014-05-07 19:01:58 +02001508 { "process", bind_parse_process, 1 }, /* set list of allowed process for this socket */
Christopher Fauleta717b992018-04-10 14:43:00 +02001509 { "proto", bind_parse_proto, 1 }, /* set the proto to use for all incoming connections */
Willy Tarreau0ccb7442013-01-07 22:54:17 +01001510 { /* END */ },
Willy Tarreau3dcc3412012-09-18 17:17:28 +02001511}};
1512
Willy Tarreau0108d902018-11-25 19:14:37 +01001513INITCALL1(STG_REGISTER, bind_register_keywords, &bind_kws);
1514
Willy Tarreau7ac908b2019-02-27 12:02:18 +01001515/* config keyword parsers */
1516static struct cfg_kw_list cfg_kws = {ILH, {
1517 { CFG_GLOBAL, "tune.listener.multi-queue", cfg_parse_tune_listener_mq },
1518 { 0, NULL, NULL }
1519}};
1520
1521INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
1522
Willy Tarreau645513a2010-05-24 20:55:15 +02001523/*
1524 * Local variables:
1525 * c-indent-level: 8
1526 * c-basic-offset: 8
1527 * End:
1528 */