2 * ircd-ratbox: A slightly useful ircd.
3 * epoll.c: Linux epoll compatible network routines.
5 * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center
6 * Copyright (C) 1996-2002 Hybrid Development Team
7 * Copyright (C) 2001 Adrian Chadd <adrian@creative.net.au>
8 * Copyright (C) 2002-2005 ircd-ratbox development team
9 * Copyright (C) 2002 Aaron Sethman <androsyn@ratbox.org>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
26 * $Id: epoll.c 26092 2008-09-19 15:13:52Z androsyn $
30 #include <libratbox_config.h>
31 #include <ratbox_lib.h>
32 #include <commio-int.h>
33 #include <event-int.h>
34 #if defined(HAVE_EPOLL_CTL) && (HAVE_SYS_EPOLL_H)
37 #include <sys/epoll.h>
39 #if defined(HAVE_SIGNALFD) && (HAVE_SYS_SIGNALFD_H) && (USE_TIMER_CREATE) && (HAVE_SYS_UIO_H)
41 #include <sys/signalfd.h>
43 #define EPOLL_SCHED_EVENT 1
46 #if defined(USE_TIMERFD_CREATE)
47 #include <sys/timerfd.h>
50 #define RTSIGNAL SIGRTMIN
54 struct epoll_event
*pfd
;
58 static struct epoll_info
*ep_info
;
59 static int can_do_event
;
60 static int can_do_timerfd
;
65 * This is a needed exported function which will be called to initialise
66 * the network loop code.
69 rb_init_netio_epoll(void)
71 can_do_event
= 0; /* shut up gcc */
72 ep_info
= rb_malloc(sizeof(struct epoll_info
));
73 ep_info
->pfd_size
= getdtablesize();
74 ep_info
->ep
= epoll_create(ep_info
->pfd_size
);
79 rb_open(ep_info
->ep
, RB_FD_UNKNOWN
, "epoll file descriptor");
80 ep_info
->pfd
= rb_malloc(sizeof(struct epoll_event
) * ep_info
->pfd_size
);
86 rb_setup_fd_epoll(rb_fde_t
*F
)
95 * This is a needed exported function which will be called to register
96 * and deregister interest in a pending IO state for a given FD.
99 rb_setselect_epoll(rb_fde_t
*F
, unsigned int type
, PF
* handler
, void *client_data
)
101 struct epoll_event ep_event
;
102 int old_flags
= F
->pflags
;
105 lrb_assert(IsFDOpen(F
));
107 /* Update the list, even though we're not using it .. */
108 if(type
& RB_SELECT_READ
)
111 F
->pflags
|= EPOLLIN
;
113 F
->pflags
&= ~EPOLLIN
;
114 F
->read_handler
= handler
;
115 F
->read_data
= client_data
;
118 if(type
& RB_SELECT_WRITE
)
121 F
->pflags
|= EPOLLOUT
;
123 F
->pflags
&= ~EPOLLOUT
;
124 F
->write_handler
= handler
;
125 F
->write_data
= client_data
;
128 if(old_flags
== 0 && F
->pflags
== 0)
130 else if(F
->pflags
<= 0)
132 else if(old_flags
== 0 && F
->pflags
> 0)
134 else if(F
->pflags
!= old_flags
)
140 ep_event
.events
= F
->pflags
;
141 ep_event
.data
.ptr
= F
;
143 if(op
== EPOLL_CTL_ADD
|| op
== EPOLL_CTL_MOD
)
144 ep_event
.events
|= EPOLLET
;
146 if(epoll_ctl(ep_info
->ep
, op
, F
->fd
, &ep_event
) != 0)
148 rb_lib_log("rb_setselect_epoll(): epoll_ctl failed: %s", strerror(errno
));
158 * Called to do the new-style IO, courtesy of squid (like most of this
159 * new IO code). This routine handles the stuff we've hidden in
160 * rb_setselect and fd_table[] and calls callbacks for IO ready
165 rb_select_epoll(long delay
)
167 int num
, i
, flags
, old_flags
, op
;
168 struct epoll_event ep_event
;
172 num
= epoll_wait(ep_info
->ep
, ep_info
->pfd
, ep_info
->pfd_size
, delay
);
174 /* save errno as rb_set_time() will likely clobber it */
179 if(num
< 0 && !rb_ignore_errno(o_errno
))
185 for(i
= 0; i
< num
; i
++)
188 rb_fde_t
*F
= ep_info
->pfd
[i
].data
.ptr
;
189 old_flags
= F
->pflags
;
190 if(ep_info
->pfd
[i
].events
& (EPOLLIN
| EPOLLHUP
| EPOLLERR
))
192 hdl
= F
->read_handler
;
194 F
->read_handler
= NULL
;
204 if(ep_info
->pfd
[i
].events
& (EPOLLOUT
| EPOLLHUP
| EPOLLERR
))
206 hdl
= F
->write_handler
;
207 data
= F
->write_data
;
208 F
->write_handler
= NULL
;
209 F
->write_data
= NULL
;
222 if(F
->read_handler
!= NULL
)
224 if(F
->write_handler
!= NULL
)
227 if(old_flags
!= flags
)
233 F
->pflags
= ep_event
.events
= flags
;
234 ep_event
.data
.ptr
= F
;
235 if(op
== EPOLL_CTL_MOD
|| op
== EPOLL_CTL_ADD
)
236 ep_event
.events
|= EPOLLET
;
238 if(epoll_ctl(ep_info
->ep
, op
, F
->fd
, &ep_event
) != 0)
240 rb_lib_log("rb_select_epoll(): epoll_ctl failed: %s",
249 #ifdef EPOLL_SCHED_EVENT
251 rb_epoll_supports_event(void)
253 /* try to detect at runtime if everything we need actually works */
259 if(can_do_event
== 1)
261 if(can_do_event
== -1)
264 #ifdef USE_TIMERFD_CREATE
265 if((fd
= timerfd_create(CLOCK_REALTIME
, 0)) >= 0)
274 ev
.sigev_signo
= SIGVTALRM
;
275 ev
.sigev_notify
= SIGEV_SIGNAL
;
276 if(timer_create(CLOCK_REALTIME
, &ev
, &timer
) != 0)
283 fd
= signalfd(-1, &set
, 0);
295 /* bleh..work around a glibc header bug on 32bit systems */
296 struct our_signalfd_siginfo
318 #define SIGFDIOV_COUNT 16
320 signalfd_handler(rb_fde_t
*F
, void *data
)
322 static struct our_signalfd_siginfo fdsig
[SIGFDIOV_COUNT
];
323 static struct iovec iov
[SIGFDIOV_COUNT
];
327 for(x
= 0; x
< SIGFDIOV_COUNT
; x
++)
329 iov
[x
].iov_base
= &fdsig
[x
];
330 iov
[x
].iov_len
= sizeof(struct our_signalfd_siginfo
);
335 ret
= readv(rb_get_fd(F
), iov
, SIGFDIOV_COUNT
);
336 if(ret
== 0 || (ret
< 0 && !rb_ignore_errno(errno
)))
339 rb_epoll_init_event();
345 rb_setselect(F
, RB_SELECT_READ
, signalfd_handler
, NULL
);
348 for(x
= 0; x
< ret
/ (int)sizeof(struct our_signalfd_siginfo
); x
++)
350 ev
= (struct ev_entry
*)((uintptr_t)fdsig
[x
].svptr
);
359 rb_epoll_init_event(void)
365 rb_epoll_supports_event();
369 sigaddset(&ss
, RTSIGNAL
);
370 sigprocmask(SIG_BLOCK
, &ss
, 0);
372 sigaddset(&ss
, RTSIGNAL
);
373 sfd
= signalfd(-1, &ss
, 0);
379 F
= rb_open(sfd
, RB_FD_UNKNOWN
, "signalfd");
381 signalfd_handler(F
, NULL
);
386 rb_epoll_sched_event_signalfd(struct ev_entry
*event
, int when
)
390 struct itimerspec ts
;
392 memset(&ev
, 0, sizeof(&ev
));
393 event
->comm_ptr
= rb_malloc(sizeof(timer_t
));
394 id
= event
->comm_ptr
;
395 ev
.sigev_notify
= SIGEV_SIGNAL
;
396 ev
.sigev_signo
= RTSIGNAL
;
397 ev
.sigev_value
.sival_ptr
= event
;
399 if(timer_create(CLOCK_REALTIME
, &ev
, id
) < 0)
401 rb_lib_log("timer_create: %s\n", strerror(errno
));
404 memset(&ts
, 0, sizeof(ts
));
405 ts
.it_value
.tv_sec
= when
;
406 ts
.it_value
.tv_nsec
= 0;
407 if(event
->frequency
!= 0)
408 ts
.it_interval
= ts
.it_value
;
410 if(timer_settime(*id
, 0, &ts
, NULL
) < 0)
412 rb_lib_log("timer_settime: %s\n", strerror(errno
));
418 #ifdef USE_TIMERFD_CREATE
420 rb_read_timerfd(rb_fde_t
*F
, void *data
)
422 struct ev_entry
*event
= (struct ev_entry
*)data
;
432 retlen
= rb_read(F
, &count
, sizeof(count
));
433 if(retlen
== 0 || (retlen
< 0 && !rb_ignore_errno(errno
)))
436 rb_lib_log("rb_read_timerfd: timerfd[%s] closed on error: %s", event
->name
,
440 rb_setselect(F
, RB_SELECT_READ
, rb_read_timerfd
, event
);
446 rb_epoll_sched_event_timerfd(struct ev_entry
*event
, int when
)
448 struct itimerspec ts
;
449 static char buf
[FD_DESC_SZ
+ 8];
453 if((fd
= timerfd_create(CLOCK_REALTIME
, 0)) < 0)
455 rb_lib_log("timerfd_create: %s\n", strerror(errno
));
459 memset(&ts
, 0, sizeof(ts
));
460 ts
.it_value
.tv_sec
= when
;
461 ts
.it_value
.tv_nsec
= 0;
462 if(event
->frequency
!= 0)
463 ts
.it_interval
= ts
.it_value
;
465 if(timerfd_settime(fd
, 0, &ts
, NULL
) < 0)
467 rb_lib_log("timerfd_settime: %s\n", strerror(errno
));
471 rb_snprintf(buf
, sizeof(buf
), "timerfd: %s", event
->name
);
472 F
= rb_open(fd
, RB_FD_UNKNOWN
, buf
);
475 rb_setselect(F
, RB_SELECT_READ
, rb_read_timerfd
, event
);
483 rb_epoll_sched_event(struct ev_entry
*event
, int when
)
485 #ifdef USE_TIMERFD_CREATE
488 return rb_epoll_sched_event_timerfd(event
, when
);
491 return rb_epoll_sched_event_signalfd(event
, when
);
495 rb_epoll_unsched_event(struct ev_entry
*event
)
497 #ifdef USE_TIMERFD_CREATE
500 rb_close((rb_fde_t
*)event
->comm_ptr
);
501 event
->comm_ptr
= NULL
;
505 timer_delete(*((timer_t
*) event
->comm_ptr
));
506 rb_free(event
->comm_ptr
);
507 event
->comm_ptr
= NULL
;
509 #endif /* EPOLL_SCHED_EVENT */
511 #else /* epoll not supported here */
513 rb_init_netio_epoll(void)
519 rb_setselect_epoll(rb_fde_t
*F
, unsigned int type
, PF
* handler
, void *client_data
)
526 rb_select_epoll(long delay
)
533 rb_setup_fd_epoll(rb_fde_t
*F
)
542 #if !defined(USING_EPOLL) || !defined(EPOLL_SCHED_EVENT)
544 rb_epoll_init_event(void)
550 rb_epoll_sched_event(struct ev_entry
*event
, int when
)
557 rb_epoll_unsched_event(struct ev_entry
*event
)
563 rb_epoll_supports_event(void)
568 #endif /* !USING_EPOLL || !EPOLL_SCHED_EVENT */