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