blob: 65ff1b50dae88191b44b69e4017527f82fa99ea7 [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 Tarreau4c7e4b72020-05-27 12:58:42 +020017#include <haproxy/api.h>
Willy Tarreau3f567e42020-05-28 15:29:19 +020018#include <haproxy/thread-t.h>
Willy Tarreau58094f22007-04-10 01:33:20 +020019#include <common/standard.h>
Willy Tarreauc2f7c582020-06-02 18:15:32 +020020#include <haproxy/ticks.h>
Willy Tarreau92b4f132020-06-01 11:05:15 +020021#include <haproxy/time.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020022
Willy Tarreau4f60f162007-04-08 16:39:58 +020023#include <types/global.h>
24
Willy Tarreaua04ded52020-06-02 10:29:48 +020025#include <haproxy/activity.h>
Willy Tarreaue9f49e72012-11-11 17:42:00 +010026#include <proto/fd.h>
Willy Tarreaubeb859a2018-11-22 18:07:59 +010027#include <proto/signal.h>
Willy Tarreau4f60f162007-04-08 16:39:58 +020028
Willy Tarreau58094f22007-04-10 01:33:20 +020029
Willy Tarreau4f60f162007-04-08 16:39:58 +020030/* private data */
Christopher Fauletd4604ad2017-05-29 10:40:41 +020031static THREAD_LOCAL struct epoll_event *epoll_events = NULL;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010032static int epoll_fd[MAX_THREADS]; // per-thread epoll_fd
Willy Tarreau4f60f162007-04-08 16:39:58 +020033
Willy Tarreau1c07b072013-01-07 16:19:18 +010034#ifndef EPOLLRDHUP
35/* EPOLLRDHUP was defined late in libc, and it appeared in kernel 2.6.17 */
36#define EPOLLRDHUP 0x2000
37#endif
38
Willy Tarreau4f60f162007-04-08 16:39:58 +020039/*
Conrad Hoffmann041751c2014-05-20 14:28:24 +020040 * Immediately remove file descriptor from epoll set upon close.
41 * Since we forked, some fds share inodes with the other process, and epoll may
42 * send us events even though this process closed the fd (see man 7 epoll,
43 * "Questions and answers", Q 6).
44 */
Willy Tarreau03e78532020-02-25 07:38:05 +010045static void __fd_clo(int fd)
Conrad Hoffmann041751c2014-05-20 14:28:24 +020046{
Willy Tarreaud9e7e362018-01-18 19:16:02 +010047 if (unlikely(fdtab[fd].cloned)) {
Olivier Houchard53055052019-07-25 14:00:18 +000048 unsigned long m = polled_mask[fd].poll_recv | polled_mask[fd].poll_send;
Willy Tarreau902871d2020-02-20 11:23:43 +010049 struct epoll_event ev;
Willy Tarreaud9e7e362018-01-18 19:16:02 +010050 int i;
51
52 for (i = global.nbthread - 1; i >= 0; i--)
53 if (m & (1UL << i))
54 epoll_ctl(epoll_fd[i], EPOLL_CTL_DEL, fd, &ev);
55 }
Conrad Hoffmann041751c2014-05-20 14:28:24 +020056}
57
Olivier Houchard6b96f722018-04-25 16:58:25 +020058static void _update_fd(int fd)
59{
60 int en, opcode;
Willy Tarreau55c53992020-02-26 14:32:53 +010061 struct epoll_event ev = { };
Olivier Houchard6b96f722018-04-25 16:58:25 +020062
63 en = fdtab[fd].state;
64
Willy Tarreau5d7dcc22019-12-26 16:40:24 +010065 /* if we're already polling or are going to poll for this FD and it's
66 * neither active nor ready, force it to be active so that we don't
67 * needlessly unsubscribe then re-subscribe it.
68 */
69 if (!(en & FD_EV_READY_R) &&
70 ((en & FD_EV_ACTIVE_W) ||
71 ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit)))
72 en |= FD_EV_ACTIVE_R;
73
Olivier Houchard53055052019-07-25 14:00:18 +000074 if ((polled_mask[fd].poll_send | polled_mask[fd].poll_recv) & tid_bit) {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020075 if (!(fdtab[fd].thread_mask & tid_bit) || !(en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +020076 /* fd removed from poll list */
77 opcode = EPOLL_CTL_DEL;
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);
Olivier Houchard6b96f722018-04-25 16:58:25 +020082 }
83 else {
Willy Tarreau5bee3e22019-09-04 09:52:57 +020084 if (((en & FD_EV_ACTIVE_R) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000085 ((polled_mask[fd].poll_recv & tid_bit) != 0) &&
Willy Tarreau5bee3e22019-09-04 09:52:57 +020086 ((en & FD_EV_ACTIVE_W) != 0) ==
Olivier Houchard53055052019-07-25 14:00:18 +000087 ((polled_mask[fd].poll_send & tid_bit) != 0))
88 return;
Willy Tarreau5bee3e22019-09-04 09:52:57 +020089 if (en & FD_EV_ACTIVE_R) {
Olivier Houchard53055052019-07-25 14:00:18 +000090 if (!(polled_mask[fd].poll_recv & tid_bit))
91 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
92 } else {
93 if (polled_mask[fd].poll_recv & tid_bit)
94 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
95 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +020096 if (en & FD_EV_ACTIVE_W) {
Olivier Houchard53055052019-07-25 14:00:18 +000097 if (!(polled_mask[fd].poll_send & tid_bit))
98 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
99 } else {
100 if (polled_mask[fd].poll_send & tid_bit)
101 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
102 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200103 /* fd status changed */
104 opcode = EPOLL_CTL_MOD;
105 }
106 }
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200107 else if ((fdtab[fd].thread_mask & tid_bit) && (en & FD_EV_ACTIVE_RW)) {
Olivier Houchard6b96f722018-04-25 16:58:25 +0200108 /* new fd in the poll list */
109 opcode = EPOLL_CTL_ADD;
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200110 if (en & FD_EV_ACTIVE_R)
Olivier Houchard53055052019-07-25 14:00:18 +0000111 _HA_ATOMIC_OR(&polled_mask[fd].poll_recv, tid_bit);
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200112 if (en & FD_EV_ACTIVE_W)
Olivier Houchard53055052019-07-25 14:00:18 +0000113 _HA_ATOMIC_OR(&polled_mask[fd].poll_send, tid_bit);
Olivier Houchard6b96f722018-04-25 16:58:25 +0200114 }
115 else {
116 return;
117 }
118
119 /* construct the epoll events based on new state */
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200120 if (en & FD_EV_ACTIVE_R)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200121 ev.events |= EPOLLIN | EPOLLRDHUP;
122
Willy Tarreau5bee3e22019-09-04 09:52:57 +0200123 if (en & FD_EV_ACTIVE_W)
Olivier Houchard6b96f722018-04-25 16:58:25 +0200124 ev.events |= EPOLLOUT;
125
126 ev.data.fd = fd;
127 epoll_ctl(epoll_fd[tid], opcode, fd, &ev);
128}
129
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200130/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100131 * Linux epoll() poller
Willy Tarreau4f60f162007-04-08 16:39:58 +0200132 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100133static void _do_poll(struct poller *p, int exp, int wake)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200134{
Olivier Houchard6b96f722018-04-25 16:58:25 +0200135 int status;
136 int fd;
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100137 int count;
138 int updt_idx;
139 int wait_time;
Olivier Houchard6b96f722018-04-25 16:58:25 +0200140 int old_fd;
Willy Tarreau58094f22007-04-10 01:33:20 +0200141
Willy Tarreau5be2f352014-11-19 19:43:05 +0100142 /* first, scan the update list to find polling changes */
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100143 for (updt_idx = 0; updt_idx < fd_nbupdt; updt_idx++) {
144 fd = fd_updt[updt_idx];
Willy Tarreau58094f22007-04-10 01:33:20 +0200145
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100146 _HA_ATOMIC_AND(&fdtab[fd].update_mask, ~tid_bit);
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100147 if (!fdtab[fd].owner) {
148 activity[tid].poll_drop++;
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100149 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100150 }
Willy Tarreau58094f22007-04-10 01:33:20 +0200151
Olivier Houchard6b96f722018-04-25 16:58:25 +0200152 _update_fd(fd);
153 }
154 fd_nbupdt = 0;
155 /* Scan the global update list */
156 for (old_fd = fd = update_list.first; fd != -1; fd = fdtab[fd].update.next) {
157 if (fd == -2) {
158 fd = old_fd;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100159 continue;
160 }
Olivier Houchard6b96f722018-04-25 16:58:25 +0200161 else if (fd <= -3)
162 fd = -fd -4;
163 if (fd == -1)
164 break;
165 if (fdtab[fd].update_mask & tid_bit)
166 done_update_polling(fd);
167 else
168 continue;
169 if (!fdtab[fd].owner)
170 continue;
171 _update_fd(fd);
Willy Tarreau58094f22007-04-10 01:33:20 +0200172 }
Willy Tarreau4f60f162007-04-08 16:39:58 +0200173
Willy Tarreau60b639c2018-08-02 10:16:17 +0200174 thread_harmless_now();
175
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100176 /* now let's wait for polled events */
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200177 wait_time = wake ? 0 : compute_poll_timeout(exp);
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200178 tv_entering_poll();
Willy Tarreau609aad92018-11-22 08:31:09 +0100179 activity_count_runtime();
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100180 do {
181 int timeout = (global.tune.options & GTUNE_BUSY_POLLING) ? 0 : wait_time;
182
183 status = epoll_wait(epoll_fd[tid], epoll_events, global.tune.maxpollevents, timeout);
184 tv_update_date(timeout, status);
185
186 if (status)
187 break;
188 if (timeout || !wait_time)
189 break;
Willy Tarreau2ae84e42019-05-28 16:44:05 +0200190 if (signal_queue_len || wake)
Willy Tarreaubeb859a2018-11-22 18:07:59 +0100191 break;
192 if (tick_isset(exp) && tick_is_expired(exp, now_ms))
193 break;
194 } while (1);
195
Willy Tarreau7e9c4ae2018-10-17 14:31:19 +0200196 tv_leaving_poll(wait_time, status);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200197
Willy Tarreau60b639c2018-08-02 10:16:17 +0200198 thread_harmless_end();
Olivier Houchard305d5ab2019-07-24 18:07:06 +0200199 if (sleeping_thread_mask & tid_bit)
200 _HA_ATOMIC_AND(&sleeping_thread_mask, ~tid_bit);
Willy Tarreau60b639c2018-08-02 10:16:17 +0200201
Willy Tarreaue9f49e72012-11-11 17:42:00 +0100202 /* process polled events */
203
Willy Tarreau4f60f162007-04-08 16:39:58 +0200204 for (count = 0; count < status; count++) {
Willy Tarreau902871d2020-02-20 11:23:43 +0100205 struct epoll_event ev;
206 unsigned int n, e;
207
208 e = epoll_events[count].events;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200209 fd = epoll_events[count].data.fd;
210
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100211 if (!fdtab[fd].owner) {
212 activity[tid].poll_dead++;
213 continue;
214 }
215
216 if (!(fdtab[fd].thread_mask & tid_bit)) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100217 /* FD has been migrated */
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100218 activity[tid].poll_skip++;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100219 epoll_ctl(epoll_fd[tid], EPOLL_CTL_DEL, fd, &ev);
Olivier Houchard53055052019-07-25 14:00:18 +0000220 _HA_ATOMIC_AND(&polled_mask[fd].poll_recv, ~tid_bit);
221 _HA_ATOMIC_AND(&polled_mask[fd].poll_send, ~tid_bit);
Willy Tarreau076be252012-07-06 16:02:29 +0200222 continue;
Willy Tarreaud80cb4e2018-01-20 19:30:13 +0100223 }
Willy Tarreau076be252012-07-06 16:02:29 +0200224
Willy Tarreau6b308982019-09-06 19:05:50 +0200225 n = ((e & EPOLLIN) ? FD_EV_READY_R : 0) |
226 ((e & EPOLLOUT) ? FD_EV_READY_W : 0) |
227 ((e & EPOLLRDHUP) ? FD_EV_SHUT_R : 0) |
228 ((e & EPOLLHUP) ? FD_EV_SHUT_RW : 0) |
229 ((e & EPOLLERR) ? FD_EV_ERR_RW : 0);
Willy Tarreau491c4982012-07-06 11:16:01 +0200230
Willy Tarreau6b308982019-09-06 19:05:50 +0200231 if ((e & EPOLLRDHUP) && !(cur_poller.flags & HAP_POLL_F_RDHUP))
Olivier Houchardcb6c9272019-03-08 18:49:54 +0100232 _HA_ATOMIC_OR(&cur_poller.flags, HAP_POLL_F_RDHUP);
Willy Tarreau6b308982019-09-06 19:05:50 +0200233
Christopher Fauletab62f512017-08-30 10:34:36 +0200234 fd_update_events(fd, n);
Willy Tarreau4f60f162007-04-08 16:39:58 +0200235 }
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100236 /* the caller will take care of cached events */
Willy Tarreau4f60f162007-04-08 16:39:58 +0200237}
238
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200239static int init_epoll_per_thread()
240{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100241 int fd;
242
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200243 epoll_events = calloc(1, sizeof(struct epoll_event) * global.tune.maxpollevents);
244 if (epoll_events == NULL)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100245 goto fail_alloc;
246
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100247 if (MAX_THREADS > 1 && tid) {
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100248 epoll_fd[tid] = epoll_create(global.maxsock + 1);
249 if (epoll_fd[tid] < 0)
250 goto fail_fd;
251 }
252
253 /* we may have to unregister some events initially registered on the
254 * original fd when it was alone, and/or to register events on the new
255 * fd for this thread. Let's just mark them as updated, the poller will
256 * do the rest.
257 */
Willy Tarreauce036bc2018-01-29 14:58:02 +0100258 for (fd = 0; fd < global.maxsock; fd++)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100259 updt_fd_polling(fd);
260
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200261 return 1;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100262 fail_fd:
263 free(epoll_events);
264 fail_alloc:
265 return 0;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200266}
267
268static void deinit_epoll_per_thread()
269{
Christopher Faulet3e805ed2018-01-25 16:18:09 +0100270 if (MAX_THREADS > 1 && tid)
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100271 close(epoll_fd[tid]);
272
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200273 free(epoll_events);
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200274 epoll_events = NULL;
Christopher Fauletd4604ad2017-05-29 10:40:41 +0200275}
276
Willy Tarreau4f60f162007-04-08 16:39:58 +0200277/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100278 * Initialization of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200279 * Returns 0 in case of failure, non-zero in case of success. If it fails, it
280 * disables the poller by setting its pref to 0.
281 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100282static int _do_init(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200283{
Willy Tarreaue54e9172007-04-09 09:23:31 +0200284 p->private = NULL;
Willy Tarreaue54e9172007-04-09 09:23:31 +0200285
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100286 epoll_fd[tid] = epoll_create(global.maxsock + 1);
287 if (epoll_fd[tid] < 0)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200288 goto fail_fd;
289
Christopher Fauletcd7879a2017-10-27 13:53:47 +0200290 hap_register_per_thread_init(init_epoll_per_thread);
291 hap_register_per_thread_deinit(deinit_epoll_per_thread);
Willy Tarreaue54e9172007-04-09 09:23:31 +0200292
Willy Tarreaue54e9172007-04-09 09:23:31 +0200293 return 1;
294
Willy Tarreaue54e9172007-04-09 09:23:31 +0200295 fail_fd:
296 p->pref = 0;
297 return 0;
298}
299
300/*
Willy Tarreauf817e9f2014-01-10 16:58:45 +0100301 * Termination of the epoll() poller.
Willy Tarreaue54e9172007-04-09 09:23:31 +0200302 * Memory is released and the poller is marked as unselectable.
303 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100304static void _do_term(struct poller *p)
Willy Tarreaue54e9172007-04-09 09:23:31 +0200305{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100306 if (epoll_fd[tid] >= 0) {
307 close(epoll_fd[tid]);
308 epoll_fd[tid] = -1;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200309 }
Willy Tarreaue54e9172007-04-09 09:23:31 +0200310
311 p->private = NULL;
312 p->pref = 0;
313}
314
315/*
Willy Tarreau2ff76222007-04-09 19:29:56 +0200316 * Check that the poller works.
317 * Returns 1 if OK, otherwise 0.
318 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100319static int _do_test(struct poller *p)
Willy Tarreau2ff76222007-04-09 19:29:56 +0200320{
321 int fd;
322
323 fd = epoll_create(global.maxsock + 1);
324 if (fd < 0)
325 return 0;
326 close(fd);
327 return 1;
328}
329
330/*
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200331 * Recreate the epoll file descriptor after a fork(). Returns 1 if OK,
332 * otherwise 0. It will ensure that all processes will not share their
333 * epoll_fd. Some side effects were encountered because of this, such
334 * as epoll_wait() returning an FD which was previously deleted.
335 */
Willy Tarreau03e78532020-02-25 07:38:05 +0100336static int _do_fork(struct poller *p)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200337{
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100338 if (epoll_fd[tid] >= 0)
339 close(epoll_fd[tid]);
340 epoll_fd[tid] = epoll_create(global.maxsock + 1);
341 if (epoll_fd[tid] < 0)
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200342 return 0;
343 return 1;
344}
345
346/*
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200347 * It is a constructor, which means that it will automatically be called before
348 * main(). This is GCC-specific but it works at least since 2.95.
349 * Special care must be taken so that it does not need any uninitialized data.
Willy Tarreau4f60f162007-04-08 16:39:58 +0200350 */
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200351__attribute__((constructor))
352static void _do_register(void)
Willy Tarreau4f60f162007-04-08 16:39:58 +0200353{
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200354 struct poller *p;
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100355 int i;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200356
357 if (nbpollers >= MAX_POLLERS)
358 return;
Willy Tarreaud79e79b2009-05-10 10:18:54 +0200359
Willy Tarreaud9e7e362018-01-18 19:16:02 +0100360 for (i = 0; i < MAX_THREADS; i++)
361 epoll_fd[i] = -1;
362
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200363 p = &pollers[nbpollers++];
364
Willy Tarreau4f60f162007-04-08 16:39:58 +0200365 p->name = "epoll";
366 p->pref = 300;
Willy Tarreau11ef0832019-11-28 18:17:33 +0100367 p->flags = HAP_POLL_F_ERRHUP; // note: RDHUP might be dynamically added
Willy Tarreau4f60f162007-04-08 16:39:58 +0200368 p->private = NULL;
369
Conrad Hoffmann041751c2014-05-20 14:28:24 +0200370 p->clo = __fd_clo;
Willy Tarreauef1d1f82007-04-16 00:25:25 +0200371 p->test = _do_test;
372 p->init = _do_init;
373 p->term = _do_term;
374 p->poll = _do_poll;
Willy Tarreaufb8983f2007-06-03 16:40:44 +0200375 p->fork = _do_fork;
Willy Tarreau4f60f162007-04-08 16:39:58 +0200376}
377
378
379/*
380 * Local variables:
381 * c-indent-level: 8
382 * c-basic-offset: 8
383 * End:
384 */