cff6e46e2c4db97c157f902f6af1dad4252ce212
[gd/samba-autobuild/.git] / lib / tevent / tevent_epoll.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    main select loop and event handling - epoll implementation
5
6    Copyright (C) Andrew Tridgell        2003-2005
7    Copyright (C) Stefan Metzmacher      2005
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 3 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
21 */
22
23 #include "replace.h"
24 #include "system/filesys.h"
25 #include "system/network.h"
26 #include "tevent.h"
27 #include "tevent_internal.h"
28 #include "tevent_util.h"
29 #include <sys/epoll.h>
30
31 struct epoll_event_context {
32         /* a pointer back to the generic event_context */
33         struct event_context *ev;
34
35         /* list of filedescriptor events */
36         struct fd_event *fd_events;
37
38         /* number of registered fd event handlers */
39         int num_fd_events;
40
41         /* this is changed by the destructors for the fd event
42            type. It is used to detect event destruction by event
43            handlers, which means the code that is calling the event
44            handler needs to assume that the linked list is no longer
45            valid
46         */
47         uint32_t destruction_count;
48
49         /* when using epoll this is the handle from epoll_create */
50         int epoll_fd;
51
52         pid_t pid;
53 };
54
55 /*
56   called when a epoll call fails, and we should fallback
57   to using select
58 */
59 static void epoll_panic(struct epoll_event_context *epoll_ev, const char *reason)
60 {
61         ev_debug(epoll_ev->ev, EV_DEBUG_FATAL,
62                  "%s (%s) - calling abort()\n", reason, strerror(errno));
63         abort();
64 }
65
66 /*
67   map from EVENT_FD_* to EPOLLIN/EPOLLOUT
68 */
69 static uint32_t epoll_map_flags(uint16_t flags)
70 {
71         uint32_t ret = 0;
72         if (flags & EVENT_FD_READ) ret |= (EPOLLIN | EPOLLERR | EPOLLHUP);
73         if (flags & EVENT_FD_WRITE) ret |= (EPOLLOUT | EPOLLERR | EPOLLHUP);
74         return ret;
75 }
76
77 /*
78  free the epoll fd
79 */
80 static int epoll_ctx_destructor(struct epoll_event_context *epoll_ev)
81 {
82         close(epoll_ev->epoll_fd);
83         epoll_ev->epoll_fd = -1;
84         return 0;
85 }
86
87 /*
88  init the epoll fd
89 */
90 static int epoll_init_ctx(struct epoll_event_context *epoll_ev)
91 {
92         epoll_ev->epoll_fd = epoll_create(64);
93         epoll_ev->pid = getpid();
94         talloc_set_destructor(epoll_ev, epoll_ctx_destructor);
95         if (epoll_ev->epoll_fd == -1) {
96                 return -1;
97         }
98         return 0;
99 }
100
101 static void epoll_add_event(struct epoll_event_context *epoll_ev, struct fd_event *fde);
102
103 /*
104   reopen the epoll handle when our pid changes
105   see http://junkcode.samba.org/ftp/unpacked/junkcode/epoll_fork.c for an 
106   demonstration of why this is needed
107  */
108 static void epoll_check_reopen(struct epoll_event_context *epoll_ev)
109 {
110         struct fd_event *fde;
111
112         if (epoll_ev->pid == getpid()) {
113                 return;
114         }
115
116         close(epoll_ev->epoll_fd);
117         epoll_ev->epoll_fd = epoll_create(64);
118         if (epoll_ev->epoll_fd == -1) {
119                 ev_debug(epoll_ev->ev, EV_DEBUG_FATAL,
120                          "Failed to recreate epoll handle after fork\n");
121                 return;
122         }
123         epoll_ev->pid = getpid();
124         for (fde=epoll_ev->fd_events;fde;fde=fde->next) {
125                 epoll_add_event(epoll_ev, fde);
126         }
127 }
128
129 #define EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT      (1<<0)
130 #define EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR   (1<<1)
131 #define EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR      (1<<2)
132
133 /*
134  add the epoll event to the given fd_event
135 */
136 static void epoll_add_event(struct epoll_event_context *epoll_ev, struct fd_event *fde)
137 {
138         struct epoll_event event;
139
140         if (epoll_ev->epoll_fd == -1) return;
141
142         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
143
144         /* if we don't want events yet, don't add an epoll_event */
145         if (fde->flags == 0) return;
146
147         ZERO_STRUCT(event);
148         event.events = epoll_map_flags(fde->flags);
149         event.data.ptr = fde;
150         if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_ADD, fde->fd, &event) != 0) {
151                 epoll_panic(epoll_ev, "EPOLL_CTL_ADD failed");
152         }
153         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
154
155         /* only if we want to read we want to tell the event handler about errors */
156         if (fde->flags & EVENT_FD_READ) {
157                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
158         }
159 }
160
161 /*
162  delete the epoll event for given fd_event
163 */
164 static void epoll_del_event(struct epoll_event_context *epoll_ev, struct fd_event *fde)
165 {
166         struct epoll_event event;
167
168         if (epoll_ev->epoll_fd == -1) return;
169
170         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
171
172         /* if there's no epoll_event, we don't need to delete it */
173         if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT)) return;
174
175         ZERO_STRUCT(event);
176         event.events = epoll_map_flags(fde->flags);
177         event.data.ptr = fde;
178         if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_DEL, fde->fd, &event) != 0) {
179                 ev_debug(epoll_ev->ev, EV_DEBUG_FATAL,
180                          "epoll_del_event failed! probable early close bug (%s)\n",
181                          strerror(errno));
182         }
183         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT;
184 }
185
186 /*
187  change the epoll event to the given fd_event
188 */
189 static void epoll_mod_event(struct epoll_event_context *epoll_ev, struct fd_event *fde)
190 {
191         struct epoll_event event;
192         if (epoll_ev->epoll_fd == -1) return;
193
194         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
195
196         ZERO_STRUCT(event);
197         event.events = epoll_map_flags(fde->flags);
198         event.data.ptr = fde;
199         if (epoll_ctl(epoll_ev->epoll_fd, EPOLL_CTL_MOD, fde->fd, &event) != 0) {
200                 epoll_panic(epoll_ev, "EPOLL_CTL_MOD failed");
201         }
202
203         /* only if we want to read we want to tell the event handler about errors */
204         if (fde->flags & EVENT_FD_READ) {
205                 fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
206         }
207 }
208
209 static void epoll_change_event(struct epoll_event_context *epoll_ev, struct fd_event *fde)
210 {
211         bool got_error = (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR);
212         bool want_read = (fde->flags & EVENT_FD_READ);
213         bool want_write= (fde->flags & EVENT_FD_WRITE);
214
215         if (epoll_ev->epoll_fd == -1) return;
216
217         fde->additional_flags &= ~EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR;
218
219         /* there's already an event */
220         if (fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_HAS_EVENT) {
221                 if (want_read || (want_write && !got_error)) {
222                         epoll_mod_event(epoll_ev, fde);
223                         return;
224                 }
225                 /* 
226                  * if we want to match the select behavior, we need to remove the epoll_event
227                  * when the caller isn't interested in events.
228                  *
229                  * this is because epoll reports EPOLLERR and EPOLLHUP, even without asking for them
230                  */
231                 epoll_del_event(epoll_ev, fde);
232                 return;
233         }
234
235         /* there's no epoll_event attached to the fde */
236         if (want_read || (want_write && !got_error)) {
237                 epoll_add_event(epoll_ev, fde);
238                 return;
239         }
240 }
241
242 /*
243   event loop handling using epoll
244 */
245 static int epoll_event_loop(struct epoll_event_context *epoll_ev, struct timeval *tvalp)
246 {
247         int ret, i;
248 #define MAXEVENTS 32
249         struct epoll_event events[MAXEVENTS];
250         uint32_t destruction_count = ++epoll_ev->destruction_count;
251         int timeout = -1;
252
253         if (epoll_ev->epoll_fd == -1) return -1;
254
255         if (tvalp) {
256                 /* it's better to trigger timed events a bit later than to early */
257                 timeout = ((tvalp->tv_usec+999) / 1000) + (tvalp->tv_sec*1000);
258         }
259
260         if (epoll_ev->ev->num_signal_handlers && 
261             common_event_check_signal(epoll_ev->ev)) {
262                 return 0;
263         }
264
265         ret = epoll_wait(epoll_ev->epoll_fd, events, MAXEVENTS, timeout);
266
267         if (ret == -1 && errno == EINTR && epoll_ev->ev->num_signal_handlers) {
268                 if (common_event_check_signal(epoll_ev->ev)) {
269                         return 0;
270                 }
271         }
272
273         if (ret == -1 && errno != EINTR) {
274                 epoll_panic(epoll_ev, "epoll_wait() failed");
275                 return -1;
276         }
277
278         if (ret == 0 && tvalp) {
279                 /* we don't care about a possible delay here */
280                 common_event_loop_timer_delay(epoll_ev->ev);
281                 return 0;
282         }
283
284         for (i=0;i<ret;i++) {
285                 struct fd_event *fde = talloc_get_type(events[i].data.ptr, 
286                                                        struct fd_event);
287                 uint16_t flags = 0;
288
289                 if (fde == NULL) {
290                         epoll_panic(epoll_ev, "epoll_wait() gave bad data");
291                         return -1;
292                 }
293                 if (events[i].events & (EPOLLHUP|EPOLLERR)) {
294                         fde->additional_flags |= EPOLL_ADDITIONAL_FD_FLAG_GOT_ERROR;
295                         /*
296                          * if we only wait for EVENT_FD_WRITE, we should not tell the
297                          * event handler about it, and remove the epoll_event,
298                          * as we only report errors when waiting for read events,
299                          * to match the select() behavior
300                          */
301                         if (!(fde->additional_flags & EPOLL_ADDITIONAL_FD_FLAG_REPORT_ERROR)) {
302                                 epoll_del_event(epoll_ev, fde);
303                                 continue;
304                         }
305                         flags |= EVENT_FD_READ;
306                 }
307                 if (events[i].events & EPOLLIN) flags |= EVENT_FD_READ;
308                 if (events[i].events & EPOLLOUT) flags |= EVENT_FD_WRITE;
309                 if (flags) {
310                         fde->handler(epoll_ev->ev, fde, flags, fde->private_data);
311                         if (destruction_count != epoll_ev->destruction_count) {
312                                 break;
313                         }
314                 }
315         }
316
317         return 0;
318 }
319
320 /*
321   create a epoll_event_context structure.
322 */
323 static int epoll_event_context_init(struct event_context *ev)
324 {
325         int ret;
326         struct epoll_event_context *epoll_ev;
327
328         epoll_ev = talloc_zero(ev, struct epoll_event_context);
329         if (!epoll_ev) return -1;
330         epoll_ev->ev = ev;
331         epoll_ev->epoll_fd = -1;
332
333         ret = epoll_init_ctx(epoll_ev);
334         if (ret != 0) {
335                 talloc_free(epoll_ev);
336                 return ret;
337         }
338
339         ev->additional_data = epoll_ev;
340         return 0;
341 }
342
343 /*
344   destroy an fd_event
345 */
346 static int epoll_event_fd_destructor(struct fd_event *fde)
347 {
348         struct event_context *ev = fde->event_ctx;
349         struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
350                                                            struct epoll_event_context);
351
352         epoll_check_reopen(epoll_ev);
353
354         epoll_ev->num_fd_events--;
355         epoll_ev->destruction_count++;
356
357         DLIST_REMOVE(epoll_ev->fd_events, fde);
358                 
359         epoll_del_event(epoll_ev, fde);
360
361         if (fde->flags & EVENT_FD_AUTOCLOSE) {
362                 close(fde->fd);
363                 fde->fd = -1;
364         }
365
366         return 0;
367 }
368
369 /*
370   add a fd based event
371   return NULL on failure (memory allocation error)
372 */
373 static struct fd_event *epoll_event_add_fd(struct event_context *ev, TALLOC_CTX *mem_ctx,
374                                          int fd, uint16_t flags,
375                                          event_fd_handler_t handler,
376                                          void *private_data)
377 {
378         struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
379                                                            struct epoll_event_context);
380         struct fd_event *fde;
381
382         epoll_check_reopen(epoll_ev);
383
384         fde = talloc(mem_ctx?mem_ctx:ev, struct fd_event);
385         if (!fde) return NULL;
386
387         fde->event_ctx          = ev;
388         fde->fd                 = fd;
389         fde->flags              = flags;
390         fde->handler            = handler;
391         fde->private_data       = private_data;
392         fde->additional_flags   = 0;
393         fde->additional_data    = NULL;
394
395         epoll_ev->num_fd_events++;
396         talloc_set_destructor(fde, epoll_event_fd_destructor);
397
398         DLIST_ADD(epoll_ev->fd_events, fde);
399         epoll_add_event(epoll_ev, fde);
400
401         return fde;
402 }
403
404
405 /*
406   return the fd event flags
407 */
408 static uint16_t epoll_event_get_fd_flags(struct fd_event *fde)
409 {
410         return fde->flags;
411 }
412
413 /*
414   set the fd event flags
415 */
416 static void epoll_event_set_fd_flags(struct fd_event *fde, uint16_t flags)
417 {
418         struct event_context *ev;
419         struct epoll_event_context *epoll_ev;
420
421         if (fde->flags == flags) return;
422
423         ev = fde->event_ctx;
424         epoll_ev = talloc_get_type(ev->additional_data, struct epoll_event_context);
425
426         fde->flags = flags;
427
428         epoll_check_reopen(epoll_ev);
429
430         epoll_change_event(epoll_ev, fde);
431 }
432
433 /*
434   do a single event loop using the events defined in ev 
435 */
436 static int epoll_event_loop_once(struct event_context *ev)
437 {
438         struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
439                                                            struct epoll_event_context);
440         struct timeval tval;
441
442         tval = common_event_loop_timer_delay(ev);
443         if (ev_timeval_is_zero(&tval)) {
444                 return 0;
445         }
446
447         epoll_check_reopen(epoll_ev);
448
449         return epoll_event_loop(epoll_ev, &tval);
450 }
451
452 /*
453   return on failure or (with 0) if all fd events are removed
454 */
455 static int epoll_event_loop_wait(struct event_context *ev)
456 {
457         struct epoll_event_context *epoll_ev = talloc_get_type(ev->additional_data,
458                                                            struct epoll_event_context);
459         while (epoll_ev->num_fd_events) {
460                 if (epoll_event_loop_once(ev) != 0) {
461                         break;
462                 }
463         }
464
465         return 0;
466 }
467
468 static const struct event_ops epoll_event_ops = {
469         .context_init   = epoll_event_context_init,
470         .add_fd         = epoll_event_add_fd,
471         .get_fd_flags   = epoll_event_get_fd_flags,
472         .set_fd_flags   = epoll_event_set_fd_flags,
473         .add_timer      = common_event_add_timed,
474         .add_signal     = common_event_add_signal,
475         .loop_once      = epoll_event_loop_once,
476         .loop_wait      = epoll_event_loop_wait,
477 };
478
479 bool events_epoll_init(void)
480 {
481         return event_register_backend("epoll", &epoll_event_ops);
482 }