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


4af10401d83ec9a2c5428ba3ba16faec4d6fe58e
[thirdparty/systemd.git] / src / libsystemd / sd-event / sd-event.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 Copyright 2013 Lennart Poettering
4 ***/
5
6 #include <sys/epoll.h>
7 #include <sys/timerfd.h>
8 #include <sys/wait.h>
9
10 #include "sd-daemon.h"
11 #include "sd-event.h"
12 #include "sd-id128.h"
13
14 #include "alloc-util.h"
15 #include "fd-util.h"
16 #include "fs-util.h"
17 #include "hashmap.h"
18 #include "list.h"
19 #include "macro.h"
20 #include "missing.h"
21 #include "prioq.h"
22 #include "process-util.h"
23 #include "set.h"
24 #include "signal-util.h"
25 #include "string-table.h"
26 #include "string-util.h"
27 #include "time-util.h"
28 #include "util.h"
29
30 #define DEFAULT_ACCURACY_USEC (250 * USEC_PER_MSEC)
31
32 typedef enum EventSourceType {
33 SOURCE_IO,
34 SOURCE_TIME_REALTIME,
35 SOURCE_TIME_BOOTTIME,
36 SOURCE_TIME_MONOTONIC,
37 SOURCE_TIME_REALTIME_ALARM,
38 SOURCE_TIME_BOOTTIME_ALARM,
39 SOURCE_SIGNAL,
40 SOURCE_CHILD,
41 SOURCE_DEFER,
42 SOURCE_POST,
43 SOURCE_EXIT,
44 SOURCE_WATCHDOG,
45 SOURCE_INOTIFY,
46 _SOURCE_EVENT_SOURCE_TYPE_MAX,
47 _SOURCE_EVENT_SOURCE_TYPE_INVALID = -1
48 } EventSourceType;
49
50 static const char* const event_source_type_table[_SOURCE_EVENT_SOURCE_TYPE_MAX] = {
51 [SOURCE_IO] = "io",
52 [SOURCE_TIME_REALTIME] = "realtime",
53 [SOURCE_TIME_BOOTTIME] = "bootime",
54 [SOURCE_TIME_MONOTONIC] = "monotonic",
55 [SOURCE_TIME_REALTIME_ALARM] = "realtime-alarm",
56 [SOURCE_TIME_BOOTTIME_ALARM] = "boottime-alarm",
57 [SOURCE_SIGNAL] = "signal",
58 [SOURCE_CHILD] = "child",
59 [SOURCE_DEFER] = "defer",
60 [SOURCE_POST] = "post",
61 [SOURCE_EXIT] = "exit",
62 [SOURCE_WATCHDOG] = "watchdog",
63 [SOURCE_INOTIFY] = "inotify",
64 };
65
66 DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(event_source_type, int);
67
68 /* All objects we use in epoll events start with this value, so that
69 * we know how to dispatch it */
70 typedef enum WakeupType {
71 WAKEUP_NONE,
72 WAKEUP_EVENT_SOURCE,
73 WAKEUP_CLOCK_DATA,
74 WAKEUP_SIGNAL_DATA,
75 WAKEUP_INOTIFY_DATA,
76 _WAKEUP_TYPE_MAX,
77 _WAKEUP_TYPE_INVALID = -1,
78 } WakeupType;
79
80 #define EVENT_SOURCE_IS_TIME(t) IN_SET((t), SOURCE_TIME_REALTIME, SOURCE_TIME_BOOTTIME, SOURCE_TIME_MONOTONIC, SOURCE_TIME_REALTIME_ALARM, SOURCE_TIME_BOOTTIME_ALARM)
81
82 struct inode_data;
83
84 struct sd_event_source {
85 WakeupType wakeup;
86
87 unsigned n_ref;
88
89 sd_event *event;
90 void *userdata;
91 sd_event_handler_t prepare;
92
93 char *description;
94
95 EventSourceType type:5;
96 int enabled:3;
97 bool pending:1;
98 bool dispatching:1;
99 bool floating:1;
100
101 int64_t priority;
102 unsigned pending_index;
103 unsigned prepare_index;
104 uint64_t pending_iteration;
105 uint64_t prepare_iteration;
106
107 sd_event_destroy_t destroy_callback;
108
109 LIST_FIELDS(sd_event_source, sources);
110
111 union {
112 struct {
113 sd_event_io_handler_t callback;
114 int fd;
115 uint32_t events;
116 uint32_t revents;
117 bool registered:1;
118 bool owned:1;
119 } io;
120 struct {
121 sd_event_time_handler_t callback;
122 usec_t next, accuracy;
123 unsigned earliest_index;
124 unsigned latest_index;
125 } time;
126 struct {
127 sd_event_signal_handler_t callback;
128 struct signalfd_siginfo siginfo;
129 int sig;
130 } signal;
131 struct {
132 sd_event_child_handler_t callback;
133 siginfo_t siginfo;
134 pid_t pid;
135 int options;
136 } child;
137 struct {
138 sd_event_handler_t callback;
139 } defer;
140 struct {
141 sd_event_handler_t callback;
142 } post;
143 struct {
144 sd_event_handler_t callback;
145 unsigned prioq_index;
146 } exit;
147 struct {
148 sd_event_inotify_handler_t callback;
149 uint32_t mask;
150 struct inode_data *inode_data;
151 LIST_FIELDS(sd_event_source, by_inode_data);
152 } inotify;
153 };
154 };
155
156 struct clock_data {
157 WakeupType wakeup;
158 int fd;
159
160 /* For all clocks we maintain two priority queues each, one
161 * ordered for the earliest times the events may be
162 * dispatched, and one ordered by the latest times they must
163 * have been dispatched. The range between the top entries in
164 * the two prioqs is the time window we can freely schedule
165 * wakeups in */
166
167 Prioq *earliest;
168 Prioq *latest;
169 usec_t next;
170
171 bool needs_rearm:1;
172 };
173
174 struct signal_data {
175 WakeupType wakeup;
176
177 /* For each priority we maintain one signal fd, so that we
178 * only have to dequeue a single event per priority at a
179 * time. */
180
181 int fd;
182 int64_t priority;
183 sigset_t sigset;
184 sd_event_source *current;
185 };
186
187 /* A structure listing all event sources currently watching a specific inode */
188 struct inode_data {
189 /* The identifier for the inode, the combination of the .st_dev + .st_ino fields of the file */
190 ino_t ino;
191 dev_t dev;
192
193 /* An fd of the inode to watch. The fd is kept open until the next iteration of the loop, so that we can
194 * rearrange the priority still until then, as we need the original inode to change the priority as we need to
195 * add a watch descriptor to the right inotify for the priority which we can only do if we have a handle to the
196 * original inode. We keep a list of all inode_data objects with an open fd in the to_close list (see below) of
197 * the sd-event object, so that it is efficient to close everything, before entering the next event loop
198 * iteration. */
199 int fd;
200
201 /* The inotify "watch descriptor" */
202 int wd;
203
204 /* The combination of the mask of all inotify watches on this inode we manage. This is also the mask that has
205 * most recently been set on the watch descriptor. */
206 uint32_t combined_mask;
207
208 /* All event sources subscribed to this inode */
209 LIST_HEAD(sd_event_source, event_sources);
210
211 /* The inotify object we watch this inode with */
212 struct inotify_data *inotify_data;
213
214 /* A linked list of all inode data objects with fds to close (see above) */
215 LIST_FIELDS(struct inode_data, to_close);
216 };
217
218 /* A structure encapsulating an inotify fd */
219 struct inotify_data {
220 WakeupType wakeup;
221
222 /* For each priority we maintain one inotify fd, so that we only have to dequeue a single event per priority at
223 * a time */
224
225 int fd;
226 int64_t priority;
227
228 Hashmap *inodes; /* The inode_data structures keyed by dev+ino */
229 Hashmap *wd; /* The inode_data structures keyed by the watch descriptor for each */
230
231 /* The buffer we read inotify events into */
232 union inotify_event_buffer buffer;
233 size_t buffer_filled; /* fill level of the buffer */
234
235 /* How many event sources are currently marked pending for this inotify. We won't read new events off the
236 * inotify fd as long as there are still pending events on the inotify (because we have no strategy of queuing
237 * the events locally if they can't be coalesced). */
238 unsigned n_pending;
239
240 /* A linked list of all inotify objects with data already read, that still need processing. We keep this list
241 * to make it efficient to figure out what inotify objects to process data on next. */
242 LIST_FIELDS(struct inotify_data, buffered);
243 };
244
245 struct sd_event {
246 unsigned n_ref;
247
248 int epoll_fd;
249 int watchdog_fd;
250
251 Prioq *pending;
252 Prioq *prepare;
253
254 /* timerfd_create() only supports these five clocks so far. We
255 * can add support for more clocks when the kernel learns to
256 * deal with them, too. */
257 struct clock_data realtime;
258 struct clock_data boottime;
259 struct clock_data monotonic;
260 struct clock_data realtime_alarm;
261 struct clock_data boottime_alarm;
262
263 usec_t perturb;
264
265 sd_event_source **signal_sources; /* indexed by signal number */
266 Hashmap *signal_data; /* indexed by priority */
267
268 Hashmap *child_sources;
269 unsigned n_enabled_child_sources;
270
271 Set *post_sources;
272
273 Prioq *exit;
274
275 Hashmap *inotify_data; /* indexed by priority */
276
277 /* A list of inode structures that still have an fd open, that we need to close before the next loop iteration */
278 LIST_HEAD(struct inode_data, inode_data_to_close);
279
280 /* A list of inotify objects that already have events buffered which aren't processed yet */
281 LIST_HEAD(struct inotify_data, inotify_data_buffered);
282
283 pid_t original_pid;
284
285 uint64_t iteration;
286 triple_timestamp timestamp;
287 int state;
288
289 bool exit_requested:1;
290 bool need_process_child:1;
291 bool watchdog:1;
292 bool profile_delays:1;
293
294 int exit_code;
295
296 pid_t tid;
297 sd_event **default_event_ptr;
298
299 usec_t watchdog_last, watchdog_period;
300
301 unsigned n_sources;
302
303 LIST_HEAD(sd_event_source, sources);
304
305 usec_t last_run, last_log;
306 unsigned delays[sizeof(usec_t) * 8];
307 };
308
309 static thread_local sd_event *default_event = NULL;
310
311 static void source_disconnect(sd_event_source *s);
312 static void event_gc_inode_data(sd_event *e, struct inode_data *d);
313
314 static sd_event *event_resolve(sd_event *e) {
315 return e == SD_EVENT_DEFAULT ? default_event : e;
316 }
317
318 static int pending_prioq_compare(const void *a, const void *b) {
319 const sd_event_source *x = a, *y = b;
320
321 assert(x->pending);
322 assert(y->pending);
323
324 /* Enabled ones first */
325 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
326 return -1;
327 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
328 return 1;
329
330 /* Lower priority values first */
331 if (x->priority < y->priority)
332 return -1;
333 if (x->priority > y->priority)
334 return 1;
335
336 /* Older entries first */
337 if (x->pending_iteration < y->pending_iteration)
338 return -1;
339 if (x->pending_iteration > y->pending_iteration)
340 return 1;
341
342 return 0;
343 }
344
345 static int prepare_prioq_compare(const void *a, const void *b) {
346 const sd_event_source *x = a, *y = b;
347
348 assert(x->prepare);
349 assert(y->prepare);
350
351 /* Enabled ones first */
352 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
353 return -1;
354 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
355 return 1;
356
357 /* Move most recently prepared ones last, so that we can stop
358 * preparing as soon as we hit one that has already been
359 * prepared in the current iteration */
360 if (x->prepare_iteration < y->prepare_iteration)
361 return -1;
362 if (x->prepare_iteration > y->prepare_iteration)
363 return 1;
364
365 /* Lower priority values first */
366 if (x->priority < y->priority)
367 return -1;
368 if (x->priority > y->priority)
369 return 1;
370
371 return 0;
372 }
373
374 static int earliest_time_prioq_compare(const void *a, const void *b) {
375 const sd_event_source *x = a, *y = b;
376
377 assert(EVENT_SOURCE_IS_TIME(x->type));
378 assert(x->type == y->type);
379
380 /* Enabled ones first */
381 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
382 return -1;
383 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
384 return 1;
385
386 /* Move the pending ones to the end */
387 if (!x->pending && y->pending)
388 return -1;
389 if (x->pending && !y->pending)
390 return 1;
391
392 /* Order by time */
393 if (x->time.next < y->time.next)
394 return -1;
395 if (x->time.next > y->time.next)
396 return 1;
397
398 return 0;
399 }
400
401 static usec_t time_event_source_latest(const sd_event_source *s) {
402 return usec_add(s->time.next, s->time.accuracy);
403 }
404
405 static int latest_time_prioq_compare(const void *a, const void *b) {
406 const sd_event_source *x = a, *y = b;
407
408 assert(EVENT_SOURCE_IS_TIME(x->type));
409 assert(x->type == y->type);
410
411 /* Enabled ones first */
412 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
413 return -1;
414 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
415 return 1;
416
417 /* Move the pending ones to the end */
418 if (!x->pending && y->pending)
419 return -1;
420 if (x->pending && !y->pending)
421 return 1;
422
423 /* Order by time */
424 if (time_event_source_latest(x) < time_event_source_latest(y))
425 return -1;
426 if (time_event_source_latest(x) > time_event_source_latest(y))
427 return 1;
428
429 return 0;
430 }
431
432 static int exit_prioq_compare(const void *a, const void *b) {
433 const sd_event_source *x = a, *y = b;
434
435 assert(x->type == SOURCE_EXIT);
436 assert(y->type == SOURCE_EXIT);
437
438 /* Enabled ones first */
439 if (x->enabled != SD_EVENT_OFF && y->enabled == SD_EVENT_OFF)
440 return -1;
441 if (x->enabled == SD_EVENT_OFF && y->enabled != SD_EVENT_OFF)
442 return 1;
443
444 /* Lower priority values first */
445 if (x->priority < y->priority)
446 return -1;
447 if (x->priority > y->priority)
448 return 1;
449
450 return 0;
451 }
452
453 static void free_clock_data(struct clock_data *d) {
454 assert(d);
455 assert(d->wakeup == WAKEUP_CLOCK_DATA);
456
457 safe_close(d->fd);
458 prioq_free(d->earliest);
459 prioq_free(d->latest);
460 }
461
462 static void event_free(sd_event *e) {
463 sd_event_source *s;
464
465 assert(e);
466
467 while ((s = e->sources)) {
468 assert(s->floating);
469 source_disconnect(s);
470 sd_event_source_unref(s);
471 }
472
473 assert(e->n_sources == 0);
474
475 if (e->default_event_ptr)
476 *(e->default_event_ptr) = NULL;
477
478 safe_close(e->epoll_fd);
479 safe_close(e->watchdog_fd);
480
481 free_clock_data(&e->realtime);
482 free_clock_data(&e->boottime);
483 free_clock_data(&e->monotonic);
484 free_clock_data(&e->realtime_alarm);
485 free_clock_data(&e->boottime_alarm);
486
487 prioq_free(e->pending);
488 prioq_free(e->prepare);
489 prioq_free(e->exit);
490
491 free(e->signal_sources);
492 hashmap_free(e->signal_data);
493
494 hashmap_free(e->inotify_data);
495
496 hashmap_free(e->child_sources);
497 set_free(e->post_sources);
498 free(e);
499 }
500
501 _public_ int sd_event_new(sd_event** ret) {
502 sd_event *e;
503 int r;
504
505 assert_return(ret, -EINVAL);
506
507 e = new(sd_event, 1);
508 if (!e)
509 return -ENOMEM;
510
511 *e = (sd_event) {
512 .n_ref = 1,
513 .epoll_fd = -1,
514 .watchdog_fd = -1,
515 .realtime.wakeup = WAKEUP_CLOCK_DATA,
516 .realtime.fd = -1,
517 .realtime.next = USEC_INFINITY,
518 .boottime.wakeup = WAKEUP_CLOCK_DATA,
519 .boottime.fd = -1,
520 .boottime.next = USEC_INFINITY,
521 .monotonic.wakeup = WAKEUP_CLOCK_DATA,
522 .monotonic.fd = -1,
523 .monotonic.next = USEC_INFINITY,
524 .realtime_alarm.wakeup = WAKEUP_CLOCK_DATA,
525 .realtime_alarm.fd = -1,
526 .realtime_alarm.next = USEC_INFINITY,
527 .boottime_alarm.wakeup = WAKEUP_CLOCK_DATA,
528 .boottime_alarm.fd = -1,
529 .boottime_alarm.next = USEC_INFINITY,
530 .perturb = USEC_INFINITY,
531 .original_pid = getpid_cached(),
532 };
533
534 r = prioq_ensure_allocated(&e->pending, pending_prioq_compare);
535 if (r < 0)
536 goto fail;
537
538 e->epoll_fd = epoll_create1(EPOLL_CLOEXEC);
539 if (e->epoll_fd < 0) {
540 r = -errno;
541 goto fail;
542 }
543
544 e->epoll_fd = fd_move_above_stdio(e->epoll_fd);
545
546 if (secure_getenv("SD_EVENT_PROFILE_DELAYS")) {
547 log_debug("Event loop profiling enabled. Logarithmic histogram of event loop iterations in the range 2^0 ... 2^63 us will be logged every 5s.");
548 e->profile_delays = true;
549 }
550
551 *ret = e;
552 return 0;
553
554 fail:
555 event_free(e);
556 return r;
557 }
558
559 _public_ sd_event* sd_event_ref(sd_event *e) {
560
561 if (!e)
562 return NULL;
563
564 assert(e->n_ref >= 1);
565 e->n_ref++;
566
567 return e;
568 }
569
570 _public_ sd_event* sd_event_unref(sd_event *e) {
571
572 if (!e)
573 return NULL;
574
575 assert(e->n_ref >= 1);
576 e->n_ref--;
577
578 if (e->n_ref <= 0)
579 event_free(e);
580
581 return NULL;
582 }
583
584 static bool event_pid_changed(sd_event *e) {
585 assert(e);
586
587 /* We don't support people creating an event loop and keeping
588 * it around over a fork(). Let's complain. */
589
590 return e->original_pid != getpid_cached();
591 }
592
593 static void source_io_unregister(sd_event_source *s) {
594 int r;
595
596 assert(s);
597 assert(s->type == SOURCE_IO);
598
599 if (event_pid_changed(s->event))
600 return;
601
602 if (!s->io.registered)
603 return;
604
605 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, s->io.fd, NULL);
606 if (r < 0)
607 log_debug_errno(errno, "Failed to remove source %s (type %s) from epoll: %m",
608 strna(s->description), event_source_type_to_string(s->type));
609
610 s->io.registered = false;
611 }
612
613 static int source_io_register(
614 sd_event_source *s,
615 int enabled,
616 uint32_t events) {
617
618 struct epoll_event ev;
619 int r;
620
621 assert(s);
622 assert(s->type == SOURCE_IO);
623 assert(enabled != SD_EVENT_OFF);
624
625 ev = (struct epoll_event) {
626 .events = events | (enabled == SD_EVENT_ONESHOT ? EPOLLONESHOT : 0),
627 .data.ptr = s,
628 };
629
630 if (s->io.registered)
631 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_MOD, s->io.fd, &ev);
632 else
633 r = epoll_ctl(s->event->epoll_fd, EPOLL_CTL_ADD, s->io.fd, &ev);
634 if (r < 0)
635 return -errno;
636
637 s->io.registered = true;
638
639 return 0;
640 }
641
642 static clockid_t event_source_type_to_clock(EventSourceType t) {
643
644 switch (t) {
645
646 case SOURCE_TIME_REALTIME:
647 return CLOCK_REALTIME;
648
649 case SOURCE_TIME_BOOTTIME:
650 return CLOCK_BOOTTIME;
651
652 case SOURCE_TIME_MONOTONIC:
653 return CLOCK_MONOTONIC;
654
655 case SOURCE_TIME_REALTIME_ALARM:
656 return CLOCK_REALTIME_ALARM;
657
658 case SOURCE_TIME_BOOTTIME_ALARM:
659 return CLOCK_BOOTTIME_ALARM;
660
661 default:
662 return (clockid_t) -1;
663 }
664 }
665
666 static EventSourceType clock_to_event_source_type(clockid_t clock) {
667
668 switch (clock) {
669
670 case CLOCK_REALTIME:
671 return SOURCE_TIME_REALTIME;
672
673 case CLOCK_BOOTTIME:
674 return SOURCE_TIME_BOOTTIME;
675
676 case CLOCK_MONOTONIC:
677 return SOURCE_TIME_MONOTONIC;
678
679 case CLOCK_REALTIME_ALARM:
680 return SOURCE_TIME_REALTIME_ALARM;
681
682 case CLOCK_BOOTTIME_ALARM:
683 return SOURCE_TIME_BOOTTIME_ALARM;
684
685 default:
686 return _SOURCE_EVENT_SOURCE_TYPE_INVALID;
687 }
688 }
689
690 static struct clock_data* event_get_clock_data(sd_event *e, EventSourceType t) {
691 assert(e);
692
693 switch (t) {
694
695 case SOURCE_TIME_REALTIME:
696 return &e->realtime;
697
698 case SOURCE_TIME_BOOTTIME:
699 return &e->boottime;
700
701 case SOURCE_TIME_MONOTONIC:
702 return &e->monotonic;
703
704 case SOURCE_TIME_REALTIME_ALARM:
705 return &e->realtime_alarm;
706
707 case SOURCE_TIME_BOOTTIME_ALARM:
708 return &e->boottime_alarm;
709
710 default:
711 return NULL;
712 }
713 }
714
715 static int event_make_signal_data(
716 sd_event *e,
717 int sig,
718 struct signal_data **ret) {
719
720 struct epoll_event ev;
721 struct signal_data *d;
722 bool added = false;
723 sigset_t ss_copy;
724 int64_t priority;
725 int r;
726
727 assert(e);
728
729 if (event_pid_changed(e))
730 return -ECHILD;
731
732 if (e->signal_sources && e->signal_sources[sig])
733 priority = e->signal_sources[sig]->priority;
734 else
735 priority = SD_EVENT_PRIORITY_NORMAL;
736
737 d = hashmap_get(e->signal_data, &priority);
738 if (d) {
739 if (sigismember(&d->sigset, sig) > 0) {
740 if (ret)
741 *ret = d;
742 return 0;
743 }
744 } else {
745 r = hashmap_ensure_allocated(&e->signal_data, &uint64_hash_ops);
746 if (r < 0)
747 return r;
748
749 d = new(struct signal_data, 1);
750 if (!d)
751 return -ENOMEM;
752
753 *d = (struct signal_data) {
754 .wakeup = WAKEUP_SIGNAL_DATA,
755 .fd = -1,
756 .priority = priority,
757 };
758
759 r = hashmap_put(e->signal_data, &d->priority, d);
760 if (r < 0) {
761 free(d);
762 return r;
763 }
764
765 added = true;
766 }
767
768 ss_copy = d->sigset;
769 assert_se(sigaddset(&ss_copy, sig) >= 0);
770
771 r = signalfd(d->fd, &ss_copy, SFD_NONBLOCK|SFD_CLOEXEC);
772 if (r < 0) {
773 r = -errno;
774 goto fail;
775 }
776
777 d->sigset = ss_copy;
778
779 if (d->fd >= 0) {
780 if (ret)
781 *ret = d;
782 return 0;
783 }
784
785 d->fd = fd_move_above_stdio(r);
786
787 ev = (struct epoll_event) {
788 .events = EPOLLIN,
789 .data.ptr = d,
790 };
791
792 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, d->fd, &ev);
793 if (r < 0) {
794 r = -errno;
795 goto fail;
796 }
797
798 if (ret)
799 *ret = d;
800
801 return 0;
802
803 fail:
804 if (added) {
805 d->fd = safe_close(d->fd);
806 hashmap_remove(e->signal_data, &d->priority);
807 free(d);
808 }
809
810 return r;
811 }
812
813 static void event_unmask_signal_data(sd_event *e, struct signal_data *d, int sig) {
814 assert(e);
815 assert(d);
816
817 /* Turns off the specified signal in the signal data
818 * object. If the signal mask of the object becomes empty that
819 * way removes it. */
820
821 if (sigismember(&d->sigset, sig) == 0)
822 return;
823
824 assert_se(sigdelset(&d->sigset, sig) >= 0);
825
826 if (sigisemptyset(&d->sigset)) {
827
828 /* If all the mask is all-zero we can get rid of the structure */
829 hashmap_remove(e->signal_data, &d->priority);
830 safe_close(d->fd);
831 free(d);
832 return;
833 }
834
835 assert(d->fd >= 0);
836
837 if (signalfd(d->fd, &d->sigset, SFD_NONBLOCK|SFD_CLOEXEC) < 0)
838 log_debug_errno(errno, "Failed to unset signal bit, ignoring: %m");
839 }
840
841 static void event_gc_signal_data(sd_event *e, const int64_t *priority, int sig) {
842 struct signal_data *d;
843 static const int64_t zero_priority = 0;
844
845 assert(e);
846
847 /* Rechecks if the specified signal is still something we are
848 * interested in. If not, we'll unmask it, and possibly drop
849 * the signalfd for it. */
850
851 if (sig == SIGCHLD &&
852 e->n_enabled_child_sources > 0)
853 return;
854
855 if (e->signal_sources &&
856 e->signal_sources[sig] &&
857 e->signal_sources[sig]->enabled != SD_EVENT_OFF)
858 return;
859
860 /*
861 * The specified signal might be enabled in three different queues:
862 *
863 * 1) the one that belongs to the priority passed (if it is non-NULL)
864 * 2) the one that belongs to the priority of the event source of the signal (if there is one)
865 * 3) the 0 priority (to cover the SIGCHLD case)
866 *
867 * Hence, let's remove it from all three here.
868 */
869
870 if (priority) {
871 d = hashmap_get(e->signal_data, priority);
872 if (d)
873 event_unmask_signal_data(e, d, sig);
874 }
875
876 if (e->signal_sources && e->signal_sources[sig]) {
877 d = hashmap_get(e->signal_data, &e->signal_sources[sig]->priority);
878 if (d)
879 event_unmask_signal_data(e, d, sig);
880 }
881
882 d = hashmap_get(e->signal_data, &zero_priority);
883 if (d)
884 event_unmask_signal_data(e, d, sig);
885 }
886
887 static void source_disconnect(sd_event_source *s) {
888 sd_event *event;
889
890 assert(s);
891
892 if (!s->event)
893 return;
894
895 assert(s->event->n_sources > 0);
896
897 switch (s->type) {
898
899 case SOURCE_IO:
900 if (s->io.fd >= 0)
901 source_io_unregister(s);
902
903 break;
904
905 case SOURCE_TIME_REALTIME:
906 case SOURCE_TIME_BOOTTIME:
907 case SOURCE_TIME_MONOTONIC:
908 case SOURCE_TIME_REALTIME_ALARM:
909 case SOURCE_TIME_BOOTTIME_ALARM: {
910 struct clock_data *d;
911
912 d = event_get_clock_data(s->event, s->type);
913 assert(d);
914
915 prioq_remove(d->earliest, s, &s->time.earliest_index);
916 prioq_remove(d->latest, s, &s->time.latest_index);
917 d->needs_rearm = true;
918 break;
919 }
920
921 case SOURCE_SIGNAL:
922 if (s->signal.sig > 0) {
923
924 if (s->event->signal_sources)
925 s->event->signal_sources[s->signal.sig] = NULL;
926
927 event_gc_signal_data(s->event, &s->priority, s->signal.sig);
928 }
929
930 break;
931
932 case SOURCE_CHILD:
933 if (s->child.pid > 0) {
934 if (s->enabled != SD_EVENT_OFF) {
935 assert(s->event->n_enabled_child_sources > 0);
936 s->event->n_enabled_child_sources--;
937 }
938
939 (void) hashmap_remove(s->event->child_sources, PID_TO_PTR(s->child.pid));
940 event_gc_signal_data(s->event, &s->priority, SIGCHLD);
941 }
942
943 break;
944
945 case SOURCE_DEFER:
946 /* nothing */
947 break;
948
949 case SOURCE_POST:
950 set_remove(s->event->post_sources, s);
951 break;
952
953 case SOURCE_EXIT:
954 prioq_remove(s->event->exit, s, &s->exit.prioq_index);
955 break;
956
957 case SOURCE_INOTIFY: {
958 struct inode_data *inode_data;
959
960 inode_data = s->inotify.inode_data;
961 if (inode_data) {
962 struct inotify_data *inotify_data;
963 assert_se(inotify_data = inode_data->inotify_data);
964
965 /* Detach this event source from the inode object */
966 LIST_REMOVE(inotify.by_inode_data, inode_data->event_sources, s);
967 s->inotify.inode_data = NULL;
968
969 if (s->pending) {
970 assert(inotify_data->n_pending > 0);
971 inotify_data->n_pending--;
972 }
973
974 /* Note that we don't reduce the inotify mask for the watch descriptor here if the inode is
975 * continued to being watched. That's because inotify doesn't really have an API for that: we
976 * can only change watch masks with access to the original inode either by fd or by path. But
977 * paths aren't stable, and keeping an O_PATH fd open all the time would mean wasting an fd
978 * continously and keeping the mount busy which we can't really do. We could reconstruct the
979 * original inode from /proc/self/fdinfo/$INOTIFY_FD (as all watch descriptors are listed
980 * there), but given the need for open_by_handle_at() which is privileged and not universally
981 * available this would be quite an incomplete solution. Hence we go the other way, leave the
982 * mask set, even if it is not minimized now, and ignore all events we aren't interested in
983 * anymore after reception. Yes, this sucks, but … Linux … */
984
985 /* Maybe release the inode data (and its inotify) */
986 event_gc_inode_data(s->event, inode_data);
987 }
988
989 break;
990 }
991
992 default:
993 assert_not_reached("Wut? I shouldn't exist.");
994 }
995
996 if (s->pending)
997 prioq_remove(s->event->pending, s, &s->pending_index);
998
999 if (s->prepare)
1000 prioq_remove(s->event->prepare, s, &s->prepare_index);
1001
1002 event = s->event;
1003
1004 s->type = _SOURCE_EVENT_SOURCE_TYPE_INVALID;
1005 s->event = NULL;
1006 LIST_REMOVE(sources, event->sources, s);
1007 event->n_sources--;
1008
1009 if (!s->floating)
1010 sd_event_unref(event);
1011 }
1012
1013 static void source_free(sd_event_source *s) {
1014 assert(s);
1015
1016 source_disconnect(s);
1017
1018 if (s->type == SOURCE_IO && s->io.owned)
1019 s->io.fd = safe_close(s->io.fd);
1020
1021 if (s->destroy_callback)
1022 s->destroy_callback(s->userdata);
1023
1024 free(s->description);
1025 free(s);
1026 }
1027
1028 static int source_set_pending(sd_event_source *s, bool b) {
1029 int r;
1030
1031 assert(s);
1032 assert(s->type != SOURCE_EXIT);
1033
1034 if (s->pending == b)
1035 return 0;
1036
1037 s->pending = b;
1038
1039 if (b) {
1040 s->pending_iteration = s->event->iteration;
1041
1042 r = prioq_put(s->event->pending, s, &s->pending_index);
1043 if (r < 0) {
1044 s->pending = false;
1045 return r;
1046 }
1047 } else
1048 assert_se(prioq_remove(s->event->pending, s, &s->pending_index));
1049
1050 if (EVENT_SOURCE_IS_TIME(s->type)) {
1051 struct clock_data *d;
1052
1053 d = event_get_clock_data(s->event, s->type);
1054 assert(d);
1055
1056 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
1057 prioq_reshuffle(d->latest, s, &s->time.latest_index);
1058 d->needs_rearm = true;
1059 }
1060
1061 if (s->type == SOURCE_SIGNAL && !b) {
1062 struct signal_data *d;
1063
1064 d = hashmap_get(s->event->signal_data, &s->priority);
1065 if (d && d->current == s)
1066 d->current = NULL;
1067 }
1068
1069 if (s->type == SOURCE_INOTIFY) {
1070
1071 assert(s->inotify.inode_data);
1072 assert(s->inotify.inode_data->inotify_data);
1073
1074 if (b)
1075 s->inotify.inode_data->inotify_data->n_pending ++;
1076 else {
1077 assert(s->inotify.inode_data->inotify_data->n_pending > 0);
1078 s->inotify.inode_data->inotify_data->n_pending --;
1079 }
1080 }
1081
1082 return 0;
1083 }
1084
1085 static sd_event_source *source_new(sd_event *e, bool floating, EventSourceType type) {
1086 sd_event_source *s;
1087
1088 assert(e);
1089
1090 s = new(sd_event_source, 1);
1091 if (!s)
1092 return NULL;
1093
1094 *s = (struct sd_event_source) {
1095 .n_ref = 1,
1096 .event = e,
1097 .floating = floating,
1098 .type = type,
1099 .pending_index = PRIOQ_IDX_NULL,
1100 .prepare_index = PRIOQ_IDX_NULL,
1101 };
1102
1103 if (!floating)
1104 sd_event_ref(e);
1105
1106 LIST_PREPEND(sources, e->sources, s);
1107 e->n_sources++;
1108
1109 return s;
1110 }
1111
1112 _public_ int sd_event_add_io(
1113 sd_event *e,
1114 sd_event_source **ret,
1115 int fd,
1116 uint32_t events,
1117 sd_event_io_handler_t callback,
1118 void *userdata) {
1119
1120 sd_event_source *s;
1121 int r;
1122
1123 assert_return(e, -EINVAL);
1124 assert_return(e = event_resolve(e), -ENOPKG);
1125 assert_return(fd >= 0, -EBADF);
1126 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
1127 assert_return(callback, -EINVAL);
1128 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1129 assert_return(!event_pid_changed(e), -ECHILD);
1130
1131 s = source_new(e, !ret, SOURCE_IO);
1132 if (!s)
1133 return -ENOMEM;
1134
1135 s->wakeup = WAKEUP_EVENT_SOURCE;
1136 s->io.fd = fd;
1137 s->io.events = events;
1138 s->io.callback = callback;
1139 s->userdata = userdata;
1140 s->enabled = SD_EVENT_ON;
1141
1142 r = source_io_register(s, s->enabled, events);
1143 if (r < 0) {
1144 source_free(s);
1145 return r;
1146 }
1147
1148 if (ret)
1149 *ret = s;
1150
1151 return 0;
1152 }
1153
1154 static void initialize_perturb(sd_event *e) {
1155 sd_id128_t bootid = {};
1156
1157 /* When we sleep for longer, we try to realign the wakeup to
1158 the same time wihtin each minute/second/250ms, so that
1159 events all across the system can be coalesced into a single
1160 CPU wakeup. However, let's take some system-specific
1161 randomness for this value, so that in a network of systems
1162 with synced clocks timer events are distributed a
1163 bit. Here, we calculate a perturbation usec offset from the
1164 boot ID. */
1165
1166 if (_likely_(e->perturb != USEC_INFINITY))
1167 return;
1168
1169 if (sd_id128_get_boot(&bootid) >= 0)
1170 e->perturb = (bootid.qwords[0] ^ bootid.qwords[1]) % USEC_PER_MINUTE;
1171 }
1172
1173 static int event_setup_timer_fd(
1174 sd_event *e,
1175 struct clock_data *d,
1176 clockid_t clock) {
1177
1178 struct epoll_event ev;
1179 int r, fd;
1180
1181 assert(e);
1182 assert(d);
1183
1184 if (_likely_(d->fd >= 0))
1185 return 0;
1186
1187 fd = timerfd_create(clock, TFD_NONBLOCK|TFD_CLOEXEC);
1188 if (fd < 0)
1189 return -errno;
1190
1191 fd = fd_move_above_stdio(fd);
1192
1193 ev = (struct epoll_event) {
1194 .events = EPOLLIN,
1195 .data.ptr = d,
1196 };
1197
1198 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, fd, &ev);
1199 if (r < 0) {
1200 safe_close(fd);
1201 return -errno;
1202 }
1203
1204 d->fd = fd;
1205 return 0;
1206 }
1207
1208 static int time_exit_callback(sd_event_source *s, uint64_t usec, void *userdata) {
1209 assert(s);
1210
1211 return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1212 }
1213
1214 _public_ int sd_event_add_time(
1215 sd_event *e,
1216 sd_event_source **ret,
1217 clockid_t clock,
1218 uint64_t usec,
1219 uint64_t accuracy,
1220 sd_event_time_handler_t callback,
1221 void *userdata) {
1222
1223 EventSourceType type;
1224 sd_event_source *s;
1225 struct clock_data *d;
1226 int r;
1227
1228 assert_return(e, -EINVAL);
1229 assert_return(e = event_resolve(e), -ENOPKG);
1230 assert_return(accuracy != (uint64_t) -1, -EINVAL);
1231 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1232 assert_return(!event_pid_changed(e), -ECHILD);
1233
1234 if (!clock_supported(clock)) /* Checks whether the kernel supports the clock */
1235 return -EOPNOTSUPP;
1236
1237 type = clock_to_event_source_type(clock); /* checks whether sd-event supports this clock */
1238 if (type < 0)
1239 return -EOPNOTSUPP;
1240
1241 if (!callback)
1242 callback = time_exit_callback;
1243
1244 d = event_get_clock_data(e, type);
1245 assert(d);
1246
1247 r = prioq_ensure_allocated(&d->earliest, earliest_time_prioq_compare);
1248 if (r < 0)
1249 return r;
1250
1251 r = prioq_ensure_allocated(&d->latest, latest_time_prioq_compare);
1252 if (r < 0)
1253 return r;
1254
1255 if (d->fd < 0) {
1256 r = event_setup_timer_fd(e, d, clock);
1257 if (r < 0)
1258 return r;
1259 }
1260
1261 s = source_new(e, !ret, type);
1262 if (!s)
1263 return -ENOMEM;
1264
1265 s->time.next = usec;
1266 s->time.accuracy = accuracy == 0 ? DEFAULT_ACCURACY_USEC : accuracy;
1267 s->time.callback = callback;
1268 s->time.earliest_index = s->time.latest_index = PRIOQ_IDX_NULL;
1269 s->userdata = userdata;
1270 s->enabled = SD_EVENT_ONESHOT;
1271
1272 d->needs_rearm = true;
1273
1274 r = prioq_put(d->earliest, s, &s->time.earliest_index);
1275 if (r < 0)
1276 goto fail;
1277
1278 r = prioq_put(d->latest, s, &s->time.latest_index);
1279 if (r < 0)
1280 goto fail;
1281
1282 if (ret)
1283 *ret = s;
1284
1285 return 0;
1286
1287 fail:
1288 source_free(s);
1289 return r;
1290 }
1291
1292 static int signal_exit_callback(sd_event_source *s, const struct signalfd_siginfo *si, void *userdata) {
1293 assert(s);
1294
1295 return sd_event_exit(sd_event_source_get_event(s), PTR_TO_INT(userdata));
1296 }
1297
1298 _public_ int sd_event_add_signal(
1299 sd_event *e,
1300 sd_event_source **ret,
1301 int sig,
1302 sd_event_signal_handler_t callback,
1303 void *userdata) {
1304
1305 sd_event_source *s;
1306 struct signal_data *d;
1307 sigset_t ss;
1308 int r;
1309
1310 assert_return(e, -EINVAL);
1311 assert_return(e = event_resolve(e), -ENOPKG);
1312 assert_return(SIGNAL_VALID(sig), -EINVAL);
1313 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1314 assert_return(!event_pid_changed(e), -ECHILD);
1315
1316 if (!callback)
1317 callback = signal_exit_callback;
1318
1319 r = pthread_sigmask(SIG_SETMASK, NULL, &ss);
1320 if (r != 0)
1321 return -r;
1322
1323 if (!sigismember(&ss, sig))
1324 return -EBUSY;
1325
1326 if (!e->signal_sources) {
1327 e->signal_sources = new0(sd_event_source*, _NSIG);
1328 if (!e->signal_sources)
1329 return -ENOMEM;
1330 } else if (e->signal_sources[sig])
1331 return -EBUSY;
1332
1333 s = source_new(e, !ret, SOURCE_SIGNAL);
1334 if (!s)
1335 return -ENOMEM;
1336
1337 s->signal.sig = sig;
1338 s->signal.callback = callback;
1339 s->userdata = userdata;
1340 s->enabled = SD_EVENT_ON;
1341
1342 e->signal_sources[sig] = s;
1343
1344 r = event_make_signal_data(e, sig, &d);
1345 if (r < 0) {
1346 source_free(s);
1347 return r;
1348 }
1349
1350 /* Use the signal name as description for the event source by default */
1351 (void) sd_event_source_set_description(s, signal_to_string(sig));
1352
1353 if (ret)
1354 *ret = s;
1355
1356 return 0;
1357 }
1358
1359 _public_ int sd_event_add_child(
1360 sd_event *e,
1361 sd_event_source **ret,
1362 pid_t pid,
1363 int options,
1364 sd_event_child_handler_t callback,
1365 void *userdata) {
1366
1367 sd_event_source *s;
1368 int r;
1369
1370 assert_return(e, -EINVAL);
1371 assert_return(e = event_resolve(e), -ENOPKG);
1372 assert_return(pid > 1, -EINVAL);
1373 assert_return(!(options & ~(WEXITED|WSTOPPED|WCONTINUED)), -EINVAL);
1374 assert_return(options != 0, -EINVAL);
1375 assert_return(callback, -EINVAL);
1376 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1377 assert_return(!event_pid_changed(e), -ECHILD);
1378
1379 r = hashmap_ensure_allocated(&e->child_sources, NULL);
1380 if (r < 0)
1381 return r;
1382
1383 if (hashmap_contains(e->child_sources, PID_TO_PTR(pid)))
1384 return -EBUSY;
1385
1386 s = source_new(e, !ret, SOURCE_CHILD);
1387 if (!s)
1388 return -ENOMEM;
1389
1390 s->child.pid = pid;
1391 s->child.options = options;
1392 s->child.callback = callback;
1393 s->userdata = userdata;
1394 s->enabled = SD_EVENT_ONESHOT;
1395
1396 r = hashmap_put(e->child_sources, PID_TO_PTR(pid), s);
1397 if (r < 0) {
1398 source_free(s);
1399 return r;
1400 }
1401
1402 e->n_enabled_child_sources++;
1403
1404 r = event_make_signal_data(e, SIGCHLD, NULL);
1405 if (r < 0) {
1406 e->n_enabled_child_sources--;
1407 source_free(s);
1408 return r;
1409 }
1410
1411 e->need_process_child = true;
1412
1413 if (ret)
1414 *ret = s;
1415
1416 return 0;
1417 }
1418
1419 _public_ int sd_event_add_defer(
1420 sd_event *e,
1421 sd_event_source **ret,
1422 sd_event_handler_t callback,
1423 void *userdata) {
1424
1425 sd_event_source *s;
1426 int r;
1427
1428 assert_return(e, -EINVAL);
1429 assert_return(e = event_resolve(e), -ENOPKG);
1430 assert_return(callback, -EINVAL);
1431 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1432 assert_return(!event_pid_changed(e), -ECHILD);
1433
1434 s = source_new(e, !ret, SOURCE_DEFER);
1435 if (!s)
1436 return -ENOMEM;
1437
1438 s->defer.callback = callback;
1439 s->userdata = userdata;
1440 s->enabled = SD_EVENT_ONESHOT;
1441
1442 r = source_set_pending(s, true);
1443 if (r < 0) {
1444 source_free(s);
1445 return r;
1446 }
1447
1448 if (ret)
1449 *ret = s;
1450
1451 return 0;
1452 }
1453
1454 _public_ int sd_event_add_post(
1455 sd_event *e,
1456 sd_event_source **ret,
1457 sd_event_handler_t callback,
1458 void *userdata) {
1459
1460 sd_event_source *s;
1461 int r;
1462
1463 assert_return(e, -EINVAL);
1464 assert_return(e = event_resolve(e), -ENOPKG);
1465 assert_return(callback, -EINVAL);
1466 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1467 assert_return(!event_pid_changed(e), -ECHILD);
1468
1469 r = set_ensure_allocated(&e->post_sources, NULL);
1470 if (r < 0)
1471 return r;
1472
1473 s = source_new(e, !ret, SOURCE_POST);
1474 if (!s)
1475 return -ENOMEM;
1476
1477 s->post.callback = callback;
1478 s->userdata = userdata;
1479 s->enabled = SD_EVENT_ON;
1480
1481 r = set_put(e->post_sources, s);
1482 if (r < 0) {
1483 source_free(s);
1484 return r;
1485 }
1486
1487 if (ret)
1488 *ret = s;
1489
1490 return 0;
1491 }
1492
1493 _public_ int sd_event_add_exit(
1494 sd_event *e,
1495 sd_event_source **ret,
1496 sd_event_handler_t callback,
1497 void *userdata) {
1498
1499 sd_event_source *s;
1500 int r;
1501
1502 assert_return(e, -EINVAL);
1503 assert_return(e = event_resolve(e), -ENOPKG);
1504 assert_return(callback, -EINVAL);
1505 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1506 assert_return(!event_pid_changed(e), -ECHILD);
1507
1508 r = prioq_ensure_allocated(&e->exit, exit_prioq_compare);
1509 if (r < 0)
1510 return r;
1511
1512 s = source_new(e, !ret, SOURCE_EXIT);
1513 if (!s)
1514 return -ENOMEM;
1515
1516 s->exit.callback = callback;
1517 s->userdata = userdata;
1518 s->exit.prioq_index = PRIOQ_IDX_NULL;
1519 s->enabled = SD_EVENT_ONESHOT;
1520
1521 r = prioq_put(s->event->exit, s, &s->exit.prioq_index);
1522 if (r < 0) {
1523 source_free(s);
1524 return r;
1525 }
1526
1527 if (ret)
1528 *ret = s;
1529
1530 return 0;
1531 }
1532
1533 static void event_free_inotify_data(sd_event *e, struct inotify_data *d) {
1534 assert(e);
1535
1536 if (!d)
1537 return;
1538
1539 assert(hashmap_isempty(d->inodes));
1540 assert(hashmap_isempty(d->wd));
1541
1542 if (d->buffer_filled > 0)
1543 LIST_REMOVE(buffered, e->inotify_data_buffered, d);
1544
1545 hashmap_free(d->inodes);
1546 hashmap_free(d->wd);
1547
1548 assert_se(hashmap_remove(e->inotify_data, &d->priority) == d);
1549
1550 if (d->fd >= 0) {
1551 if (epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, d->fd, NULL) < 0)
1552 log_debug_errno(errno, "Failed to remove inotify fd from epoll, ignoring: %m");
1553
1554 safe_close(d->fd);
1555 }
1556 free(d);
1557 }
1558
1559 static int event_make_inotify_data(
1560 sd_event *e,
1561 int64_t priority,
1562 struct inotify_data **ret) {
1563
1564 _cleanup_close_ int fd = -1;
1565 struct inotify_data *d;
1566 struct epoll_event ev;
1567 int r;
1568
1569 assert(e);
1570
1571 d = hashmap_get(e->inotify_data, &priority);
1572 if (d) {
1573 if (ret)
1574 *ret = d;
1575 return 0;
1576 }
1577
1578 fd = inotify_init1(IN_NONBLOCK|O_CLOEXEC);
1579 if (fd < 0)
1580 return -errno;
1581
1582 fd = fd_move_above_stdio(fd);
1583
1584 r = hashmap_ensure_allocated(&e->inotify_data, &uint64_hash_ops);
1585 if (r < 0)
1586 return r;
1587
1588 d = new(struct inotify_data, 1);
1589 if (!d)
1590 return -ENOMEM;
1591
1592 *d = (struct inotify_data) {
1593 .wakeup = WAKEUP_INOTIFY_DATA,
1594 .fd = TAKE_FD(fd),
1595 .priority = priority,
1596 };
1597
1598 r = hashmap_put(e->inotify_data, &d->priority, d);
1599 if (r < 0) {
1600 d->fd = safe_close(d->fd);
1601 free(d);
1602 return r;
1603 }
1604
1605 ev = (struct epoll_event) {
1606 .events = EPOLLIN,
1607 .data.ptr = d,
1608 };
1609
1610 if (epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, d->fd, &ev) < 0) {
1611 r = -errno;
1612 d->fd = safe_close(d->fd); /* let's close this ourselves, as event_free_inotify_data() would otherwise
1613 * remove the fd from the epoll first, which we don't want as we couldn't
1614 * add it in the first place. */
1615 event_free_inotify_data(e, d);
1616 return r;
1617 }
1618
1619 if (ret)
1620 *ret = d;
1621
1622 return 1;
1623 }
1624
1625 static int inode_data_compare(const void *a, const void *b) {
1626 const struct inode_data *x = a, *y = b;
1627
1628 assert(x);
1629 assert(y);
1630
1631 if (x->dev < y->dev)
1632 return -1;
1633 if (x->dev > y->dev)
1634 return 1;
1635
1636 if (x->ino < y->ino)
1637 return -1;
1638 if (x->ino > y->ino)
1639 return 1;
1640
1641 return 0;
1642 }
1643
1644 static void inode_data_hash_func(const void *p, struct siphash *state) {
1645 const struct inode_data *d = p;
1646
1647 assert(p);
1648
1649 siphash24_compress(&d->dev, sizeof(d->dev), state);
1650 siphash24_compress(&d->ino, sizeof(d->ino), state);
1651 }
1652
1653 const struct hash_ops inode_data_hash_ops = {
1654 .hash = inode_data_hash_func,
1655 .compare = inode_data_compare
1656 };
1657
1658 static void event_free_inode_data(
1659 sd_event *e,
1660 struct inode_data *d) {
1661
1662 assert(e);
1663
1664 if (!d)
1665 return;
1666
1667 assert(!d->event_sources);
1668
1669 if (d->fd >= 0) {
1670 LIST_REMOVE(to_close, e->inode_data_to_close, d);
1671 safe_close(d->fd);
1672 }
1673
1674 if (d->inotify_data) {
1675
1676 if (d->wd >= 0) {
1677 if (d->inotify_data->fd >= 0) {
1678 /* So here's a problem. At the time this runs the watch descriptor might already be
1679 * invalidated, because an IN_IGNORED event might be queued right the moment we enter
1680 * the syscall. Hence, whenever we get EINVAL, ignore it entirely, since it's a very
1681 * likely case to happen. */
1682
1683 if (inotify_rm_watch(d->inotify_data->fd, d->wd) < 0 && errno != EINVAL)
1684 log_debug_errno(errno, "Failed to remove watch descriptor %i from inotify, ignoring: %m", d->wd);
1685 }
1686
1687 assert_se(hashmap_remove(d->inotify_data->wd, INT_TO_PTR(d->wd)) == d);
1688 }
1689
1690 assert_se(hashmap_remove(d->inotify_data->inodes, d) == d);
1691 }
1692
1693 free(d);
1694 }
1695
1696 static void event_gc_inode_data(
1697 sd_event *e,
1698 struct inode_data *d) {
1699
1700 struct inotify_data *inotify_data;
1701
1702 assert(e);
1703
1704 if (!d)
1705 return;
1706
1707 if (d->event_sources)
1708 return;
1709
1710 inotify_data = d->inotify_data;
1711 event_free_inode_data(e, d);
1712
1713 if (inotify_data && hashmap_isempty(inotify_data->inodes))
1714 event_free_inotify_data(e, inotify_data);
1715 }
1716
1717 static int event_make_inode_data(
1718 sd_event *e,
1719 struct inotify_data *inotify_data,
1720 dev_t dev,
1721 ino_t ino,
1722 struct inode_data **ret) {
1723
1724 struct inode_data *d, key;
1725 int r;
1726
1727 assert(e);
1728 assert(inotify_data);
1729
1730 key = (struct inode_data) {
1731 .ino = ino,
1732 .dev = dev,
1733 };
1734
1735 d = hashmap_get(inotify_data->inodes, &key);
1736 if (d) {
1737 if (ret)
1738 *ret = d;
1739
1740 return 0;
1741 }
1742
1743 r = hashmap_ensure_allocated(&inotify_data->inodes, &inode_data_hash_ops);
1744 if (r < 0)
1745 return r;
1746
1747 d = new(struct inode_data, 1);
1748 if (!d)
1749 return -ENOMEM;
1750
1751 *d = (struct inode_data) {
1752 .dev = dev,
1753 .ino = ino,
1754 .wd = -1,
1755 .fd = -1,
1756 .inotify_data = inotify_data,
1757 };
1758
1759 r = hashmap_put(inotify_data->inodes, d, d);
1760 if (r < 0) {
1761 free(d);
1762 return r;
1763 }
1764
1765 if (ret)
1766 *ret = d;
1767
1768 return 1;
1769 }
1770
1771 static uint32_t inode_data_determine_mask(struct inode_data *d) {
1772 bool excl_unlink = true;
1773 uint32_t combined = 0;
1774 sd_event_source *s;
1775
1776 assert(d);
1777
1778 /* Combines the watch masks of all event sources watching this inode. We generally just OR them together, but
1779 * the IN_EXCL_UNLINK flag is ANDed instead.
1780 *
1781 * Note that we add all sources to the mask here, regardless whether enabled, disabled or oneshot. That's
1782 * because we cannot change the mask anymore after the event source was created once, since the kernel has no
1783 * API for that. Hence we need to subscribe to the maximum mask we ever might be interested in, and supress
1784 * events we don't care for client-side. */
1785
1786 LIST_FOREACH(inotify.by_inode_data, s, d->event_sources) {
1787
1788 if ((s->inotify.mask & IN_EXCL_UNLINK) == 0)
1789 excl_unlink = false;
1790
1791 combined |= s->inotify.mask;
1792 }
1793
1794 return (combined & ~(IN_ONESHOT|IN_DONT_FOLLOW|IN_ONLYDIR|IN_EXCL_UNLINK)) | (excl_unlink ? IN_EXCL_UNLINK : 0);
1795 }
1796
1797 static int inode_data_realize_watch(sd_event *e, struct inode_data *d) {
1798 uint32_t combined_mask;
1799 int wd, r;
1800
1801 assert(d);
1802 assert(d->fd >= 0);
1803
1804 combined_mask = inode_data_determine_mask(d);
1805
1806 if (d->wd >= 0 && combined_mask == d->combined_mask)
1807 return 0;
1808
1809 r = hashmap_ensure_allocated(&d->inotify_data->wd, NULL);
1810 if (r < 0)
1811 return r;
1812
1813 wd = inotify_add_watch_fd(d->inotify_data->fd, d->fd, combined_mask);
1814 if (wd < 0)
1815 return -errno;
1816
1817 if (d->wd < 0) {
1818 r = hashmap_put(d->inotify_data->wd, INT_TO_PTR(wd), d);
1819 if (r < 0) {
1820 (void) inotify_rm_watch(d->inotify_data->fd, wd);
1821 return r;
1822 }
1823
1824 d->wd = wd;
1825
1826 } else if (d->wd != wd) {
1827
1828 log_debug("Weird, the watch descriptor we already knew for this inode changed?");
1829 (void) inotify_rm_watch(d->fd, wd);
1830 return -EINVAL;
1831 }
1832
1833 d->combined_mask = combined_mask;
1834 return 1;
1835 }
1836
1837 _public_ int sd_event_add_inotify(
1838 sd_event *e,
1839 sd_event_source **ret,
1840 const char *path,
1841 uint32_t mask,
1842 sd_event_inotify_handler_t callback,
1843 void *userdata) {
1844
1845 bool rm_inotify = false, rm_inode = false;
1846 struct inotify_data *inotify_data = NULL;
1847 struct inode_data *inode_data = NULL;
1848 _cleanup_close_ int fd = -1;
1849 sd_event_source *s;
1850 struct stat st;
1851 int r;
1852
1853 assert_return(e, -EINVAL);
1854 assert_return(e = event_resolve(e), -ENOPKG);
1855 assert_return(path, -EINVAL);
1856 assert_return(callback, -EINVAL);
1857 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
1858 assert_return(!event_pid_changed(e), -ECHILD);
1859
1860 /* Refuse IN_MASK_ADD since we coalesce watches on the same inode, and hence really don't want to merge
1861 * masks. Or in other words, this whole code exists only to manage IN_MASK_ADD type operations for you, hence
1862 * the user can't use them for us. */
1863 if (mask & IN_MASK_ADD)
1864 return -EINVAL;
1865
1866 fd = open(path, O_PATH|O_CLOEXEC|
1867 (mask & IN_ONLYDIR ? O_DIRECTORY : 0)|
1868 (mask & IN_DONT_FOLLOW ? O_NOFOLLOW : 0));
1869 if (fd < 0)
1870 return -errno;
1871
1872 if (fstat(fd, &st) < 0)
1873 return -errno;
1874
1875 s = source_new(e, !ret, SOURCE_INOTIFY);
1876 if (!s)
1877 return -ENOMEM;
1878
1879 s->enabled = mask & IN_ONESHOT ? SD_EVENT_ONESHOT : SD_EVENT_ON;
1880 s->inotify.mask = mask;
1881 s->inotify.callback = callback;
1882 s->userdata = userdata;
1883
1884 /* Allocate an inotify object for this priority, and an inode object within it */
1885 r = event_make_inotify_data(e, SD_EVENT_PRIORITY_NORMAL, &inotify_data);
1886 if (r < 0)
1887 goto fail;
1888 rm_inotify = r > 0;
1889
1890 r = event_make_inode_data(e, inotify_data, st.st_dev, st.st_ino, &inode_data);
1891 if (r < 0)
1892 goto fail;
1893 rm_inode = r > 0;
1894
1895 /* Keep the O_PATH fd around until the first iteration of the loop, so that we can still change the priority of
1896 * the event source, until then, for which we need the original inode. */
1897 if (inode_data->fd < 0) {
1898 inode_data->fd = TAKE_FD(fd);
1899 LIST_PREPEND(to_close, e->inode_data_to_close, inode_data);
1900 }
1901
1902 /* Link our event source to the inode data object */
1903 LIST_PREPEND(inotify.by_inode_data, inode_data->event_sources, s);
1904 s->inotify.inode_data = inode_data;
1905
1906 rm_inode = rm_inotify = false;
1907
1908 /* Actually realize the watch now */
1909 r = inode_data_realize_watch(e, inode_data);
1910 if (r < 0)
1911 goto fail;
1912
1913 (void) sd_event_source_set_description(s, path);
1914
1915 if (ret)
1916 *ret = s;
1917
1918 return 0;
1919
1920 fail:
1921 source_free(s);
1922
1923 if (rm_inode)
1924 event_free_inode_data(e, inode_data);
1925
1926 if (rm_inotify)
1927 event_free_inotify_data(e, inotify_data);
1928
1929 return r;
1930 }
1931
1932 _public_ sd_event_source* sd_event_source_ref(sd_event_source *s) {
1933
1934 if (!s)
1935 return NULL;
1936
1937 assert(s->n_ref >= 1);
1938 s->n_ref++;
1939
1940 return s;
1941 }
1942
1943 _public_ sd_event_source* sd_event_source_unref(sd_event_source *s) {
1944
1945 if (!s)
1946 return NULL;
1947
1948 assert(s->n_ref >= 1);
1949 s->n_ref--;
1950
1951 if (s->n_ref <= 0) {
1952 /* Here's a special hack: when we are called from a
1953 * dispatch handler we won't free the event source
1954 * immediately, but we will detach the fd from the
1955 * epoll. This way it is safe for the caller to unref
1956 * the event source and immediately close the fd, but
1957 * we still retain a valid event source object after
1958 * the callback. */
1959
1960 if (s->dispatching) {
1961 if (s->type == SOURCE_IO)
1962 source_io_unregister(s);
1963
1964 source_disconnect(s);
1965 } else
1966 source_free(s);
1967 }
1968
1969 return NULL;
1970 }
1971
1972 _public_ int sd_event_source_set_description(sd_event_source *s, const char *description) {
1973 assert_return(s, -EINVAL);
1974 assert_return(!event_pid_changed(s->event), -ECHILD);
1975
1976 return free_and_strdup(&s->description, description);
1977 }
1978
1979 _public_ int sd_event_source_get_description(sd_event_source *s, const char **description) {
1980 assert_return(s, -EINVAL);
1981 assert_return(description, -EINVAL);
1982 assert_return(s->description, -ENXIO);
1983 assert_return(!event_pid_changed(s->event), -ECHILD);
1984
1985 *description = s->description;
1986 return 0;
1987 }
1988
1989 _public_ sd_event *sd_event_source_get_event(sd_event_source *s) {
1990 assert_return(s, NULL);
1991
1992 return s->event;
1993 }
1994
1995 _public_ int sd_event_source_get_pending(sd_event_source *s) {
1996 assert_return(s, -EINVAL);
1997 assert_return(s->type != SOURCE_EXIT, -EDOM);
1998 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
1999 assert_return(!event_pid_changed(s->event), -ECHILD);
2000
2001 return s->pending;
2002 }
2003
2004 _public_ int sd_event_source_get_io_fd(sd_event_source *s) {
2005 assert_return(s, -EINVAL);
2006 assert_return(s->type == SOURCE_IO, -EDOM);
2007 assert_return(!event_pid_changed(s->event), -ECHILD);
2008
2009 return s->io.fd;
2010 }
2011
2012 _public_ int sd_event_source_set_io_fd(sd_event_source *s, int fd) {
2013 int r;
2014
2015 assert_return(s, -EINVAL);
2016 assert_return(fd >= 0, -EBADF);
2017 assert_return(s->type == SOURCE_IO, -EDOM);
2018 assert_return(!event_pid_changed(s->event), -ECHILD);
2019
2020 if (s->io.fd == fd)
2021 return 0;
2022
2023 if (s->enabled == SD_EVENT_OFF) {
2024 s->io.fd = fd;
2025 s->io.registered = false;
2026 } else {
2027 int saved_fd;
2028
2029 saved_fd = s->io.fd;
2030 assert(s->io.registered);
2031
2032 s->io.fd = fd;
2033 s->io.registered = false;
2034
2035 r = source_io_register(s, s->enabled, s->io.events);
2036 if (r < 0) {
2037 s->io.fd = saved_fd;
2038 s->io.registered = true;
2039 return r;
2040 }
2041
2042 epoll_ctl(s->event->epoll_fd, EPOLL_CTL_DEL, saved_fd, NULL);
2043 }
2044
2045 return 0;
2046 }
2047
2048 _public_ int sd_event_source_get_io_fd_own(sd_event_source *s) {
2049 assert_return(s, -EINVAL);
2050 assert_return(s->type == SOURCE_IO, -EDOM);
2051
2052 return s->io.owned;
2053 }
2054
2055 _public_ int sd_event_source_set_io_fd_own(sd_event_source *s, int own) {
2056 assert_return(s, -EINVAL);
2057 assert_return(s->type == SOURCE_IO, -EDOM);
2058
2059 s->io.owned = own;
2060 return 0;
2061 }
2062
2063 _public_ int sd_event_source_get_io_events(sd_event_source *s, uint32_t* events) {
2064 assert_return(s, -EINVAL);
2065 assert_return(events, -EINVAL);
2066 assert_return(s->type == SOURCE_IO, -EDOM);
2067 assert_return(!event_pid_changed(s->event), -ECHILD);
2068
2069 *events = s->io.events;
2070 return 0;
2071 }
2072
2073 _public_ int sd_event_source_set_io_events(sd_event_source *s, uint32_t events) {
2074 int r;
2075
2076 assert_return(s, -EINVAL);
2077 assert_return(s->type == SOURCE_IO, -EDOM);
2078 assert_return(!(events & ~(EPOLLIN|EPOLLOUT|EPOLLRDHUP|EPOLLPRI|EPOLLERR|EPOLLHUP|EPOLLET)), -EINVAL);
2079 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
2080 assert_return(!event_pid_changed(s->event), -ECHILD);
2081
2082 /* edge-triggered updates are never skipped, so we can reset edges */
2083 if (s->io.events == events && !(events & EPOLLET))
2084 return 0;
2085
2086 r = source_set_pending(s, false);
2087 if (r < 0)
2088 return r;
2089
2090 if (s->enabled != SD_EVENT_OFF) {
2091 r = source_io_register(s, s->enabled, events);
2092 if (r < 0)
2093 return r;
2094 }
2095
2096 s->io.events = events;
2097
2098 return 0;
2099 }
2100
2101 _public_ int sd_event_source_get_io_revents(sd_event_source *s, uint32_t* revents) {
2102 assert_return(s, -EINVAL);
2103 assert_return(revents, -EINVAL);
2104 assert_return(s->type == SOURCE_IO, -EDOM);
2105 assert_return(s->pending, -ENODATA);
2106 assert_return(!event_pid_changed(s->event), -ECHILD);
2107
2108 *revents = s->io.revents;
2109 return 0;
2110 }
2111
2112 _public_ int sd_event_source_get_signal(sd_event_source *s) {
2113 assert_return(s, -EINVAL);
2114 assert_return(s->type == SOURCE_SIGNAL, -EDOM);
2115 assert_return(!event_pid_changed(s->event), -ECHILD);
2116
2117 return s->signal.sig;
2118 }
2119
2120 _public_ int sd_event_source_get_priority(sd_event_source *s, int64_t *priority) {
2121 assert_return(s, -EINVAL);
2122 assert_return(!event_pid_changed(s->event), -ECHILD);
2123
2124 *priority = s->priority;
2125 return 0;
2126 }
2127
2128 _public_ int sd_event_source_set_priority(sd_event_source *s, int64_t priority) {
2129 bool rm_inotify = false, rm_inode = false;
2130 struct inotify_data *new_inotify_data = NULL;
2131 struct inode_data *new_inode_data = NULL;
2132 int r;
2133
2134 assert_return(s, -EINVAL);
2135 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
2136 assert_return(!event_pid_changed(s->event), -ECHILD);
2137
2138 if (s->priority == priority)
2139 return 0;
2140
2141 if (s->type == SOURCE_INOTIFY) {
2142 struct inode_data *old_inode_data;
2143
2144 assert(s->inotify.inode_data);
2145 old_inode_data = s->inotify.inode_data;
2146
2147 /* We need the original fd to change the priority. If we don't have it we can't change the priority,
2148 * anymore. Note that we close any fds when entering the next event loop iteration, i.e. for inotify
2149 * events we allow priority changes only until the first following iteration. */
2150 if (old_inode_data->fd < 0)
2151 return -EOPNOTSUPP;
2152
2153 r = event_make_inotify_data(s->event, priority, &new_inotify_data);
2154 if (r < 0)
2155 return r;
2156 rm_inotify = r > 0;
2157
2158 r = event_make_inode_data(s->event, new_inotify_data, old_inode_data->dev, old_inode_data->ino, &new_inode_data);
2159 if (r < 0)
2160 goto fail;
2161 rm_inode = r > 0;
2162
2163 if (new_inode_data->fd < 0) {
2164 /* Duplicate the fd for the new inode object if we don't have any yet */
2165 new_inode_data->fd = fcntl(old_inode_data->fd, F_DUPFD_CLOEXEC, 3);
2166 if (new_inode_data->fd < 0) {
2167 r = -errno;
2168 goto fail;
2169 }
2170
2171 LIST_PREPEND(to_close, s->event->inode_data_to_close, new_inode_data);
2172 }
2173
2174 /* Move the event source to the new inode data structure */
2175 LIST_REMOVE(inotify.by_inode_data, old_inode_data->event_sources, s);
2176 LIST_PREPEND(inotify.by_inode_data, new_inode_data->event_sources, s);
2177 s->inotify.inode_data = new_inode_data;
2178
2179 /* Now create the new watch */
2180 r = inode_data_realize_watch(s->event, new_inode_data);
2181 if (r < 0) {
2182 /* Move it back */
2183 LIST_REMOVE(inotify.by_inode_data, new_inode_data->event_sources, s);
2184 LIST_PREPEND(inotify.by_inode_data, old_inode_data->event_sources, s);
2185 s->inotify.inode_data = old_inode_data;
2186 goto fail;
2187 }
2188
2189 s->priority = priority;
2190
2191 event_gc_inode_data(s->event, old_inode_data);
2192
2193 } else if (s->type == SOURCE_SIGNAL && s->enabled != SD_EVENT_OFF) {
2194 struct signal_data *old, *d;
2195
2196 /* Move us from the signalfd belonging to the old
2197 * priority to the signalfd of the new priority */
2198
2199 assert_se(old = hashmap_get(s->event->signal_data, &s->priority));
2200
2201 s->priority = priority;
2202
2203 r = event_make_signal_data(s->event, s->signal.sig, &d);
2204 if (r < 0) {
2205 s->priority = old->priority;
2206 return r;
2207 }
2208
2209 event_unmask_signal_data(s->event, old, s->signal.sig);
2210 } else
2211 s->priority = priority;
2212
2213 if (s->pending)
2214 prioq_reshuffle(s->event->pending, s, &s->pending_index);
2215
2216 if (s->prepare)
2217 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
2218
2219 if (s->type == SOURCE_EXIT)
2220 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
2221
2222 return 0;
2223
2224 fail:
2225 if (rm_inode)
2226 event_free_inode_data(s->event, new_inode_data);
2227
2228 if (rm_inotify)
2229 event_free_inotify_data(s->event, new_inotify_data);
2230
2231 return r;
2232 }
2233
2234 _public_ int sd_event_source_get_enabled(sd_event_source *s, int *m) {
2235 assert_return(s, -EINVAL);
2236 assert_return(m, -EINVAL);
2237 assert_return(!event_pid_changed(s->event), -ECHILD);
2238
2239 *m = s->enabled;
2240 return 0;
2241 }
2242
2243 _public_ int sd_event_source_set_enabled(sd_event_source *s, int m) {
2244 int r;
2245
2246 assert_return(s, -EINVAL);
2247 assert_return(IN_SET(m, SD_EVENT_OFF, SD_EVENT_ON, SD_EVENT_ONESHOT), -EINVAL);
2248 assert_return(!event_pid_changed(s->event), -ECHILD);
2249
2250 /* If we are dead anyway, we are fine with turning off
2251 * sources, but everything else needs to fail. */
2252 if (s->event->state == SD_EVENT_FINISHED)
2253 return m == SD_EVENT_OFF ? 0 : -ESTALE;
2254
2255 if (s->enabled == m)
2256 return 0;
2257
2258 if (m == SD_EVENT_OFF) {
2259
2260 /* Unset the pending flag when this event source is disabled */
2261 if (!IN_SET(s->type, SOURCE_DEFER, SOURCE_EXIT)) {
2262 r = source_set_pending(s, false);
2263 if (r < 0)
2264 return r;
2265 }
2266
2267 switch (s->type) {
2268
2269 case SOURCE_IO:
2270 source_io_unregister(s);
2271 s->enabled = m;
2272 break;
2273
2274 case SOURCE_TIME_REALTIME:
2275 case SOURCE_TIME_BOOTTIME:
2276 case SOURCE_TIME_MONOTONIC:
2277 case SOURCE_TIME_REALTIME_ALARM:
2278 case SOURCE_TIME_BOOTTIME_ALARM: {
2279 struct clock_data *d;
2280
2281 s->enabled = m;
2282 d = event_get_clock_data(s->event, s->type);
2283 assert(d);
2284
2285 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2286 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2287 d->needs_rearm = true;
2288 break;
2289 }
2290
2291 case SOURCE_SIGNAL:
2292 s->enabled = m;
2293
2294 event_gc_signal_data(s->event, &s->priority, s->signal.sig);
2295 break;
2296
2297 case SOURCE_CHILD:
2298 s->enabled = m;
2299
2300 assert(s->event->n_enabled_child_sources > 0);
2301 s->event->n_enabled_child_sources--;
2302
2303 event_gc_signal_data(s->event, &s->priority, SIGCHLD);
2304 break;
2305
2306 case SOURCE_EXIT:
2307 s->enabled = m;
2308 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
2309 break;
2310
2311 case SOURCE_DEFER:
2312 case SOURCE_POST:
2313 case SOURCE_INOTIFY:
2314 s->enabled = m;
2315 break;
2316
2317 default:
2318 assert_not_reached("Wut? I shouldn't exist.");
2319 }
2320
2321 } else {
2322
2323 /* Unset the pending flag when this event source is enabled */
2324 if (s->enabled == SD_EVENT_OFF && !IN_SET(s->type, SOURCE_DEFER, SOURCE_EXIT)) {
2325 r = source_set_pending(s, false);
2326 if (r < 0)
2327 return r;
2328 }
2329
2330 switch (s->type) {
2331
2332 case SOURCE_IO:
2333 r = source_io_register(s, m, s->io.events);
2334 if (r < 0)
2335 return r;
2336
2337 s->enabled = m;
2338 break;
2339
2340 case SOURCE_TIME_REALTIME:
2341 case SOURCE_TIME_BOOTTIME:
2342 case SOURCE_TIME_MONOTONIC:
2343 case SOURCE_TIME_REALTIME_ALARM:
2344 case SOURCE_TIME_BOOTTIME_ALARM: {
2345 struct clock_data *d;
2346
2347 s->enabled = m;
2348 d = event_get_clock_data(s->event, s->type);
2349 assert(d);
2350
2351 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2352 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2353 d->needs_rearm = true;
2354 break;
2355 }
2356
2357 case SOURCE_SIGNAL:
2358
2359 s->enabled = m;
2360
2361 r = event_make_signal_data(s->event, s->signal.sig, NULL);
2362 if (r < 0) {
2363 s->enabled = SD_EVENT_OFF;
2364 event_gc_signal_data(s->event, &s->priority, s->signal.sig);
2365 return r;
2366 }
2367
2368 break;
2369
2370 case SOURCE_CHILD:
2371
2372 if (s->enabled == SD_EVENT_OFF)
2373 s->event->n_enabled_child_sources++;
2374
2375 s->enabled = m;
2376
2377 r = event_make_signal_data(s->event, SIGCHLD, NULL);
2378 if (r < 0) {
2379 s->enabled = SD_EVENT_OFF;
2380 s->event->n_enabled_child_sources--;
2381 event_gc_signal_data(s->event, &s->priority, SIGCHLD);
2382 return r;
2383 }
2384
2385 break;
2386
2387 case SOURCE_EXIT:
2388 s->enabled = m;
2389 prioq_reshuffle(s->event->exit, s, &s->exit.prioq_index);
2390 break;
2391
2392 case SOURCE_DEFER:
2393 case SOURCE_POST:
2394 case SOURCE_INOTIFY:
2395 s->enabled = m;
2396 break;
2397
2398 default:
2399 assert_not_reached("Wut? I shouldn't exist.");
2400 }
2401 }
2402
2403 if (s->pending)
2404 prioq_reshuffle(s->event->pending, s, &s->pending_index);
2405
2406 if (s->prepare)
2407 prioq_reshuffle(s->event->prepare, s, &s->prepare_index);
2408
2409 return 0;
2410 }
2411
2412 _public_ int sd_event_source_get_time(sd_event_source *s, uint64_t *usec) {
2413 assert_return(s, -EINVAL);
2414 assert_return(usec, -EINVAL);
2415 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
2416 assert_return(!event_pid_changed(s->event), -ECHILD);
2417
2418 *usec = s->time.next;
2419 return 0;
2420 }
2421
2422 _public_ int sd_event_source_set_time(sd_event_source *s, uint64_t usec) {
2423 struct clock_data *d;
2424 int r;
2425
2426 assert_return(s, -EINVAL);
2427 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
2428 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
2429 assert_return(!event_pid_changed(s->event), -ECHILD);
2430
2431 r = source_set_pending(s, false);
2432 if (r < 0)
2433 return r;
2434
2435 s->time.next = usec;
2436
2437 d = event_get_clock_data(s->event, s->type);
2438 assert(d);
2439
2440 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2441 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2442 d->needs_rearm = true;
2443
2444 return 0;
2445 }
2446
2447 _public_ int sd_event_source_get_time_accuracy(sd_event_source *s, uint64_t *usec) {
2448 assert_return(s, -EINVAL);
2449 assert_return(usec, -EINVAL);
2450 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
2451 assert_return(!event_pid_changed(s->event), -ECHILD);
2452
2453 *usec = s->time.accuracy;
2454 return 0;
2455 }
2456
2457 _public_ int sd_event_source_set_time_accuracy(sd_event_source *s, uint64_t usec) {
2458 struct clock_data *d;
2459 int r;
2460
2461 assert_return(s, -EINVAL);
2462 assert_return(usec != (uint64_t) -1, -EINVAL);
2463 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
2464 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
2465 assert_return(!event_pid_changed(s->event), -ECHILD);
2466
2467 r = source_set_pending(s, false);
2468 if (r < 0)
2469 return r;
2470
2471 if (usec == 0)
2472 usec = DEFAULT_ACCURACY_USEC;
2473
2474 s->time.accuracy = usec;
2475
2476 d = event_get_clock_data(s->event, s->type);
2477 assert(d);
2478
2479 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2480 d->needs_rearm = true;
2481
2482 return 0;
2483 }
2484
2485 _public_ int sd_event_source_get_time_clock(sd_event_source *s, clockid_t *clock) {
2486 assert_return(s, -EINVAL);
2487 assert_return(clock, -EINVAL);
2488 assert_return(EVENT_SOURCE_IS_TIME(s->type), -EDOM);
2489 assert_return(!event_pid_changed(s->event), -ECHILD);
2490
2491 *clock = event_source_type_to_clock(s->type);
2492 return 0;
2493 }
2494
2495 _public_ int sd_event_source_get_child_pid(sd_event_source *s, pid_t *pid) {
2496 assert_return(s, -EINVAL);
2497 assert_return(pid, -EINVAL);
2498 assert_return(s->type == SOURCE_CHILD, -EDOM);
2499 assert_return(!event_pid_changed(s->event), -ECHILD);
2500
2501 *pid = s->child.pid;
2502 return 0;
2503 }
2504
2505 _public_ int sd_event_source_get_inotify_mask(sd_event_source *s, uint32_t *mask) {
2506 assert_return(s, -EINVAL);
2507 assert_return(mask, -EINVAL);
2508 assert_return(s->type == SOURCE_INOTIFY, -EDOM);
2509 assert_return(!event_pid_changed(s->event), -ECHILD);
2510
2511 *mask = s->inotify.mask;
2512 return 0;
2513 }
2514
2515 _public_ int sd_event_source_set_prepare(sd_event_source *s, sd_event_handler_t callback) {
2516 int r;
2517
2518 assert_return(s, -EINVAL);
2519 assert_return(s->type != SOURCE_EXIT, -EDOM);
2520 assert_return(s->event->state != SD_EVENT_FINISHED, -ESTALE);
2521 assert_return(!event_pid_changed(s->event), -ECHILD);
2522
2523 if (s->prepare == callback)
2524 return 0;
2525
2526 if (callback && s->prepare) {
2527 s->prepare = callback;
2528 return 0;
2529 }
2530
2531 r = prioq_ensure_allocated(&s->event->prepare, prepare_prioq_compare);
2532 if (r < 0)
2533 return r;
2534
2535 s->prepare = callback;
2536
2537 if (callback) {
2538 r = prioq_put(s->event->prepare, s, &s->prepare_index);
2539 if (r < 0)
2540 return r;
2541 } else
2542 prioq_remove(s->event->prepare, s, &s->prepare_index);
2543
2544 return 0;
2545 }
2546
2547 _public_ void* sd_event_source_get_userdata(sd_event_source *s) {
2548 assert_return(s, NULL);
2549
2550 return s->userdata;
2551 }
2552
2553 _public_ void *sd_event_source_set_userdata(sd_event_source *s, void *userdata) {
2554 void *ret;
2555
2556 assert_return(s, NULL);
2557
2558 ret = s->userdata;
2559 s->userdata = userdata;
2560
2561 return ret;
2562 }
2563
2564 static usec_t sleep_between(sd_event *e, usec_t a, usec_t b) {
2565 usec_t c;
2566 assert(e);
2567 assert(a <= b);
2568
2569 if (a <= 0)
2570 return 0;
2571 if (a >= USEC_INFINITY)
2572 return USEC_INFINITY;
2573
2574 if (b <= a + 1)
2575 return a;
2576
2577 initialize_perturb(e);
2578
2579 /*
2580 Find a good time to wake up again between times a and b. We
2581 have two goals here:
2582
2583 a) We want to wake up as seldom as possible, hence prefer
2584 later times over earlier times.
2585
2586 b) But if we have to wake up, then let's make sure to
2587 dispatch as much as possible on the entire system.
2588
2589 We implement this by waking up everywhere at the same time
2590 within any given minute if we can, synchronised via the
2591 perturbation value determined from the boot ID. If we can't,
2592 then we try to find the same spot in every 10s, then 1s and
2593 then 250ms step. Otherwise, we pick the last possible time
2594 to wake up.
2595 */
2596
2597 c = (b / USEC_PER_MINUTE) * USEC_PER_MINUTE + e->perturb;
2598 if (c >= b) {
2599 if (_unlikely_(c < USEC_PER_MINUTE))
2600 return b;
2601
2602 c -= USEC_PER_MINUTE;
2603 }
2604
2605 if (c >= a)
2606 return c;
2607
2608 c = (b / (USEC_PER_SEC*10)) * (USEC_PER_SEC*10) + (e->perturb % (USEC_PER_SEC*10));
2609 if (c >= b) {
2610 if (_unlikely_(c < USEC_PER_SEC*10))
2611 return b;
2612
2613 c -= USEC_PER_SEC*10;
2614 }
2615
2616 if (c >= a)
2617 return c;
2618
2619 c = (b / USEC_PER_SEC) * USEC_PER_SEC + (e->perturb % USEC_PER_SEC);
2620 if (c >= b) {
2621 if (_unlikely_(c < USEC_PER_SEC))
2622 return b;
2623
2624 c -= USEC_PER_SEC;
2625 }
2626
2627 if (c >= a)
2628 return c;
2629
2630 c = (b / (USEC_PER_MSEC*250)) * (USEC_PER_MSEC*250) + (e->perturb % (USEC_PER_MSEC*250));
2631 if (c >= b) {
2632 if (_unlikely_(c < USEC_PER_MSEC*250))
2633 return b;
2634
2635 c -= USEC_PER_MSEC*250;
2636 }
2637
2638 if (c >= a)
2639 return c;
2640
2641 return b;
2642 }
2643
2644 static int event_arm_timer(
2645 sd_event *e,
2646 struct clock_data *d) {
2647
2648 struct itimerspec its = {};
2649 sd_event_source *a, *b;
2650 usec_t t;
2651 int r;
2652
2653 assert(e);
2654 assert(d);
2655
2656 if (!d->needs_rearm)
2657 return 0;
2658 else
2659 d->needs_rearm = false;
2660
2661 a = prioq_peek(d->earliest);
2662 if (!a || a->enabled == SD_EVENT_OFF || a->time.next == USEC_INFINITY) {
2663
2664 if (d->fd < 0)
2665 return 0;
2666
2667 if (d->next == USEC_INFINITY)
2668 return 0;
2669
2670 /* disarm */
2671 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2672 if (r < 0)
2673 return r;
2674
2675 d->next = USEC_INFINITY;
2676 return 0;
2677 }
2678
2679 b = prioq_peek(d->latest);
2680 assert_se(b && b->enabled != SD_EVENT_OFF);
2681
2682 t = sleep_between(e, a->time.next, time_event_source_latest(b));
2683 if (d->next == t)
2684 return 0;
2685
2686 assert_se(d->fd >= 0);
2687
2688 if (t == 0) {
2689 /* We don' want to disarm here, just mean some time looooong ago. */
2690 its.it_value.tv_sec = 0;
2691 its.it_value.tv_nsec = 1;
2692 } else
2693 timespec_store(&its.it_value, t);
2694
2695 r = timerfd_settime(d->fd, TFD_TIMER_ABSTIME, &its, NULL);
2696 if (r < 0)
2697 return -errno;
2698
2699 d->next = t;
2700 return 0;
2701 }
2702
2703 static int process_io(sd_event *e, sd_event_source *s, uint32_t revents) {
2704 assert(e);
2705 assert(s);
2706 assert(s->type == SOURCE_IO);
2707
2708 /* If the event source was already pending, we just OR in the
2709 * new revents, otherwise we reset the value. The ORing is
2710 * necessary to handle EPOLLONESHOT events properly where
2711 * readability might happen independently of writability, and
2712 * we need to keep track of both */
2713
2714 if (s->pending)
2715 s->io.revents |= revents;
2716 else
2717 s->io.revents = revents;
2718
2719 return source_set_pending(s, true);
2720 }
2721
2722 static int flush_timer(sd_event *e, int fd, uint32_t events, usec_t *next) {
2723 uint64_t x;
2724 ssize_t ss;
2725
2726 assert(e);
2727 assert(fd >= 0);
2728
2729 assert_return(events == EPOLLIN, -EIO);
2730
2731 ss = read(fd, &x, sizeof(x));
2732 if (ss < 0) {
2733 if (IN_SET(errno, EAGAIN, EINTR))
2734 return 0;
2735
2736 return -errno;
2737 }
2738
2739 if (_unlikely_(ss != sizeof(x)))
2740 return -EIO;
2741
2742 if (next)
2743 *next = USEC_INFINITY;
2744
2745 return 0;
2746 }
2747
2748 static int process_timer(
2749 sd_event *e,
2750 usec_t n,
2751 struct clock_data *d) {
2752
2753 sd_event_source *s;
2754 int r;
2755
2756 assert(e);
2757 assert(d);
2758
2759 for (;;) {
2760 s = prioq_peek(d->earliest);
2761 if (!s ||
2762 s->time.next > n ||
2763 s->enabled == SD_EVENT_OFF ||
2764 s->pending)
2765 break;
2766
2767 r = source_set_pending(s, true);
2768 if (r < 0)
2769 return r;
2770
2771 prioq_reshuffle(d->earliest, s, &s->time.earliest_index);
2772 prioq_reshuffle(d->latest, s, &s->time.latest_index);
2773 d->needs_rearm = true;
2774 }
2775
2776 return 0;
2777 }
2778
2779 static int process_child(sd_event *e) {
2780 sd_event_source *s;
2781 Iterator i;
2782 int r;
2783
2784 assert(e);
2785
2786 e->need_process_child = false;
2787
2788 /*
2789 So, this is ugly. We iteratively invoke waitid() with P_PID
2790 + WNOHANG for each PID we wait for, instead of using
2791 P_ALL. This is because we only want to get child
2792 information of very specific child processes, and not all
2793 of them. We might not have processed the SIGCHLD even of a
2794 previous invocation and we don't want to maintain a
2795 unbounded *per-child* event queue, hence we really don't
2796 want anything flushed out of the kernel's queue that we
2797 don't care about. Since this is O(n) this means that if you
2798 have a lot of processes you probably want to handle SIGCHLD
2799 yourself.
2800
2801 We do not reap the children here (by using WNOWAIT), this
2802 is only done after the event source is dispatched so that
2803 the callback still sees the process as a zombie.
2804 */
2805
2806 HASHMAP_FOREACH(s, e->child_sources, i) {
2807 assert(s->type == SOURCE_CHILD);
2808
2809 if (s->pending)
2810 continue;
2811
2812 if (s->enabled == SD_EVENT_OFF)
2813 continue;
2814
2815 zero(s->child.siginfo);
2816 r = waitid(P_PID, s->child.pid, &s->child.siginfo,
2817 WNOHANG | (s->child.options & WEXITED ? WNOWAIT : 0) | s->child.options);
2818 if (r < 0)
2819 return -errno;
2820
2821 if (s->child.siginfo.si_pid != 0) {
2822 bool zombie = IN_SET(s->child.siginfo.si_code, CLD_EXITED, CLD_KILLED, CLD_DUMPED);
2823
2824 if (!zombie && (s->child.options & WEXITED)) {
2825 /* If the child isn't dead then let's
2826 * immediately remove the state change
2827 * from the queue, since there's no
2828 * benefit in leaving it queued */
2829
2830 assert(s->child.options & (WSTOPPED|WCONTINUED));
2831 waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|(s->child.options & (WSTOPPED|WCONTINUED)));
2832 }
2833
2834 r = source_set_pending(s, true);
2835 if (r < 0)
2836 return r;
2837 }
2838 }
2839
2840 return 0;
2841 }
2842
2843 static int process_signal(sd_event *e, struct signal_data *d, uint32_t events) {
2844 bool read_one = false;
2845 int r;
2846
2847 assert(e);
2848 assert(d);
2849 assert_return(events == EPOLLIN, -EIO);
2850
2851 /* If there's a signal queued on this priority and SIGCHLD is
2852 on this priority too, then make sure to recheck the
2853 children we watch. This is because we only ever dequeue
2854 the first signal per priority, and if we dequeue one, and
2855 SIGCHLD might be enqueued later we wouldn't know, but we
2856 might have higher priority children we care about hence we
2857 need to check that explicitly. */
2858
2859 if (sigismember(&d->sigset, SIGCHLD))
2860 e->need_process_child = true;
2861
2862 /* If there's already an event source pending for this
2863 * priority we don't read another */
2864 if (d->current)
2865 return 0;
2866
2867 for (;;) {
2868 struct signalfd_siginfo si;
2869 ssize_t n;
2870 sd_event_source *s = NULL;
2871
2872 n = read(d->fd, &si, sizeof(si));
2873 if (n < 0) {
2874 if (IN_SET(errno, EAGAIN, EINTR))
2875 return read_one;
2876
2877 return -errno;
2878 }
2879
2880 if (_unlikely_(n != sizeof(si)))
2881 return -EIO;
2882
2883 assert(SIGNAL_VALID(si.ssi_signo));
2884
2885 read_one = true;
2886
2887 if (e->signal_sources)
2888 s = e->signal_sources[si.ssi_signo];
2889 if (!s)
2890 continue;
2891 if (s->pending)
2892 continue;
2893
2894 s->signal.siginfo = si;
2895 d->current = s;
2896
2897 r = source_set_pending(s, true);
2898 if (r < 0)
2899 return r;
2900
2901 return 1;
2902 }
2903 }
2904
2905 static int event_inotify_data_read(sd_event *e, struct inotify_data *d, uint32_t revents) {
2906 ssize_t n;
2907
2908 assert(e);
2909 assert(d);
2910
2911 assert_return(revents == EPOLLIN, -EIO);
2912
2913 /* If there's already an event source pending for this priority, don't read another */
2914 if (d->n_pending > 0)
2915 return 0;
2916
2917 /* Is the read buffer non-empty? If so, let's not read more */
2918 if (d->buffer_filled > 0)
2919 return 0;
2920
2921 n = read(d->fd, &d->buffer, sizeof(d->buffer));
2922 if (n < 0) {
2923 if (IN_SET(errno, EAGAIN, EINTR))
2924 return 0;
2925
2926 return -errno;
2927 }
2928
2929 assert(n > 0);
2930 d->buffer_filled = (size_t) n;
2931 LIST_PREPEND(buffered, e->inotify_data_buffered, d);
2932
2933 return 1;
2934 }
2935
2936 static void event_inotify_data_drop(sd_event *e, struct inotify_data *d, size_t sz) {
2937 assert(e);
2938 assert(d);
2939 assert(sz <= d->buffer_filled);
2940
2941 if (sz == 0)
2942 return;
2943
2944 /* Move the rest to the buffer to the front, in order to get things properly aligned again */
2945 memmove(d->buffer.raw, d->buffer.raw + sz, d->buffer_filled - sz);
2946 d->buffer_filled -= sz;
2947
2948 if (d->buffer_filled == 0)
2949 LIST_REMOVE(buffered, e->inotify_data_buffered, d);
2950 }
2951
2952 static int event_inotify_data_process(sd_event *e, struct inotify_data *d) {
2953 int r;
2954
2955 assert(e);
2956 assert(d);
2957
2958 /* If there's already an event source pending for this priority, don't read another */
2959 if (d->n_pending > 0)
2960 return 0;
2961
2962 while (d->buffer_filled > 0) {
2963 size_t sz;
2964
2965 /* Let's validate that the event structures are complete */
2966 if (d->buffer_filled < offsetof(struct inotify_event, name))
2967 return -EIO;
2968
2969 sz = offsetof(struct inotify_event, name) + d->buffer.ev.len;
2970 if (d->buffer_filled < sz)
2971 return -EIO;
2972
2973 if (d->buffer.ev.mask & IN_Q_OVERFLOW) {
2974 struct inode_data *inode_data;
2975 Iterator i;
2976
2977 /* The queue overran, let's pass this event to all event sources connected to this inotify
2978 * object */
2979
2980 HASHMAP_FOREACH(inode_data, d->inodes, i) {
2981 sd_event_source *s;
2982
2983 LIST_FOREACH(inotify.by_inode_data, s, inode_data->event_sources) {
2984
2985 if (s->enabled == SD_EVENT_OFF)
2986 continue;
2987
2988 r = source_set_pending(s, true);
2989 if (r < 0)
2990 return r;
2991 }
2992 }
2993 } else {
2994 struct inode_data *inode_data;
2995 sd_event_source *s;
2996
2997 /* Find the inode object for this watch descriptor. If IN_IGNORED is set we also remove it from
2998 * our watch descriptor table. */
2999 if (d->buffer.ev.mask & IN_IGNORED) {
3000
3001 inode_data = hashmap_remove(d->wd, INT_TO_PTR(d->buffer.ev.wd));
3002 if (!inode_data) {
3003 event_inotify_data_drop(e, d, sz);
3004 continue;
3005 }
3006
3007 /* The watch descriptor was removed by the kernel, let's drop it here too */
3008 inode_data->wd = -1;
3009 } else {
3010 inode_data = hashmap_get(d->wd, INT_TO_PTR(d->buffer.ev.wd));
3011 if (!inode_data) {
3012 event_inotify_data_drop(e, d, sz);
3013 continue;
3014 }
3015 }
3016
3017 /* Trigger all event sources that are interested in these events. Also trigger all event
3018 * sources if IN_IGNORED or IN_UNMOUNT is set. */
3019 LIST_FOREACH(inotify.by_inode_data, s, inode_data->event_sources) {
3020
3021 if (s->enabled == SD_EVENT_OFF)
3022 continue;
3023
3024 if ((d->buffer.ev.mask & (IN_IGNORED|IN_UNMOUNT)) == 0 &&
3025 (s->inotify.mask & d->buffer.ev.mask & IN_ALL_EVENTS) == 0)
3026 continue;
3027
3028 r = source_set_pending(s, true);
3029 if (r < 0)
3030 return r;
3031 }
3032 }
3033
3034 /* Something pending now? If so, let's finish, otherwise let's read more. */
3035 if (d->n_pending > 0)
3036 return 1;
3037 }
3038
3039 return 0;
3040 }
3041
3042 static int process_inotify(sd_event *e) {
3043 struct inotify_data *d;
3044 int r, done = 0;
3045
3046 assert(e);
3047
3048 LIST_FOREACH(buffered, d, e->inotify_data_buffered) {
3049 r = event_inotify_data_process(e, d);
3050 if (r < 0)
3051 return r;
3052 if (r > 0)
3053 done ++;
3054 }
3055
3056 return done;
3057 }
3058
3059 static int source_dispatch(sd_event_source *s) {
3060 EventSourceType saved_type;
3061 int r = 0;
3062
3063 assert(s);
3064 assert(s->pending || s->type == SOURCE_EXIT);
3065
3066 /* Save the event source type, here, so that we still know it after the event callback which might invalidate
3067 * the event. */
3068 saved_type = s->type;
3069
3070 if (!IN_SET(s->type, SOURCE_DEFER, SOURCE_EXIT)) {
3071 r = source_set_pending(s, false);
3072 if (r < 0)
3073 return r;
3074 }
3075
3076 if (s->type != SOURCE_POST) {
3077 sd_event_source *z;
3078 Iterator i;
3079
3080 /* If we execute a non-post source, let's mark all
3081 * post sources as pending */
3082
3083 SET_FOREACH(z, s->event->post_sources, i) {
3084 if (z->enabled == SD_EVENT_OFF)
3085 continue;
3086
3087 r = source_set_pending(z, true);
3088 if (r < 0)
3089 return r;
3090 }
3091 }
3092
3093 if (s->enabled == SD_EVENT_ONESHOT) {
3094 r = sd_event_source_set_enabled(s, SD_EVENT_OFF);
3095 if (r < 0)
3096 return r;
3097 }
3098
3099 s->dispatching = true;
3100
3101 switch (s->type) {
3102
3103 case SOURCE_IO:
3104 r = s->io.callback(s, s->io.fd, s->io.revents, s->userdata);
3105 break;
3106
3107 case SOURCE_TIME_REALTIME:
3108 case SOURCE_TIME_BOOTTIME:
3109 case SOURCE_TIME_MONOTONIC:
3110 case SOURCE_TIME_REALTIME_ALARM:
3111 case SOURCE_TIME_BOOTTIME_ALARM:
3112 r = s->time.callback(s, s->time.next, s->userdata);
3113 break;
3114
3115 case SOURCE_SIGNAL:
3116 r = s->signal.callback(s, &s->signal.siginfo, s->userdata);
3117 break;
3118
3119 case SOURCE_CHILD: {
3120 bool zombie;
3121
3122 zombie = IN_SET(s->child.siginfo.si_code, CLD_EXITED, CLD_KILLED, CLD_DUMPED);
3123
3124 r = s->child.callback(s, &s->child.siginfo, s->userdata);
3125
3126 /* Now, reap the PID for good. */
3127 if (zombie)
3128 (void) waitid(P_PID, s->child.pid, &s->child.siginfo, WNOHANG|WEXITED);
3129
3130 break;
3131 }
3132
3133 case SOURCE_DEFER:
3134 r = s->defer.callback(s, s->userdata);
3135 break;
3136
3137 case SOURCE_POST:
3138 r = s->post.callback(s, s->userdata);
3139 break;
3140
3141 case SOURCE_EXIT:
3142 r = s->exit.callback(s, s->userdata);
3143 break;
3144
3145 case SOURCE_INOTIFY: {
3146 struct sd_event *e = s->event;
3147 struct inotify_data *d;
3148 size_t sz;
3149
3150 assert(s->inotify.inode_data);
3151 assert_se(d = s->inotify.inode_data->inotify_data);
3152
3153 assert(d->buffer_filled >= offsetof(struct inotify_event, name));
3154 sz = offsetof(struct inotify_event, name) + d->buffer.ev.len;
3155 assert(d->buffer_filled >= sz);
3156
3157 r = s->inotify.callback(s, &d->buffer.ev, s->userdata);
3158
3159 /* When no event is pending anymore on this inotify object, then let's drop the event from the
3160 * buffer. */
3161 if (d->n_pending == 0)
3162 event_inotify_data_drop(e, d, sz);
3163
3164 break;
3165 }
3166
3167 case SOURCE_WATCHDOG:
3168 case _SOURCE_EVENT_SOURCE_TYPE_MAX:
3169 case _SOURCE_EVENT_SOURCE_TYPE_INVALID:
3170 assert_not_reached("Wut? I shouldn't exist.");
3171 }
3172
3173 s->dispatching = false;
3174
3175 if (r < 0)
3176 log_debug_errno(r, "Event source %s (type %s) returned error, disabling: %m",
3177 strna(s->description), event_source_type_to_string(saved_type));
3178
3179 if (s->n_ref == 0)
3180 source_free(s);
3181 else if (r < 0)
3182 sd_event_source_set_enabled(s, SD_EVENT_OFF);
3183
3184 return 1;
3185 }
3186
3187 static int event_prepare(sd_event *e) {
3188 int r;
3189
3190 assert(e);
3191
3192 for (;;) {
3193 sd_event_source *s;
3194
3195 s = prioq_peek(e->prepare);
3196 if (!s || s->prepare_iteration == e->iteration || s->enabled == SD_EVENT_OFF)
3197 break;
3198
3199 s->prepare_iteration = e->iteration;
3200 r = prioq_reshuffle(e->prepare, s, &s->prepare_index);
3201 if (r < 0)
3202 return r;
3203
3204 assert(s->prepare);
3205
3206 s->dispatching = true;
3207 r = s->prepare(s, s->userdata);
3208 s->dispatching = false;
3209
3210 if (r < 0)
3211 log_debug_errno(r, "Prepare callback of event source %s (type %s) returned error, disabling: %m",
3212 strna(s->description), event_source_type_to_string(s->type));
3213
3214 if (s->n_ref == 0)
3215 source_free(s);
3216 else if (r < 0)
3217 sd_event_source_set_enabled(s, SD_EVENT_OFF);
3218 }
3219
3220 return 0;
3221 }
3222
3223 static int dispatch_exit(sd_event *e) {
3224 sd_event_source *p;
3225 _cleanup_(sd_event_unrefp) sd_event *ref = NULL;
3226 int r;
3227
3228 assert(e);
3229
3230 p = prioq_peek(e->exit);
3231 if (!p || p->enabled == SD_EVENT_OFF) {
3232 e->state = SD_EVENT_FINISHED;
3233 return 0;
3234 }
3235
3236 ref = sd_event_ref(e);
3237 e->iteration++;
3238 e->state = SD_EVENT_EXITING;
3239 r = source_dispatch(p);
3240 e->state = SD_EVENT_INITIAL;
3241 return r;
3242 }
3243
3244 static sd_event_source* event_next_pending(sd_event *e) {
3245 sd_event_source *p;
3246
3247 assert(e);
3248
3249 p = prioq_peek(e->pending);
3250 if (!p)
3251 return NULL;
3252
3253 if (p->enabled == SD_EVENT_OFF)
3254 return NULL;
3255
3256 return p;
3257 }
3258
3259 static int arm_watchdog(sd_event *e) {
3260 struct itimerspec its = {};
3261 usec_t t;
3262 int r;
3263
3264 assert(e);
3265 assert(e->watchdog_fd >= 0);
3266
3267 t = sleep_between(e,
3268 e->watchdog_last + (e->watchdog_period / 2),
3269 e->watchdog_last + (e->watchdog_period * 3 / 4));
3270
3271 timespec_store(&its.it_value, t);
3272
3273 /* Make sure we never set the watchdog to 0, which tells the
3274 * kernel to disable it. */
3275 if (its.it_value.tv_sec == 0 && its.it_value.tv_nsec == 0)
3276 its.it_value.tv_nsec = 1;
3277
3278 r = timerfd_settime(e->watchdog_fd, TFD_TIMER_ABSTIME, &its, NULL);
3279 if (r < 0)
3280 return -errno;
3281
3282 return 0;
3283 }
3284
3285 static int process_watchdog(sd_event *e) {
3286 assert(e);
3287
3288 if (!e->watchdog)
3289 return 0;
3290
3291 /* Don't notify watchdog too often */
3292 if (e->watchdog_last + e->watchdog_period / 4 > e->timestamp.monotonic)
3293 return 0;
3294
3295 sd_notify(false, "WATCHDOG=1");
3296 e->watchdog_last = e->timestamp.monotonic;
3297
3298 return arm_watchdog(e);
3299 }
3300
3301 static void event_close_inode_data_fds(sd_event *e) {
3302 struct inode_data *d;
3303
3304 assert(e);
3305
3306 /* Close the fds pointing to the inodes to watch now. We need to close them as they might otherwise pin
3307 * filesystems. But we can't close them right-away as we need them as long as the user still wants to make
3308 * adjustments to the even source, such as changing the priority (which requires us to remove and readd a watch
3309 * for the inode). Hence, let's close them when entering the first iteration after they were added, as a
3310 * compromise. */
3311
3312 while ((d = e->inode_data_to_close)) {
3313 assert(d->fd >= 0);
3314 d->fd = safe_close(d->fd);
3315
3316 LIST_REMOVE(to_close, e->inode_data_to_close, d);
3317 }
3318 }
3319
3320 _public_ int sd_event_prepare(sd_event *e) {
3321 int r;
3322
3323 assert_return(e, -EINVAL);
3324 assert_return(e = event_resolve(e), -ENOPKG);
3325 assert_return(!event_pid_changed(e), -ECHILD);
3326 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
3327 assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
3328
3329 if (e->exit_requested)
3330 goto pending;
3331
3332 e->iteration++;
3333
3334 e->state = SD_EVENT_PREPARING;
3335 r = event_prepare(e);
3336 e->state = SD_EVENT_INITIAL;
3337 if (r < 0)
3338 return r;
3339
3340 r = event_arm_timer(e, &e->realtime);
3341 if (r < 0)
3342 return r;
3343
3344 r = event_arm_timer(e, &e->boottime);
3345 if (r < 0)
3346 return r;
3347
3348 r = event_arm_timer(e, &e->monotonic);
3349 if (r < 0)
3350 return r;
3351
3352 r = event_arm_timer(e, &e->realtime_alarm);
3353 if (r < 0)
3354 return r;
3355
3356 r = event_arm_timer(e, &e->boottime_alarm);
3357 if (r < 0)
3358 return r;
3359
3360 event_close_inode_data_fds(e);
3361
3362 if (event_next_pending(e) || e->need_process_child)
3363 goto pending;
3364
3365 e->state = SD_EVENT_ARMED;
3366
3367 return 0;
3368
3369 pending:
3370 e->state = SD_EVENT_ARMED;
3371 r = sd_event_wait(e, 0);
3372 if (r == 0)
3373 e->state = SD_EVENT_ARMED;
3374
3375 return r;
3376 }
3377
3378 _public_ int sd_event_wait(sd_event *e, uint64_t timeout) {
3379 struct epoll_event *ev_queue;
3380 unsigned ev_queue_max;
3381 int r, m, i;
3382
3383 assert_return(e, -EINVAL);
3384 assert_return(e = event_resolve(e), -ENOPKG);
3385 assert_return(!event_pid_changed(e), -ECHILD);
3386 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
3387 assert_return(e->state == SD_EVENT_ARMED, -EBUSY);
3388
3389 if (e->exit_requested) {
3390 e->state = SD_EVENT_PENDING;
3391 return 1;
3392 }
3393
3394 ev_queue_max = MAX(e->n_sources, 1u);
3395 ev_queue = newa(struct epoll_event, ev_queue_max);
3396
3397 /* If we still have inotify data buffered, then query the other fds, but don't wait on it */
3398 if (e->inotify_data_buffered)
3399 timeout = 0;
3400
3401 m = epoll_wait(e->epoll_fd, ev_queue, ev_queue_max,
3402 timeout == (uint64_t) -1 ? -1 : (int) ((timeout + USEC_PER_MSEC - 1) / USEC_PER_MSEC));
3403 if (m < 0) {
3404 if (errno == EINTR) {
3405 e->state = SD_EVENT_PENDING;
3406 return 1;
3407 }
3408
3409 r = -errno;
3410 goto finish;
3411 }
3412
3413 triple_timestamp_get(&e->timestamp);
3414
3415 for (i = 0; i < m; i++) {
3416
3417 if (ev_queue[i].data.ptr == INT_TO_PTR(SOURCE_WATCHDOG))
3418 r = flush_timer(e, e->watchdog_fd, ev_queue[i].events, NULL);
3419 else {
3420 WakeupType *t = ev_queue[i].data.ptr;
3421
3422 switch (*t) {
3423
3424 case WAKEUP_EVENT_SOURCE:
3425 r = process_io(e, ev_queue[i].data.ptr, ev_queue[i].events);
3426 break;
3427
3428 case WAKEUP_CLOCK_DATA: {
3429 struct clock_data *d = ev_queue[i].data.ptr;
3430 r = flush_timer(e, d->fd, ev_queue[i].events, &d->next);
3431 break;
3432 }
3433
3434 case WAKEUP_SIGNAL_DATA:
3435 r = process_signal(e, ev_queue[i].data.ptr, ev_queue[i].events);
3436 break;
3437
3438 case WAKEUP_INOTIFY_DATA:
3439 r = event_inotify_data_read(e, ev_queue[i].data.ptr, ev_queue[i].events);
3440 break;
3441
3442 default:
3443 assert_not_reached("Invalid wake-up pointer");
3444 }
3445 }
3446 if (r < 0)
3447 goto finish;
3448 }
3449
3450 r = process_watchdog(e);
3451 if (r < 0)
3452 goto finish;
3453
3454 r = process_timer(e, e->timestamp.realtime, &e->realtime);
3455 if (r < 0)
3456 goto finish;
3457
3458 r = process_timer(e, e->timestamp.boottime, &e->boottime);
3459 if (r < 0)
3460 goto finish;
3461
3462 r = process_timer(e, e->timestamp.monotonic, &e->monotonic);
3463 if (r < 0)
3464 goto finish;
3465
3466 r = process_timer(e, e->timestamp.realtime, &e->realtime_alarm);
3467 if (r < 0)
3468 goto finish;
3469
3470 r = process_timer(e, e->timestamp.boottime, &e->boottime_alarm);
3471 if (r < 0)
3472 goto finish;
3473
3474 if (e->need_process_child) {
3475 r = process_child(e);
3476 if (r < 0)
3477 goto finish;
3478 }
3479
3480 r = process_inotify(e);
3481 if (r < 0)
3482 goto finish;
3483
3484 if (event_next_pending(e)) {
3485 e->state = SD_EVENT_PENDING;
3486
3487 return 1;
3488 }
3489
3490 r = 0;
3491
3492 finish:
3493 e->state = SD_EVENT_INITIAL;
3494
3495 return r;
3496 }
3497
3498 _public_ int sd_event_dispatch(sd_event *e) {
3499 sd_event_source *p;
3500 int r;
3501
3502 assert_return(e, -EINVAL);
3503 assert_return(e = event_resolve(e), -ENOPKG);
3504 assert_return(!event_pid_changed(e), -ECHILD);
3505 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
3506 assert_return(e->state == SD_EVENT_PENDING, -EBUSY);
3507
3508 if (e->exit_requested)
3509 return dispatch_exit(e);
3510
3511 p = event_next_pending(e);
3512 if (p) {
3513 _cleanup_(sd_event_unrefp) sd_event *ref = NULL;
3514
3515 ref = sd_event_ref(e);
3516 e->state = SD_EVENT_RUNNING;
3517 r = source_dispatch(p);
3518 e->state = SD_EVENT_INITIAL;
3519 return r;
3520 }
3521
3522 e->state = SD_EVENT_INITIAL;
3523
3524 return 1;
3525 }
3526
3527 static void event_log_delays(sd_event *e) {
3528 char b[ELEMENTSOF(e->delays) * DECIMAL_STR_MAX(unsigned) + 1];
3529 unsigned i;
3530 int o;
3531
3532 for (i = o = 0; i < ELEMENTSOF(e->delays); i++) {
3533 o += snprintf(&b[o], sizeof(b) - o, "%u ", e->delays[i]);
3534 e->delays[i] = 0;
3535 }
3536 log_debug("Event loop iterations: %.*s", o, b);
3537 }
3538
3539 _public_ int sd_event_run(sd_event *e, uint64_t timeout) {
3540 int r;
3541
3542 assert_return(e, -EINVAL);
3543 assert_return(e = event_resolve(e), -ENOPKG);
3544 assert_return(!event_pid_changed(e), -ECHILD);
3545 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
3546 assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
3547
3548 if (e->profile_delays && e->last_run) {
3549 usec_t this_run;
3550 unsigned l;
3551
3552 this_run = now(CLOCK_MONOTONIC);
3553
3554 l = u64log2(this_run - e->last_run);
3555 assert(l < sizeof(e->delays));
3556 e->delays[l]++;
3557
3558 if (this_run - e->last_log >= 5*USEC_PER_SEC) {
3559 event_log_delays(e);
3560 e->last_log = this_run;
3561 }
3562 }
3563
3564 r = sd_event_prepare(e);
3565 if (r == 0)
3566 /* There was nothing? Then wait... */
3567 r = sd_event_wait(e, timeout);
3568
3569 if (e->profile_delays)
3570 e->last_run = now(CLOCK_MONOTONIC);
3571
3572 if (r > 0) {
3573 /* There's something now, then let's dispatch it */
3574 r = sd_event_dispatch(e);
3575 if (r < 0)
3576 return r;
3577
3578 return 1;
3579 }
3580
3581 return r;
3582 }
3583
3584 _public_ int sd_event_loop(sd_event *e) {
3585 _cleanup_(sd_event_unrefp) sd_event *ref = NULL;
3586 int r;
3587
3588 assert_return(e, -EINVAL);
3589 assert_return(e = event_resolve(e), -ENOPKG);
3590 assert_return(!event_pid_changed(e), -ECHILD);
3591 assert_return(e->state == SD_EVENT_INITIAL, -EBUSY);
3592
3593 ref = sd_event_ref(e);
3594
3595 while (e->state != SD_EVENT_FINISHED) {
3596 r = sd_event_run(e, (uint64_t) -1);
3597 if (r < 0)
3598 return r;
3599 }
3600
3601 return e->exit_code;
3602 }
3603
3604 _public_ int sd_event_get_fd(sd_event *e) {
3605
3606 assert_return(e, -EINVAL);
3607 assert_return(e = event_resolve(e), -ENOPKG);
3608 assert_return(!event_pid_changed(e), -ECHILD);
3609
3610 return e->epoll_fd;
3611 }
3612
3613 _public_ int sd_event_get_state(sd_event *e) {
3614 assert_return(e, -EINVAL);
3615 assert_return(e = event_resolve(e), -ENOPKG);
3616 assert_return(!event_pid_changed(e), -ECHILD);
3617
3618 return e->state;
3619 }
3620
3621 _public_ int sd_event_get_exit_code(sd_event *e, int *code) {
3622 assert_return(e, -EINVAL);
3623 assert_return(e = event_resolve(e), -ENOPKG);
3624 assert_return(code, -EINVAL);
3625 assert_return(!event_pid_changed(e), -ECHILD);
3626
3627 if (!e->exit_requested)
3628 return -ENODATA;
3629
3630 *code = e->exit_code;
3631 return 0;
3632 }
3633
3634 _public_ int sd_event_exit(sd_event *e, int code) {
3635 assert_return(e, -EINVAL);
3636 assert_return(e = event_resolve(e), -ENOPKG);
3637 assert_return(e->state != SD_EVENT_FINISHED, -ESTALE);
3638 assert_return(!event_pid_changed(e), -ECHILD);
3639
3640 e->exit_requested = true;
3641 e->exit_code = code;
3642
3643 return 0;
3644 }
3645
3646 _public_ int sd_event_now(sd_event *e, clockid_t clock, uint64_t *usec) {
3647 assert_return(e, -EINVAL);
3648 assert_return(e = event_resolve(e), -ENOPKG);
3649 assert_return(usec, -EINVAL);
3650 assert_return(!event_pid_changed(e), -ECHILD);
3651
3652 if (!TRIPLE_TIMESTAMP_HAS_CLOCK(clock))
3653 return -EOPNOTSUPP;
3654
3655 /* Generate a clean error in case CLOCK_BOOTTIME is not available. Note that don't use clock_supported() here,
3656 * for a reason: there are systems where CLOCK_BOOTTIME is supported, but CLOCK_BOOTTIME_ALARM is not, but for
3657 * the purpose of getting the time this doesn't matter. */
3658 if (IN_SET(clock, CLOCK_BOOTTIME, CLOCK_BOOTTIME_ALARM) && !clock_boottime_supported())
3659 return -EOPNOTSUPP;
3660
3661 if (!triple_timestamp_is_set(&e->timestamp)) {
3662 /* Implicitly fall back to now() if we never ran
3663 * before and thus have no cached time. */
3664 *usec = now(clock);
3665 return 1;
3666 }
3667
3668 *usec = triple_timestamp_by_clock(&e->timestamp, clock);
3669 return 0;
3670 }
3671
3672 _public_ int sd_event_default(sd_event **ret) {
3673 sd_event *e = NULL;
3674 int r;
3675
3676 if (!ret)
3677 return !!default_event;
3678
3679 if (default_event) {
3680 *ret = sd_event_ref(default_event);
3681 return 0;
3682 }
3683
3684 r = sd_event_new(&e);
3685 if (r < 0)
3686 return r;
3687
3688 e->default_event_ptr = &default_event;
3689 e->tid = gettid();
3690 default_event = e;
3691
3692 *ret = e;
3693 return 1;
3694 }
3695
3696 _public_ int sd_event_get_tid(sd_event *e, pid_t *tid) {
3697 assert_return(e, -EINVAL);
3698 assert_return(e = event_resolve(e), -ENOPKG);
3699 assert_return(tid, -EINVAL);
3700 assert_return(!event_pid_changed(e), -ECHILD);
3701
3702 if (e->tid != 0) {
3703 *tid = e->tid;
3704 return 0;
3705 }
3706
3707 return -ENXIO;
3708 }
3709
3710 _public_ int sd_event_set_watchdog(sd_event *e, int b) {
3711 int r;
3712
3713 assert_return(e, -EINVAL);
3714 assert_return(e = event_resolve(e), -ENOPKG);
3715 assert_return(!event_pid_changed(e), -ECHILD);
3716
3717 if (e->watchdog == !!b)
3718 return e->watchdog;
3719
3720 if (b) {
3721 struct epoll_event ev;
3722
3723 r = sd_watchdog_enabled(false, &e->watchdog_period);
3724 if (r <= 0)
3725 return r;
3726
3727 /* Issue first ping immediately */
3728 sd_notify(false, "WATCHDOG=1");
3729 e->watchdog_last = now(CLOCK_MONOTONIC);
3730
3731 e->watchdog_fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC);
3732 if (e->watchdog_fd < 0)
3733 return -errno;
3734
3735 r = arm_watchdog(e);
3736 if (r < 0)
3737 goto fail;
3738
3739 ev = (struct epoll_event) {
3740 .events = EPOLLIN,
3741 .data.ptr = INT_TO_PTR(SOURCE_WATCHDOG),
3742 };
3743
3744 r = epoll_ctl(e->epoll_fd, EPOLL_CTL_ADD, e->watchdog_fd, &ev);
3745 if (r < 0) {
3746 r = -errno;
3747 goto fail;
3748 }
3749
3750 } else {
3751 if (e->watchdog_fd >= 0) {
3752 epoll_ctl(e->epoll_fd, EPOLL_CTL_DEL, e->watchdog_fd, NULL);
3753 e->watchdog_fd = safe_close(e->watchdog_fd);
3754 }
3755 }
3756
3757 e->watchdog = !!b;
3758 return e->watchdog;
3759
3760 fail:
3761 e->watchdog_fd = safe_close(e->watchdog_fd);
3762 return r;
3763 }
3764
3765 _public_ int sd_event_get_watchdog(sd_event *e) {
3766 assert_return(e, -EINVAL);
3767 assert_return(e = event_resolve(e), -ENOPKG);
3768 assert_return(!event_pid_changed(e), -ECHILD);
3769
3770 return e->watchdog;
3771 }
3772
3773 _public_ int sd_event_get_iteration(sd_event *e, uint64_t *ret) {
3774 assert_return(e, -EINVAL);
3775 assert_return(e = event_resolve(e), -ENOPKG);
3776 assert_return(!event_pid_changed(e), -ECHILD);
3777
3778 *ret = e->iteration;
3779 return 0;
3780 }
3781
3782 _public_ int sd_event_source_set_destroy_callback(sd_event_source *s, sd_event_destroy_t callback) {
3783 assert_return(s, -EINVAL);
3784
3785 s->destroy_callback = callback;
3786 return 0;
3787 }
3788
3789 _public_ int sd_event_source_get_destroy_callback(sd_event_source *s, sd_event_destroy_t *ret) {
3790 assert_return(s, -EINVAL);
3791
3792 if (ret)
3793 *ret = s->destroy_callback;
3794
3795 return !!s->destroy_callback;
3796 }
Unnamed repository; edit this file 'description' to name the repository.