blob: 9129402c6fc3e9ff28a98f0c64613091e1b2c269 [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
17#include <common/compat.h>
18#include <common/config.h>
Willy Tarreaue9f49e72012-11-11 17:42:00 +010019#include <common/debug.h>
Willy Tarreau60b639c2018-08-02 10:16:17 +020020#include <common/hathreads.h>
Willy Tarreau58094f22007-04-10 01:33:20 +020021#include <common/standard.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020022#include <common/ticks.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020023#include <common/time.h>
Willy Tarreau1db37712007-06-03 17:16:49 +020024#include <common/tools.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020025
Willy Tarreau4f60f162007-04-08 16:39:58 +020026#include <types/global.h>
27
Willy Tarreau609aad92018-11-22 08:31:09 +010028#include <proto/activity.h>
Willy Tarreaue9f49e72012-11-11 17:42:00 +010029#include <proto/fd.h>
Willy Tarreaubeb859a2018-11-22 18:07:59 +010030#include <proto/signal.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020031
Willy Tarreau58094f22007-04-10 01:33:20 +020032
Willy Tarreau4f60f162007-04-08 16:39:58 +020033/* private data */
Christopher Fauletd4604ad2017-05-29 10:40:41 +020034static THREAD_LOCAL struct epoll_event *epoll_events = NULL;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010035static int epoll_fd[MAX_THREADS]; // per-thread epoll_fd
Willy Tarreau4f60f162007-04-08 16:39:58 +020036
Willy Tarreau1c07b072013-01-07 16:19:18 +010037#ifndef EPOLLRDHUP
38/* EPOLLRDHUP was defined late in libc, and it appeared in kernel 2.6.17 */
39#define EPOLLRDHUP 0x2000
40#endif
41
Willy Tarreau4f60f162007-04-08 16:39:58 +020042/*
Conrad Hoffmann041751c2014-05-20 14:28:24 +020043 * Immediately remove file descriptor from epoll set upon close.
44 * Since we forked, some fds share inodes with the other process, and epoll may
45 * send us events even though this process closed the fd (see man 7 epoll,
46 * "Questions and answers", Q 6).
47 */
Willy Tarreau03e78532020-02-25 07:38:05 +010048static void __fd_clo(int fd)
Conrad Hoffmann041751c2014-05-20 14:28:24 +020049{
Willy Tarreaud9e7e362018-01-18 19:16:02 +010050 if (unlikely(fdtab[fd].cloned)) {
Olivier Houchard53055052019-07-25 14:00:18 +000051 unsigned long m = polled_mask[fd].poll_recv | polled_mask[fd].poll_send;
Willy Tarreau902871d2020-02-20 11:23:43 +010052 struct epoll_event ev;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010053 int i;
54
55 for (i = global.nbthread - 1; i >= 0; i--)
56 if (m & (1UL << i))
57 epoll_ctl(epoll_fd[i], EPOLL_CTL_DEL, fd, &ev);
58 }
Conrad Hoffmann041751c2014-05-20 14:28:24 +020059}
60
Olivier Houchard6b96f722018-04-25 16:58:25 +020061static void _update_fd(int fd)
62{
63 int en, opcode;
Willy Tarreau55c53992020-02-26 14:32:53 +010064 struct epoll_event ev = { };
Olivier Houchard6b96f722018-04-25 16:58:25 +020065
66 en = fdtab[fd].state;
67
Willy Tarreau5d7dcc22019-12-26 16:40:24 +010068 /* if we're already polling or are going to poll for this FD and it's
69 * neither active nor ready, force it to be active so that we don't
70 * needlessly unsubscribe then re-subscribe it.
71 */
72 if (!(en & FD_EV_READY_R) &&
73 ((en & FD_EV_ACTIVE_W) ||
74 ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit)))
75 en |= FD_EV_ACTIVE_R;
76
Olivier Houchard53055052019-07-25 14:00:18 +000077 if ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit) {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020078 if (!(fdtab[fd].thread_mask & tid_bit) || !(en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +020079 /* fd removed from poll list */
80 opcode = EPOLL_CTL_DEL;
Olivier Houchard53055052019-07-25 14:00:18 +000081 if (polled_mask[fd].poll_recv & tid_bit)
82 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
83 if (polled_mask[fd].poll_send & tid_bit)
84 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Olivier Houchard6b96f722018-04-25 16:58:25 +020085 }
86 else {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020087 if (((en & FD_EV_ACTIVE_R) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000088 ((polled_mask[fd].poll_recv & tid_bit) != 0) &&
Willy Tarreau5bee3e22019-09-04 09:52:57 +020089 ((en & FD_EV_ACTIVE_W) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000090 ((polled_mask[fd].poll_send & tid_bit) != 0))
91 return;
Willy Tarreau5bee3e22019-09-04 09:52:57 +020092 if (en & FD_EV_ACTIVE_R) {
Olivier Houchard53055052019-07-25 14:00:18 +000093 if (!(polled_mask[fd].poll_recv & tid_bit))
94 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
95 } else {
96 if (polled_mask[fd].poll_recv & tid_bit)
97 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
98 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +020099 if (en & FD_EV_ACTIVE_W) {
Olivier Houchard53055052019-07-25 14:00:18 +0000100 if (!(polled_mask[fd].poll_send & tid_bit))
101 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
102 } else {
103 if (polled_mask[fd].poll_send & tid_bit)
104 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
105 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200106 /* fd status changed */
107 opcode = EPOLL_CTL_MOD;
108 }
109 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200110 else if ((fdtab[fd].thread_mask & tid_bit) && (en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +0200111 /* new fd in the poll list */
112 opcode = EPOLL_CTL_ADD;
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200113 if (en & FD_EV_ACTIVE_R)
Olivier Houchard53055052019-07-25 14:00:18 +0000114 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200115 if (en & FD_EV_ACTIVE_W)
Olivier Houchard53055052019-07-25 14:00:18 +0000116 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
Olivier Houchard6b96f722018-04-25 16:58:25 +0200117 }
118 else {
119 return;
120 }
121
122 /* construct the epoll events based on new state */
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200123 if (en & FD_EV_ACTIVE_R)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200124 ev.events |= EPOLLIN | EPOLLRDHUP;
125
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200126 if (en & FD_EV_ACTIVE_W)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200127 ev.events |= EPOLLOUT;
128
129 ev.data.fd = fd;
130 epoll_ctl(epoll_fd[tid], opcode, fd, &ev);
131}
132
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200133/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100134 * Linux epoll() poller
Willy Tarreau4f60f162007-04-08 16:39:58 +0200135 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100136static void _do_poll(struct poller *p, int exp, int wake)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200137{
Olivier Houchard6b96f722018-04-25 16:58:25 +0200138 int status;
139 int fd;
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100140 int count;
141 int updt_idx;
142 int wait_time;
Olivier Houchard6b96f722018-04-25 16:58:25 +0200143 int old_fd;
Willy Tarreau58094f22007-04-10 01:33:20 +0200144
Willy Tarreau5be2f352014-11-19 19:43:05 +0100145 /* first, scan the update list to find polling changes */
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100146 for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) {
147 fd = fd_updt[updt_idx];
Willy Tarreau58094f22007-04-10 01:33:20 +0200148
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100149 _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100150 if (!fdtab[fd].owner) {
151 activity[tid].poll_drop++;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100152 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100153 }
Willy Tarreau58094f22007-04-10 01:33:20 +0200154
Olivier Houchard6b96f722018-04-25 16:58:25 +0200155 _update_fd(fd);
156 }
157 fd_nbupdt = 0;
158 /* Scan the global update list */
159 for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) {
160 if (fd == -2) {
161 fd = old_fd;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100162 continue;
163 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200164 else if (fd <= -3)
165 fd = -fd -4;
166 if (fd == -1)
167 break;
168 if (fdtab[fd].update_mask & tid_bit)
169 done_update_polling(fd);
170 else
171 continue;
172 if (!fdtab[fd].owner)
173 continue;
174 _update_fd(fd);
Willy Tarreau58094f22007-04-10 01:33:20 +0200175 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200176
Willy Tarreau60b639c2018-08-02 10:16:17 +0200177 thread_harmless_now();
178
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100179 /* now let's wait for polled events */
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200180 wait_time = wake ? 0 : compute_poll_timeout(exp);
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200181 tv_entering_poll();
Willy Tarreau609aad92018-11-22 08:31:09 +0100182 activity_count_runtime();
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100183 do {
184 int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
185
186 status = epoll_wait(epoll_fd[tid], epoll_events, global.tune.maxpollevents, timeout);
187 tv_update_date(timeout, status);
188
189 if (status)
190 break;
191 if (timeout || !wait_time)
192 break;
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200193 if (signal_queue_len || wake)
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100194 break;
195 if (tick_isset(exp) && tick_is_expired(exp, now_ms))
196 break;
197 } while (1);
198
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200199 tv_leaving_poll(wait_time, status);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200200
Willy Tarreau60b639c2018-08-02 10:16:17 +0200201 thread_harmless_end();
Olivier Houchard305d5ab2019-07-24 18:07:06 +0200202 if (sleeping_thread_mask & tid_bit)
203 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Willy Tarreau60b639c2018-08-02 10:16:17 +0200204
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100205 /* process polled events */
206
Willy Tarreau4f60f162007-04-08 16:39:58 +0200207 for (count = 0; count < status; count++) {
Willy Tarreau902871d2020-02-20 11:23:43 +0100208 struct epoll_event ev;
209 unsigned int n, e;
210
211 e = epoll_events[count].events;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200212 fd = epoll_events[count].data.fd;
213
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100214 if (!fdtab[fd].owner) {
215 activity[tid].poll_dead++;
216 continue;
217 }
218
219 if (!(fdtab[fd].thread_mask & tid_bit)) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100220 /* FD has been migrated */
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100221 activity[tid].poll_skip++;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100222 epoll_ctl(epoll_fd[tid], EPOLL_CTL_DEL, fd, &ev);
Olivier Houchard53055052019-07-25 14:00:18 +0000223 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
224 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Willy Tarreau076be252012-07-06 16:02:29 +0200225 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100226 }
Willy Tarreau076be252012-07-06 16:02:29 +0200227
Willy Tarreau6b308982019-09-06 19:05:50 +0200228 n = ((e & EPOLLIN) ? FD_EV_READY_R : 0) |
229 ((e & EPOLLOUT) ? FD_EV_READY_W : 0) |
230 ((e & EPOLLRDHUP) ? FD_EV_SHUT_R : 0) |
231 ((e & EPOLLHUP) ? FD_EV_SHUT_RW : 0) |
232 ((e & EPOLLERR) ? FD_EV_ERR_RW : 0);
Willy Tarreau491c4982012-07-06 11:16:01 +0200233
Willy Tarreau6b308982019-09-06 19:05:50 +0200234 if ((e & EPOLLRDHUP) && !(cur_poller.flags & HAP_POLL_F_RDHUP))
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100235 _HA_ATOMIC_OR(&cur_poller.flags, HAP_POLL_F_RDHUP);
Willy Tarreau6b308982019-09-06 19:05:50 +0200236
Christopher Fauletab62f512017-08-30 10:34:36 +0200237 fd_update_events(fd, n);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200238 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100239 /* the caller will take care of cached events */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200240}
241
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200242static int init_epoll_per_thread()
243{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100244 int fd;
245
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200246 epoll_events = calloc(1, sizeof(struct epoll_event) * global.tune.maxpollevents);
247 if (epoll_events == NULL)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100248 goto fail_alloc;
249
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100250 if (MAX_THREADS > 1 && tid) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100251 epoll_fd[tid] = epoll_create(global.maxsock + 1);
252 if (epoll_fd[tid] < 0)
253 goto fail_fd;
254 }
255
256 /* we may have to unregister some events initially registered on the
257 * original fd when it was alone, and/or to register events on the new
258 * fd for this thread. Let's just mark them as updated, the poller will
259 * do the rest.
260 */
Willy Tarreauce036bc2018-01-29 14:58:02 +0100261 for (fd = 0; fd < global.maxsock; fd++)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100262 updt_fd_polling(fd);
263
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200264 return 1;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100265 fail_fd:
266 free(epoll_events);
267 fail_alloc:
268 return 0;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200269}
270
271static void deinit_epoll_per_thread()
272{
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100273 if (MAX_THREADS > 1 && tid)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100274 close(epoll_fd[tid]);
275
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200276 free(epoll_events);
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200277 epoll_events = NULL;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200278}
279
Willy Tarreau4f60f162007-04-08 16:39:58 +0200280/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100281 * Initialization of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200282 * Returns 0 in case of failure, non-zero in case of success. If it fails, it
283 * disables the poller by setting its pref to 0.
284 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100285static int _do_init(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200286{
Willy Tarreaue54e9172007-04-09 09:23:31 +0200287 p->private = NULL;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200288
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100289 epoll_fd[tid] = epoll_create(global.maxsock + 1);
290 if (epoll_fd[tid] < 0)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200291 goto fail_fd;
292
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200293 hap_register_per_thread_init(init_epoll_per_thread);
294 hap_register_per_thread_deinit(deinit_epoll_per_thread);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200295
Willy Tarreaue54e9172007-04-09 09:23:31 +0200296 return 1;
297
Willy Tarreaue54e9172007-04-09 09:23:31 +0200298 fail_fd:
299 p->pref = 0;
300 return 0;
301}
302
303/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100304 * Termination of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200305 * Memory is released and the poller is marked as unselectable.
306 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100307static void _do_term(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200308{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100309 if (epoll_fd[tid] >= 0) {
310 close(epoll_fd[tid]);
311 epoll_fd[tid] = -1;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200312 }
Willy Tarreaue54e9172007-04-09 09:23:31 +0200313
314 p->private = NULL;
315 p->pref = 0;
316}
317
318/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200319 * Check that the poller works.
320 * Returns 1 if OK, otherwise 0.
321 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100322static int _do_test(struct poller *p)
Willy Tarreau2ff76222007-04-09 19:29:56 +0200323{
324 int fd;
325
326 fd = epoll_create(global.maxsock + 1);
327 if (fd < 0)
328 return 0;
329 close(fd);
330 return 1;
331}
332
333/*
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200334 * Recreate the epoll file descriptor after a fork(). Returns 1 if OK,
335 * otherwise 0. It will ensure that all processes will not share their
336 * epoll_fd. Some side effects were encountered because of this, such
337 * as epoll_wait() returning an FD which was previously deleted.
338 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100339static int _do_fork(struct poller *p)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200340{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100341 if (epoll_fd[tid] >= 0)
342 close(epoll_fd[tid]);
343 epoll_fd[tid] = epoll_create(global.maxsock + 1);
344 if (epoll_fd[tid] < 0)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200345 return 0;
346 return 1;
347}
348
349/*
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200350 * It is a constructor, which means that it will automatically be called before
351 * main(). This is GCC-specific but it works at least since 2.95.
352 * Special care must be taken so that it does not need any uninitialized data.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200353 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200354__attribute__((constructor))
355static void _do_register(void)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200356{
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200357 struct poller *p;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100358 int i;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200359
360 if (nbpollers >= MAX_POLLERS)
361 return;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200362
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100363 for (i = 0; i < MAX_THREADS; i++)
364 epoll_fd[i] = -1;
365
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200366 p = &pollers[nbpollers++];
367
Willy Tarreau4f60f162007-04-08 16:39:58 +0200368 p->name = "epoll";
369 p->pref = 300;
Willy Tarreau11ef0832019-11-28 18:17:33 +0100370 p->flags = HAP_POLL_F_ERRHUP; // note: RDHUP might be dynamically added
Willy Tarreau4f60f162007-04-08 16:39:58 +0200371 p->private = NULL;
372
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200373 p->clo = __fd_clo;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200374 p->test = _do_test;
375 p->init = _do_init;
376 p->term = _do_term;
377 p->poll = _do_poll;
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200378 p->fork = _do_fork;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200379}
380
381
382/*
383 * Local variables:
384 * c-indent-level: 8
385 * c-basic-offset: 8
386 * End:
387 */