Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 1 | /* |
| 2 | * FD polling functions for generic select() |
| 3 | * |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 4 | * Copyright 2000-2014 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +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 | * |
| 11 | */ |
| 12 | |
| 13 | #include <unistd.h> |
| 14 | #include <sys/time.h> |
| 15 | #include <sys/types.h> |
| 16 | |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 17 | #include <haproxy/activity.h> |
Willy Tarreau | 4c7e4b7 | 2020-05-27 12:58:42 +0200 | [diff] [blame] | 18 | #include <haproxy/api.h> |
Willy Tarreau | b255105 | 2020-06-09 09:07:15 +0200 | [diff] [blame] | 19 | #include <haproxy/fd.h> |
| 20 | #include <haproxy/global.h> |
Willy Tarreau | c2f7c58 | 2020-06-02 18:15:32 +0200 | [diff] [blame] | 21 | #include <haproxy/ticks.h> |
Willy Tarreau | 92b4f13 | 2020-06-01 11:05:15 +0200 | [diff] [blame] | 22 | #include <haproxy/time.h> |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 23 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 24 | |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 25 | /* private data */ |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 26 | static int maxfd; /* # of the highest fd + 1 */ |
Willy Tarreau | d51a507 | 2018-01-25 16:48:46 +0100 | [diff] [blame] | 27 | static unsigned int *fd_evts[2]; |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 28 | static THREAD_LOCAL fd_set *tmp_evts[2]; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 29 | |
Willy Tarreau | 4d31fb2 | 2012-11-11 16:53:50 +0100 | [diff] [blame] | 30 | /* Immediately remove the entry upon close() */ |
Willy Tarreau | 03e7853 | 2020-02-25 07:38:05 +0100 | [diff] [blame] | 31 | static void __fd_clo(int fd) |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 32 | { |
Willy Tarreau | d51a507 | 2018-01-25 16:48:46 +0100 | [diff] [blame] | 33 | hap_fd_clr(fd, fd_evts[DIR_RD]); |
| 34 | hap_fd_clr(fd, fd_evts[DIR_WR]); |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 35 | } |
| 36 | |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 37 | static void _update_fd(int fd, int *max_add_fd) |
| 38 | { |
| 39 | int en; |
| 40 | |
| 41 | en = fdtab[fd].state; |
| 42 | |
| 43 | /* we have a single state for all threads, which is why we |
| 44 | * don't check the tid_bit. First thread to see the update |
| 45 | * takes it for every other one. |
| 46 | */ |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 47 | if (!(en & FD_EV_ACTIVE_RW)) { |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 48 | if (!(polled_mask[fd].poll_recv | polled_mask[fd].poll_send)) { |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 49 | /* fd was not watched, it's still not */ |
| 50 | return; |
| 51 | } |
| 52 | /* fd totally removed from poll list */ |
| 53 | hap_fd_clr(fd, fd_evts[DIR_RD]); |
| 54 | hap_fd_clr(fd, fd_evts[DIR_WR]); |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 55 | _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, 0); |
Olivier Houchard | a3a8ea2 | 2019-08-05 23:54:37 +0200 | [diff] [blame] | 56 | _HA_ATOMIC_AND(&polled_mask[fd].poll_send, 0); |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 57 | } |
| 58 | else { |
| 59 | /* OK fd has to be monitored, it was either added or changed */ |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 60 | if (!(en & FD_EV_ACTIVE_R)) { |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 61 | hap_fd_clr(fd, fd_evts[DIR_RD]); |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 62 | if (polled_mask[fd].poll_recv & tid_bit) |
| 63 | _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit); |
| 64 | } else { |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 65 | hap_fd_set(fd, fd_evts[DIR_RD]); |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 66 | if (!(polled_mask[fd].poll_recv & tid_bit)) |
| 67 | _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit); |
| 68 | } |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 69 | |
Willy Tarreau | 5bee3e2 | 2019-09-04 09:52:57 +0200 | [diff] [blame] | 70 | if (!(en & FD_EV_ACTIVE_W)) { |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 71 | hap_fd_clr(fd, fd_evts[DIR_WR]); |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 72 | if (polled_mask[fd].poll_send & tid_bit) |
| 73 | _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit); |
| 74 | } else { |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 75 | hap_fd_set(fd, fd_evts[DIR_WR]); |
Olivier Houchard | 5305505 | 2019-07-25 14:00:18 +0000 | [diff] [blame] | 76 | if (!(polled_mask[fd].poll_send & tid_bit)) |
| 77 | _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit); |
| 78 | } |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 79 | |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 80 | if (fd > *max_add_fd) |
| 81 | *max_add_fd = fd; |
| 82 | } |
| 83 | } |
| 84 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 85 | /* |
| 86 | * Select() poller |
| 87 | */ |
Willy Tarreau | 03e7853 | 2020-02-25 07:38:05 +0100 | [diff] [blame] | 88 | static void _do_poll(struct poller *p, int exp, int wake) |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 89 | { |
| 90 | int status; |
| 91 | int fd, i; |
| 92 | struct timeval delta; |
Willy Tarreau | b0b37bc | 2008-06-23 14:00:57 +0200 | [diff] [blame] | 93 | int delta_ms; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 94 | int fds; |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 95 | int updt_idx; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 96 | char count; |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 97 | int readnotnull, writenotnull; |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 98 | int old_maxfd, new_maxfd, max_add_fd; |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 99 | int old_fd; |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 100 | |
| 101 | max_add_fd = -1; |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 102 | |
Willy Tarreau | 4d31fb2 | 2012-11-11 16:53:50 +0100 | [diff] [blame] | 103 | /* first, scan the update list to find changes */ |
| 104 | for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) { |
| 105 | fd = fd_updt[updt_idx]; |
Willy Tarreau | 4d31fb2 | 2012-11-11 16:53:50 +0100 | [diff] [blame] | 106 | |
Olivier Houchard | cb6c927 | 2019-03-08 18:49:54 +0100 | [diff] [blame] | 107 | _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit); |
Willy Tarreau | d80cb4e | 2018-01-20 19:30:13 +0100 | [diff] [blame] | 108 | if (!fdtab[fd].owner) { |
Willy Tarreau | e406386 | 2020-06-17 20:35:33 +0200 | [diff] [blame] | 109 | activity[tid].poll_drop_fd++; |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 110 | continue; |
Willy Tarreau | d80cb4e | 2018-01-20 19:30:13 +0100 | [diff] [blame] | 111 | } |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 112 | _update_fd(fd, &max_add_fd); |
| 113 | } |
| 114 | /* Now scan the global update list */ |
| 115 | for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) { |
| 116 | if (fd == -2) { |
| 117 | fd = old_fd; |
| 118 | continue; |
Willy Tarreau | f817e9f | 2014-01-10 16:58:45 +0100 | [diff] [blame] | 119 | } |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 120 | else if (fd <= -3) |
| 121 | fd = -fd -4; |
| 122 | if (fd == -1) |
| 123 | break; |
| 124 | if (fdtab[fd].update_mask & tid_bit) { |
| 125 | /* Cheat a bit, as the state is global to all pollers |
Willy Tarreau | 94a01e1 | 2021-01-06 17:35:12 +0100 | [diff] [blame] | 126 | * we don't need every thread to take care of the |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 127 | * update. |
| 128 | */ |
Olivier Houchard | cb6c927 | 2019-03-08 18:49:54 +0100 | [diff] [blame] | 129 | _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~all_threads_mask); |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 130 | done_update_polling(fd); |
| 131 | } else |
| 132 | continue; |
| 133 | if (!fdtab[fd].owner) |
| 134 | continue; |
| 135 | _update_fd(fd, &max_add_fd); |
Willy Tarreau | 4d31fb2 | 2012-11-11 16:53:50 +0100 | [diff] [blame] | 136 | } |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 137 | |
Olivier Houchard | 6b96f72 | 2018-04-25 16:58:25 +0200 | [diff] [blame] | 138 | |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 139 | /* maybe we added at least one fd larger than maxfd */ |
| 140 | for (old_maxfd = maxfd; old_maxfd <= max_add_fd; ) { |
Olivier Houchard | cb6c927 | 2019-03-08 18:49:54 +0100 | [diff] [blame] | 141 | if (_HA_ATOMIC_CAS(&maxfd, &old_maxfd, max_add_fd + 1)) |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 142 | break; |
| 143 | } |
| 144 | |
| 145 | /* maxfd doesn't need to be precise but it needs to cover *all* active |
| 146 | * FDs. Thus we only shrink it if we have such an opportunity. The algo |
| 147 | * is simple : look for the previous used place, try to update maxfd to |
| 148 | * point to it, abort if maxfd changed in the mean time. |
| 149 | */ |
| 150 | old_maxfd = maxfd; |
| 151 | do { |
| 152 | new_maxfd = old_maxfd; |
| 153 | while (new_maxfd - 1 >= 0 && !fdtab[new_maxfd - 1].owner) |
| 154 | new_maxfd--; |
| 155 | if (new_maxfd >= old_maxfd) |
| 156 | break; |
Olivier Houchard | cb6c927 | 2019-03-08 18:49:54 +0100 | [diff] [blame] | 157 | } while (!_HA_ATOMIC_CAS(&maxfd, &old_maxfd, new_maxfd)); |
Willy Tarreau | 173d995 | 2018-01-26 21:48:23 +0100 | [diff] [blame] | 158 | |
Willy Tarreau | 88d1c5d | 2021-08-04 11:44:17 +0200 | [diff] [blame] | 159 | thread_idle_now(); |
Willy Tarreau | 60b639c | 2018-08-02 10:16:17 +0200 | [diff] [blame] | 160 | thread_harmless_now(); |
| 161 | |
Willy Tarreau | 4d31fb2 | 2012-11-11 16:53:50 +0100 | [diff] [blame] | 162 | fd_nbupdt = 0; |
| 163 | |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 164 | /* let's restore fdset state */ |
| 165 | readnotnull = 0; writenotnull = 0; |
| 166 | for (i = 0; i < (maxfd + FD_SETSIZE - 1)/(8*sizeof(int)); i++) { |
| 167 | readnotnull |= (*(((int*)tmp_evts[DIR_RD])+i) = *(((int*)fd_evts[DIR_RD])+i)) != 0; |
| 168 | writenotnull |= (*(((int*)tmp_evts[DIR_WR])+i) = *(((int*)fd_evts[DIR_WR])+i)) != 0; |
| 169 | } |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 170 | |
Willy Tarreau | f37ba94 | 2018-10-17 11:25:54 +0200 | [diff] [blame] | 171 | /* now let's wait for events */ |
Willy Tarreau | 2ae84e4 | 2019-05-28 16:44:05 +0200 | [diff] [blame] | 172 | delta_ms = wake ? 0 : compute_poll_timeout(exp); |
Willy Tarreau | f37ba94 | 2018-10-17 11:25:54 +0200 | [diff] [blame] | 173 | delta.tv_sec = (delta_ms / 1000); |
| 174 | delta.tv_usec = (delta_ms % 1000) * 1000; |
Willy Tarreau | 7e9c4ae | 2018-10-17 14:31:19 +0200 | [diff] [blame] | 175 | tv_entering_poll(); |
Willy Tarreau | 609aad9 | 2018-11-22 08:31:09 +0100 | [diff] [blame] | 176 | activity_count_runtime(); |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 177 | status = select(maxfd, |
Willy Tarreau | 28d8686 | 2007-04-08 17:42:27 +0200 | [diff] [blame] | 178 | readnotnull ? tmp_evts[DIR_RD] : NULL, |
| 179 | writenotnull ? tmp_evts[DIR_WR] : NULL, |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 180 | NULL, |
Willy Tarreau | b0b37bc | 2008-06-23 14:00:57 +0200 | [diff] [blame] | 181 | &delta); |
Willy Tarreau | 48f8bc1 | 2018-11-22 18:57:37 +0100 | [diff] [blame] | 182 | tv_update_date(delta_ms, status); |
Willy Tarreau | 7e9c4ae | 2018-10-17 14:31:19 +0200 | [diff] [blame] | 183 | tv_leaving_poll(delta_ms, status); |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 184 | |
Willy Tarreau | 60b639c | 2018-08-02 10:16:17 +0200 | [diff] [blame] | 185 | thread_harmless_end(); |
Willy Tarreau | 88d1c5d | 2021-08-04 11:44:17 +0200 | [diff] [blame] | 186 | thread_idle_end(); |
| 187 | |
Olivier Houchard | 305d5ab | 2019-07-24 18:07:06 +0200 | [diff] [blame] | 188 | if (sleeping_thread_mask & tid_bit) |
| 189 | _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit); |
Willy Tarreau | 60b639c | 2018-08-02 10:16:17 +0200 | [diff] [blame] | 190 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 191 | if (status <= 0) |
| 192 | return; |
| 193 | |
Willy Tarreau | e545153 | 2020-06-17 20:25:18 +0200 | [diff] [blame] | 194 | activity[tid].poll_io++; |
| 195 | |
Willy Tarreau | 177e2b0 | 2008-07-15 00:36:31 +0200 | [diff] [blame] | 196 | for (fds = 0; (fds * BITS_PER_INT) < maxfd; fds++) { |
Willy Tarreau | 28d8686 | 2007-04-08 17:42:27 +0200 | [diff] [blame] | 197 | if ((((int *)(tmp_evts[DIR_RD]))[fds] | ((int *)(tmp_evts[DIR_WR]))[fds]) == 0) |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 198 | continue; |
| 199 | |
Willy Tarreau | 177e2b0 | 2008-07-15 00:36:31 +0200 | [diff] [blame] | 200 | for (count = BITS_PER_INT, fd = fds * BITS_PER_INT; count && fd < maxfd; count--, fd++) { |
Christopher Faulet | ab62f51 | 2017-08-30 10:34:36 +0200 | [diff] [blame] | 201 | unsigned int n = 0; |
| 202 | |
Willy Tarreau | fcc5281 | 2021-07-30 13:55:36 +0200 | [diff] [blame] | 203 | if (FD_ISSET(fd, tmp_evts[DIR_RD])) |
| 204 | n |= FD_EV_READY_R; |
| 205 | |
| 206 | if (FD_ISSET(fd, tmp_evts[DIR_WR])) |
| 207 | n |= FD_EV_READY_W; |
| 208 | |
| 209 | if (!n) |
| 210 | continue; |
| 211 | |
Willy Tarreau | 38e8a1c | 2020-06-23 10:04:54 +0200 | [diff] [blame] | 212 | #ifdef DEBUG_FD |
Willy Tarreau | 4781b15 | 2021-04-06 13:53:36 +0200 | [diff] [blame] | 213 | _HA_ATOMIC_INC(&fdtab[fd].event_count); |
Willy Tarreau | 38e8a1c | 2020-06-23 10:04:54 +0200 | [diff] [blame] | 214 | #endif |
Willy Tarreau | 076be25 | 2012-07-06 16:02:29 +0200 | [diff] [blame] | 215 | |
Christopher Faulet | ab62f51 | 2017-08-30 10:34:36 +0200 | [diff] [blame] | 216 | fd_update_events(fd, n); |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 217 | } |
| 218 | } |
| 219 | } |
| 220 | |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 221 | static int init_select_per_thread() |
| 222 | { |
| 223 | int fd_set_bytes; |
| 224 | |
| 225 | fd_set_bytes = sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE; |
Tim Duesterhus | 403fd72 | 2021-04-08 20:05:23 +0200 | [diff] [blame] | 226 | tmp_evts[DIR_RD] = calloc(1, fd_set_bytes); |
William Dauchy | 32fba0a | 2020-05-11 15:20:05 +0200 | [diff] [blame] | 227 | if (tmp_evts[DIR_RD] == NULL) |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 228 | goto fail; |
Tim Duesterhus | 403fd72 | 2021-04-08 20:05:23 +0200 | [diff] [blame] | 229 | tmp_evts[DIR_WR] = calloc(1, fd_set_bytes); |
William Dauchy | 32fba0a | 2020-05-11 15:20:05 +0200 | [diff] [blame] | 230 | if (tmp_evts[DIR_WR] == NULL) |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 231 | goto fail; |
| 232 | return 1; |
| 233 | fail: |
| 234 | free(tmp_evts[DIR_RD]); |
| 235 | free(tmp_evts[DIR_WR]); |
| 236 | return 0; |
| 237 | } |
| 238 | |
| 239 | static void deinit_select_per_thread() |
| 240 | { |
Willy Tarreau | 61cfdf4 | 2021-02-20 10:46:51 +0100 | [diff] [blame] | 241 | ha_free(&tmp_evts[DIR_WR]); |
| 242 | ha_free(&tmp_evts[DIR_RD]); |
Christopher Faulet | d4604ad | 2017-05-29 10:40:41 +0200 | [diff] [blame] | 243 | } |
| 244 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 245 | /* |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 246 | * Initialization of the select() poller. |
| 247 | * Returns 0 in case of failure, non-zero in case of success. If it fails, it |
| 248 | * disables the poller by setting its pref to 0. |
| 249 | */ |
Willy Tarreau | 03e7853 | 2020-02-25 07:38:05 +0100 | [diff] [blame] | 250 | static int _do_init(struct poller *p) |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 251 | { |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 252 | int fd_set_bytes; |
| 253 | |
| 254 | p->private = NULL; |
Willy Tarreau | 3fa87b1 | 2013-03-31 14:41:15 +0200 | [diff] [blame] | 255 | |
| 256 | if (global.maxsock > FD_SETSIZE) |
William Dauchy | 42a50bd | 2020-05-11 15:20:03 +0200 | [diff] [blame] | 257 | goto fail_srevt; |
Willy Tarreau | 3fa87b1 | 2013-03-31 14:41:15 +0200 | [diff] [blame] | 258 | |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 259 | fd_set_bytes = sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE; |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 260 | |
Willy Tarreau | d51a507 | 2018-01-25 16:48:46 +0100 | [diff] [blame] | 261 | if ((fd_evts[DIR_RD] = calloc(1, fd_set_bytes)) == NULL) |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 262 | goto fail_srevt; |
Willy Tarreau | d51a507 | 2018-01-25 16:48:46 +0100 | [diff] [blame] | 263 | if ((fd_evts[DIR_WR] = calloc(1, fd_set_bytes)) == NULL) |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 264 | goto fail_swevt; |
| 265 | |
Christopher Faulet | cd7879a | 2017-10-27 13:53:47 +0200 | [diff] [blame] | 266 | hap_register_per_thread_init(init_select_per_thread); |
| 267 | hap_register_per_thread_deinit(deinit_select_per_thread); |
| 268 | |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 269 | return 1; |
| 270 | |
| 271 | fail_swevt: |
| 272 | free(fd_evts[DIR_RD]); |
| 273 | fail_srevt: |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 274 | p->pref = 0; |
| 275 | return 0; |
| 276 | } |
| 277 | |
| 278 | /* |
| 279 | * Termination of the select() poller. |
| 280 | * Memory is released and the poller is marked as unselectable. |
| 281 | */ |
Willy Tarreau | 03e7853 | 2020-02-25 07:38:05 +0100 | [diff] [blame] | 282 | static void _do_term(struct poller *p) |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 283 | { |
Willy Tarreau | a534fea | 2008-08-03 12:19:50 +0200 | [diff] [blame] | 284 | free(fd_evts[DIR_WR]); |
| 285 | free(fd_evts[DIR_RD]); |
Willy Tarreau | e54e917 | 2007-04-09 09:23:31 +0200 | [diff] [blame] | 286 | p->private = NULL; |
| 287 | p->pref = 0; |
| 288 | } |
| 289 | |
| 290 | /* |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 291 | * Check that the poller works. |
| 292 | * Returns 1 if OK, otherwise 0. |
| 293 | */ |
Willy Tarreau | 03e7853 | 2020-02-25 07:38:05 +0100 | [diff] [blame] | 294 | static int _do_test(struct poller *p) |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 295 | { |
Willy Tarreau | 3fa87b1 | 2013-03-31 14:41:15 +0200 | [diff] [blame] | 296 | if (global.maxsock > FD_SETSIZE) |
| 297 | return 0; |
| 298 | |
Willy Tarreau | 2ff7622 | 2007-04-09 19:29:56 +0200 | [diff] [blame] | 299 | return 1; |
| 300 | } |
| 301 | |
| 302 | /* |
Willy Tarreau | ef1d1f8 | 2007-04-16 00:25:25 +0200 | [diff] [blame] | 303 | * It is a constructor, which means that it will automatically be called before |
| 304 | * main(). This is GCC-specific but it works at least since 2.95. |
| 305 | * Special care must be taken so that it does not need any uninitialized data. |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 306 | */ |
Willy Tarreau | ef1d1f8 | 2007-04-16 00:25:25 +0200 | [diff] [blame] | 307 | __attribute__((constructor)) |
| 308 | static void _do_register(void) |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 309 | { |
Willy Tarreau | ef1d1f8 | 2007-04-16 00:25:25 +0200 | [diff] [blame] | 310 | struct poller *p; |
| 311 | |
| 312 | if (nbpollers >= MAX_POLLERS) |
| 313 | return; |
| 314 | p = &pollers[nbpollers++]; |
| 315 | |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 316 | p->name = "select"; |
| 317 | p->pref = 150; |
Willy Tarreau | 5a76769 | 2017-03-13 11:38:28 +0100 | [diff] [blame] | 318 | p->flags = 0; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 319 | p->private = NULL; |
| 320 | |
Willy Tarreau | 70c6fd8 | 2012-11-11 21:02:34 +0100 | [diff] [blame] | 321 | p->clo = __fd_clo; |
Willy Tarreau | ef1d1f8 | 2007-04-16 00:25:25 +0200 | [diff] [blame] | 322 | p->test = _do_test; |
| 323 | p->init = _do_init; |
| 324 | p->term = _do_term; |
| 325 | p->poll = _do_poll; |
Willy Tarreau | 4f60f16 | 2007-04-08 16:39:58 +0200 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | |
| 329 | /* |
| 330 | * Local variables: |
| 331 | * c-indent-level: 8 |
| 332 | * c-basic-offset: 8 |
| 333 | * End: |
| 334 | */ |