]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/libsystemd-bus/sd-event.c
projects / thirdparty / systemd.git / blob
? search:


96ba2ad269cc10cc02f4d3ff20704ba619c15952
[thirdparty/systemd.git] / src / libsystemd-bus / sd-event.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2013 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <sys/epoll.h>
23 #include <sys/timerfd.h>
24 #include <sys/wait.h>
25
26 #include "macro.h"
27 #include "prioq.h"
28 #include "hashmap.h"
29 #include "util.h"
30 #include "time-util.h"
31 #include "sd-id128.h"
32
33 #include "sd-event.h"
34
35 #define EPOLL_QUEUE_MAX 64
36 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
37
38 typedef enum EventSourceType {
39 SOURCE_IO,
40 SOURCE_MONOTONIC,
41 SOURCE_REALTIME,
42 SOURCE_SIGNAL,
43 SOURCE_CHILD,
44 SOURCE_DEFER,
45 SOURCE_QUIT
46 } EventSourceType;
47
48 struct sd_event_source {
49 unsigned n_ref;
50
51 sd_event *event;
52 void *userdata;
53 sd_prepare_handler_t prepare;
54
55 EventSourceType type:4;
56 int enabled:3;
57 bool pending:1;
58
59 int priority;
60 unsigned pending_index;
61 unsigned prepare_index;
62 unsigned pending_iteration;
63 unsigned prepare_iteration;
64
65 union {
66 struct {
67 sd_io_handler_t callback;
68 int fd;
69 uint32_t events;
70 uint32_t revents;
71 bool registered:1;
72 } io;
73 struct {
74 sd_time_handler_t callback;
75 usec_t next, accuracy;
76 unsigned earliest_index;
77 unsigned latest_index;
78 } time;
79 struct {
80 sd_signal_handler_t callback;
81 struct signalfd_siginfo siginfo;
82 int sig;
83 } signal;
84 struct {
85 sd_child_handler_t callback;
86 siginfo_t siginfo;
87 pid_t pid;
88 int options;
89 } child;
90 struct {
91 sd_defer_handler_t callback;
92 } defer;
93 struct {
94 sd_quit_handler_t callback;
95 unsigned prioq_index;
96 } quit;
97 };
98 };
99
100 struct sd_event {
101 unsigned n_ref;
102
103 int epoll_fd;
104 int signal_fd;
105 int realtime_fd;
106 int monotonic_fd;
107
108 Prioq *pending;
109 Prioq *prepare;
110
111 /* For both clocks we maintain two priority queues each, one
112 * ordered for the earliest times the events may be
113 * dispatched, and one ordered by the latest times they must
114 * have been dispatched. The range between the top entries in
115 * the two prioqs is the time window we can freely schedule
116 * wakeups in */
117 Prioq *monotonic_earliest;
118 Prioq *monotonic_latest;
119 Prioq *realtime_earliest;
120 Prioq *realtime_latest;
121
122 usec_t realtime_next, monotonic_next;
123 usec_t perturb;
124
125 sigset_t sigset;
126 sd_event_source **signal_sources;
127
128 Hashmap *child_sources;
129 unsigned n_enabled_child_sources;
130
131 Prioq *quit;
132
133 pid_t original_pid;
134
135 unsigned iteration;
136 dual_timestamp timestamp;
137 int state;
138
139 bool quit_requested:1;
140 bool need_process_child:1;
141 };
142
143 static int pending_prioq_compare(const void *a, const void *b) {
144 const sd_event_source *x = a, *y = b;
145
146 assert(x->pending);
147 assert(y->pending);
148
149 /* Enabled ones first */
150 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
151 return -1;
152 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
153 return 1;
154
155 /* Lower priority values first */
156 if (x->priority < y->priority)
157 return -1;
158 if (x->priority > y->priority)
159 return 1;
160
161 /* Older entries first */
162 if (x->pending_iteration < y->pending_iteration)
163 return -1;
164 if (x->pending_iteration > y->pending_iteration)
165 return 1;
166
167 /* Stability for the rest */
168 if (x < y)
169 return -1;
170 if (x > y)
171 return 1;
172
173 return 0;
174 }
175
176 static int prepare_prioq_compare(const void *a, const void *b) {
177 const sd_event_source *x = a, *y = b;
178
179 assert(x->prepare);
180 assert(y->prepare);
181
182 /* Move most recently prepared ones last, so that we can stop
183 * preparing as soon as we hit one that has already been
184 * prepared in the current iteration */
185 if (x->prepare_iteration < y->prepare_iteration)
186 return -1;
187 if (x->prepare_iteration > y->prepare_iteration)
188 return 1;
189
190 /* Enabled ones first */
191 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
192 return -1;
193 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
194 return 1;
195
196 /* Lower priority values first */
197 if (x->priority < y->priority)
198 return -1;
199 if (x->priority > y->priority)
200 return 1;
201
202 /* Stability for the rest */
203 if (x < y)
204 return -1;
205 if (x > y)
206 return 1;
207
208 return 0;
209 }
210
211 static int earliest_time_prioq_compare(const void *a, const void *b) {
212 const sd_event_source *x = a, *y = b;
213
214 assert(x->type == SOURCE_MONOTONIC || x->type == SOURCE_REALTIME);
215 assert(y->type == SOURCE_MONOTONIC || y->type == SOURCE_REALTIME);
216
217 /* Enabled ones first */
218 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
219 return -1;
220 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
221 return 1;
222
223 /* Move the pending ones to the end */
224 if (!x->pending && y->pending)
225 return -1;
226 if (x->pending && !y->pending)
227 return 1;
228
229 /* Order by time */
230 if (x->time.next < y->time.next)
231 return -1;
232 if (x->time.next > y->time.next)
233 return -1;
234
235 /* Stability for the rest */
236 if (x < y)
237 return -1;
238 if (x > y)
239 return 1;
240
241 return 0;
242 }
243
244 static int latest_time_prioq_compare(const void *a, const void *b) {
245 const sd_event_source *x = a, *y = b;
246
247 assert((x->type == SOURCE_MONOTONIC && y->type == SOURCE_MONOTONIC) ||
248 (x->type == SOURCE_REALTIME && y->type == SOURCE_REALTIME));
249
250 /* Enabled ones first */
251 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
252 return -1;
253 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
254 return 1;
255
256 /* Move the pending ones to the end */
257 if (!x->pending && y->pending)
258 return -1;
259 if (x->pending && !y->pending)
260 return 1;
261
262 /* Order by time */
263 if (x->time.next + x->time.accuracy < y->time.next + y->time.accuracy)
264 return -1;
265 if (x->time.next + x->time.accuracy > y->time.next + y->time.accuracy)
266 return -1;
267
268 /* Stability for the rest */
269 if (x < y)
270 return -1;
271 if (x > y)
272 return 1;
273
274 return 0;
275 }
276
277 static int quit_prioq_compare(const void *a, const void *b) {
278 const sd_event_source *x = a, *y = b;
279
280 assert(x->type == SOURCE_QUIT);
281 assert(y->type == SOURCE_QUIT);
282
283 /* Enabled ones first */
284 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
285 return -1;
286 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
287 return 1;
288
289 /* Lower priority values first */
290 if (x->priority < y->priority)
291 return -1;
292 if (x->priority > y->priority)
293 return 1;
294
295 /* Stability for the rest */
296 if (x < y)
297 return -1;
298 if (x > y)
299 return 1;
300
301 return 0;
302 }
303
304 static void event_free(sd_event *e) {
305 assert(e);
306
307 if (e->epoll_fd >= 0)
308 close_nointr_nofail(e->epoll_fd);
309
310 if (e->signal_fd >= 0)
311 close_nointr_nofail(e->signal_fd);
312
313 if (e->realtime_fd >= 0)
314 close_nointr_nofail(e->realtime_fd);
315
316 if (e->monotonic_fd >= 0)
317 close_nointr_nofail(e->monotonic_fd);
318
319 prioq_free(e->pending);
320 prioq_free(e->prepare);
321 prioq_free(e->monotonic_earliest);
322 prioq_free(e->monotonic_latest);
323 prioq_free(e->realtime_earliest);
324 prioq_free(e->realtime_latest);
325 prioq_free(e->quit);
326
327 free(e->signal_sources);
328
329 hashmap_free(e->child_sources);
330 free(e);
331 }
332
333 int sd_event_new(sd_event** ret) {
334 sd_event *e;
335 int r;
336
337 assert_return(ret, -EINVAL);
338
339 e = new0(sd_event, 1);
340 if (!e)
341 return -ENOMEM;
342
343 e->n_ref = 1;
344 e->signal_fd = e->realtime_fd = e->monotonic_fd = e->epoll_fd = -1;
345 e->realtime_next = e->monotonic_next = (usec_t) -1;
346 e->original_pid = getpid();
347
348 assert_se(sigemptyset(&e->sigset) == 0);
349
350 e->pending = prioq_new(pending_prioq_compare);
351 if (!e->pending) {
352 r = -ENOMEM;
353 goto fail;
354 }
355
356 e->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
357 if (e->epoll_fd < 0) {
358 r = -errno;
359 goto fail;
360 }
361
362 *ret = e;
363 return 0;
364
365 fail:
366 event_free(e);
367 return r;
368 }
369
370 sd_event* sd_event_ref(sd_event *e) {
371 assert_return(e, NULL);
372
373 assert(e->n_ref >= 1);
374 e->n_ref++;
375
376 return e;
377 }
378
379 sd_event* sd_event_unref(sd_event *e) {
380 assert_return(e, NULL);
381
382 assert(e->n_ref >= 1);
383 e->n_ref--;
384
385 if (e->n_ref <= 0)
386 event_free(e);
387
388 return NULL;
389 }
390
391 static bool event_pid_changed(sd_event *e) {
392 assert(e);
393
394 /* We don't support people creating am event loop and keeping
395 * it around over a fork(). Let's complain. */
396
397 return e->original_pid != getpid();
398 }
399
400 static int source_io_unregister(sd_event_source *s) {
401 int r;
402
403 assert(s);
404 assert(s->type == SOURCE_IO);
405
406 if (!s->io.registered)
407 return 0;
408
409 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, s->io.fd, NULL);
410 if (r < 0)
411 return -errno;
412
413 s->io.registered = false;
414 return 0;
415 }
416
417 static int source_io_register(
418 sd_event_source *s,
419 int enabled,
420 uint32_t events) {
421
422 struct epoll_event ev = {};
423 int r;
424
425 assert(s);
426 assert(s->type == SOURCE_IO);
427 assert(enabled != SD_EVENT_OFF);
428
429 ev.events = events;
430 ev.data.ptr = s;
431
432 if (enabled == SD_EVENT_ONESHOT)
433 ev.events |= EPOLLONESHOT;
434
435 if (s->io.registered)
436 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_MOD, s->io.fd, &ev);
437 else
438 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_ADD, s->io.fd, &ev);
439
440 if (r < 0)
441 return -errno;
442
443 s->io.registered = true;
444
445 return 0;
446 }
447
448 static void source_free(sd_event_source *s) {
449 assert(s);
450
451 if (s->event) {
452 switch (s->type) {
453
454 case SOURCE_IO:
455 if (s->io.fd >= 0)
456 source_io_unregister(s);
457
458 break;
459
460 case SOURCE_MONOTONIC:
461 prioq_remove(s->event->monotonic_earliest, s, &s->time.earliest_index);
462 prioq_remove(s->event->monotonic_latest, s, &s->time.latest_index);
463 break;
464
465 case SOURCE_REALTIME:
466 prioq_remove(s->event->realtime_earliest, s, &s->time.earliest_index);
467 prioq_remove(s->event->realtime_latest, s, &s->time.latest_index);
468 break;
469
470 case SOURCE_SIGNAL:
471 if (s->signal.sig > 0) {
472 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0)
473 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
474
475 if (s->event->signal_sources)
476 s->event->signal_sources[s->signal.sig] = NULL;
477 }
478
479 break;
480
481 case SOURCE_CHILD:
482 if (s->child.pid > 0) {
483 if (s->enabled != SD_EVENT_OFF) {
484 assert(s->event->n_enabled_child_sources > 0);
485 s->event->n_enabled_child_sources--;
486 }
487
488 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD])
489 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
490
491 hashmap_remove(s->event->child_sources, INT_TO_PTR(s->child.pid));
492 }
493
494 break;
495
496 case SOURCE_QUIT:
497 prioq_remove(s->event->quit, s, &s->quit.prioq_index);
498 break;
499 }
500
501 if (s->pending)
502 prioq_remove(s->event->pending, s, &s->pending_index);
503
504 if (s->prepare)
505 prioq_remove(s->event->prepare, s, &s->prepare_index);
506
507 sd_event_unref(s->event);
508 }
509
510 free(s);
511 }
512
513 static int source_set_pending(sd_event_source *s, bool b) {
514 int r;
515
516 assert(s);
517 assert(s->type != SOURCE_QUIT);
518
519 if (s->pending == b)
520 return 0;
521
522 s->pending = b;
523
524 if (b) {
525 s->pending_iteration = s->event->iteration;
526
527 r = prioq_put(s->event->pending, s, &s->pending_index);
528 if (r < 0) {
529 s->pending = false;
530 return r;
531 }
532 } else
533 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
534
535 return 0;
536 }
537
538 static sd_event_source *source_new(sd_event *e, EventSourceType type) {
539 sd_event_source *s;
540
541 assert(e);
542
543 s = new0(sd_event_source, 1);
544 if (!s)
545 return NULL;
546
547 s->n_ref = 1;
548 s->event = sd_event_ref(e);
549 s->type = type;
550 s->pending_index = s->prepare_index = PRIOQ_IDX_NULL;
551
552 return s;
553 }
554
555 int sd_event_add_io(
556 sd_event *e,
557 int fd,
558 uint32_t events,
559 sd_io_handler_t callback,
560 void *userdata,
561 sd_event_source **ret) {
562
563 sd_event_source *s;
564 int r;
565
566 assert_return(e, -EINVAL);
567 assert_return(fd >= 0, -EINVAL);
568 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP)), -EINVAL);
569 assert_return(callback, -EINVAL);
570 assert_return(ret, -EINVAL);
571 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
572 assert_return(!event_pid_changed(e), -ECHILD);
573
574 s = source_new(e, SOURCE_IO);
575 if (!s)
576 return -ENOMEM;
577
578 s->io.fd = fd;
579 s->io.events = events;
580 s->io.callback = callback;
581 s->userdata = userdata;
582 s->enabled = SD_EVENT_ON;
583
584 r = source_io_register(s, s->enabled, events);
585 if (r < 0) {
586 source_free(s);
587 return -errno;
588 }
589
590 *ret = s;
591 return 0;
592 }
593
594 static int event_setup_timer_fd(
595 sd_event *e,
596 EventSourceType type,
597 int *timer_fd,
598 clockid_t id) {
599
600 struct epoll_event ev = {};
601 int r, fd;
602 sd_id128_t bootid;
603
604 assert(e);
605 assert(timer_fd);
606
607 if (_likely_(*timer_fd >= 0))
608 return 0;
609
610 fd = timerfd_create(id, TFD_NONBLOCK|TFD_CLOEXEC);
611 if (fd < 0)
612 return -errno;
613
614 ev.events = EPOLLIN;
615 ev.data.ptr = INT_TO_PTR(type);
616
617 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
618 if (r < 0) {
619 close_nointr_nofail(fd);
620 return -errno;
621 }
622
623 /* When we sleep for longer, we try to realign the wakeup to
624 the same time wihtin each second, so that events all across
625 the system can be coalesced into a single CPU
626 wakeup. However, let's take some system-specific randomness
627 for this value, so that in a network of systems with synced
628 clocks timer events are distributed a bit. Here, we
629 calculate a perturbation usec offset from the boot ID. */
630
631 if (sd_id128_get_boot(&bootid) >= 0)
632 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_SEC;
633
634 *timer_fd = fd;
635 return 0;
636 }
637
638 static int event_add_time_internal(
639 sd_event *e,
640 EventSourceType type,
641 int *timer_fd,
642 clockid_t id,
643 Prioq **earliest,
644 Prioq **latest,
645 uint64_t usec,
646 uint64_t accuracy,
647 sd_time_handler_t callback,
648 void *userdata,
649 sd_event_source **ret) {
650
651 sd_event_source *s;
652 int r;
653
654 assert_return(e, -EINVAL);
655 assert_return(callback, -EINVAL);
656 assert_return(ret, -EINVAL);
657 assert_return(usec != (uint64_t) -1, -EINVAL);
658 assert_return(accuracy != (uint64_t) -1, -EINVAL);
659 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
660 assert_return(!event_pid_changed(e), -ECHILD);
661
662 assert(timer_fd);
663 assert(earliest);
664 assert(latest);
665
666 if (!*earliest) {
667 *earliest = prioq_new(earliest_time_prioq_compare);
668 if (!*earliest)
669 return -ENOMEM;
670 }
671
672 if (!*latest) {
673 *latest = prioq_new(latest_time_prioq_compare);
674 if (!*latest)
675 return -ENOMEM;
676 }
677
678 if (*timer_fd < 0) {
679 r = event_setup_timer_fd(e, type, timer_fd, id);
680 if (r < 0)
681 return r;
682 }
683
684 s = source_new(e, type);
685 if (!s)
686 return -ENOMEM;
687
688 s->time.next = usec;
689 s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
690 s->time.callback = callback;
691 s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
692 s->userdata = userdata;
693 s->enabled = SD_EVENT_ONESHOT;
694
695 r = prioq_put(*earliest, s, &s->time.earliest_index);
696 if (r < 0)
697 goto fail;
698
699 r = prioq_put(*latest, s, &s->time.latest_index);
700 if (r < 0)
701 goto fail;
702
703 *ret = s;
704 return 0;
705
706 fail:
707 source_free(s);
708 return r;
709 }
710
711 int sd_event_add_monotonic(sd_event *e, uint64_t usec, uint64_t accuracy, sd_time_handler_t callback, void *userdata, sd_event_source **ret) {
712 return event_add_time_internal(e, SOURCE_MONOTONIC, &e->monotonic_fd, CLOCK_MONOTONIC, &e->monotonic_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata, ret);
713 }
714
715 int sd_event_add_realtime(sd_event *e, uint64_t usec, uint64_t accuracy, sd_time_handler_t callback, void *userdata, sd_event_source **ret) {
716 return event_add_time_internal(e, SOURCE_REALTIME, &e->realtime_fd, CLOCK_REALTIME, &e->realtime_earliest, &e->monotonic_latest, usec, accuracy, callback, userdata, ret);
717 }
718
719 static int event_update_signal_fd(sd_event *e) {
720 struct epoll_event ev = {};
721 bool add_to_epoll;
722 int r;
723
724 assert(e);
725
726 add_to_epoll = e->signal_fd < 0;
727
728 r = signalfd(e->signal_fd, &e->sigset, SFD_NONBLOCK|SFD_CLOEXEC);
729 if (r < 0)
730 return -errno;
731
732 e->signal_fd = r;
733
734 if (!add_to_epoll)
735 return 0;
736
737 ev.events = EPOLLIN;
738 ev.data.ptr = INT_TO_PTR(SOURCE_SIGNAL);
739
740 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->signal_fd, &ev);
741 if (r < 0) {
742 close_nointr_nofail(e->signal_fd);
743 e->signal_fd = -1;
744
745 return -errno;
746 }
747
748 return 0;
749 }
750
751 int sd_event_add_signal(
752 sd_event *e,
753 int sig,
754 sd_signal_handler_t callback,
755 void *userdata,
756 sd_event_source **ret) {
757
758 sd_event_source *s;
759 int r;
760
761 assert_return(e, -EINVAL);
762 assert_return(sig > 0, -EINVAL);
763 assert_return(sig < _NSIG, -EINVAL);
764 assert_return(callback, -EINVAL);
765 assert_return(ret, -EINVAL);
766 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
767 assert_return(!event_pid_changed(e), -ECHILD);
768
769 if (!e->signal_sources) {
770 e->signal_sources = new0(sd_event_source*, _NSIG);
771 if (!e->signal_sources)
772 return -ENOMEM;
773 } else if (e->signal_sources[sig])
774 return -EBUSY;
775
776 s = source_new(e, SOURCE_SIGNAL);
777 if (!s)
778 return -ENOMEM;
779
780 s->signal.sig = sig;
781 s->signal.callback = callback;
782 s->userdata = userdata;
783 s->enabled = SD_EVENT_ON;
784
785 e->signal_sources[sig] = s;
786 assert_se(sigaddset(&e->sigset, sig) == 0);
787
788 if (sig != SIGCHLD || e->n_enabled_child_sources == 0) {
789 r = event_update_signal_fd(e);
790 if (r < 0) {
791 source_free(s);
792 return r;
793 }
794 }
795
796 *ret = s;
797 return 0;
798 }
799
800 int sd_event_add_child(
801 sd_event *e,
802 pid_t pid,
803 int options,
804 sd_child_handler_t callback,
805 void *userdata,
806 sd_event_source **ret) {
807
808 sd_event_source *s;
809 int r;
810
811 assert_return(e, -EINVAL);
812 assert_return(pid > 1, -EINVAL);
813 assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
814 assert_return(options != 0, -EINVAL);
815 assert_return(callback, -EINVAL);
816 assert_return(ret, -EINVAL);
817 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
818 assert_return(!event_pid_changed(e), -ECHILD);
819
820 r = hashmap_ensure_allocated(&e->child_sources, trivial_hash_func, trivial_compare_func);
821 if (r < 0)
822 return r;
823
824 if (hashmap_contains(e->child_sources, INT_TO_PTR(pid)))
825 return -EBUSY;
826
827 s = source_new(e, SOURCE_CHILD);
828 if (!s)
829 return -ENOMEM;
830
831 s->child.pid = pid;
832 s->child.options = options;
833 s->child.callback = callback;
834 s->userdata = userdata;
835 s->enabled = SD_EVENT_ONESHOT;
836
837 r = hashmap_put(e->child_sources, INT_TO_PTR(pid), s);
838 if (r < 0) {
839 source_free(s);
840 return r;
841 }
842
843 e->n_enabled_child_sources ++;
844
845 assert_se(sigaddset(&e->sigset, SIGCHLD) == 0);
846
847 if (!e->signal_sources || !e->signal_sources[SIGCHLD]) {
848 r = event_update_signal_fd(e);
849 if (r < 0) {
850 source_free(s);
851 return -errno;
852 }
853 }
854
855 e->need_process_child = true;
856
857 *ret = s;
858 return 0;
859 }
860
861 int sd_event_add_defer(
862 sd_event *e,
863 sd_defer_handler_t callback,
864 void *userdata,
865 sd_event_source **ret) {
866
867 sd_event_source *s;
868 int r;
869
870 assert_return(e, -EINVAL);
871 assert_return(callback, -EINVAL);
872 assert_return(ret, -EINVAL);
873 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
874 assert_return(!event_pid_changed(e), -ECHILD);
875
876 s = source_new(e, SOURCE_DEFER);
877 if (!s)
878 return -ENOMEM;
879
880 s->defer.callback = callback;
881 s->userdata = userdata;
882 s->enabled = SD_EVENT_ONESHOT;
883
884 r = source_set_pending(s, true);
885 if (r < 0) {
886 source_free(s);
887 return r;
888 }
889
890 *ret = s;
891 return 0;
892 }
893
894 int sd_event_add_quit(
895 sd_event *e,
896 sd_quit_handler_t callback,
897 void *userdata,
898 sd_event_source **ret) {
899
900 sd_event_source *s;
901 int r;
902
903 assert_return(e, -EINVAL);
904 assert_return(callback, -EINVAL);
905 assert_return(ret, -EINVAL);
906 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
907 assert_return(!event_pid_changed(e), -ECHILD);
908
909 if (!e->quit) {
910 e->quit = prioq_new(quit_prioq_compare);
911 if (!e->quit)
912 return -ENOMEM;
913 }
914
915 s = source_new(e, SOURCE_QUIT);
916 if (!s)
917 return -ENOMEM;
918
919 s->quit.callback = callback;
920 s->userdata = userdata;
921 s->quit.prioq_index = PRIOQ_IDX_NULL;
922 s->enabled = SD_EVENT_ONESHOT;
923
924 r = prioq_put(s->event->quit, s, &s->quit.prioq_index);
925 if (r < 0) {
926 source_free(s);
927 return r;
928 }
929
930 *ret = s;
931 return 0;
932 }
933
934 sd_event_source* sd_event_source_ref(sd_event_source *s) {
935 assert_return(s, NULL);
936
937 assert(s->n_ref >= 1);
938 s->n_ref++;
939
940 return s;
941 }
942
943 sd_event_source* sd_event_source_unref(sd_event_source *s) {
944 assert_return(s, NULL);
945
946 assert(s->n_ref >= 1);
947 s->n_ref--;
948
949 if (s->n_ref <= 0)
950 source_free(s);
951
952 return NULL;
953 }
954
955 sd_event *sd_event_get(sd_event_source *s) {
956 assert_return(s, NULL);
957
958 return s->event;
959 }
960
961 int sd_event_source_get_pending(sd_event_source *s) {
962 assert_return(s, -EINVAL);
963 assert_return(s->type != SOURCE_QUIT, -EDOM);
964 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
965 assert_return(!event_pid_changed(s->event), -ECHILD);
966
967 return s->pending;
968 }
969
970 int sd_event_source_get_io_fd(sd_event_source *s) {
971 assert_return(s, -EINVAL);
972 assert_return(s->type == SOURCE_IO, -EDOM);
973 assert_return(!event_pid_changed(s->event), -ECHILD);
974
975 return s->io.fd;
976 }
977
978 int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
979 assert_return(s, -EINVAL);
980 assert_return(events, -EINVAL);
981 assert_return(s->type == SOURCE_IO, -EDOM);
982 assert_return(!event_pid_changed(s->event), -ECHILD);
983
984 *events = s->io.events;
985 return 0;
986 }
987
988 int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
989 int r;
990
991 assert_return(s, -EINVAL);
992 assert_return(s->type == SOURCE_IO, -EDOM);
993 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP)), -EINVAL);
994 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
995 assert_return(!event_pid_changed(s->event), -ECHILD);
996
997 if (s->io.events == events)
998 return 0;
999
1000 if (s->enabled != SD_EVENT_OFF) {
1001 r = source_io_register(s, s->io.events, events);
1002 if (r < 0)
1003 return r;
1004 }
1005
1006 s->io.events = events;
1007
1008 return 0;
1009 }
1010
1011 int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
1012 assert_return(s, -EINVAL);
1013 assert_return(revents, -EINVAL);
1014 assert_return(s->type == SOURCE_IO, -EDOM);
1015 assert_return(s->pending, -ENODATA);
1016 assert_return(!event_pid_changed(s->event), -ECHILD);
1017
1018 *revents = s->io.revents;
1019 return 0;
1020 }
1021
1022 int sd_event_source_get_signal(sd_event_source *s) {
1023 assert_return(s, -EINVAL);
1024 assert_return(s->type == SOURCE_SIGNAL, -EDOM);
1025 assert_return(!event_pid_changed(s->event), -ECHILD);
1026
1027 return s->signal.sig;
1028 }
1029
1030 int sd_event_source_get_priority(sd_event_source *s, int *priority) {
1031 assert_return(s, -EINVAL);
1032 assert_return(!event_pid_changed(s->event), -ECHILD);
1033
1034 return s->priority;
1035 }
1036
1037 int sd_event_source_set_priority(sd_event_source *s, int priority) {
1038 assert_return(s, -EINVAL);
1039 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1040 assert_return(!event_pid_changed(s->event), -ECHILD);
1041
1042 if (s->priority == priority)
1043 return 0;
1044
1045 s->priority = priority;
1046
1047 if (s->pending)
1048 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1049
1050 if (s->prepare)
1051 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1052
1053 if (s->type == SOURCE_QUIT)
1054 prioq_reshuffle(s->event->quit, s, &s->quit.prioq_index);
1055
1056 return 0;
1057 }
1058
1059 int sd_event_source_get_enabled(sd_event_source *s, int *m) {
1060 assert_return(s, -EINVAL);
1061 assert_return(m, -EINVAL);
1062 assert_return(!event_pid_changed(s->event), -ECHILD);
1063
1064 *m = s->enabled;
1065 return 0;
1066 }
1067
1068 int sd_event_source_set_enabled(sd_event_source *s, int m) {
1069 int r;
1070
1071 assert_return(s, -EINVAL);
1072 assert_return(m == SD_EVENT_OFF || m == SD_EVENT_ON || m == SD_EVENT_ONESHOT, -EINVAL);
1073 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1074 assert_return(!event_pid_changed(s->event), -ECHILD);
1075
1076 if (s->enabled == m)
1077 return 0;
1078
1079 if (m == SD_EVENT_OFF) {
1080
1081 switch (s->type) {
1082
1083 case SOURCE_IO:
1084 r = source_io_unregister(s);
1085 if (r < 0)
1086 return r;
1087
1088 s->enabled = m;
1089 break;
1090
1091 case SOURCE_MONOTONIC:
1092 s->enabled = m;
1093 prioq_reshuffle(s->event->monotonic_earliest, s, &s->time.earliest_index);
1094 prioq_reshuffle(s->event->monotonic_latest, s, &s->time.latest_index);
1095 break;
1096
1097 case SOURCE_REALTIME:
1098 s->enabled = m;
1099 prioq_reshuffle(s->event->realtime_earliest, s, &s->time.earliest_index);
1100 prioq_reshuffle(s->event->realtime_latest, s, &s->time.latest_index);
1101 break;
1102
1103 case SOURCE_SIGNAL:
1104 s->enabled = m;
1105 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0) {
1106 assert_se(sigdelset(&s->event->sigset, s->signal.sig) == 0);
1107 event_update_signal_fd(s->event);
1108 }
1109
1110 break;
1111
1112 case SOURCE_CHILD:
1113 s->enabled = m;
1114
1115 assert(s->event->n_enabled_child_sources > 0);
1116 s->event->n_enabled_child_sources--;
1117
1118 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD]) {
1119 assert_se(sigdelset(&s->event->sigset, SIGCHLD) == 0);
1120 event_update_signal_fd(s->event);
1121 }
1122
1123 break;
1124
1125 case SOURCE_QUIT:
1126 s->enabled = m;
1127 prioq_reshuffle(s->event->quit, s, &s->quit.prioq_index);
1128 break;
1129
1130 case SOURCE_DEFER:
1131 s->enabled = m;
1132 break;
1133 }
1134
1135 } else {
1136 switch (s->type) {
1137
1138 case SOURCE_IO:
1139 r = source_io_register(s, m, s->io.events);
1140 if (r < 0)
1141 return r;
1142
1143 s->enabled = m;
1144 break;
1145
1146 case SOURCE_MONOTONIC:
1147 s->enabled = m;
1148 prioq_reshuffle(s->event->monotonic_earliest, s, &s->time.earliest_index);
1149 prioq_reshuffle(s->event->monotonic_latest, s, &s->time.latest_index);
1150 break;
1151
1152 case SOURCE_REALTIME:
1153 s->enabled = m;
1154 prioq_reshuffle(s->event->realtime_earliest, s, &s->time.earliest_index);
1155 prioq_reshuffle(s->event->realtime_latest, s, &s->time.latest_index);
1156 break;
1157
1158 case SOURCE_SIGNAL:
1159 s->enabled = m;
1160
1161 if (s->signal.sig != SIGCHLD || s->event->n_enabled_child_sources == 0) {
1162 assert_se(sigaddset(&s->event->sigset, s->signal.sig) == 0);
1163 event_update_signal_fd(s->event);
1164 }
1165 break;
1166
1167 case SOURCE_CHILD:
1168 s->enabled = m;
1169
1170 if (s->enabled == SD_EVENT_OFF) {
1171 s->event->n_enabled_child_sources++;
1172
1173 if (!s->event->signal_sources || !s->event->signal_sources[SIGCHLD]) {
1174 assert_se(sigaddset(&s->event->sigset, SIGCHLD) == 0);
1175 event_update_signal_fd(s->event);
1176 }
1177 }
1178 break;
1179
1180 case SOURCE_QUIT:
1181 s->enabled = m;
1182 prioq_reshuffle(s->event->quit, s, &s->quit.prioq_index);
1183 break;
1184
1185 case SOURCE_DEFER:
1186 s->enabled = m;
1187 break;
1188 }
1189 }
1190
1191 if (s->pending)
1192 prioq_reshuffle(s->event->pending, s, &s->pending_index);
1193
1194 if (s->prepare)
1195 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
1196
1197 return 0;
1198 }
1199
1200 int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
1201 assert_return(s, -EINVAL);
1202 assert_return(usec, -EINVAL);
1203 assert_return(s->type == SOURCE_REALTIME || s->type == SOURCE_MONOTONIC, -EDOM);
1204 assert_return(!event_pid_changed(s->event), -ECHILD);
1205
1206 *usec = s->time.next;
1207 return 0;
1208 }
1209
1210 int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
1211 assert_return(s, -EINVAL);
1212 assert_return(usec != (uint64_t) -1, -EINVAL);
1213 assert_return(s->type == SOURCE_REALTIME || s->type == SOURCE_MONOTONIC, -EDOM);
1214 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1215 assert_return(!event_pid_changed(s->event), -ECHILD);
1216
1217 if (s->time.next == usec)
1218 return 0;
1219
1220 s->time.next = usec;
1221
1222 if (s->type == SOURCE_REALTIME) {
1223 prioq_reshuffle(s->event->realtime_earliest, s, &s->time.earliest_index);
1224 prioq_reshuffle(s->event->realtime_latest, s, &s->time.latest_index);
1225 } else {
1226 prioq_reshuffle(s->event->monotonic_earliest, s, &s->time.earliest_index);
1227 prioq_reshuffle(s->event->monotonic_latest, s, &s->time.latest_index);
1228 }
1229
1230 return 0;
1231 }
1232
1233 int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
1234 assert_return(s, -EINVAL);
1235 assert_return(usec, -EINVAL);
1236 assert_return(s->type == SOURCE_REALTIME || s->type == SOURCE_MONOTONIC, -EDOM);
1237 assert_return(!event_pid_changed(s->event), -ECHILD);
1238
1239 *usec = s->time.accuracy;
1240 return 0;
1241 }
1242
1243 int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
1244 assert_return(s, -EINVAL);
1245 assert_return(usec != (uint64_t) -1, -EINVAL);
1246 assert_return(s->type == SOURCE_REALTIME || s->type == SOURCE_MONOTONIC, -EDOM);
1247 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1248 assert_return(!event_pid_changed(s->event), -ECHILD);
1249
1250 if (usec == 0)
1251 usec = DEFAULT_ACCURACY_USEC;
1252
1253 if (s->time.accuracy == usec)
1254 return 0;
1255
1256 s->time.accuracy = usec;
1257
1258 if (s->type == SOURCE_REALTIME)
1259 prioq_reshuffle(s->event->realtime_latest, s, &s->time.latest_index);
1260 else
1261 prioq_reshuffle(s->event->monotonic_latest, s, &s->time.latest_index);
1262
1263 return 0;
1264 }
1265
1266 int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
1267 assert_return(s, -EINVAL);
1268 assert_return(pid, -EINVAL);
1269 assert_return(s->type == SOURCE_CHILD, -EDOM);
1270 assert_return(!event_pid_changed(s->event), -ECHILD);
1271
1272 *pid = s->child.pid;
1273 return 0;
1274 }
1275
1276 int sd_event_source_set_prepare(sd_event_source *s, sd_prepare_handler_t callback) {
1277 int r;
1278
1279 assert_return(s, -EINVAL);
1280 assert_return(s->type != SOURCE_QUIT, -EDOM);
1281 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1282 assert_return(!event_pid_changed(s->event), -ECHILD);
1283
1284 if (s->prepare == callback)
1285 return 0;
1286
1287 if (callback && s->prepare) {
1288 s->prepare = callback;
1289 return 0;
1290 }
1291
1292 r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
1293 if (r < 0)
1294 return r;
1295
1296 s->prepare = callback;
1297
1298 if (callback) {
1299 r = prioq_put(s->event->prepare, s, &s->prepare_index);
1300 if (r < 0)
1301 return r;
1302 } else
1303 prioq_remove(s->event->prepare, s, &s->prepare_index);
1304
1305 return 0;
1306 }
1307
1308 void* sd_event_source_get_userdata(sd_event_source *s) {
1309 assert_return(s, NULL);
1310
1311 return s->userdata;
1312 }
1313
1314 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
1315 usec_t c;
1316 assert(e);
1317 assert(a <= b);
1318
1319 if (a <= 0)
1320 return 0;
1321
1322 if (b <= a + 1)
1323 return a;
1324
1325 /*
1326 Find a good time to wake up again between times a and b. We
1327 have two goals here:
1328
1329 a) We want to wake up as seldom as possible, hence prefer
1330 later times over earlier times.
1331
1332 b) But if we have to wake up, then let's make sure to
1333 dispatch as much as possible on the entire system.
1334
1335 We implement this by waking up everywhere at the same time
1336 within any given second if we can, synchronised via the
1337 perturbation value determined from the boot ID. If we can't,
1338 then we try to find the same spot in every a 250ms
1339 step. Otherwise, we pick the last possible time to wake up.
1340 */
1341
1342 c = (b / USEC_PER_SEC) * USEC_PER_SEC + e->perturb;
1343 if (c >= b) {
1344 if (_unlikely_(c < USEC_PER_SEC))
1345 return b;
1346
1347 c -= USEC_PER_SEC;
1348 }
1349
1350 if (c >= a)
1351 return c;
1352
1353 c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
1354 if (c >= b) {
1355 if (_unlikely_(c < USEC_PER_MSEC*250))
1356 return b;
1357
1358 c -= USEC_PER_MSEC*250;
1359 }
1360
1361 if (c >= a)
1362 return c;
1363
1364 return b;
1365 }
1366
1367 static int event_arm_timer(
1368 sd_event *e,
1369 int timer_fd,
1370 Prioq *earliest,
1371 Prioq *latest,
1372 usec_t *next) {
1373
1374 struct itimerspec its = {};
1375 sd_event_source *a, *b;
1376 usec_t t;
1377 int r;
1378
1379 assert_se(e);
1380 assert_se(next);
1381
1382 a = prioq_peek(earliest);
1383 if (!a || a->enabled == SD_EVENT_OFF)
1384 return 0;
1385
1386 b = prioq_peek(latest);
1387 assert_se(b && b->enabled != SD_EVENT_OFF);
1388
1389 t = sleep_between(e, a->time.next, b->time.next + b->time.accuracy);
1390 if (*next == t)
1391 return 0;
1392
1393 assert_se(timer_fd >= 0);
1394
1395 if (t == 0) {
1396 /* We don' want to disarm here, just mean some time looooong ago. */
1397 its.it_value.tv_sec = 0;
1398 its.it_value.tv_nsec = 1;
1399 } else
1400 timespec_store(&its.it_value, t);
1401
1402 r = timerfd_settime(timer_fd, TFD_TIMER_ABSTIME, &its, NULL);
1403 if (r < 0)
1404 return r;
1405
1406 *next = t;
1407 return 0;
1408 }
1409
1410 static int process_io(sd_event *e, sd_event_source *s, uint32_t events) {
1411 assert(e);
1412 assert(s);
1413 assert(s->type == SOURCE_IO);
1414
1415 s->io.revents = events;
1416
1417 /*
1418 If this is a oneshot event source, then we added it to the
1419 epoll with EPOLLONESHOT, hence we know it's not registered
1420 anymore. We can save a syscall here...
1421 */
1422
1423 if (s->enabled == SD_EVENT_ONESHOT)
1424 s->io.registered = false;
1425
1426 return source_set_pending(s, true);
1427 }
1428
1429 static int flush_timer(sd_event *e, int fd, uint32_t events) {
1430 uint64_t x;
1431 ssize_t ss;
1432
1433 assert(e);
1434 assert(fd >= 0);
1435 assert_return(events == EPOLLIN, -EIO);
1436
1437 ss = read(fd, &x, sizeof(x));
1438 if (ss < 0) {
1439 if (errno == EAGAIN || errno == EINTR)
1440 return 0;
1441
1442 return -errno;
1443 }
1444
1445 if (ss != sizeof(x))
1446 return -EIO;
1447
1448 return 0;
1449 }
1450
1451 static int process_timer(
1452 sd_event *e,
1453 usec_t n,
1454 Prioq *earliest,
1455 Prioq *latest) {
1456
1457 sd_event_source *s;
1458 int r;
1459
1460 assert(e);
1461
1462 for (;;) {
1463 s = prioq_peek(earliest);
1464 if (!s ||
1465 s->time.next > n ||
1466 s->enabled == SD_EVENT_OFF ||
1467 s->pending)
1468 break;
1469
1470 r = source_set_pending(s, true);
1471 if (r < 0)
1472 return r;
1473
1474 prioq_reshuffle(earliest, s, &s->time.earliest_index);
1475 prioq_reshuffle(latest, s, &s->time.latest_index);
1476 }
1477
1478 return 0;
1479 }
1480
1481 static int process_child(sd_event *e) {
1482 sd_event_source *s;
1483 Iterator i;
1484 int r;
1485
1486 assert(e);
1487
1488 e->need_process_child = false;
1489
1490 /*
1491 So, this is ugly. We iteratively invoke waitid() with P_PID
1492 + WNOHANG for each PID we wait for, instead of using
1493 P_ALL. This is because we only want to get child
1494 information of very specific child processes, and not all
1495 of them. We might not have processed the SIGCHLD even of a
1496 previous invocation and we don't want to maintain a
1497 unbounded *per-child* event queue, hence we really don't
1498 want anything flushed out of the kernel's queue that we
1499 don't care about. Since this is O(n) this means that if you
1500 have a lot of processes you probably want to handle SIGCHLD
1501 yourself.
1502 */
1503
1504 HASHMAP_FOREACH(s, e->child_sources, i) {
1505 assert(s->type == SOURCE_CHILD);
1506
1507 if (s->pending)
1508 continue;
1509
1510 if (s->enabled == SD_EVENT_OFF)
1511 continue;
1512
1513 zero(s->child.siginfo);
1514 r = waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|s->child.options);
1515 if (r < 0)
1516 return -errno;
1517
1518 if (s->child.siginfo.si_pid != 0) {
1519 r = source_set_pending(s, true);
1520 if (r < 0)
1521 return r;
1522 }
1523 }
1524
1525 return 0;
1526 }
1527
1528 static int process_signal(sd_event *e, uint32_t events) {
1529 struct signalfd_siginfo si;
1530 bool read_one = false;
1531 ssize_t ss;
1532 int r;
1533
1534 assert(e);
1535 assert_return(events == EPOLLIN, -EIO);
1536
1537 for (;;) {
1538 sd_event_source *s;
1539
1540 ss = read(e->signal_fd, &si, sizeof(si));
1541 if (ss < 0) {
1542 if (errno == EAGAIN || errno == EINTR)
1543 return read_one;
1544
1545 return -errno;
1546 }
1547
1548 if (ss != sizeof(si))
1549 return -EIO;
1550
1551 read_one = true;
1552
1553 if (si.ssi_signo == SIGCHLD) {
1554 r = process_child(e);
1555 if (r < 0)
1556 return r;
1557 if (r > 0 || !e->signal_sources[si.ssi_signo])
1558 continue;
1559 } else {
1560 s = e->signal_sources[si.ssi_signo];
1561 if (!s)
1562 return -EIO;
1563 }
1564
1565 s->signal.siginfo = si;
1566 r = source_set_pending(s, true);
1567 if (r < 0)
1568 return r;
1569 }
1570
1571
1572 return 0;
1573 }
1574
1575 static int source_dispatch(sd_event_source *s) {
1576 int r;
1577
1578 assert(s);
1579 assert(s->pending || s->type == SOURCE_QUIT);
1580
1581 if (s->type != SOURCE_DEFER && s->type != SOURCE_QUIT) {
1582 r = source_set_pending(s, false);
1583 if (r < 0)
1584 return r;
1585 }
1586
1587 if (s->enabled == SD_EVENT_ONESHOT) {
1588 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
1589 if (r < 0)
1590 return r;
1591 }
1592
1593 switch (s->type) {
1594
1595 case SOURCE_IO:
1596 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
1597 break;
1598
1599 case SOURCE_MONOTONIC:
1600 r = s->time.callback(s, s->time.next, s->userdata);
1601 break;
1602
1603 case SOURCE_REALTIME:
1604 r = s->time.callback(s, s->time.next, s->userdata);
1605 break;
1606
1607 case SOURCE_SIGNAL:
1608 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
1609 break;
1610
1611 case SOURCE_CHILD:
1612 r = s->child.callback(s, &s->child.siginfo, s->userdata);
1613 break;
1614
1615 case SOURCE_DEFER:
1616 r = s->defer.callback(s, s->userdata);
1617 break;
1618
1619 case SOURCE_QUIT:
1620 r = s->quit.callback(s, s->userdata);
1621 break;
1622 }
1623
1624 return r;
1625 }
1626
1627 static int event_prepare(sd_event *e) {
1628 int r;
1629
1630 assert(e);
1631
1632 for (;;) {
1633 sd_event_source *s;
1634
1635 s = prioq_peek(e->prepare);
1636 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
1637 break;
1638
1639 s->prepare_iteration = e->iteration;
1640 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
1641 if (r < 0)
1642 return r;
1643
1644 assert(s->prepare);
1645 r = s->prepare(s, s->userdata);
1646 if (r < 0)
1647 return r;
1648
1649 }
1650
1651 return 0;
1652 }
1653
1654 static int dispatch_quit(sd_event *e) {
1655 sd_event_source *p;
1656 int r;
1657
1658 assert(e);
1659
1660 p = prioq_peek(e->quit);
1661 if (!p || p->enabled == SD_EVENT_OFF) {
1662 e->state = SD_EVENT_FINISHED;
1663 return 0;
1664 }
1665
1666 sd_event_ref(e);
1667 e->iteration++;
1668 e->state = SD_EVENT_QUITTING;
1669
1670 r = source_dispatch(p);
1671
1672 e->state = SD_EVENT_PASSIVE;
1673 sd_event_unref(e);
1674
1675 return r;
1676 }
1677
1678 static sd_event_source* event_next_pending(sd_event *e) {
1679 sd_event_source *p;
1680
1681 assert(e);
1682
1683 p = prioq_peek(e->pending);
1684 if (!p)
1685 return NULL;
1686
1687 if (p->enabled == SD_EVENT_OFF)
1688 return NULL;
1689
1690 return p;
1691 }
1692
1693 int sd_event_run(sd_event *e, uint64_t timeout) {
1694 struct epoll_event ev_queue[EPOLL_QUEUE_MAX];
1695 sd_event_source *p;
1696 int r, i, m;
1697
1698 assert_return(e, -EINVAL);
1699 assert_return(!event_pid_changed(e), -ECHILD);
1700 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1701 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
1702
1703 if (e->quit_requested)
1704 return dispatch_quit(e);
1705
1706 sd_event_ref(e);
1707 e->iteration++;
1708 e->state = SD_EVENT_RUNNING;
1709
1710 r = event_prepare(e);
1711 if (r < 0)
1712 goto finish;
1713
1714 if (event_next_pending(e) || e->need_process_child)
1715 timeout = 0;
1716
1717 if (timeout > 0) {
1718 r = event_arm_timer(e, e->monotonic_fd, e->monotonic_earliest, e->monotonic_latest, &e->monotonic_next);
1719 if (r < 0)
1720 goto finish;
1721
1722 r = event_arm_timer(e, e->realtime_fd, e->realtime_earliest, e->realtime_latest, &e->realtime_next);
1723 if (r < 0)
1724 goto finish;
1725 }
1726
1727 m = epoll_wait(e->epoll_fd, ev_queue, EPOLL_QUEUE_MAX,
1728 timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
1729 if (m < 0) {
1730 r = m;
1731 goto finish;
1732 }
1733
1734 dual_timestamp_get(&e->timestamp);
1735
1736 for (i = 0; i < m; i++) {
1737
1738 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_MONOTONIC))
1739 r = flush_timer(e, e->monotonic_fd, ev_queue[i].events);
1740 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_REALTIME))
1741 r = flush_timer(e, e->realtime_fd, ev_queue[i].events);
1742 else if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_SIGNAL))
1743 r = process_signal(e, ev_queue[i].events);
1744 else
1745 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
1746
1747 if (r < 0)
1748 goto finish;
1749 }
1750
1751 r = process_timer(e, e->timestamp.monotonic, e->monotonic_earliest, e->monotonic_latest);
1752 if (r < 0)
1753 goto finish;
1754
1755 r = process_timer(e, e->timestamp.realtime, e->realtime_earliest, e->realtime_latest);
1756 if (r < 0)
1757 goto finish;
1758
1759 if (e->need_process_child) {
1760 r = process_child(e);
1761 if (r < 0)
1762 goto finish;
1763 }
1764
1765 p = event_next_pending(e);
1766 if (!p) {
1767 r = 0;
1768 goto finish;
1769 }
1770
1771 r = source_dispatch(p);
1772
1773 finish:
1774 e->state = SD_EVENT_PASSIVE;
1775 sd_event_unref(e);
1776
1777 return r;
1778 }
1779
1780 int sd_event_loop(sd_event *e) {
1781 int r;
1782
1783 assert_return(e, -EINVAL);
1784 assert_return(!event_pid_changed(e), -ECHILD);
1785 assert_return(e->state == SD_EVENT_PASSIVE, -EBUSY);
1786
1787 sd_event_ref(e);
1788
1789 while (e->state != SD_EVENT_FINISHED) {
1790 r = sd_event_run(e, (uint64_t) -1);
1791 if (r < 0)
1792 goto finish;
1793 }
1794
1795 r = 0;
1796
1797 finish:
1798 sd_event_unref(e);
1799 return r;
1800 }
1801
1802 int sd_event_get_state(sd_event *e) {
1803 assert_return(e, -EINVAL);
1804 assert_return(!event_pid_changed(e), -ECHILD);
1805
1806 return e->state;
1807 }
1808
1809 int sd_event_get_quit(sd_event *e) {
1810 assert_return(e, -EINVAL);
1811 assert_return(!event_pid_changed(e), -ECHILD);
1812
1813 return e->quit_requested;
1814 }
1815
1816 int sd_event_request_quit(sd_event *e) {
1817 assert_return(e, -EINVAL);
1818 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1819 assert_return(!event_pid_changed(e), -ECHILD);
1820
1821 e->quit_requested = true;
1822 return 0;
1823 }
1824
1825 int sd_event_get_now_realtime(sd_event *e, uint64_t *usec) {
1826 assert_return(e, -EINVAL);
1827 assert_return(usec, -EINVAL);
1828 assert_return(dual_timestamp_is_set(&e->timestamp), -ENODATA);
1829 assert_return(!event_pid_changed(e), -ECHILD);
1830
1831 *usec = e->timestamp.realtime;
1832 return 0;
1833 }
1834
1835 int sd_event_get_now_monotonic(sd_event *e, uint64_t *usec) {
1836 assert_return(e, -EINVAL);
1837 assert_return(usec, -EINVAL);
1838 assert_return(dual_timestamp_is_set(&e->timestamp), -ENODATA);
1839 assert_return(!event_pid_changed(e), -ECHILD);
1840
1841 *usec = e->timestamp.monotonic;
1842 return 0;
1843 }
Unnamed repository; edit this file 'description' to name the repository.