talloc: use the system pytalloc-util for python3 as well
[sfrench/samba-autobuild/.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
63 static int poll_event_context_destructor(struct poll_event_context *poll_ev)
64 {
65         struct tevent_fd *fd, *fn;
66
67         for (fd = poll_ev->fresh; fd; fd = fn) {
68                 fn = fd->next;
69                 fd->event_ctx = NULL;
70                 DLIST_REMOVE(poll_ev->fresh, fd);
71         }
72
73         for (fd = poll_ev->disabled; fd; fd = fn) {
74                 fn = fd->next;
75                 fd->event_ctx = NULL;
76                 DLIST_REMOVE(poll_ev->disabled, fd);
77         }
78
79         if (poll_ev->signal_fd == -1) {
80                 /*
81                  * Non-threaded, no signal pipe
82                  */
83                 return 0;
84         }
85
86         close(poll_ev->signal_fd);
87         poll_ev->signal_fd = -1;
88
89         if (poll_ev->num_fds == 0) {
90                 return 0;
91         }
92         if (poll_ev->fds[0].fd != -1) {
93                 close(poll_ev->fds[0].fd);
94                 poll_ev->fds[0].fd = -1;
95         }
96         return 0;
97 }
98
99 /*
100   create a poll_event_context structure.
101 */
102 static int poll_event_context_init(struct tevent_context *ev)
103 {
104         struct poll_event_context *poll_ev;
105
106         /*
107          * we might be called during tevent_re_initialise()
108          * which means we need to free our old additional_data
109          * in order to detach old fd events from the
110          * poll_ev->fresh list
111          */
112         TALLOC_FREE(ev->additional_data);
113
114         poll_ev = talloc_zero(ev, struct poll_event_context);
115         if (poll_ev == NULL) {
116                 return -1;
117         }
118         poll_ev->ev = ev;
119         poll_ev->signal_fd = -1;
120         ev->additional_data = poll_ev;
121         talloc_set_destructor(poll_ev, poll_event_context_destructor);
122         return 0;
123 }
124
125 static bool set_nonblock(int fd)
126 {
127         int val;
128
129         val = fcntl(fd, F_GETFL, 0);
130         if (val == -1) {
131                 return false;
132         }
133         val |= O_NONBLOCK;
134
135         return (fcntl(fd, F_SETFL, val) != -1);
136 }
137
138 static int poll_event_context_init_mt(struct tevent_context *ev)
139 {
140         struct poll_event_context *poll_ev;
141         struct pollfd *pfd;
142         int fds[2];
143         int ret;
144
145         ret = poll_event_context_init(ev);
146         if (ret == -1) {
147                 return ret;
148         }
149
150         poll_ev = talloc_get_type_abort(
151                 ev->additional_data, struct poll_event_context);
152
153         poll_ev->fds = talloc_zero(poll_ev, struct pollfd);
154         if (poll_ev->fds == NULL) {
155                 return -1;
156         }
157
158         ret = pipe(fds);
159         if (ret == -1) {
160                 return -1;
161         }
162
163         if (!set_nonblock(fds[0]) || !set_nonblock(fds[1])) {
164                 close(fds[0]);
165                 close(fds[1]);
166                 return -1;
167         }
168
169         poll_ev->signal_fd = fds[1];
170
171         pfd = &poll_ev->fds[0];
172         pfd->fd = fds[0];
173         pfd->events = (POLLIN|POLLHUP);
174
175         poll_ev->num_fds = 1;
176
177         talloc_set_destructor(poll_ev, poll_event_context_destructor);
178
179         return 0;
180 }
181
182 static void poll_event_wake_pollthread(struct poll_event_context *poll_ev)
183 {
184         char c;
185         ssize_t ret;
186
187         if (poll_ev->signal_fd == -1) {
188                 return;
189         }
190         c = 0;
191         do {
192                 ret = write(poll_ev->signal_fd, &c, sizeof(c));
193         } while ((ret == -1) && (errno == EINTR));
194 }
195
196 static void poll_event_drain_signal_fd(struct poll_event_context *poll_ev)
197 {
198         char buf[16];
199         ssize_t ret;
200         int fd;
201
202         if (poll_ev->signal_fd == -1) {
203                 return;
204         }
205
206         if (poll_ev->num_fds < 1) {
207                 return;
208         }
209         fd = poll_ev->fds[0].fd;
210
211         do {
212                 ret = read(fd, buf, sizeof(buf));
213         } while (ret == sizeof(buf));
214 }
215
216 /*
217   destroy an fd_event
218 */
219 static int poll_event_fd_destructor(struct tevent_fd *fde)
220 {
221         struct tevent_context *ev = fde->event_ctx;
222         struct poll_event_context *poll_ev;
223         uint64_t del_idx = fde->additional_flags;
224
225         if (ev == NULL) {
226                 goto done;
227         }
228
229         poll_ev = talloc_get_type_abort(
230                 ev->additional_data, struct poll_event_context);
231
232         if (del_idx == UINT64_MAX) {
233                 struct tevent_fd **listp =
234                         (struct tevent_fd **)fde->additional_data;
235
236                 DLIST_REMOVE((*listp), fde);
237                 goto done;
238         }
239
240         poll_ev->fdes[del_idx] = NULL;
241         poll_ev->deleted = true;
242         poll_event_wake_pollthread(poll_ev);
243 done:
244         return tevent_common_fd_destructor(fde);
245 }
246
247 static void poll_event_schedule_immediate(struct tevent_immediate *im,
248                                           struct tevent_context *ev,
249                                           tevent_immediate_handler_t handler,
250                                           void *private_data,
251                                           const char *handler_name,
252                                           const char *location)
253 {
254         struct poll_event_context *poll_ev = talloc_get_type_abort(
255                 ev->additional_data, struct poll_event_context);
256
257         tevent_common_schedule_immediate(im, ev, handler, private_data,
258                                          handler_name, location);
259         poll_event_wake_pollthread(poll_ev);
260 }
261
262 /*
263   Private function called by "standard" backend fallback.
264   Note this only allows fallback to "poll" backend, not "poll-mt".
265 */
266 _PRIVATE_ void tevent_poll_event_add_fd_internal(struct tevent_context *ev,
267                                                  struct tevent_fd *fde)
268 {
269         struct poll_event_context *poll_ev = talloc_get_type_abort(
270                 ev->additional_data, struct poll_event_context);
271         struct tevent_fd **listp;
272
273         if (fde->flags != 0) {
274                 listp = &poll_ev->fresh;
275         } else {
276                 listp = &poll_ev->disabled;
277         }
278
279         fde->additional_flags   = UINT64_MAX;
280         fde->additional_data    = listp;
281
282         DLIST_ADD((*listp), fde);
283         talloc_set_destructor(fde, poll_event_fd_destructor);
284 }
285
286 /*
287   add a fd based event
288   return NULL on failure (memory allocation error)
289 */
290 static struct tevent_fd *poll_event_add_fd(struct tevent_context *ev,
291                                            TALLOC_CTX *mem_ctx,
292                                            int fd, uint16_t flags,
293                                            tevent_fd_handler_t handler,
294                                            void *private_data,
295                                            const char *handler_name,
296                                            const char *location)
297 {
298         struct poll_event_context *poll_ev = talloc_get_type_abort(
299                 ev->additional_data, struct poll_event_context);
300         struct tevent_fd *fde;
301
302         if (fd < 0) {
303                 return NULL;
304         }
305
306         fde = talloc(mem_ctx ? mem_ctx : ev, struct tevent_fd);
307         if (fde == NULL) {
308                 return NULL;
309         }
310         fde->event_ctx          = ev;
311         fde->fd                 = fd;
312         fde->flags              = flags;
313         fde->handler            = handler;
314         fde->close_fn           = NULL;
315         fde->private_data       = private_data;
316         fde->handler_name       = handler_name;
317         fde->location           = location;
318         fde->additional_flags   = UINT64_MAX;
319         fde->additional_data    = NULL;
320
321         tevent_poll_event_add_fd_internal(ev, fde);
322         poll_event_wake_pollthread(poll_ev);
323
324         /*
325          * poll_event_loop_poll will take care of the rest in
326          * poll_event_setup_fresh
327          */
328         return fde;
329 }
330
331 /*
332   set the fd event flags
333 */
334 static void poll_event_set_fd_flags(struct tevent_fd *fde, uint16_t flags)
335 {
336         struct tevent_context *ev = fde->event_ctx;
337         struct poll_event_context *poll_ev;
338         uint64_t idx = fde->additional_flags;
339         uint16_t pollflags;
340
341         if (ev == NULL) {
342                 return;
343         }
344         poll_ev = talloc_get_type_abort(
345                 ev->additional_data, struct poll_event_context);
346
347         fde->flags = flags;
348
349         if (idx == UINT64_MAX) {
350                 struct tevent_fd **listp =
351                         (struct tevent_fd **)fde->additional_data;
352
353                 /*
354                  * We move it between the fresh and disabled lists.
355                  */
356                 DLIST_REMOVE((*listp), fde);
357                 tevent_poll_event_add_fd_internal(ev, fde);
358                 poll_event_wake_pollthread(poll_ev);
359                 return;
360         }
361
362         if (fde->flags == 0) {
363                 /*
364                  * We need to remove it from the array
365                  * and move it to the disabled list.
366                  */
367                 poll_ev->fdes[idx] = NULL;
368                 poll_ev->deleted = true;
369                 DLIST_REMOVE(ev->fd_events, fde);
370                 tevent_poll_event_add_fd_internal(ev, fde);
371                 poll_event_wake_pollthread(poll_ev);
372                 return;
373         }
374
375         pollflags = 0;
376
377         if (flags & TEVENT_FD_READ) {
378                 pollflags |= (POLLIN|POLLHUP);
379         }
380         if (flags & TEVENT_FD_WRITE) {
381                 pollflags |= (POLLOUT);
382         }
383         poll_ev->fds[idx].events = pollflags;
384
385         poll_event_wake_pollthread(poll_ev);
386 }
387
388 static bool poll_event_setup_fresh(struct tevent_context *ev,
389                                    struct poll_event_context *poll_ev)
390 {
391         struct tevent_fd *fde, *next;
392         unsigned num_fresh, num_fds;
393
394         if (poll_ev->deleted) {
395                 unsigned first_fd = (poll_ev->signal_fd != -1) ? 1 : 0;
396                 unsigned i;
397
398                 for (i=first_fd; i < poll_ev->num_fds;) {
399                         fde = poll_ev->fdes[i];
400                         if (fde != NULL) {
401                                 i++;
402                                 continue;
403                         }
404
405                         /*
406                          * This fde was talloc_free()'ed. Delete it
407                          * from the arrays
408                          */
409                         poll_ev->num_fds -= 1;
410                         if (poll_ev->num_fds == i) {
411                                 break;
412                         }
413                         poll_ev->fds[i] = poll_ev->fds[poll_ev->num_fds];
414                         poll_ev->fdes[i] = poll_ev->fdes[poll_ev->num_fds];
415                         if (poll_ev->fdes[i] != NULL) {
416                                 poll_ev->fdes[i]->additional_flags = i;
417                         }
418                 }
419                 poll_ev->deleted = false;
420         }
421
422         if (poll_ev->fresh == NULL) {
423                 return true;
424         }
425
426         num_fresh = 0;
427         for (fde = poll_ev->fresh; fde; fde = fde->next) {
428                 num_fresh += 1;
429         }
430         num_fds = poll_ev->num_fds + num_fresh;
431
432         /*
433          * We check the length of fdes here. It is the last one
434          * enlarged, so if the realloc for poll_fd->fdes fails,
435          * poll_fd->fds will have at least the size of poll_fd->fdes
436          */
437
438         if (num_fds >= talloc_array_length(poll_ev->fdes)) {
439                 struct pollfd *tmp_fds;
440                 struct tevent_fd **tmp_fdes;
441                 unsigned array_length;
442
443                 array_length = (num_fds + 15) & ~15; /* round up to 16 */
444
445                 tmp_fds = talloc_realloc(
446                         poll_ev, poll_ev->fds, struct pollfd, array_length);
447                 if (tmp_fds == NULL) {
448                         return false;
449                 }
450                 poll_ev->fds = tmp_fds;
451
452                 tmp_fdes = talloc_realloc(
453                         poll_ev, poll_ev->fdes, struct tevent_fd *,
454                         array_length);
455                 if (tmp_fdes == NULL) {
456                         return false;
457                 }
458                 poll_ev->fdes = tmp_fdes;
459         }
460
461         for (fde = poll_ev->fresh; fde; fde = next) {
462                 struct pollfd *pfd;
463
464                 pfd = &poll_ev->fds[poll_ev->num_fds];
465
466                 pfd->fd = fde->fd;
467                 pfd->events = 0;
468                 pfd->revents = 0;
469
470                 if (fde->flags & TEVENT_FD_READ) {
471                         pfd->events |= (POLLIN|POLLHUP);
472                 }
473                 if (fde->flags & TEVENT_FD_WRITE) {
474                         pfd->events |= (POLLOUT);
475                 }
476
477                 fde->additional_flags = poll_ev->num_fds;
478                 poll_ev->fdes[poll_ev->num_fds] = fde;
479
480                 next = fde->next;
481                 DLIST_REMOVE(poll_ev->fresh, fde);
482                 DLIST_ADD(ev->fd_events, fde);
483
484                 poll_ev->num_fds += 1;
485         }
486         return true;
487 }
488
489 /*
490   event loop handling using poll()
491 */
492 static int poll_event_loop_poll(struct tevent_context *ev,
493                                 struct timeval *tvalp)
494 {
495         struct poll_event_context *poll_ev = talloc_get_type_abort(
496                 ev->additional_data, struct poll_event_context);
497         int pollrtn;
498         int timeout = -1;
499         int poll_errno;
500         struct tevent_fd *fde = NULL;
501         struct tevent_fd *next = NULL;
502         unsigned i;
503
504         if (ev->signal_events && tevent_common_check_signal(ev)) {
505                 return 0;
506         }
507
508         if (tvalp != NULL) {
509                 timeout = tvalp->tv_sec * 1000;
510                 timeout += (tvalp->tv_usec + 999) / 1000;
511         }
512
513         poll_event_drain_signal_fd(poll_ev);
514
515         if (!poll_event_setup_fresh(ev, poll_ev)) {
516                 return -1;
517         }
518
519         tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_BEFORE_WAIT);
520         pollrtn = poll(poll_ev->fds, poll_ev->num_fds, timeout);
521         poll_errno = errno;
522         tevent_trace_point_callback(poll_ev->ev, TEVENT_TRACE_AFTER_WAIT);
523
524         if (pollrtn == -1 && poll_errno == EINTR && ev->signal_events) {
525                 tevent_common_check_signal(ev);
526                 return 0;
527         }
528
529         if (pollrtn == 0 && tvalp) {
530                 /* we don't care about a possible delay here */
531                 tevent_common_loop_timer_delay(ev);
532                 return 0;
533         }
534
535         if (pollrtn <= 0) {
536                 /*
537                  * No fd's ready
538                  */
539                 return 0;
540         }
541
542         /* at least one file descriptor is ready - check
543            which ones and call the handler, being careful to allow
544            the handler to remove itself when called */
545
546         for (fde = ev->fd_events; fde; fde = next) {
547                 uint64_t idx = fde->additional_flags;
548                 struct pollfd *pfd;
549                 uint16_t flags = 0;
550
551                 next = fde->next;
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);
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->threaded_contexts != NULL) {
649                 tevent_common_threaded_activate_immediate(ev);
650         }
651
652         if (ev->immediate_events &&
653             tevent_common_loop_immediate(ev)) {
654                 return 0;
655         }
656
657         tval = tevent_common_loop_timer_delay(ev);
658         if (tevent_timeval_is_zero(&tval)) {
659                 return 0;
660         }
661
662         return poll_event_loop_poll(ev, &tval);
663 }
664
665 static int poll_event_loop_wait(struct tevent_context *ev,
666                                 const char *location)
667 {
668         struct poll_event_context *poll_ev = talloc_get_type_abort(
669                 ev->additional_data, struct poll_event_context);
670
671         /*
672          * loop as long as we have events pending
673          */
674         while (tevent_common_have_events(ev) ||
675                poll_ev->fresh ||
676                poll_ev->disabled) {
677                 int ret;
678                 ret = _tevent_loop_once(ev, location);
679                 if (ret != 0) {
680                         tevent_debug(ev, TEVENT_DEBUG_FATAL,
681                                      "_tevent_loop_once() failed: %d - %s\n",
682                                      ret, strerror(errno));
683                         return ret;
684                 }
685         }
686
687         tevent_debug(ev, TEVENT_DEBUG_WARNING,
688                      "poll_event_loop_wait() out of events\n");
689         return 0;
690 }
691
692 static const struct tevent_ops poll_event_ops = {
693         .context_init           = poll_event_context_init,
694         .add_fd                 = poll_event_add_fd,
695         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
696         .get_fd_flags           = tevent_common_fd_get_flags,
697         .set_fd_flags           = poll_event_set_fd_flags,
698         .add_timer              = tevent_common_add_timer_v2,
699         .schedule_immediate     = tevent_common_schedule_immediate,
700         .add_signal             = tevent_common_add_signal,
701         .loop_once              = poll_event_loop_once,
702         .loop_wait              = poll_event_loop_wait,
703 };
704
705 _PRIVATE_ bool tevent_poll_init(void)
706 {
707         return tevent_register_backend("poll", &poll_event_ops);
708 }
709
710 static const struct tevent_ops poll_event_mt_ops = {
711         .context_init           = poll_event_context_init_mt,
712         .add_fd                 = poll_event_add_fd,
713         .set_fd_close_fn        = tevent_common_fd_set_close_fn,
714         .get_fd_flags           = tevent_common_fd_get_flags,
715         .set_fd_flags           = poll_event_set_fd_flags,
716         .add_timer              = tevent_common_add_timer_v2,
717         .schedule_immediate     = poll_event_schedule_immediate,
718         .add_signal             = tevent_common_add_signal,
719         .loop_once              = poll_event_loop_once,
720         .loop_wait              = poll_event_loop_wait,
721 };
722
723 _PRIVATE_ bool tevent_poll_mt_init(void)
724 {
725         return tevent_register_backend("poll_mt", &poll_event_mt_ops);
726 }