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


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