blob: 3c9629ffce04a7cfb4e169a546c568650c0b0433 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
2 * File descriptors management functions.
3 *
Willy Tarreauf817e9f2014-01-10 16:58:45 +01004 * Copyright 2000-2014 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +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 *
Willy Tarreau7be79a42012-11-11 15:02:54 +010011 * There is no direct link between the FD and the updates list. There is only a
12 * bit in the fdtab[] to indicate than a file descriptor is already present in
13 * the updates list. Once an fd is present in the updates list, it will have to
14 * be considered even if its changes are reverted in the middle or if the fd is
15 * replaced.
16 *
Willy Tarreauf817e9f2014-01-10 16:58:45 +010017 * The event state for an FD, as found in fdtab[].state, is maintained for each
18 * direction. The state field is built this way, with R bits in the low nibble
19 * and W bits in the high nibble for ease of access and debugging :
Willy Tarreau7be79a42012-11-11 15:02:54 +010020 *
Willy Tarreauf817e9f2014-01-10 16:58:45 +010021 * 7 6 5 4 3 2 1 0
Willy Tarreau5bee3e22019-09-04 09:52:57 +020022 * [ 0 | 0 | RW | AW | 0 | 0 | RR | AR ]
Willy Tarreauf817e9f2014-01-10 16:58:45 +010023 *
24 * A* = active *R = read
Willy Tarreau5bee3e22019-09-04 09:52:57 +020025 * R* = ready *W = write
Willy Tarreauf817e9f2014-01-10 16:58:45 +010026 *
27 * An FD is marked "active" when there is a desire to use it.
Willy Tarreauf817e9f2014-01-10 16:58:45 +010028 * An FD is marked "ready" when it has not faced a new EAGAIN since last wake-up
Willy Tarreau5bee3e22019-09-04 09:52:57 +020029 * (it is a cache of the last EAGAIN regardless of polling changes). Each poller
30 * has its own "polled" state for the same fd, as stored in the polled_mask.
Willy Tarreau7be79a42012-11-11 15:02:54 +010031 *
Willy Tarreau5bee3e22019-09-04 09:52:57 +020032 * We have 4 possible states for each direction based on these 2 flags :
Willy Tarreau7be79a42012-11-11 15:02:54 +010033 *
Willy Tarreau5bee3e22019-09-04 09:52:57 +020034 * +---+---+----------+---------------------------------------------+
35 * | R | A | State | Description |
36 * +---+---+----------+---------------------------------------------+
37 * | 0 | 0 | DISABLED | No activity desired, not ready. |
38 * | 0 | 1 | ACTIVE | Activity desired. |
39 * | 1 | 0 | STOPPED | End of activity. |
40 * | 1 | 1 | READY | Activity desired and reported. |
41 * +---+---+----------+---------------------------------------------+
Willy Tarreau7be79a42012-11-11 15:02:54 +010042 *
Willy Tarreauf817e9f2014-01-10 16:58:45 +010043 * The transitions are pretty simple :
44 * - fd_want_*() : set flag A
45 * - fd_stop_*() : clear flag A
46 * - fd_cant_*() : clear flag R (when facing EAGAIN)
47 * - fd_may_*() : set flag R (upon return from poll())
Willy Tarreauf817e9f2014-01-10 16:58:45 +010048 *
Willy Tarreau5bee3e22019-09-04 09:52:57 +020049 * Each poller then computes its own polled state :
50 * if (A) { if (!R) P := 1 } else { P := 0 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +010051 *
Willy Tarreau5bee3e22019-09-04 09:52:57 +020052 * The state transitions look like the diagram below.
Willy Tarreauf817e9f2014-01-10 16:58:45 +010053 *
Willy Tarreau5bee3e22019-09-04 09:52:57 +020054 * may +----------+
55 * ,----| DISABLED | (READY=0, ACTIVE=0)
56 * | +----------+
57 * | want | ^
58 * | | |
59 * | v | stop
60 * | +----------+
61 * | | ACTIVE | (READY=0, ACTIVE=1)
62 * | +----------+
63 * | | ^
64 * | may | |
Thayne McCombs8f0cc5c2021-01-07 21:35:52 -070065 * | v | EAGAIN (can't)
Willy Tarreau5bee3e22019-09-04 09:52:57 +020066 * | +--------+
67 * | | READY | (READY=1, ACTIVE=1)
68 * | +--------+
69 * | stop | ^
70 * | | |
71 * | v | want
72 * | +---------+
73 * `--->| STOPPED | (READY=1, ACTIVE=0)
74 * +---------+
Willy Tarreaubaaee002006-06-26 02:48:02 +020075 */
76
Willy Tarreau2ff76222007-04-09 19:29:56 +020077#include <stdio.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020078#include <string.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020079#include <unistd.h>
Olivier Houchard79321b92018-07-26 17:55:11 +020080#include <fcntl.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020081#include <sys/types.h>
Willy Tarreau2d7f81b2019-02-21 22:19:17 +010082#include <sys/resource.h>
Willy Tarreau931d8b72019-08-27 11:08:17 +020083#include <sys/uio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020084
Willy Tarreaue5733232019-05-22 19:24:06 +020085#if defined(USE_POLL)
Willy Tarreau9188ac62019-02-21 22:12:47 +010086#include <poll.h>
87#include <errno.h>
88#endif
89
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020090#include <haproxy/api.h>
Willy Tarreaubc52bec2020-06-18 08:58:47 +020091#include <haproxy/cfgparse.h>
Willy Tarreau0f6ffd62020-06-03 19:33:00 +020092#include <haproxy/fd.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020093#include <haproxy/global.h>
Willy Tarreauc28aab02021-05-08 20:35:03 +020094#include <haproxy/log.h>
Willy Tarreaufc8f6a82020-06-03 19:20:59 +020095#include <haproxy/port_range.h>
Willy Tarreaubc52bec2020-06-18 08:58:47 +020096#include <haproxy/tools.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020097
Willy Tarreaub2551052020-06-09 09:07:15 +020098
Willy Tarreaua1090a52021-04-10 16:58:13 +020099struct fdtab *fdtab __read_mostly = NULL; /* array of all the file descriptors */
100struct polled_mask *polled_mask __read_mostly = NULL; /* Array for the polled_mask of each fd */
101struct fdinfo *fdinfo __read_mostly = NULL; /* less-often used infos for file descriptors */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200102int totalconn; /* total # of terminated sessions */
103int actconn; /* # of active sessions */
104
Willy Tarreaua1090a52021-04-10 16:58:13 +0200105struct poller pollers[MAX_POLLERS] __read_mostly;
106struct poller cur_poller __read_mostly;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200107int nbpollers = 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200108
Olivier Houchard6b96f722018-04-25 16:58:25 +0200109volatile struct fdlist update_list; // Global update list
Olivier Houchard4815c8c2018-01-24 18:17:56 +0100110
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200111THREAD_LOCAL int *fd_updt = NULL; // FD updates list
112THREAD_LOCAL int fd_nbupdt = 0; // number of updates in the list
Olivier Houchard79321b92018-07-26 17:55:11 +0200113THREAD_LOCAL int poller_rd_pipe = -1; // Pipe to wake the thread
Willy Tarreaua1090a52021-04-10 16:58:13 +0200114int poller_wr_pipe[MAX_THREADS] __read_mostly; // Pipe to wake the threads
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200115
Olivier Houchard7c49d2e2019-04-16 18:37:05 +0200116volatile int ha_used_fds = 0; // Number of FD we're currently using
Willy Tarreau8c3c0962022-01-27 16:10:48 +0100117static struct fdtab *fdtab_addr; /* address of the allocated area containing fdtab */
Olivier Houchard7c49d2e2019-04-16 18:37:05 +0200118
Willy Tarreau337fb712019-12-20 07:20:00 +0100119#define _GET_NEXT(fd, off) ((volatile struct fdlist_entry *)(void *)((char *)(&fdtab[fd]) + off))->next
120#define _GET_PREV(fd, off) ((volatile struct fdlist_entry *)(void *)((char *)(&fdtab[fd]) + off))->prev
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100121/* adds fd <fd> to fd list <list> if it was not yet in it */
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200122void fd_add_to_fd_list(volatile struct fdlist *list, int fd, int off)
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100123{
124 int next;
125 int new;
126 int old;
127 int last;
128
129redo_next:
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200130 next = _GET_NEXT(fd, off);
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100131 /* Check that we're not already in the cache, and if not, lock us. */
Olivier Houchardfc51f0f52019-12-19 18:33:08 +0100132 if (next > -2)
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100133 goto done;
Olivier Houchardfc51f0f52019-12-19 18:33:08 +0100134 if (next == -2)
135 goto redo_next;
Olivier Houchardd3608792019-03-08 18:47:42 +0100136 if (!_HA_ATOMIC_CAS(&_GET_NEXT(fd, off), &next, -2))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100137 goto redo_next;
Olivier Houchardd2b5d162019-03-08 13:47:21 +0100138 __ha_barrier_atomic_store();
Willy Tarreau11559a72018-02-05 17:52:24 +0100139
140 new = fd;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100141redo_last:
142 /* First, insert in the linked list */
143 last = list->last;
144 old = -1;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100145
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200146 _GET_PREV(fd, off) = -2;
Willy Tarreau11559a72018-02-05 17:52:24 +0100147 /* Make sure the "prev" store is visible before we update the last entry */
148 __ha_barrier_store();
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100149
Willy Tarreau11559a72018-02-05 17:52:24 +0100150 if (unlikely(last == -1)) {
151 /* list is empty, try to add ourselves alone so that list->last=fd */
Olivier Houchardd3608792019-03-08 18:47:42 +0100152 if (unlikely(!_HA_ATOMIC_CAS(&list->last, &old, new)))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100153 goto redo_last;
154
155 /* list->first was necessary -1, we're guaranteed to be alone here */
156 list->first = fd;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100157 } else {
Willy Tarreau11559a72018-02-05 17:52:24 +0100158 /* adding ourselves past the last element
159 * The CAS will only succeed if its next is -1,
160 * which means it's in the cache, and the last element.
161 */
Olivier Houchardd3608792019-03-08 18:47:42 +0100162 if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(last, off), &old, new)))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100163 goto redo_last;
Willy Tarreau11559a72018-02-05 17:52:24 +0100164
165 /* Then, update the last entry */
166 list->last = fd;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100167 }
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100168 __ha_barrier_store();
Willy Tarreau11559a72018-02-05 17:52:24 +0100169 /* since we're alone at the end of the list and still locked(-2),
Ilya Shipitsinb8888ab2021-01-06 21:20:16 +0500170 * we know no one tried to add past us. Mark the end of list.
Willy Tarreau11559a72018-02-05 17:52:24 +0100171 */
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200172 _GET_PREV(fd, off) = last;
173 _GET_NEXT(fd, off) = -1;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100174 __ha_barrier_store();
175done:
176 return;
177}
178
179/* removes fd <fd> from fd list <list> */
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200180void fd_rm_from_fd_list(volatile struct fdlist *list, int fd, int off)
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100181{
182#if defined(HA_HAVE_CAS_DW) || defined(HA_CAS_IS_8B)
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100183 volatile union {
184 struct fdlist_entry ent;
185 uint64_t u64;
186 uint32_t u32[2];
187 } cur_list, next_list;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100188#endif
189 int old;
190 int new = -2;
191 int prev;
192 int next;
193 int last;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100194lock_self:
195#if (defined(HA_CAS_IS_8B) || defined(HA_HAVE_CAS_DW))
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100196 next_list.ent.next = next_list.ent.prev = -2;
197 cur_list.ent = *(volatile struct fdlist_entry *)(((char *)&fdtab[fd]) + off);
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100198 /* First, attempt to lock our own entries */
199 do {
200 /* The FD is not in the FD cache, give up */
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100201 if (unlikely(cur_list.ent.next <= -3))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100202 return;
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100203 if (unlikely(cur_list.ent.prev == -2 || cur_list.ent.next == -2))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100204 goto lock_self;
205 } while (
206#ifdef HA_CAS_IS_8B
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100207 unlikely(!_HA_ATOMIC_CAS(((uint64_t *)&_GET_NEXT(fd, off)), (uint64_t *)&cur_list.u64, next_list.u64))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100208#else
Willy Tarreau9cc5fb42022-09-17 11:15:29 +0200209 unlikely(!_HA_ATOMIC_DWCAS(((long *)&_GET_NEXT(fd, off)), (uint32_t *)&cur_list.u32, (const uint32_t *)&next_list.u32))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100210#endif
Willy Tarreau2b9f0662020-02-25 09:25:53 +0100211 );
212 next = cur_list.ent.next;
213 prev = cur_list.ent.prev;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100214
215#else
216lock_self_next:
Willy Tarreau337fb712019-12-20 07:20:00 +0100217 next = _GET_NEXT(fd, off);
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100218 if (next == -2)
219 goto lock_self_next;
220 if (next <= -3)
221 goto done;
Olivier Houchardd3608792019-03-08 18:47:42 +0100222 if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(fd, off), &next, -2)))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100223 goto lock_self_next;
224lock_self_prev:
Willy Tarreau337fb712019-12-20 07:20:00 +0100225 prev = _GET_PREV(fd, off);
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100226 if (prev == -2)
227 goto lock_self_prev;
Olivier Houchardd3608792019-03-08 18:47:42 +0100228 if (unlikely(!_HA_ATOMIC_CAS(&_GET_PREV(fd, off), &prev, -2)))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100229 goto lock_self_prev;
230#endif
Olivier Houchardd2b5d162019-03-08 13:47:21 +0100231 __ha_barrier_atomic_store();
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100232
233 /* Now, lock the entries of our neighbours */
234 if (likely(prev != -1)) {
235redo_prev:
236 old = fd;
237
Olivier Houchardd3608792019-03-08 18:47:42 +0100238 if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(prev, off), &old, new))) {
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100239 if (unlikely(old == -2)) {
240 /* Neighbour already locked, give up and
241 * retry again once he's done
242 */
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200243 _GET_PREV(fd, off) = prev;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100244 __ha_barrier_store();
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200245 _GET_NEXT(fd, off) = next;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100246 __ha_barrier_store();
247 goto lock_self;
248 }
249 goto redo_prev;
250 }
251 }
252 if (likely(next != -1)) {
253redo_next:
254 old = fd;
Olivier Houchardd3608792019-03-08 18:47:42 +0100255 if (unlikely(!_HA_ATOMIC_CAS(&_GET_PREV(next, off), &old, new))) {
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100256 if (unlikely(old == -2)) {
257 /* Neighbour already locked, give up and
258 * retry again once he's done
259 */
260 if (prev != -1) {
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200261 _GET_NEXT(prev, off) = fd;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100262 __ha_barrier_store();
263 }
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200264 _GET_PREV(fd, off) = prev;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100265 __ha_barrier_store();
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200266 _GET_NEXT(fd, off) = next;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100267 __ha_barrier_store();
268 goto lock_self;
269 }
270 goto redo_next;
271 }
272 }
273 if (list->first == fd)
274 list->first = next;
275 __ha_barrier_store();
276 last = list->last;
Olivier Houchardd3608792019-03-08 18:47:42 +0100277 while (unlikely(last == fd && (!_HA_ATOMIC_CAS(&list->last, &last, prev))))
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100278 __ha_compiler_barrier();
279 /* Make sure we let other threads know we're no longer in cache,
280 * before releasing our neighbours.
281 */
282 __ha_barrier_store();
283 if (likely(prev != -1))
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200284 _GET_NEXT(prev, off) = next;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100285 __ha_barrier_store();
286 if (likely(next != -1))
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200287 _GET_PREV(next, off) = prev;
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100288 __ha_barrier_store();
289 /* Ok, now we're out of the fd cache */
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200290 _GET_NEXT(fd, off) = -(next + 4);
Willy Tarreau4cc67a22018-02-05 17:14:55 +0100291 __ha_barrier_store();
292done:
293 return;
294}
295
Olivier Houchard6a2cf872018-04-25 15:10:30 +0200296#undef _GET_NEXT
297#undef _GET_PREV
298
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100299/* deletes the FD once nobody uses it anymore, as detected by the caller by its
300 * thread_mask being zero and its running mask turning to zero. There is no
301 * protection against concurrent accesses, it's up to the caller to make sure
302 * only the last thread will call it. This is only for internal use, please use
303 * fd_delete() instead.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200304 */
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100305void _fd_delete_orphan(int fd)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200306{
Emeric Brun1dee3ec2022-07-01 17:31:25 +0200307 uint fd_disown;
308
309 fd_disown = fdtab[fd].state & FD_DISOWN;
Willy Tarreaub41a6e92021-04-06 17:49:19 +0200310 if (fdtab[fd].state & FD_LINGER_RISK) {
Willy Tarreauad38ace2013-12-15 14:19:38 +0100311 /* this is generally set when connecting to servers */
Ilya Shipitsinb7e43f02020-04-02 15:02:08 +0500312 DISGUISE(setsockopt(fd, SOL_SOCKET, SO_LINGER,
313 (struct linger *) &nolinger, sizeof(struct linger)));
Willy Tarreauad38ace2013-12-15 14:19:38 +0100314 }
Willy Tarreau6ea20b12012-11-11 16:05:19 +0100315 if (cur_poller.clo)
316 cur_poller.clo(fd);
Willy Tarreau2d423292021-03-24 15:34:25 +0100317
318 port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port);
Olivier Houchardc22580c2019-08-05 18:51:52 +0200319 polled_mask[fd].poll_recv = polled_mask[fd].poll_send = 0;
Willy Tarreau6ea20b12012-11-11 16:05:19 +0100320
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100321 fdtab[fd].state = 0;
Willy Tarreau6ea20b12012-11-11 16:05:19 +0100322
Willy Tarreau38e8a1c2020-06-23 10:04:54 +0200323#ifdef DEBUG_FD
324 fdtab[fd].event_count = 0;
325#endif
Willy Tarreau8d5d77e2009-10-18 07:25:52 +0200326 fdinfo[fd].port_range = NULL;
Willy Tarreaudb3b3262012-07-05 23:19:22 +0200327 fdtab[fd].owner = NULL;
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100328 /* perform the close() call last as it's what unlocks the instant reuse
329 * of this FD by any other thread.
330 */
Emeric Brun1dee3ec2022-07-01 17:31:25 +0200331 if (!fd_disown)
332 close(fd);
Willy Tarreau4781b152021-04-06 13:53:36 +0200333 _HA_ATOMIC_DEC(&ha_used_fds);
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100334}
335
Olivier Houchardc23b3372021-03-25 01:38:54 +0100336#ifndef HA_HAVE_CAS_DW
337__decl_thread(__decl_rwlock(fd_mig_lock));
338#endif
339
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100340/* Deletes an FD from the fdsets. The file descriptor is also closed, possibly
341 * asynchronously. Only the owning thread may do this.
342 */
343void fd_delete(int fd)
344{
345 /* we must postpone removal of an FD that may currently be in use
Ilya Shipitsinb2be9a12021-04-24 13:25:42 +0500346 * by another thread. This can happen in the following two situations:
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100347 * - after a takeover, the owning thread closes the connection but
348 * the previous one just woke up from the poller and entered
349 * the FD handler iocb. That thread holds an entry in running_mask
350 * and requires removal protection.
351 * - multiple threads are accepting connections on a listener, and
352 * one of them (or even an separate one) decides to unbind the
353 * listener under the listener's lock while other ones still hold
354 * the running bit.
355 * In both situations the FD is marked as unused (thread_mask = 0) and
356 * will not take new bits in its running_mask so we have the guarantee
357 * that the last thread eliminating running_mask is the one allowed to
358 * safely delete the FD. Most of the time it will be the current thread.
359 */
360
361 HA_ATOMIC_OR(&fdtab[fd].running_mask, tid_bit);
Olivier Houchardc23b3372021-03-25 01:38:54 +0100362#ifndef HA_HAVE_CAS_DW
363 HA_RWLOCK_WRLOCK(OTHER_LOCK, &fd_mig_lock);
364#endif
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100365 HA_ATOMIC_STORE(&fdtab[fd].thread_mask, 0);
Olivier Houchardc23b3372021-03-25 01:38:54 +0100366#ifndef HA_HAVE_CAS_DW
367 HA_RWLOCK_WRUNLOCK(OTHER_LOCK, &fd_mig_lock);
368#endif
Willy Tarreau2c3f9812021-03-24 10:51:32 +0100369 if (fd_clr_running(fd) == 0)
370 _fd_delete_orphan(fd);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200371}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200372
Olivier Houchard88516642020-03-05 18:10:51 +0100373/*
374 * Take over a FD belonging to another thread.
375 * unexpected_conn is the expected owner of the fd.
376 * Returns 0 on success, and -1 on failure.
377 */
378int fd_takeover(int fd, void *expected_owner)
379{
Willy Tarreauc460c912020-06-18 07:28:09 +0200380 int ret = -1;
Olivier Houchard88516642020-03-05 18:10:51 +0100381
Willy Tarreauf1cad382020-06-18 08:14:59 +0200382#ifndef HA_HAVE_CAS_DW
Willy Tarreau1db42732021-04-06 11:44:07 +0200383 if (_HA_ATOMIC_OR_FETCH(&fdtab[fd].running_mask, tid_bit) == tid_bit) {
Willy Tarreauc460c912020-06-18 07:28:09 +0200384 HA_RWLOCK_WRLOCK(OTHER_LOCK, &fd_mig_lock);
385 if (fdtab[fd].owner == expected_owner) {
386 fdtab[fd].thread_mask = tid_bit;
387 ret = 0;
388 }
389 HA_RWLOCK_WRUNLOCK(OTHER_LOCK, &fd_mig_lock);
Olivier Houchard88516642020-03-05 18:10:51 +0100390 }
Olivier Houchard88516642020-03-05 18:10:51 +0100391#else
392 unsigned long old_masks[2];
393 unsigned long new_masks[2];
394
Olivier Houchard88516642020-03-05 18:10:51 +0100395 new_masks[0] = new_masks[1] = tid_bit;
Willy Tarreau42973632020-06-18 08:05:15 +0200396
Willy Tarreau1db42732021-04-06 11:44:07 +0200397 old_masks[0] = _HA_ATOMIC_OR_FETCH(&fdtab[fd].running_mask, tid_bit);
Willy Tarreau42973632020-06-18 08:05:15 +0200398 old_masks[1] = fdtab[fd].thread_mask;
399
Olivier Houchard88516642020-03-05 18:10:51 +0100400 /* protect ourself against a delete then an insert for the same fd,
401 * if it happens, then the owner will no longer be the expected
402 * connection.
403 */
Willy Tarreauf1cad382020-06-18 08:14:59 +0200404 if (fdtab[fd].owner == expected_owner) {
405 while (old_masks[0] == tid_bit && old_masks[1]) {
406 if (_HA_ATOMIC_DWCAS(&fdtab[fd].running_mask, &old_masks, &new_masks)) {
407 ret = 0;
408 break;
409 }
Olivier Houchard88516642020-03-05 18:10:51 +0100410 }
Willy Tarreauf1cad382020-06-18 08:14:59 +0200411 }
412#endif /* HW_HAVE_CAS_DW */
413
Olivier Houchard88516642020-03-05 18:10:51 +0100414 _HA_ATOMIC_AND(&fdtab[fd].running_mask, ~tid_bit);
Willy Tarreauf1cad382020-06-18 08:14:59 +0200415
Olivier Houchardddc874c2020-06-17 20:34:05 +0200416 /* Make sure the FD doesn't have the active bit. It is possible that
417 * the fd is polled by the thread that used to own it, the new thread
418 * is supposed to call subscribe() later, to activate polling.
419 */
Willy Tarreauf1cad382020-06-18 08:14:59 +0200420 if (likely(ret == 0))
421 fd_stop_recv(fd);
422 return ret;
Olivier Houchard88516642020-03-05 18:10:51 +0100423}
424
Willy Tarreaudbe30602019-09-04 13:25:41 +0200425void updt_fd_polling(const int fd)
426{
Willy Tarreau5a7d6eb2020-11-26 22:25:10 +0100427 if (all_threads_mask == 1UL || (fdtab[fd].thread_mask & all_threads_mask) == tid_bit) {
Willy Tarreaudbe30602019-09-04 13:25:41 +0200428 if (HA_ATOMIC_BTS(&fdtab[fd].update_mask, tid))
429 return;
430
431 fd_updt[fd_nbupdt++] = fd;
432 } else {
433 unsigned long update_mask = fdtab[fd].update_mask;
434 do {
435 if (update_mask == fdtab[fd].thread_mask)
436 return;
Willy Tarreauf0158872020-09-25 12:18:53 +0200437 } while (!_HA_ATOMIC_CAS(&fdtab[fd].update_mask, &update_mask, fdtab[fd].thread_mask));
438
Willy Tarreaudbe30602019-09-04 13:25:41 +0200439 fd_add_to_fd_list(&update_list, fd, offsetof(struct fdtab, update));
Willy Tarreauf0158872020-09-25 12:18:53 +0200440
441 if (fd_active(fd) &&
442 !(fdtab[fd].thread_mask & tid_bit) &&
443 (fdtab[fd].thread_mask & ~tid_bit & all_threads_mask & ~sleeping_thread_mask) == 0) {
444 /* we need to wake up one thread to handle it immediately */
445 int thr = my_ffsl(fdtab[fd].thread_mask & ~tid_bit & all_threads_mask) - 1;
446
447 _HA_ATOMIC_AND(&sleeping_thread_mask, ~(1UL << thr));
448 wake_thread(thr);
449 }
Willy Tarreaudbe30602019-09-04 13:25:41 +0200450 }
451}
452
Willy Tarreau931d8b72019-08-27 11:08:17 +0200453/* Tries to send <npfx> parts from <prefix> followed by <nmsg> parts from <msg>
454 * optionally followed by a newline if <nl> is non-null, to file descriptor
455 * <fd>. The message is sent atomically using writev(). It may be truncated to
456 * <maxlen> bytes if <maxlen> is non-null. There is no distinction between the
457 * two lists, it's just a convenience to help the caller prepend some prefixes
458 * when necessary. It takes the fd's lock to make sure no other thread will
459 * write to the same fd in parallel. Returns the number of bytes sent, or <=0
460 * on failure. A limit to 31 total non-empty segments is enforced. The caller
461 * is responsible for taking care of making the fd non-blocking.
462 */
463ssize_t fd_write_frag_line(int fd, size_t maxlen, const struct ist pfx[], size_t npfx, const struct ist msg[], size_t nmsg, int nl)
464{
465 struct iovec iovec[32];
Willy Tarreau931d8b72019-08-27 11:08:17 +0200466 size_t sent = 0;
467 int vec = 0;
Willy Tarreaudf187872020-06-11 14:25:47 +0200468 int attempts = 0;
Willy Tarreau931d8b72019-08-27 11:08:17 +0200469
470 if (!maxlen)
471 maxlen = ~0;
472
473 /* keep one char for a possible trailing '\n' in any case */
474 maxlen--;
475
476 /* make an iovec from the concatenation of all parts of the original
477 * message. Skip empty fields and truncate the whole message to maxlen,
478 * leaving one spare iovec for the '\n'.
479 */
480 while (vec < (sizeof(iovec) / sizeof(iovec[0]) - 1)) {
481 if (!npfx) {
482 pfx = msg;
483 npfx = nmsg;
484 nmsg = 0;
485 if (!npfx)
486 break;
487 }
488
489 iovec[vec].iov_base = pfx->ptr;
490 iovec[vec].iov_len = MIN(maxlen, pfx->len);
491 maxlen -= iovec[vec].iov_len;
Willy Tarreau931d8b72019-08-27 11:08:17 +0200492 if (iovec[vec].iov_len)
493 vec++;
494 pfx++; npfx--;
495 };
496
497 if (nl) {
498 iovec[vec].iov_base = "\n";
499 iovec[vec].iov_len = 1;
500 vec++;
501 }
502
Willy Tarreaudf187872020-06-11 14:25:47 +0200503 /* make sure we never interleave writes and we never block. This means
504 * we prefer to fail on collision than to block. But we don't want to
505 * lose too many logs so we just perform a few lock attempts then give
506 * up.
507 */
508
Willy Tarreau1673c4a2021-04-07 17:36:57 +0200509 while (HA_ATOMIC_BTS(&fdtab[fd].state, FD_EXCL_SYSCALL_BIT)) {
Willy Tarreaudf187872020-06-11 14:25:47 +0200510 if (++attempts >= 200) {
511 /* so that the caller knows the message couldn't be delivered */
512 sent = -1;
513 errno = EAGAIN;
514 goto leave;
515 }
516 ha_thread_relax();
517 }
518
Willy Tarreau0cc61282021-04-06 17:57:12 +0200519 if (unlikely(!(fdtab[fd].state & FD_INITIALIZED))) {
520 HA_ATOMIC_OR(&fdtab[fd].state, FD_INITIALIZED);
Willy Tarreau7e9776a2019-08-30 14:41:47 +0200521 if (!isatty(fd))
522 fcntl(fd, F_SETFL, O_NONBLOCK);
523 }
Willy Tarreau931d8b72019-08-27 11:08:17 +0200524 sent = writev(fd, iovec, vec);
Willy Tarreau1673c4a2021-04-07 17:36:57 +0200525 HA_ATOMIC_BTR(&fdtab[fd].state, FD_EXCL_SYSCALL_BIT);
Willy Tarreau931d8b72019-08-27 11:08:17 +0200526
Willy Tarreaudf187872020-06-11 14:25:47 +0200527 leave:
Willy Tarreau931d8b72019-08-27 11:08:17 +0200528 /* sent > 0 if the message was delivered */
529 return sent;
530}
531
Olivier Houchard2292edf2019-02-25 14:26:54 +0100532#if defined(USE_CLOSEFROM)
533void my_closefrom(int start)
534{
535 closefrom(start);
536}
537
Willy Tarreaue5733232019-05-22 19:24:06 +0200538#elif defined(USE_POLL)
Willy Tarreau9188ac62019-02-21 22:12:47 +0100539/* This is a portable implementation of closefrom(). It closes all open file
540 * descriptors starting at <start> and above. It relies on the fact that poll()
541 * will return POLLNVAL for each invalid (hence close) file descriptor passed
542 * in argument in order to skip them. It acts with batches of FDs and will
543 * typically perform one poll() call per 1024 FDs so the overhead is low in
544 * case all FDs have to be closed.
545 */
546void my_closefrom(int start)
547{
548 struct pollfd poll_events[1024];
549 struct rlimit limit;
550 int nbfds, fd, ret, idx;
551 int step, next;
552
553 if (getrlimit(RLIMIT_NOFILE, &limit) == 0)
554 step = nbfds = limit.rlim_cur;
555 else
556 step = nbfds = 0;
557
558 if (nbfds <= 0) {
559 /* set safe limit */
560 nbfds = 1024;
561 step = 256;
562 }
563
564 if (step > sizeof(poll_events) / sizeof(poll_events[0]))
565 step = sizeof(poll_events) / sizeof(poll_events[0]);
566
567 while (start < nbfds) {
568 next = (start / step + 1) * step;
569
570 for (fd = start; fd < next && fd < nbfds; fd++) {
571 poll_events[fd - start].fd = fd;
572 poll_events[fd - start].events = 0;
573 }
574
575 do {
576 ret = poll(poll_events, fd - start, 0);
577 if (ret >= 0)
578 break;
579 } while (errno == EAGAIN || errno == EINTR || errno == ENOMEM);
580
Willy Tarreaub8e602c2019-02-22 09:07:42 +0100581 if (ret)
582 ret = fd - start;
583
Willy Tarreau9188ac62019-02-21 22:12:47 +0100584 for (idx = 0; idx < ret; idx++) {
585 if (poll_events[idx].revents & POLLNVAL)
586 continue; /* already closed */
587
588 fd = poll_events[idx].fd;
589 close(fd);
590 }
591 start = next;
592 }
593}
594
Willy Tarreaue5733232019-05-22 19:24:06 +0200595#else // defined(USE_POLL)
Willy Tarreau9188ac62019-02-21 22:12:47 +0100596
Willy Tarreau2d7f81b2019-02-21 22:19:17 +0100597/* This is a portable implementation of closefrom(). It closes all open file
598 * descriptors starting at <start> and above. This is a naive version for use
599 * when the operating system provides no alternative.
600 */
601void my_closefrom(int start)
602{
603 struct rlimit limit;
604 int nbfds;
605
606 if (getrlimit(RLIMIT_NOFILE, &limit) == 0)
607 nbfds = limit.rlim_cur;
608 else
609 nbfds = 0;
610
611 if (nbfds <= 0)
612 nbfds = 1024; /* safe limit */
613
614 while (start < nbfds)
615 close(start++);
616}
Willy Tarreaue5733232019-05-22 19:24:06 +0200617#endif // defined(USE_POLL)
Willy Tarreau2d7f81b2019-02-21 22:19:17 +0100618
Willy Tarreau4f60f162007-04-08 16:39:58 +0200619/* disable the specified poller */
620void disable_poller(const char *poller_name)
621{
622 int p;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200623
Willy Tarreau4f60f162007-04-08 16:39:58 +0200624 for (p = 0; p < nbpollers; p++)
625 if (strcmp(pollers[p].name, poller_name) == 0)
626 pollers[p].pref = 0;
627}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200628
Olivier Houchard79321b92018-07-26 17:55:11 +0200629void poller_pipe_io_handler(int fd)
630{
631 char buf[1024];
632 /* Flush the pipe */
633 while (read(fd, buf, sizeof(buf)) > 0);
634 fd_cant_recv(fd);
635}
636
Willy Tarreau082b6282019-05-22 14:42:12 +0200637/* allocate the per-thread fd_updt thus needs to be called early after
638 * thread creation.
639 */
640static int alloc_pollers_per_thread()
641{
642 fd_updt = calloc(global.maxsock, sizeof(*fd_updt));
643 return fd_updt != NULL;
644}
645
646/* Initialize the pollers per thread.*/
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200647static int init_pollers_per_thread()
648{
Olivier Houchard79321b92018-07-26 17:55:11 +0200649 int mypipe[2];
Willy Tarreau082b6282019-05-22 14:42:12 +0200650
651 if (pipe(mypipe) < 0)
Olivier Houchard79321b92018-07-26 17:55:11 +0200652 return 0;
Willy Tarreau082b6282019-05-22 14:42:12 +0200653
Olivier Houchard79321b92018-07-26 17:55:11 +0200654 poller_rd_pipe = mypipe[0];
655 poller_wr_pipe[tid] = mypipe[1];
656 fcntl(poller_rd_pipe, F_SETFL, O_NONBLOCK);
657 fd_insert(poller_rd_pipe, poller_pipe_io_handler, poller_pipe_io_handler,
658 tid_bit);
659 fd_want_recv(poller_rd_pipe);
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200660 return 1;
661}
662
663/* Deinitialize the pollers per thread */
664static void deinit_pollers_per_thread()
665{
William Lallemand808e1b72018-12-15 22:34:31 +0100666 /* rd and wr are init at the same place, but only rd is init to -1, so
667 we rely to rd to close. */
668 if (poller_rd_pipe > -1) {
Willy Tarreauf91c7b92022-08-10 17:08:17 +0200669 fd_delete(poller_rd_pipe);
William Lallemand808e1b72018-12-15 22:34:31 +0100670 poller_rd_pipe = -1;
Willy Tarreauf91c7b92022-08-10 17:08:17 +0200671 fd_delete(poller_wr_pipe[tid]);
William Lallemand808e1b72018-12-15 22:34:31 +0100672 poller_wr_pipe[tid] = -1;
673 }
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200674}
675
Willy Tarreau082b6282019-05-22 14:42:12 +0200676/* Release the pollers per thread, to be called late */
677static void free_pollers_per_thread()
678{
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100679 ha_free(&fd_updt);
Willy Tarreau082b6282019-05-22 14:42:12 +0200680}
681
Willy Tarreaubaaee002006-06-26 02:48:02 +0200682/*
Willy Tarreau4f60f162007-04-08 16:39:58 +0200683 * Initialize the pollers till the best one is found.
684 * If none works, returns 0, otherwise 1.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200685 */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200686int init_pollers()
Willy Tarreaubaaee002006-06-26 02:48:02 +0200687{
Willy Tarreau4f60f162007-04-08 16:39:58 +0200688 int p;
689 struct poller *bp;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200690
Willy Tarreau8c3c0962022-01-27 16:10:48 +0100691 if ((fdtab_addr = calloc(global.maxsock, sizeof(*fdtab) + 64)) == NULL) {
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200692 ha_alert("Not enough memory to allocate %d entries for fdtab!\n", global.maxsock);
Christopher Faulet63fe6522017-08-31 17:52:09 +0200693 goto fail_tab;
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200694 }
Christopher Faulet63fe6522017-08-31 17:52:09 +0200695
Willy Tarreau8c3c0962022-01-27 16:10:48 +0100696 /* always provide an aligned fdtab */
697 fdtab = (struct fdtab*)((((size_t)fdtab_addr) + 63) & -(size_t)64);
698
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200699 if ((polled_mask = calloc(global.maxsock, sizeof(*polled_mask))) == NULL) {
700 ha_alert("Not enough memory to allocate %d entries for polled_mask!\n", global.maxsock);
Olivier Houchardcb92f5c2018-04-26 14:23:07 +0200701 goto fail_polledmask;
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200702 }
Uman Shahzadda7eeed2019-01-17 08:21:39 +0000703
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200704 if ((fdinfo = calloc(global.maxsock, sizeof(*fdinfo))) == NULL) {
705 ha_alert("Not enough memory to allocate %d entries for fdinfo!\n", global.maxsock);
Christopher Faulet63fe6522017-08-31 17:52:09 +0200706 goto fail_info;
Willy Tarreau7c9f7562020-10-13 15:45:07 +0200707 }
Christopher Faulet63fe6522017-08-31 17:52:09 +0200708
Olivier Houchard6b96f722018-04-25 16:58:25 +0200709 update_list.first = update_list.last = -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200710
Olivier Houchard4815c8c2018-01-24 18:17:56 +0100711 for (p = 0; p < global.maxsock; p++) {
Olivier Houchard4815c8c2018-01-24 18:17:56 +0100712 /* Mark the fd as out of the fd cache */
Olivier Houchard6b96f722018-04-25 16:58:25 +0200713 fdtab[p].update.next = -3;
Olivier Houchard4815c8c2018-01-24 18:17:56 +0100714 }
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200715
Willy Tarreau4f60f162007-04-08 16:39:58 +0200716 do {
717 bp = NULL;
718 for (p = 0; p < nbpollers; p++)
719 if (!bp || (pollers[p].pref > bp->pref))
720 bp = &pollers[p];
Willy Tarreaubaaee002006-06-26 02:48:02 +0200721
Willy Tarreau4f60f162007-04-08 16:39:58 +0200722 if (!bp || bp->pref == 0)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200723 break;
724
Willy Tarreau4f60f162007-04-08 16:39:58 +0200725 if (bp->init(bp)) {
726 memcpy(&cur_poller, bp, sizeof(*bp));
727 return 1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200728 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200729 } while (!bp || bp->pref == 0);
Willy Tarreau7be79a42012-11-11 15:02:54 +0100730
Christopher Faulet63fe6522017-08-31 17:52:09 +0200731 free(fdinfo);
732 fail_info:
Olivier Houchardcb92f5c2018-04-26 14:23:07 +0200733 free(polled_mask);
734 fail_polledmask:
Willy Tarreau8c3c0962022-01-27 16:10:48 +0100735 free(fdtab_addr);
Uman Shahzadda7eeed2019-01-17 08:21:39 +0000736 fail_tab:
Willy Tarreau7be79a42012-11-11 15:02:54 +0100737 return 0;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200738}
739
Willy Tarreaubaaee002006-06-26 02:48:02 +0200740/*
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +0200741 * Deinitialize the pollers.
742 */
743void deinit_pollers() {
744
745 struct poller *bp;
746 int p;
747
748 for (p = 0; p < nbpollers; p++) {
749 bp = &pollers[p];
750
751 if (bp && bp->pref)
752 bp->term(bp);
753 }
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200754
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100755 ha_free(&fdinfo);
Willy Tarreau8c3c0962022-01-27 16:10:48 +0100756 ha_free(&fdtab_addr);
Willy Tarreau61cfdf42021-02-20 10:46:51 +0100757 ha_free(&polled_mask);
Krzysztof Piotr Oledzkia643baf2008-05-29 23:53:44 +0200758}
759
760/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200761 * Lists the known pollers on <out>.
762 * Should be performed only before initialization.
763 */
764int list_pollers(FILE *out)
765{
766 int p;
767 int last, next;
768 int usable;
769 struct poller *bp;
770
771 fprintf(out, "Available polling systems :\n");
772
773 usable = 0;
774 bp = NULL;
775 last = next = -1;
776 while (1) {
777 for (p = 0; p < nbpollers; p++) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200778 if ((next < 0 || pollers[p].pref > next)
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100779 && (last < 0 || pollers[p].pref < last)) {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200780 next = pollers[p].pref;
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100781 if (!bp || (pollers[p].pref > bp->pref))
782 bp = &pollers[p];
783 }
Willy Tarreau2ff76222007-04-09 19:29:56 +0200784 }
785
786 if (next == -1)
787 break;
788
789 for (p = 0; p < nbpollers; p++) {
790 if (pollers[p].pref == next) {
791 fprintf(out, " %10s : ", pollers[p].name);
792 if (pollers[p].pref == 0)
793 fprintf(out, "disabled, ");
794 else
795 fprintf(out, "pref=%3d, ", pollers[p].pref);
796 if (pollers[p].test(&pollers[p])) {
797 fprintf(out, " test result OK");
798 if (next > 0)
799 usable++;
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100800 } else {
Willy Tarreau2ff76222007-04-09 19:29:56 +0200801 fprintf(out, " test result FAILED");
Willy Tarreaue79c3b22010-11-19 10:20:36 +0100802 if (bp == &pollers[p])
803 bp = NULL;
804 }
Willy Tarreau2ff76222007-04-09 19:29:56 +0200805 fprintf(out, "\n");
806 }
807 }
808 last = next;
809 next = -1;
810 };
811 fprintf(out, "Total: %d (%d usable), will use %s.\n", nbpollers, usable, bp ? bp->name : "none");
812 return 0;
813}
814
815/*
816 * Some pollers may lose their connection after a fork(). It may be necessary
817 * to create initialize part of them again. Returns 0 in case of failure,
818 * otherwise 1. The fork() function may be NULL if unused. In case of error,
819 * the the current poller is destroyed and the caller is responsible for trying
820 * another one by calling init_pollers() again.
821 */
822int fork_poller()
823{
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200824 int fd;
Willy Tarreauce036bc2018-01-29 14:58:02 +0100825 for (fd = 0; fd < global.maxsock; fd++) {
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200826 if (fdtab[fd].owner) {
Willy Tarreau030dae12021-04-06 17:53:33 +0200827 HA_ATOMIC_OR(&fdtab[fd].state, FD_CLONED);
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200828 }
829 }
830
Willy Tarreau2ff76222007-04-09 19:29:56 +0200831 if (cur_poller.fork) {
832 if (cur_poller.fork(&cur_poller))
833 return 1;
834 cur_poller.term(&cur_poller);
835 return 0;
836 }
837 return 1;
838}
839
Willy Tarreaubc52bec2020-06-18 08:58:47 +0200840/* config parser for global "tune.fd.edge-triggered", accepts "on" or "off" */
841static int cfg_parse_tune_fd_edge_triggered(char **args, int section_type, struct proxy *curpx,
Willy Tarreau01825162021-03-09 09:53:46 +0100842 const struct proxy *defpx, const char *file, int line,
Willy Tarreaubc52bec2020-06-18 08:58:47 +0200843 char **err)
844{
845 if (too_many_args(1, args, err, NULL))
846 return -1;
847
848 if (strcmp(args[1], "on") == 0)
849 global.tune.options |= GTUNE_FD_ET;
850 else if (strcmp(args[1], "off") == 0)
851 global.tune.options &= ~GTUNE_FD_ET;
852 else {
853 memprintf(err, "'%s' expects either 'on' or 'off' but got '%s'.", args[0], args[1]);
854 return -1;
855 }
856 return 0;
857}
858
859/* config keyword parsers */
860static struct cfg_kw_list cfg_kws = {ILH, {
Willy Tarreau9eec7e22021-05-08 11:06:32 +0200861 { CFG_GLOBAL, "tune.fd.edge-triggered", cfg_parse_tune_fd_edge_triggered, KWF_EXPERIMENTAL },
Willy Tarreaubc52bec2020-06-18 08:58:47 +0200862 { 0, NULL, NULL }
863}};
864
865INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws);
866
Willy Tarreau082b6282019-05-22 14:42:12 +0200867REGISTER_PER_THREAD_ALLOC(alloc_pollers_per_thread);
Willy Tarreau172f5ce2018-11-26 11:21:50 +0100868REGISTER_PER_THREAD_INIT(init_pollers_per_thread);
869REGISTER_PER_THREAD_DEINIT(deinit_pollers_per_thread);
Willy Tarreau082b6282019-05-22 14:42:12 +0200870REGISTER_PER_THREAD_FREE(free_pollers_per_thread);
Willy Tarreau172f5ce2018-11-26 11:21:50 +0100871
Willy Tarreau2ff76222007-04-09 19:29:56 +0200872/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200873 * Local variables:
874 * c-indent-level: 8
875 * c-basic-offset: 8
876 * End:
877 */