Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
| 2 | * File descriptors management functions. |
| 3 | * |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 4 | * Copyright 2000-2014 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 5 | * |
| 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 Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 11 | * 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 Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 17 | * 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 Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 20 | * |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 21 | * 7 6 5 4 3 2 1 0 |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 22 | * [ 0 | 0 | RW | AW | 0 | 0 | RR | AR ] |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 23 | * |
| 24 | * A* = active *R = read |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 25 | * R* = ready *W = write |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 26 | * |
| 27 | * An FD is marked "active" when there is a desire to use it. |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 28 | * An FD is marked "ready" when it has not faced a new EAGAIN since last wake-up |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 29 | * (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 Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 31 | * |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 32 | * We have 4 possible states for each direction based on these 2 flags : |
Willy Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 33 | * |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 34 | * +---+---+----------+---------------------------------------------+ |
| 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 Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 42 | * |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 43 | * 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 Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 48 | * |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 49 | * Each poller then computes its own polled state : |
| 50 | * if (A) { if (!R) P := 1 } else { P := 0 } |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 51 | * |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 52 | * The state transitions look like the diagram below. |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 53 | * |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 54 | * 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 McCombs | 8f0cc5c | 2021-01-07 21:35:52 -0700 | [diff] [blame] | 65 | * | v | EAGAIN (can't) |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 66 | * | +--------+ |
| 67 | * | | READY | (READY=1, ACTIVE=1) |
| 68 | * | +--------+ |
| 69 | * | stop | ^ |
| 70 | * | | | |
| 71 | * | v | want |
| 72 | * | +---------+ |
| 73 | * `--->| STOPPED | (READY=1, ACTIVE=0) |
| 74 | * +---------+ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 75 | */ |
| 76 | |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 77 | #include <stdio.h> |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 78 | #include <string.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 79 | #include <unistd.h> |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 80 | #include <fcntl.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 81 | #include <sys/types.h> |
Willy Tarreau | 2d7f81b | 2019-02-21 22:19:17 +0100 | [diff] [blame] | 82 | #include <sys/resource.h> |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 83 | #include <sys/uio.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 84 | |
Willy Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 85 | #if defined(USE_POLL) |
Willy Tarreau | 9188ac6 | 2019-02-21 22:12:47 +0100 | [diff] [blame] | 86 | #include <poll.h> |
| 87 | #include <errno.h> |
| 88 | #endif |
| 89 | |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 90 | #include <haproxy/api.h> |
Willy Tarreau | bc52bec | 2020-06-18 08:58:47 +0200 | [diff] [blame] | 91 | #include <haproxy/cfgparse.h> |
Willy Tarreau | 0f6ffd6 | 2020-06-03 19:33:00 +0200 | [diff] [blame] | 92 | #include <haproxy/fd.h> |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 93 | #include <haproxy/global.h> |
Willy Tarreau | c28aab0 | 2021-05-08 20:35:03 +0200 | [diff] [blame] | 94 | #include <haproxy/log.h> |
Willy Tarreau | fc8f6a8 | 2020-06-03 19:20:59 +0200 | [diff] [blame] | 95 | #include <haproxy/port_range.h> |
Willy Tarreau | bc52bec | 2020-06-18 08:58:47 +0200 | [diff] [blame] | 96 | #include <haproxy/tools.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 97 | |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 98 | |
Willy Tarreau | a1090a5 | 2021-04-10 16:58:13 +0200 | [diff] [blame] | 99 | struct fdtab *fdtab __read_mostly = NULL; /* array of all the file descriptors */ |
| 100 | struct polled_mask *polled_mask __read_mostly = NULL; /* Array for the polled_mask of each fd */ |
| 101 | struct fdinfo *fdinfo __read_mostly = NULL; /* less-often used infos for file descriptors */ |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 102 | int totalconn; /* total # of terminated sessions */ |
| 103 | int actconn; /* # of active sessions */ |
| 104 | |
Willy Tarreau | a1090a5 | 2021-04-10 16:58:13 +0200 | [diff] [blame] | 105 | struct poller pollers[MAX_POLLERS] __read_mostly; |
| 106 | struct poller cur_poller __read_mostly; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 107 | int nbpollers = 0; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 108 | |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 109 | volatile struct fdlist update_list; // Global update list |
Olivier Houchard | 4815c8c | 2018-01-24 18:17:56 +0100 | [diff] [blame] | 110 | |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 111 | THREAD_LOCAL int *fd_updt = NULL; // FD updates list |
| 112 | THREAD_LOCAL int fd_nbupdt = 0; // number of updates in the list |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 113 | THREAD_LOCAL int poller_rd_pipe = -1; // Pipe to wake the thread |
Willy Tarreau | a1090a5 | 2021-04-10 16:58:13 +0200 | [diff] [blame] | 114 | int poller_wr_pipe[MAX_THREADS] __read_mostly; // Pipe to wake the threads |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 115 | |
Olivier Houchard | 7c49d2e | 2019-04-16 18:37:05 +0200 | [diff] [blame] | 116 | volatile int ha_used_fds = 0; // Number of FD we're currently using |
Willy Tarreau | 8c3c096 | 2022-01-27 16:10:48 +0100 | [diff] [blame] | 117 | static struct fdtab *fdtab_addr; /* address of the allocated area containing fdtab */ |
Olivier Houchard | 7c49d2e | 2019-04-16 18:37:05 +0200 | [diff] [blame] | 118 | |
Willy Tarreau | 337fb71 | 2019-12-20 07:20:00 +0100 | [diff] [blame] | 119 | #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 Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 121 | /* adds fd <fd> to fd list <list> if it was not yet in it */ |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 122 | void fd_add_to_fd_list(volatile struct fdlist *list, int fd, int off) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 123 | { |
| 124 | int next; |
| 125 | int new; |
| 126 | int old; |
| 127 | int last; |
| 128 | |
| 129 | redo_next: |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 130 | next = _GET_NEXT(fd, off); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 131 | /* Check that we're not already in the cache, and if not, lock us. */ |
Olivier Houchard | fc51f0f5 | 2019-12-19 18:33:08 +0100 | [diff] [blame] | 132 | if (next > -2) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 133 | goto done; |
Olivier Houchard | fc51f0f5 | 2019-12-19 18:33:08 +0100 | [diff] [blame] | 134 | if (next == -2) |
| 135 | goto redo_next; |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 136 | if (!_HA_ATOMIC_CAS(&_GET_NEXT(fd, off), &next, -2)) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 137 | goto redo_next; |
Olivier Houchard | d2b5d16 | 2019-03-08 13:47:21 +0100 | [diff] [blame] | 138 | __ha_barrier_atomic_store(); |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 139 | |
| 140 | new = fd; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 141 | redo_last: |
| 142 | /* First, insert in the linked list */ |
| 143 | last = list->last; |
| 144 | old = -1; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 145 | |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 146 | _GET_PREV(fd, off) = -2; |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 147 | /* Make sure the "prev" store is visible before we update the last entry */ |
| 148 | __ha_barrier_store(); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 149 | |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 150 | if (unlikely(last == -1)) { |
| 151 | /* list is empty, try to add ourselves alone so that list->last=fd */ |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 152 | if (unlikely(!_HA_ATOMIC_CAS(&list->last, &old, new))) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 153 | goto redo_last; |
| 154 | |
| 155 | /* list->first was necessary -1, we're guaranteed to be alone here */ |
| 156 | list->first = fd; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 157 | } else { |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 158 | /* 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 Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 162 | if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(last, off), &old, new))) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 163 | goto redo_last; |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 164 | |
| 165 | /* Then, update the last entry */ |
| 166 | list->last = fd; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 167 | } |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 168 | __ha_barrier_store(); |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 169 | /* since we're alone at the end of the list and still locked(-2), |
Ilya Shipitsin | b8888ab | 2021-01-06 21:20:16 +0500 | [diff] [blame] | 170 | * we know no one tried to add past us. Mark the end of list. |
Willy Tarreau | 11559a7 | 2018-02-05 17:52:24 +0100 | [diff] [blame] | 171 | */ |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 172 | _GET_PREV(fd, off) = last; |
| 173 | _GET_NEXT(fd, off) = -1; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 174 | __ha_barrier_store(); |
| 175 | done: |
| 176 | return; |
| 177 | } |
| 178 | |
| 179 | /* removes fd <fd> from fd list <list> */ |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 180 | void fd_rm_from_fd_list(volatile struct fdlist *list, int fd, int off) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 181 | { |
| 182 | #if defined(HA_HAVE_CAS_DW) || defined(HA_CAS_IS_8B) |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 183 | volatile union { |
| 184 | struct fdlist_entry ent; |
| 185 | uint64_t u64; |
| 186 | uint32_t u32[2]; |
| 187 | } cur_list, next_list; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 188 | #endif |
| 189 | int old; |
| 190 | int new = -2; |
| 191 | int prev; |
| 192 | int next; |
| 193 | int last; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 194 | lock_self: |
| 195 | #if (defined(HA_CAS_IS_8B) || defined(HA_HAVE_CAS_DW)) |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 196 | next_list.ent.next = next_list.ent.prev = -2; |
| 197 | cur_list.ent = *(volatile struct fdlist_entry *)(((char *)&fdtab[fd]) + off); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 198 | /* First, attempt to lock our own entries */ |
| 199 | do { |
| 200 | /* The FD is not in the FD cache, give up */ |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 201 | if (unlikely(cur_list.ent.next <= -3)) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 202 | return; |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 203 | if (unlikely(cur_list.ent.prev == -2 || cur_list.ent.next == -2)) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 204 | goto lock_self; |
| 205 | } while ( |
| 206 | #ifdef HA_CAS_IS_8B |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 207 | unlikely(!_HA_ATOMIC_CAS(((uint64_t *)&_GET_NEXT(fd, off)), (uint64_t *)&cur_list.u64, next_list.u64)) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 208 | #else |
Willy Tarreau | 9cc5fb4 | 2022-09-17 11:15:29 +0200 | [diff] [blame] | 209 | unlikely(!_HA_ATOMIC_DWCAS(((long *)&_GET_NEXT(fd, off)), (uint32_t *)&cur_list.u32, (const uint32_t *)&next_list.u32)) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 210 | #endif |
Willy Tarreau | 2b9f066 | 2020-02-25 09:25:53 +0100 | [diff] [blame] | 211 | ); |
| 212 | next = cur_list.ent.next; |
| 213 | prev = cur_list.ent.prev; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 214 | |
| 215 | #else |
| 216 | lock_self_next: |
Willy Tarreau | 337fb71 | 2019-12-20 07:20:00 +0100 | [diff] [blame] | 217 | next = _GET_NEXT(fd, off); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 218 | if (next == -2) |
| 219 | goto lock_self_next; |
| 220 | if (next <= -3) |
| 221 | goto done; |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 222 | if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(fd, off), &next, -2))) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 223 | goto lock_self_next; |
| 224 | lock_self_prev: |
Willy Tarreau | 337fb71 | 2019-12-20 07:20:00 +0100 | [diff] [blame] | 225 | prev = _GET_PREV(fd, off); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 226 | if (prev == -2) |
| 227 | goto lock_self_prev; |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 228 | if (unlikely(!_HA_ATOMIC_CAS(&_GET_PREV(fd, off), &prev, -2))) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 229 | goto lock_self_prev; |
| 230 | #endif |
Olivier Houchard | d2b5d16 | 2019-03-08 13:47:21 +0100 | [diff] [blame] | 231 | __ha_barrier_atomic_store(); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 232 | |
| 233 | /* Now, lock the entries of our neighbours */ |
| 234 | if (likely(prev != -1)) { |
| 235 | redo_prev: |
| 236 | old = fd; |
| 237 | |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 238 | if (unlikely(!_HA_ATOMIC_CAS(&_GET_NEXT(prev, off), &old, new))) { |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 239 | if (unlikely(old == -2)) { |
| 240 | /* Neighbour already locked, give up and |
| 241 | * retry again once he's done |
| 242 | */ |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 243 | _GET_PREV(fd, off) = prev; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 244 | __ha_barrier_store(); |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 245 | _GET_NEXT(fd, off) = next; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 246 | __ha_barrier_store(); |
| 247 | goto lock_self; |
| 248 | } |
| 249 | goto redo_prev; |
| 250 | } |
| 251 | } |
| 252 | if (likely(next != -1)) { |
| 253 | redo_next: |
| 254 | old = fd; |
Olivier Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 255 | if (unlikely(!_HA_ATOMIC_CAS(&_GET_PREV(next, off), &old, new))) { |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 256 | if (unlikely(old == -2)) { |
| 257 | /* Neighbour already locked, give up and |
| 258 | * retry again once he's done |
| 259 | */ |
| 260 | if (prev != -1) { |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 261 | _GET_NEXT(prev, off) = fd; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 262 | __ha_barrier_store(); |
| 263 | } |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 264 | _GET_PREV(fd, off) = prev; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 265 | __ha_barrier_store(); |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 266 | _GET_NEXT(fd, off) = next; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 267 | __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 Houchard | d360879 | 2019-03-08 18:47:42 +0100 | [diff] [blame] | 277 | while (unlikely(last == fd && (!_HA_ATOMIC_CAS(&list->last, &last, prev)))) |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 278 | __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 Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 284 | _GET_NEXT(prev, off) = next; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 285 | __ha_barrier_store(); |
| 286 | if (likely(next != -1)) |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 287 | _GET_PREV(next, off) = prev; |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 288 | __ha_barrier_store(); |
| 289 | /* Ok, now we're out of the fd cache */ |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 290 | _GET_NEXT(fd, off) = -(next + 4); |
Willy Tarreau | 4cc67a2 | 2018-02-05 17:14:55 +0100 | [diff] [blame] | 291 | __ha_barrier_store(); |
| 292 | done: |
| 293 | return; |
| 294 | } |
| 295 | |
Olivier Houchard | 6a2cf87 | 2018-04-25 15:10:30 +0200 | [diff] [blame] | 296 | #undef _GET_NEXT |
| 297 | #undef _GET_PREV |
| 298 | |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 299 | /* 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 Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 304 | */ |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 305 | void _fd_delete_orphan(int fd) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 306 | { |
Emeric Brun | 1dee3ec | 2022-07-01 17:31:25 +0200 | [diff] [blame] | 307 | uint fd_disown; |
| 308 | |
| 309 | fd_disown = fdtab[fd].state & FD_DISOWN; |
Willy Tarreau | b41a6e9 | 2021-04-06 17:49:19 +0200 | [diff] [blame] | 310 | if (fdtab[fd].state & FD_LINGER_RISK) { |
Willy Tarreau | ad38ace | 2013-12-15 14:19:38 +0100 | [diff] [blame] | 311 | /* this is generally set when connecting to servers */ |
Ilya Shipitsin | b7e43f0 | 2020-04-02 15:02:08 +0500 | [diff] [blame] | 312 | DISGUISE(setsockopt(fd, SOL_SOCKET, SO_LINGER, |
| 313 | (struct linger *) &nolinger, sizeof(struct linger))); |
Willy Tarreau | ad38ace | 2013-12-15 14:19:38 +0100 | [diff] [blame] | 314 | } |
Willy Tarreau | 6ea20b1 | 2012-11-11 16:05:19 +0100 | [diff] [blame] | 315 | if (cur_poller.clo) |
| 316 | cur_poller.clo(fd); |
Willy Tarreau | 2d42329 | 2021-03-24 15:34:25 +0100 | [diff] [blame] | 317 | |
| 318 | port_range_release_port(fdinfo[fd].port_range, fdinfo[fd].local_port); |
Olivier Houchard | c22580c | 2019-08-05 18:51:52 +0200 | [diff] [blame] | 319 | polled_mask[fd].poll_recv = polled_mask[fd].poll_send = 0; |
Willy Tarreau | 6ea20b1 | 2012-11-11 16:05:19 +0100 | [diff] [blame] | 320 | |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 321 | fdtab[fd].state = 0; |
Willy Tarreau | 6ea20b1 | 2012-11-11 16:05:19 +0100 | [diff] [blame] | 322 | |
Willy Tarreau | 38e8a1c | 2020-06-23 10:04:54 +0200 | [diff] [blame] | 323 | #ifdef DEBUG_FD |
| 324 | fdtab[fd].event_count = 0; |
| 325 | #endif |
Willy Tarreau | 8d5d77e | 2009-10-18 07:25:52 +0200 | [diff] [blame] | 326 | fdinfo[fd].port_range = NULL; |
Willy Tarreau | db3b326 | 2012-07-05 23:19:22 +0200 | [diff] [blame] | 327 | fdtab[fd].owner = NULL; |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 328 | /* perform the close() call last as it's what unlocks the instant reuse |
| 329 | * of this FD by any other thread. |
| 330 | */ |
Emeric Brun | 1dee3ec | 2022-07-01 17:31:25 +0200 | [diff] [blame] | 331 | if (!fd_disown) |
| 332 | close(fd); |
Willy Tarreau | 4781b15 | 2021-04-06 13:53:36 +0200 | [diff] [blame] | 333 | _HA_ATOMIC_DEC(&ha_used_fds); |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 334 | } |
| 335 | |
Olivier Houchard | c23b337 | 2021-03-25 01:38:54 +0100 | [diff] [blame] | 336 | #ifndef HA_HAVE_CAS_DW |
| 337 | __decl_thread(__decl_rwlock(fd_mig_lock)); |
| 338 | #endif |
| 339 | |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 340 | /* Deletes an FD from the fdsets. The file descriptor is also closed, possibly |
| 341 | * asynchronously. Only the owning thread may do this. |
| 342 | */ |
| 343 | void fd_delete(int fd) |
| 344 | { |
| 345 | /* we must postpone removal of an FD that may currently be in use |
Ilya Shipitsin | b2be9a1 | 2021-04-24 13:25:42 +0500 | [diff] [blame] | 346 | * by another thread. This can happen in the following two situations: |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 347 | * - 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 Houchard | c23b337 | 2021-03-25 01:38:54 +0100 | [diff] [blame] | 362 | #ifndef HA_HAVE_CAS_DW |
| 363 | HA_RWLOCK_WRLOCK(OTHER_LOCK, &fd_mig_lock); |
| 364 | #endif |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 365 | HA_ATOMIC_STORE(&fdtab[fd].thread_mask, 0); |
Olivier Houchard | c23b337 | 2021-03-25 01:38:54 +0100 | [diff] [blame] | 366 | #ifndef HA_HAVE_CAS_DW |
| 367 | HA_RWLOCK_WRUNLOCK(OTHER_LOCK, &fd_mig_lock); |
| 368 | #endif |
Willy Tarreau | 2c3f981 | 2021-03-24 10:51:32 +0100 | [diff] [blame] | 369 | if (fd_clr_running(fd) == 0) |
| 370 | _fd_delete_orphan(fd); |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 371 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 372 | |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 373 | /* |
| 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 | */ |
| 378 | int fd_takeover(int fd, void *expected_owner) |
| 379 | { |
Willy Tarreau | c460c91 | 2020-06-18 07:28:09 +0200 | [diff] [blame] | 380 | int ret = -1; |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 381 | |
Willy Tarreau | f1cad38 | 2020-06-18 08:14:59 +0200 | [diff] [blame] | 382 | #ifndef HA_HAVE_CAS_DW |
Willy Tarreau | 1db4273 | 2021-04-06 11:44:07 +0200 | [diff] [blame] | 383 | if (_HA_ATOMIC_OR_FETCH(&fdtab[fd].running_mask, tid_bit) == tid_bit) { |
Willy Tarreau | c460c91 | 2020-06-18 07:28:09 +0200 | [diff] [blame] | 384 | 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 Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 390 | } |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 391 | #else |
| 392 | unsigned long old_masks[2]; |
| 393 | unsigned long new_masks[2]; |
| 394 | |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 395 | new_masks[0] = new_masks[1] = tid_bit; |
Willy Tarreau | 4297363 | 2020-06-18 08:05:15 +0200 | [diff] [blame] | 396 | |
Willy Tarreau | 1db4273 | 2021-04-06 11:44:07 +0200 | [diff] [blame] | 397 | old_masks[0] = _HA_ATOMIC_OR_FETCH(&fdtab[fd].running_mask, tid_bit); |
Willy Tarreau | 4297363 | 2020-06-18 08:05:15 +0200 | [diff] [blame] | 398 | old_masks[1] = fdtab[fd].thread_mask; |
| 399 | |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 400 | /* 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 Tarreau | f1cad38 | 2020-06-18 08:14:59 +0200 | [diff] [blame] | 404 | 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 Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 410 | } |
Willy Tarreau | f1cad38 | 2020-06-18 08:14:59 +0200 | [diff] [blame] | 411 | } |
| 412 | #endif /* HW_HAVE_CAS_DW */ |
| 413 | |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 414 | _HA_ATOMIC_AND(&fdtab[fd].running_mask, ~tid_bit); |
Willy Tarreau | f1cad38 | 2020-06-18 08:14:59 +0200 | [diff] [blame] | 415 | |
Olivier Houchard | ddc874c | 2020-06-17 20:34:05 +0200 | [diff] [blame] | 416 | /* 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 Tarreau | f1cad38 | 2020-06-18 08:14:59 +0200 | [diff] [blame] | 420 | if (likely(ret == 0)) |
| 421 | fd_stop_recv(fd); |
| 422 | return ret; |
Olivier Houchard | 8851664 | 2020-03-05 18:10:51 +0100 | [diff] [blame] | 423 | } |
| 424 | |
Willy Tarreau | dbe3060 | 2019-09-04 13:25:41 +0200 | [diff] [blame] | 425 | void updt_fd_polling(const int fd) |
| 426 | { |
Willy Tarreau | 5a7d6eb | 2020-11-26 22:25:10 +0100 | [diff] [blame] | 427 | if (all_threads_mask == 1UL || (fdtab[fd].thread_mask & all_threads_mask) == tid_bit) { |
Willy Tarreau | dbe3060 | 2019-09-04 13:25:41 +0200 | [diff] [blame] | 428 | 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 Tarreau | f015887 | 2020-09-25 12:18:53 +0200 | [diff] [blame] | 437 | } while (!_HA_ATOMIC_CAS(&fdtab[fd].update_mask, &update_mask, fdtab[fd].thread_mask)); |
| 438 | |
Willy Tarreau | dbe3060 | 2019-09-04 13:25:41 +0200 | [diff] [blame] | 439 | fd_add_to_fd_list(&update_list, fd, offsetof(struct fdtab, update)); |
Willy Tarreau | f015887 | 2020-09-25 12:18:53 +0200 | [diff] [blame] | 440 | |
| 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 Tarreau | dbe3060 | 2019-09-04 13:25:41 +0200 | [diff] [blame] | 450 | } |
| 451 | } |
| 452 | |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 453 | /* 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 | */ |
| 463 | ssize_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 Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 466 | size_t sent = 0; |
| 467 | int vec = 0; |
Willy Tarreau | df18787 | 2020-06-11 14:25:47 +0200 | [diff] [blame] | 468 | int attempts = 0; |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 469 | |
| 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 Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 492 | 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 Tarreau | df18787 | 2020-06-11 14:25:47 +0200 | [diff] [blame] | 503 | /* 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 Tarreau | 1673c4a | 2021-04-07 17:36:57 +0200 | [diff] [blame] | 509 | while (HA_ATOMIC_BTS(&fdtab[fd].state, FD_EXCL_SYSCALL_BIT)) { |
Willy Tarreau | df18787 | 2020-06-11 14:25:47 +0200 | [diff] [blame] | 510 | 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 Tarreau | 0cc6128 | 2021-04-06 17:57:12 +0200 | [diff] [blame] | 519 | if (unlikely(!(fdtab[fd].state & FD_INITIALIZED))) { |
| 520 | HA_ATOMIC_OR(&fdtab[fd].state, FD_INITIALIZED); |
Willy Tarreau | 7e9776a | 2019-08-30 14:41:47 +0200 | [diff] [blame] | 521 | if (!isatty(fd)) |
| 522 | fcntl(fd, F_SETFL, O_NONBLOCK); |
| 523 | } |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 524 | sent = writev(fd, iovec, vec); |
Willy Tarreau | 1673c4a | 2021-04-07 17:36:57 +0200 | [diff] [blame] | 525 | HA_ATOMIC_BTR(&fdtab[fd].state, FD_EXCL_SYSCALL_BIT); |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 526 | |
Willy Tarreau | df18787 | 2020-06-11 14:25:47 +0200 | [diff] [blame] | 527 | leave: |
Willy Tarreau | 931d8b7 | 2019-08-27 11:08:17 +0200 | [diff] [blame] | 528 | /* sent > 0 if the message was delivered */ |
| 529 | return sent; |
| 530 | } |
| 531 | |
Olivier Houchard | 2292edf | 2019-02-25 14:26:54 +0100 | [diff] [blame] | 532 | #if defined(USE_CLOSEFROM) |
| 533 | void my_closefrom(int start) |
| 534 | { |
| 535 | closefrom(start); |
| 536 | } |
| 537 | |
Willy Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 538 | #elif defined(USE_POLL) |
Willy Tarreau | 9188ac6 | 2019-02-21 22:12:47 +0100 | [diff] [blame] | 539 | /* 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 | */ |
| 546 | void 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 Tarreau | 2d30863 | 2024-04-19 16:52:32 +0200 | [diff] [blame] | 581 | /* always check the whole range */ |
| 582 | ret = fd - start; |
Willy Tarreau | b8e602c | 2019-02-22 09:07:42 +0100 | [diff] [blame] | 583 | |
Willy Tarreau | 9188ac6 | 2019-02-21 22:12:47 +0100 | [diff] [blame] | 584 | 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 Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 595 | #else // defined(USE_POLL) |
Willy Tarreau | 9188ac6 | 2019-02-21 22:12:47 +0100 | [diff] [blame] | 596 | |
Willy Tarreau | 2d7f81b | 2019-02-21 22:19:17 +0100 | [diff] [blame] | 597 | /* 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 | */ |
| 601 | void 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 Tarreau | e573323 | 2019-05-22 19:24:06 +0200 | [diff] [blame] | 617 | #endif // defined(USE_POLL) |
Willy Tarreau | 2d7f81b | 2019-02-21 22:19:17 +0100 | [diff] [blame] | 618 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 619 | /* disable the specified poller */ |
| 620 | void disable_poller(const char *poller_name) |
| 621 | { |
| 622 | int p; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 623 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 624 | for (p = 0; p < nbpollers; p++) |
| 625 | if (strcmp(pollers[p].name, poller_name) == 0) |
| 626 | pollers[p].pref = 0; |
| 627 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 628 | |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 629 | void 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 Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 637 | /* allocate the per-thread fd_updt thus needs to be called early after |
| 638 | * thread creation. |
| 639 | */ |
| 640 | static 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 Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 647 | static int init_pollers_per_thread() |
| 648 | { |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 649 | int mypipe[2]; |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 650 | |
| 651 | if (pipe(mypipe) < 0) |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 652 | return 0; |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 653 | |
Olivier Houchard | 79321b9 | 2018-07-26 17:55:11 +0200 | [diff] [blame] | 654 | 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 Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 660 | return 1; |
| 661 | } |
| 662 | |
| 663 | /* Deinitialize the pollers per thread */ |
| 664 | static void deinit_pollers_per_thread() |
| 665 | { |
William Lallemand | 808e1b7 | 2018-12-15 22:34:31 +0100 | [diff] [blame] | 666 | /* 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 Tarreau | f91c7b9 | 2022-08-10 17:08:17 +0200 | [diff] [blame] | 669 | fd_delete(poller_rd_pipe); |
William Lallemand | 808e1b7 | 2018-12-15 22:34:31 +0100 | [diff] [blame] | 670 | poller_rd_pipe = -1; |
Willy Tarreau | f91c7b9 | 2022-08-10 17:08:17 +0200 | [diff] [blame] | 671 | fd_delete(poller_wr_pipe[tid]); |
William Lallemand | 808e1b7 | 2018-12-15 22:34:31 +0100 | [diff] [blame] | 672 | poller_wr_pipe[tid] = -1; |
| 673 | } |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 674 | } |
| 675 | |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 676 | /* Release the pollers per thread, to be called late */ |
| 677 | static void free_pollers_per_thread() |
| 678 | { |
Willy Tarreau | 61cfdf4 | 2021-02-20 10:46:51 +0100 | [diff] [blame] | 679 | ha_free(&fd_updt); |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 680 | } |
| 681 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 682 | /* |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 683 | * Initialize the pollers till the best one is found. |
| 684 | * If none works, returns 0, otherwise 1. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 685 | */ |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 686 | int init_pollers() |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 687 | { |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 688 | int p; |
| 689 | struct poller *bp; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 690 | |
Willy Tarreau | 8c3c096 | 2022-01-27 16:10:48 +0100 | [diff] [blame] | 691 | if ((fdtab_addr = calloc(global.maxsock, sizeof(*fdtab) + 64)) == NULL) { |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 692 | ha_alert("Not enough memory to allocate %d entries for fdtab!\n", global.maxsock); |
Christopher Faulet | 63fe652 | 2017-08-31 17:52:09 +0200 | [diff] [blame] | 693 | goto fail_tab; |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 694 | } |
Christopher Faulet | 63fe652 | 2017-08-31 17:52:09 +0200 | [diff] [blame] | 695 | |
Willy Tarreau | 8c3c096 | 2022-01-27 16:10:48 +0100 | [diff] [blame] | 696 | /* always provide an aligned fdtab */ |
| 697 | fdtab = (struct fdtab*)((((size_t)fdtab_addr) + 63) & -(size_t)64); |
| 698 | |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 699 | 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 Houchard | cb92f5c | 2018-04-26 14:23:07 +0200 | [diff] [blame] | 701 | goto fail_polledmask; |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 702 | } |
Uman Shahzad | da7eeed | 2019-01-17 08:21:39 +0000 | [diff] [blame] | 703 | |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 704 | if ((fdinfo = calloc(global.maxsock, sizeof(*fdinfo))) == NULL) { |
| 705 | ha_alert("Not enough memory to allocate %d entries for fdinfo!\n", global.maxsock); |
Christopher Faulet | 63fe652 | 2017-08-31 17:52:09 +0200 | [diff] [blame] | 706 | goto fail_info; |
Willy Tarreau | 7c9f756 | 2020-10-13 15:45:07 +0200 | [diff] [blame] | 707 | } |
Christopher Faulet | 63fe652 | 2017-08-31 17:52:09 +0200 | [diff] [blame] | 708 | |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 709 | update_list.first = update_list.last = -1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 710 | |
Olivier Houchard | 4815c8c | 2018-01-24 18:17:56 +0100 | [diff] [blame] | 711 | for (p = 0; p < global.maxsock; p++) { |
Olivier Houchard | 4815c8c | 2018-01-24 18:17:56 +0100 | [diff] [blame] | 712 | /* Mark the fd as out of the fd cache */ |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 713 | fdtab[p].update.next = -3; |
Olivier Houchard | 4815c8c | 2018-01-24 18:17:56 +0100 | [diff] [blame] | 714 | } |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 715 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 716 | do { |
| 717 | bp = NULL; |
| 718 | for (p = 0; p < nbpollers; p++) |
| 719 | if (!bp || (pollers[p].pref > bp->pref)) |
| 720 | bp = &pollers[p]; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 721 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 722 | if (!bp || bp->pref == 0) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 723 | break; |
| 724 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 725 | if (bp->init(bp)) { |
| 726 | memcpy(&cur_poller, bp, sizeof(*bp)); |
| 727 | return 1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 728 | } |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 729 | } while (!bp || bp->pref == 0); |
Willy Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 730 | |
Christopher Faulet | 63fe652 | 2017-08-31 17:52:09 +0200 | [diff] [blame] | 731 | free(fdinfo); |
| 732 | fail_info: |
Olivier Houchard | cb92f5c | 2018-04-26 14:23:07 +0200 | [diff] [blame] | 733 | free(polled_mask); |
| 734 | fail_polledmask: |
Willy Tarreau | 8c3c096 | 2022-01-27 16:10:48 +0100 | [diff] [blame] | 735 | free(fdtab_addr); |
Uman Shahzad | da7eeed | 2019-01-17 08:21:39 +0000 | [diff] [blame] | 736 | fail_tab: |
Willy Tarreau | 7be79a4 | 2012-11-11 15:02:54 +0100 | [diff] [blame] | 737 | return 0; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 738 | } |
| 739 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 740 | /* |
Krzysztof Piotr Oledzki | a643baf | 2008-05-29 23:53:44 +0200 | [diff] [blame] | 741 | * Deinitialize the pollers. |
| 742 | */ |
| 743 | void 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 Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 754 | |
Willy Tarreau | 61cfdf4 | 2021-02-20 10:46:51 +0100 | [diff] [blame] | 755 | ha_free(&fdinfo); |
Willy Tarreau | 8c3c096 | 2022-01-27 16:10:48 +0100 | [diff] [blame] | 756 | ha_free(&fdtab_addr); |
Willy Tarreau | 61cfdf4 | 2021-02-20 10:46:51 +0100 | [diff] [blame] | 757 | ha_free(&polled_mask); |
Krzysztof Piotr Oledzki | a643baf | 2008-05-29 23:53:44 +0200 | [diff] [blame] | 758 | } |
| 759 | |
| 760 | /* |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 761 | * Lists the known pollers on <out>. |
| 762 | * Should be performed only before initialization. |
| 763 | */ |
| 764 | int 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 Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 778 | if ((next < 0 || pollers[p].pref > next) |
Willy Tarreau | e79c3b2 | 2010-11-19 10:20:36 +0100 | [diff] [blame] | 779 | && (last < 0 || pollers[p].pref < last)) { |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 780 | next = pollers[p].pref; |
Willy Tarreau | e79c3b2 | 2010-11-19 10:20:36 +0100 | [diff] [blame] | 781 | if (!bp || (pollers[p].pref > bp->pref)) |
| 782 | bp = &pollers[p]; |
| 783 | } |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 784 | } |
| 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 Tarreau | e79c3b2 | 2010-11-19 10:20:36 +0100 | [diff] [blame] | 800 | } else { |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 801 | fprintf(out, " test result FAILED"); |
Willy Tarreau | e79c3b2 | 2010-11-19 10:20:36 +0100 | [diff] [blame] | 802 | if (bp == &pollers[p]) |
| 803 | bp = NULL; |
| 804 | } |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 805 | 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 | */ |
| 822 | int fork_poller() |
| 823 | { |
Conrad Hoffmann | 041751c | 2014-05-20 14:28:24 +0200 | [diff] [blame] | 824 | int fd; |
Willy Tarreau | ce036bc | 2018-01-29 14:58:02 +0100 | [diff] [blame] | 825 | for (fd = 0; fd < global.maxsock; fd++) { |
Conrad Hoffmann | 041751c | 2014-05-20 14:28:24 +0200 | [diff] [blame] | 826 | if (fdtab[fd].owner) { |
Willy Tarreau | 030dae1 | 2021-04-06 17:53:33 +0200 | [diff] [blame] | 827 | HA_ATOMIC_OR(&fdtab[fd].state, FD_CLONED); |
Conrad Hoffmann | 041751c | 2014-05-20 14:28:24 +0200 | [diff] [blame] | 828 | } |
| 829 | } |
| 830 | |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 831 | 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 Tarreau | bc52bec | 2020-06-18 08:58:47 +0200 | [diff] [blame] | 840 | /* config parser for global "tune.fd.edge-triggered", accepts "on" or "off" */ |
| 841 | static int cfg_parse_tune_fd_edge_triggered(char **args, int section_type, struct proxy *curpx, |
Willy Tarreau | 0182516 | 2021-03-09 09:53:46 +0100 | [diff] [blame] | 842 | const struct proxy *defpx, const char *file, int line, |
Willy Tarreau | bc52bec | 2020-06-18 08:58:47 +0200 | [diff] [blame] | 843 | 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 */ |
| 860 | static struct cfg_kw_list cfg_kws = {ILH, { |
Willy Tarreau | 9eec7e2 | 2021-05-08 11:06:32 +0200 | [diff] [blame] | 861 | { CFG_GLOBAL, "tune.fd.edge-triggered", cfg_parse_tune_fd_edge_triggered, KWF_EXPERIMENTAL }, |
Willy Tarreau | bc52bec | 2020-06-18 08:58:47 +0200 | [diff] [blame] | 862 | { 0, NULL, NULL } |
| 863 | }}; |
| 864 | |
| 865 | INITCALL1(STG_REGISTER, cfg_register_keywords, &cfg_kws); |
| 866 | |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 867 | REGISTER_PER_THREAD_ALLOC(alloc_pollers_per_thread); |
Willy Tarreau | 172f5ce | 2018-11-26 11:21:50 +0100 | [diff] [blame] | 868 | REGISTER_PER_THREAD_INIT(init_pollers_per_thread); |
| 869 | REGISTER_PER_THREAD_DEINIT(deinit_pollers_per_thread); |
Willy Tarreau | 082b628 | 2019-05-22 14:42:12 +0200 | [diff] [blame] | 870 | REGISTER_PER_THREAD_FREE(free_pollers_per_thread); |
Willy Tarreau | 172f5ce | 2018-11-26 11:21:50 +0100 | [diff] [blame] | 871 | |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 872 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 873 | * Local variables: |
| 874 | * c-indent-level: 8 |
| 875 | * c-basic-offset: 8 |
| 876 | * End: |
| 877 | */ |