blob: a00813584f29c1629a253aad93f52ac8ad988ae2 [file] [log] [blame]
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +00001/*
2 * FD polling functions for SunOS event ports.
3 *
4 * Copyright 2018 Joyent, Inc.
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#include <unistd.h>
13#include <sys/time.h>
14#include <sys/types.h>
15
16#include <poll.h>
17#include <port.h>
18#include <errno.h>
19#include <syslog.h>
20
Willy Tarreaub2551052020-06-09 09:07:15 +020021#include <haproxy/activity.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020022#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020023#include <haproxy/fd.h>
24#include <haproxy/global.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +020025#include <haproxy/signal.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020026#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020027#include <haproxy/time.h>
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000028
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000029/*
30 * Private data:
31 */
32static int evports_fd[MAX_THREADS]; // per-thread evports_fd
33static THREAD_LOCAL port_event_t *evports_evlist = NULL;
34static THREAD_LOCAL int evports_evlist_max = 0;
35
36/*
37 * Convert the "state" member of "fdtab" into an event ports event mask.
38 */
39static inline int evports_state_to_events(int state)
40{
41 int events = 0;
42
Willy Tarreau5bee3e22019-09-04 09:52:57 +020043 if (state & FD_EV_ACTIVE_W)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000044 events |= POLLOUT;
Willy Tarreau5bee3e22019-09-04 09:52:57 +020045 if (state & FD_EV_ACTIVE_R)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000046 events |= POLLIN;
47
48 return (events);
49}
50
51/*
52 * Associate or dissociate this file descriptor with the event port, using the
53 * specified event mask.
54 */
55static inline void evports_resync_fd(int fd, int events)
56{
57 if (events == 0)
58 port_dissociate(evports_fd[tid], PORT_SOURCE_FD, fd);
59 else
60 port_associate(evports_fd[tid], PORT_SOURCE_FD, fd, events, NULL);
61}
62
63static void _update_fd(int fd)
64{
65 int en;
66 int events;
67
68 en = fdtab[fd].state;
69
Willy Tarreau5bee3e22019-09-04 09:52:57 +020070 if (!(fdtab[fd].thread_mask & tid_bit) || !(en & FD_EV_ACTIVE_RW)) {
Olivier Houchard53055052019-07-25 14:00:18 +000071 if (!(polled_mask[fd].poll_recv & tid_bit) &&
72 !(polled_mask[fd].poll_send & tid_bit)) {
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000073 /* fd was not watched, it's still not */
74 return;
75 }
76 /* fd totally removed from poll list */
77 events = 0;
Olivier Houchard53055052019-07-25 14:00:18 +000078 if (polled_mask[fd].poll_recv & tid_bit)
79 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
80 if (polled_mask[fd].poll_send & tid_bit)
81 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +000082 }
83 else {
84 /* OK fd has to be monitored, it was either added or changed */
85 events = evports_state_to_events(en);
Willy Tarreau5bee3e22019-09-04 09:52:57 +020086 if (en & FD_EV_ACTIVE_R) {
Olivier Houchard53055052019-07-25 14:00:18 +000087 if (!(polled_mask[fd].poll_recv & tid_bit))
88 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
89 } else {
90 if (polled_mask[fd].poll_recv & tid_bit)
91 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
92 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +020093 if (en & FD_EV_ACTIVE_W) {
Olivier Houchard53055052019-07-25 14:00:18 +000094 if (!(polled_mask[fd].poll_send & tid_bit))
95 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
96 } else {
97 if (polled_mask[fd].poll_send & tid_bit)
98 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
99 }
100
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000101 }
102 evports_resync_fd(fd, events);
103}
104
105/*
106 * Event Ports poller. This routine interacts with the file descriptor
107 * management data structures and routines; see the large block comment in
108 * "src/fd.c" for more information.
109 */
110
Willy Tarreau03e78532020-02-25 07:38:05 +0100111static void _do_poll(struct poller *p, int exp, int wake)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000112{
113 int i;
114 int wait_time;
115 struct timespec timeout_ts;
116 unsigned int nevlist;
117 int fd, old_fd;
118 int status;
119
120 /*
121 * Scan the list of file descriptors with an updated status:
122 */
123 for (i = 0; i < fd_nbupdt; i++) {
124 fd = fd_updt[i];
125
126 _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
127 if (fdtab[fd].owner == NULL) {
Willy Tarreaue4063862020-06-17 20:35:33 +0200128 activity[tid].poll_drop_fd++;
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000129 continue;
130 }
131
132 _update_fd(fd);
133 }
134 fd_nbupdt = 0;
135 /* Scan the global update list */
136 for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) {
137 if (fd == -2) {
138 fd = old_fd;
139 continue;
140 }
141 else if (fd <= -3)
142 fd = -fd -4;
143 if (fd == -1)
144 break;
145 if (fdtab[fd].update_mask & tid_bit)
146 done_update_polling(fd);
147 else
148 continue;
149 if (!fdtab[fd].owner)
150 continue;
151 _update_fd(fd);
152 }
153
154 thread_harmless_now();
Olivier Houchard305d5ab2019-07-24 18:07:06 +0200155 if (sleeping_thread_mask & tid_bit)
156 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000157
158 /*
159 * Determine how long to wait for events to materialise on the port.
160 */
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200161 wait_time = wake ? 0 : compute_poll_timeout(exp);
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000162 tv_entering_poll();
163 activity_count_runtime();
164
165 do {
166 int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
167 int interrupted = 0;
168 nevlist = 1; /* desired number of events to be retrieved */
169 timeout_ts.tv_sec = (timeout / 1000);
170 timeout_ts.tv_nsec = (timeout % 1000) * 1000000;
171
172 status = port_getn(evports_fd[tid],
173 evports_evlist,
174 evports_evlist_max,
175 &nevlist, /* updated to the number of events retrieved */
176 &timeout_ts);
177 if (status != 0) {
178 int e = errno;
179 switch (e) {
180 case ETIME:
181 /*
182 * Though the manual page has not historically made it
183 * clear, port_getn() can return -1 with an errno of
184 * ETIME and still have returned some number of events.
185 */
186 /* nevlist >= 0 */
187 break;
188 default:
189 nevlist = 0;
190 interrupted = 1;
191 break;
192 }
193 }
194 tv_update_date(timeout, nevlist);
195
196 if (nevlist || interrupted)
197 break;
198 if (timeout || !wait_time)
199 break;
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200200 if (signal_queue_len || wake)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000201 break;
202 if (tick_isset(exp) && tick_is_expired(exp, now_ms))
203 break;
204 } while(1);
205
206 tv_leaving_poll(wait_time, nevlist);
207
208 thread_harmless_end();
209
Willy Tarreaue5451532020-06-17 20:25:18 +0200210 if (nevlist > 0)
211 activity[tid].poll_io++;
212
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000213 for (i = 0; i < nevlist; i++) {
214 unsigned int n = 0;
215 int events, rebind_events;
216 fd = evports_evlist[i].portev_object;
217 events = evports_evlist[i].portev_events;
218
219 if (fdtab[fd].owner == NULL) {
Willy Tarreaue4063862020-06-17 20:35:33 +0200220 activity[tid].poll_dead_fd++;
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000221 continue;
222 }
223
224 if (!(fdtab[fd].thread_mask & tid_bit)) {
Willy Tarreaue4063862020-06-17 20:35:33 +0200225 activity[tid].poll_skip_fd++;
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000226 continue;
227 }
228
229 /*
230 * By virtue of receiving an event for this file descriptor, it
231 * is no longer associated with the port in question. Store
232 * the previous event mask so that we may reassociate after
233 * processing is complete.
234 */
235 rebind_events = evports_state_to_events(fdtab[fd].state);
236 /* rebind_events != 0 */
237
238 /*
239 * Set bits based on the events we received from the port:
240 */
Emmanuel Hocdet7ceb96b2019-09-19 11:08:26 +0000241 n = ((events & POLLIN) ? FD_EV_READY_R : 0) |
242 ((events & POLLOUT) ? FD_EV_READY_W : 0) |
243 ((events & POLLHUP) ? FD_EV_SHUT_RW : 0) |
244 ((events & POLLERR) ? FD_EV_ERR_RW : 0);
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000245
246 /*
247 * Call connection processing callbacks. Note that it's
248 * possible for this processing to alter the required event
Ilya Shipitsince7b00f2020-03-23 22:28:40 +0500249 * port association; i.e., the "state" member of the "fdtab"
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000250 * entry. If it changes, the fd will be placed on the updated
251 * list for processing the next time we are called.
252 */
253 fd_update_events(fd, n);
254
255 /*
256 * This file descriptor was closed during the processing of
257 * polled events. No need to reassociate.
258 */
259 if (fdtab[fd].owner == NULL)
260 continue;
261
262 /*
263 * Reassociate with the port, using the same event mask as
264 * before. This call will not result in a dissociation as we
265 * asserted that _some_ events needed to be rebound above.
266 *
267 * Reassociating with the same mask allows us to mimic the
268 * level-triggered behaviour of poll(2). In the event that we
269 * are interested in the same events on the next turn of the
270 * loop, this represents no extra work.
271 *
272 * If this additional port_associate(3C) call becomes a
273 * performance problem, we would need to verify that we can
274 * correctly interact with the file descriptor cache and update
275 * list (see "src/fd.c") to avoid reassociating here, or to use
276 * a different events mask.
277 */
278 evports_resync_fd(fd, rebind_events);
279 }
280}
281
282static int init_evports_per_thread()
283{
284 int fd;
285
286 evports_evlist_max = global.tune.maxpollevents;
287 evports_evlist = calloc(evports_evlist_max, sizeof (port_event_t));
288 if (evports_evlist == NULL) {
289 goto fail_alloc;
290 }
291
292 if (MAX_THREADS > 1 && tid) {
293 if ((evports_fd[tid] = port_create()) == -1) {
294 goto fail_fd;
295 }
296 }
297
298 /* we may have to unregister some events initially registered on the
299 * original fd when it was alone, and/or to register events on the new
300 * fd for this thread. Let's just mark them as updated, the poller will
301 * do the rest.
302 */
303 for (fd = 0; fd < global.maxsock; fd++)
304 updt_fd_polling(fd);
305
306 return 1;
307
308 fail_fd:
309 free(evports_evlist);
310 evports_evlist = NULL;
311 evports_evlist_max = 0;
312 fail_alloc:
313 return 0;
314}
315
316static void deinit_evports_per_thread()
317{
318 if (MAX_THREADS > 1 && tid)
319 close(evports_fd[tid]);
320
321 free(evports_evlist);
322 evports_evlist = NULL;
323 evports_evlist_max = 0;
324}
325
326/*
327 * Initialisation of the event ports poller.
328 * Returns 0 in case of failure, non-zero in case of success.
329 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100330static int _do_init(struct poller *p)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000331{
332 p->private = NULL;
333
334 if ((evports_fd[tid] = port_create()) == -1) {
335 goto fail;
336 }
337
338 hap_register_per_thread_init(init_evports_per_thread);
339 hap_register_per_thread_deinit(deinit_evports_per_thread);
340
341 return 1;
342
343fail:
344 p->pref = 0;
345 return 0;
346}
347
348/*
349 * Termination of the event ports poller.
350 * All resources are released and the poller is marked as inoperative.
351 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100352static void _do_term(struct poller *p)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000353{
354 if (evports_fd[tid] != -1) {
355 close(evports_fd[tid]);
356 evports_fd[tid] = -1;
357 }
358
359 p->private = NULL;
360 p->pref = 0;
361
362 free(evports_evlist);
363 evports_evlist = NULL;
364 evports_evlist_max = 0;
365}
366
367/*
368 * Run-time check to make sure we can allocate the resources needed for
369 * the poller to function correctly.
370 * Returns 1 on success, otherwise 0.
371 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100372static int _do_test(struct poller *p)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000373{
374 int fd;
375
376 if ((fd = port_create()) == -1) {
377 return 0;
378 }
379
380 close(fd);
381 return 1;
382}
383
384/*
385 * Close and recreate the event port after fork(). Returns 1 on success,
386 * otherwise 0. If this function fails, "_do_term()" must be called to
387 * clean up the poller.
388 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100389static int _do_fork(struct poller *p)
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000390{
391 if (evports_fd[tid] != -1) {
392 close(evports_fd[tid]);
393 }
394
395 if ((evports_fd[tid] = port_create()) == -1) {
396 return 0;
397 }
398
399 return 1;
400}
401
402/*
403 * This constructor must be called before main() to register the event ports
404 * poller.
405 */
406__attribute__((constructor))
407static void _do_register(void)
408{
409 struct poller *p;
410 int i;
411
412 if (nbpollers >= MAX_POLLERS)
413 return;
414
415 for (i = 0; i < MAX_THREADS; i++)
416 evports_fd[i] = -1;
417
418 p = &pollers[nbpollers++];
419
420 p->name = "evports";
421 p->pref = 300;
Willy Tarreau11ef0832019-11-28 18:17:33 +0100422 p->flags = HAP_POLL_F_ERRHUP;
Emmanuel Hocdet0ba4f482019-04-08 16:53:32 +0000423 p->private = NULL;
424
425 p->clo = NULL;
426 p->test = _do_test;
427 p->init = _do_init;
428 p->term = _do_term;
429 p->poll = _do_poll;
430 p->fork = _do_fork;
431}