blob: 92c000f85937413e42869d0ce5e4c511565804a4 [file] [log] [blame]
Willy Tarreau4f60f162007-04-08 16:39:58 +02001/*
Willy Tarreaue9f49e72012-11-11 17:42:00 +01002 * FD polling functions for Linux epoll
Willy Tarreau4f60f162007-04-08 16:39:58 +02003 *
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.
Willy Tarreau4f60f162007-04-08 16:39:58 +020010 */
11
12#include <unistd.h>
Willy Tarreau3858b122020-03-10 07:08:10 +010013#include <sys/epoll.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020014#include <sys/time.h>
15#include <sys/types.h>
16
Willy Tarreaub2551052020-06-09 09:07:15 +020017#include <haproxy/activity.h>
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020018#include <haproxy/api.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020019#include <haproxy/fd.h>
Willy Tarreauf268ee82020-06-04 17:05:57 +020020#include <haproxy/global.h>
Willy Tarreau3727a8a2020-06-04 17:37:26 +020021#include <haproxy/signal.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020022#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020023#include <haproxy/time.h>
Willy Tarreaub2551052020-06-09 09:07:15 +020024#include <haproxy/tools.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020025
Willy Tarreau58094f22007-04-10 01:33:20 +020026
Willy Tarreau4f60f162007-04-08 16:39:58 +020027/* private data */
Christopher Fauletd4604ad2017-05-29 10:40:41 +020028static THREAD_LOCAL struct epoll_event *epoll_events = NULL;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010029static int epoll_fd[MAX_THREADS]; // per-thread epoll_fd
Willy Tarreau4f60f162007-04-08 16:39:58 +020030
Willy Tarreau1c07b072013-01-07 16:19:18 +010031#ifndef EPOLLRDHUP
32/* EPOLLRDHUP was defined late in libc, and it appeared in kernel 2.6.17 */
33#define EPOLLRDHUP 0x2000
34#endif
35
Willy Tarreau4f60f162007-04-08 16:39:58 +020036/*
Conrad Hoffmann041751c2014-05-20 14:28:24 +020037 * Immediately remove file descriptor from epoll set upon close.
38 * Since we forked, some fds share inodes with the other process, and epoll may
39 * send us events even though this process closed the fd (see man 7 epoll,
40 * "Questions and answers", Q 6).
41 */
Willy Tarreau03e78532020-02-25 07:38:05 +010042static void __fd_clo(int fd)
Conrad Hoffmann041751c2014-05-20 14:28:24 +020043{
Willy Tarreaud9e7e362018-01-18 19:16:02 +010044 if (unlikely(fdtab[fd].cloned)) {
Olivier Houchard53055052019-07-25 14:00:18 +000045 unsigned long m = polled_mask[fd].poll_recv | polled_mask[fd].poll_send;
Willy Tarreau902871d2020-02-20 11:23:43 +010046 struct epoll_event ev;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010047 int i;
48
49 for (i = global.nbthread - 1; i >= 0; i--)
50 if (m & (1UL << i))
51 epoll_ctl(epoll_fd[i], EPOLL_CTL_DEL, fd, &ev);
52 }
Conrad Hoffmann041751c2014-05-20 14:28:24 +020053}
54
Olivier Houchard6b96f722018-04-25 16:58:25 +020055static void _update_fd(int fd)
56{
57 int en, opcode;
Willy Tarreau55c53992020-02-26 14:32:53 +010058 struct epoll_event ev = { };
Olivier Houchard6b96f722018-04-25 16:58:25 +020059
60 en = fdtab[fd].state;
61
Willy Tarreaubc52bec2020-06-18 08:58:47 +020062 /* Try to force EPOLLET on FDs that support it */
63 if (fdtab[fd].et_possible) {
64 /* already done ? */
65 if (polled_mask[fd].poll_recv & polled_mask[fd].poll_send & tid_bit)
66 return;
67
68 /* enable ET polling in both directions */
69 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
70 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
71 opcode = EPOLL_CTL_ADD;
72 ev.events = EPOLLIN | EPOLLRDHUP | EPOLLOUT | EPOLLET;
73 goto done;
74 }
75
Willy Tarreau5d7dcc22019-12-26 16:40:24 +010076 /* if we're already polling or are going to poll for this FD and it's
77 * neither active nor ready, force it to be active so that we don't
78 * needlessly unsubscribe then re-subscribe it.
79 */
80 if (!(en & FD_EV_READY_R) &&
81 ((en & FD_EV_ACTIVE_W) ||
82 ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit)))
83 en |= FD_EV_ACTIVE_R;
84
Olivier Houchard53055052019-07-25 14:00:18 +000085 if ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit) {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020086 if (!(fdtab[fd].thread_mask & tid_bit) || !(en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +020087 /* fd removed from poll list */
88 opcode = EPOLL_CTL_DEL;
Olivier Houchard53055052019-07-25 14:00:18 +000089 if (polled_mask[fd].poll_recv & tid_bit)
90 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
91 if (polled_mask[fd].poll_send & tid_bit)
92 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Olivier Houchard6b96f722018-04-25 16:58:25 +020093 }
94 else {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020095 if (((en & FD_EV_ACTIVE_R) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000096 ((polled_mask[fd].poll_recv & tid_bit) != 0) &&
Willy Tarreau5bee3e22019-09-04 09:52:57 +020097 ((en & FD_EV_ACTIVE_W) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000098 ((polled_mask[fd].poll_send & tid_bit) != 0))
99 return;
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200100 if (en & FD_EV_ACTIVE_R) {
Olivier Houchard53055052019-07-25 14:00:18 +0000101 if (!(polled_mask[fd].poll_recv & tid_bit))
102 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
103 } else {
104 if (polled_mask[fd].poll_recv & tid_bit)
105 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
106 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200107 if (en & FD_EV_ACTIVE_W) {
Olivier Houchard53055052019-07-25 14:00:18 +0000108 if (!(polled_mask[fd].poll_send & tid_bit))
109 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
110 } else {
111 if (polled_mask[fd].poll_send & tid_bit)
112 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
113 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200114 /* fd status changed */
115 opcode = EPOLL_CTL_MOD;
116 }
117 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200118 else if ((fdtab[fd].thread_mask & tid_bit) && (en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +0200119 /* new fd in the poll list */
120 opcode = EPOLL_CTL_ADD;
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200121 if (en & FD_EV_ACTIVE_R)
Olivier Houchard53055052019-07-25 14:00:18 +0000122 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200123 if (en & FD_EV_ACTIVE_W)
Olivier Houchard53055052019-07-25 14:00:18 +0000124 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
Olivier Houchard6b96f722018-04-25 16:58:25 +0200125 }
126 else {
127 return;
128 }
129
130 /* construct the epoll events based on new state */
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200131 if (en & FD_EV_ACTIVE_R)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200132 ev.events |= EPOLLIN | EPOLLRDHUP;
133
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200134 if (en & FD_EV_ACTIVE_W)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200135 ev.events |= EPOLLOUT;
136
Willy Tarreaubc52bec2020-06-18 08:58:47 +0200137 done:
Olivier Houchard6b96f722018-04-25 16:58:25 +0200138 ev.data.fd = fd;
139 epoll_ctl(epoll_fd[tid], opcode, fd, &ev);
140}
141
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200142/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100143 * Linux epoll() poller
Willy Tarreau4f60f162007-04-08 16:39:58 +0200144 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100145static void _do_poll(struct poller *p, int exp, int wake)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200146{
Olivier Houchard6b96f722018-04-25 16:58:25 +0200147 int status;
148 int fd;
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100149 int count;
150 int updt_idx;
151 int wait_time;
Olivier Houchard6b96f722018-04-25 16:58:25 +0200152 int old_fd;
Willy Tarreau58094f22007-04-10 01:33:20 +0200153
Willy Tarreau5be2f352014-11-19 19:43:05 +0100154 /* first, scan the update list to find polling changes */
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100155 for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) {
156 fd = fd_updt[updt_idx];
Willy Tarreau58094f22007-04-10 01:33:20 +0200157
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100158 _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100159 if (!fdtab[fd].owner) {
Willy Tarreaue4063862020-06-17 20:35:33 +0200160 activity[tid].poll_drop_fd++;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100161 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100162 }
Willy Tarreau58094f22007-04-10 01:33:20 +0200163
Olivier Houchard6b96f722018-04-25 16:58:25 +0200164 _update_fd(fd);
165 }
166 fd_nbupdt = 0;
167 /* Scan the global update list */
168 for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) {
169 if (fd == -2) {
170 fd = old_fd;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100171 continue;
172 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200173 else if (fd <= -3)
174 fd = -fd -4;
175 if (fd == -1)
176 break;
177 if (fdtab[fd].update_mask & tid_bit)
178 done_update_polling(fd);
179 else
180 continue;
181 if (!fdtab[fd].owner)
182 continue;
183 _update_fd(fd);
Willy Tarreau58094f22007-04-10 01:33:20 +0200184 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200185
Willy Tarreau60b639c2018-08-02 10:16:17 +0200186 thread_harmless_now();
187
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100188 /* now let's wait for polled events */
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200189 wait_time = wake ? 0 : compute_poll_timeout(exp);
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200190 tv_entering_poll();
Willy Tarreau609aad92018-11-22 08:31:09 +0100191 activity_count_runtime();
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100192 do {
193 int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
194
195 status = epoll_wait(epoll_fd[tid], epoll_events, global.tune.maxpollevents, timeout);
196 tv_update_date(timeout, status);
197
Willy Tarreaue5451532020-06-17 20:25:18 +0200198 if (status) {
199 activity[tid].poll_io++;
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100200 break;
Willy Tarreaue5451532020-06-17 20:25:18 +0200201 }
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100202 if (timeout || !wait_time)
203 break;
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200204 if (signal_queue_len || wake)
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100205 break;
206 if (tick_isset(exp) && tick_is_expired(exp, now_ms))
207 break;
208 } while (1);
209
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200210 tv_leaving_poll(wait_time, status);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200211
Willy Tarreau60b639c2018-08-02 10:16:17 +0200212 thread_harmless_end();
Olivier Houchard305d5ab2019-07-24 18:07:06 +0200213 if (sleeping_thread_mask & tid_bit)
214 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Willy Tarreau60b639c2018-08-02 10:16:17 +0200215
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100216 /* process polled events */
217
Willy Tarreau4f60f162007-04-08 16:39:58 +0200218 for (count = 0; count < status; count++) {
Willy Tarreau902871d2020-02-20 11:23:43 +0100219 struct epoll_event ev;
220 unsigned int n, e;
221
222 e = epoll_events[count].events;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200223 fd = epoll_events[count].data.fd;
224
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100225 if (!fdtab[fd].owner) {
Willy Tarreaue4063862020-06-17 20:35:33 +0200226 activity[tid].poll_dead_fd++;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100227 continue;
228 }
229
230 if (!(fdtab[fd].thread_mask & tid_bit)) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100231 /* FD has been migrated */
Willy Tarreaue4063862020-06-17 20:35:33 +0200232 activity[tid].poll_skip_fd++;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100233 epoll_ctl(epoll_fd[tid], EPOLL_CTL_DEL, fd, &ev);
Olivier Houchard53055052019-07-25 14:00:18 +0000234 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
235 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Willy Tarreau076be252012-07-06 16:02:29 +0200236 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100237 }
Willy Tarreau076be252012-07-06 16:02:29 +0200238
Willy Tarreau6b308982019-09-06 19:05:50 +0200239 n = ((e & EPOLLIN) ? FD_EV_READY_R : 0) |
240 ((e & EPOLLOUT) ? FD_EV_READY_W : 0) |
241 ((e & EPOLLRDHUP) ? FD_EV_SHUT_R : 0) |
242 ((e & EPOLLHUP) ? FD_EV_SHUT_RW : 0) |
243 ((e & EPOLLERR) ? FD_EV_ERR_RW : 0);
Willy Tarreau491c4982012-07-06 11:16:01 +0200244
Willy Tarreau6b308982019-09-06 19:05:50 +0200245 if ((e & EPOLLRDHUP) && !(cur_poller.flags & HAP_POLL_F_RDHUP))
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100246 _HA_ATOMIC_OR(&cur_poller.flags, HAP_POLL_F_RDHUP);
Willy Tarreau6b308982019-09-06 19:05:50 +0200247
Christopher Fauletab62f512017-08-30 10:34:36 +0200248 fd_update_events(fd, n);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200249 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100250 /* the caller will take care of cached events */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200251}
252
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200253static int init_epoll_per_thread()
254{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100255 int fd;
256
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200257 epoll_events = calloc(1, sizeof(struct epoll_event) * global.tune.maxpollevents);
258 if (epoll_events == NULL)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100259 goto fail_alloc;
260
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100261 if (MAX_THREADS > 1 && tid) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100262 epoll_fd[tid] = epoll_create(global.maxsock + 1);
263 if (epoll_fd[tid] < 0)
264 goto fail_fd;
265 }
266
267 /* we may have to unregister some events initially registered on the
268 * original fd when it was alone, and/or to register events on the new
269 * fd for this thread. Let's just mark them as updated, the poller will
270 * do the rest.
271 */
Willy Tarreauce036bc2018-01-29 14:58:02 +0100272 for (fd = 0; fd < global.maxsock; fd++)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100273 updt_fd_polling(fd);
274
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200275 return 1;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100276 fail_fd:
277 free(epoll_events);
278 fail_alloc:
279 return 0;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200280}
281
282static void deinit_epoll_per_thread()
283{
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100284 if (MAX_THREADS > 1 && tid)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100285 close(epoll_fd[tid]);
286
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200287 free(epoll_events);
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200288 epoll_events = NULL;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200289}
290
Willy Tarreau4f60f162007-04-08 16:39:58 +0200291/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100292 * Initialization of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200293 * Returns 0 in case of failure, non-zero in case of success. If it fails, it
294 * disables the poller by setting its pref to 0.
295 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100296static int _do_init(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200297{
Willy Tarreaue54e9172007-04-09 09:23:31 +0200298 p->private = NULL;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200299
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100300 epoll_fd[tid] = epoll_create(global.maxsock + 1);
301 if (epoll_fd[tid] < 0)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200302 goto fail_fd;
303
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200304 hap_register_per_thread_init(init_epoll_per_thread);
305 hap_register_per_thread_deinit(deinit_epoll_per_thread);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200306
Willy Tarreaue54e9172007-04-09 09:23:31 +0200307 return 1;
308
Willy Tarreaue54e9172007-04-09 09:23:31 +0200309 fail_fd:
310 p->pref = 0;
311 return 0;
312}
313
314/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100315 * Termination of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200316 * Memory is released and the poller is marked as unselectable.
317 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100318static void _do_term(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200319{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100320 if (epoll_fd[tid] >= 0) {
321 close(epoll_fd[tid]);
322 epoll_fd[tid] = -1;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200323 }
Willy Tarreaue54e9172007-04-09 09:23:31 +0200324
325 p->private = NULL;
326 p->pref = 0;
327}
328
329/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200330 * Check that the poller works.
331 * Returns 1 if OK, otherwise 0.
332 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100333static int _do_test(struct poller *p)
Willy Tarreau2ff76222007-04-09 19:29:56 +0200334{
335 int fd;
336
337 fd = epoll_create(global.maxsock + 1);
338 if (fd < 0)
339 return 0;
340 close(fd);
341 return 1;
342}
343
344/*
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200345 * Recreate the epoll file descriptor after a fork(). Returns 1 if OK,
346 * otherwise 0. It will ensure that all processes will not share their
347 * epoll_fd. Some side effects were encountered because of this, such
348 * as epoll_wait() returning an FD which was previously deleted.
349 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100350static int _do_fork(struct poller *p)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200351{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100352 if (epoll_fd[tid] >= 0)
353 close(epoll_fd[tid]);
354 epoll_fd[tid] = epoll_create(global.maxsock + 1);
355 if (epoll_fd[tid] < 0)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200356 return 0;
357 return 1;
358}
359
360/*
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200361 * It is a constructor, which means that it will automatically be called before
362 * main(). This is GCC-specific but it works at least since 2.95.
363 * Special care must be taken so that it does not need any uninitialized data.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200364 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200365__attribute__((constructor))
366static void _do_register(void)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200367{
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200368 struct poller *p;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100369 int i;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200370
371 if (nbpollers >= MAX_POLLERS)
372 return;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200373
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100374 for (i = 0; i < MAX_THREADS; i++)
375 epoll_fd[i] = -1;
376
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200377 p = &pollers[nbpollers++];
378
Willy Tarreau4f60f162007-04-08 16:39:58 +0200379 p->name = "epoll";
380 p->pref = 300;
Willy Tarreau11ef0832019-11-28 18:17:33 +0100381 p->flags = HAP_POLL_F_ERRHUP; // note: RDHUP might be dynamically added
Willy Tarreau4f60f162007-04-08 16:39:58 +0200382 p->private = NULL;
383
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200384 p->clo = __fd_clo;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200385 p->test = _do_test;
386 p->init = _do_init;
387 p->term = _do_term;
388 p->poll = _do_poll;
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200389 p->fork = _do_fork;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200390}
391
392
393/*
394 * Local variables:
395 * c-indent-level: 8
396 * c-basic-offset: 8
397 * End:
398 */