blob: 6e834678db4e6bf8b46c5749f3e428cb53fe73ec [file] [log] [blame]
Willy Tarreau4f60f162007-04-08 16:39:58 +02001/*
2 * FD polling functions for generic select()
3 *
Willy Tarreauf817e9f2014-01-10 16:58:45 +01004 * Copyright 2000-2014 Willy Tarreau <w@1wt.eu>
Willy Tarreau4f60f162007-04-08 16:39:58 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <unistd.h>
14#include <sys/time.h>
15#include <sys/types.h>
16
17#include <common/compat.h>
18#include <common/config.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020019#include <common/ticks.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020020#include <common/time.h>
21
Willy Tarreau4f60f162007-04-08 16:39:58 +020022#include <types/global.h>
23
24#include <proto/fd.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020025
26
Christopher Fauletd4604ad2017-05-29 10:40:41 +020027/* private data */
Willy Tarreau173d9952018-01-26 21:48:23 +010028static int maxfd; /* # of the highest fd + 1 */
Willy Tarreaud51a5072018-01-25 16:48:46 +010029static unsigned int *fd_evts[2];
Christopher Fauletd4604ad2017-05-29 10:40:41 +020030static THREAD_LOCAL fd_set *tmp_evts[2];
Willy Tarreau4f60f162007-04-08 16:39:58 +020031
Willy Tarreau4d31fb22012-11-11 16:53:50 +010032/* Immediately remove the entry upon close() */
33REGPRM1 static void __fd_clo(int fd)
Willy Tarreau4f60f162007-04-08 16:39:58 +020034{
Willy Tarreaud51a5072018-01-25 16:48:46 +010035 hap_fd_clr(fd, fd_evts[DIR_RD]);
36 hap_fd_clr(fd, fd_evts[DIR_WR]);
Willy Tarreau4f60f162007-04-08 16:39:58 +020037}
38
Willy Tarreau4f60f162007-04-08 16:39:58 +020039/*
40 * Select() poller
41 */
Willy Tarreau0c303ee2008-07-07 00:09:58 +020042REGPRM2 static void _do_poll(struct poller *p, int exp)
Willy Tarreau4f60f162007-04-08 16:39:58 +020043{
44 int status;
45 int fd, i;
46 struct timeval delta;
Willy Tarreaub0b37bc2008-06-23 14:00:57 +020047 int delta_ms;
Willy Tarreau4f60f162007-04-08 16:39:58 +020048 int fds;
Willy Tarreaud4daeac2018-01-25 17:15:43 +010049 int updt_idx, en;
Willy Tarreau4f60f162007-04-08 16:39:58 +020050 char count;
Christopher Fauletd4604ad2017-05-29 10:40:41 +020051 int readnotnull, writenotnull;
Willy Tarreau173d9952018-01-26 21:48:23 +010052 int old_maxfd, new_maxfd, max_add_fd;
53
54 max_add_fd = -1;
Christopher Fauletd4604ad2017-05-29 10:40:41 +020055
Willy Tarreau4d31fb22012-11-11 16:53:50 +010056 /* first, scan the update list to find changes */
57 for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) {
58 fd = fd_updt[updt_idx];
Willy Tarreau4d31fb22012-11-11 16:53:50 +010059
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010060 if (!fdtab[fd].owner) {
61 activity[tid].poll_drop++;
Willy Tarreauf817e9f2014-01-10 16:58:45 +010062 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +010063 }
Willy Tarreau4d31fb22012-11-11 16:53:50 +010064
Willy Tarreaud4daeac2018-01-25 17:15:43 +010065 en = fdtab[fd].state;
Willy Tarreau62a627a2018-01-25 18:06:46 +010066 HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
Willy Tarreauf817e9f2014-01-10 16:58:45 +010067
Willy Tarreau56dd12a2018-01-25 17:09:33 +010068 /* we have a single state for all threads, which is why we
69 * don't check the tid_bit. First thread to see the update
70 * takes it for every other one.
71 */
72 if (!(en & FD_EV_POLLED_RW)) {
73 if (!fdtab[fd].polled_mask) {
74 /* fd was not watched, it's still not */
75 continue;
76 }
77 /* fd totally removed from poll list */
78 hap_fd_clr(fd, fd_evts[DIR_RD]);
79 hap_fd_clr(fd, fd_evts[DIR_WR]);
80 HA_ATOMIC_AND(&fdtab[fd].polled_mask, 0);
81 }
82 else {
83 /* OK fd has to be monitored, it was either added or changed */
84 if (!(en & FD_EV_POLLED_R))
Willy Tarreaud51a5072018-01-25 16:48:46 +010085 hap_fd_clr(fd, fd_evts[DIR_RD]);
Willy Tarreau56dd12a2018-01-25 17:09:33 +010086 else
Willy Tarreaud51a5072018-01-25 16:48:46 +010087 hap_fd_set(fd, fd_evts[DIR_RD]);
Willy Tarreauf817e9f2014-01-10 16:58:45 +010088
Willy Tarreau56dd12a2018-01-25 17:09:33 +010089 if (!(en & FD_EV_POLLED_W))
Willy Tarreaud51a5072018-01-25 16:48:46 +010090 hap_fd_clr(fd, fd_evts[DIR_WR]);
Willy Tarreau56dd12a2018-01-25 17:09:33 +010091 else
Willy Tarreaud51a5072018-01-25 16:48:46 +010092 hap_fd_set(fd, fd_evts[DIR_WR]);
Willy Tarreau56dd12a2018-01-25 17:09:33 +010093
94 HA_ATOMIC_OR(&fdtab[fd].polled_mask, tid_bit);
95 if (fd > max_add_fd)
96 max_add_fd = fd;
Willy Tarreauf817e9f2014-01-10 16:58:45 +010097 }
Willy Tarreau4d31fb22012-11-11 16:53:50 +010098 }
Willy Tarreau173d9952018-01-26 21:48:23 +010099
100 /* maybe we added at least one fd larger than maxfd */
101 for (old_maxfd = maxfd; old_maxfd <= max_add_fd; ) {
102 if (HA_ATOMIC_CAS(&maxfd, &old_maxfd, max_add_fd + 1))
103 break;
104 }
105
106 /* maxfd doesn't need to be precise but it needs to cover *all* active
107 * FDs. Thus we only shrink it if we have such an opportunity. The algo
108 * is simple : look for the previous used place, try to update maxfd to
109 * point to it, abort if maxfd changed in the mean time.
110 */
111 old_maxfd = maxfd;
112 do {
113 new_maxfd = old_maxfd;
114 while (new_maxfd - 1 >= 0 && !fdtab[new_maxfd - 1].owner)
115 new_maxfd--;
116 if (new_maxfd >= old_maxfd)
117 break;
118 } while (!HA_ATOMIC_CAS(&maxfd, &old_maxfd, new_maxfd));
119
Willy Tarreau4d31fb22012-11-11 16:53:50 +0100120 fd_nbupdt = 0;
121
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200122 /* let's restore fdset state */
123 readnotnull = 0; writenotnull = 0;
124 for (i = 0; i < (maxfd + FD_SETSIZE - 1)/(8*sizeof(int)); i++) {
125 readnotnull |= (*(((int*)tmp_evts[DIR_RD])+i) = *(((int*)fd_evts[DIR_RD])+i)) != 0;
126 writenotnull |= (*(((int*)tmp_evts[DIR_WR])+i) = *(((int*)fd_evts[DIR_WR])+i)) != 0;
127 }
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200128
Willy Tarreau0c303ee2008-07-07 00:09:58 +0200129 delta_ms = 0;
130 delta.tv_sec = 0;
131 delta.tv_usec = 0;
132
Willy Tarreau10146c92015-04-13 20:44:19 +0200133 if (!exp) {
134 delta_ms = MAX_DELAY_MS;
135 delta.tv_sec = (MAX_DELAY_MS / 1000);
136 delta.tv_usec = (MAX_DELAY_MS % 1000) * 1000;
137 }
138 else if (!tick_is_expired(exp, now_ms)) {
139 delta_ms = TICKS_TO_MS(tick_remain(now_ms, exp)) + SCHEDULER_RESOLUTION;
140 if (delta_ms > MAX_DELAY_MS)
141 delta_ms = MAX_DELAY_MS;
142 delta.tv_sec = (delta_ms / 1000);
143 delta.tv_usec = (delta_ms % 1000) * 1000;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200144 }
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100145 else
146 activity[tid].poll_exp++;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200147
Willy Tarreau45a12512011-09-10 16:56:42 +0200148 gettimeofday(&before_poll, NULL);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200149 status = select(maxfd,
Willy Tarreau28d86862007-04-08 17:42:27 +0200150 readnotnull ? tmp_evts[DIR_RD] : NULL,
151 writenotnull ? tmp_evts[DIR_WR] : NULL,
Willy Tarreau4f60f162007-04-08 16:39:58 +0200152 NULL,
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200153 &delta);
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200154
Willy Tarreaub0b37bc2008-06-23 14:00:57 +0200155 tv_update_date(delta_ms, status);
Willy Tarreau45a12512011-09-10 16:56:42 +0200156 measure_idle();
Willy Tarreau4f60f162007-04-08 16:39:58 +0200157
158 if (status <= 0)
159 return;
160
Willy Tarreau177e2b02008-07-15 00:36:31 +0200161 for (fds = 0; (fds * BITS_PER_INT) < maxfd; fds++) {
Willy Tarreau28d86862007-04-08 17:42:27 +0200162 if ((((int *)(tmp_evts[DIR_RD]))[fds] | ((int *)(tmp_evts[DIR_WR]))[fds]) == 0)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200163 continue;
164
Willy Tarreau177e2b02008-07-15 00:36:31 +0200165 for (count = BITS_PER_INT, fd = fds * BITS_PER_INT; count && fd < maxfd; count--, fd++) {
Christopher Fauletab62f512017-08-30 10:34:36 +0200166 unsigned int n = 0;
167
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100168 if (!fdtab[fd].owner) {
169 activity[tid].poll_dead++;
170 continue;
171 }
172
173 if (!(fdtab[fd].thread_mask & tid_bit)) {
174 activity[tid].poll_skip++;
Willy Tarreau076be252012-07-06 16:02:29 +0200175 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100176 }
Willy Tarreau076be252012-07-06 16:02:29 +0200177
Willy Tarreau076be252012-07-06 16:02:29 +0200178 if (FD_ISSET(fd, tmp_evts[DIR_RD]))
Christopher Fauletab62f512017-08-30 10:34:36 +0200179 n |= FD_POLL_IN;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200180
Willy Tarreau076be252012-07-06 16:02:29 +0200181 if (FD_ISSET(fd, tmp_evts[DIR_WR]))
Christopher Fauletab62f512017-08-30 10:34:36 +0200182 n |= FD_POLL_OUT;
Willy Tarreau5be2f352014-11-19 19:43:05 +0100183
Christopher Fauletab62f512017-08-30 10:34:36 +0200184 fd_update_events(fd, n);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200185 }
186 }
187}
188
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200189static int init_select_per_thread()
190{
191 int fd_set_bytes;
192
193 fd_set_bytes = sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE;
194 if ((tmp_evts[DIR_RD] = (fd_set *)calloc(1, fd_set_bytes)) == NULL)
195 goto fail;
196 if ((tmp_evts[DIR_WR] = (fd_set *)calloc(1, fd_set_bytes)) == NULL)
197 goto fail;
198 return 1;
199 fail:
200 free(tmp_evts[DIR_RD]);
201 free(tmp_evts[DIR_WR]);
202 return 0;
203}
204
205static void deinit_select_per_thread()
206{
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200207 free(tmp_evts[DIR_WR]); tmp_evts[DIR_WR] = NULL;
208 free(tmp_evts[DIR_RD]); tmp_evts[DIR_RD] = NULL;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200209}
210
Willy Tarreau4f60f162007-04-08 16:39:58 +0200211/*
Willy Tarreaue54e9172007-04-09 09:23:31 +0200212 * Initialization of the select() poller.
213 * Returns 0 in case of failure, non-zero in case of success. If it fails, it
214 * disables the poller by setting its pref to 0.
215 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200216REGPRM1 static int _do_init(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200217{
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200218 __label__ fail_swevt, fail_srevt, fail_revt;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200219 int fd_set_bytes;
220
221 p->private = NULL;
Willy Tarreau3fa87b12013-03-31 14:41:15 +0200222
223 if (global.maxsock > FD_SETSIZE)
224 goto fail_revt;
225
Willy Tarreaue54e9172007-04-09 09:23:31 +0200226 fd_set_bytes = sizeof(fd_set) * (global.maxsock + FD_SETSIZE - 1) / FD_SETSIZE;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200227
Willy Tarreaud51a5072018-01-25 16:48:46 +0100228 if ((fd_evts[DIR_RD] = calloc(1, fd_set_bytes)) == NULL)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200229 goto fail_srevt;
Willy Tarreaud51a5072018-01-25 16:48:46 +0100230 if ((fd_evts[DIR_WR] = calloc(1, fd_set_bytes)) == NULL)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200231 goto fail_swevt;
232
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200233 hap_register_per_thread_init(init_select_per_thread);
234 hap_register_per_thread_deinit(deinit_select_per_thread);
235
Willy Tarreaue54e9172007-04-09 09:23:31 +0200236 return 1;
237
238 fail_swevt:
239 free(fd_evts[DIR_RD]);
240 fail_srevt:
241 free(tmp_evts[DIR_WR]);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200242 free(tmp_evts[DIR_RD]);
243 fail_revt:
244 p->pref = 0;
245 return 0;
246}
247
248/*
249 * Termination of the select() poller.
250 * Memory is released and the poller is marked as unselectable.
251 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200252REGPRM1 static void _do_term(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200253{
Willy Tarreaua534fea2008-08-03 12:19:50 +0200254 free(fd_evts[DIR_WR]);
255 free(fd_evts[DIR_RD]);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200256 p->private = NULL;
257 p->pref = 0;
258}
259
260/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200261 * Check that the poller works.
262 * Returns 1 if OK, otherwise 0.
263 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200264REGPRM1 static int _do_test(struct poller *p)
Willy Tarreau2ff76222007-04-09 19:29:56 +0200265{
Willy Tarreau3fa87b12013-03-31 14:41:15 +0200266 if (global.maxsock > FD_SETSIZE)
267 return 0;
268
Willy Tarreau2ff76222007-04-09 19:29:56 +0200269 return 1;
270}
271
272/*
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200273 * It is a constructor, which means that it will automatically be called before
274 * main(). This is GCC-specific but it works at least since 2.95.
275 * Special care must be taken so that it does not need any uninitialized data.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200276 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200277__attribute__((constructor))
278static void _do_register(void)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200279{
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200280 struct poller *p;
281
282 if (nbpollers >= MAX_POLLERS)
283 return;
284 p = &pollers[nbpollers++];
285
Willy Tarreau4f60f162007-04-08 16:39:58 +0200286 p->name = "select";
287 p->pref = 150;
Willy Tarreau5a767692017-03-13 11:38:28 +0100288 p->flags = 0;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200289 p->private = NULL;
290
Willy Tarreau70c6fd82012-11-11 21:02:34 +0100291 p->clo = __fd_clo;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200292 p->test = _do_test;
293 p->init = _do_init;
294 p->term = _do_term;
295 p->poll = _do_poll;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200296}
297
298
299/*
300 * Local variables:
301 * c-indent-level: 8
302 * c-basic-offset: 8
303 * End:
304 */