tevent: Only set poll_ev->delete=false if it was true
[samba.git] / lib / tevent / tevent_poll.c
1 /*
2    Unix SMB/CIFS implementation.
3    main select loop and event handling
4    Copyright (C) Andrew Tridgell        2003-2005
5    Copyright (C) Stefan Metzmacher      2005-2009
6
7      ** NOTE! The following LGPL license applies to the tevent
8      ** library. This does NOT imply that all of Samba is released
9      ** under the LGPL
10
11    This library is free software; you can redistribute it and/or
12    modify it under the terms of the GNU Lesser General Public
13    License as published by the Free Software Foundation; either
14    version 3 of the License, or (at your option) any later version.
15
16    This library 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 GNU
19    Lesser General Public License for more details.
20
21    You should have received a copy of the GNU Lesser General Public
22    License along with this library; if not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "replace.h"
26 #include "system/filesys.h"
27 #include "system/select.h"
28 #include "tevent.h"
29 #include "tevent_util.h"
30 #include "tevent_internal.h"
31
32 struct poll_event_context {
33         /* a pointer back to the generic event_context */
34         struct tevent_context *ev;
35
36         /*
37          * A DLIST for fresh fde's added by poll_event_add_fd but not
38          * picked up yet by poll_event_loop_once
39          */
40         struct tevent_fd *fresh;
41         /*
42          * A DLIST for disabled fde's.
43          */
44         struct tevent_fd *disabled;
45         /*
46          * one or more events were deleted or disabled
47          */
48         bool deleted;
49
50         /*
51          * These two arrays are maintained together.
52          */
53         struct pollfd *fds;
54         struct tevent_fd **fdes;
55         unsigned num_fds;
56
57         /*
58          * Signal fd to wake the poll() thread
59          */
60         int signal_fd;
61
62         /* information for exiting from the event loop */
63         int exit_code;
64 };
65
66 static int poll_event_context_destructor(struct poll_event_context *poll_ev)
67 {
68         struct tevent_fd *fd, *fn;
69
70         for (fd = poll_ev->fresh; fd; fd = fn) {
71                 fn = fd->next;
72                 fd->event_ctx = NULL;
73                 DLIST_REMOVE(poll_ev->fresh, fd);
74         }
75
76         for (fd = poll_ev->disabled; fd; fd = fn) {
77                 fn = fd->next;
78                 fd->event_ctx = NULL;
79                 DLIST_REMOVE(poll_ev->disabled, fd);
80         }
81
82         if (poll_ev->signal_fd == -1) {
83                 /*
84                  * Non-threaded, no signal pipe
85                  */
86                 return 0;
87         }
88
89         close(poll_ev->signal_fd);
90         poll_ev->signal_fd = -1;
91
92         if (poll_ev->num_fds == 0) {
93                 return 0;
94         }
95         if (poll_ev->fds[0].fd != -1) {
96                 close(poll_ev->fds[0].fd);
97                 poll_ev->fds[0].fd = -1;
98         }
99         return 0;
100 }
101
102 /*
103   create a poll_event_context structure.
104 */
105 static int poll_event_context_init(struct tevent_context *ev)
106 {
107         struct poll_event_context *poll_ev;
108
109         /*
110          * we might be called during tevent_re_initialise()
111          * which means we need to free our old additional_data
112          * in order to detach old fd events from the
113          * poll_ev->fresh list
114          */
115         TALLOC_FREE(ev->additional_data);
116
117         poll_ev = talloc_zero(ev, struct poll_event_context);
118         if (poll_ev == NULL) {
119                 return -1;
120         }
121         poll_ev->ev = ev;
122         poll_ev->signal_fd = -1;
123         ev->additional_data = poll_ev;
124         talloc_set_destructor(poll_ev, poll_event_context_destructor);
125         return 0;
126 }
127
128 static bool set_nonblock(int fd)
129 {
130         int val;
131
132         val = fcntl(fd, F_GETFL, 0);
133         if (val == -1) {
134                 return false;
135         }
136         val |= O_NONBLOCK;
137
138         return (fcntl(fd, F_SETFL, val) != -1);
139 }
140
141 static int poll_event_context_init_mt(struct tevent_context *ev)
142 {
143         struct poll_event_context *poll_ev;
144         struct pollfd *pfd;
145         int fds[2];
146         int ret;
147
148         ret = poll_event_context_init(ev);
149         if (ret == -1) {
150                 return ret;
151         }
152
153         poll_ev = talloc_get_type_abort(
154                 ev->additional_data, struct poll_event_context);
155
156         poll_ev->fds = talloc_zero(poll_ev, struct pollfd);
157         if (poll_ev->fds == NULL) {
158                 return -1;
159         }
160
161         ret = pipe(fds);
162         if (ret == -1) {
163                 return -1;
164         }
165
166         if (!set_nonblock(fds[0]) || !set_nonblock(fds[1])) {
167                 close(fds[0]);
168                 close(fds[1]);
169                 return -1;
170         }
171
172         poll_ev->signal_fd = fds[1];
173
174         pfd = &poll_ev->fds[0];
175         pfd->fd = fds[0];
176         pfd->events = (POLLIN|POLLHUP);
177
178         poll_ev->num_fds = 1;
179
180         talloc_set_destructor(poll_ev, poll_event_context_destructor);
181
182         return 0;
183 }
184
185 static void poll_event_wake_pollthread(struct poll_event_context *poll_ev)
186 {
187         char c;
188         ssize_t ret;
189
190         if (poll_ev->signal_fd == -1) {
191                 return;
192         }
193         c = 0;
194         do {
195                 ret = write(poll_ev->signal_fd, &c, sizeof(c));
196         } while ((ret == -1) && (errno == EINTR));
197 }
198
199 static void poll_event_drain_signal_fd(struct poll_event_context *poll_ev)
200 {
201         char buf[16];
202         ssize_t ret;
203         int fd;
204
205         if (poll_ev->signal_fd == -1) {
206                 return;
207         }
208
209         if (poll_ev->num_fds < 1) {
210                 return;
211         }
212         fd = poll_ev->fds[0].fd;
213
214         do {
215                 ret = read(fd, buf, sizeof(buf));
216         } while (ret == sizeof(buf));
217 }
218
219 /*
220   destroy an fd_event
221 */
222 static int poll_event_fd_destructor(struct tevent_fd *fde)
223 {
224         struct tevent_context *ev = fde->event_ctx;
225         struct poll_event_context *poll_ev;
226         uint64_t del_idx = fde->additional_flags;
227
228         if (ev == NULL) {
229                 goto done;
230         }
231
232         poll_ev = talloc_get_type_abort(
233                 ev->additional_data, struct poll_event_context);
234
235         if (del_idx == UINT64_MAX) {
236                 struct tevent_fd **listp =
237                         (struct tevent_fd **)fde->additional_data;
238
239                 DLIST_REMOVE((*listp), fde);
240                 goto done;
241         }
242
243         poll_ev->fdes[del_idx] = NULL;
244         poll_ev->deleted = true;
245         poll_event_wake_pollthread(poll_ev);
246 done:
247         return tevent_common_fd_destructor(fde);
248 }
249
250 static void poll_event_schedule_immediate(struct tevent_immediate *im,
251                                           struct tevent_context *ev,
252                                           tevent_immediate_handler_t handler,
253                                           void *private_data,
254                                           const char *handler_name,
255                                           const char *location)
256 {
257         struct poll_event_context *poll_ev = talloc_get_type_abort(
258                 ev->additional_data, struct poll_event_context);
259
260         tevent_common_schedule_immediate(im, ev, handler, private_data,
261                                          handler_name, location);
262         poll_event_wake_pollthread(poll_ev);
263 }
264
265 /*
266   Private function called by "standard" backend fallback.
267   Note this only allows fallback to "poll" backend, not "poll-mt".
268 */
269 _PRIVATE_ void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
270                                                  struct tevent_fd *fde)
271 {
272         struct poll_event_context *poll_ev = talloc_get_type_abort(
273                 ev->additional_data, struct poll_event_context);
274         struct tevent_fd **listp;
275
276         if (fde->flags != 0) {
277                 listp = &poll_ev->fresh;
278         } else {
279                 listp = &poll_ev->disabled;
280         }
281
282         fde->additional_flags   = UINT64_MAX;
283         fde->additional_data    = listp;
284
285         DLIST_ADD((*listp), fde);
286         talloc_set_destructor(fde, poll_event_fd_destructor);
287 }
288
289 /*
290   add a fd based event
291   return NULL on failure (memory allocation error)
292 */
293 static struct tevent_fd *poll_event_add_fd(struct tevent_context *ev,
294                                            TALLOC_CTX *mem_ctx,
295                                            int fd, uint16_t flags,
296                                            tevent_fd_handler_t handler,
297                                            void *private_data,
298                                            const char *handler_name,
299                                            const char *location)
300 {
301         struct poll_event_context *poll_ev = talloc_get_type_abort(
302                 ev->additional_data, struct poll_event_context);
303         struct tevent_fd *fde;
304
305         if (fd < 0) {
306                 return NULL;
307         }
308
309         fde = talloc(mem_ctx ? mem_ctx : ev, struct tevent_fd);
310         if (fde == NULL) {
311                 return NULL;
312         }
313         fde->event_ctx          = ev;
314         fde->fd                 = fd;
315         fde->flags              = flags;
316         fde->handler            = handler;
317         fde->close_fn           = NULL;
318         fde->private_data       = private_data;
319         fde->handler_name       = handler_name;
320         fde->location           = location;
321         fde->additional_flags   = UINT64_MAX;
322         fde->additional_data    = NULL;
323
324         tevent_poll_event_add_fd_internal(ev, fde);
325         poll_event_wake_pollthread(poll_ev);
326
327         /*
328          * poll_event_loop_poll will take care of the rest in
329          * poll_event_setup_fresh
330          */
331         return fde;
332 }
333
334 /*
335   set the fd event flags
336 */
337 static void poll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
338 {
339         struct tevent_context *ev = fde->event_ctx;
340         struct poll_event_context *poll_ev;
341         uint64_t idx = fde->additional_flags;
342         uint16_t pollflags;
343
344         if (ev == NULL) {
345                 return;
346         }
347         poll_ev = talloc_get_type_abort(
348                 ev->additional_data, struct poll_event_context);
349
350         fde->flags = flags;
351
352         if (idx == UINT64_MAX) {
353                 struct tevent_fd **listp =
354                         (struct tevent_fd **)fde->additional_data;
355
356                 /*
357                  * We move it between the fresh and disabled lists.
358                  */
359                 DLIST_REMOVE((*listp), fde);
360                 tevent_poll_event_add_fd_internal(ev, fde);
361                 poll_event_wake_pollthread(poll_ev);
362                 return;
363         }
364
365         if (fde->flags == 0) {
366                 /*
367                  * We need to remove it from the array
368                  * and move it to the disabled list.
369                  */
370                 poll_ev->fdes[idx] = NULL;
371                 poll_ev->deleted = true;
372                 DLIST_REMOVE(ev->fd_events, fde);
373                 tevent_poll_event_add_fd_internal(ev, fde);
374                 poll_event_wake_pollthread(poll_ev);
375                 return;
376         }
377
378         pollflags = 0;
379
380         if (flags & TEVENT_FD_READ) {
381                 pollflags |= (POLLIN|POLLHUP);
382         }
383         if (flags & TEVENT_FD_WRITE) {
384                 pollflags |= (POLLOUT);
385         }
386         poll_ev->fds[idx].events = pollflags;
387
388         poll_event_wake_pollthread(poll_ev);
389 }
390
391 static bool poll_event_setup_fresh(struct tevent_context *ev,
392                                    struct poll_event_context *poll_ev)
393 {
394         struct tevent_fd *fde, *next;
395         unsigned num_fresh, num_fds;
396
397         if (poll_ev->deleted) {
398                 unsigned first_fd = (poll_ev->signal_fd != -1) ? 1 : 0;
399                 unsigned i;
400
401                 for (i=first_fd; i < poll_ev->num_fds;) {
402                         fde = poll_ev->fdes[i];
403                         if (fde != NULL) {
404                                 i++;
405                                 continue;
406                         }
407
408                         /*
409                          * This fde was talloc_free()'ed. Delete it
410                          * from the arrays
411                          */
412                         poll_ev->num_fds -= 1;
413                         if (poll_ev->num_fds == i) {
414                                 break;
415                         }
416                         poll_ev->fds[i] = poll_ev->fds[poll_ev->num_fds];
417                         poll_ev->fdes[i] = poll_ev->fdes[poll_ev->num_fds];
418                         if (poll_ev->fdes[i] != NULL) {
419                                 poll_ev->fdes[i]->additional_flags = i;
420                         }
421                 }
422                 poll_ev->deleted = false;
423         }
424
425         if (poll_ev->fresh == NULL) {
426                 return true;
427         }
428
429         num_fresh = 0;
430         for (fde = poll_ev->fresh; fde; fde = fde->next) {
431                 num_fresh += 1;
432         }
433         num_fds = poll_ev->num_fds + num_fresh;
434
435         /*
436          * We check the length of fdes here. It is the last one
437          * enlarged, so if the realloc for poll_fd->fdes fails,
438          * poll_fd->fds will have at least the size of poll_fd->fdes
439          */
440
441         if (num_fds >= talloc_array_length(poll_ev->fdes)) {
442                 struct pollfd *tmp_fds;
443                 struct tevent_fd **tmp_fdes;
444                 unsigned array_length;
445
446                 array_length = (num_fds + 15) & ~15; /* round up to 16 */
447
448                 tmp_fds = talloc_realloc(
449                         poll_ev, poll_ev->fds, struct pollfd, array_length);
450                 if (tmp_fds == NULL) {
451                         return false;
452                 }
453                 poll_ev->fds = tmp_fds;
454
455                 tmp_fdes = talloc_realloc(
456                         poll_ev, poll_ev->fdes, struct tevent_fd *,
457                         array_length);
458                 if (tmp_fdes == NULL) {
459                         return false;
460                 }
461                 poll_ev->fdes = tmp_fdes;
462         }
463
464         for (fde = poll_ev->fresh; fde; fde = next) {
465                 struct pollfd *pfd;
466
467                 pfd = &poll_ev->fds[poll_ev->num_fds];
468
469                 pfd->fd = fde->fd;
470                 pfd->events = 0;
471                 pfd->revents = 0;
472
473                 if (fde->flags & TEVENT_FD_READ) {
474                         pfd->events |= (POLLIN|POLLHUP);
475                 }
476                 if (fde->flags & TEVENT_FD_WRITE) {
477                         pfd->events |= (POLLOUT);
478                 }
479
480                 fde->additional_flags = poll_ev->num_fds;
481                 poll_ev->fdes[poll_ev->num_fds] = fde;
482
483                 next = fde->next;
484                 DLIST_REMOVE(poll_ev->fresh, fde);
485                 DLIST_ADD(ev->fd_events, fde);
486
487                 poll_ev->num_fds += 1;
488         }
489         return true;
490 }
491
492 /*
493   event loop handling using poll()
494 */
495 static int poll_event_loop_poll(struct tevent_context *ev,
496                                 struct timeval *tvalp)
497 {
498         struct poll_event_context *poll_ev = talloc_get_type_abort(
499                 ev->additional_data, struct poll_event_context);
500         int pollrtn;
501         int timeout = -1;
502         int poll_errno;
503         struct tevent_fd *fde = NULL;
504         unsigned i;
505
506         if (ev->signal_events && tevent_common_check_signal(ev)) {
507                 return 0;
508         }
509
510         if (tvalp != NULL) {
511                 timeout = tvalp->tv_sec * 1000;
512                 timeout += (tvalp->tv_usec + 999) / 1000;
513         }
514
515         poll_event_drain_signal_fd(poll_ev);
516
517         if (!poll_event_setup_fresh(ev, poll_ev)) {
518                 return -1;
519         }
520
521         tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
522         pollrtn = poll(poll_ev->fds, poll_ev->num_fds, timeout);
523         poll_errno = errno;
524         tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
525
526         if (pollrtn == -1 && poll_errno == EINTR && ev->signal_events) {
527                 tevent_common_check_signal(ev);
528                 return 0;
529         }
530
531         if (pollrtn == 0 && tvalp) {
532                 /* we don't care about a possible delay here */
533                 tevent_common_loop_timer_delay(ev);
534                 return 0;
535         }
536
537         if (pollrtn <= 0) {
538                 /*
539                  * No fd's ready
540                  */
541                 return 0;
542         }
543
544         /* at least one file descriptor is ready - check
545            which ones and call the handler, being careful to allow
546            the handler to remove itself when called */
547
548         for (fde = ev->fd_events; fde; fde = fde->next) {
549                 unsigned idx = fde->additional_flags;
550                 struct pollfd *pfd;
551                 uint16_t flags = 0;
552
553                 if (idx == UINT64_MAX) {
554                         continue;
555                 }
556
557                 pfd = &poll_ev->fds[idx];
558
559                 if (pfd->revents & POLLNVAL) {
560                         /*
561                          * the socket is dead! this should never
562                          * happen as the socket should have first been
563                          * made readable and that should have removed
564                          * the event, so this must be a bug.
565                          *
566                          * We ignore it here to match the epoll
567                          * behavior.
568                          */
569                         tevent_debug(ev, TEVENT_DEBUG_ERROR,
570                                      "POLLNVAL on fde[%p] fd[%d] - disabling\n",
571                                      fde, pfd->fd);
572                         poll_ev->fdes[idx] = NULL;
573                         poll_ev->deleted = true;
574                         DLIST_REMOVE(ev->fd_events, fde);
575                         fde->event_ctx = NULL;
576                         continue;
577                 }
578
579                 if (pfd->revents & (POLLHUP|POLLERR)) {
580                         /* If we only wait for TEVENT_FD_WRITE, we
581                            should not tell the event handler about it,
582                            and remove the writable flag, as we only
583                            report errors when waiting for read events
584                            to match the select behavior. */
585                         if (!(fde->flags & TEVENT_FD_READ)) {
586                                 TEVENT_FD_NOT_WRITEABLE(fde);
587                                 continue;
588                         }
589                         flags |= TEVENT_FD_READ;
590                 }
591                 if (pfd->revents & POLLIN) {
592                         flags |= TEVENT_FD_READ;
593                 }
594                 if (pfd->revents & POLLOUT) {
595                         flags |= TEVENT_FD_WRITE;
596                 }
597                 /*
598                  * Note that fde->flags could be changed when using
599                  * the poll_mt backend together with threads,
600                  * that why we need to check pfd->revents and fde->flags
601                  */
602                 flags &= fde->flags;
603                 if (flags != 0) {
604                         DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd);
605                         fde->handler(ev, fde, flags, fde->private_data);
606                         return 0;
607                 }
608         }
609
610         for (i = 0; i < poll_ev->num_fds; i++) {
611                 if (poll_ev->fds[i].revents & POLLNVAL) {
612                         /*
613                          * the socket is dead! this should never
614                          * happen as the socket should have first been
615                          * made readable and that should have removed
616                          * the event, so this must be a bug or
617                          * a race in the poll_mt usage.
618                          */
619                         fde = poll_ev->fdes[i];
620                         tevent_debug(ev, TEVENT_DEBUG_WARNING,
621                                      "POLLNVAL on dangling fd[%d] fde[%p] - disabling\n",
622                                      poll_ev->fds[i].fd, fde);
623                         poll_ev->fdes[i] = NULL;
624                         poll_ev->deleted = true;
625                         if (fde != NULL) {
626                                 DLIST_REMOVE(ev->fd_events, fde);
627                                 fde->event_ctx = NULL;
628                         }
629                 }
630         }
631
632         return 0;
633 }
634
635 /*
636   do a single event loop using the events defined in ev
637 */
638 static int poll_event_loop_once(struct tevent_context *ev,
639                                 const char *location)
640 {
641         struct timeval tval;
642
643         if (ev->signal_events &&
644             tevent_common_check_signal(ev)) {
645                 return 0;
646         }
647
648         if (ev->immediate_events &&
649             tevent_common_loop_immediate(ev)) {
650                 return 0;
651         }
652
653         tval = tevent_common_loop_timer_delay(ev);
654         if (tevent_timeval_is_zero(&tval)) {
655                 return 0;
656         }
657
658         return poll_event_loop_poll(ev, &tval);
659 }
660
661 static int poll_event_loop_wait(struct tevent_context *ev,
662                                 const char *location)
663 {
664         struct poll_event_context *poll_ev = talloc_get_type_abort(
665                 ev->additional_data, struct poll_event_context);
666
667         /*
668          * loop as long as we have events pending
669          */
670         while (ev->fd_events ||
671                ev->timer_events ||
672                ev->immediate_events ||
673                ev->signal_events ||
674                poll_ev->fresh ||
675                poll_ev->disabled) {
676                 int ret;
677                 ret = _tevent_loop_once(ev, location);
678                 if (ret != 0) {
679                         tevent_debug(ev, TEVENT_DEBUG_FATAL,
680                                      "_tevent_loop_once() failed: %d - %s\n",
681                                      ret, strerror(errno));
682                         return ret;
683                 }
684         }
685
686         tevent_debug(ev, TEVENT_DEBUG_WARNING,
687                      "poll_event_loop_wait() out of events\n");
688         return 0;
689 }
690
691 static const struct tevent_ops poll_event_ops = {
692         .context_init           = poll_event_context_init,
693         .add_fd                 = poll_event_add_fd,
694         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
695         .get_fd_flags           = tevent_common_fd_get_flags,
696         .set_fd_flags           = poll_event_set_fd_flags,
697         .add_timer              = tevent_common_add_timer_v2,
698         .schedule_immediate     = tevent_common_schedule_immediate,
699         .add_signal             = tevent_common_add_signal,
700         .loop_once              = poll_event_loop_once,
701         .loop_wait              = poll_event_loop_wait,
702 };
703
704 _PRIVATE_ bool tevent_poll_init(void)
705 {
706         return tevent_register_backend("poll", &poll_event_ops);
707 }
708
709 static const struct tevent_ops poll_event_mt_ops = {
710         .context_init           = poll_event_context_init_mt,
711         .add_fd                 = poll_event_add_fd,
712         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
713         .get_fd_flags           = tevent_common_fd_get_flags,
714         .set_fd_flags           = poll_event_set_fd_flags,
715         .add_timer              = tevent_common_add_timer_v2,
716         .schedule_immediate     = poll_event_schedule_immediate,
717         .add_signal             = tevent_common_add_signal,
718         .loop_once              = poll_event_loop_once,
719         .loop_wait              = poll_event_loop_wait,
720 };
721
722 _PRIVATE_ bool tevent_poll_mt_init(void)
723 {
724         return tevent_register_backend("poll_mt", &poll_event_mt_ops);
725 }