../src/libsystemd/sd-event/sd-event.c

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_A57 = (
(!!x->ratelimited)); const typeof((!!y->ratelimited)) __unique_prefix_B58
= ((!!y->ratelimited)); __unique_prefix_A57 < __unique_prefix_B58
? -1 : __unique_prefix_A57 > __unique_prefix_B58 ? 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_A59 = ((x->
priority)); const typeof((y->priority)) __unique_prefix_B60
= ((y->priority)); __unique_prefix_A59 < __unique_prefix_B60
? -1 : __unique_prefix_A59 > __unique_prefix_B60 ? 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_A61
= ((x->pending_iteration)); const typeof((y->pending_iteration
)) __unique_prefix_B62 = ((y->pending_iteration)); __unique_prefix_A61
< __unique_prefix_B62 ? -1 : __unique_prefix_A61 > __unique_prefix_B62
? 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_A63 = (
(!!x->ratelimited)); const typeof((!!y->ratelimited)) __unique_prefix_B64
= ((!!y->ratelimited)); __unique_prefix_A63 < __unique_prefix_B64
? -1 : __unique_prefix_A63 > __unique_prefix_B64 ? 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_A65
= ((x->prepare_iteration)); const typeof((y->prepare_iteration
)) __unique_prefix_B66 = ((y->prepare_iteration)); __unique_prefix_A65
< __unique_prefix_B66 ? -1 : __unique_prefix_A65 > __unique_prefix_B66
? 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_A67 = ((x->
priority)); const typeof((y->priority)) __unique_prefix_B68
= ((y->priority)); __unique_prefix_A67 < __unique_prefix_B68
? -1 : __unique_prefix_A67 > __unique_prefix_B68 ? 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_A69
= ((time_event_source_next(x))); const typeof((time_event_source_next
(y))) __unique_prefix_B70 = ((time_event_source_next(y))); __unique_prefix_A69
< __unique_prefix_B70 ? -1 : __unique_prefix_A69 > __unique_prefix_B70
? 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_A71
= ((e->n_sources)); const typeof((1u)) __unique_prefix_B72
= ((1u)); __unique_prefix_A71 > __unique_prefix_B72 ? __unique_prefix_A71
: __unique_prefix_B72; });

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

}

File:	build-scan/../src/libsystemd/sd-event/sd-event.c
Warning:	line 3319, column 9 Value stored to 'saved_event' is never read

Bug Summary

Annotated Source Code