blob: 5122510092e3411d0f2a5a6b8e59d4fc6aef0644 [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>
13#include <sys/time.h>
14#include <sys/types.h>
15
16#include <common/compat.h>
17#include <common/config.h>
Willy Tarreaue9f49e72012-11-11 17:42:00 +010018#include <common/debug.h>
Willy Tarreau43d8fb22011-08-22 17:12:02 +020019#include <common/epoll.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 Tarreau902871d2020-02-20 11:23:43 +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 */
123 ev.events = 0;
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200124 if (en & FD_EV_ACTIVE_R)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200125 ev.events |= EPOLLIN | EPOLLRDHUP;
126
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200127 if (en & FD_EV_ACTIVE_W)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200128 ev.events |= EPOLLOUT;
129
130 ev.data.fd = fd;
131 epoll_ctl(epoll_fd[tid], opcode, fd, &ev);
132}
133
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200134/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100135 * Linux epoll() poller
Willy Tarreau4f60f162007-04-08 16:39:58 +0200136 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100137static void _do_poll(struct poller *p, int exp, int wake)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200138{
Olivier Houchard6b96f722018-04-25 16:58:25 +0200139 int status;
140 int fd;
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100141 int count;
142 int updt_idx;
143 int wait_time;
Olivier Houchard6b96f722018-04-25 16:58:25 +0200144 int old_fd;
Willy Tarreau58094f22007-04-10 01:33:20 +0200145
Willy Tarreau5be2f352014-11-19 19:43:05 +0100146 /* first, scan the update list to find polling changes */
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100147 for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) {
148 fd = fd_updt[updt_idx];
Willy Tarreau58094f22007-04-10 01:33:20 +0200149
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100150 _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100151 if (!fdtab[fd].owner) {
152 activity[tid].poll_drop++;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100153 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100154 }
Willy Tarreau58094f22007-04-10 01:33:20 +0200155
Olivier Houchard6b96f722018-04-25 16:58:25 +0200156 _update_fd(fd);
157 }
158 fd_nbupdt = 0;
159 /* Scan the global update list */
160 for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) {
161 if (fd == -2) {
162 fd = old_fd;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100163 continue;
164 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200165 else if (fd <= -3)
166 fd = -fd -4;
167 if (fd == -1)
168 break;
169 if (fdtab[fd].update_mask & tid_bit)
170 done_update_polling(fd);
171 else
172 continue;
173 if (!fdtab[fd].owner)
174 continue;
175 _update_fd(fd);
Willy Tarreau58094f22007-04-10 01:33:20 +0200176 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200177
Willy Tarreau60b639c2018-08-02 10:16:17 +0200178 thread_harmless_now();
179
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100180 /* now let's wait for polled events */
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200181 wait_time = wake ? 0 : compute_poll_timeout(exp);
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200182 tv_entering_poll();
Willy Tarreau609aad92018-11-22 08:31:09 +0100183 activity_count_runtime();
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100184 do {
185 int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
186
187 status = epoll_wait(epoll_fd[tid], epoll_events, global.tune.maxpollevents, timeout);
188 tv_update_date(timeout, status);
189
190 if (status)
191 break;
192 if (timeout || !wait_time)
193 break;
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200194 if (signal_queue_len || wake)
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100195 break;
196 if (tick_isset(exp) && tick_is_expired(exp, now_ms))
197 break;
198 } while (1);
199
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200200 tv_leaving_poll(wait_time, status);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200201
Willy Tarreau60b639c2018-08-02 10:16:17 +0200202 thread_harmless_end();
Olivier Houchard305d5ab2019-07-24 18:07:06 +0200203 if (sleeping_thread_mask & tid_bit)
204 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Willy Tarreau60b639c2018-08-02 10:16:17 +0200205
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100206 /* process polled events */
207
Willy Tarreau4f60f162007-04-08 16:39:58 +0200208 for (count = 0; count < status; count++) {
Willy Tarreau902871d2020-02-20 11:23:43 +0100209 struct epoll_event ev;
210 unsigned int n, e;
211
212 e = epoll_events[count].events;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200213 fd = epoll_events[count].data.fd;
214
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100215 if (!fdtab[fd].owner) {
216 activity[tid].poll_dead++;
217 continue;
218 }
219
220 if (!(fdtab[fd].thread_mask & tid_bit)) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100221 /* FD has been migrated */
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100222 activity[tid].poll_skip++;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100223 epoll_ctl(epoll_fd[tid], EPOLL_CTL_DEL, fd, &ev);
Olivier Houchard53055052019-07-25 14:00:18 +0000224 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
225 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Willy Tarreau076be252012-07-06 16:02:29 +0200226 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100227 }
Willy Tarreau076be252012-07-06 16:02:29 +0200228
Willy Tarreau6b308982019-09-06 19:05:50 +0200229 n = ((e & EPOLLIN) ? FD_EV_READY_R : 0) |
230 ((e & EPOLLOUT) ? FD_EV_READY_W : 0) |
231 ((e & EPOLLRDHUP) ? FD_EV_SHUT_R : 0) |
232 ((e & EPOLLHUP) ? FD_EV_SHUT_RW : 0) |
233 ((e & EPOLLERR) ? FD_EV_ERR_RW : 0);
Willy Tarreau491c4982012-07-06 11:16:01 +0200234
Willy Tarreau6b308982019-09-06 19:05:50 +0200235 if ((e & EPOLLRDHUP) && !(cur_poller.flags & HAP_POLL_F_RDHUP))
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100236 _HA_ATOMIC_OR(&cur_poller.flags, HAP_POLL_F_RDHUP);
Willy Tarreau6b308982019-09-06 19:05:50 +0200237
Christopher Fauletab62f512017-08-30 10:34:36 +0200238 fd_update_events(fd, n);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200239 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100240 /* the caller will take care of cached events */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200241}
242
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200243static int init_epoll_per_thread()
244{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100245 int fd;
246
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200247 epoll_events = calloc(1, sizeof(struct epoll_event) * global.tune.maxpollevents);
248 if (epoll_events == NULL)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100249 goto fail_alloc;
250
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100251 if (MAX_THREADS > 1 && tid) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100252 epoll_fd[tid] = epoll_create(global.maxsock + 1);
253 if (epoll_fd[tid] < 0)
254 goto fail_fd;
255 }
256
257 /* we may have to unregister some events initially registered on the
258 * original fd when it was alone, and/or to register events on the new
259 * fd for this thread. Let's just mark them as updated, the poller will
260 * do the rest.
261 */
Willy Tarreauce036bc2018-01-29 14:58:02 +0100262 for (fd = 0; fd < global.maxsock; fd++)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100263 updt_fd_polling(fd);
264
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200265 return 1;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100266 fail_fd:
267 free(epoll_events);
268 fail_alloc:
269 return 0;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200270}
271
272static void deinit_epoll_per_thread()
273{
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100274 if (MAX_THREADS > 1 && tid)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100275 close(epoll_fd[tid]);
276
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200277 free(epoll_events);
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200278 epoll_events = NULL;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200279}
280
Willy Tarreau4f60f162007-04-08 16:39:58 +0200281/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100282 * Initialization of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200283 * Returns 0 in case of failure, non-zero in case of success. If it fails, it
284 * disables the poller by setting its pref to 0.
285 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100286static int _do_init(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200287{
Willy Tarreaue54e9172007-04-09 09:23:31 +0200288 p->private = NULL;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200289
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100290 epoll_fd[tid] = epoll_create(global.maxsock + 1);
291 if (epoll_fd[tid] < 0)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200292 goto fail_fd;
293
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200294 hap_register_per_thread_init(init_epoll_per_thread);
295 hap_register_per_thread_deinit(deinit_epoll_per_thread);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200296
Willy Tarreaue54e9172007-04-09 09:23:31 +0200297 return 1;
298
Willy Tarreaue54e9172007-04-09 09:23:31 +0200299 fail_fd:
300 p->pref = 0;
301 return 0;
302}
303
304/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100305 * Termination of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200306 * Memory is released and the poller is marked as unselectable.
307 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100308static void _do_term(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200309{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100310 if (epoll_fd[tid] >= 0) {
311 close(epoll_fd[tid]);
312 epoll_fd[tid] = -1;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200313 }
Willy Tarreaue54e9172007-04-09 09:23:31 +0200314
315 p->private = NULL;
316 p->pref = 0;
317}
318
319/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200320 * Check that the poller works.
321 * Returns 1 if OK, otherwise 0.
322 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100323static int _do_test(struct poller *p)
Willy Tarreau2ff76222007-04-09 19:29:56 +0200324{
325 int fd;
326
327 fd = epoll_create(global.maxsock + 1);
328 if (fd < 0)
329 return 0;
330 close(fd);
331 return 1;
332}
333
334/*
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200335 * Recreate the epoll file descriptor after a fork(). Returns 1 if OK,
336 * otherwise 0. It will ensure that all processes will not share their
337 * epoll_fd. Some side effects were encountered because of this, such
338 * as epoll_wait() returning an FD which was previously deleted.
339 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100340static int _do_fork(struct poller *p)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200341{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100342 if (epoll_fd[tid] >= 0)
343 close(epoll_fd[tid]);
344 epoll_fd[tid] = epoll_create(global.maxsock + 1);
345 if (epoll_fd[tid] < 0)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200346 return 0;
347 return 1;
348}
349
350/*
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200351 * It is a constructor, which means that it will automatically be called before
352 * main(). This is GCC-specific but it works at least since 2.95.
353 * Special care must be taken so that it does not need any uninitialized data.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200354 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200355__attribute__((constructor))
356static void _do_register(void)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200357{
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200358 struct poller *p;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100359 int i;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200360
361 if (nbpollers >= MAX_POLLERS)
362 return;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200363
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100364 for (i = 0; i < MAX_THREADS; i++)
365 epoll_fd[i] = -1;
366
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200367 p = &pollers[nbpollers++];
368
Willy Tarreau4f60f162007-04-08 16:39:58 +0200369 p->name = "epoll";
370 p->pref = 300;
Willy Tarreau11ef0832019-11-28 18:17:33 +0100371 p->flags = HAP_POLL_F_ERRHUP; // note: RDHUP might be dynamically added
Willy Tarreau4f60f162007-04-08 16:39:58 +0200372 p->private = NULL;
373
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200374 p->clo = __fd_clo;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200375 p->test = _do_test;
376 p->init = _do_init;
377 p->term = _do_term;
378 p->poll = _do_poll;
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200379 p->fork = _do_fork;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200380}
381
382
383/*
384 * Local variables:
385 * c-indent-level: 8
386 * c-basic-offset: 8
387 * End:
388 */