../src/core/unit.c

1

/* SPDX-License-Identifier: LGPL-2.1+ */

2

3

#include <errno(*__errno_location ()).h>

4

#include <stdlib.h>

5

#include <string.h>

6

#include <sys/prctl.h>

7

#include <sys/stat.h>

8

#include <unistd.h>

9

10

#include "sd-id128.h"

11

#include "sd-messages.h"

12

13

#include "alloc-util.h"

14

#include "all-units.h"

15

#include "bus-common-errors.h"

16

#include "bus-util.h"

17

#include "cgroup-util.h"

18

#include "dbus-unit.h"

19

#include "dbus.h"

20

#include "dropin.h"

21

#include "escape.h"

22

#include "execute.h"

23

#include "fd-util.h"

24

#include "fileio-label.h"

25

#include "format-util.h"

26

#include "fs-util.h"

27

#include "id128-util.h"

28

#include "io-util.h"

29

#include "load-dropin.h"

30

#include "load-fragment.h"

31

#include "log.h"

32

#include "macro.h"

33

#include "missing.h"

34

#include "mkdir.h"

35

#include "parse-util.h"

36

#include "path-util.h"

37

#include "process-util.h"

38

#include "set.h"

39

#include "signal-util.h"

40

#include "sparse-endian.h"

41

#include "special.h"

42

#include "specifier.h"

43

#include "stat-util.h"

44

#include "stdio-util.h"

45

#include "string-table.h"

46

#include "string-util.h"

47

#include "strv.h"

48

#include "umask-util.h"

49

#include "unit-name.h"

50

#include "unit.h"

51

#include "user-util.h"

52

#include "virt.h"

53

54

const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {

55

[UNIT_SERVICE] = &service_vtable,

56

[UNIT_SOCKET] = &socket_vtable,

57

[UNIT_TARGET] = &target_vtable,

58

[UNIT_DEVICE] = &device_vtable,

59

[UNIT_MOUNT] = &mount_vtable,

60

[UNIT_AUTOMOUNT] = &automount_vtable,

61

[UNIT_SWAP] = &swap_vtable,

62

[UNIT_TIMER] = &timer_vtable,

63

[UNIT_PATH] = &path_vtable,

64

[UNIT_SLICE] = &slice_vtable,

65

[UNIT_SCOPE] = &scope_vtable,

66

};

67

68

static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency);

69

70

Unit *unit_new(Manager *m, size_t size) {

71

Unit *u;

72

73

assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/core/unit.c", 73, __PRETTY_FUNCTION__
); } while (0);

74

assert(size >= sizeof(Unit))do { if ((__builtin_expect(!!(!(size >= sizeof(Unit))),0))
) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("size >= sizeof(Unit)"
), "../src/core/unit.c", 74, __PRETTY_FUNCTION__); } while (0
);

75

76

u = malloc0(size)(calloc(1, (size)));

77

if (!u)

78

return NULL((void*)0);

79

80

u->names = set_new(&string_hash_ops)internal_set_new(&string_hash_ops );

81

if (!u->names)

82

return mfree(u);

83

84

u->manager = m;

85

u->type = _UNIT_TYPE_INVALID;

86

u->default_dependencies = true1;

87

u->unit_file_state = _UNIT_FILE_STATE_INVALID;

88

u->unit_file_preset = -1;

89

u->on_failure_job_mode = JOB_REPLACE;

90

u->cgroup_inotify_wd = -1;

91

u->job_timeout = USEC_INFINITY((usec_t) -1);

92

u->job_running_timeout = USEC_INFINITY((usec_t) -1);

93

u->ref_uid = UID_INVALID((uid_t) -1);

94

u->ref_gid = GID_INVALID((gid_t) -1);

95

u->cpu_usage_last = NSEC_INFINITY((nsec_t) -1);

96

u->cgroup_bpf_state = UNIT_CGROUP_BPF_INVALIDATED;

97

98

u->ip_accounting_ingress_map_fd = -1;

99

u->ip_accounting_egress_map_fd = -1;

100

u->ipv4_allow_map_fd = -1;

101

u->ipv6_allow_map_fd = -1;

102

u->ipv4_deny_map_fd = -1;

103

u->ipv6_deny_map_fd = -1;

104

105

u->last_section_private = -1;

106

107

RATELIMIT_INIT(u->start_limit, m->default_start_limit_interval, m->default_start_limit_burst)do { RateLimit *_r = &(u->start_limit); _r->interval
= (m->default_start_limit_interval); _r->burst = (m->
default_start_limit_burst); _r->num = 0; _r->begin = 0;
} while (0);

108

RATELIMIT_INIT(u->auto_stop_ratelimit, 10 * USEC_PER_SEC, 16)do { RateLimit *_r = &(u->auto_stop_ratelimit); _r->
interval = (10 * ((usec_t) 1000000ULL)); _r->burst = (16);
_r->num = 0; _r->begin = 0; } while (0);

109

110

return u;

111

}

112

113

int unit_new_for_name(Manager *m, size_t size, const char *name, Unit **ret) {

114

_cleanup_(unit_freep)__attribute__((cleanup(unit_freep))) Unit *u = NULL((void*)0);

115

int r;

116

117

u = unit_new(m, size);

118

if (!u)

119

return -ENOMEM12;

120

121

r = unit_add_name(u, name);

122

if (r < 0)

123

return r;

124

125

*ret = TAKE_PTR(u)({ typeof(u) _ptr_ = (u); (u) = ((void*)0); _ptr_; });

126

127

return r;

128

}

129

130

bool_Bool unit_has_name(Unit *u, const char *name) {

131

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 131, __PRETTY_FUNCTION__
); } while (0);

132

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 132, __PRETTY_FUNCTION__
); } while (0);

133

134

return set_contains(u->names, (char*) name);

135

}

136

137

static void unit_init(Unit *u) {

138

CGroupContext *cc;

139

ExecContext *ec;

140

KillContext *kc;

141

142

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 142, __PRETTY_FUNCTION__
); } while (0);

143

assert(u->manager)do { if ((__builtin_expect(!!(!(u->manager)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u->manager"), "../src/core/unit.c", 143
, __PRETTY_FUNCTION__); } while (0);

144

assert(u->type >= 0)do { if ((__builtin_expect(!!(!(u->type >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u->type >= 0"), "../src/core/unit.c"
, 144, __PRETTY_FUNCTION__); } while (0);

145

146

cc = unit_get_cgroup_context(u);

147

if (cc) {

148

cgroup_context_init(cc);

149

150

/* Copy in the manager defaults into the cgroup

151

* context, _before_ the rest of the settings have

152

* been initialized */

153

154

cc->cpu_accounting = u->manager->default_cpu_accounting;

155

cc->io_accounting = u->manager->default_io_accounting;

156

cc->ip_accounting = u->manager->default_ip_accounting;

157

cc->blockio_accounting = u->manager->default_blockio_accounting;

158

cc->memory_accounting = u->manager->default_memory_accounting;

159

cc->tasks_accounting = u->manager->default_tasks_accounting;

160

cc->ip_accounting = u->manager->default_ip_accounting;

161

162

if (u->type != UNIT_SLICE)

163

cc->tasks_max = u->manager->default_tasks_max;

164

}

165

166

ec = unit_get_exec_context(u);

167

if (ec) {

168

exec_context_init(ec);

169

170

ec->keyring_mode = MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM) ?

171

EXEC_KEYRING_SHARED : EXEC_KEYRING_INHERIT;

172

}

173

174

kc = unit_get_kill_context(u);

175

if (kc)

176

kill_context_init(kc);

177

178

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->init)

179

UNIT_VTABLE(u)unit_vtable[(u)->type]->init(u);

180

}

181

182

int unit_add_name(Unit *u, const char *text) {

183

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0), *i = NULL((void*)0);

184

UnitType t;

185

int r;

186

187

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 187, __PRETTY_FUNCTION__
); } while (0);

188

assert(text)do { if ((__builtin_expect(!!(!(text)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("text"), "../src/core/unit.c", 188, __PRETTY_FUNCTION__
); } while (0);

189

190

if (unit_name_is_valid(text, UNIT_NAME_TEMPLATE)) {

191

192

if (!u->instance)

193

return -EINVAL22;

194

195

r = unit_name_replace_instance(text, u->instance, &s);

196

if (r < 0)

197

return r;

198

} else {

199

s = strdup(text);

200

if (!s)

201

return -ENOMEM12;

202

}

203

204

if (set_contains(u->names, s))

205

return 0;

206

if (hashmap_contains(u->manager->units, s))

207

return -EEXIST17;

208

209

if (!unit_name_is_valid(s, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))

210

return -EINVAL22;

211

212

t = unit_name_to_type(s);

213

if (t < 0)

214

return -EINVAL22;

215

216

if (u->type != _UNIT_TYPE_INVALID && t != u->type)

217

return -EINVAL22;

218

219

r = unit_name_to_instance(s, &i);

220

if (r < 0)

221

return r;

222

223

if (i && !unit_type_may_template(t))

224

return -EINVAL22;

225

226

/* Ensure that this unit is either instanced or not instanced,

227

* but not both. Note that we do allow names with different

228

* instance names however! */

229

if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)

230

return -EINVAL22;

231

232

if (!unit_type_may_alias(t) && !set_isempty(u->names))

233

return -EEXIST17;

234

235

if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES131072)

236

return -E2BIG7;

237

238

r = set_put(u->names, s);

239

if (r < 0)

240

return r;

241

assert(r > 0)do { if ((__builtin_expect(!!(!(r > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("r > 0"), "../src/core/unit.c", 241, __PRETTY_FUNCTION__
); } while (0);

242

243

r = hashmap_put(u->manager->units, s, u);

244

if (r < 0) {

245

(void) set_remove(u->names, s);

246

return r;

247

}

248

249

if (u->type == _UNIT_TYPE_INVALID) {

250

u->type = t;

251

u->id = s;

252

u->instance = TAKE_PTR(i)({ typeof(i) _ptr_ = (i); (i) = ((void*)0); _ptr_; });

253

254

LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u)do { typeof(*(u->manager->units_by_type[t])) **_head = &
(u->manager->units_by_type[t]), *_item = (u); do { if (
(__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("_item"), "../src/core/unit.c", 254, __PRETTY_FUNCTION__);
} while (0); if ((_item->units_by_type_next = *_head)) _item
->units_by_type_next->units_by_type_prev = _item; _item
->units_by_type_prev = ((void*)0); *_head = _item; } while
(0);

255

256

unit_init(u);

257

}

258

259

s = NULL((void*)0);

260

261

unit_add_to_dbus_queue(u);

262

return 0;

263

}

264

265

int unit_choose_id(Unit *u, const char *name) {

266

_cleanup_free___attribute__((cleanup(freep))) char *t = NULL((void*)0);

267

char *s, *i;

268

int r;

269

270

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 270, __PRETTY_FUNCTION__
); } while (0);

271

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 271, __PRETTY_FUNCTION__
); } while (0);

272

273

if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {

274

275

if (!u->instance)

276

return -EINVAL22;

277

278

r = unit_name_replace_instance(name, u->instance, &t);

279

if (r < 0)

280

return r;

281

282

name = t;

283

}

284

285

/* Selects one of the names of this unit as the id */

286

s = set_get(u->names, (char*) name);

287

if (!s)

288

return -ENOENT2;

289

290

/* Determine the new instance from the new id */

291

r = unit_name_to_instance(s, &i);

292

if (r < 0)

293

return r;

294

295

u->id = s;

296

297

free(u->instance);

298

u->instance = i;

299

300

unit_add_to_dbus_queue(u);

301

302

return 0;

303

}

304

305

int unit_set_description(Unit *u, const char *description) {

306

int r;

307

308

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 308, __PRETTY_FUNCTION__
); } while (0);

309

310

r = free_and_strdup(&u->description, empty_to_null(description));

311

if (r < 0)

312

return r;

313

if (r > 0)

314

unit_add_to_dbus_queue(u);

315

316

return 0;

317

}

318

319

bool_Bool unit_may_gc(Unit *u) {

320

UnitActiveState state;

321

int r;

322

323

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 323, __PRETTY_FUNCTION__
); } while (0);

324

325

/* Checks whether the unit is ready to be unloaded for garbage collection.

326

* Returns true when the unit may be collected, and false if there's some

327

* reason to keep it loaded.

328

*

329

* References from other units are *not* checked here. Instead, this is done

330

* in unit_gc_sweep(), but using markers to properly collect dependency loops.

331

*/

332

333

if (u->job)

334

return false0;

335

336

if (u->nop_job)

337

return false0;

338

339

state = unit_active_state(u);

340

341

/* If the unit is inactive and failed and no job is queued for it, then release its runtime resources */

342

if (UNIT_IS_INACTIVE_OR_FAILED(state) &&

343

UNIT_VTABLE(u)unit_vtable[(u)->type]->release_resources)

344

UNIT_VTABLE(u)unit_vtable[(u)->type]->release_resources(u);

345

346

if (u->perpetual)

347

return false0;

348

349

if (sd_bus_track_count(u->bus_track) > 0)

350

return false0;

351

352

/* But we keep the unit object around for longer when it is referenced or configured to not be gc'ed */

353

switch (u->collect_mode) {

354

355

case COLLECT_INACTIVE:

356

if (state != UNIT_INACTIVE)

357

return false0;

358

359

break;

360

361

case COLLECT_INACTIVE_OR_FAILED:

362

if (!IN_SET(state, UNIT_INACTIVE, UNIT_FAILED)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){UNIT_INACTIVE, UNIT_FAILED})/sizeof(int)
]; switch(state) { case UNIT_INACTIVE: case UNIT_FAILED: _found
= 1; break; default: break; } _found; }))

363

return false0;

364

365

break;

366

367

default:

368

assert_not_reached("Unknown garbage collection mode")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unknown garbage collection mode"), "../src/core/unit.c", 368
, __PRETTY_FUNCTION__); } while (0);

369

}

370

371

if (u->cgroup_path) {

372

/* If the unit has a cgroup, then check whether there's anything in it. If so, we should stay

373

* around. Units with active processes should never be collected. */

374

375

r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path);

376

if (r < 0)

377

log_unit_debug_errno(u, r, "Failed to determine whether cgroup %s is empty: %m", u->cgroup_path)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 377, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to determine whether cgroup %s is empty: %m", u->
cgroup_path) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), r, "../src/core/unit.c", 377, __func__, "Failed to determine whether cgroup %s is empty: %m"
, u->cgroup_path); });

378

if (r <= 0)

379

return false0;

380

}

381

382

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->may_gc && !UNIT_VTABLE(u)unit_vtable[(u)->type]->may_gc(u))

383

return false0;

384

385

return true1;

386

}

387

388

void unit_add_to_load_queue(Unit *u) {

389

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 389, __PRETTY_FUNCTION__
); } while (0);

390

assert(u->type != _UNIT_TYPE_INVALID)do { if ((__builtin_expect(!!(!(u->type != _UNIT_TYPE_INVALID
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("u->type != _UNIT_TYPE_INVALID"
), "../src/core/unit.c", 390, __PRETTY_FUNCTION__); } while (
0);

391

392

if (u->load_state != UNIT_STUB || u->in_load_queue)

393

return;

394

395

LIST_PREPEND(load_queue, u->manager->load_queue, u)do { typeof(*(u->manager->load_queue)) **_head = &(
u->manager->load_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 395, __PRETTY_FUNCTION__); }
while (0); if ((_item->load_queue_next = *_head)) _item->
load_queue_next->load_queue_prev = _item; _item->load_queue_prev
= ((void*)0); *_head = _item; } while (0);

396

u->in_load_queue = true1;

397

}

398

399

void unit_add_to_cleanup_queue(Unit *u) {

400

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 400, __PRETTY_FUNCTION__
); } while (0);

401

402

if (u->in_cleanup_queue)

403

return;

404

405

LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u)do { typeof(*(u->manager->cleanup_queue)) **_head = &
(u->manager->cleanup_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 405, __PRETTY_FUNCTION__); }
while (0); if ((_item->cleanup_queue_next = *_head)) _item
->cleanup_queue_next->cleanup_queue_prev = _item; _item
->cleanup_queue_prev = ((void*)0); *_head = _item; } while
(0);

406

u->in_cleanup_queue = true1;

407

}

408

409

void unit_add_to_gc_queue(Unit *u) {

410

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 410, __PRETTY_FUNCTION__
); } while (0);

411

412

if (u->in_gc_queue || u->in_cleanup_queue)

413

return;

414

415

if (!unit_may_gc(u))

416

return;

417

418

LIST_PREPEND(gc_queue, u->manager->gc_unit_queue, u)do { typeof(*(u->manager->gc_unit_queue)) **_head = &
(u->manager->gc_unit_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 418, __PRETTY_FUNCTION__); }
while (0); if ((_item->gc_queue_next = *_head)) _item->
gc_queue_next->gc_queue_prev = _item; _item->gc_queue_prev
= ((void*)0); *_head = _item; } while (0);

419

u->in_gc_queue = true1;

420

}

421

422

void unit_add_to_dbus_queue(Unit *u) {

423

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 423, __PRETTY_FUNCTION__
); } while (0);

424

assert(u->type != _UNIT_TYPE_INVALID)do { if ((__builtin_expect(!!(!(u->type != _UNIT_TYPE_INVALID
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("u->type != _UNIT_TYPE_INVALID"
), "../src/core/unit.c", 424, __PRETTY_FUNCTION__); } while (
0);

425

426

if (u->load_state == UNIT_STUB || u->in_dbus_queue)

427

return;

428

429

/* Shortcut things if nobody cares */

430

if (sd_bus_track_count(u->manager->subscribed) <= 0 &&

431

sd_bus_track_count(u->bus_track) <= 0 &&

432

set_isempty(u->manager->private_buses)) {

433

u->sent_dbus_new_signal = true1;

434

return;

435

}

436

437

LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u)do { typeof(*(u->manager->dbus_unit_queue)) **_head = &
(u->manager->dbus_unit_queue), *_item = (u); do { if ((
__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("_item"), "../src/core/unit.c", 437, __PRETTY_FUNCTION__);
} while (0); if ((_item->dbus_queue_next = *_head)) _item
->dbus_queue_next->dbus_queue_prev = _item; _item->dbus_queue_prev
= ((void*)0); *_head = _item; } while (0);

438

u->in_dbus_queue = true1;

439

}

440

441

void unit_add_to_stop_when_unneeded_queue(Unit *u) {

442

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 442, __PRETTY_FUNCTION__
); } while (0);

443

444

if (u->in_stop_when_unneeded_queue)

445

return;

446

447

if (!u->stop_when_unneeded)

448

return;

449

450

if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))

451

return;

452

453

LIST_PREPEND(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u)do { typeof(*(u->manager->stop_when_unneeded_queue)) **
_head = &(u->manager->stop_when_unneeded_queue), *_item
= (u); do { if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 453, __PRETTY_FUNCTION__
); } while (0); if ((_item->stop_when_unneeded_queue_next =
*_head)) _item->stop_when_unneeded_queue_next->stop_when_unneeded_queue_prev
= _item; _item->stop_when_unneeded_queue_prev = ((void*)0
); *_head = _item; } while (0);

454

u->in_stop_when_unneeded_queue = true1;

455

}

456

457

static void bidi_set_free(Unit *u, Hashmap *h) {

458

Unit *other;

459

Iterator i;

460

void *v;

461

462

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 462, __PRETTY_FUNCTION__
); } while (0);

463

464

/* Frees the hashmap and makes sure we are dropped from the inverse pointers */

465

466

HASHMAP_FOREACH_KEY(v, other, h, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((h), &(i), (void
**)&(v), (const void**) &(other)); ) {

467

UnitDependency d;

468

469

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)

470

hashmap_remove(other->dependencies[d], u);

471

472

unit_add_to_gc_queue(other);

473

}

474

475

hashmap_free(h);

476

}

477

478

static void unit_remove_transient(Unit *u) {

479

char **i;

480

481

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 481, __PRETTY_FUNCTION__
); } while (0);

482

483

if (!u->transient)

484

return;

485

486

if (u->fragment_path)

487

(void) unlink(u->fragment_path);

488

489

STRV_FOREACH(i, u->dropin_paths)for ((i) = (u->dropin_paths); (i) && *(i); (i)++) {

490

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *pp = NULL((void*)0);

491

492

p = dirname_malloc(*i); /* Get the drop-in directory from the drop-in file */

493

if (!p)

494

continue;

495

496

pp = dirname_malloc(p); /* Get the config directory from the drop-in directory */

497

if (!pp)

498

continue;

499

500

/* Only drop transient drop-ins */

501

if (!path_equal(u->manager->lookup_paths.transient, pp))

502

continue;

503

504

(void) unlink(*i);

505

(void) rmdir(p);

506

}

507

}

508

509

static void unit_free_requires_mounts_for(Unit *u) {

510

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 510, __PRETTY_FUNCTION__
); } while (0);

511

512

for (;;) {

513

_cleanup_free___attribute__((cleanup(freep))) char *path;

514

515

path = hashmap_steal_first_key(u->requires_mounts_for);

516

if (!path)

517

break;

518

else {

519

char s[strlen(path) + 1];

520

521

PATH_FOREACH_PREFIX_MORE(s, path)for (char *_slash = ({ path_simplify(strcpy(s, path), 0); if (
(strcmp((s),("/")) == 0)) s[0] = 0; strrchr(s, 0); }); _slash
&& ((*_slash = 0), 1); _slash = strrchr((s), '/')) {

522

char *y;

523

Set *x;

524

525

x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);

526

if (!x)

527

continue;

528

529

(void) set_remove(x, u);

530

531

if (set_isempty(x)) {

532

(void) hashmap_remove(u->manager->units_requiring_mounts_for, y);

533

free(y);

534

set_free(x);

535

}

536

}

537

}

538

}

539

540

u->requires_mounts_for = hashmap_free(u->requires_mounts_for);

541

}

542

543

static void unit_done(Unit *u) {

544

ExecContext *ec;

545

CGroupContext *cc;

546

547

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 547, __PRETTY_FUNCTION__
); } while (0);

548

549

if (u->type < 0)

550

return;

551

552

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->done)

553

UNIT_VTABLE(u)unit_vtable[(u)->type]->done(u);

554

555

ec = unit_get_exec_context(u);

556

if (ec)

557

exec_context_done(ec);

558

559

cc = unit_get_cgroup_context(u);

560

if (cc)

561

cgroup_context_done(cc);

562

}

563

564

void unit_free(Unit *u) {

565

UnitDependency d;

566

Iterator i;

567

char *t;

568

569

if (!u)

570

return;

571

572

u->transient_file = safe_fclose(u->transient_file);

573

574

if (!MANAGER_IS_RELOADING(u->manager)((u->manager)->n_reloading > 0))

575

unit_remove_transient(u);

576

577

bus_unit_send_removed_signal(u);

578

579

unit_done(u);

580

581

unit_dequeue_rewatch_pids(u);

582

583

sd_bus_slot_unref(u->match_bus_slot);

584

sd_bus_track_unref(u->bus_track);

585

u->deserialized_refs = strv_free(u->deserialized_refs);

586

u->pending_freezer_message = sd_bus_message_unref(u->pending_freezer_message);

587

588

unit_free_requires_mounts_for(u);

589

590

SET_FOREACH(t, u->names, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((u->names), &(i)
, (void**)&(t)); )

591

hashmap_remove_value(u->manager->units, t, u);

592

593

if (!sd_id128_is_null(u->invocation_id))

594

hashmap_remove_value(u->manager->units_by_invocation_id, &u->invocation_id, u);

595

596

if (u->job) {

597

Job *j = u->job;

598

job_uninstall(j);

599

job_free(j);

600

}

601

602

if (u->nop_job) {

603

Job *j = u->nop_job;

604

job_uninstall(j);

605

job_free(j);

606

}

607

608

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)

609

bidi_set_free(u, u->dependencies[d]);

610

611

if (u->on_console)

612

manager_unref_console(u->manager);

613

614

unit_release_cgroup(u);

615

616

if (!MANAGER_IS_RELOADING(u->manager)((u->manager)->n_reloading > 0))

617

unit_unlink_state_files(u);

618

619

unit_unref_uid_gid(u, false0);

620

621

(void) manager_update_failed_units(u->manager, u, false0);

622

set_remove(u->manager->startup_units, u);

623

624

unit_unwatch_all_pids(u);

625

626

unit_ref_unset(&u->slice);

627

while (u->refs_by_target)

628

unit_ref_unset(u->refs_by_target);

629

630

if (u->type != _UNIT_TYPE_INVALID)

631

LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u)do { typeof(*(u->manager->units_by_type[u->type])) *
*_head = &(u->manager->units_by_type[u->type]), *
_item = (u); do { if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 631, __PRETTY_FUNCTION__
); } while (0); if (_item->units_by_type_next) _item->units_by_type_next
->units_by_type_prev = _item->units_by_type_prev; if (_item
->units_by_type_prev) _item->units_by_type_prev->units_by_type_next
= _item->units_by_type_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 631, __PRETTY_FUNCTION__
); } while (0); *_head = _item->units_by_type_next; } _item
->units_by_type_next = _item->units_by_type_prev = ((void
*)0); } while (0);

632

633

if (u->in_load_queue)

634

LIST_REMOVE(load_queue, u->manager->load_queue, u)do { typeof(*(u->manager->load_queue)) **_head = &(
u->manager->load_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 634, __PRETTY_FUNCTION__); }
while (0); if (_item->load_queue_next) _item->load_queue_next
->load_queue_prev = _item->load_queue_prev; if (_item->
load_queue_prev) _item->load_queue_prev->load_queue_next
= _item->load_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 634, __PRETTY_FUNCTION__
); } while (0); *_head = _item->load_queue_next; } _item->
load_queue_next = _item->load_queue_prev = ((void*)0); } while
(0);

635

636

if (u->in_dbus_queue)

637

LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u)do { typeof(*(u->manager->dbus_unit_queue)) **_head = &
(u->manager->dbus_unit_queue), *_item = (u); do { if ((
__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("_item"), "../src/core/unit.c", 637, __PRETTY_FUNCTION__);
} while (0); if (_item->dbus_queue_next) _item->dbus_queue_next
->dbus_queue_prev = _item->dbus_queue_prev; if (_item->
dbus_queue_prev) _item->dbus_queue_prev->dbus_queue_next
= _item->dbus_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 637, __PRETTY_FUNCTION__
); } while (0); *_head = _item->dbus_queue_next; } _item->
dbus_queue_next = _item->dbus_queue_prev = ((void*)0); } while
(0);

638

639

if (u->in_gc_queue)

640

LIST_REMOVE(gc_queue, u->manager->gc_unit_queue, u)do { typeof(*(u->manager->gc_unit_queue)) **_head = &
(u->manager->gc_unit_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 640, __PRETTY_FUNCTION__); }
while (0); if (_item->gc_queue_next) _item->gc_queue_next
->gc_queue_prev = _item->gc_queue_prev; if (_item->gc_queue_prev
) _item->gc_queue_prev->gc_queue_next = _item->gc_queue_next
; else { do { if ((__builtin_expect(!!(!(*_head == _item)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("*_head == _item"
), "../src/core/unit.c", 640, __PRETTY_FUNCTION__); } while (
0); *_head = _item->gc_queue_next; } _item->gc_queue_next
= _item->gc_queue_prev = ((void*)0); } while (0);

641

642

if (u->in_cgroup_realize_queue)

643

LIST_REMOVE(cgroup_realize_queue, u->manager->cgroup_realize_queue, u)do { typeof(*(u->manager->cgroup_realize_queue)) **_head
= &(u->manager->cgroup_realize_queue), *_item = (u
); do { if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 643, __PRETTY_FUNCTION__
); } while (0); if (_item->cgroup_realize_queue_next) _item
->cgroup_realize_queue_next->cgroup_realize_queue_prev =
_item->cgroup_realize_queue_prev; if (_item->cgroup_realize_queue_prev
) _item->cgroup_realize_queue_prev->cgroup_realize_queue_next
= _item->cgroup_realize_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 643, __PRETTY_FUNCTION__
); } while (0); *_head = _item->cgroup_realize_queue_next;
} _item->cgroup_realize_queue_next = _item->cgroup_realize_queue_prev
= ((void*)0); } while (0);

644

645

if (u->in_cgroup_empty_queue)

646

LIST_REMOVE(cgroup_empty_queue, u->manager->cgroup_empty_queue, u)do { typeof(*(u->manager->cgroup_empty_queue)) **_head =
&(u->manager->cgroup_empty_queue), *_item = (u); do
{ if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 646, __PRETTY_FUNCTION__
); } while (0); if (_item->cgroup_empty_queue_next) _item->
cgroup_empty_queue_next->cgroup_empty_queue_prev = _item->
cgroup_empty_queue_prev; if (_item->cgroup_empty_queue_prev
) _item->cgroup_empty_queue_prev->cgroup_empty_queue_next
= _item->cgroup_empty_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 646, __PRETTY_FUNCTION__
); } while (0); *_head = _item->cgroup_empty_queue_next; }
_item->cgroup_empty_queue_next = _item->cgroup_empty_queue_prev
= ((void*)0); } while (0);

647

648

if (u->in_cleanup_queue)

649

LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u)do { typeof(*(u->manager->cleanup_queue)) **_head = &
(u->manager->cleanup_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 649, __PRETTY_FUNCTION__); }
while (0); if (_item->cleanup_queue_next) _item->cleanup_queue_next
->cleanup_queue_prev = _item->cleanup_queue_prev; if (_item
->cleanup_queue_prev) _item->cleanup_queue_prev->cleanup_queue_next
= _item->cleanup_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 649, __PRETTY_FUNCTION__
); } while (0); *_head = _item->cleanup_queue_next; } _item
->cleanup_queue_next = _item->cleanup_queue_prev = ((void
*)0); } while (0);

650

651

if (u->in_target_deps_queue)

652

LIST_REMOVE(target_deps_queue, u->manager->target_deps_queue, u)do { typeof(*(u->manager->target_deps_queue)) **_head =
&(u->manager->target_deps_queue), *_item = (u); do
{ if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 652, __PRETTY_FUNCTION__
); } while (0); if (_item->target_deps_queue_next) _item->
target_deps_queue_next->target_deps_queue_prev = _item->
target_deps_queue_prev; if (_item->target_deps_queue_prev)
_item->target_deps_queue_prev->target_deps_queue_next =
_item->target_deps_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 652, __PRETTY_FUNCTION__
); } while (0); *_head = _item->target_deps_queue_next; } _item
->target_deps_queue_next = _item->target_deps_queue_prev
= ((void*)0); } while (0);

653

654

if (u->in_stop_when_unneeded_queue)

655

LIST_REMOVE(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u)do { typeof(*(u->manager->stop_when_unneeded_queue)) **
_head = &(u->manager->stop_when_unneeded_queue), *_item
= (u); do { if ((__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_item"), "../src/core/unit.c", 655, __PRETTY_FUNCTION__
); } while (0); if (_item->stop_when_unneeded_queue_next) _item
->stop_when_unneeded_queue_next->stop_when_unneeded_queue_prev
= _item->stop_when_unneeded_queue_prev; if (_item->stop_when_unneeded_queue_prev
) _item->stop_when_unneeded_queue_prev->stop_when_unneeded_queue_next
= _item->stop_when_unneeded_queue_next; else { do { if ((
__builtin_expect(!!(!(*_head == _item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("*_head == _item"), "../src/core/unit.c"
, 655, __PRETTY_FUNCTION__); } while (0); *_head = _item->
stop_when_unneeded_queue_next; } _item->stop_when_unneeded_queue_next
= _item->stop_when_unneeded_queue_prev = ((void*)0); } while
(0);

656

657

safe_close(u->ip_accounting_ingress_map_fd);

658

safe_close(u->ip_accounting_egress_map_fd);

659

660

safe_close(u->ipv4_allow_map_fd);

661

safe_close(u->ipv6_allow_map_fd);

662

safe_close(u->ipv4_deny_map_fd);

663

safe_close(u->ipv6_deny_map_fd);

664

665

bpf_program_unref(u->ip_bpf_ingress);

666

bpf_program_unref(u->ip_bpf_ingress_installed);

667

bpf_program_unref(u->ip_bpf_egress);

668

bpf_program_unref(u->ip_bpf_egress_installed);

669

670

condition_free_list(u->conditions);

671

condition_free_list(u->asserts);

672

673

free(u->description);

674

strv_free(u->documentation);

675

free(u->fragment_path);

676

free(u->source_path);

677

strv_free(u->dropin_paths);

678

free(u->instance);

679

680

free(u->job_timeout_reboot_arg);

681

682

set_free_free(u->names);

683

684

free(u->reboot_arg);

685

686

free(u);

687

}

688

689

FreezerState unit_freezer_state(Unit *u) {

690

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 690, __PRETTY_FUNCTION__
); } while (0);

691

692

return u->freezer_state;

693

}

694

695

int unit_freezer_state_kernel(Unit *u, FreezerState *ret) {

696

char *values[1] = {};

697

int r;

698

699

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 699, __PRETTY_FUNCTION__
); } while (0);

700

701

r = cg_get_keyed_attribute(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path, "cgroup.events",

702

STRV_MAKE("frozen")((char**) ((const char*[]) { "frozen", ((void*)0) })), values);

703

if (r < 0)

704

return r;

705

706

r = _FREEZER_STATE_INVALID;

707

708

if (values[0]) {

709

if (streq(values[0], "0")(strcmp((values[0]),("0")) == 0))

710

r = FREEZER_RUNNING;

711

else if (streq(values[0], "1")(strcmp((values[0]),("1")) == 0))

712

r = FREEZER_FROZEN;

713

}

714

715

free(values[0]);

716

*ret = r;

717

718

return 0;

719

}

720

721

UnitActiveState unit_active_state(Unit *u) {

722

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 722, __PRETTY_FUNCTION__
); } while (0);

723

724

if (u->load_state == UNIT_MERGED)

725

return unit_active_state(unit_follow_merge(u));

726

727

/* After a reload it might happen that a unit is not correctly

728

* loaded but still has a process around. That's why we won't

729

* shortcut failed loading to UNIT_INACTIVE_FAILED. */

730

731

return UNIT_VTABLE(u)unit_vtable[(u)->type]->active_state(u);

732

}

733

734

const char* unit_sub_state_to_string(Unit *u) {

735

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 735, __PRETTY_FUNCTION__
); } while (0);

736

737

return UNIT_VTABLE(u)unit_vtable[(u)->type]->sub_state_to_string(u);

738

}

739

740

static int set_complete_move(Set **s, Set **other) {

741

assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/core/unit.c", 741, __PRETTY_FUNCTION__
); } while (0);

742

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 742, __PRETTY_FUNCTION__
); } while (0);

743

744

if (!other)

745

return 0;

746

747

if (*s)

748

return set_move(*s, *other);

749

else

750

*s = TAKE_PTR(*other)({ typeof(*other) _ptr_ = (*other); (*other) = ((void*)0); _ptr_
; });

751

752

return 0;

753

}

754

755

static int hashmap_complete_move(Hashmap **s, Hashmap **other) {

756

assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/core/unit.c", 756, __PRETTY_FUNCTION__
); } while (0);

757

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 757, __PRETTY_FUNCTION__
); } while (0);

758

759

if (!*other)

760

return 0;

761

762

if (*s)

763

return hashmap_move(*s, *other);

764

else

765

*s = TAKE_PTR(*other)({ typeof(*other) _ptr_ = (*other); (*other) = ((void*)0); _ptr_
; });

766

767

return 0;

768

}

769

770

static int merge_names(Unit *u, Unit *other) {

771

char *t;

772

Iterator i;

773

int r;

774

775

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 775, __PRETTY_FUNCTION__
); } while (0);

776

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 776, __PRETTY_FUNCTION__
); } while (0);

777

778

r = set_complete_move(&u->names, &other->names);

779

if (r < 0)

780

return r;

781

782

set_free_free(other->names);

783

other->names = NULL((void*)0);

784

other->id = NULL((void*)0);

785

786

SET_FOREACH(t, u->names, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((u->names), &(i)
, (void**)&(t)); )

787

assert_se(hashmap_replace(u->manager->units, t, u) == 0)do { if ((__builtin_expect(!!(!(hashmap_replace(u->manager
->units, t, u) == 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("hashmap_replace(u->manager->units, t, u) == 0"), "../src/core/unit.c"
, 787, __PRETTY_FUNCTION__); } while (0);

788

789

return 0;

790

}

791

792

static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {

793

unsigned n_reserve;

794

795

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 795, __PRETTY_FUNCTION__
); } while (0);

796

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 796, __PRETTY_FUNCTION__
); } while (0);

797

assert(d < _UNIT_DEPENDENCY_MAX)do { if ((__builtin_expect(!!(!(d < _UNIT_DEPENDENCY_MAX))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("d < _UNIT_DEPENDENCY_MAX"
), "../src/core/unit.c", 797, __PRETTY_FUNCTION__); } while (
0);

798

799

/*

800

* If u does not have this dependency set allocated, there is no need

801

* to reserve anything. In that case other's set will be transferred

802

* as a whole to u by complete_move().

803

*/

804

if (!u->dependencies[d])

805

return 0;

806

807

/* merge_dependencies() will skip a u-on-u dependency */

808

n_reserve = hashmap_size(other->dependencies[d]) - !!hashmap_get(other->dependencies[d], u);

809

810

return hashmap_reserve(u->dependencies[d], n_reserve);

811

}

812

813

static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {

814

Iterator i;

815

Unit *back;

816

void *v;

817

int r;

818

819

/* Merges all dependencies of type 'd' of the unit 'other' into the deps of the unit 'u' */

820

821

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 821, __PRETTY_FUNCTION__
); } while (0);

822

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 822, __PRETTY_FUNCTION__
); } while (0);

823

assert(d < _UNIT_DEPENDENCY_MAX)do { if ((__builtin_expect(!!(!(d < _UNIT_DEPENDENCY_MAX))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("d < _UNIT_DEPENDENCY_MAX"
), "../src/core/unit.c", 823, __PRETTY_FUNCTION__); } while (
0);

824

825

/* Fix backwards pointers. Let's iterate through all dependendent units of the other unit. */

826

HASHMAP_FOREACH_KEY(v, back, other->dependencies[d], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((other->dependencies
[d]), &(i), (void**)&(v), (const void**) &(back))
; ) {

827

UnitDependency k;

828

829

/* Let's now iterate through the dependencies of that dependencies of the other units, looking for

830

* pointers back, and let's fix them up, to instead point to 'u'. */

831

832

for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {

833

if (back == u) {

834

/* Do not add dependencies between u and itself. */

835

if (hashmap_remove(back->dependencies[k], other))

836

maybe_warn_about_dependency(u, other_id, k);

837

} else {

838

UnitDependencyInfo di_u, di_other, di_merged;

839

840

/* Let's drop this dependency between "back" and "other", and let's create it between

841

* "back" and "u" instead. Let's merge the bit masks of the dependency we are moving,

842

* and any such dependency which might already exist */

843

844

di_other.data = hashmap_get(back->dependencies[k], other);

845

if (!di_other.data)

846

continue; /* dependency isn't set, let's try the next one */

847

848

di_u.data = hashmap_get(back->dependencies[k], u);

849

850

di_merged = (UnitDependencyInfo) {

851

.origin_mask = di_u.origin_mask | di_other.origin_mask,

852

.destination_mask = di_u.destination_mask | di_other.destination_mask,

853

};

854

855

r = hashmap_remove_and_replace(back->dependencies[k], other, u, di_merged.data);

856

if (r < 0)

857

log_warning_errno(r, "Failed to remove/replace: back=%s other=%s u=%s: %m", back->id, other_id, u->id)({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 857, __func__, "Failed to remove/replace: back=%s other=%s u=%s: %m"
, back->id, other_id, u->id) : -abs(_e); });

858

assert(r >= 0)do { if ((__builtin_expect(!!(!(r >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("r >= 0"), "../src/core/unit.c", 858,
__PRETTY_FUNCTION__); } while (0);

859

860

/* assert_se(hashmap_remove_and_replace(back->dependencies[k], other, u, di_merged.data) >= 0); */

861

}

862

}

863

864

}

865

866

/* Also do not move dependencies on u to itself */

867

back = hashmap_remove(other->dependencies[d], u);

868

if (back)

869

maybe_warn_about_dependency(u, other_id, d);

870

871

/* The move cannot fail. The caller must have performed a reservation. */

872

assert_se(hashmap_complete_move(&u->dependencies[d], &other->dependencies[d]) == 0)do { if ((__builtin_expect(!!(!(hashmap_complete_move(&u->
dependencies[d], &other->dependencies[d]) == 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("hashmap_complete_move(&u->dependencies[d], &other->dependencies[d]) == 0"
), "../src/core/unit.c", 872, __PRETTY_FUNCTION__); } while (
0);

873

874

other->dependencies[d] = hashmap_free(other->dependencies[d]);

875

}

876

877

int unit_merge(Unit *u, Unit *other) {

878

UnitDependency d;

879

const char *other_id = NULL((void*)0);

880

int r;

881

882

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 882, __PRETTY_FUNCTION__
); } while (0);

883

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 883, __PRETTY_FUNCTION__
); } while (0);

884

assert(u->manager == other->manager)do { if ((__builtin_expect(!!(!(u->manager == other->manager
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("u->manager == other->manager"
), "../src/core/unit.c", 884, __PRETTY_FUNCTION__); } while (
0);

885

assert(u->type != _UNIT_TYPE_INVALID)do { if ((__builtin_expect(!!(!(u->type != _UNIT_TYPE_INVALID
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("u->type != _UNIT_TYPE_INVALID"
), "../src/core/unit.c", 885, __PRETTY_FUNCTION__); } while (
0);

886

887

other = unit_follow_merge(other);

888

889

if (other == u)

890

return 0;

891

892

if (u->type != other->type)

893

return -EINVAL22;

894

895

if (!u->instance != !other->instance)

896

return -EINVAL22;

897

898

if (!unit_type_may_alias(u->type)) /* Merging only applies to unit names that support aliases */

899

return -EEXIST17;

900

901

if (!IN_SET(other->load_state, UNIT_STUB, UNIT_NOT_FOUND)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){UNIT_STUB, UNIT_NOT_FOUND})/sizeof(int)]
; switch(other->load_state) { case UNIT_STUB: case UNIT_NOT_FOUND
: _found = 1; break; default: break; } _found; }))

902

return -EEXIST17;

903

904

if (other->job)

905

return -EEXIST17;

906

907

if (other->nop_job)

908

return -EEXIST17;

909

910

if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))

911

return -EEXIST17;

912

913

if (other->id)

914

other_id = strdupa(other->id)(__extension__ ({ const char *__old = (other->id); size_t __len
= strlen (__old) + 1; char *__new = (char *) __builtin_alloca
(__len); (char *) memcpy (__new, __old, __len); }));

915

916

/* Make reservations to ensure merge_dependencies() won't fail */

917

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {

918

r = reserve_dependencies(u, other, d);

919

/*

920

* We don't rollback reservations if we fail. We don't have

921

* a way to undo reservations. A reservation is not a leak.

922

*/

923

if (r < 0)

924

return r;

925

}

926

927

/* Merge names */

928

r = merge_names(u, other);

929

if (r < 0)

930

return r;

931

932

/* Redirect all references */

933

while (other->refs_by_target)

934

unit_ref_set(other->refs_by_target, other->refs_by_target->source, u);

935

936

/* Merge dependencies */

937

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)

938

merge_dependencies(u, other, other_id, d);

939

940

other->load_state = UNIT_MERGED;

941

other->merged_into = u;

942

943

/* If there is still some data attached to the other node, we

944

* don't need it anymore, and can free it. */

945

if (other->load_state != UNIT_STUB)

946

if (UNIT_VTABLE(other)unit_vtable[(other)->type]->done)

947

UNIT_VTABLE(other)unit_vtable[(other)->type]->done(other);

948

949

unit_add_to_dbus_queue(u);

950

unit_add_to_cleanup_queue(other);

951

952

return 0;

953

}

954

955

int unit_merge_by_name(Unit *u, const char *name) {

956

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

957

Unit *other;

958

int r;

959

960

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 960, __PRETTY_FUNCTION__
); } while (0);

961

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 961, __PRETTY_FUNCTION__
); } while (0);

962

963

if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {

964

if (!u->instance)

965

return -EINVAL22;

966

967

r = unit_name_replace_instance(name, u->instance, &s);

968

if (r < 0)

969

return r;

970

971

name = s;

972

}

973

974

other = manager_get_unit(u->manager, name);

975

if (other)

976

return unit_merge(u, other);

977

978

return unit_add_name(u, name);

979

}

980

981

Unit* unit_follow_merge(Unit *u) {

982

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 982, __PRETTY_FUNCTION__
); } while (0);

983

984

while (u->load_state == UNIT_MERGED)

985

assert_se(u = u->merged_into)do { if ((__builtin_expect(!!(!(u = u->merged_into)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u = u->merged_into"), "../src/core/unit.c"
, 985, __PRETTY_FUNCTION__); } while (0);

986

987

return u;

988

}

989

990

int unit_add_exec_dependencies(Unit *u, ExecContext *c) {

991

ExecDirectoryType dt;

992

char **dp;

993

int r;

994

995

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 995, __PRETTY_FUNCTION__
); } while (0);

996

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 996, __PRETTY_FUNCTION__
); } while (0);

997

998

if (c->working_directory) {

999

r = unit_require_mounts_for(u, c->working_directory, UNIT_DEPENDENCY_FILE);

1000

if (r < 0)

1001

return r;

1002

}

1003

1004

if (c->root_directory) {

1005

r = unit_require_mounts_for(u, c->root_directory, UNIT_DEPENDENCY_FILE);

1006

if (r < 0)

1007

return r;

1008

}

1009

1010

if (c->root_image) {

1011

r = unit_require_mounts_for(u, c->root_image, UNIT_DEPENDENCY_FILE);

1012

if (r < 0)

1013

return r;

1014

}

1015

1016

for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) {

1017

if (!u->manager->prefix[dt])

1018

continue;

1019

1020

STRV_FOREACH(dp, c->directories[dt].paths)for ((dp) = (c->directories[dt].paths); (dp) && *(
dp); (dp)++) {

1021

_cleanup_free___attribute__((cleanup(freep))) char *p;

1022

1023

p = strjoin(u->manager->prefix[dt], "/", *dp)strjoin_real((u->manager->prefix[dt]), "/", *dp, ((void
*)0));

1024

if (!p)

1025

return -ENOMEM12;

1026

1027

r = unit_require_mounts_for(u, p, UNIT_DEPENDENCY_FILE);

1028

if (r < 0)

1029

return r;

1030

}

1031

}

1032

1033

if (!MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM))

1034

return 0;

1035

1036

if (c->private_tmp) {

1037

r = unit_add_dependency_by_name(u, UNIT_AFTER, "tmp.mount", NULL((void*)0), true1, UNIT_DEPENDENCY_FILE);

1038

if (r < 0)

1039

return r;

1040

1041

r = unit_require_mounts_for(u, "/var/tmp", UNIT_DEPENDENCY_FILE);

1042

if (r < 0)

1043

return r;

1044

1045

r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_TMPFILES_SETUP_SERVICE"systemd-tmpfiles-setup.service", NULL((void*)0), true1, UNIT_DEPENDENCY_FILE);

1046

if (r < 0)

1047

return r;

1048

}

1049

1050

if (!IN_SET(c->std_output,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_output) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1051

EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_output) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1052

EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_output) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1053

EXEC_OUTPUT_SYSLOG, EXEC_OUTPUT_SYSLOG_AND_CONSOLE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_output) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; }) &&

1054

!IN_SET(c->std_error,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_error) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1055

EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_error) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1056

EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE,({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_error) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; })

1057

EXEC_OUTPUT_SYSLOG, EXEC_OUTPUT_SYSLOG_AND_CONSOLE)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE
, EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE, EXEC_OUTPUT_SYSLOG
, EXEC_OUTPUT_SYSLOG_AND_CONSOLE})/sizeof(int)]; switch(c->
std_error) { case EXEC_OUTPUT_JOURNAL: case EXEC_OUTPUT_JOURNAL_AND_CONSOLE
: case EXEC_OUTPUT_KMSG: case EXEC_OUTPUT_KMSG_AND_CONSOLE: case
EXEC_OUTPUT_SYSLOG: case EXEC_OUTPUT_SYSLOG_AND_CONSOLE: _found
= 1; break; default: break; } _found; }))

1058

return 0;

1059

1060

/* If syslog or kernel logging is requested, make sure our own

1061

* logging daemon is run first. */

1062

1063

r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET"systemd-journald.socket", NULL((void*)0), true1, UNIT_DEPENDENCY_FILE);

1064

if (r < 0)

1065

return r;

1066

1067

return 0;

1068

}

1069

1070

const char *unit_description(Unit *u) {

1071

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1071, __PRETTY_FUNCTION__
); } while (0);

1072

1073

if (u->description)

1074

return u->description;

1075

1076

return strna(u->id);

1077

}

1078

1079

static void print_unit_dependency_mask(FILE *f, const char *kind, UnitDependencyMask mask, bool_Bool *space) {

1080

const struct {

1081

UnitDependencyMask mask;

1082

const char *name;

1083

} table[] = {

1084

{ UNIT_DEPENDENCY_FILE, "file" },

1085

{ UNIT_DEPENDENCY_IMPLICIT, "implicit" },

1086

{ UNIT_DEPENDENCY_DEFAULT, "default" },

1087

{ UNIT_DEPENDENCY_UDEV, "udev" },

1088

{ UNIT_DEPENDENCY_PATH, "path" },

1089

{ UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT, "mountinfo-implicit" },

1090

{ UNIT_DEPENDENCY_MOUNTINFO_DEFAULT, "mountinfo-default" },

1091

{ UNIT_DEPENDENCY_PROC_SWAP, "proc-swap" },

1092

};

1093

size_t i;

1094

1095

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 1095, __PRETTY_FUNCTION__
); } while (0);

1096

assert(kind)do { if ((__builtin_expect(!!(!(kind)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("kind"), "../src/core/unit.c", 1096, __PRETTY_FUNCTION__
); } while (0);

1097

assert(space)do { if ((__builtin_expect(!!(!(space)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("space"), "../src/core/unit.c", 1097, __PRETTY_FUNCTION__
); } while (0);

1098

1099

for (i = 0; i < ELEMENTSOF(table)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(table), typeof(&*(table))), sizeof(table)/sizeof(
(table)[0]), ((void)0))); i++) {

1100

1101

if (mask == 0)

1102

break;

1103

1104

if (FLAGS_SET(mask, table[i].mask)(((mask) & (table[i].mask)) == (table[i].mask))) {

1105

if (*space)

1106

fputc(' ', f);

1107

else

1108

*space = true1;

1109

1110

fputs(kind, f);

1111

fputs("-", f);

1112

fputs(table[i].name, f);

1113

1114

mask &= ~table[i].mask;

1115

}

1116

}

1117

1118

assert(mask == 0)do { if ((__builtin_expect(!!(!(mask == 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("mask == 0"), "../src/core/unit.c", 1118
, __PRETTY_FUNCTION__); } while (0);

1119

}

1120

1121

void unit_dump(Unit *u, FILE *f, const char *prefix) {

1122

char *t, **j;

1123

UnitDependency d;

1124

Iterator i;

1125

const char *prefix2;

1126

char

1127

timestamp0[FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1)],

1128

timestamp1[FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1)],

1129

timestamp2[FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1)],

1130

timestamp3[FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1)],

1131

timestamp4[FORMAT_TIMESTAMP_MAX(3+1+10+1+8+1+6+1+6+1)],

1132

timespan[FORMAT_TIMESPAN_MAX64];

1133

Unit *following;

1134

_cleanup_set_free___attribute__((cleanup(set_freep))) Set *following_set = NULL((void*)0);

1135

const char *n;

1136

CGroupMask m;

1137

int r;

1138

1139

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1139, __PRETTY_FUNCTION__
); } while (0);

1140

assert(u->type >= 0)do { if ((__builtin_expect(!!(!(u->type >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u->type >= 0"), "../src/core/unit.c"
, 1140, __PRETTY_FUNCTION__); } while (0);

1141

1142

prefix = strempty(prefix);

1143

prefix2 = strjoina(prefix, "\t")({ const char *_appendees_[] = { prefix, "\t" }; char *_d_, *
_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

1144

1145

fprintf(f,

1146

"%s-> Unit %s:\n"

1147

"%s\tDescription: %s\n"

1148

"%s\tInstance: %s\n"

1149

"%s\tUnit Load State: %s\n"

1150

"%s\tUnit Active State: %s\n"

1151

"%s\tState Change Timestamp: %s\n"

1152

"%s\tInactive Exit Timestamp: %s\n"

1153

"%s\tActive Enter Timestamp: %s\n"

1154

"%s\tActive Exit Timestamp: %s\n"

1155

"%s\tInactive Enter Timestamp: %s\n"

1156

"%s\tMay GC: %s\n"

1157

"%s\tNeed Daemon Reload: %s\n"

1158

"%s\tTransient: %s\n"

1159

"%s\tPerpetual: %s\n"

1160

"%s\tGarbage Collection Mode: %s\n"

1161

"%s\tSlice: %s\n"

1162

"%s\tCGroup: %s\n"

1163

"%s\tCGroup realized: %s\n",

1164

prefix, u->id,

1165

prefix, unit_description(u),

1166

prefix, strna(u->instance),

1167

prefix, unit_load_state_to_string(u->load_state),

1168

prefix, unit_active_state_to_string(unit_active_state(u)),

1169

prefix, strna(format_timestamp(timestamp0, sizeof(timestamp0), u->state_change_timestamp.realtime)),

1170

prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),

1171

prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),

1172

prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),

1173

prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),

1174

prefix, yes_no(unit_may_gc(u)),

1175

prefix, yes_no(unit_need_daemon_reload(u)),

1176

prefix, yes_no(u->transient),

1177

prefix, yes_no(u->perpetual),

1178

prefix, collect_mode_to_string(u->collect_mode),

1179

prefix, strna(unit_slice_name(u)),

1180

prefix, strna(u->cgroup_path),

1181

prefix, yes_no(u->cgroup_realized));

1182

1183

if (u->cgroup_realized_mask != 0) {

1184

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

1185

(void) cg_mask_to_string(u->cgroup_realized_mask, &s);

1186

fprintf(f, "%s\tCGroup realized mask: %s\n", prefix, strnull(s));

1187

}

1188

if (u->cgroup_enabled_mask != 0) {

1189

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

1190

(void) cg_mask_to_string(u->cgroup_enabled_mask, &s);

1191

fprintf(f, "%s\tCGroup enabled mask: %s\n", prefix, strnull(s));

1192

}

1193

m = unit_get_own_mask(u);

1194

if (m != 0) {

1195

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

1196

(void) cg_mask_to_string(m, &s);

1197

fprintf(f, "%s\tCGroup own mask: %s\n", prefix, strnull(s));

1198

}

1199

m = unit_get_members_mask(u);

1200

if (m != 0) {

1201

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

1202

(void) cg_mask_to_string(m, &s);

1203

fprintf(f, "%s\tCGroup members mask: %s\n", prefix, strnull(s));

1204

}

1205

1206

SET_FOREACH(t, u->names, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((u->names), &(i)
, (void**)&(t)); )

1207

fprintf(f, "%s\tName: %s\n", prefix, t);

1208

1209

if (!sd_id128_is_null(u->invocation_id))

1210

fprintf(f, "%s\tInvocation ID: " SD_ID128_FORMAT_STR"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" "\n",

1211

prefix, SD_ID128_FORMAT_VAL(u->invocation_id)(u->invocation_id).bytes[0], (u->invocation_id).bytes[1
], (u->invocation_id).bytes[2], (u->invocation_id).bytes
[3], (u->invocation_id).bytes[4], (u->invocation_id).bytes
[5], (u->invocation_id).bytes[6], (u->invocation_id).bytes
[7], (u->invocation_id).bytes[8], (u->invocation_id).bytes
[9], (u->invocation_id).bytes[10], (u->invocation_id).bytes
[11], (u->invocation_id).bytes[12], (u->invocation_id).
bytes[13], (u->invocation_id).bytes[14], (u->invocation_id
).bytes[15]);

1212

1213

STRV_FOREACH(j, u->documentation)for ((j) = (u->documentation); (j) && *(j); (j)++)

1214

fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);

1215

1216

following = unit_following(u);

1217

if (following)

1218

fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);

1219

1220

r = unit_following_set(u, &following_set);

1221

if (r >= 0) {

1222

Unit *other;

1223

1224

SET_FOREACH(other, following_set, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((following_set), &(
i), (void**)&(other)); )

1225

fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);

1226

}

1227

1228

if (u->fragment_path)

1229

fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);

1230

1231

if (u->source_path)

1232

fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);

1233

1234

STRV_FOREACH(j, u->dropin_paths)for ((j) = (u->dropin_paths); (j) && *(j); (j)++)

1235

fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);

1236

1237

if (u->failure_action != EMERGENCY_ACTION_NONE)

1238

fprintf(f, "%s\tFailure Action: %s\n", prefix, emergency_action_to_string(u->failure_action));

1239

if (u->success_action != EMERGENCY_ACTION_NONE)

1240

fprintf(f, "%s\tSuccess Action: %s\n", prefix, emergency_action_to_string(u->success_action));

1241

1242

if (u->job_timeout != USEC_INFINITY((usec_t) -1))

1243

fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));

1244

1245

if (u->job_timeout_action != EMERGENCY_ACTION_NONE)

1246

fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, emergency_action_to_string(u->job_timeout_action));

1247

1248

if (u->job_timeout_reboot_arg)

1249

fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);

1250

1251

condition_dump_list(u->conditions, f, prefix, condition_type_to_string);

1252

condition_dump_list(u->asserts, f, prefix, assert_type_to_string);

1253

1254

if (dual_timestamp_is_set(&u->condition_timestamp))

1255

fprintf(f,

1256

"%s\tCondition Timestamp: %s\n"

1257

"%s\tCondition Result: %s\n",

1258

prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),

1259

prefix, yes_no(u->condition_result));

1260

1261

if (dual_timestamp_is_set(&u->assert_timestamp))

1262

fprintf(f,

1263

"%s\tAssert Timestamp: %s\n"

1264

"%s\tAssert Result: %s\n",

1265

prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),

1266

prefix, yes_no(u->assert_result));

1267

1268

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {

1269

UnitDependencyInfo di;

1270

Unit *other;

1271

1272

HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[d]), &(i), (void**)&(di.data), (const void**) &(
other)); ) {

1273

bool_Bool space = false0;

1274

1275

fprintf(f, "%s\t%s: %s (", prefix, unit_dependency_to_string(d), other->id);

1276

1277

print_unit_dependency_mask(f, "origin", di.origin_mask, &space);

1278

print_unit_dependency_mask(f, "destination", di.destination_mask, &space);

1279

1280

fputs(")\n", f);

1281

}

1282

}

1283

1284

if (!hashmap_isempty(u->requires_mounts_for)) {

1285

UnitDependencyInfo di;

1286

const char *path;

1287

1288

HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->requires_mounts_for
), &(i), (void**)&(di.data), (const void**) &(path
)); ) {

1289

bool_Bool space = false0;

1290

1291

fprintf(f, "%s\tRequiresMountsFor: %s (", prefix, path);

1292

1293

print_unit_dependency_mask(f, "origin", di.origin_mask, &space);

1294

print_unit_dependency_mask(f, "destination", di.destination_mask, &space);

1295

1296

fputs(")\n", f);

1297

}

1298

}

1299

1300

if (u->load_state == UNIT_LOADED) {

1301

1302

fprintf(f,

1303

"%s\tStopWhenUnneeded: %s\n"

1304

"%s\tRefuseManualStart: %s\n"

1305

"%s\tRefuseManualStop: %s\n"

1306

"%s\tDefaultDependencies: %s\n"

1307

"%s\tOnFailureJobMode: %s\n"

1308

"%s\tIgnoreOnIsolate: %s\n",

1309

prefix, yes_no(u->stop_when_unneeded),

1310

prefix, yes_no(u->refuse_manual_start),

1311

prefix, yes_no(u->refuse_manual_stop),

1312

prefix, yes_no(u->default_dependencies),

1313

prefix, job_mode_to_string(u->on_failure_job_mode),

1314

prefix, yes_no(u->ignore_on_isolate));

1315

1316

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->dump)

1317

UNIT_VTABLE(u)unit_vtable[(u)->type]->dump(u, f, prefix2);

1318

1319

} else if (u->load_state == UNIT_MERGED)

1320

fprintf(f,

1321

"%s\tMerged into: %s\n",

1322

prefix, u->merged_into->id);

1323

else if (u->load_state == UNIT_ERROR)

1324

fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));

1325

1326

for (n = sd_bus_track_first(u->bus_track); n; n = sd_bus_track_next(u->bus_track))

1327

fprintf(f, "%s\tBus Ref: %s\n", prefix, n);

1328

1329

if (u->job)

1330

job_dump(u->job, f, prefix2);

1331

1332

if (u->nop_job)

1333

job_dump(u->nop_job, f, prefix2);

1334

}

1335

1336

/* Common implementation for multiple backends */

1337

int unit_load_fragment_and_dropin(Unit *u) {

1338

int r;

1339

1340

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1340, __PRETTY_FUNCTION__
); } while (0);

1341

1342

/* Load a .{service,socket,...} file */

1343

r = unit_load_fragment(u);

1344

if (r < 0)

1345

return r;

1346

1347

if (u->load_state == UNIT_STUB)

1348

return -ENOENT2;

1349

1350

/* Load drop-in directory data. If u is an alias, we might be reloading the

1351

* target unit needlessly. But we cannot be sure which drops-ins have already

1352

* been loaded and which not, at least without doing complicated book-keeping,

1353

* so let's always reread all drop-ins. */

1354

return unit_load_dropin(unit_follow_merge(u));

1355

}

1356

1357

/* Common implementation for multiple backends */

1358

int unit_load_fragment_and_dropin_optional(Unit *u) {

1359

int r;

1360

1361

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1361, __PRETTY_FUNCTION__
); } while (0);

1362

1363

/* Same as unit_load_fragment_and_dropin(), but whether

1364

* something can be loaded or not doesn't matter. */

1365

1366

/* Load a .service/.socket/.slice/… file */

1367

r = unit_load_fragment(u);

1368

if (r < 0)

1369

return r;

1370

1371

if (u->load_state == UNIT_STUB)

1372

u->load_state = UNIT_LOADED;

1373

1374

/* Load drop-in directory data */

1375

return unit_load_dropin(unit_follow_merge(u));

1376

}

1377

1378

void unit_add_to_target_deps_queue(Unit *u) {

1379

Manager *m = u->manager;

1380

1381

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1381, __PRETTY_FUNCTION__
); } while (0);

1382

1383

if (u->in_target_deps_queue)

1384

return;

1385

1386

LIST_PREPEND(target_deps_queue, m->target_deps_queue, u)do { typeof(*(m->target_deps_queue)) **_head = &(m->
target_deps_queue), *_item = (u); do { if ((__builtin_expect(
!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, (
"_item"), "../src/core/unit.c", 1386, __PRETTY_FUNCTION__); }
while (0); if ((_item->target_deps_queue_next = *_head)) _item
->target_deps_queue_next->target_deps_queue_prev = _item
; _item->target_deps_queue_prev = ((void*)0); *_head = _item
; } while (0);

1387

u->in_target_deps_queue = true1;

1388

}

1389

1390

int unit_add_default_target_dependency(Unit *u, Unit *target) {

1391

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1391, __PRETTY_FUNCTION__
); } while (0);

1392

assert(target)do { if ((__builtin_expect(!!(!(target)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("target"), "../src/core/unit.c", 1392, __PRETTY_FUNCTION__
); } while (0);

1393

1394

if (target->type != UNIT_TARGET)

1395

return 0;

1396

1397

/* Only add the dependency if both units are loaded, so that

1398

* that loop check below is reliable */

1399

if (u->load_state != UNIT_LOADED ||

1400

target->load_state != UNIT_LOADED)

1401

return 0;

1402

1403

/* If either side wants no automatic dependencies, then let's

1404

* skip this */

1405

if (!u->default_dependencies ||

1406

!target->default_dependencies)

1407

return 0;

1408

1409

/* Don't create loops */

1410

if (hashmap_get(target->dependencies[UNIT_BEFORE], u))

1411

return 0;

1412

1413

return unit_add_dependency(target, UNIT_AFTER, u, true1, UNIT_DEPENDENCY_DEFAULT);

1414

}

1415

1416

static int unit_add_slice_dependencies(Unit *u) {

1417

UnitDependencyMask mask;

1418

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1418, __PRETTY_FUNCTION__
); } while (0);

1419

1420

if (!UNIT_HAS_CGROUP_CONTEXT(u)(unit_vtable[(u)->type]->cgroup_context_offset > 0))

1421

return 0;

1422

1423

/* Slice units are implicitly ordered against their parent slices (as this relationship is encoded in the

1424

name), while all other units are ordered based on configuration (as in their case Slice= configures the

1425

relationship). */

1426

mask = u->type == UNIT_SLICE ? UNIT_DEPENDENCY_IMPLICIT : UNIT_DEPENDENCY_FILE;

1427

1428

if (UNIT_ISSET(u->slice)(!!(u->slice).target))

1429

return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT_DEREF(u->slice)((u->slice).target), true1, mask);

1430

1431

if (unit_has_name(u, SPECIAL_ROOT_SLICE"-.slice"))

1432

return 0;

1433

1434

return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_ROOT_SLICE"-.slice", NULL((void*)0), true1, mask);

1435

}

1436

1437

static int unit_add_mount_dependencies(Unit *u) {

1438

UnitDependencyInfo di;

1439

const char *path;

1440

Iterator i;

1441

int r;

1442

1443

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1443, __PRETTY_FUNCTION__
); } while (0);

1444

1445

HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->requires_mounts_for
), &(i), (void**)&(di.data), (const void**) &(path
)); ) {

1446

char prefix[strlen(path) + 1];

1447

1448

PATH_FOREACH_PREFIX_MORE(prefix, path)for (char *_slash = ({ path_simplify(strcpy(prefix, path), 0)
; if ((strcmp((prefix),("/")) == 0)) prefix[0] = 0; strrchr(prefix
, 0); }); _slash && ((*_slash = 0), 1); _slash = strrchr
((prefix), '/')) {

1449

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

1450

Unit *m;

1451

1452

r = unit_name_from_path(prefix, ".mount", &p);

1453

if (r < 0)

1454

return r;

1455

1456

m = manager_get_unit(u->manager, p);

1457

if (!m) {

1458

/* Make sure to load the mount unit if

1459

* it exists. If so the dependencies

1460

* on this unit will be added later

1461

* during the loading of the mount

1462

* unit. */

1463

(void) manager_load_unit_prepare(u->manager, p, NULL((void*)0), NULL((void*)0), &m);

1464

continue;

1465

}

1466

if (m == u)

1467

continue;

1468

1469

if (m->load_state != UNIT_LOADED)

1470

continue;

1471

1472

r = unit_add_dependency(u, UNIT_AFTER, m, true1, di.origin_mask);

1473

if (r < 0)

1474

return r;

1475

1476

if (m->fragment_path && !streq(m->id, "tmp.mount")(strcmp((m->id),("tmp.mount")) == 0)) {

1477

r = unit_add_dependency(u, UNIT_REQUIRES, m, true1, di.origin_mask);

1478

if (r < 0)

1479

return r;

1480

}

1481

}

1482

}

1483

1484

return 0;

1485

}

1486

1487

static int unit_add_startup_units(Unit *u) {

1488

CGroupContext *c;

1489

int r;

1490

1491

c = unit_get_cgroup_context(u);

1492

if (!c)

1493

return 0;

1494

1495

if (c->startup_cpu_shares == CGROUP_CPU_SHARES_INVALID((uint64_t) -1) &&

1496

c->startup_io_weight == CGROUP_WEIGHT_INVALID((uint64_t) -1) &&

1497

c->startup_blockio_weight == CGROUP_BLKIO_WEIGHT_INVALID((uint64_t) -1))

1498

return 0;

1499

1500

r = set_ensure_allocated(&u->manager->startup_units, NULL)internal_set_ensure_allocated(&u->manager->startup_units
, ((void*)0) );

1501

if (r < 0)

1502

return r;

1503

1504

return set_put(u->manager->startup_units, u);

1505

}

1506

1507

int unit_load(Unit *u) {

1508

int r;

1509

1510

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1510, __PRETTY_FUNCTION__
); } while (0);

1511

1512

if (u->in_load_queue) {

1513

LIST_REMOVE(load_queue, u->manager->load_queue, u)do { typeof(*(u->manager->load_queue)) **_head = &(
u->manager->load_queue), *_item = (u); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 1513, __PRETTY_FUNCTION__);
} while (0); if (_item->load_queue_next) _item->load_queue_next
->load_queue_prev = _item->load_queue_prev; if (_item->
load_queue_prev) _item->load_queue_prev->load_queue_next
= _item->load_queue_next; else { do { if ((__builtin_expect
(!!(!(*_head == _item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("*_head == _item"), "../src/core/unit.c", 1513, __PRETTY_FUNCTION__
); } while (0); *_head = _item->load_queue_next; } _item->
load_queue_next = _item->load_queue_prev = ((void*)0); } while
(0);

1514

u->in_load_queue = false0;

1515

}

1516

1517

if (u->type == _UNIT_TYPE_INVALID)

1518

return -EINVAL22;

1519

1520

if (u->load_state != UNIT_STUB)

1521

return 0;

1522

1523

if (u->transient_file) {

1524

r = fflush_and_check(u->transient_file);

1525

if (r < 0)

1526

goto fail;

1527

1528

u->transient_file = safe_fclose(u->transient_file);

1529

u->fragment_mtime = now(CLOCK_REALTIME0);

1530

}

1531

1532

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->load) {

1533

r = UNIT_VTABLE(u)unit_vtable[(u)->type]->load(u);

1534

if (r < 0)

1535

goto fail;

1536

}

1537

1538

if (u->load_state == UNIT_STUB) {

1539

r = -ENOENT2;

1540

goto fail;

1541

}

1542

1543

if (u->load_state == UNIT_LOADED) {

1544

unit_add_to_target_deps_queue(u);

1545

1546

r = unit_add_slice_dependencies(u);

1547

if (r < 0)

1548

goto fail;

1549

1550

r = unit_add_mount_dependencies(u);

1551

if (r < 0)

1552

goto fail;

1553

1554

r = unit_add_startup_units(u);

1555

if (r < 0)

1556

goto fail;

1557

1558

if (u->on_failure_job_mode == JOB_ISOLATE && hashmap_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {

1559

log_unit_error(u, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.")({ const Unit *_u = (u); _u ? log_object_internal(3, 0, "../src/core/unit.c"
, 1559, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing."
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((3
))), 0, "../src/core/unit.c", 1559, __func__, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing."
); });

1560

r = -ENOEXEC8;

1561

goto fail;

1562

}

1563

1564

if (u->job_running_timeout != USEC_INFINITY((usec_t) -1) && u->job_running_timeout > u->job_timeout)

1565

log_unit_warning(u, "JobRunningTimeoutSec= is greater than JobTimeoutSec=, it has no effect.")({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1565, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "JobRunningTimeoutSec= is greater than JobTimeoutSec=, it has no effect."
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((4
))), 0, "../src/core/unit.c", 1565, __func__, "JobRunningTimeoutSec= is greater than JobTimeoutSec=, it has no effect."
); });

1566

1567

unit_update_cgroup_members_masks(u);

1568

}

1569

1570

assert((u->load_state != UNIT_MERGED) == !u->merged_into)do { if ((__builtin_expect(!!(!((u->load_state != UNIT_MERGED
) == !u->merged_into)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("(u->load_state != UNIT_MERGED) == !u->merged_into")
, "../src/core/unit.c", 1570, __PRETTY_FUNCTION__); } while (
0);

1571

1572

unit_add_to_dbus_queue(unit_follow_merge(u));

1573

unit_add_to_gc_queue(u);

1574

1575

return 0;

1576

1577

fail:

1578

/* We convert ENOEXEC errors to the UNIT_BAD_SETTING load state here. Configuration parsing code should hence

1579

* return ENOEXEC to ensure units are placed in this state after loading */

1580

1581

u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND :

1582

r == -ENOEXEC8 ? UNIT_BAD_SETTING :

1583

UNIT_ERROR;

1584

u->load_error = r;

1585

1586

unit_add_to_dbus_queue(u);

1587

unit_add_to_gc_queue(u);

1588

1589

return log_unit_debug_errno(u, r, "Failed to load configuration: %m")({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 1589, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to load configuration: %m") : log_internal_realm(((
LOG_REALM_SYSTEMD) << 10 | ((7))), r, "../src/core/unit.c"
, 1589, __func__, "Failed to load configuration: %m"); });

1590

}

1591

1592

static bool_Bool unit_condition_test_list(Unit *u, Condition *first, const char *(*to_string)(ConditionType t)) {

1593

Condition *c;

1594

int triggered = -1;

1595

1596

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1596, __PRETTY_FUNCTION__
); } while (0);

1597

assert(to_string)do { if ((__builtin_expect(!!(!(to_string)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("to_string"), "../src/core/unit.c", 1597
, __PRETTY_FUNCTION__); } while (0);

1598

1599

/* If the condition list is empty, then it is true */

1600

if (!first)

1601

return true1;

1602

1603

/* Otherwise, if all of the non-trigger conditions apply and

1604

* if any of the trigger conditions apply (unless there are

1605

* none) we return true */

1606

LIST_FOREACH(conditions, c, first)for ((c) = (first); (c); (c) = (c)->conditions_next) {

1607

int r;

1608

1609

r = condition_test(c);

1610

if (r < 0)

1611

log_unit_warning(u,({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); })

1612

"Couldn't determine result for %s=%s%s%s, assuming failed: %m",({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); })

1613

to_string(c->type),({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); })

1614

c->trigger ? "|" : "",({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); })

1615

c->negate ? "!" : "",({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); })

1616

c->parameter)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1616, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), 0, "../src/core/unit.c", 1616, __func__
, "Couldn't determine result for %s=%s%s%s, assuming failed: %m"
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter); });

1617

else

1618

log_unit_debug(u,({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1619

"%s=%s%s%s %s.",({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1620

to_string(c->type),({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1621

c->trigger ? "|" : "",({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1622

c->negate ? "!" : "",({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1623

c->parameter,({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); })

1624

condition_result_to_string(c->result))({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1624, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s=%s%s%s %s.", to_string(c->type), c->trigger ? "|"
: "", c->negate ? "!" : "", c->parameter, condition_result_to_string
(c->result)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 1624, __func__, "%s=%s%s%s %s."
, to_string(c->type), c->trigger ? "|" : "", c->negate
? "!" : "", c->parameter, condition_result_to_string(c->
result)); });

1625

1626

if (!c->trigger && r <= 0)

1627

return false0;

1628

1629

if (c->trigger && triggered <= 0)

1630

triggered = r > 0;

1631

}

1632

1633

return triggered != 0;

1634

}

1635

1636

static bool_Bool unit_condition_test(Unit *u) {

1637

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1637, __PRETTY_FUNCTION__
); } while (0);

1638

1639

dual_timestamp_get(&u->condition_timestamp);

1640

u->condition_result = unit_condition_test_list(u, u->conditions, condition_type_to_string);

1641

1642

return u->condition_result;

1643

}

1644

1645

static bool_Bool unit_assert_test(Unit *u) {

1646

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1646, __PRETTY_FUNCTION__
); } while (0);

1647

1648

dual_timestamp_get(&u->assert_timestamp);

1649

u->assert_result = unit_condition_test_list(u, u->asserts, assert_type_to_string);

1650

1651

return u->assert_result;

1652

}

1653

1654

void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {

1655

DISABLE_WARNING_FORMAT_NONLITERALGCC diagnostic push ; GCC diagnostic ignored "-Wformat-nonliteral"
;

1656

manager_status_printf(u->manager, STATUS_TYPE_NORMAL, status, unit_status_msg_format, unit_description(u));

1657

REENABLE_WARNINGGCC diagnostic pop ;

1658

}

1659

1660

1661

int unit_start_limit_test(Unit *u) {

1662

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1662, __PRETTY_FUNCTION__
); } while (0);

1663

1664

if (ratelimit_below(&u->start_limit)) {

1665

u->start_limit_hit = false0;

1666

return 0;

1667

}

1668

1669

log_unit_warning(u, "Start request repeated too quickly.")({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1669, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Start request repeated too quickly.") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((4))), 0, "../src/core/unit.c"
, 1669, __func__, "Start request repeated too quickly."); });

1670

u->start_limit_hit = true1;

1671

1672

return emergency_action(u->manager, u->start_limit_action, u->reboot_arg, "unit failed");

1673

}

1674

1675

bool_Bool unit_shall_confirm_spawn(Unit *u) {

1676

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1676, __PRETTY_FUNCTION__
); } while (0);

1677

1678

if (manager_is_confirm_spawn_disabled(u->manager))

1679

return false0;

1680

1681

/* For some reasons units remaining in the same process group

1682

* as PID 1 fail to acquire the console even if it's not used

1683

* by any process. So skip the confirmation question for them. */

1684

return !unit_get_exec_context(u)->same_pgrp;

1685

}

1686

1687

static bool_Bool unit_verify_deps(Unit *u) {

1688

Unit *other;

1689

Iterator j;

1690

void *v;

1691

1692

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1692, __PRETTY_FUNCTION__
); } while (0);

1693

1694

/* Checks whether all BindsTo= dependencies of this unit are fulfilled — if they are also combined with

1695

* After=. We do not check Requires= or Requisite= here as they only should have an effect on the job

1696

* processing, but do not have any effect afterwards. We don't check BindsTo= dependencies that are not used in

1697

* conjunction with After= as for them any such check would make things entirely racy. */

1698

1699

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], j)for ((j) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_BINDS_TO]), &(j), (void**)&(v), (const void**) &
(other)); ) {

1700

1701

if (!hashmap_contains(u->dependencies[UNIT_AFTER], other))

1702

continue;

1703

1704

if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(other))) {

1705

log_unit_notice(u, "Bound to unit %s, but unit isn't active.", other->id)({ const Unit *_u = (u); _u ? log_object_internal(5, 0, "../src/core/unit.c"
, 1705, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Bound to unit %s, but unit isn't active.", other->id) :
log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((5)))
, 0, "../src/core/unit.c", 1705, __func__, "Bound to unit %s, but unit isn't active."
, other->id); });

1706

return false0;

1707

}

1708

}

1709

1710

return true1;

1711

}

1712

1713

/* Errors:

1714

* -EBADR: This unit type does not support starting.

1715

* -EALREADY: Unit is already started.

1716

* -EAGAIN: An operation is already in progress. Retry later.

1717

* -ECANCELED: Too many requests for now.

1718

* -EPROTO: Assert failed

1719

* -EINVAL: Unit not loaded

1720

* -EOPNOTSUPP: Unit type not supported

1721

* -ENOLINK: The necessary dependencies are not fulfilled.

1722

* -ESTALE: This unit has been started before and can't be started a second time

1723

*/

1724

int unit_start(Unit *u) {

1725

UnitActiveState state;

1726

Unit *following;

1727

1728

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1728, __PRETTY_FUNCTION__
); } while (0);

1729

1730

/* If this is already started, then this will succeed. Note

1731

* that this will even succeed if this unit is not startable

1732

* by the user. This is relied on to detect when we need to

1733

* wait for units and when waiting is finished. */

1734

state = unit_active_state(u);

1735

if (UNIT_IS_ACTIVE_OR_RELOADING(state))

1736

return -EALREADY114;

1737

1738

/* Units that aren't loaded cannot be started */

1739

if (u->load_state != UNIT_LOADED)

1740

return -EINVAL22;

1741

1742

/* Refuse starting scope units more than once */

1743

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->once_only && dual_timestamp_is_set(&u->inactive_enter_timestamp))

1744

return -ESTALE116;

1745

1746

/* If the conditions failed, don't do anything at all. If we

1747

* already are activating this call might still be useful to

1748

* speed up activation in case there is some hold-off time,

1749

* but we don't want to recheck the condition in that case. */

1750

if (state != UNIT_ACTIVATING &&

1751

!unit_condition_test(u)) {

1752

log_unit_debug(u, "Starting requested but condition failed. Not starting unit.")({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1752, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Starting requested but condition failed. Not starting unit."
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7
))), 0, "../src/core/unit.c", 1752, __func__, "Starting requested but condition failed. Not starting unit."
); });

1753

return -EALREADY114;

1754

}

1755

1756

/* If the asserts failed, fail the entire job */

1757

if (state != UNIT_ACTIVATING &&

1758

!unit_assert_test(u)) {

1759

log_unit_notice(u, "Starting requested but asserts failed.")({ const Unit *_u = (u); _u ? log_object_internal(5, 0, "../src/core/unit.c"
, 1759, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Starting requested but asserts failed.") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 1759, __func__, "Starting requested but asserts failed."); }
);

1760

return -EPROTO71;

1761

}

1762

1763

/* Units of types that aren't supported cannot be

1764

* started. Note that we do this test only after the condition

1765

* checks, so that we rather return condition check errors

1766

* (which are usually not considered a true failure) than "not

1767

* supported" errors (which are considered a failure).

1768

*/

1769

if (!unit_supported(u))

1770

return -EOPNOTSUPP95;

1771

1772

/* Let's make sure that the deps really are in order before we start this. Normally the job engine should have

1773

* taken care of this already, but let's check this here again. After all, our dependencies might not be in

1774

* effect anymore, due to a reload or due to a failed condition. */

1775

if (!unit_verify_deps(u))

1776

return -ENOLINK67;

1777

1778

/* Forward to the main object, if we aren't it. */

1779

following = unit_following(u);

1780

if (following) {

1781

log_unit_debug(u, "Redirecting start request from %s to %s.", u->id, following->id)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1781, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Redirecting start request from %s to %s.", u->id, following
->id) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10
| ((7))), 0, "../src/core/unit.c", 1781, __func__, "Redirecting start request from %s to %s."
, u->id, following->id); });

1782

return unit_start(following);

1783

}

1784

1785

/* If it is stopped, but we cannot start it, then fail */

1786

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->start)

1787

return -EBADR53;

1788

1789

/* We don't suppress calls to ->start() here when we are

1790

* already starting, to allow this request to be used as a

1791

* "hurry up" call, for example when the unit is in some "auto

1792

* restart" state where it waits for a holdoff timer to elapse

1793

* before it will start again. */

1794

1795

unit_add_to_dbus_queue(u);

1796

unit_cgroup_freezer_action(u, FREEZER_THAW);

1797

1798

return UNIT_VTABLE(u)unit_vtable[(u)->type]->start(u);

1799

}

1800

1801

bool_Bool unit_can_start(Unit *u) {

1802

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1802, __PRETTY_FUNCTION__
); } while (0);

1803

1804

if (u->load_state != UNIT_LOADED)

1805

return false0;

1806

1807

if (!unit_supported(u))

1808

return false0;

1809

1810

/* Scope units may be started only once */

1811

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->once_only && dual_timestamp_is_set(&u->inactive_exit_timestamp))

1812

return false0;

1813

1814

return !!UNIT_VTABLE(u)unit_vtable[(u)->type]->start;

1815

}

1816

1817

bool_Bool unit_can_isolate(Unit *u) {

1818

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1818, __PRETTY_FUNCTION__
); } while (0);

1819

1820

return unit_can_start(u) &&

1821

u->allow_isolate;

1822

}

1823

1824

/* Errors:

1825

* -EBADR: This unit type does not support stopping.

1826

* -EALREADY: Unit is already stopped.

1827

* -EAGAIN: An operation is already in progress. Retry later.

1828

*/

1829

int unit_stop(Unit *u) {

1830

UnitActiveState state;

1831

Unit *following;

1832

1833

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1833, __PRETTY_FUNCTION__
); } while (0);

1834

1835

state = unit_active_state(u);

1836

if (UNIT_IS_INACTIVE_OR_FAILED(state))

1837

return -EALREADY114;

1838

1839

following = unit_following(u);

1840

if (following) {

1841

log_unit_debug(u, "Redirecting stop request from %s to %s.", u->id, following->id)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1841, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Redirecting stop request from %s to %s.", u->id, following
->id) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10
| ((7))), 0, "../src/core/unit.c", 1841, __func__, "Redirecting stop request from %s to %s."
, u->id, following->id); });

1842

return unit_stop(following);

1843

}

1844

1845

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->stop)

1846

return -EBADR53;

1847

1848

unit_add_to_dbus_queue(u);

1849

unit_cgroup_freezer_action(u, FREEZER_THAW);

1850

1851

return UNIT_VTABLE(u)unit_vtable[(u)->type]->stop(u);

1852

}

1853

1854

bool_Bool unit_can_stop(Unit *u) {

1855

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1855, __PRETTY_FUNCTION__
); } while (0);

1856

1857

if (!unit_supported(u))

1858

return false0;

1859

1860

if (u->perpetual)

1861

return false0;

1862

1863

return !!UNIT_VTABLE(u)unit_vtable[(u)->type]->stop;

1864

}

1865

1866

/* Errors:

1867

* -EBADR: This unit type does not support reloading.

1868

* -ENOEXEC: Unit is not started.

1869

* -EAGAIN: An operation is already in progress. Retry later.

1870

*/

1871

int unit_reload(Unit *u) {

1872

UnitActiveState state;

1873

Unit *following;

1874

1875

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1875, __PRETTY_FUNCTION__
); } while (0);

1876

1877

if (u->load_state != UNIT_LOADED)

1878

return -EINVAL22;

1879

1880

if (!unit_can_reload(u))

1881

return -EBADR53;

1882

1883

state = unit_active_state(u);

1884

if (state == UNIT_RELOADING)

1885

return -EALREADY114;

1886

1887

if (state != UNIT_ACTIVE) {

1888

log_unit_warning(u, "Unit cannot be reloaded because it is inactive.")({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 1888, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Unit cannot be reloaded because it is inactive.") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((4))), 0, "../src/core/unit.c"
, 1888, __func__, "Unit cannot be reloaded because it is inactive."
); });

1889

return -ENOEXEC8;

1890

}

1891

1892

following = unit_following(u);

1893

if (following) {

1894

log_unit_debug(u, "Redirecting reload request from %s to %s.", u->id, following->id)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 1894, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Redirecting reload request from %s to %s.", u->id, following
->id) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10
| ((7))), 0, "../src/core/unit.c", 1894, __func__, "Redirecting reload request from %s to %s."
, u->id, following->id); });

1895

return unit_reload(following);

1896

}

1897

1898

unit_add_to_dbus_queue(u);

1899

1900

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->reload) {

1901

/* Unit doesn't have a reload function, but we need to propagate the reload anyway */

1902

unit_notify(u, unit_active_state(u), unit_active_state(u), 0);

1903

return 0;

1904

}

1905

1906

unit_cgroup_freezer_action(u, FREEZER_THAW);

1907

1908

return UNIT_VTABLE(u)unit_vtable[(u)->type]->reload(u);

1909

}

1910

1911

bool_Bool unit_can_reload(Unit *u) {

1912

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1912, __PRETTY_FUNCTION__
); } while (0);

1913

1914

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->can_reload)

1915

return UNIT_VTABLE(u)unit_vtable[(u)->type]->can_reload(u);

1916

1917

if (!hashmap_isempty(u->dependencies[UNIT_PROPAGATES_RELOAD_TO]))

1918

return true1;

1919

1920

return UNIT_VTABLE(u)unit_vtable[(u)->type]->reload;

1921

}

1922

1923

bool_Bool unit_is_unneeded(Unit *u) {

1924

static const UnitDependency deps[] = {

1925

UNIT_REQUIRED_BY,

1926

UNIT_REQUISITE_OF,

1927

UNIT_WANTED_BY,

1928

UNIT_BOUND_BY,

1929

};

1930

size_t j;

1931

1932

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1932, __PRETTY_FUNCTION__
); } while (0);

1933

1934

if (!u->stop_when_unneeded)

1935

return false0;

1936

1937

/* Don't clean up while the unit is transitioning or is even inactive. */

1938

if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))

1939

return false0;

1940

if (u->job)

1941

return false0;

1942

1943

for (j = 0; j < ELEMENTSOF(deps)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(deps), typeof(&*(deps))), sizeof(deps)/sizeof((deps
)[0]), ((void)0))); j++) {

1944

Unit *other;

1945

Iterator i;

1946

void *v;

1947

1948

/* If a dependending unit has a job queued, or is active (or in transitioning), or is marked for

1949

* restart, then don't clean this one up. */

1950

1951

HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[deps[j]]), &(i), (void**)&(v), (const void**) &(
other)); ) {

1952

if (u->job)

1953

return false0;

1954

1955

if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))

1956

return false0;

1957

1958

if (unit_will_restart(other))

1959

return false0;

1960

}

1961

}

1962

1963

return true1;

1964

}

1965

1966

static void check_unneeded_dependencies(Unit *u) {

1967

1968

static const UnitDependency deps[] = {

1969

UNIT_REQUIRES,

1970

UNIT_REQUISITE,

1971

UNIT_WANTS,

1972

UNIT_BINDS_TO,

1973

};

1974

size_t j;

1975

1976

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1976, __PRETTY_FUNCTION__
); } while (0);

1977

1978

/* Add all units this unit depends on to the queue that processes StopWhenUnneeded= behaviour. */

1979

1980

for (j = 0; j < ELEMENTSOF(deps)__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(deps), typeof(&*(deps))), sizeof(deps)/sizeof((deps
)[0]), ((void)0))); j++) {

1981

Unit *other;

1982

Iterator i;

1983

void *v;

1984

1985

HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[deps[j]]), &(i), (void**)&(v), (const void**) &(
other)); )

1986

unit_add_to_stop_when_unneeded_queue(other);

1987

}

1988

}

1989

1990

static void unit_check_binds_to(Unit *u) {

1991

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

1992

bool_Bool stop = false0;

1993

Unit *other;

1994

Iterator i;

1995

void *v;

1996

int r;

1997

1998

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 1998, __PRETTY_FUNCTION__
); } while (0);

1999

2000

if (u->job)

2001

return;

2002

2003

if (unit_active_state(u) != UNIT_ACTIVE)

2004

return;

2005

2006

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_BINDS_TO]), &(i), (void**)&(v), (const void**) &
(other)); ) {

2007

if (other->job)

2008

continue;

2009

2010

if (!other->coldplugged)

2011

/* We might yet create a job for the other unit… */

2012

continue;

2013

2014

if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))

2015

continue;

2016

2017

stop = true1;

2018

break;

2019

}

2020

2021

if (!stop)

2022

return;

2023

2024

/* If stopping a unit fails continuously we might enter a stop

2025

* loop here, hence stop acting on the service being

2026

* unnecessary after a while. */

2027

if (!ratelimit_below(&u->auto_stop_ratelimit)) {

2028

log_unit_warning(u, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other->id)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 2028, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently."
, other->id) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((4))), 0, "../src/core/unit.c", 2028, __func__, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently."
, other->id); });

2029

return;

2030

}

2031

2032

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 2032, __PRETTY_FUNCTION__
); } while (0);

2033

log_unit_info(u, "Unit is bound to inactive unit %s. Stopping, too.", other->id)({ const Unit *_u = (u); _u ? log_object_internal(6, 0, "../src/core/unit.c"
, 2033, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Unit is bound to inactive unit %s. Stopping, too.", other->
id) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(6))), 0, "../src/core/unit.c", 2033, __func__, "Unit is bound to inactive unit %s. Stopping, too."
, other->id); });

2034

2035

/* A unit we need to run is gone. Sniff. Let's stop this. */

2036

r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, NULL((void*)0), &error, NULL((void*)0));

2037

if (r < 0)

2038

log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error, r))({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 2038, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to enqueue stop job, ignoring: %s", bus_error_message
(&error, r)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((4))), r, "../src/core/unit.c", 2038, __func__, "Failed to enqueue stop job, ignoring: %s"
, bus_error_message(&error, r)); });

2039

}

2040

2041

static void retroactively_start_dependencies(Unit *u) {

2042

Iterator i;

2043

Unit *other;

2044

void *v;

2045

2046

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2046, __PRETTY_FUNCTION__
); } while (0);

2047

assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))do { if ((__builtin_expect(!!(!(UNIT_IS_ACTIVE_OR_ACTIVATING(
unit_active_state(u)))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u))"), "../src/core/unit.c"
, 2047, __PRETTY_FUNCTION__); } while (0);

2048

2049

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRES], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_REQUIRES]), &(i), (void**)&(v), (const void**) &
(other)); )

2050

if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&

2051

!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))

2052

manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2053

2054

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_BINDS_TO]), &(i), (void**)&(v), (const void**) &
(other)); )

2055

if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&

2056

!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))

2057

manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2058

2059

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_WANTS], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_WANTS]), &(i), (void**)&(v), (const void**) &
(other)); )

2060

if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&

2061

!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))

2062

manager_add_job(u->manager, JOB_START, other, JOB_FAIL, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2063

2064

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTS], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_CONFLICTS]), &(i), (void**)&(v), (const void**)
&(other)); )

2065

if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))

2066

manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2067

2068

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTED_BY], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_CONFLICTED_BY]), &(i), (void**)&(v), (const void
**) &(other)); )

2069

if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))

2070

manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2071

}

2072

2073

static void retroactively_stop_dependencies(Unit *u) {

2074

Unit *other;

2075

Iterator i;

2076

void *v;

2077

2078

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2078, __PRETTY_FUNCTION__
); } while (0);

2079

assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))do { if ((__builtin_expect(!!(!(UNIT_IS_INACTIVE_OR_DEACTIVATING
(unit_active_state(u)))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u))"),
"../src/core/unit.c", 2079, __PRETTY_FUNCTION__); } while (0
);

2080

2081

/* Pull down units which are bound to us recursively if enabled */

2082

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BOUND_BY], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_BOUND_BY]), &(i), (void**)&(v), (const void**) &
(other)); )

2083

if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))

2084

manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL((void*)0), NULL((void*)0), NULL((void*)0));

2085

}

2086

2087

void unit_start_on_failure(Unit *u) {

2088

Unit *other;

2089

Iterator i;

2090

void *v;

2091

int r;

2092

2093

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2093, __PRETTY_FUNCTION__
); } while (0);

2094

2095

if (hashmap_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)

2096

return;

2097

2098

log_unit_info(u, "Triggering OnFailure= dependencies.")({ const Unit *_u = (u); _u ? log_object_internal(6, 0, "../src/core/unit.c"
, 2098, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Triggering OnFailure= dependencies.") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((6))), 0, "../src/core/unit.c"
, 2098, __func__, "Triggering OnFailure= dependencies."); });

2099

2100

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_ON_FAILURE], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_ON_FAILURE]), &(i), (void**)&(v), (const void**
) &(other)); ) {

2101

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

2102

2103

r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, NULL((void*)0), &error, NULL((void*)0));

2104

if (r < 0)

2105

log_unit_warning_errno(u, r, "Failed to enqueue OnFailure= job, ignoring: %s", bus_error_message(&error, r))({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 2105, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to enqueue OnFailure= job, ignoring: %s", bus_error_message
(&error, r)) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((4))), r, "../src/core/unit.c", 2105, __func__, "Failed to enqueue OnFailure= job, ignoring: %s"
, bus_error_message(&error, r)); });

2106

}

2107

}

2108

2109

void unit_trigger_notify(Unit *u) {

2110

Unit *other;

2111

Iterator i;

2112

void *v;

2113

2114

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2114, __PRETTY_FUNCTION__
); } while (0);

2115

2116

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_TRIGGERED_BY], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_TRIGGERED_BY]), &(i), (void**)&(v), (const void
**) &(other)); )

2117

if (UNIT_VTABLE(other)unit_vtable[(other)->type]->trigger_notify)

2118

UNIT_VTABLE(other)unit_vtable[(other)->type]->trigger_notify(other, u);

2119

}

2120

2121

static int unit_log_resources(Unit *u) {

2122

2123

struct iovec iovec[1 + _CGROUP_IP_ACCOUNTING_METRIC_MAX + 4];

2124

size_t n_message_parts = 0, n_iovec = 0;

2125

char* message_parts[3 + 1], *t;

2126

nsec_t nsec = NSEC_INFINITY((nsec_t) -1);

2127

CGroupIPAccountingMetric m;

2128

size_t i;

2129

int r;

2130

const char* const ip_fields[_CGROUP_IP_ACCOUNTING_METRIC_MAX] = {

2131

[CGROUP_IP_INGRESS_BYTES] = "IP_METRIC_INGRESS_BYTES",

2132

[CGROUP_IP_INGRESS_PACKETS] = "IP_METRIC_INGRESS_PACKETS",

2133

[CGROUP_IP_EGRESS_BYTES] = "IP_METRIC_EGRESS_BYTES",

2134

[CGROUP_IP_EGRESS_PACKETS] = "IP_METRIC_EGRESS_PACKETS",

2135

};

2136

2137

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2137, __PRETTY_FUNCTION__
); } while (0);

2138

2139

/* Invoked whenever a unit enters failed or dead state. Logs information about consumed resources if resource

2140

* accounting was enabled for a unit. It does this in two ways: a friendly human readable string with reduced

2141

* information and the complete data in structured fields. */

2142

2143

(void) unit_get_cpu_usage(u, &nsec);

2144

if (nsec != NSEC_INFINITY((nsec_t) -1)) {

2145

char buf[FORMAT_TIMESPAN_MAX64] = "";

2146

2147

/* Format the CPU time for inclusion in the structured log message */

2148

if (asprintf(&t, "CPU_USAGE_NSEC=%" PRIu64"l" "u", nsec) < 0) {

2149

r = log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 2149
, __func__);

2150

goto finish;

2151

}

2152

iovec[n_iovec++] = IOVEC_MAKE_STRING(t)(struct iovec) { .iov_base = ((char*) t), .iov_len = (strlen(
t)) };

2153

2154

/* Format the CPU time for inclusion in the human language message string */

2155

format_timespan(buf, sizeof(buf), nsec / NSEC_PER_USEC((nsec_t) 1000ULL), USEC_PER_MSEC((usec_t) 1000ULL));

2156

t = strjoin(n_message_parts > 0 ? "consumed " : "Consumed ", buf, " CPU time")strjoin_real((n_message_parts > 0 ? "consumed " : "Consumed "
), buf, " CPU time", ((void*)0));

2157

if (!t) {

2158

r = log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 2158
, __func__);

2159

goto finish;

2160

}

2161

2162

message_parts[n_message_parts++] = t;

2163

}

2164

2165

for (m = 0; m < _CGROUP_IP_ACCOUNTING_METRIC_MAX; m++) {

2166

char buf[FORMAT_BYTES_MAX8] = "";

2167

uint64_t value = UINT64_MAX(18446744073709551615UL);

2168

2169

assert(ip_fields[m])do { if ((__builtin_expect(!!(!(ip_fields[m])),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ip_fields[m]"), "../src/core/unit.c", 2169
, __PRETTY_FUNCTION__); } while (0);

2170

2171

(void) unit_get_ip_accounting(u, m, &value);

2172

if (value == UINT64_MAX(18446744073709551615UL))

2173

continue;

2174

2175

/* Format IP accounting data for inclusion in the structured log message */

2176

if (asprintf(&t, "%s=%" PRIu64"l" "u", ip_fields[m], value) < 0) {

2177

r = log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 2177
, __func__);

2178

goto finish;

2179

}

2180

iovec[n_iovec++] = IOVEC_MAKE_STRING(t)(struct iovec) { .iov_base = ((char*) t), .iov_len = (strlen(
t)) };

2181

2182

/* Format the IP accounting data for inclusion in the human language message string, but only for the

2183

* bytes counters (and not for the packets counters) */

2184

if (m == CGROUP_IP_INGRESS_BYTES)

2185

t = strjoin(n_message_parts > 0 ? "received " : "Received ",strjoin_real((n_message_parts > 0 ? "received " : "Received "
), format_bytes(buf, sizeof(buf), value), " IP traffic", ((void
*)0))

2186

format_bytes(buf, sizeof(buf), value),strjoin_real((n_message_parts > 0 ? "received " : "Received "
), format_bytes(buf, sizeof(buf), value), " IP traffic", ((void
*)0))

2187

" IP traffic")strjoin_real((n_message_parts > 0 ? "received " : "Received "
), format_bytes(buf, sizeof(buf), value), " IP traffic", ((void
*)0));

2188

else if (m == CGROUP_IP_EGRESS_BYTES)

2189

t = strjoin(n_message_parts > 0 ? "sent " : "Sent ",strjoin_real((n_message_parts > 0 ? "sent " : "Sent "), format_bytes
(buf, sizeof(buf), value), " IP traffic", ((void*)0))

2190

format_bytes(buf, sizeof(buf), value),strjoin_real((n_message_parts > 0 ? "sent " : "Sent "), format_bytes
(buf, sizeof(buf), value), " IP traffic", ((void*)0))

2191

" IP traffic")strjoin_real((n_message_parts > 0 ? "sent " : "Sent "), format_bytes
(buf, sizeof(buf), value), " IP traffic", ((void*)0));

2192

else

2193

continue;

2194

if (!t) {

2195

r = log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 2195
, __func__);

2196

goto finish;

2197

}

2198

2199

message_parts[n_message_parts++] = t;

2200

}

2201

2202

/* Is there any accounting data available at all? */

2203

if (n_iovec == 0) {

2204

r = 0;

2205

goto finish;

2206

}

2207

2208

if (n_message_parts == 0)

2209

t = strjoina("MESSAGE=", u->id, ": Completed")({ const char *_appendees_[] = { "MESSAGE=", u->id, ": Completed"
}; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

2210

else {

2211

_cleanup_free___attribute__((cleanup(freep))) char *joined;

2212

2213

message_parts[n_message_parts] = NULL((void*)0);

2214

2215

joined = strv_join(message_parts, ", ");

2216

if (!joined) {

2217

r = log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 2217
, __func__);

2218

goto finish;

2219

}

2220

2221

t = strjoina("MESSAGE=", u->id, ": ", joined)({ const char *_appendees_[] = { "MESSAGE=", u->id, ": ", joined
}; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

2222

}

2223

2224

/* The following four fields we allocate on the stack or are static strings, we hence don't want to free them,

2225

* and hence don't increase n_iovec for them */

2226

iovec[n_iovec] = IOVEC_MAKE_STRING(t)(struct iovec) { .iov_base = ((char*) t), .iov_len = (strlen(
t)) };

2227

iovec[n_iovec + 1] = IOVEC_MAKE_STRING("MESSAGE_ID=" SD_MESSAGE_UNIT_RESOURCES_STR)(struct iovec) { .iov_base = ((char*) "MESSAGE_ID=" "ae" "8f"
"7b" "86" "6b" "03" "47" "b9" "af" "31" "fe" "1c" "80" "b1" "27"
"c0"), .iov_len = (strlen("MESSAGE_ID=" "ae" "8f" "7b" "86" "6b"
"03" "47" "b9" "af" "31" "fe" "1c" "80" "b1" "27" "c0")) };

2228

2229

t = strjoina(u->manager->unit_log_field, u->id)({ const char *_appendees_[] = { u->manager->unit_log_field
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

2230

iovec[n_iovec + 2] = IOVEC_MAKE_STRING(t)(struct iovec) { .iov_base = ((char*) t), .iov_len = (strlen(
t)) };

2231

2232

t = strjoina(u->manager->invocation_log_field, u->invocation_id_string)({ const char *_appendees_[] = { u->manager->invocation_log_field
, u->invocation_id_string }; char *_d_, *_p_; size_t _len_
= 0; size_t _i_; for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _len_ += strlen
(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca (_len_ + 1);
for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr(
!__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

2233

iovec[n_iovec + 3] = IOVEC_MAKE_STRING(t)(struct iovec) { .iov_base = ((char*) t), .iov_len = (strlen(
t)) };

2234

2235

log_struct_iovec(LOG_INFO, iovec, n_iovec + 4)log_struct_iovec_internal(((LOG_REALM_SYSTEMD) << 10 | (
6)), 0, "../src/core/unit.c", 2235, __func__, iovec, n_iovec +
4);

2236

r = 0;

2237

2238

finish:

2239

for (i = 0; i < n_message_parts; i++)

2240

free(message_parts[i]);

2241

2242

for (i = 0; i < n_iovec; i++)

2243

free(iovec[i].iov_base);

2244

2245

return r;

2246

2247

}

2248

2249

static void unit_update_on_console(Unit *u) {

2250

bool_Bool b;

2251

2252

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2252, __PRETTY_FUNCTION__
); } while (0);

2253

2254

b = unit_needs_console(u);

2255

if (u->on_console == b)

2256

return;

2257

2258

u->on_console = b;

2259

if (b)

2260

manager_ref_console(u->manager);

2261

else

2262

manager_unref_console(u->manager);

2263

}

2264

2265

static bool_Bool unit_process_job(Job *j, UnitActiveState ns, UnitNotifyFlags flags) {

2266

bool_Bool unexpected = false0;

2267

JobResult result;

2268

2269

assert(j)do { if ((__builtin_expect(!!(!(j)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("j"), "../src/core/unit.c", 2269, __PRETTY_FUNCTION__
); } while (0);

2270

2271

if (j->state == JOB_WAITING)

2272

2273

/* So we reached a different state for this job. Let's see if we can run it now if it failed previously

2274

* due to EAGAIN. */

2275

job_add_to_run_queue(j);

2276

2277

/* Let's check whether the unit's new state constitutes a finished job, or maybe contradicts a running job and

2278

* hence needs to invalidate jobs. */

2279

2280

switch (j->type) {

2281

2282

case JOB_START:

2283

case JOB_VERIFY_ACTIVE:

2284

2285

if (UNIT_IS_ACTIVE_OR_RELOADING(ns))

2286

job_finish_and_invalidate(j, JOB_DONE, true1, false0);

2287

else if (j->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {

2288

unexpected = true1;

2289

2290

if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {

2291

if (ns == UNIT_FAILED)

2292

result = JOB_FAILED;

2293

else if (FLAGS_SET(flags, UNIT_NOTIFY_SKIP_CONDITION)(((flags) & (UNIT_NOTIFY_SKIP_CONDITION)) == (UNIT_NOTIFY_SKIP_CONDITION
)))

2294

result = JOB_SKIPPED;

2295

else

2296

result = JOB_DONE;

2297

2298

job_finish_and_invalidate(j, result, true1, false0);

2299

}

2300

}

2301

2302

break;

2303

2304

case JOB_RELOAD:

2305

case JOB_RELOAD_OR_START:

2306

case JOB_TRY_RELOAD:

2307

2308

if (j->state == JOB_RUNNING) {

2309

if (ns == UNIT_ACTIVE)

2310

job_finish_and_invalidate(j, (flags & UNIT_NOTIFY_RELOAD_FAILURE) ? JOB_FAILED : JOB_DONE, true1, false0);

2311

else if (!IN_SET(ns, UNIT_ACTIVATING, UNIT_RELOADING)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){UNIT_ACTIVATING, UNIT_RELOADING})/sizeof
(int)]; switch(ns) { case UNIT_ACTIVATING: case UNIT_RELOADING
: _found = 1; break; default: break; } _found; })) {

2312

unexpected = true1;

2313

2314

if (UNIT_IS_INACTIVE_OR_FAILED(ns))

2315

job_finish_and_invalidate(j, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true1, false0);

2316

}

2317

}

2318

2319

break;

2320

2321

case JOB_STOP:

2322

case JOB_RESTART:

2323

case JOB_TRY_RESTART:

2324

2325

if (UNIT_IS_INACTIVE_OR_FAILED(ns))

2326

job_finish_and_invalidate(j, JOB_DONE, true1, false0);

2327

else if (j->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {

2328

unexpected = true1;

2329

job_finish_and_invalidate(j, JOB_FAILED, true1, false0);

2330

}

2331

2332

break;

2333

2334

default:

2335

assert_not_reached("Job type unknown")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Job type unknown"), "../src/core/unit.c", 2335, __PRETTY_FUNCTION__
); } while (0);

2336

}

2337

2338

return unexpected;

2339

}

2340

2341

void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, UnitNotifyFlags flags) {

2342

bool_Bool unexpected;

2343

Manager *m;

2344

2345

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2345, __PRETTY_FUNCTION__
); } while (0);

2346

assert(os < _UNIT_ACTIVE_STATE_MAX)do { if ((__builtin_expect(!!(!(os < _UNIT_ACTIVE_STATE_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("os < _UNIT_ACTIVE_STATE_MAX"
), "../src/core/unit.c", 2346, __PRETTY_FUNCTION__); } while (
0);

2347

assert(ns < _UNIT_ACTIVE_STATE_MAX)do { if ((__builtin_expect(!!(!(ns < _UNIT_ACTIVE_STATE_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("ns < _UNIT_ACTIVE_STATE_MAX"
), "../src/core/unit.c", 2347, __PRETTY_FUNCTION__); } while (
0);

2348

2349

/* Note that this is called for all low-level state changes, even if they might map to the same high-level

2350

* UnitActiveState! That means that ns == os is an expected behavior here. For example: if a mount point is

2351

* remounted this function will be called too! */

2352

2353

m = u->manager;

2354

2355

/* Update timestamps for state changes */

2356

if (!MANAGER_IS_RELOADING(m)((m)->n_reloading > 0)) {

2357

dual_timestamp_get(&u->state_change_timestamp);

2358

2359

if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))

2360

u->inactive_exit_timestamp = u->state_change_timestamp;

2361

else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))

2362

u->inactive_enter_timestamp = u->state_change_timestamp;

2363

2364

if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))

2365

u->active_enter_timestamp = u->state_change_timestamp;

2366

else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))

2367

u->active_exit_timestamp = u->state_change_timestamp;

2368

}

2369

2370

/* Keep track of failed units */

2371

(void) manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);

2372

2373

/* Make sure the cgroup and state files are always removed when we become inactive */

2374

if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {

2375

unit_prune_cgroup(u);

2376

unit_unlink_state_files(u);

2377

}

2378

2379

unit_update_on_console(u);

2380

2381

/* Let's propagate state changes to the job */

2382

if (u->job)

2383

unexpected = unit_process_job(u->job, ns, flags);

2384

else

2385

unexpected = true1;

2386

2387

if (!MANAGER_IS_RELOADING(m)((m)->n_reloading > 0)) {

2388

2389

/* If this state change happened without being

2390

* requested by a job, then let's retroactively start

2391

* or stop dependencies. We skip that step when

2392

* deserializing, since we don't want to create any

2393

* additional jobs just because something is already

2394

* activated. */

2395

2396

if (unexpected) {

2397

if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))

2398

retroactively_start_dependencies(u);

2399

else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))

2400

retroactively_stop_dependencies(u);

2401

}

2402

2403

/* stop unneeded units regardless if going down was expected or not */

2404

if (UNIT_IS_INACTIVE_OR_FAILED(ns))

2405

check_unneeded_dependencies(u);

2406

2407

if (ns != os && ns == UNIT_FAILED) {

2408

log_unit_debug(u, "Unit entered failed state.")({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 2408, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Unit entered failed state.") : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((7))), 0, "../src/core/unit.c", 2408, __func__
, "Unit entered failed state."); });

2409

2410

if (!(flags & UNIT_NOTIFY_WILL_AUTO_RESTART))

2411

unit_start_on_failure(u);

2412

}

2413

}

2414

2415

if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {

2416

2417

if (u->type == UNIT_SERVICE &&

2418

!UNIT_IS_ACTIVE_OR_RELOADING(os) &&

2419

!MANAGER_IS_RELOADING(m)((m)->n_reloading > 0)) {

2420

/* Write audit record if we have just finished starting up */

2421

manager_send_unit_audit(m, u, AUDIT_SERVICE_START1130, true1);

2422

u->in_audit = true1;

2423

}

2424

2425

if (!UNIT_IS_ACTIVE_OR_RELOADING(os))

2426

manager_send_unit_plymouth(m, u);

2427

2428

} else {

2429

2430

if (UNIT_IS_INACTIVE_OR_FAILED(ns) &&

2431

!UNIT_IS_INACTIVE_OR_FAILED(os)

2432

&& !MANAGER_IS_RELOADING(m)((m)->n_reloading > 0)) {

2433

2434

/* This unit just stopped/failed. */

2435

if (u->type == UNIT_SERVICE) {

2436

2437

/* Hmm, if there was no start record written

2438

* write it now, so that we always have a nice

2439

* pair */

2440

if (!u->in_audit) {

2441

manager_send_unit_audit(m, u, AUDIT_SERVICE_START1130, ns == UNIT_INACTIVE);

2442

2443

if (ns == UNIT_INACTIVE)

2444

manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP1131, true1);

2445

} else

2446

/* Write audit record if we have just finished shutting down */

2447

manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP1131, ns == UNIT_INACTIVE);

2448

2449

u->in_audit = false0;

2450

}

2451

2452

/* Write a log message about consumed resources */

2453

unit_log_resources(u);

2454

}

2455

}

2456

2457

manager_recheck_journal(m);

2458

manager_recheck_dbus(m);

2459

2460

unit_trigger_notify(u);

2461

2462

if (!MANAGER_IS_RELOADING(u->manager)((u->manager)->n_reloading > 0)) {

2463

/* Maybe we finished startup and are now ready for being stopped because unneeded? */

2464

unit_add_to_stop_when_unneeded_queue(u);

2465

2466

/* Maybe we finished startup, but something we needed has vanished? Let's die then. (This happens when

2467

* something BindsTo= to a Type=oneshot unit, as these units go directly from starting to inactive,

2468

* without ever entering started.) */

2469

unit_check_binds_to(u);

2470

2471

if (os != UNIT_FAILED && ns == UNIT_FAILED)

2472

(void) emergency_action(u->manager, u->failure_action, u->reboot_arg, "unit failed");

2473

else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && ns == UNIT_INACTIVE)

2474

(void) emergency_action(u->manager, u->success_action, u->reboot_arg, "unit succeeded");

2475

}

2476

2477

unit_add_to_dbus_queue(u);

2478

unit_add_to_gc_queue(u);

2479

}

2480

2481

int unit_watch_pid(Unit *u, pid_t pid, bool_Bool exclusive) {

2482

int r;

2483

2484

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2484, __PRETTY_FUNCTION__
); } while (0);

2485

assert(pid_is_valid(pid))do { if ((__builtin_expect(!!(!(pid_is_valid(pid))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid_is_valid(pid)"), "../src/core/unit.c"
, 2485, __PRETTY_FUNCTION__); } while (0);

2486

2487

/* Watch a specific PID */

2488

2489

/* Caller might be sure that this PID belongs to this unit only. Let's take this

2490

* opportunity to remove any stalled references to this PID as they can be created

2491

* easily (when watching a process which is not our direct child). */

2492

if (exclusive)

2493

manager_unwatch_pid(u->manager, pid);

2494

2495

r = set_ensure_allocated(&u->pids, NULL)internal_set_ensure_allocated(&u->pids, ((void*)0) );

2496

if (r < 0)

2497

return r;

2498

2499

r = hashmap_ensure_allocated(&u->manager->watch_pids, NULL)internal_hashmap_ensure_allocated(&u->manager->watch_pids
, ((void*)0) );

2500

if (r < 0)

2501

return r;

2502

2503

/* First try, let's add the unit keyed by "pid". */

2504

r = hashmap_put(u->manager->watch_pids, PID_TO_PTR(pid), u);

2505

if (r == -EEXIST17) {

2506

Unit **array;

2507

bool_Bool found = false0;

2508

size_t n = 0;

2509

2510

/* OK, the "pid" key is already assigned to a different unit. Let's see if the "-pid" key (which points

2511

* to an array of Units rather than just a Unit), lists us already. */

2512

2513

array = hashmap_get(u->manager->watch_pids, PID_TO_PTR(-pid));

2514

if (array)

2515

for (; array[n]; n++)

2516

if (array[n] == u)

2517

found = true1;

2518

2519

if (found) /* Found it already? if so, do nothing */

2520

r = 0;

2521

else {

2522

Unit **new_array;

2523

2524

/* Allocate a new array */

2525

new_array = new(Unit*, n + 2)((Unit**) malloc_multiply(sizeof(Unit*), (n + 2)));

2526

if (!new_array)

2527

return -ENOMEM12;

2528

2529

memcpy_safe(new_array, array, sizeof(Unit*) * n);

2530

new_array[n] = u;

2531

new_array[n+1] = NULL((void*)0);

2532

2533

/* Add or replace the old array */

2534

r = hashmap_replace(u->manager->watch_pids, PID_TO_PTR(-pid), new_array);

2535

if (r < 0) {

2536

free(new_array);

2537

return r;

2538

}

2539

2540

free(array);

2541

}

2542

} else if (r < 0)

2543

return r;

2544

2545

r = set_put(u->pids, PID_TO_PTR(pid));

2546

if (r < 0)

2547

return r;

2548

2549

return 0;

2550

}

2551

2552

void unit_unwatch_pid(Unit *u, pid_t pid) {

2553

Unit **array;

2554

2555

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2555, __PRETTY_FUNCTION__
); } while (0);

2556

assert(pid_is_valid(pid))do { if ((__builtin_expect(!!(!(pid_is_valid(pid))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("pid_is_valid(pid)"), "../src/core/unit.c"
, 2556, __PRETTY_FUNCTION__); } while (0);

2557

2558

/* First let's drop the unit in case it's keyed as "pid". */

2559

(void) hashmap_remove_value(u->manager->watch_pids, PID_TO_PTR(pid), u);

2560

2561

/* Then, let's also drop the unit, in case it's in the array keyed by -pid */

2562

array = hashmap_get(u->manager->watch_pids, PID_TO_PTR(-pid));

2563

if (array) {

2564

size_t n, m = 0;

2565

2566

/* Let's iterate through the array, dropping our own entry */

2567

for (n = 0; array[n]; n++)

2568

if (array[n] != u)

2569

array[m++] = array[n];

2570

array[m] = NULL((void*)0);

2571

2572

if (m == 0) {

2573

/* The array is now empty, remove the entire entry */

2574

assert(hashmap_remove(u->manager->watch_pids, PID_TO_PTR(-pid)) == array)do { if ((__builtin_expect(!!(!(hashmap_remove(u->manager->
watch_pids, PID_TO_PTR(-pid)) == array)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("hashmap_remove(u->manager->watch_pids, PID_TO_PTR(-pid)) == array"
), "../src/core/unit.c", 2574, __PRETTY_FUNCTION__); } while (
0);

2575

free(array);

2576

}

2577

}

2578

2579

(void) set_remove(u->pids, PID_TO_PTR(pid));

2580

}

2581

2582

void unit_unwatch_all_pids(Unit *u) {

2583

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2583, __PRETTY_FUNCTION__
); } while (0);

2584

2585

while (!set_isempty(u->pids))

2586

unit_unwatch_pid(u, PTR_TO_PID(set_first(u->pids)));

2587

2588

u->pids = set_free(u->pids);

2589

}

2590

2591

static void unit_tidy_watch_pids(Unit *u) {

2592

pid_t except1, except2;

2593

Iterator i;

2594

void *e;

2595

2596

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2596, __PRETTY_FUNCTION__
); } while (0);

2597

2598

/* Cleans dead PIDs from our list */

2599

2600

except1 = unit_main_pid(u);

2601

except2 = unit_control_pid(u);

2602

2603

SET_FOREACH(e, u->pids, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((u->pids), &(i),
(void**)&(e)); ) {

2604

pid_t pid = PTR_TO_PID(e);

2605

2606

if (pid == except1 || pid == except2)

2607

continue;

2608

2609

if (!pid_is_unwaited(pid))

2610

unit_unwatch_pid(u, pid);

2611

}

2612

}

2613

2614

static int on_rewatch_pids_event(sd_event_source *s, void *userdata) {

2615

Unit *u = userdata;

2616

2617

assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/core/unit.c", 2617, __PRETTY_FUNCTION__
); } while (0);

2618

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2618, __PRETTY_FUNCTION__
); } while (0);

2619

2620

unit_tidy_watch_pids(u);

2621

unit_watch_all_pids(u);

2622

2623

/* If the PID set is empty now, then let's finish this off. */

2624

unit_synthesize_cgroup_empty_event(u);

2625

2626

return 0;

2627

}

2628

2629

int unit_enqueue_rewatch_pids(Unit *u) {

2630

int r;

2631

2632

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2632, __PRETTY_FUNCTION__
); } while (0);

2633

2634

if (!u->cgroup_path)

2635

return -ENOENT2;

2636

2637

r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER"_systemd");

2638

if (r < 0)

2639

return r;

2640

if (r > 0) /* On unified we can use proper notifications */

2641

return 0;

2642

2643

/* Enqueues a low-priority job that will clean up dead PIDs from our list of PIDs to watch and subscribe to new

2644

* PIDs that might have appeared. We do this in a delayed job because the work might be quite slow, as it

2645

* involves issuing kill(pid, 0) on all processes we watch. */

2646

2647

if (!u->rewatch_pids_event_source) {

2648

_cleanup_(sd_event_source_unrefp)__attribute__((cleanup(sd_event_source_unrefp))) sd_event_source *s = NULL((void*)0);

2649

2650

r = sd_event_add_defer(u->manager->event, &s, on_rewatch_pids_event, u);

2651

if (r < 0)

2652

return log_error_errno(r, "Failed to allocate event source for tidying watched PIDs: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 2652, __func__, "Failed to allocate event source for tidying watched PIDs: %m"
) : -abs(_e); });

2653

2654

r = sd_event_source_set_priority(s, SD_EVENT_PRIORITY_IDLE);

2655

if (r < 0)

2656

return log_error_errno(r, "Failed to adjust priority of event source for tidying watched PIDs: m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 2656, __func__, "Failed to adjust priority of event source for tidying watched PIDs: m"
) : -abs(_e); });

2657

2658

(void) sd_event_source_set_description(s, "tidy-watch-pids");

2659

2660

u->rewatch_pids_event_source = TAKE_PTR(s)({ typeof(s) _ptr_ = (s); (s) = ((void*)0); _ptr_; });

2661

}

2662

2663

r = sd_event_source_set_enabled(u->rewatch_pids_event_source, SD_EVENT_ONESHOT);

2664

if (r < 0)

2665

return log_error_errno(r, "Failed to enable event source for tidying watched PIDs: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 2665, __func__, "Failed to enable event source for tidying watched PIDs: %m"
) : -abs(_e); });

2666

2667

return 0;

2668

}

2669

2670

void unit_dequeue_rewatch_pids(Unit *u) {

2671

int r;

2672

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2672, __PRETTY_FUNCTION__
); } while (0);

2673

2674

if (!u->rewatch_pids_event_source)

2675

return;

2676

2677

r = sd_event_source_set_enabled(u->rewatch_pids_event_source, SD_EVENT_OFF);

2678

if (r < 0)

2679

log_warning_errno(r, "Failed to disable event source for tidying watched PIDs, ignoring: %m")({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 2679, __func__, "Failed to disable event source for tidying watched PIDs, ignoring: %m"
) : -abs(_e); });

2680

2681

u->rewatch_pids_event_source = sd_event_source_unref(u->rewatch_pids_event_source);

2682

}

2683

2684

bool_Bool unit_job_is_applicable(Unit *u, JobType j) {

2685

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2685, __PRETTY_FUNCTION__
); } while (0);

2686

assert(j >= 0 && j < _JOB_TYPE_MAX)do { if ((__builtin_expect(!!(!(j >= 0 && j < _JOB_TYPE_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("j >= 0 && j < _JOB_TYPE_MAX"
), "../src/core/unit.c", 2686, __PRETTY_FUNCTION__); } while (
0);

2687

2688

switch (j) {

2689

2690

case JOB_VERIFY_ACTIVE:

2691

case JOB_START:

2692

case JOB_NOP:

2693

/* Note that we don't check unit_can_start() here. That's because .device units and suchlike are not

2694

* startable by us but may appear due to external events, and it thus makes sense to permit enqueing

2695

* jobs for it. */

2696

return true1;

2697

2698

case JOB_STOP:

2699

/* Similar as above. However, perpetual units can never be stopped (neither explicitly nor due to

2700

* external events), hence it makes no sense to permit enqueing such a request either. */

2701

return !u->perpetual;

2702

2703

case JOB_RESTART:

2704

case JOB_TRY_RESTART:

2705

return unit_can_stop(u) && unit_can_start(u);

2706

2707

case JOB_RELOAD:

2708

case JOB_TRY_RELOAD:

2709

return unit_can_reload(u);

2710

2711

case JOB_RELOAD_OR_START:

2712

return unit_can_reload(u) && unit_can_start(u);

2713

2714

default:

2715

assert_not_reached("Invalid job type")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Invalid job type"), "../src/core/unit.c", 2715, __PRETTY_FUNCTION__
); } while (0);

2716

}

2717

}

2718

2719

static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency) {

2720

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2720, __PRETTY_FUNCTION__
); } while (0);

2721

2722

/* Only warn about some unit types */

2723

if (!IN_SET(dependency, UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE
, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY
})/sizeof(int)]; switch(dependency) { case UNIT_CONFLICTS: case
UNIT_CONFLICTED_BY: case UNIT_BEFORE: case UNIT_AFTER: case UNIT_ON_FAILURE
: case UNIT_TRIGGERS: case UNIT_TRIGGERED_BY: _found = 1; break
; default: break; } _found; }))

2724

return;

2725

2726

if (streq_ptr(u->id, other))

2727

log_unit_warning(u, "Dependency %s=%s dropped", unit_dependency_to_string(dependency), u->id)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 2727, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Dependency %s=%s dropped", unit_dependency_to_string(dependency
), u->id) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((4))), 0, "../src/core/unit.c", 2727, __func__, "Dependency %s=%s dropped"
, unit_dependency_to_string(dependency), u->id); });

2728

else

2729

log_unit_warning(u, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency), strna(other), u->id)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 2729, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string
(dependency), strna(other), u->id) : log_internal_realm(((
LOG_REALM_SYSTEMD) << 10 | ((4))), 0, "../src/core/unit.c"
, 2729, __func__, "Dependency %s=%s dropped, merged into %s",
unit_dependency_to_string(dependency), strna(other), u->id
); });

2730

}

2731

2732

static int unit_add_dependency_hashmap(

2733

Hashmap **h,

2734

Unit *other,

2735

UnitDependencyMask origin_mask,

2736

UnitDependencyMask destination_mask) {

2737

2738

UnitDependencyInfo info;

2739

int r;

2740

2741

assert(h)do { if ((__builtin_expect(!!(!(h)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("h"), "../src/core/unit.c", 2741, __PRETTY_FUNCTION__
); } while (0);

2742

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 2742, __PRETTY_FUNCTION__
); } while (0);

2743

assert(origin_mask < _UNIT_DEPENDENCY_MASK_FULL)do { if ((__builtin_expect(!!(!(origin_mask < _UNIT_DEPENDENCY_MASK_FULL
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("origin_mask < _UNIT_DEPENDENCY_MASK_FULL"
), "../src/core/unit.c", 2743, __PRETTY_FUNCTION__); } while (
0);

2744

assert(destination_mask < _UNIT_DEPENDENCY_MASK_FULL)do { if ((__builtin_expect(!!(!(destination_mask < _UNIT_DEPENDENCY_MASK_FULL
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("destination_mask < _UNIT_DEPENDENCY_MASK_FULL"
), "../src/core/unit.c", 2744, __PRETTY_FUNCTION__); } while (
0);

2745

assert(origin_mask > 0 || destination_mask > 0)do { if ((__builtin_expect(!!(!(origin_mask > 0 || destination_mask
> 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("origin_mask > 0 || destination_mask > 0"
), "../src/core/unit.c", 2745, __PRETTY_FUNCTION__); } while (
0);

2746

2747

r = hashmap_ensure_allocated(h, NULL)internal_hashmap_ensure_allocated(h, ((void*)0) );

2748

if (r < 0)

2749

return r;

2750

2751

assert_cc(sizeof(void*) == sizeof(info))GCC diagnostic push ; GCC diagnostic ignored "-Wdeclaration-after-statement"
; struct _assert_struct_35 { char x[(sizeof(void*) == sizeof
(info)) ? 0 : -1]; }; GCC diagnostic pop ;

2752

2753

info.data = hashmap_get(*h, other);

2754

if (info.data) {

2755

/* Entry already exists. Add in our mask. */

2756

2757

if (FLAGS_SET(origin_mask, info.origin_mask)(((origin_mask) & (info.origin_mask)) == (info.origin_mask
)) &&

2758

FLAGS_SET(destination_mask, info.destination_mask)(((destination_mask) & (info.destination_mask)) == (info.
destination_mask)))

2759

return 0; /* NOP */

2760

2761

info.origin_mask |= origin_mask;

2762

info.destination_mask |= destination_mask;

2763

2764

r = hashmap_update(*h, other, info.data);

2765

} else {

2766

info = (UnitDependencyInfo) {

2767

.origin_mask = origin_mask,

2768

.destination_mask = destination_mask,

2769

};

2770

2771

r = hashmap_put(*h, other, info.data);

2772

}

2773

if (r < 0)

2774

return r;

2775

2776

return 1;

2777

}

2778

2779

int unit_add_dependency(

2780

Unit *u,

2781

UnitDependency d,

2782

Unit *other,

2783

bool_Bool add_reference,

2784

UnitDependencyMask mask) {

2785

2786

static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {

2787

[UNIT_REQUIRES] = UNIT_REQUIRED_BY,

2788

[UNIT_WANTS] = UNIT_WANTED_BY,

2789

[UNIT_REQUISITE] = UNIT_REQUISITE_OF,

2790

[UNIT_BINDS_TO] = UNIT_BOUND_BY,

2791

[UNIT_PART_OF] = UNIT_CONSISTS_OF,

2792

[UNIT_REQUIRED_BY] = UNIT_REQUIRES,

2793

[UNIT_REQUISITE_OF] = UNIT_REQUISITE,

2794

[UNIT_WANTED_BY] = UNIT_WANTS,

2795

[UNIT_BOUND_BY] = UNIT_BINDS_TO,

2796

[UNIT_CONSISTS_OF] = UNIT_PART_OF,

2797

[UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,

2798

[UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,

2799

[UNIT_BEFORE] = UNIT_AFTER,

2800

[UNIT_AFTER] = UNIT_BEFORE,

2801

[UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,

2802

[UNIT_REFERENCES] = UNIT_REFERENCED_BY,

2803

[UNIT_REFERENCED_BY] = UNIT_REFERENCES,

2804

[UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,

2805

[UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,

2806

[UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,

2807

[UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,

2808

[UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,

2809

};

2810

Unit *original_u = u, *original_other = other;

2811

int r;

2812

2813

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2813, __PRETTY_FUNCTION__
); } while (0);

2814

assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX)do { if ((__builtin_expect(!!(!(d >= 0 && d < _UNIT_DEPENDENCY_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("d >= 0 && d < _UNIT_DEPENDENCY_MAX"
), "../src/core/unit.c", 2814, __PRETTY_FUNCTION__); } while (
0);

2815

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 2815, __PRETTY_FUNCTION__
); } while (0);

2816

2817

u = unit_follow_merge(u);

2818

other = unit_follow_merge(other);

2819

2820

/* We won't allow dependencies on ourselves. We will not

2821

* consider them an error however. */

2822

if (u == other) {

2823

maybe_warn_about_dependency(original_u, original_other->id, d);

2824

return 0;

2825

}

2826

2827

if ((d == UNIT_BEFORE && other->type == UNIT_DEVICE) ||

2828

(d == UNIT_AFTER && u->type == UNIT_DEVICE)) {

2829

log_unit_warning(u, "Dependency Before=%s ignored (.device units cannot be delayed)", other->id)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 2829, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Dependency Before=%s ignored (.device units cannot be delayed)"
, other->id) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((4))), 0, "../src/core/unit.c", 2829, __func__, "Dependency Before=%s ignored (.device units cannot be delayed)"
, other->id); });

2830

return 0;

2831

}

2832

2833

r = unit_add_dependency_hashmap(u->dependencies + d, other, mask, 0);

2834

if (r < 0)

2835

return r;

2836

2837

if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {

2838

r = unit_add_dependency_hashmap(other->dependencies + inverse_table[d], u, 0, mask);

2839

if (r < 0)

2840

return r;

2841

}

2842

2843

if (add_reference) {

2844

r = unit_add_dependency_hashmap(u->dependencies + UNIT_REFERENCES, other, mask, 0);

2845

if (r < 0)

2846

return r;

2847

2848

r = unit_add_dependency_hashmap(other->dependencies + UNIT_REFERENCED_BY, u, 0, mask);

2849

if (r < 0)

2850

return r;

2851

}

2852

2853

unit_add_to_dbus_queue(u);

2854

return 0;

2855

}

2856

2857

int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool_Bool add_reference, UnitDependencyMask mask) {

2858

int r;

2859

2860

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2860, __PRETTY_FUNCTION__
); } while (0);

2861

2862

r = unit_add_dependency(u, d, other, add_reference, mask);

2863

if (r < 0)

2864

return r;

2865

2866

return unit_add_dependency(u, e, other, add_reference, mask);

2867

}

2868

2869

static int resolve_template(Unit *u, const char *name, const char*path, char **buf, const char **ret) {

2870

int r;

2871

2872

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2872, __PRETTY_FUNCTION__
); } while (0);

2873

assert(name || path)do { if ((__builtin_expect(!!(!(name || path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name || path"), "../src/core/unit.c", 2873
, __PRETTY_FUNCTION__); } while (0);

2874

assert(buf)do { if ((__builtin_expect(!!(!(buf)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("buf"), "../src/core/unit.c", 2874, __PRETTY_FUNCTION__
); } while (0);

2875

assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/core/unit.c", 2875, __PRETTY_FUNCTION__
); } while (0);

2876

2877

if (!name)

2878

name = basename(path);

2879

2880

if (!unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {

2881

*buf = NULL((void*)0);

2882

*ret = name;

2883

return 0;

2884

}

2885

2886

if (u->instance)

2887

r = unit_name_replace_instance(name, u->instance, buf);

2888

else {

2889

_cleanup_free___attribute__((cleanup(freep))) char *i = NULL((void*)0);

2890

2891

r = unit_name_to_prefix(u->id, &i);

2892

if (r < 0)

2893

return r;

2894

2895

r = unit_name_replace_instance(name, i, buf);

2896

}

2897

if (r < 0)

2898

return r;

2899

2900

*ret = *buf;

2901

return 0;

2902

}

2903

2904

int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool_Bool add_reference, UnitDependencyMask mask) {

2905

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

2906

Unit *other;

2907

int r;

2908

2909

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2909, __PRETTY_FUNCTION__
); } while (0);

2910

assert(name || path)do { if ((__builtin_expect(!!(!(name || path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name || path"), "../src/core/unit.c", 2910
, __PRETTY_FUNCTION__); } while (0);

2911

2912

r = resolve_template(u, name, path, &buf, &name);

2913

if (r < 0)

2914

return r;

2915

2916

r = manager_load_unit(u->manager, name, path, NULL((void*)0), &other);

2917

if (r < 0)

2918

return r;

2919

2920

return unit_add_dependency(u, d, other, add_reference, mask);

2921

}

2922

2923

int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool_Bool add_reference, UnitDependencyMask mask) {

2924

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

2925

Unit *other;

2926

int r;

2927

2928

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2928, __PRETTY_FUNCTION__
); } while (0);

2929

assert(name || path)do { if ((__builtin_expect(!!(!(name || path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name || path"), "../src/core/unit.c", 2929
, __PRETTY_FUNCTION__); } while (0);

2930

2931

r = resolve_template(u, name, path, &buf, &name);

2932

if (r < 0)

2933

return r;

2934

2935

r = manager_load_unit(u->manager, name, path, NULL((void*)0), &other);

2936

if (r < 0)

2937

return r;

2938

2939

return unit_add_two_dependencies(u, d, e, other, add_reference, mask);

2940

}

2941

2942

int set_unit_path(const char *p) {

2943

/* This is mostly for debug purposes */

2944

if (setenv("SYSTEMD_UNIT_PATH", p, 1) < 0)

2945

return -errno(*__errno_location ());

2946

2947

return 0;

2948

}

2949

2950

char *unit_dbus_path(Unit *u) {

2951

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2951, __PRETTY_FUNCTION__
); } while (0);

2952

2953

if (!u->id)

2954

return NULL((void*)0);

2955

2956

return unit_dbus_path_from_name(u->id);

2957

}

2958

2959

char *unit_dbus_path_invocation_id(Unit *u) {

2960

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2960, __PRETTY_FUNCTION__
); } while (0);

2961

2962

if (sd_id128_is_null(u->invocation_id))

2963

return NULL((void*)0);

2964

2965

return unit_dbus_path_from_name(u->invocation_id_string);

2966

}

2967

2968

int unit_set_slice(Unit *u, Unit *slice) {

2969

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 2969, __PRETTY_FUNCTION__
); } while (0);

2970

assert(slice)do { if ((__builtin_expect(!!(!(slice)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("slice"), "../src/core/unit.c", 2970, __PRETTY_FUNCTION__
); } while (0);

2971

2972

/* Sets the unit slice if it has not been set before. Is extra

2973

* careful, to only allow this for units that actually have a

2974

* cgroup context. Also, we don't allow to set this for slices

2975

* (since the parent slice is derived from the name). Make

2976

* sure the unit we set is actually a slice. */

2977

2978

if (!UNIT_HAS_CGROUP_CONTEXT(u)(unit_vtable[(u)->type]->cgroup_context_offset > 0))

2979

return -EOPNOTSUPP95;

2980

2981

if (u->type == UNIT_SLICE)

2982

return -EINVAL22;

2983

2984

if (unit_active_state(u) != UNIT_INACTIVE)

2985

return -EBUSY16;

2986

2987

if (slice->type != UNIT_SLICE)

2988

return -EINVAL22;

2989

2990

if (unit_has_name(u, SPECIAL_INIT_SCOPE"init.scope") &&

2991

!unit_has_name(slice, SPECIAL_ROOT_SLICE"-.slice"))

2992

return -EPERM1;

2993

2994

if (UNIT_DEREF(u->slice)((u->slice).target) == slice)

2995

return 0;

2996

2997

/* Disallow slice changes if @u is already bound to cgroups */

2998

if (UNIT_ISSET(u->slice)(!!(u->slice).target) && u->cgroup_realized)

2999

return -EBUSY16;

3000

3001

unit_ref_set(&u->slice, u, slice);

3002

return 1;

3003

}

3004

3005

int unit_set_default_slice(Unit *u) {

3006

_cleanup_free___attribute__((cleanup(freep))) char *b = NULL((void*)0);

3007

const char *slice_name;

3008

Unit *slice;

3009

int r;

3010

3011

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3011, __PRETTY_FUNCTION__
); } while (0);

3012

3013

if (UNIT_ISSET(u->slice)(!!(u->slice).target))

3014

return 0;

3015

3016

if (u->instance) {

3017

_cleanup_free___attribute__((cleanup(freep))) char *prefix = NULL((void*)0), *escaped = NULL((void*)0);

3018

3019

/* Implicitly place all instantiated units in their

3020

* own per-template slice */

3021

3022

r = unit_name_to_prefix(u->id, &prefix);

3023

if (r < 0)

3024

return r;

3025

3026

/* The prefix is already escaped, but it might include

3027

* "-" which has a special meaning for slice units,

3028

* hence escape it here extra. */

3029

escaped = unit_name_escape(prefix);

3030

if (!escaped)

3031

return -ENOMEM12;

3032

3033

if (MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM))

3034

b = strjoin("system-", escaped, ".slice")strjoin_real(("system-"), escaped, ".slice", ((void*)0));

3035

else

3036

b = strappend(escaped, ".slice");

3037

if (!b)

3038

return -ENOMEM12;

3039

3040

slice_name = b;

3041

} else

3042

slice_name =

3043

MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM) && !unit_has_name(u, SPECIAL_INIT_SCOPE"init.scope")

3044

? SPECIAL_SYSTEM_SLICE"system.slice"

3045

: SPECIAL_ROOT_SLICE"-.slice";

3046

3047

r = manager_load_unit(u->manager, slice_name, NULL((void*)0), NULL((void*)0), &slice);

3048

if (r < 0)

3049

return r;

3050

3051

return unit_set_slice(u, slice);

3052

}

3053

3054

const char *unit_slice_name(Unit *u) {

3055

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3055, __PRETTY_FUNCTION__
); } while (0);

3056

3057

if (!UNIT_ISSET(u->slice)(!!(u->slice).target))

3058

return NULL((void*)0);

3059

3060

return UNIT_DEREF(u->slice)((u->slice).target)->id;

3061

}

3062

3063

int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {

3064

_cleanup_free___attribute__((cleanup(freep))) char *t = NULL((void*)0);

3065

int r;

3066

3067

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3067, __PRETTY_FUNCTION__
); } while (0);

3068

assert(type)do { if ((__builtin_expect(!!(!(type)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("type"), "../src/core/unit.c", 3068, __PRETTY_FUNCTION__
); } while (0);

3069

assert(_found)do { if ((__builtin_expect(!!(!(_found)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_found"), "../src/core/unit.c", 3069, __PRETTY_FUNCTION__
); } while (0);

3070

3071

r = unit_name_change_suffix(u->id, type, &t);

3072

if (r < 0)

3073

return r;

3074

if (unit_has_name(u, t))

3075

return -EINVAL22;

3076

3077

r = manager_load_unit(u->manager, t, NULL((void*)0), NULL((void*)0), _found);

3078

assert(r < 0 || *_found != u)do { if ((__builtin_expect(!!(!(r < 0 || *_found != u)),0)
)) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("r < 0 || *_found != u"
), "../src/core/unit.c", 3078, __PRETTY_FUNCTION__); } while (
0);

3079

return r;

3080

}

3081

3082

static int signal_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {

3083

const char *name, *old_owner, *new_owner;

3084

Unit *u = userdata;

3085

int r;

3086

3087

assert(message)do { if ((__builtin_expect(!!(!(message)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("message"), "../src/core/unit.c", 3087, __PRETTY_FUNCTION__
); } while (0);

3088

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3088, __PRETTY_FUNCTION__
); } while (0);

3089

3090

r = sd_bus_message_read(message, "sss", &name, &old_owner, &new_owner);

3091

if (r < 0) {

3092

bus_log_parse_error(r);

3093

return 0;

3094

}

3095

3096

old_owner = empty_to_null(old_owner);

3097

new_owner = empty_to_null(new_owner);

3098

3099

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->bus_name_owner_change)

3100

UNIT_VTABLE(u)unit_vtable[(u)->type]->bus_name_owner_change(u, name, old_owner, new_owner);

3101

3102

return 0;

3103

}

3104

3105

int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name) {

3106

const char *match;

3107

3108

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3108, __PRETTY_FUNCTION__
); } while (0);

3109

assert(bus)do { if ((__builtin_expect(!!(!(bus)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("bus"), "../src/core/unit.c", 3109, __PRETTY_FUNCTION__
); } while (0);

3110

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 3110, __PRETTY_FUNCTION__
); } while (0);

3111

3112

if (u->match_bus_slot)

3113

return -EBUSY16;

3114

3115

match = strjoina("type='signal',"({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

3116

"sender='org.freedesktop.DBus',"({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

3117

"path='/org/freedesktop/DBus',"({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

3118

"interface='org.freedesktop.DBus',"({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

3119

"member='NameOwnerChanged',"({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

3120

"arg0='", name, "'")({ const char *_appendees_[] = { "type='signal'," "sender='org.freedesktop.DBus',"
"path='/org/freedesktop/DBus'," "interface='org.freedesktop.DBus',"
"member='NameOwnerChanged'," "arg0='", name, "'" }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

3121

3122

return sd_bus_add_match_async(bus, &u->match_bus_slot, match, signal_name_owner_changed, NULL((void*)0), u);

3123

}

3124

3125

int unit_watch_bus_name(Unit *u, const char *name) {

3126

int r;

3127

3128

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3128, __PRETTY_FUNCTION__
); } while (0);

3129

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 3129, __PRETTY_FUNCTION__
); } while (0);

3130

3131

/* Watch a specific name on the bus. We only support one unit

3132

* watching each name for now. */

3133

3134

if (u->manager->api_bus) {

3135

/* If the bus is already available, install the match directly.

3136

* Otherwise, just put the name in the list. bus_setup_api() will take care later. */

3137

r = unit_install_bus_match(u, u->manager->api_bus, name);

3138

if (r < 0)

3139

return log_warning_errno(r, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name)({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 3139, __func__, "Failed to subscribe to NameOwnerChanged signal for '%s': %m"
, name) : -abs(_e); });

3140

}

3141

3142

r = hashmap_put(u->manager->watch_bus, name, u);

3143

if (r < 0) {

3144

u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);

3145

return log_warning_errno(r, "Failed to put bus name to hashmap: %m")({ int _level = ((4)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 3145, __func__, "Failed to put bus name to hashmap: %m"
) : -abs(_e); });

3146

}

3147

3148

return 0;

3149

}

3150

3151

void unit_unwatch_bus_name(Unit *u, const char *name) {

3152

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3152, __PRETTY_FUNCTION__
); } while (0);

3153

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 3153, __PRETTY_FUNCTION__
); } while (0);

3154

3155

(void) hashmap_remove_value(u->manager->watch_bus, name, u);

3156

u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);

3157

}

3158

3159

bool_Bool unit_can_serialize(Unit *u) {

3160

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3160, __PRETTY_FUNCTION__
); } while (0);

3161

3162

return UNIT_VTABLE(u)unit_vtable[(u)->type]->serialize && UNIT_VTABLE(u)unit_vtable[(u)->type]->deserialize_item;

3163

}

3164

3165

static int unit_serialize_cgroup_mask(FILE *f, const char *key, CGroupMask mask) {

3166

_cleanup_free___attribute__((cleanup(freep))) char *s = NULL((void*)0);

3167

int r = 0;

3168

3169

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3169, __PRETTY_FUNCTION__
); } while (0);

3170

assert(key)do { if ((__builtin_expect(!!(!(key)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("key"), "../src/core/unit.c", 3170, __PRETTY_FUNCTION__
); } while (0);

3171

3172

if (mask != 0) {

3173

r = cg_mask_to_string(mask, &s);

3174

if (r >= 0) {

3175

fputs(key, f);

3176

fputc('=', f);

3177

fputs(s, f);

3178

fputc('\n', f);

3179

}

3180

}

3181

return r;

3182

}

3183

3184

static const char *ip_accounting_metric_field[_CGROUP_IP_ACCOUNTING_METRIC_MAX] = {

3185

[CGROUP_IP_INGRESS_BYTES] = "ip-accounting-ingress-bytes",

3186

[CGROUP_IP_INGRESS_PACKETS] = "ip-accounting-ingress-packets",

3187

[CGROUP_IP_EGRESS_BYTES] = "ip-accounting-egress-bytes",

3188

[CGROUP_IP_EGRESS_PACKETS] = "ip-accounting-egress-packets",

3189

};

3190

3191

int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool_Bool serialize_jobs) {

3192

CGroupIPAccountingMetric m;

3193

int r;

3194

3195

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3195, __PRETTY_FUNCTION__
); } while (0);

3196

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3196, __PRETTY_FUNCTION__
); } while (0);

3197

assert(fds)do { if ((__builtin_expect(!!(!(fds)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fds"), "../src/core/unit.c", 3197, __PRETTY_FUNCTION__
); } while (0);

3198

3199

if (unit_can_serialize(u)) {

3200

r = UNIT_VTABLE(u)unit_vtable[(u)->type]->serialize(u, f, fds);

3201

if (r < 0)

3202

return r;

3203

}

3204

3205

dual_timestamp_serialize(f, "state-change-timestamp", &u->state_change_timestamp);

3206

3207

dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);

3208

dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);

3209

dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);

3210

dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);

3211

3212

dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);

3213

dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);

3214

3215

if (dual_timestamp_is_set(&u->condition_timestamp))

3216

unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));

3217

3218

if (dual_timestamp_is_set(&u->assert_timestamp))

3219

unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));

3220

3221

unit_serialize_item(u, f, "transient", yes_no(u->transient));

3222

3223

unit_serialize_item(u, f, "exported-invocation-id", yes_no(u->exported_invocation_id));

3224

unit_serialize_item(u, f, "exported-log-level-max", yes_no(u->exported_log_level_max));

3225

unit_serialize_item(u, f, "exported-log-extra-fields", yes_no(u->exported_log_extra_fields));

3226

unit_serialize_item(u, f, "exported-log-rate-limit-interval", yes_no(u->exported_log_rate_limit_interval));

3227

unit_serialize_item(u, f, "exported-log-rate-limit-burst", yes_no(u->exported_log_rate_limit_burst));

3228

3229

unit_serialize_item_format(u, f, "cpu-usage-base", "%" PRIu64"l" "u", u->cpu_usage_base);

3230

if (u->cpu_usage_last != NSEC_INFINITY((nsec_t) -1))

3231

unit_serialize_item_format(u, f, "cpu-usage-last", "%" PRIu64"l" "u", u->cpu_usage_last);

3232

3233

if (u->cgroup_path)

3234

unit_serialize_item(u, f, "cgroup", u->cgroup_path);

3235

unit_serialize_item(u, f, "cgroup-realized", yes_no(u->cgroup_realized));

3236

(void) unit_serialize_cgroup_mask(f, "cgroup-realized-mask", u->cgroup_realized_mask);

3237

(void) unit_serialize_cgroup_mask(f, "cgroup-enabled-mask", u->cgroup_enabled_mask);

3238

unit_serialize_item_format(u, f, "cgroup-bpf-realized", "%i", u->cgroup_bpf_state);

3239

3240

if (uid_is_valid(u->ref_uid))

3241

unit_serialize_item_format(u, f, "ref-uid", UID_FMT"%" "u", u->ref_uid);

3242

if (gid_is_valid(u->ref_gid))

3243

unit_serialize_item_format(u, f, "ref-gid", GID_FMT"%" "u", u->ref_gid);

3244

3245

if (!sd_id128_is_null(u->invocation_id))

3246

unit_serialize_item_format(u, f, "invocation-id", SD_ID128_FORMAT_STR"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", SD_ID128_FORMAT_VAL(u->invocation_id)(u->invocation_id).bytes[0], (u->invocation_id).bytes[1
], (u->invocation_id).bytes[2], (u->invocation_id).bytes
[3], (u->invocation_id).bytes[4], (u->invocation_id).bytes
[5], (u->invocation_id).bytes[6], (u->invocation_id).bytes
[7], (u->invocation_id).bytes[8], (u->invocation_id).bytes
[9], (u->invocation_id).bytes[10], (u->invocation_id).bytes
[11], (u->invocation_id).bytes[12], (u->invocation_id).
bytes[13], (u->invocation_id).bytes[14], (u->invocation_id
).bytes[15]);

3247

3248

(void) unit_serialize_item_format(u, f, "freezer-state", "%s", freezer_state_to_string(unit_freezer_state(u)));

3249

3250

bus_track_serialize(u->bus_track, f, "ref");

3251

3252

for (m = 0; m < _CGROUP_IP_ACCOUNTING_METRIC_MAX; m++) {

3253

uint64_t v;

3254

3255

r = unit_get_ip_accounting(u, m, &v);

3256

if (r >= 0)

3257

unit_serialize_item_format(u, f, ip_accounting_metric_field[m], "%" PRIu64"l" "u", v);

3258

}

3259

3260

if (serialize_jobs) {

3261

if (u->job) {

3262

fprintf(f, "job\n");

3263

job_serialize(u->job, f);

3264

}

3265

3266

if (u->nop_job) {

3267

fprintf(f, "job\n");

3268

job_serialize(u->nop_job, f);

3269

}

3270

}

3271

3272

/* End marker */

3273

fputc('\n', f);

3274

return 0;

3275

}

3276

3277

int unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {

3278

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3278, __PRETTY_FUNCTION__
); } while (0);

3279

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3279, __PRETTY_FUNCTION__
); } while (0);

3280

assert(key)do { if ((__builtin_expect(!!(!(key)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("key"), "../src/core/unit.c", 3280, __PRETTY_FUNCTION__
); } while (0);

3281

3282

if (!value)

3283

return 0;

3284

3285

fputs(key, f);

3286

fputc('=', f);

3287

fputs(value, f);

3288

fputc('\n', f);

3289

3290

return 1;

3291

}

3292

3293

int unit_serialize_item_escaped(Unit *u, FILE *f, const char *key, const char *value) {

3294

_cleanup_free___attribute__((cleanup(freep))) char *c = NULL((void*)0);

3295

3296

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3296, __PRETTY_FUNCTION__
); } while (0);

3297

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3297, __PRETTY_FUNCTION__
); } while (0);

3298

assert(key)do { if ((__builtin_expect(!!(!(key)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("key"), "../src/core/unit.c", 3298, __PRETTY_FUNCTION__
); } while (0);

3299

3300

if (!value)

3301

return 0;

3302

3303

c = cescape(value);

3304

if (!c)

3305

return -ENOMEM12;

3306

3307

fputs(key, f);

3308

fputc('=', f);

3309

fputs(c, f);

3310

fputc('\n', f);

3311

3312

return 1;

3313

}

3314

3315

int unit_serialize_item_fd(Unit *u, FILE *f, FDSet *fds, const char *key, int fd) {

3316

int copy;

3317

3318

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3318, __PRETTY_FUNCTION__
); } while (0);

3319

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3319, __PRETTY_FUNCTION__
); } while (0);

3320

assert(key)do { if ((__builtin_expect(!!(!(key)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("key"), "../src/core/unit.c", 3320, __PRETTY_FUNCTION__
); } while (0);

3321

3322

if (fd < 0)

3323

return 0;

3324

3325

copy = fdset_put_dup(fds, fd);

3326

if (copy < 0)

3327

return copy;

3328

3329

fprintf(f, "%s=%i\n", key, copy);

3330

return 1;

3331

}

3332

3333

void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {

3334

va_list ap;

3335

3336

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3336, __PRETTY_FUNCTION__
); } while (0);

3337

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3337, __PRETTY_FUNCTION__
); } while (0);

3338

assert(key)do { if ((__builtin_expect(!!(!(key)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("key"), "../src/core/unit.c", 3338, __PRETTY_FUNCTION__
); } while (0);

3339

assert(format)do { if ((__builtin_expect(!!(!(format)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("format"), "../src/core/unit.c", 3339, __PRETTY_FUNCTION__
); } while (0);

3340

3341

fputs(key, f);

3342

fputc('=', f);

3343

3344

va_start(ap, format)__builtin_va_start(ap, format);

3345

vfprintf(f, format, ap);

3346

va_end(ap)__builtin_va_end(ap);

3347

3348

fputc('\n', f);

3349

}

3350

3351

int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {

3352

int r;

3353

3354

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3354, __PRETTY_FUNCTION__
); } while (0);

3355

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3355, __PRETTY_FUNCTION__
); } while (0);

3356

assert(fds)do { if ((__builtin_expect(!!(!(fds)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("fds"), "../src/core/unit.c", 3356, __PRETTY_FUNCTION__
); } while (0);

3357

3358

for (;;) {

3359

_cleanup_free___attribute__((cleanup(freep))) char *line = NULL((void*)0);

3360

CGroupIPAccountingMetric m;

3361

char *l, *v;

3362

size_t k;

3363

3364

r = read_line(f, LONG_LINE_MAX(1U*1024U*1024U), &line);

3365

if (r < 0)

3366

return log_error_errno(r, "Failed to read serialization line: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 3366, __func__, "Failed to read serialization line: %m"
) : -abs(_e); });

3367

if (r == 0) /* eof */

3368

break;

3369

3370

l = strstrip(line);

3371

if (isempty(l)) /* End marker */

3372

break;

3373

3374

k = strcspn(l, "=");

3375

3376

if (l[k] == '=') {

3377

l[k] = 0;

3378

v = l+k+1;

3379

} else

3380

v = l+k;

3381

3382

if (streq(l, "job")(strcmp((l),("job")) == 0)) {

3383

if (v[0] == '\0') {

3384

/* new-style serialized job */

3385

Job *j;

3386

3387

j = job_new_raw(u);

3388

if (!j)

3389

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 3389
, __func__);

3390

3391

r = job_deserialize(j, f);

3392

if (r < 0) {

3393

job_free(j);

3394

return r;

3395

}

3396

3397

r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id)((void *) ((uintptr_t) (j->id))), j);

3398

if (r < 0) {

3399

job_free(j);

3400

return r;

3401

}

3402

3403

r = job_install_deserialized(j);

3404

if (r < 0) {

3405

hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id)((void *) ((uintptr_t) (j->id))));

3406

job_free(j);

3407

return r;

3408

}

3409

} else /* legacy for pre-44 */

3410

log_unit_warning(u, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 3410, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Update from too old systemd versions are unsupported, cannot deserialize job: %s"
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(4))), 0, "../src/core/unit.c", 3410, __func__, "Update from too old systemd versions are unsupported, cannot deserialize job: %s"
, v); });

3411

continue;

3412

} else if (streq(l, "state-change-timestamp")(strcmp((l),("state-change-timestamp")) == 0)) {

3413

dual_timestamp_deserialize(v, &u->state_change_timestamp);

3414

continue;

3415

} else if (streq(l, "inactive-exit-timestamp")(strcmp((l),("inactive-exit-timestamp")) == 0)) {

3416

dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);

3417

continue;

3418

} else if (streq(l, "active-enter-timestamp")(strcmp((l),("active-enter-timestamp")) == 0)) {

3419

dual_timestamp_deserialize(v, &u->active_enter_timestamp);

3420

continue;

3421

} else if (streq(l, "active-exit-timestamp")(strcmp((l),("active-exit-timestamp")) == 0)) {

3422

dual_timestamp_deserialize(v, &u->active_exit_timestamp);

3423

continue;

3424

} else if (streq(l, "inactive-enter-timestamp")(strcmp((l),("inactive-enter-timestamp")) == 0)) {

3425

dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);

3426

continue;

3427

} else if (streq(l, "condition-timestamp")(strcmp((l),("condition-timestamp")) == 0)) {

3428

dual_timestamp_deserialize(v, &u->condition_timestamp);

3429

continue;

3430

} else if (streq(l, "assert-timestamp")(strcmp((l),("assert-timestamp")) == 0)) {

3431

dual_timestamp_deserialize(v, &u->assert_timestamp);

3432

continue;

3433

} else if (streq(l, "condition-result")(strcmp((l),("condition-result")) == 0)) {

3434

3435

r = parse_boolean(v);

3436

if (r < 0)

3437

log_unit_debug(u, "Failed to parse condition result value %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3437, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse condition result value %s, ignoring.", v) :
log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7)))
, 0, "../src/core/unit.c", 3437, __func__, "Failed to parse condition result value %s, ignoring."
, v); });

3438

else

3439

u->condition_result = r;

3440

3441

continue;

3442

3443

} else if (streq(l, "assert-result")(strcmp((l),("assert-result")) == 0)) {

3444

3445

r = parse_boolean(v);

3446

if (r < 0)

3447

log_unit_debug(u, "Failed to parse assert result value %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3447, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse assert result value %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3447, __func__, "Failed to parse assert result value %s, ignoring."
, v); });

3448

else

3449

u->assert_result = r;

3450

3451

continue;

3452

3453

} else if (streq(l, "transient")(strcmp((l),("transient")) == 0)) {

3454

3455

r = parse_boolean(v);

3456

if (r < 0)

3457

log_unit_debug(u, "Failed to parse transient bool %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3457, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse transient bool %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3457, __func__, "Failed to parse transient bool %s, ignoring."
, v); });

3458

else

3459

u->transient = r;

3460

3461

continue;

3462

3463

} else if (streq(l, "exported-invocation-id")(strcmp((l),("exported-invocation-id")) == 0)) {

3464

3465

r = parse_boolean(v);

3466

if (r < 0)

3467

log_unit_debug(u, "Failed to parse exported invocation ID bool %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3467, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse exported invocation ID bool %s, ignoring."
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(7))), 0, "../src/core/unit.c", 3467, __func__, "Failed to parse exported invocation ID bool %s, ignoring."
, v); });

3468

else

3469

u->exported_invocation_id = r;

3470

3471

continue;

3472

3473

} else if (streq(l, "exported-log-level-max")(strcmp((l),("exported-log-level-max")) == 0)) {

3474

3475

r = parse_boolean(v);

3476

if (r < 0)

3477

log_unit_debug(u, "Failed to parse exported log level max bool %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3477, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse exported log level max bool %s, ignoring."
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(7))), 0, "../src/core/unit.c", 3477, __func__, "Failed to parse exported log level max bool %s, ignoring."
, v); });

3478

else

3479

u->exported_log_level_max = r;

3480

3481

continue;

3482

3483

} else if (streq(l, "exported-log-extra-fields")(strcmp((l),("exported-log-extra-fields")) == 0)) {

3484

3485

r = parse_boolean(v);

3486

if (r < 0)

3487

log_unit_debug(u, "Failed to parse exported log extra fields bool %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3487, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse exported log extra fields bool %s, ignoring."
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(7))), 0, "../src/core/unit.c", 3487, __func__, "Failed to parse exported log extra fields bool %s, ignoring."
, v); });

3488

else

3489

u->exported_log_extra_fields = r;

3490

3491

continue;

3492

3493

} else if (streq(l, "exported-log-rate-limit-interval")(strcmp((l),("exported-log-rate-limit-interval")) == 0)) {

3494

3495

r = parse_boolean(v);

3496

if (r < 0)

3497

log_unit_debug(u, "Failed to parse exported log rate limit interval %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3497, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse exported log rate limit interval %s, ignoring."
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(7))), 0, "../src/core/unit.c", 3497, __func__, "Failed to parse exported log rate limit interval %s, ignoring."
, v); });

3498

else

3499

u->exported_log_rate_limit_interval = r;

3500

3501

continue;

3502

3503

} else if (streq(l, "exported-log-rate-limit-burst")(strcmp((l),("exported-log-rate-limit-burst")) == 0)) {

3504

3505

r = parse_boolean(v);

3506

if (r < 0)

3507

log_unit_debug(u, "Failed to parse exported log rate limit burst %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3507, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse exported log rate limit burst %s, ignoring."
, v) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | (
(7))), 0, "../src/core/unit.c", 3507, __func__, "Failed to parse exported log rate limit burst %s, ignoring."
, v); });

3508

else

3509

u->exported_log_rate_limit_burst = r;

3510

3511

continue;

3512

3513

} else if (STR_IN_SET(l, "cpu-usage-base", "cpuacct-usage-base")(!!strv_find((((char**) ((const char*[]) { "cpu-usage-base", "cpuacct-usage-base"
, ((void*)0) }))), (l)))) {

3514

3515

r = safe_atou64(v, &u->cpu_usage_base);

3516

if (r < 0)

3517

log_unit_debug(u, "Failed to parse CPU usage base %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3517, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse CPU usage base %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3517, __func__, "Failed to parse CPU usage base %s, ignoring."
, v); });

3518

3519

continue;

3520

3521

} else if (streq(l, "cpu-usage-last")(strcmp((l),("cpu-usage-last")) == 0)) {

3522

3523

r = safe_atou64(v, &u->cpu_usage_last);

3524

if (r < 0)

3525

log_unit_debug(u, "Failed to read CPU usage last %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3525, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to read CPU usage last %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3525, __func__, "Failed to read CPU usage last %s, ignoring."
, v); });

3526

3527

continue;

3528

3529

} else if (streq(l, "cgroup")(strcmp((l),("cgroup")) == 0)) {

3530

3531

r = unit_set_cgroup_path(u, v);

3532

if (r < 0)

3533

log_unit_debug_errno(u, r, "Failed to set cgroup path %s, ignoring: %m", v)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 3533, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to set cgroup path %s, ignoring: %m", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), r, "../src/core/unit.c"
, 3533, __func__, "Failed to set cgroup path %s, ignoring: %m"
, v); });

3534

3535

(void) unit_watch_cgroup(u);

3536

3537

continue;

3538

} else if (streq(l, "cgroup-realized")(strcmp((l),("cgroup-realized")) == 0)) {

3539

int b;

3540

3541

b = parse_boolean(v);

3542

if (b < 0)

3543

log_unit_debug(u, "Failed to parse cgroup-realized bool %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3543, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse cgroup-realized bool %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3543, __func__, "Failed to parse cgroup-realized bool %s, ignoring."
, v); });

3544

else

3545

u->cgroup_realized = b;

3546

3547

continue;

3548

3549

} else if (streq(l, "cgroup-realized-mask")(strcmp((l),("cgroup-realized-mask")) == 0)) {

3550

3551

r = cg_mask_from_string(v, &u->cgroup_realized_mask);

3552

if (r < 0)

3553

log_unit_debug(u, "Failed to parse cgroup-realized-mask %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3553, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse cgroup-realized-mask %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3553, __func__, "Failed to parse cgroup-realized-mask %s, ignoring."
, v); });

3554

continue;

3555

3556

} else if (streq(l, "cgroup-enabled-mask")(strcmp((l),("cgroup-enabled-mask")) == 0)) {

3557

3558

r = cg_mask_from_string(v, &u->cgroup_enabled_mask);

3559

if (r < 0)

3560

log_unit_debug(u, "Failed to parse cgroup-enabled-mask %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3560, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse cgroup-enabled-mask %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3560, __func__, "Failed to parse cgroup-enabled-mask %s, ignoring."
, v); });

3561

continue;

3562

3563

} else if (streq(l, "cgroup-bpf-realized")(strcmp((l),("cgroup-bpf-realized")) == 0)) {

3564

int i;

3565

3566

r = safe_atoi(v, &i);

3567

if (r < 0)

3568

log_unit_debug(u, "Failed to parse cgroup BPF state %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3568, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse cgroup BPF state %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3568, __func__, "Failed to parse cgroup BPF state %s, ignoring."
, v); });

3569

else

3570

u->cgroup_bpf_state =

3571

i < 0 ? UNIT_CGROUP_BPF_INVALIDATED :

3572

i > 0 ? UNIT_CGROUP_BPF_ON :

3573

UNIT_CGROUP_BPF_OFF;

3574

3575

continue;

3576

3577

} else if (streq(l, "ref-uid")(strcmp((l),("ref-uid")) == 0)) {

3578

uid_t uid;

3579

3580

r = parse_uid(v, &uid);

3581

if (r < 0)

3582

log_unit_debug(u, "Failed to parse referenced UID %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3582, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse referenced UID %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3582, __func__, "Failed to parse referenced UID %s, ignoring."
, v); });

3583

else

3584

unit_ref_uid_gid(u, uid, GID_INVALID((gid_t) -1));

3585

3586

continue;

3587

3588

} else if (streq(l, "ref-gid")(strcmp((l),("ref-gid")) == 0)) {

3589

gid_t gid;

3590

3591

r = parse_gid(v, &gid);

3592

if (r < 0)

3593

log_unit_debug(u, "Failed to parse referenced GID %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3593, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse referenced GID %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3593, __func__, "Failed to parse referenced GID %s, ignoring."
, v); });

3594

else

3595

unit_ref_uid_gid(u, UID_INVALID((uid_t) -1), gid);

3596

3597

} else if (streq(l, "ref")(strcmp((l),("ref")) == 0)) {

3598

3599

r = strv_extend(&u->deserialized_refs, v);

3600

if (r < 0)

3601

log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 3601
, __func__);

3602

3603

continue;

3604

} else if (streq(l, "invocation-id")(strcmp((l),("invocation-id")) == 0)) {

3605

sd_id128_t id;

3606

3607

r = sd_id128_from_string(v, &id);

3608

if (r < 0)

3609

log_unit_debug(u, "Failed to parse invocation id %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3609, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse invocation id %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3609, __func__, "Failed to parse invocation id %s, ignoring."
, v); });

3610

else {

3611

r = unit_set_invocation_id(u, id);

3612

if (r < 0)

3613

log_unit_warning_errno(u, r, "Failed to set invocation ID for unit: %m")({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 3613, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to set invocation ID for unit: %m") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((4))), r, "../src/core/unit.c"
, 3613, __func__, "Failed to set invocation ID for unit: %m")
; });

3614

}

3615

3616

continue;

3617

} else if (streq(l, "freezer-state")(strcmp((l),("freezer-state")) == 0)) {

3618

FreezerState s;

3619

3620

s = freezer_state_from_string(v);

3621

if (s < 0)

3622

log_unit_debug(u, "Failed to deserialize freezer-state '%s', ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3622, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to deserialize freezer-state '%s', ignoring.", v) :
log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7)))
, 0, "../src/core/unit.c", 3622, __func__, "Failed to deserialize freezer-state '%s', ignoring."
, v); });

3623

else

3624

u->freezer_state = s;

3625

3626

continue;

3627

}

3628

3629

/* Check if this is an IP accounting metric serialization field */

3630

for (m = 0; m < _CGROUP_IP_ACCOUNTING_METRIC_MAX; m++)

3631

if (streq(l, ip_accounting_metric_field[m])(strcmp((l),(ip_accounting_metric_field[m])) == 0))

3632

break;

3633

if (m < _CGROUP_IP_ACCOUNTING_METRIC_MAX) {

3634

uint64_t c;

3635

3636

r = safe_atou64(v, &c);

3637

if (r < 0)

3638

log_unit_debug(u, "Failed to parse IP accounting value %s, ignoring.", v)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 3638, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to parse IP accounting value %s, ignoring.", v) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), 0, "../src/core/unit.c"
, 3638, __func__, "Failed to parse IP accounting value %s, ignoring."
, v); });

3639

else

3640

u->ip_accounting_extra[m] = c;

3641

continue;

3642

}

3643

3644

if (unit_can_serialize(u)) {

3645

r = exec_runtime_deserialize_compat(u, l, v, fds);

3646

if (r < 0) {

3647

log_unit_warning(u, "Failed to deserialize runtime parameter '%s', ignoring.", l)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 3647, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to deserialize runtime parameter '%s', ignoring.", l
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((4
))), 0, "../src/core/unit.c", 3647, __func__, "Failed to deserialize runtime parameter '%s', ignoring."
, l); });

3648

continue;

3649

}

3650

3651

/* Returns positive if key was handled by the call */

3652

if (r > 0)

3653

continue;

3654

3655

r = UNIT_VTABLE(u)unit_vtable[(u)->type]->deserialize_item(u, l, v, fds);

3656

if (r < 0)

3657

log_unit_warning(u, "Failed to deserialize unit parameter '%s', ignoring.", l)({ const Unit *_u = (u); _u ? log_object_internal(4, 0, "../src/core/unit.c"
, 3657, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to deserialize unit parameter '%s', ignoring.", l) :
log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((4)))
, 0, "../src/core/unit.c", 3657, __func__, "Failed to deserialize unit parameter '%s', ignoring."
, l); });

3658

}

3659

}

3660

3661

/* Versions before 228 did not carry a state change timestamp. In this case, take the current time. This is

3662

* useful, so that timeouts based on this timestamp don't trigger too early, and is in-line with the logic from

3663

* before 228 where the base for timeouts was not persistent across reboots. */

3664

3665

if (!dual_timestamp_is_set(&u->state_change_timestamp))

3666

dual_timestamp_get(&u->state_change_timestamp);

3667

3668

/* Let's make sure that everything that is deserialized also gets any potential new cgroup settings applied

3669

* after we are done. For that we invalidate anything already realized, so that we can realize it again. */

3670

unit_invalidate_cgroup(u, _CGROUP_MASK_ALL);

3671

unit_invalidate_cgroup_bpf(u);

3672

3673

return 0;

3674

}

3675

3676

int unit_deserialize_skip(FILE *f) {

3677

int r;

3678

assert(f)do { if ((__builtin_expect(!!(!(f)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("f"), "../src/core/unit.c", 3678, __PRETTY_FUNCTION__
); } while (0);

3679

3680

/* Skip serialized data for this unit. We don't know what it is. */

3681

3682

for (;;) {

3683

_cleanup_free___attribute__((cleanup(freep))) char *line = NULL((void*)0);

3684

char *l;

3685

3686

r = read_line(f, LONG_LINE_MAX(1U*1024U*1024U), &line);

3687

if (r < 0)

3688

return log_error_errno(r, "Failed to read serialization line: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/core/unit.c", 3688, __func__, "Failed to read serialization line: %m"
) : -abs(_e); });

3689

if (r == 0)

3690

return 0;

3691

3692

l = strstrip(line);

3693

3694

/* End marker */

3695

if (isempty(l))

3696

return 1;

3697

}

3698

}

3699

3700

int unit_add_node_dependency(Unit *u, const char *what, bool_Bool wants, UnitDependency dep, UnitDependencyMask mask) {

3701

Unit *device;

3702

_cleanup_free___attribute__((cleanup(freep))) char *e = NULL((void*)0);

3703

int r;

3704

3705

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3705, __PRETTY_FUNCTION__
); } while (0);

3706

3707

/* Adds in links to the device node that this unit is based on */

3708

if (isempty(what))

3709

return 0;

3710

3711

if (!is_device_path(what))

3712

return 0;

3713

3714

/* When device units aren't supported (such as in a

3715

* container), don't create dependencies on them. */

3716

if (!unit_type_supported(UNIT_DEVICE))

3717

return 0;

3718

3719

r = unit_name_from_path(what, ".device", &e);

3720

if (r < 0)

3721

return r;

3722

3723

r = manager_load_unit(u->manager, e, NULL((void*)0), NULL((void*)0), &device);

3724

if (r < 0)

3725

return r;

3726

3727

if (dep == UNIT_REQUIRES && device_shall_be_bound_by(device, u))

3728

dep = UNIT_BINDS_TO;

3729

3730

r = unit_add_two_dependencies(u, UNIT_AFTER,

3731

MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM) ? dep : UNIT_WANTS,

3732

device, true1, mask);

3733

if (r < 0)

3734

return r;

3735

3736

if (wants) {

3737

r = unit_add_dependency(device, UNIT_WANTS, u, false0, mask);

3738

if (r < 0)

3739

return r;

3740

}

3741

3742

return 0;

3743

}

3744

3745

int unit_coldplug(Unit *u) {

3746

int r = 0, q;

3747

char **i;

3748

Job *uj;

3749

3750

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3750, __PRETTY_FUNCTION__
); } while (0);

3751

3752

/* Make sure we don't enter a loop, when coldplugging recursively. */

3753

if (u->coldplugged)

3754

return 0;

3755

3756

u->coldplugged = true1;

3757

3758

STRV_FOREACH(i, u->deserialized_refs)for ((i) = (u->deserialized_refs); (i) && *(i); (i
)++) {

3759

q = bus_unit_track_add_name(u, *i);

3760

if (q < 0 && r >= 0)

3761

r = q;

3762

}

3763

u->deserialized_refs = strv_free(u->deserialized_refs);

3764

3765

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->coldplug) {

3766

q = UNIT_VTABLE(u)unit_vtable[(u)->type]->coldplug(u);

3767

if (q < 0 && r >= 0)

3768

r = q;

3769

}

3770

3771

uj = u->job ?: u->nop_job;

3772

if (uj) {

3773

q = job_coldplug(uj);

3774

if (q < 0 && r >= 0)

3775

r = q;

3776

}

3777

3778

return r;

3779

}

3780

3781

void unit_catchup(Unit *u) {

3782

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3782, __PRETTY_FUNCTION__
); } while (0);

3783

3784

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->catchup)

3785

UNIT_VTABLE(u)unit_vtable[(u)->type]->catchup(u);

3786

}

3787

3788

static bool_Bool fragment_mtime_newer(const char *path, usec_t mtime, bool_Bool path_masked) {

3789

struct stat st;

3790

3791

if (!path)

3792

return false0;

3793

3794

/* If the source is some virtual kernel file system, then we assume we watch it anyway, and hence pretend we

3795

* are never out-of-date. */

3796

if (PATH_STARTSWITH_SET(path, "/proc", "/sys")({ char **s; _Bool _found = 0; for ((s) = (((char**) ((const char
*[]) { "/proc", "/sys", ((void*)0) }))); (s) && *(s);
(s)++) if (path_startswith(path, *s)) { _found = 1; break; }
_found; }))

3797

return false0;

3798

3799

if (stat(path, &st) < 0)

3800

/* What, cannot access this anymore? */

3801

return true1;

3802

3803

if (path_masked)

3804

/* For masked files check if they are still so */

3805

return !null_or_empty(&st);

3806

else

3807

/* For non-empty files check the mtime */

3808

return timespec_load(&st.st_mtim) > mtime;

3809

3810

return false0;

3811

}

3812

3813

bool_Bool unit_need_daemon_reload(Unit *u) {

3814

_cleanup_strv_free___attribute__((cleanup(strv_freep))) char **t = NULL((void*)0);

3815

char **path;

3816

3817

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3817, __PRETTY_FUNCTION__
); } while (0);

3818

3819

/* For unit files, we allow masking… */

3820

if (fragment_mtime_newer(u->fragment_path, u->fragment_mtime,

3821

u->load_state == UNIT_MASKED))

3822

return true1;

3823

3824

/* Source paths should not be masked… */

3825

if (fragment_mtime_newer(u->source_path, u->source_mtime, false0))

3826

return true1;

3827

3828

if (u->load_state == UNIT_LOADED)

3829

(void) unit_find_dropin_paths(u, &t);

3830

if (!strv_equal(u->dropin_paths, t))

3831

return true1;

3832

3833

/* … any drop-ins that are masked are simply omitted from the list. */

3834

STRV_FOREACH(path, u->dropin_paths)for ((path) = (u->dropin_paths); (path) && *(path)
; (path)++)

3835

if (fragment_mtime_newer(*path, u->dropin_mtime, false0))

3836

return true1;

3837

3838

return false0;

3839

}

3840

3841

void unit_reset_failed(Unit *u) {

3842

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3842, __PRETTY_FUNCTION__
); } while (0);

3843

3844

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->reset_failed)

3845

UNIT_VTABLE(u)unit_vtable[(u)->type]->reset_failed(u);

3846

3847

RATELIMIT_RESET(u->start_limit)do { RateLimit *_r = &(u->start_limit); _r->num = 0
; _r->begin = 0; } while (0);

3848

u->start_limit_hit = false0;

3849

}

3850

3851

Unit *unit_following(Unit *u) {

3852

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3852, __PRETTY_FUNCTION__
); } while (0);

3853

3854

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->following)

3855

return UNIT_VTABLE(u)unit_vtable[(u)->type]->following(u);

3856

3857

return NULL((void*)0);

3858

}

3859

3860

bool_Bool unit_stop_pending(Unit *u) {

3861

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3861, __PRETTY_FUNCTION__
); } while (0);

3862

3863

/* This call does check the current state of the unit. It's

3864

* hence useful to be called from state change calls of the

3865

* unit itself, where the state isn't updated yet. This is

3866

* different from unit_inactive_or_pending() which checks both

3867

* the current state and for a queued job. */

3868

3869

return u->job && u->job->type == JOB_STOP;

3870

}

3871

3872

bool_Bool unit_inactive_or_pending(Unit *u) {

3873

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3873, __PRETTY_FUNCTION__
); } while (0);

3874

3875

/* Returns true if the unit is inactive or going down */

3876

3877

if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))

3878

return true1;

3879

3880

if (unit_stop_pending(u))

3881

return true1;

3882

3883

return false0;

3884

}

3885

3886

bool_Bool unit_active_or_pending(Unit *u) {

3887

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3887, __PRETTY_FUNCTION__
); } while (0);

3888

3889

/* Returns true if the unit is active or going up */

3890

3891

if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))

3892

return true1;

3893

3894

if (u->job &&

3895

IN_SET(u->job->type, JOB_START, JOB_RELOAD_OR_START, JOB_RESTART)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){JOB_START, JOB_RELOAD_OR_START, JOB_RESTART
})/sizeof(int)]; switch(u->job->type) { case JOB_START:
case JOB_RELOAD_OR_START: case JOB_RESTART: _found = 1; break
; default: break; } _found; }))

3896

return true1;

3897

3898

return false0;

3899

}

3900

3901

bool_Bool unit_will_restart(Unit *u) {

3902

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3902, __PRETTY_FUNCTION__
); } while (0);

3903

3904

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->will_restart)

3905

return false0;

3906

3907

return UNIT_VTABLE(u)unit_vtable[(u)->type]->will_restart(u);

3908

}

3909

3910

int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {

3911

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 3911, __PRETTY_FUNCTION__
); } while (0);

3912

assert(w >= 0 && w < _KILL_WHO_MAX)do { if ((__builtin_expect(!!(!(w >= 0 && w < _KILL_WHO_MAX
)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("w >= 0 && w < _KILL_WHO_MAX"
), "../src/core/unit.c", 3912, __PRETTY_FUNCTION__); } while (
0);

3913

assert(SIGNAL_VALID(signo))do { if ((__builtin_expect(!!(!(SIGNAL_VALID(signo))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("SIGNAL_VALID(signo)"), "../src/core/unit.c"
, 3913, __PRETTY_FUNCTION__); } while (0);

3914

3915

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->kill)

3916

return -EOPNOTSUPP95;

3917

3918

return UNIT_VTABLE(u)unit_vtable[(u)->type]->kill(u, w, signo, error);

3919

}

3920

3921

static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {

3922

_cleanup_set_free___attribute__((cleanup(set_freep))) Set *pid_set = NULL((void*)0);

3923

int r;

3924

3925

pid_set = set_new(NULL)internal_set_new(((void*)0) );

3926

if (!pid_set)

3927

return NULL((void*)0);

3928

3929

/* Exclude the main/control pids from being killed via the cgroup */

3930

if (main_pid > 0) {

3931

r = set_put(pid_set, PID_TO_PTR(main_pid));

3932

if (r < 0)

3933

return NULL((void*)0);

3934

}

3935

3936

if (control_pid > 0) {

3937

r = set_put(pid_set, PID_TO_PTR(control_pid));

3938

if (r < 0)

3939

return NULL((void*)0);

3940

}

3941

3942

return TAKE_PTR(pid_set)({ typeof(pid_set) _ptr_ = (pid_set); (pid_set) = ((void*)0);
_ptr_; });

3943

}

3944

3945

int unit_kill_common(

3946

Unit *u,

3947

KillWho who,

3948

int signo,

3949

pid_t main_pid,

3950

pid_t control_pid,

3951

sd_bus_error *error) {

3952

3953

int r = 0;

3954

bool_Bool killed = false0;

3955

3956

if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_MAIN, KILL_MAIN_FAIL})/sizeof(int)]
; switch(who) { case KILL_MAIN: case KILL_MAIN_FAIL: _found =
1; break; default: break; } _found; })) {

3957

if (main_pid < 0)

3958

return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS"org.freedesktop.systemd1.NoSuchProcess", "%s units have no main processes", unit_type_to_string(u->type));

3959

else if (main_pid == 0)

3960

return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS"org.freedesktop.systemd1.NoSuchProcess", "No main process to kill");

3961

}

3962

3963

if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_CONTROL, KILL_CONTROL_FAIL})/sizeof
(int)]; switch(who) { case KILL_CONTROL: case KILL_CONTROL_FAIL
: _found = 1; break; default: break; } _found; })) {

3964

if (control_pid < 0)

3965

return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS"org.freedesktop.systemd1.NoSuchProcess", "%s units have no control processes", unit_type_to_string(u->type));

3966

else if (control_pid == 0)

3967

return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS"org.freedesktop.systemd1.NoSuchProcess", "No control process to kill");

3968

}

3969

3970

if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL, KILL_ALL_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL
, KILL_ALL_FAIL})/sizeof(int)]; switch(who) { case KILL_CONTROL
: case KILL_CONTROL_FAIL: case KILL_ALL: case KILL_ALL_FAIL: _found
= 1; break; default: break; } _found; }))

3971

if (control_pid > 0) {

3972

if (kill(control_pid, signo) < 0)

3973

r = -errno(*__errno_location ());

3974

else

3975

killed = true1;

3976

}

3977

3978

if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL
})/sizeof(int)]; switch(who) { case KILL_MAIN: case KILL_MAIN_FAIL
: case KILL_ALL: case KILL_ALL_FAIL: _found = 1; break; default
: break; } _found; }))

3979

if (main_pid > 0) {

3980

if (kill(main_pid, signo) < 0)

3981

r = -errno(*__errno_location ());

3982

else

3983

killed = true1;

3984

}

3985

3986

if (IN_SET(who, KILL_ALL, KILL_ALL_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_ALL, KILL_ALL_FAIL})/sizeof(int)]; switch
(who) { case KILL_ALL: case KILL_ALL_FAIL: _found = 1; break;
default: break; } _found; }) && u->cgroup_path) {

3987

_cleanup_set_free___attribute__((cleanup(set_freep))) Set *pid_set = NULL((void*)0);

3988

int q;

3989

3990

/* Exclude the main/control pids from being killed via the cgroup */

3991

pid_set = unit_pid_set(main_pid, control_pid);

3992

if (!pid_set)

3993

return -ENOMEM12;

3994

3995

q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path, signo, 0, pid_set, NULL((void*)0), NULL((void*)0));

3996

if (q < 0 && !IN_SET(q, -EAGAIN, -ESRCH, -ENOENT)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-11, -3, -2})/sizeof(int)]; switch(q) { case
-11: case -3: case -2: _found = 1; break; default: break; } _found
; }))

3997

r = q;

3998

else

3999

killed = true1;

4000

}

4001

4002

if (r == 0 && !killed && IN_SET(who, KILL_ALL_FAIL, KILL_CONTROL_FAIL)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_ALL_FAIL, KILL_CONTROL_FAIL})/sizeof
(int)]; switch(who) { case KILL_ALL_FAIL: case KILL_CONTROL_FAIL
: _found = 1; break; default: break; } _found; }))

4003

return -ESRCH3;

4004

4005

return r;

4006

}

4007

4008

int unit_following_set(Unit *u, Set **s) {

4009

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4009, __PRETTY_FUNCTION__
); } while (0);

4010

assert(s)do { if ((__builtin_expect(!!(!(s)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("s"), "../src/core/unit.c", 4010, __PRETTY_FUNCTION__
); } while (0);

4011

4012

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->following_set)

4013

return UNIT_VTABLE(u)unit_vtable[(u)->type]->following_set(u, s);

4014

4015

*s = NULL((void*)0);

4016

return 0;

4017

}

4018

4019

UnitFileState unit_get_unit_file_state(Unit *u) {

4020

int r;

4021

4022

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4022, __PRETTY_FUNCTION__
); } while (0);

4023

4024

if (u->unit_file_state < 0 && u->fragment_path) {

4025

r = unit_file_get_state(

4026

u->manager->unit_file_scope,

4027

NULL((void*)0),

4028

u->id,

4029

&u->unit_file_state);

4030

if (r < 0)

4031

u->unit_file_state = UNIT_FILE_BAD;

4032

}

4033

4034

return u->unit_file_state;

4035

}

4036

4037

int unit_get_unit_file_preset(Unit *u) {

4038

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4038, __PRETTY_FUNCTION__
); } while (0);

4039

4040

if (u->unit_file_preset < 0 && u->fragment_path)

4041

u->unit_file_preset = unit_file_query_preset(

4042

u->manager->unit_file_scope,

4043

NULL((void*)0),

4044

basename(u->fragment_path));

4045

4046

return u->unit_file_preset;

4047

}

4048

4049

Unit* unit_ref_set(UnitRef *ref, Unit *source, Unit *target) {

4050

assert(ref)do { if ((__builtin_expect(!!(!(ref)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ref"), "../src/core/unit.c", 4050, __PRETTY_FUNCTION__
); } while (0);

4051

assert(source)do { if ((__builtin_expect(!!(!(source)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("source"), "../src/core/unit.c", 4051, __PRETTY_FUNCTION__
); } while (0);

4052

assert(target)do { if ((__builtin_expect(!!(!(target)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("target"), "../src/core/unit.c", 4052, __PRETTY_FUNCTION__
); } while (0);

4053

4054

if (ref->target)

4055

unit_ref_unset(ref);

4056

4057

ref->source = source;

4058

ref->target = target;

4059

LIST_PREPEND(refs_by_target, target->refs_by_target, ref)do { typeof(*(target->refs_by_target)) **_head = &(target
->refs_by_target), *_item = (ref); do { if ((__builtin_expect
(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("_item"), "../src/core/unit.c", 4059, __PRETTY_FUNCTION__);
} while (0); if ((_item->refs_by_target_next = *_head)) _item
->refs_by_target_next->refs_by_target_prev = _item; _item
->refs_by_target_prev = ((void*)0); *_head = _item; } while
(0);

4060

return target;

4061

}

4062

4063

void unit_ref_unset(UnitRef *ref) {

4064

assert(ref)do { if ((__builtin_expect(!!(!(ref)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ref"), "../src/core/unit.c", 4064, __PRETTY_FUNCTION__
); } while (0);

4065

4066

if (!ref->target)

4067

return;

4068

4069

/* We are about to drop a reference to the unit, make sure the garbage collection has a look at it as it might

4070

* be unreferenced now. */

4071

unit_add_to_gc_queue(ref->target);

4072

4073

LIST_REMOVE(refs_by_target, ref->target->refs_by_target, ref)do { typeof(*(ref->target->refs_by_target)) **_head = &
(ref->target->refs_by_target), *_item = (ref); do { if (
(__builtin_expect(!!(!(_item)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("_item"), "../src/core/unit.c", 4073, __PRETTY_FUNCTION__)
; } while (0); if (_item->refs_by_target_next) _item->refs_by_target_next
->refs_by_target_prev = _item->refs_by_target_prev; if (
_item->refs_by_target_prev) _item->refs_by_target_prev->
refs_by_target_next = _item->refs_by_target_next; else { do
{ if ((__builtin_expect(!!(!(*_head == _item)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("*_head == _item"), "../src/core/unit.c"
, 4073, __PRETTY_FUNCTION__); } while (0); *_head = _item->
refs_by_target_next; } _item->refs_by_target_next = _item->
refs_by_target_prev = ((void*)0); } while (0);

4074

ref->source = ref->target = NULL((void*)0);

4075

}

4076

4077

static int user_from_unit_name(Unit *u, char **ret) {

4078

4079

static const uint8_t hash_key[] = {

4080

0x58, 0x1a, 0xaf, 0xe6, 0x28, 0x58, 0x4e, 0x96,

4081

0xb4, 0x4e, 0xf5, 0x3b, 0x8c, 0x92, 0x07, 0xec

4082

};

4083

4084

_cleanup_free___attribute__((cleanup(freep))) char *n = NULL((void*)0);

4085

int r;

4086

4087

r = unit_name_to_prefix(u->id, &n);

4088

if (r < 0)

4089

return r;

4090

4091

if (valid_user_group_name(n, 0)) {

4092

*ret = TAKE_PTR(n)({ typeof(n) _ptr_ = (n); (n) = ((void*)0); _ptr_; });

4093

return 0;

4094

}

4095

4096

/* If we can't use the unit name as a user name, then let's hash it and use that */

4097

if (asprintf(ret, "_du%016" PRIx64"l" "x", siphash24(n, strlen(n), hash_key)) < 0)

4098

return -ENOMEM12;

4099

4100

return 0;

4101

}

4102

4103

int unit_patch_contexts(Unit *u) {

4104

CGroupContext *cc;

4105

ExecContext *ec;

4106

unsigned i;

4107

int r;

4108

4109

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4109, __PRETTY_FUNCTION__
); } while (0);

4110

4111

/* Patch in the manager defaults into the exec and cgroup

4112

* contexts, _after_ the rest of the settings have been

4113

* initialized */

4114

4115

ec = unit_get_exec_context(u);

4116

if (ec) {

4117

/* This only copies in the ones that need memory */

4118

for (i = 0; i < _RLIMIT_MAX(__RLIMIT_RTTIME+1 > __RLIMIT_NLIMITS ? __RLIMIT_RTTIME+1 :
__RLIMIT_NLIMITS); i++)

4119

if (u->manager->rlimit[i] && !ec->rlimit[i]) {

4120

ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1)((struct rlimit*) memdup_multiply(u->manager->rlimit[i]
, sizeof(struct rlimit), (1)));

4121

if (!ec->rlimit[i])

4122

return -ENOMEM12;

4123

}

4124

4125

if (MANAGER_IS_USER(u->manager)((u->manager)->unit_file_scope != UNIT_FILE_SYSTEM) &&

4126

!ec->working_directory) {

4127

4128

r = get_home_dir(&ec->working_directory);

4129

if (r < 0)

4130

return r;

4131

4132

/* Allow user services to run, even if the

4133

* home directory is missing */

4134

ec->working_directory_missing_ok = true1;

4135

}

4136

4137

if (ec->private_devices)

4138

ec->capability_bounding_set &= ~((UINT64_C(1)1UL << CAP_MKNOD27) | (UINT64_C(1)1UL << CAP_SYS_RAWIO17));

4139

4140

if (ec->protect_kernel_modules)

4141

ec->capability_bounding_set &= ~(UINT64_C(1)1UL << CAP_SYS_MODULE16);

4142

4143

if (ec->dynamic_user) {

4144

if (!ec->user) {

4145

r = user_from_unit_name(u, &ec->user);

4146

if (r < 0)

4147

return r;

4148

}

4149

4150

if (!ec->group) {

4151

ec->group = strdup(ec->user);

4152

if (!ec->group)

4153

return -ENOMEM12;

4154

}

4155

4156

/* If the dynamic user option is on, let's make sure that the unit can't leave its

4157

* UID/GID around in the file system or on IPC objects. Hence enforce a strict

4158

* sandbox. */

4159

4160

ec->private_tmp = true1;

4161

ec->remove_ipc = true1;

4162

ec->protect_system = PROTECT_SYSTEM_STRICT;

4163

if (ec->protect_home == PROTECT_HOME_NO)

4164

ec->protect_home = PROTECT_HOME_READ_ONLY;

4165

4166

/* Make sure this service can neither benefit from SUID/SGID binaries nor create

4167

* them. */

4168

ec->no_new_privileges = true1;

4169

ec->restrict_suid_sgid = true1;

4170

}

4171

}

4172

4173

cc = unit_get_cgroup_context(u);

4174

if (cc) {

4175

4176

if (ec &&

4177

ec->private_devices &&

4178

cc->device_policy == CGROUP_AUTO)

4179

cc->device_policy = CGROUP_CLOSED;

4180

}

4181

4182

return 0;

4183

}

4184

4185

ExecContext *unit_get_exec_context(Unit *u) {

4186

size_t offset;

4187

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4187, __PRETTY_FUNCTION__
); } while (0);

4188

4189

if (u->type < 0)

4190

return NULL((void*)0);

4191

4192

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->exec_context_offset;

4193

if (offset <= 0)

4194

return NULL((void*)0);

4195

4196

return (ExecContext*) ((uint8_t*) u + offset);

4197

}

4198

4199

KillContext *unit_get_kill_context(Unit *u) {

4200

size_t offset;

4201

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4201, __PRETTY_FUNCTION__
); } while (0);

4202

4203

if (u->type < 0)

4204

return NULL((void*)0);

4205

4206

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->kill_context_offset;

4207

if (offset <= 0)

4208

return NULL((void*)0);

4209

4210

return (KillContext*) ((uint8_t*) u + offset);

4211

}

4212

4213

CGroupContext *unit_get_cgroup_context(Unit *u) {

4214

size_t offset;

4215

4216

if (u->type < 0)

4217

return NULL((void*)0);

4218

4219

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->cgroup_context_offset;

4220

if (offset <= 0)

4221

return NULL((void*)0);

4222

4223

return (CGroupContext*) ((uint8_t*) u + offset);

4224

}

4225

4226

ExecRuntime *unit_get_exec_runtime(Unit *u) {

4227

size_t offset;

4228

4229

if (u->type < 0)

4230

return NULL((void*)0);

4231

4232

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->exec_runtime_offset;

4233

if (offset <= 0)

4234

return NULL((void*)0);

4235

4236

return *(ExecRuntime**) ((uint8_t*) u + offset);

4237

}

4238

4239

static const char* unit_drop_in_dir(Unit *u, UnitWriteFlags flags) {

4240

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4240, __PRETTY_FUNCTION__
); } while (0);

4241

4242

if (UNIT_WRITE_FLAGS_NOOP(flags)(((flags) & (UNIT_RUNTIME|UNIT_PERSISTENT)) == 0))

4243

return NULL((void*)0);

4244

4245

if (u->transient) /* Redirect drop-ins for transient units always into the transient directory. */

4246

return u->manager->lookup_paths.transient;

4247

4248

if (flags & UNIT_PERSISTENT)

4249

return u->manager->lookup_paths.persistent_control;

4250

4251

if (flags & UNIT_RUNTIME)

4252

return u->manager->lookup_paths.runtime_control;

4253

4254

return NULL((void*)0);

4255

}

4256

4257

char* unit_escape_setting(const char *s, UnitWriteFlags flags, char **buf) {

4258

char *ret = NULL((void*)0);

4259

4260

if (!s)

4261

return NULL((void*)0);

4262

4263

/* Escapes the input string as requested. Returns the escaped string. If 'buf' is specified then the allocated

4264

* return buffer pointer is also written to *buf, except if no escaping was necessary, in which case *buf is

4265

* set to NULL, and the input pointer is returned as-is. This means the return value always contains a properly

4266

* escaped version, but *buf when passed only contains a pointer if an allocation was necessary. If *buf is

4267

* not specified, then the return value always needs to be freed. Callers can use this to optimize memory

4268

* allocations. */

4269

4270

if (flags & UNIT_ESCAPE_SPECIFIERS) {

4271

ret = specifier_escape(s);

4272

if (!ret)

4273

return NULL((void*)0);

4274

4275

s = ret;

4276

}

4277

4278

if (flags & UNIT_ESCAPE_C) {

4279

char *a;

4280

4281

a = cescape(s);

4282

free(ret);

4283

if (!a)

4284

return NULL((void*)0);

4285

4286

ret = a;

4287

}

4288

4289

if (buf) {

4290

*buf = ret;

4291

return ret ?: (char*) s;

4292

}

4293

4294

return ret ?: strdup(s);

4295

}

4296

4297

char* unit_concat_strv(char **l, UnitWriteFlags flags) {

4298

_cleanup_free___attribute__((cleanup(freep))) char *result = NULL((void*)0);

4299

size_t n = 0, allocated = 0;

4300

char **i;

4301

4302

/* Takes a list of strings, escapes them, and concatenates them. This may be used to format command lines in a

4303

* way suitable for ExecStart= stanzas */

4304

4305

STRV_FOREACH(i, l)for ((i) = (l); (i) && *(i); (i)++) {

4306

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

4307

const char *p;

4308

size_t a;

4309

char *q;

4310

4311

p = unit_escape_setting(*i, flags, &buf);

4312

if (!p)

4313

return NULL((void*)0);

4314

4315

a = (n > 0) + 1 + strlen(p) + 1; /* separating space + " + entry + " */

4316

if (!GREEDY_REALLOC(result, allocated, n + a + 1)greedy_realloc((void**) &(result), &(allocated), (n +
a + 1), sizeof((result)[0])))

4317

return NULL((void*)0);

4318

4319

q = result + n;

4320

if (n > 0)

4321

*(q++) = ' ';

4322

4323

*(q++) = '"';

4324

q = stpcpy(q, p);

4325

*(q++) = '"';

4326

4327

n += a;

4328

}

4329

4330

if (!GREEDY_REALLOC(result, allocated, n + 1)greedy_realloc((void**) &(result), &(allocated), (n +
1), sizeof((result)[0])))

4331

return NULL((void*)0);

4332

4333

result[n] = 0;

4334

4335

return TAKE_PTR(result)({ typeof(result) _ptr_ = (result); (result) = ((void*)0); _ptr_
; });

4336

}

4337

4338

int unit_write_setting(Unit *u, UnitWriteFlags flags, const char *name, const char *data) {

4339

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0), *q = NULL((void*)0), *escaped = NULL((void*)0);

4340

const char *dir, *wrapped;

4341

int r;

4342

4343

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4343, __PRETTY_FUNCTION__
); } while (0);

4344

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 4344, __PRETTY_FUNCTION__
); } while (0);

4345

assert(data)do { if ((__builtin_expect(!!(!(data)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("data"), "../src/core/unit.c", 4345, __PRETTY_FUNCTION__
); } while (0);

4346

4347

if (UNIT_WRITE_FLAGS_NOOP(flags)(((flags) & (UNIT_RUNTIME|UNIT_PERSISTENT)) == 0))

4348

return 0;

4349

4350

data = unit_escape_setting(data, flags, &escaped);

4351

if (!data)

4352

return -ENOMEM12;

4353

4354

/* Prefix the section header. If we are writing this out as transient file, then let's suppress this if the

4355

* previous section header is the same */

4356

4357

if (flags & UNIT_PRIVATE) {

4358

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->private_section)

4359

return -EINVAL22;

4360

4361

if (!u->transient_file || u->last_section_private < 0)

4362

data = strjoina("[", UNIT_VTABLE(u)->private_section, "]\n", data)({ const char *_appendees_[] = { "[", unit_vtable[(u)->type
]->private_section, "]\n", data }; char *_d_, *_p_; size_t
_len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__ (
__builtin_choose_expr( !__builtin_types_compatible_p(typeof(_appendees_
), typeof(&*(_appendees_))), sizeof(_appendees_)/sizeof((
_appendees_)[0]), ((void)0))) && _appendees_[_i_]; _i_
++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

4363

else if (u->last_section_private == 0)

4364

data = strjoina("\n[", UNIT_VTABLE(u)->private_section, "]\n", data)({ const char *_appendees_[] = { "\n[", unit_vtable[(u)->type
]->private_section, "]\n", data }; char *_d_, *_p_; size_t
_len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__ (
__builtin_choose_expr( !__builtin_types_compatible_p(typeof(_appendees_
), typeof(&*(_appendees_))), sizeof(_appendees_)/sizeof((
_appendees_)[0]), ((void)0))) && _appendees_[_i_]; _i_
++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

4365

} else {

4366

if (!u->transient_file || u->last_section_private < 0)

4367

data = strjoina("[Unit]\n", data)({ const char *_appendees_[] = { "[Unit]\n", data }; char *_d_
, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

4368

else if (u->last_section_private > 0)

4369

data = strjoina("\n[Unit]\n", data)({ const char *_appendees_[] = { "\n[Unit]\n", data }; char *
_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ <
__extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

4370

}

4371

4372

if (u->transient_file) {

4373

/* When this is a transient unit file in creation, then let's not create a new drop-in but instead

4374

* write to the transient unit file. */

4375

fputs(data, u->transient_file);

4376

4377

if (!endswith(data, "\n"))

4378

fputc('\n', u->transient_file);

4379

4380

/* Remember which section we wrote this entry to */

4381

u->last_section_private = !!(flags & UNIT_PRIVATE);

4382

return 0;

4383

}

4384

4385

dir = unit_drop_in_dir(u, flags);

4386

if (!dir)

4387

return -EINVAL22;

4388

4389

wrapped = strjoina("# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"({ const char *_appendees_[] = { "# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"
"# or an equivalent operation. Do not edit.\n", data, "\n" }
; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0
; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

4390

"# or an equivalent operation. Do not edit.\n",({ const char *_appendees_[] = { "# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"
"# or an equivalent operation. Do not edit.\n", data, "\n" }
; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0
; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

4391

data,({ const char *_appendees_[] = { "# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"
"# or an equivalent operation. Do not edit.\n", data, "\n" }
; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0
; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; })

4392

"\n")({ const char *_appendees_[] = { "# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"
"# or an equivalent operation. Do not edit.\n", data, "\n" }
; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0
; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

4393

4394

r = drop_in_file(dir, u->id, 50, name, &p, &q);

4395

if (r < 0)

4396

return r;

4397

4398

(void) mkdir_p_label(p, 0755);

4399

r = write_string_file_atomic_label(q, wrapped);

4400

if (r < 0)

4401

return r;

4402

4403

r = strv_push(&u->dropin_paths, q);

4404

if (r < 0)

4405

return r;

4406

q = NULL((void*)0);

4407

4408

strv_uniq(u->dropin_paths);

4409

4410

u->dropin_mtime = now(CLOCK_REALTIME0);

4411

4412

return 0;

4413

}

4414

4415

int unit_write_settingf(Unit *u, UnitWriteFlags flags, const char *name, const char *format, ...) {

4416

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

4417

va_list ap;

4418

int r;

4419

4420

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4420, __PRETTY_FUNCTION__
); } while (0);

4421

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/core/unit.c", 4421, __PRETTY_FUNCTION__
); } while (0);

4422

assert(format)do { if ((__builtin_expect(!!(!(format)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("format"), "../src/core/unit.c", 4422, __PRETTY_FUNCTION__
); } while (0);

4423

4424

if (UNIT_WRITE_FLAGS_NOOP(flags)(((flags) & (UNIT_RUNTIME|UNIT_PERSISTENT)) == 0))

4425

return 0;

4426

4427

va_start(ap, format)__builtin_va_start(ap, format);

4428

r = vasprintf(&p, format, ap);

4429

va_end(ap)__builtin_va_end(ap);

4430

4431

if (r < 0)

4432

return -ENOMEM12;

4433

4434

return unit_write_setting(u, flags, name, p);

4435

}

4436

4437

int unit_make_transient(Unit *u) {

4438

_cleanup_free___attribute__((cleanup(freep))) char *path = NULL((void*)0);

4439

FILE *f;

4440

4441

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4441, __PRETTY_FUNCTION__
); } while (0);

4442

4443

if (!UNIT_VTABLE(u)unit_vtable[(u)->type]->can_transient)

4444

return -EOPNOTSUPP95;

4445

4446

(void) mkdir_p_label(u->manager->lookup_paths.transient, 0755);

4447

4448

path = strjoin(u->manager->lookup_paths.transient, "/", u->id)strjoin_real((u->manager->lookup_paths.transient), "/",
u->id, ((void*)0));

4449

if (!path)

4450

return -ENOMEM12;

4451

4452

/* Let's open the file we'll write the transient settings into. This file is kept open as long as we are

4453

* creating the transient, and is closed in unit_load(), as soon as we start loading the file. */

4454

4455

RUN_WITH_UMASK(0022)for (__attribute__((cleanup(_reset_umask_))) struct _umask_struct_
_saved_umask_ = { umask(0022), 0 }; !_saved_umask_.quit ; _saved_umask_
.quit = 1) {

4456

f = fopen(path, "we");

4457

if (!f)

4458

return -errno(*__errno_location ());

4459

}

4460

4461

safe_fclose(u->transient_file);

4462

u->transient_file = f;

4463

4464

free_and_replace(u->fragment_path, path)({ free(u->fragment_path); (u->fragment_path) = (path);
(path) = ((void*)0); 0; });

4465

4466

u->source_path = mfree(u->source_path);

4467

u->dropin_paths = strv_free(u->dropin_paths);

4468

u->fragment_mtime = u->source_mtime = u->dropin_mtime = 0;

4469

4470

u->load_state = UNIT_STUB;

4471

u->load_error = 0;

4472

u->transient = true1;

4473

4474

unit_add_to_dbus_queue(u);

4475

unit_add_to_gc_queue(u);

4476

4477

fputs("# This is a transient unit file, created programmatically via the systemd API. Do not edit.\n",

4478

u->transient_file);

4479

4480

return 0;

4481

}

4482

4483

static void log_kill(pid_t pid, int sig, void *userdata) {

4484

_cleanup_free___attribute__((cleanup(freep))) char *comm = NULL((void*)0);

4485

4486

(void) get_process_comm(pid, &comm);

4487

4488

/* Don't log about processes marked with brackets, under the assumption that these are temporary processes

4489

only, like for example systemd's own PAM stub process. */

4490

if (comm && comm[0] == '(')

4491

return;

4492

4493

log_unit_notice(userdata,({ const Unit *_u = (userdata); _u ? log_object_internal(5, 0
, "../src/core/unit.c", 4497, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 4497, __func__, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)); })

4494

"Killing process " PID_FMT " (%s) with signal SIG%s.",({ const Unit *_u = (userdata); _u ? log_object_internal(5, 0
, "../src/core/unit.c", 4497, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 4497, __func__, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)); })

4495

pid,({ const Unit *_u = (userdata); _u ? log_object_internal(5, 0
, "../src/core/unit.c", 4497, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 4497, __func__, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)); })

4496

strna(comm),({ const Unit *_u = (userdata); _u ? log_object_internal(5, 0
, "../src/core/unit.c", 4497, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 4497, __func__, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)); })

4497

signal_to_string(sig))({ const Unit *_u = (userdata); _u ? log_object_internal(5, 0
, "../src/core/unit.c", 4497, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((5))), 0, "../src/core/unit.c"
, 4497, __func__, "Killing process " "%" "i" " (%s) with signal SIG%s."
, pid, strna(comm), signal_to_string(sig)); });

4498

}

4499

4500

static int operation_to_signal(KillContext *c, KillOperation k) {

4501

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 4501, __PRETTY_FUNCTION__
); } while (0);

4502

4503

switch (k) {

4504

4505

case KILL_TERMINATE:

4506

case KILL_TERMINATE_AND_LOG:

4507

return c->kill_signal;

4508

4509

case KILL_KILL:

4510

return SIGKILL9;

4511

4512

case KILL_ABORT:

4513

return SIGABRT6;

4514

4515

default:

4516

assert_not_reached("KillOperation unknown")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"KillOperation unknown"), "../src/core/unit.c", 4516, __PRETTY_FUNCTION__
); } while (0);

4517

}

4518

}

4519

4520

int unit_kill_context(

4521

Unit *u,

4522

KillContext *c,

4523

KillOperation k,

4524

pid_t main_pid,

4525

pid_t control_pid,

4526

bool_Bool main_pid_alien) {

4527

4528

bool_Bool wait_for_exit = false0, send_sighup;

4529

cg_kill_log_func_t log_func = NULL((void*)0);

4530

int sig, r;

4531

4532

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4532, __PRETTY_FUNCTION__
); } while (0);

4533

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 4533, __PRETTY_FUNCTION__
); } while (0);

4534

4535

/* Kill the processes belonging to this unit, in preparation for shutting the unit down.

4536

* Returns > 0 if we killed something worth waiting for, 0 otherwise. */

4537

4538

if (c->kill_mode == KILL_NONE)

4539

return 0;

4540

4541

sig = operation_to_signal(c, k);

4542

4543

send_sighup =

4544

c->send_sighup &&

4545

IN_SET(k, KILL_TERMINATE, KILL_TERMINATE_AND_LOG)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){KILL_TERMINATE, KILL_TERMINATE_AND_LOG})
/sizeof(int)]; switch(k) { case KILL_TERMINATE: case KILL_TERMINATE_AND_LOG
: _found = 1; break; default: break; } _found; }) &&

4546

sig != SIGHUP1;

4547

4548

if (k != KILL_TERMINATE || IN_SET(sig, SIGKILL, SIGABRT)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){9, 6})/sizeof(int)]; switch(sig) { case 9
: case 6: _found = 1; break; default: break; } _found; }))

4549

log_func = log_kill;

4550

4551

if (main_pid > 0) {

4552

if (log_func)

4553

log_func(main_pid, sig, u);

4554

4555

r = kill_and_sigcont(main_pid, sig);

4556

if (r < 0 && r != -ESRCH3) {

4557

_cleanup_free___attribute__((cleanup(freep))) char *comm = NULL((void*)0);

4558

(void) get_process_comm(main_pid, &comm);

4559

4560

log_unit_warning_errno(u, r, "Failed to kill main process " PID_FMT " (%s), ignoring: %m", main_pid, strna(comm))({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 4560, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to kill main process " "%" "i" " (%s), ignoring: %m"
, main_pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), r, "../src/core/unit.c", 4560, __func__
, "Failed to kill main process " "%" "i" " (%s), ignoring: %m"
, main_pid, strna(comm)); });

4561

} else {

4562

if (!main_pid_alien)

4563

wait_for_exit = true1;

4564

4565

if (r != -ESRCH3 && send_sighup)

4566

(void) kill(main_pid, SIGHUP1);

4567

}

4568

}

4569

4570

if (control_pid > 0) {

4571

if (log_func)

4572

log_func(control_pid, sig, u);

4573

4574

r = kill_and_sigcont(control_pid, sig);

4575

if (r < 0 && r != -ESRCH3) {

4576

_cleanup_free___attribute__((cleanup(freep))) char *comm = NULL((void*)0);

4577

(void) get_process_comm(control_pid, &comm);

4578

4579

log_unit_warning_errno(u, r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m", control_pid, strna(comm))({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 4579, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to kill control process " "%" "i" " (%s), ignoring: %m"
, control_pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD
) << 10 | ((4))), r, "../src/core/unit.c", 4579, __func__
, "Failed to kill control process " "%" "i" " (%s), ignoring: %m"
, control_pid, strna(comm)); });

4580

} else {

4581

wait_for_exit = true1;

4582

4583

if (r != -ESRCH3 && send_sighup)

4584

(void) kill(control_pid, SIGHUP1);

4585

}

4586

}

4587

4588

if (u->cgroup_path &&

4589

(c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL))) {

4590

_cleanup_set_free___attribute__((cleanup(set_freep))) Set *pid_set = NULL((void*)0);

4591

4592

/* Exclude the main/control pids from being killed via the cgroup */

4593

pid_set = unit_pid_set(main_pid, control_pid);

4594

if (!pid_set)

4595

return -ENOMEM12;

4596

4597

r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path,

4598

sig,

4599

CGROUP_SIGCONT|CGROUP_IGNORE_SELF,

4600

pid_set,

4601

log_func, u);

4602

if (r < 0) {

4603

if (!IN_SET(r, -EAGAIN, -ESRCH, -ENOENT)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){-11, -3, -2})/sizeof(int)]; switch(r) { case
-11: case -3: case -2: _found = 1; break; default: break; } _found
; }))

4604

log_unit_warning_errno(u, r, "Failed to kill control group %s, ignoring: %m", u->cgroup_path)({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 4604, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to kill control group %s, ignoring: %m", u->cgroup_path
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((4
))), r, "../src/core/unit.c", 4604, __func__, "Failed to kill control group %s, ignoring: %m"
, u->cgroup_path); });

4605

4606

} else if (r > 0) {

4607

4608

wait_for_exit = true1;

4609

4610

if (send_sighup) {

4611

set_free(pid_set);

4612

4613

pid_set = unit_pid_set(main_pid, control_pid);

4614

if (!pid_set)

4615

return -ENOMEM12;

4616

4617

cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path,

4618

SIGHUP1,

4619

CGROUP_IGNORE_SELF,

4620

pid_set,

4621

NULL((void*)0), NULL((void*)0));

4622

}

4623

}

4624

}

4625

4626

return wait_for_exit;

4627

}

4628

4629

int unit_require_mounts_for(Unit *u, const char *path, UnitDependencyMask mask) {

4630

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

4631

char *prefix;

4632

UnitDependencyInfo di;

4633

int r;

4634

4635

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4635, __PRETTY_FUNCTION__
); } while (0);

4636

assert(path)do { if ((__builtin_expect(!!(!(path)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("path"), "../src/core/unit.c", 4636, __PRETTY_FUNCTION__
); } while (0);

4637

4638

/* Registers a unit for requiring a certain path and all its prefixes. We keep a hashtable of these paths in

4639

* the unit (from the path to the UnitDependencyInfo structure indicating how to the dependency came to

4640

* be). However, we build a prefix table for all possible prefixes so that new appearing mount units can easily

4641

* determine which units to make themselves a dependency of. */

4642

4643

if (!path_is_absolute(path))

4644

return -EINVAL22;

4645

4646

r = hashmap_ensure_allocated(&u->requires_mounts_for, &path_hash_ops)internal_hashmap_ensure_allocated(&u->requires_mounts_for
, &path_hash_ops );

4647

if (r < 0)

4648

return r;

4649

4650

p = strdup(path);

4651

if (!p)

4652

return -ENOMEM12;

4653

4654

path = path_simplify(p, false0);

4655

4656

if (!path_is_normalized(path))

4657

return -EPERM1;

4658

4659

if (hashmap_contains(u->requires_mounts_for, path))

4660

return 0;

4661

4662

di = (UnitDependencyInfo) {

4663

.origin_mask = mask

4664

};

4665

4666

r = hashmap_put(u->requires_mounts_for, path, di.data);

4667

if (r < 0)

4668

return r;

4669

p = NULL((void*)0);

4670

4671

prefix = alloca(strlen(path) + 1)__builtin_alloca (strlen(path) + 1);

4672

PATH_FOREACH_PREFIX_MORE(prefix, path)for (char *_slash = ({ path_simplify(strcpy(prefix, path), 0)
; if ((strcmp((prefix),("/")) == 0)) prefix[0] = 0; strrchr(prefix
, 0); }); _slash && ((*_slash = 0), 1); _slash = strrchr
((prefix), '/')) {

4673

Set *x;

4674

4675

x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);

4676

if (!x) {

4677

_cleanup_free___attribute__((cleanup(freep))) char *q = NULL((void*)0);

4678

4679

r = hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for, &path_hash_ops)internal_hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for
, &path_hash_ops );

4680

if (r < 0)

4681

return r;

4682

4683

q = strdup(prefix);

4684

if (!q)

4685

return -ENOMEM12;

4686

4687

x = set_new(NULL)internal_set_new(((void*)0) );

4688

if (!x)

4689

return -ENOMEM12;

4690

4691

r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);

4692

if (r < 0) {

4693

set_free(x);

4694

return r;

4695

}

4696

q = NULL((void*)0);

4697

}

4698

4699

r = set_put(x, u);

4700

if (r < 0)

4701

return r;

4702

}

4703

4704

return 0;

4705

}

4706

4707

int unit_setup_exec_runtime(Unit *u) {

4708

ExecRuntime **rt;

4709

size_t offset;

4710

Unit *other;

4711

Iterator i;

4712

void *v;

4713

int r;

4714

4715

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->exec_runtime_offset;

4716

assert(offset > 0)do { if ((__builtin_expect(!!(!(offset > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offset > 0"), "../src/core/unit.c", 4716
, __PRETTY_FUNCTION__); } while (0);

4717

4718

/* Check if there already is an ExecRuntime for this unit? */

4719

rt = (ExecRuntime**) ((uint8_t*) u + offset);

4720

if (*rt)

4721

return 0;

4722

4723

/* Try to get it from somebody else */

4724

HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[UNIT_JOINS_NAMESPACE_OF]), &(i), (void**)&(v), (const
void**) &(other)); ) {

4725

r = exec_runtime_acquire(u->manager, NULL((void*)0), other->id, false0, rt);

4726

if (r == 1)

4727

return 1;

4728

}

4729

4730

return exec_runtime_acquire(u->manager, unit_get_exec_context(u), u->id, true1, rt);

4731

}

4732

4733

int unit_setup_dynamic_creds(Unit *u) {

4734

ExecContext *ec;

4735

DynamicCreds *dcreds;

4736

size_t offset;

4737

4738

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4738, __PRETTY_FUNCTION__
); } while (0);

4739

4740

offset = UNIT_VTABLE(u)unit_vtable[(u)->type]->dynamic_creds_offset;

4741

assert(offset > 0)do { if ((__builtin_expect(!!(!(offset > 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("offset > 0"), "../src/core/unit.c", 4741
, __PRETTY_FUNCTION__); } while (0);

4742

dcreds = (DynamicCreds*) ((uint8_t*) u + offset);

4743

4744

ec = unit_get_exec_context(u);

4745

assert(ec)do { if ((__builtin_expect(!!(!(ec)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ec"), "../src/core/unit.c", 4745, __PRETTY_FUNCTION__
); } while (0);

4746

4747

if (!ec->dynamic_user)

4748

return 0;

4749

4750

return dynamic_creds_acquire(dcreds, u->manager, ec->user, ec->group);

4751

}

4752

4753

bool_Bool unit_type_supported(UnitType t) {

4754

if (_unlikely_(t < 0)(__builtin_expect(!!(t < 0),0)))

4755

return false0;

4756

if (_unlikely_(t >= _UNIT_TYPE_MAX)(__builtin_expect(!!(t >= _UNIT_TYPE_MAX),0)))

4757

return false0;

4758

4759

if (!unit_vtable[t]->supported)

4760

return true1;

4761

4762

return unit_vtable[t]->supported();

4763

}

4764

4765

void unit_warn_if_dir_nonempty(Unit *u, const char* where) {

4766

int r;

4767

4768

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4768, __PRETTY_FUNCTION__
); } while (0);

4769

assert(where)do { if ((__builtin_expect(!!(!(where)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("where"), "../src/core/unit.c", 4769, __PRETTY_FUNCTION__
); } while (0);

4770

4771

r = dir_is_empty(where);

4772

if (r > 0 || r == -ENOTDIR20)

4773

return;

4774

if (r < 0) {

4775

log_unit_warning_errno(u, r, "Failed to check directory %s: %m", where)({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 4775, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to check directory %s: %m", where) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((4))), r, "../src/core/unit.c"
, 4775, __func__, "Failed to check directory %s: %m", where);
});

4776

return;

4777

}

4778

4779

log_struct(LOG_NOTICE,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4780

"MESSAGE_ID=" SD_MESSAGE_OVERMOUNTING_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4781

LOG_UNIT_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4782

LOG_UNIT_INVOCATION_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4783

LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4784

"WHERE=%s", where)log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (5)), 0
, "../src/core/unit.c", 4784, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Directory %s to mount over is not empty, mounting anyway."
, (u)->id, where, "WHERE=%s", where, ((void*)0));

4785

}

4786

4787

int unit_fail_if_noncanonical(Unit *u, const char* where) {

4788

_cleanup_free___attribute__((cleanup(freep))) char *canonical_where;

4789

int r;

4790

4791

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4791, __PRETTY_FUNCTION__
); } while (0);

4792

assert(where)do { if ((__builtin_expect(!!(!(where)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("where"), "../src/core/unit.c", 4792, __PRETTY_FUNCTION__
); } while (0);

4793

4794

r = chase_symlinks(where, NULL((void*)0), CHASE_NONEXISTENT, &canonical_where);

4795

if (r < 0) {

4796

log_unit_debug_errno(u, r, "Failed to check %s for symlinks, ignoring: %m", where)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 4796, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to check %s for symlinks, ignoring: %m", where) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), r, "../src/core/unit.c"
, 4796, __func__, "Failed to check %s for symlinks, ignoring: %m"
, where); });

4797

return 0;

4798

}

4799

4800

/* We will happily ignore a trailing slash (or any redundant slashes) */

4801

if (path_equal(where, canonical_where))

4802

return 0;

4803

4804

/* No need to mention "." or "..", they would already have been rejected by unit_name_from_path() */

4805

log_struct(LOG_ERR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4806

"MESSAGE_ID=" SD_MESSAGE_OVERMOUNTING_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4807

LOG_UNIT_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4808

LOG_UNIT_INVOCATION_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4809

LOG_UNIT_MESSAGE(u, "Mount path %s is not canonical (contains a symlink).", where),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0))

4810

"WHERE=%s", where)log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (3)), 0
, "../src/core/unit.c", 4810, __func__, "MESSAGE_ID=" "1d" "ee"
"03" "69" "c7" "fc" "47" "36" "b7" "09" "9b" "38" "ec" "b4" "6e"
"e7", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Mount path %s is not canonical (contains a symlink)."
, (u)->id, where, "WHERE=%s", where, ((void*)0));

4811

4812

return -ELOOP40;

4813

}

4814

4815

bool_Bool unit_is_pristine(Unit *u) {

4816

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4816, __PRETTY_FUNCTION__
); } while (0);

4817

4818

/* Check if the unit already exists or is already around,

4819

* in a number of different ways. Note that to cater for unit

4820

* types such as slice, we are generally fine with units that

4821

* are marked UNIT_LOADED even though nothing was actually

4822

* loaded, as those unit types don't require a file on disk. */

4823

4824

return !(!IN_SET(u->load_state, UNIT_NOT_FOUND, UNIT_LOADED)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){UNIT_NOT_FOUND, UNIT_LOADED})/sizeof(int
)]; switch(u->load_state) { case UNIT_NOT_FOUND: case UNIT_LOADED
: _found = 1; break; default: break; } _found; }) ||

4825

u->fragment_path ||

4826

u->source_path ||

4827

!strv_isempty(u->dropin_paths) ||

4828

u->job ||

4829

u->merged_into);

4830

}

4831

4832

pid_t unit_control_pid(Unit *u) {

4833

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4833, __PRETTY_FUNCTION__
); } while (0);

4834

4835

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->control_pid)

4836

return UNIT_VTABLE(u)unit_vtable[(u)->type]->control_pid(u);

4837

4838

return 0;

4839

}

4840

4841

pid_t unit_main_pid(Unit *u) {

4842

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4842, __PRETTY_FUNCTION__
); } while (0);

4843

4844

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->main_pid)

4845

return UNIT_VTABLE(u)unit_vtable[(u)->type]->main_pid(u);

4846

4847

return 0;

4848

}

4849

4850

static void unit_unref_uid_internal(

4851

Unit *u,

4852

uid_t *ref_uid,

4853

bool_Bool destroy_now,

4854

void (*_manager_unref_uid)(Manager *m, uid_t uid, bool_Bool destroy_now)) {

4855

4856

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4856, __PRETTY_FUNCTION__
); } while (0);

4857

assert(ref_uid)do { if ((__builtin_expect(!!(!(ref_uid)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ref_uid"), "../src/core/unit.c", 4857, __PRETTY_FUNCTION__
); } while (0);

4858

assert(_manager_unref_uid)do { if ((__builtin_expect(!!(!(_manager_unref_uid)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_manager_unref_uid"), "../src/core/unit.c"
, 4858, __PRETTY_FUNCTION__); } while (0);

4859

4860

/* Generic implementation of both unit_unref_uid() and unit_unref_gid(), under the assumption that uid_t and

4861

* gid_t are actually the same time, with the same validity rules.

4862

*

4863

* Drops a reference to UID/GID from a unit. */

4864

4865

assert_cc(sizeof(uid_t) == sizeof(gid_t))GCC diagnostic push ; GCC diagnostic ignored "-Wdeclaration-after-statement"
; struct _assert_struct_36 { char x[(sizeof(uid_t) == sizeof
(gid_t)) ? 0 : -1]; }; GCC diagnostic pop ;

4866

assert_cc(UID_INVALID == (uid_t) GID_INVALID)GCC diagnostic push ; GCC diagnostic ignored "-Wdeclaration-after-statement"
; struct _assert_struct_37 { char x[(((uid_t) -1) == (uid_t)
((gid_t) -1)) ? 0 : -1]; }; GCC diagnostic pop ;

4867

4868

if (!uid_is_valid(*ref_uid))

4869

return;

4870

4871

_manager_unref_uid(u->manager, *ref_uid, destroy_now);

4872

*ref_uid = UID_INVALID((uid_t) -1);

4873

}

4874

4875

void unit_unref_uid(Unit *u, bool_Bool destroy_now) {

4876

unit_unref_uid_internal(u, &u->ref_uid, destroy_now, manager_unref_uid);

4877

}

4878

4879

void unit_unref_gid(Unit *u, bool_Bool destroy_now) {

4880

unit_unref_uid_internal(u, (uid_t*) &u->ref_gid, destroy_now, manager_unref_gid);

4881

}

4882

4883

static int unit_ref_uid_internal(

4884

Unit *u,

4885

uid_t *ref_uid,

4886

uid_t uid,

4887

bool_Bool clean_ipc,

4888

int (*_manager_ref_uid)(Manager *m, uid_t uid, bool_Bool clean_ipc)) {

4889

4890

int r;

4891

4892

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4892, __PRETTY_FUNCTION__
); } while (0);

4893

assert(ref_uid)do { if ((__builtin_expect(!!(!(ref_uid)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ref_uid"), "../src/core/unit.c", 4893, __PRETTY_FUNCTION__
); } while (0);

4894

assert(uid_is_valid(uid))do { if ((__builtin_expect(!!(!(uid_is_valid(uid))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("uid_is_valid(uid)"), "../src/core/unit.c"
, 4894, __PRETTY_FUNCTION__); } while (0);

4895

assert(_manager_ref_uid)do { if ((__builtin_expect(!!(!(_manager_ref_uid)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("_manager_ref_uid"), "../src/core/unit.c"
, 4895, __PRETTY_FUNCTION__); } while (0);

4896

4897

/* Generic implementation of both unit_ref_uid() and unit_ref_guid(), under the assumption that uid_t and gid_t

4898

* are actually the same type, and have the same validity rules.

4899

*

4900

* Adds a reference on a specific UID/GID to this unit. Each unit referencing the same UID/GID maintains a

4901

* reference so that we can destroy the UID/GID's IPC resources as soon as this is requested and the counter

4902

* drops to zero. */

4903

4904

assert_cc(sizeof(uid_t) == sizeof(gid_t))GCC diagnostic push ; GCC diagnostic ignored "-Wdeclaration-after-statement"
; struct _assert_struct_38 { char x[(sizeof(uid_t) == sizeof
(gid_t)) ? 0 : -1]; }; GCC diagnostic pop ;

4905

assert_cc(UID_INVALID == (uid_t) GID_INVALID)GCC diagnostic push ; GCC diagnostic ignored "-Wdeclaration-after-statement"
; struct _assert_struct_39 { char x[(((uid_t) -1) == (uid_t)
((gid_t) -1)) ? 0 : -1]; }; GCC diagnostic pop ;

4906

4907

if (*ref_uid == uid)

4908

return 0;

4909

4910

if (uid_is_valid(*ref_uid)) /* Already set? */

4911

return -EBUSY16;

4912

4913

r = _manager_ref_uid(u->manager, uid, clean_ipc);

4914

if (r < 0)

4915

return r;

4916

4917

*ref_uid = uid;

4918

return 1;

4919

}

4920

4921

int unit_ref_uid(Unit *u, uid_t uid, bool_Bool clean_ipc) {

4922

return unit_ref_uid_internal(u, &u->ref_uid, uid, clean_ipc, manager_ref_uid);

4923

}

4924

4925

int unit_ref_gid(Unit *u, gid_t gid, bool_Bool clean_ipc) {

4926

return unit_ref_uid_internal(u, (uid_t*) &u->ref_gid, (uid_t) gid, clean_ipc, manager_ref_gid);

4927

}

4928

4929

static int unit_ref_uid_gid_internal(Unit *u, uid_t uid, gid_t gid, bool_Bool clean_ipc) {

4930

int r = 0, q = 0;

4931

4932

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4932, __PRETTY_FUNCTION__
); } while (0);

4933

4934

/* Reference both a UID and a GID in one go. Either references both, or neither. */

4935

4936

if (uid_is_valid(uid)) {

4937

r = unit_ref_uid(u, uid, clean_ipc);

4938

if (r < 0)

4939

return r;

4940

}

4941

4942

if (gid_is_valid(gid)) {

4943

q = unit_ref_gid(u, gid, clean_ipc);

4944

if (q < 0) {

4945

if (r > 0)

4946

unit_unref_uid(u, false0);

4947

4948

return q;

4949

}

4950

}

4951

4952

return r > 0 || q > 0;

4953

}

4954

4955

int unit_ref_uid_gid(Unit *u, uid_t uid, gid_t gid) {

4956

ExecContext *c;

4957

int r;

4958

4959

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4959, __PRETTY_FUNCTION__
); } while (0);

4960

4961

c = unit_get_exec_context(u);

4962

4963

r = unit_ref_uid_gid_internal(u, uid, gid, c ? c->remove_ipc : false0);

4964

if (r < 0)

4965

return log_unit_warning_errno(u, r, "Couldn't add UID/GID reference to unit, proceeding without: %m")({ const Unit *_u = (u); _u ? log_object_internal(4, r, "../src/core/unit.c"
, 4965, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Couldn't add UID/GID reference to unit, proceeding without: %m"
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((4
))), r, "../src/core/unit.c", 4965, __func__, "Couldn't add UID/GID reference to unit, proceeding without: %m"
); });

4966

4967

return r;

4968

}

4969

4970

void unit_unref_uid_gid(Unit *u, bool_Bool destroy_now) {

4971

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4971, __PRETTY_FUNCTION__
); } while (0);

4972

4973

unit_unref_uid(u, destroy_now);

4974

unit_unref_gid(u, destroy_now);

4975

}

4976

4977

void unit_notify_user_lookup(Unit *u, uid_t uid, gid_t gid) {

4978

int r;

4979

4980

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4980, __PRETTY_FUNCTION__
); } while (0);

4981

4982

/* This is invoked whenever one of the forked off processes let's us know the UID/GID its user name/group names

4983

* resolved to. We keep track of which UID/GID is currently assigned in order to be able to destroy its IPC

4984

* objects when no service references the UID/GID anymore. */

4985

4986

r = unit_ref_uid_gid(u, uid, gid);

4987

if (r > 0)

4988

bus_unit_send_change_signal(u);

4989

}

4990

4991

int unit_set_invocation_id(Unit *u, sd_id128_t id) {

4992

int r;

4993

4994

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 4994, __PRETTY_FUNCTION__
); } while (0);

4995

4996

/* Set the invocation ID for this unit. If we cannot, this will not roll back, but reset the whole thing. */

4997

4998

if (sd_id128_equal(u->invocation_id, id))

4999

return 0;

5000

5001

if (!sd_id128_is_null(u->invocation_id))

5002

(void) hashmap_remove_value(u->manager->units_by_invocation_id, &u->invocation_id, u);

5003

5004

if (sd_id128_is_null(id)) {

5005

r = 0;

5006

goto reset;

5007

}

5008

5009

r = hashmap_ensure_allocated(&u->manager->units_by_invocation_id, &id128_hash_ops)internal_hashmap_ensure_allocated(&u->manager->units_by_invocation_id
, &id128_hash_ops );

5010

if (r < 0)

5011

goto reset;

5012

5013

u->invocation_id = id;

5014

sd_id128_to_string(id, u->invocation_id_string);

5015

5016

r = hashmap_put(u->manager->units_by_invocation_id, &u->invocation_id, u);

5017

if (r < 0)

5018

goto reset;

5019

5020

return 0;

5021

5022

reset:

5023

u->invocation_id = SD_ID128_NULL((const sd_id128_t) { .qwords = { 0, 0 }});

5024

u->invocation_id_string[0] = 0;

5025

return r;

5026

}

5027

5028

int unit_acquire_invocation_id(Unit *u) {

5029

sd_id128_t id;

5030

int r;

5031

5032

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5032, __PRETTY_FUNCTION__
); } while (0);

5033

5034

r = sd_id128_randomize(&id);

5035

if (r < 0)

5036

return log_unit_error_errno(u, r, "Failed to generate invocation ID for unit: %m")({ const Unit *_u = (u); _u ? log_object_internal(3, r, "../src/core/unit.c"
, 5036, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to generate invocation ID for unit: %m") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((3))), r, "../src/core/unit.c"
, 5036, __func__, "Failed to generate invocation ID for unit: %m"
); });

5037

5038

r = unit_set_invocation_id(u, id);

5039

if (r < 0)

5040

return log_unit_error_errno(u, r, "Failed to set invocation ID for unit: %m")({ const Unit *_u = (u); _u ? log_object_internal(3, r, "../src/core/unit.c"
, 5040, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to set invocation ID for unit: %m") : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((3))), r, "../src/core/unit.c"
, 5040, __func__, "Failed to set invocation ID for unit: %m")
; });

5041

5042

return 0;

5043

}

5044

5045

void unit_set_exec_params(Unit *u, ExecParameters *p) {

5046

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5046, __PRETTY_FUNCTION__
); } while (0);

5047

assert(p)do { if ((__builtin_expect(!!(!(p)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("p"), "../src/core/unit.c", 5047, __PRETTY_FUNCTION__
); } while (0);

5048

5049

/* Copy parameters from manager */

5050

p->environment = u->manager->environment;

5051

p->confirm_spawn = manager_get_confirm_spawn(u->manager);

5052

p->cgroup_supported = u->manager->cgroup_supported;

5053

p->prefix = u->manager->prefix;

5054

SET_FLAG(p->flags, EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES, MANAGER_IS_SYSTEM(u->manager))(p->flags) = (((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM
)) ? ((p->flags) | (EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES
)) : ((p->flags) & ~(EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES
));

5055

5056

/* Copy paramaters from unit */

5057

p->cgroup_path = u->cgroup_path;

5058

SET_FLAG(p->flags, EXEC_CGROUP_DELEGATE, unit_cgroup_delegate(u))(p->flags) = (unit_cgroup_delegate(u)) ? ((p->flags) | (
EXEC_CGROUP_DELEGATE)) : ((p->flags) & ~(EXEC_CGROUP_DELEGATE
));

5059

}

5060

5061

int unit_fork_helper_process(Unit *u, const char *name, pid_t *ret) {

5062

int r;

5063

5064

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5064, __PRETTY_FUNCTION__
); } while (0);

5065

assert(ret)do { if ((__builtin_expect(!!(!(ret)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("ret"), "../src/core/unit.c", 5065, __PRETTY_FUNCTION__
); } while (0);

5066

5067

/* Forks off a helper process and makes sure it is a member of the unit's cgroup. Returns == 0 in the child,

5068

* and > 0 in the parent. The pid parameter is always filled in with the child's PID. */

5069

5070

(void) unit_realize_cgroup(u);

5071

5072

r = safe_fork(name, FORK_REOPEN_LOG, ret);

5073

if (r != 0)

5074

return r;

5075

5076

(void) default_signals(SIGNALS_CRASH_HANDLER11,4,8,7,3,6, SIGNALS_IGNORE13, -1);

5077

(void) ignore_signals(SIGPIPE13, -1);

5078

5079

(void) prctl(PR_SET_PDEATHSIG1, SIGTERM15);

5080

5081

if (u->cgroup_path) {

5082

r = cg_attach_everywhere(u->manager->cgroup_supported, u->cgroup_path, 0, NULL((void*)0), NULL((void*)0));

5083

if (r < 0) {

5084

log_unit_error_errno(u, r, "Failed to join unit cgroup %s: %m", u->cgroup_path)({ const Unit *_u = (u); _u ? log_object_internal(3, r, "../src/core/unit.c"
, 5084, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to join unit cgroup %s: %m", u->cgroup_path) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((3))), r, "../src/core/unit.c"
, 5084, __func__, "Failed to join unit cgroup %s: %m", u->
cgroup_path); });

5085

_exit(EXIT_CGROUP);

5086

}

5087

}

5088

5089

return 0;

5090

}

5091

5092

static void unit_update_dependency_mask(Unit *u, UnitDependency d, Unit *other, UnitDependencyInfo di) {

5093

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5093, __PRETTY_FUNCTION__
); } while (0);

5094

assert(d >= 0)do { if ((__builtin_expect(!!(!(d >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("d >= 0"), "../src/core/unit.c", 5094
, __PRETTY_FUNCTION__); } while (0);

5095

assert(d < _UNIT_DEPENDENCY_MAX)do { if ((__builtin_expect(!!(!(d < _UNIT_DEPENDENCY_MAX))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("d < _UNIT_DEPENDENCY_MAX"
), "../src/core/unit.c", 5095, __PRETTY_FUNCTION__); } while (
0);

5096

assert(other)do { if ((__builtin_expect(!!(!(other)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("other"), "../src/core/unit.c", 5096, __PRETTY_FUNCTION__
); } while (0);

5097

5098

if (di.origin_mask == 0 && di.destination_mask == 0) {

5099

/* No bit set anymore, let's drop the whole entry */

5100

assert_se(hashmap_remove(u->dependencies[d], other))do { if ((__builtin_expect(!!(!(hashmap_remove(u->dependencies
[d], other))),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD,
("hashmap_remove(u->dependencies[d], other)"), "../src/core/unit.c"
, 5100, __PRETTY_FUNCTION__); } while (0);

5101

log_unit_debug(u, "%s lost dependency %s=%s", u->id, unit_dependency_to_string(d), other->id)({ const Unit *_u = (u); _u ? log_object_internal(7, 0, "../src/core/unit.c"
, 5101, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "%s lost dependency %s=%s", u->id, unit_dependency_to_string
(d), other->id) : log_internal_realm(((LOG_REALM_SYSTEMD) <<
10 | ((7))), 0, "../src/core/unit.c", 5101, __func__, "%s lost dependency %s=%s"
, u->id, unit_dependency_to_string(d), other->id); });

5102

} else

5103

/* Mask was reduced, let's update the entry */

5104

assert_se(hashmap_update(u->dependencies[d], other, di.data) == 0)do { if ((__builtin_expect(!!(!(hashmap_update(u->dependencies
[d], other, di.data) == 0)),0))) log_assert_failed_realm(LOG_REALM_SYSTEMD
, ("hashmap_update(u->dependencies[d], other, di.data) == 0"
), "../src/core/unit.c", 5104, __PRETTY_FUNCTION__); } while (
0);

5105

}

5106

5107

void unit_remove_dependencies(Unit *u, UnitDependencyMask mask) {

5108

UnitDependency d;

5109

5110

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5110, __PRETTY_FUNCTION__
); } while (0);

5111

5112

/* Removes all dependencies u has on other units marked for ownership by 'mask'. */

5113

5114

if (mask == 0)

5115

return;

5116

5117

for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {

5118

bool_Bool done;

5119

5120

do {

5121

UnitDependencyInfo di;

5122

Unit *other;

5123

Iterator i;

5124

5125

done = true1;

5126

5127

HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); hashmap_iterate((u->dependencies
[d]), &(i), (void**)&(di.data), (const void**) &(
other)); ) {

5128

UnitDependency q;

5129

5130

if ((di.origin_mask & ~mask) == di.origin_mask)

5131

continue;

5132

di.origin_mask &= ~mask;

5133

unit_update_dependency_mask(u, d, other, di);

5134

5135

/* We updated the dependency from our unit to the other unit now. But most dependencies

5136

* imply a reverse dependency. Hence, let's delete that one too. For that we go through

5137

* all dependency types on the other unit and delete all those which point to us and

5138

* have the right mask set. */

5139

5140

for (q = 0; q < _UNIT_DEPENDENCY_MAX; q++) {

5141

UnitDependencyInfo dj;

5142

5143

dj.data = hashmap_get(other->dependencies[q], u);

5144

if ((dj.destination_mask & ~mask) == dj.destination_mask)

5145

continue;

5146

dj.destination_mask &= ~mask;

5147

5148

unit_update_dependency_mask(other, q, u, dj);

5149

}

5150

5151

unit_add_to_gc_queue(other);

5152

5153

done = false0;

5154

break;

5155

}

5156

5157

} while (!done);

5158

}

5159

}

5160

5161

static int unit_export_invocation_id(Unit *u) {

5162

const char *p;

5163

int r;

5164

5165

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5165, __PRETTY_FUNCTION__
); } while (0);

5166

5167

if (u->exported_invocation_id)

5168

return 0;

5169

5170

if (sd_id128_is_null(u->invocation_id))

5171

return 0;

5172

5173

p = strjoina("/run/systemd/units/invocation:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/invocation:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5174

r = symlink_atomic(u->invocation_id_string, p);

5175

if (r < 0)

5176

return log_unit_debug_errno(u, r, "Failed to create invocation ID symlink %s: %m", p)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 5176, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to create invocation ID symlink %s: %m", p) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), r, "../src/core/unit.c"
, 5176, __func__, "Failed to create invocation ID symlink %s: %m"
, p); });

5177

5178

u->exported_invocation_id = true1;

5179

return 0;

5180

}

5181

5182

static int unit_export_log_level_max(Unit *u, const ExecContext *c) {

5183

const char *p;

5184

char buf[2];

5185

int r;

5186

5187

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5187, __PRETTY_FUNCTION__
); } while (0);

5188

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 5188, __PRETTY_FUNCTION__
); } while (0);

5189

5190

if (u->exported_log_level_max)

5191

return 0;

5192

5193

if (c->log_level_max < 0)

5194

return 0;

5195

5196

assert(c->log_level_max <= 7)do { if ((__builtin_expect(!!(!(c->log_level_max <= 7))
,0))) log_assert_failed_realm(LOG_REALM_SYSTEMD, ("c->log_level_max <= 7"
), "../src/core/unit.c", 5196, __PRETTY_FUNCTION__); } while (
0);

5197

5198

buf[0] = '0' + c->log_level_max;

5199

buf[1] = 0;

5200

5201

p = strjoina("/run/systemd/units/log-level-max:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-level-max:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5202

r = symlink_atomic(buf, p);

5203

if (r < 0)

5204

return log_unit_debug_errno(u, r, "Failed to create maximum log level symlink %s: %m", p)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 5204, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to create maximum log level symlink %s: %m", p) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), r, "../src/core/unit.c"
, 5204, __func__, "Failed to create maximum log level symlink %s: %m"
, p); });

5205

5206

u->exported_log_level_max = true1;

5207

return 0;

5208

}

5209

5210

static int unit_export_log_extra_fields(Unit *u, const ExecContext *c) {

5211

_cleanup_close___attribute__((cleanup(closep))) int fd = -1;

5212

struct iovec *iovec;

5213

const char *p;

5214

char *pattern;

5215

le64_t *sizes;

5216

ssize_t n;

5217

size_t i;

5218

int r;

5219

5220

if (u->exported_log_extra_fields)

5221

return 0;

5222

5223

if (c->n_log_extra_fields <= 0)

5224

return 0;

5225

5226

sizes = newa(le64_t, c->n_log_extra_fields)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(le64_t), c->n_log_extra_fields))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(le64_t), c->n_log_extra_fields)"
), "../src/core/unit.c", 5226, __PRETTY_FUNCTION__); } while (
0); (le64_t*) __builtin_alloca (sizeof(le64_t)*(c->n_log_extra_fields
)); });

5227

iovec = newa(struct iovec, c->n_log_extra_fields * 2)({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(struct iovec), c->n_log_extra_fields * 2))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(struct iovec), c->n_log_extra_fields * 2)"
), "../src/core/unit.c", 5227, __PRETTY_FUNCTION__); } while (
0); (struct iovec*) __builtin_alloca (sizeof(struct iovec)*(c
->n_log_extra_fields * 2)); });

5228

5229

for (i = 0; i < c->n_log_extra_fields; i++) {

5230

sizes[i] = htole64(c->log_extra_fields[i].iov_len);

5231

5232

iovec[i*2] = IOVEC_MAKE(sizes + i, sizeof(le64_t))(struct iovec) { .iov_base = (sizes + i), .iov_len = (sizeof(
le64_t)) };

5233

iovec[i*2+1] = c->log_extra_fields[i];

5234

}

5235

5236

p = strjoina("/run/systemd/units/log-extra-fields:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-extra-fields:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5237

pattern = strjoina(p, ".XXXXXX")({ const char *_appendees_[] = { p, ".XXXXXX" }; char *_d_, *
_p_; size_t _len_ = 0; size_t _i_; for (_i_ = 0; _i_ < __extension__
(__builtin_choose_expr( !__builtin_types_compatible_p(typeof
(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5238

5239

fd = mkostemp_safe(pattern);

5240

if (fd < 0)

5241

return log_unit_debug_errno(u, fd, "Failed to create extra fields file %s: %m", p)({ const Unit *_u = (u); _u ? log_object_internal(7, fd, "../src/core/unit.c"
, 5241, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to create extra fields file %s: %m", p) : log_internal_realm
(((LOG_REALM_SYSTEMD) << 10 | ((7))), fd, "../src/core/unit.c"
, 5241, __func__, "Failed to create extra fields file %s: %m"
, p); });

5242

5243

n = writev(fd, iovec, c->n_log_extra_fields*2);

5244

if (n < 0) {

5245

r = log_unit_debug_errno(u, errno, "Failed to write extra fields: %m")({ const Unit *_u = (u); _u ? log_object_internal(7, (*__errno_location
()), "../src/core/unit.c", 5245, __func__, _u->manager->
unit_log_field, _u->id, _u->manager->invocation_log_field
, _u->invocation_id_string, "Failed to write extra fields: %m"
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7
))), (*__errno_location ()), "../src/core/unit.c", 5245, __func__
, "Failed to write extra fields: %m"); });

5246

goto fail;

5247

}

5248

5249

(void) fchmod(fd, 0644);

5250

5251

if (rename(pattern, p) < 0) {

5252

r = log_unit_debug_errno(u, errno, "Failed to rename extra fields file: %m")({ const Unit *_u = (u); _u ? log_object_internal(7, (*__errno_location
()), "../src/core/unit.c", 5252, __func__, _u->manager->
unit_log_field, _u->id, _u->manager->invocation_log_field
, _u->invocation_id_string, "Failed to rename extra fields file: %m"
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7
))), (*__errno_location ()), "../src/core/unit.c", 5252, __func__
, "Failed to rename extra fields file: %m"); });

5253

goto fail;

5254

}

5255

5256

u->exported_log_extra_fields = true1;

5257

return 0;

5258

5259

fail:

5260

(void) unlink(pattern);

5261

return r;

5262

}

5263

5264

static int unit_export_log_rate_limit_interval(Unit *u, const ExecContext *c) {

5265

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

5266

const char *p;

5267

int r;

5268

5269

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5269, __PRETTY_FUNCTION__
); } while (0);

5270

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 5270, __PRETTY_FUNCTION__
); } while (0);

5271

5272

if (u->exported_log_rate_limit_interval)

5273

return 0;

5274

5275

if (c->log_rate_limit_interval_usec == 0)

5276

return 0;

5277

5278

p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-rate-limit-interval:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5279

5280

if (asprintf(&buf, "%" PRIu64"l" "u", c->log_rate_limit_interval_usec) < 0)

5281

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 5281
, __func__);

5282

5283

r = symlink_atomic(buf, p);

5284

if (r < 0)

5285

return log_unit_debug_errno(u, r, "Failed to create log rate limit interval symlink %s: %m", p)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 5285, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to create log rate limit interval symlink %s: %m", p
) : log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7
))), r, "../src/core/unit.c", 5285, __func__, "Failed to create log rate limit interval symlink %s: %m"
, p); });

5286

5287

u->exported_log_rate_limit_interval = true1;

5288

return 0;

5289

}

5290

5291

static int unit_export_log_rate_limit_burst(Unit *u, const ExecContext *c) {

5292

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

5293

const char *p;

5294

int r;

5295

5296

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5296, __PRETTY_FUNCTION__
); } while (0);

5297

assert(c)do { if ((__builtin_expect(!!(!(c)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("c"), "../src/core/unit.c", 5297, __PRETTY_FUNCTION__
); } while (0);

5298

5299

if (u->exported_log_rate_limit_burst)

5300

return 0;

5301

5302

if (c->log_rate_limit_burst == 0)

5303

return 0;

5304

5305

p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-rate-limit-burst:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5306

5307

if (asprintf(&buf, "%u", c->log_rate_limit_burst) < 0)

5308

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/core/unit.c", 5308
, __func__);

5309

5310

r = symlink_atomic(buf, p);

5311

if (r < 0)

5312

return log_unit_debug_errno(u, r, "Failed to create log rate limit burst symlink %s: %m", p)({ const Unit *_u = (u); _u ? log_object_internal(7, r, "../src/core/unit.c"
, 5312, __func__, _u->manager->unit_log_field, _u->id
, _u->manager->invocation_log_field, _u->invocation_id_string
, "Failed to create log rate limit burst symlink %s: %m", p) :
log_internal_realm(((LOG_REALM_SYSTEMD) << 10 | ((7)))
, r, "../src/core/unit.c", 5312, __func__, "Failed to create log rate limit burst symlink %s: %m"
, p); });

5313

5314

u->exported_log_rate_limit_burst = true1;

5315

return 0;

5316

}

5317

5318

void unit_export_state_files(Unit *u) {

5319

const ExecContext *c;

5320

5321

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5321, __PRETTY_FUNCTION__
); } while (0);

5322

5323

if (!u->id)

5324

return;

5325

5326

if (!MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM))

5327

return;

5328

5329

if (u->manager->test_run_flags != 0)

5330

return;

5331

5332

/* Exports a couple of unit properties to /run/systemd/units/, so that journald can quickly query this data

5333

* from there. Ideally, journald would use IPC to query this, like everybody else, but that's hard, as long as

5334

* the IPC system itself and PID 1 also log to the journal.

5335

*

5336

* Note that these files really shouldn't be considered API for anyone else, as use a runtime file system as

5337

* IPC replacement is not compatible with today's world of file system namespaces. However, this doesn't really

5338

* apply to communication between the journal and systemd, as we assume that these two daemons live in the same

5339

* namespace at least.

5340

*

5341

* Note that some of the "files" exported here are actually symlinks and not regular files. Symlinks work

5342

* better for storing small bits of data, in particular as we can write them with two system calls, and read

5343

* them with one. */

5344

5345

(void) unit_export_invocation_id(u);

5346

5347

c = unit_get_exec_context(u);

5348

if (c) {

5349

(void) unit_export_log_level_max(u, c);

5350

(void) unit_export_log_extra_fields(u, c);

5351

(void) unit_export_log_rate_limit_interval(u, c);

5352

(void) unit_export_log_rate_limit_burst(u, c);

5353

}

5354

}

5355

5356

void unit_unlink_state_files(Unit *u) {

5357

const char *p;

5358

5359

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5359, __PRETTY_FUNCTION__
); } while (0);

5360

5361

if (!u->id)

5362

return;

5363

5364

if (!MANAGER_IS_SYSTEM(u->manager)((u->manager)->unit_file_scope == UNIT_FILE_SYSTEM))

5365

return;

5366

5367

/* Undoes the effect of unit_export_state() */

5368

5369

if (u->exported_invocation_id) {

5370

p = strjoina("/run/systemd/units/invocation:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/invocation:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5371

(void) unlink(p);

5372

5373

u->exported_invocation_id = false0;

5374

}

5375

5376

if (u->exported_log_level_max) {

5377

p = strjoina("/run/systemd/units/log-level-max:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-level-max:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5378

(void) unlink(p);

5379

5380

u->exported_log_level_max = false0;

5381

}

5382

5383

if (u->exported_log_extra_fields) {

5384

p = strjoina("/run/systemd/units/extra-fields:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/extra-fields:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5385

(void) unlink(p);

5386

5387

u->exported_log_extra_fields = false0;

5388

}

5389

5390

if (u->exported_log_rate_limit_interval) {

5391

p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-rate-limit-interval:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5392

(void) unlink(p);

5393

5394

u->exported_log_rate_limit_interval = false0;

5395

}

5396

5397

if (u->exported_log_rate_limit_burst) {

5398

p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id)({ const char *_appendees_[] = { "/run/systemd/units/log-rate-limit-burst:"
, u->id }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for
(_i_ = 0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

5399

(void) unlink(p);

5400

5401

u->exported_log_rate_limit_burst = false0;

5402

}

5403

}

5404

5405

int unit_prepare_exec(Unit *u) {

5406

int r;

5407

5408

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5408, __PRETTY_FUNCTION__
); } while (0);

5409

5410

/* Prepares everything so that we can fork of a process for this unit */

5411

5412

(void) unit_realize_cgroup(u);

5413

5414

if (u->reset_accounting) {

5415

(void) unit_reset_cpu_accounting(u);

5416

(void) unit_reset_ip_accounting(u);

5417

u->reset_accounting = false0;

5418

}

5419

5420

unit_export_state_files(u);

5421

5422

r = unit_setup_exec_runtime(u);

5423

if (r < 0)

5424

return r;

5425

5426

r = unit_setup_dynamic_creds(u);

5427

if (r < 0)

5428

return r;

5429

5430

return 0;

5431

}

5432

5433

static void log_leftover(pid_t pid, int sig, void *userdata) {

5434

_cleanup_free___attribute__((cleanup(freep))) char *comm = NULL((void*)0);

5435

5436

(void) get_process_comm(pid, &comm);

5437

5438

if (comm && comm[0] == '(') /* Most likely our own helper process (PAM?), ignore */

5439

return;

5440

5441

log_unit_warning(userdata,({ const Unit *_u = (userdata); _u ? log_object_internal(4, 0
, "../src/core/unit.c", 5444, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD)
<< 10 | ((4))), 0, "../src/core/unit.c", 5444, __func__
, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)); })

5442

"Found left-over process " PID_FMT " (%s) in control group while starting unit. Ignoring.\n"({ const Unit *_u = (userdata); _u ? log_object_internal(4, 0
, "../src/core/unit.c", 5444, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD)
<< 10 | ((4))), 0, "../src/core/unit.c", 5444, __func__
, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)); })

5443

"This usually indicates unclean termination of a previous run, or service implementation deficiencies.",({ const Unit *_u = (userdata); _u ? log_object_internal(4, 0
, "../src/core/unit.c", 5444, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD)
<< 10 | ((4))), 0, "../src/core/unit.c", 5444, __func__
, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)); })

5444

pid, strna(comm))({ const Unit *_u = (userdata); _u ? log_object_internal(4, 0
, "../src/core/unit.c", 5444, __func__, _u->manager->unit_log_field
, _u->id, _u->manager->invocation_log_field, _u->
invocation_id_string, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)) : log_internal_realm(((LOG_REALM_SYSTEMD)
<< 10 | ((4))), 0, "../src/core/unit.c", 5444, __func__
, "Found left-over process " "%" "i" " (%s) in control group while starting unit. Ignoring.\n"
"This usually indicates unclean termination of a previous run, or service implementation deficiencies."
, pid, strna(comm)); });

5445

}

5446

5447

void unit_warn_leftover_processes(Unit *u) {

5448

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5448, __PRETTY_FUNCTION__
); } while (0);

5449

5450

(void) unit_pick_cgroup_path(u);

5451

5452

if (!u->cgroup_path)

5453

return;

5454

5455

(void) cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER"_systemd", u->cgroup_path, 0, 0, NULL((void*)0), log_leftover, u);

5456

}

5457

5458

bool_Bool unit_needs_console(Unit *u) {

5459

ExecContext *ec;

5460

UnitActiveState state;

5461

5462

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5462, __PRETTY_FUNCTION__
); } while (0);

5463

5464

state = unit_active_state(u);

5465

5466

if (UNIT_IS_INACTIVE_OR_FAILED(state))

5467

return false0;

5468

5469

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->needs_console)

5470

return UNIT_VTABLE(u)unit_vtable[(u)->type]->needs_console(u);

5471

5472

/* If this unit type doesn't implement this call, let's use a generic fallback implementation: */

5473

ec = unit_get_exec_context(u);

5474

if (!ec)

5475

return false0;

5476

5477

return exec_context_may_touch_console(ec);

5478

}

5479

5480

const char *unit_label_path(Unit *u) {

5481

const char *p;

5482

5483

/* Returns the file system path to use for MAC access decisions, i.e. the file to read the SELinux label off

5484

* when validating access checks. */

5485

5486

p = u->source_path ?: u->fragment_path;

5487

if (!p)

5488

return NULL((void*)0);

5489

5490

/* If a unit is masked, then don't read the SELinux label of /dev/null, as that really makes no sense */

5491

if (path_equal(p, "/dev/null"))

5492

return NULL((void*)0);

5493

5494

return p;

5495

}

5496

5497

int unit_pid_attachable(Unit *u, pid_t pid, sd_bus_error *error) {

5498

int r;

5499

5500

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5500, __PRETTY_FUNCTION__
); } while (0);

5501

5502

/* Checks whether the specified PID is generally good for attaching, i.e. a valid PID, not our manager itself,

5503

* and not a kernel thread either */

5504

5505

/* First, a simple range check */

5506

if (!pid_is_valid(pid))

5507

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Process identifier " PID_FMT"%" "i" " is not valid.", pid);

5508

5509

/* Some extra safety check */

5510

if (pid == 1 || pid == getpid_cached())

5511

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Process " PID_FMT"%" "i" " is a manager process, refusing.", pid);

5512

5513

/* Don't even begin to bother with kernel threads */

5514

r = is_kernel_thread(pid);

5515

if (r == -ESRCH3)

5516

return sd_bus_error_setf(error, SD_BUS_ERROR_UNIX_PROCESS_ID_UNKNOWN"org.freedesktop.DBus.Error.UnixProcessIdUnknown", "Process with ID " PID_FMT"%" "i" " does not exist.", pid);

5517

if (r < 0)

5518

return sd_bus_error_set_errnof(error, r, "Failed to determine whether process " PID_FMT"%" "i" " is a kernel thread: %m", pid);

5519

if (r > 0)

5520

return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS"org.freedesktop.DBus.Error.InvalidArgs", "Process " PID_FMT"%" "i" " is a kernel thread, refusing.", pid);

5521

5522

return 0;

5523

}

5524

5525

void unit_log_success(Unit *u) {

5526

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5526, __PRETTY_FUNCTION__
); } while (0);

5527

5528

log_struct(LOG_INFO,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5532, __func__, "MESSAGE_ID=" "7a" "d2"
"d1" "89" "f7" "e9" "4e" "70" "a3" "8c" "78" "13" "54" "91" "24"
"48", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Succeeded.", (u)->id, ((void*)0))

5529

"MESSAGE_ID=" SD_MESSAGE_UNIT_SUCCESS_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5532, __func__, "MESSAGE_ID=" "7a" "d2"
"d1" "89" "f7" "e9" "4e" "70" "a3" "8c" "78" "13" "54" "91" "24"
"48", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Succeeded.", (u)->id, ((void*)0))

5530

LOG_UNIT_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5532, __func__, "MESSAGE_ID=" "7a" "d2"
"d1" "89" "f7" "e9" "4e" "70" "a3" "8c" "78" "13" "54" "91" "24"
"48", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Succeeded.", (u)->id, ((void*)0))

5531

LOG_UNIT_INVOCATION_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5532, __func__, "MESSAGE_ID=" "7a" "d2"
"d1" "89" "f7" "e9" "4e" "70" "a3" "8c" "78" "13" "54" "91" "24"
"48", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Succeeded.", (u)->id, ((void*)0))

5532

LOG_UNIT_MESSAGE(u, "Succeeded."))log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5532, __func__, "MESSAGE_ID=" "7a" "d2"
"d1" "89" "f7" "e9" "4e" "70" "a3" "8c" "78" "13" "54" "91" "24"
"48", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Succeeded.", (u)->id, ((void*)0));

5533

}

5534

5535

void unit_log_failure(Unit *u, const char *result) {

5536

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5536, __PRETTY_FUNCTION__
); } while (0);

5537

assert(result)do { if ((__builtin_expect(!!(!(result)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("result"), "../src/core/unit.c", 5537, __PRETTY_FUNCTION__
); } while (0);

5538

5539

log_struct(LOG_WARNING,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0))

5540

"MESSAGE_ID=" SD_MESSAGE_UNIT_FAILURE_RESULT_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0))

5541

LOG_UNIT_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0))

5542

LOG_UNIT_INVOCATION_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0))

5543

LOG_UNIT_MESSAGE(u, "Failed with result '%s'.", result),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0))

5544

"UNIT_RESULT=%s", result)log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (4)), 0
, "../src/core/unit.c", 5544, __func__, "MESSAGE_ID=" "d9" "b3"
"73" "ed" "55" "a6" "4f" "eb" "82" "42" "e0" "2d" "be" "79" "a4"
"9c", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Failed with result '%s'.", (u)->id, result
, "UNIT_RESULT=%s", result, ((void*)0));

5545

}

5546

5547

void unit_log_skip(Unit *u, const char *result) {

5548

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5548, __PRETTY_FUNCTION__
); } while (0);

5549

assert(result)do { if ((__builtin_expect(!!(!(result)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("result"), "../src/core/unit.c", 5549, __PRETTY_FUNCTION__
); } while (0);

5550

5551

log_struct(LOG_INFO,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0))

5552

"MESSAGE_ID=" SD_MESSAGE_UNIT_SKIPPED_STR,log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0))

5553

LOG_UNIT_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0))

5554

LOG_UNIT_INVOCATION_ID(u),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0))

5555

LOG_UNIT_MESSAGE(u, "Skipped due to '%s'.", result),log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0))

5556

"UNIT_RESULT=%s", result)log_struct_internal(((LOG_REALM_SYSTEMD) << 10 | (6)), 0
, "../src/core/unit.c", 5556, __func__, "MESSAGE_ID=" "0e" "42"
"84" "a0" "ca" "ca" "4b" "fc" "81" "c0" "bb" "67" "86" "97" "26"
"73", (u)->manager->unit_log_format_string, (u)->id
, (u)->manager->invocation_log_format_string, (u)->invocation_id_string
, "MESSAGE=%s: " "Skipped due to '%s'.", (u)->id, result, "UNIT_RESULT=%s"
, result, ((void*)0));

5557

}

5558

5559

bool_Bool unit_can_freeze(Unit *u) {

5560

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5560, __PRETTY_FUNCTION__
); } while (0);

5561

5562

if (UNIT_VTABLE(u)unit_vtable[(u)->type]->can_freeze)

5563

return UNIT_VTABLE(u)unit_vtable[(u)->type]->can_freeze(u);

5564

5565

return UNIT_VTABLE(u)unit_vtable[(u)->type]->freeze;

5566

}

5567

5568

void unit_frozen(Unit *u) {

5569

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5569, __PRETTY_FUNCTION__
); } while (0);

5570

5571

u->freezer_state = FREEZER_FROZEN;

5572

5573

bus_unit_send_pending_freezer_message(u);

5574

}

5575

5576

void unit_thawed(Unit *u) {

5577

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5577, __PRETTY_FUNCTION__
); } while (0);

5578

5579

u->freezer_state = FREEZER_RUNNING;

5580

5581

bus_unit_send_pending_freezer_message(u);

5582

}

5583

5584

static int unit_freezer_action(Unit *u, FreezerAction action) {

5585

UnitActiveState s;

5586

int (*method)(Unit*);

5587

int r;

5588

5589

assert(u)do { if ((__builtin_expect(!!(!(u)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("u"), "../src/core/unit.c", 5589, __PRETTY_FUNCTION__
); } while (0);

5590

assert(IN_SET(action, FREEZER_FREEZE, FREEZER_THAW))do { if ((__builtin_expect(!!(!(({ _Bool _found = 0; static __attribute__
((unused)) char _static_assert__macros_need_to_be_extended[20
- sizeof((int[]){FREEZER_FREEZE, FREEZER_THAW})/sizeof(int)]
; switch(action) { case FREEZER_FREEZE: case FREEZER_THAW: _found
= 1; break; default: break; } _found; }))),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("IN_SET(action, FREEZER_FREEZE, FREEZER_THAW)"
), "../src/core/unit.c", 5590, __PRETTY_FUNCTION__); } while (
0);

5591

5592

method = action == FREEZER_FREEZE ? UNIT_VTABLE(u)unit_vtable[(u)->type]->freeze : UNIT_VTABLE(u)unit_vtable[(u)->type]->thaw;

5593

if (!method || !cg_freezer_supported())

5594

return -EOPNOTSUPP95;

5595

5596

if (u->job)

5597

return -EBUSY16;

5598

5599

if (u->load_state != UNIT_LOADED)

5600

return -EHOSTDOWN112;

5601

5602

s = unit_active_state(u);

5603

if (s != UNIT_ACTIVE)

5604

return -EHOSTDOWN112;

5605

5606

if (IN_SET(u->freezer_state, FREEZER_FREEZING, FREEZER_THAWING)({ _Bool _found = 0; static __attribute__ ((unused)) char _static_assert__macros_need_to_be_extended
[20 - sizeof((int[]){FREEZER_FREEZING, FREEZER_THAWING})/sizeof
(int)]; switch(u->freezer_state) { case FREEZER_FREEZING: case
FREEZER_THAWING: _found = 1; break; default: break; } _found
; }))

5607

return -EALREADY114;

5608

5609

r = method(u);

5610

if (r <= 0)

5611

return r;

5612

5613

return 1;

5614

}

5615

5616

int unit_freeze(Unit *u) {

5617

return unit_freezer_action(u, FREEZER_FREEZE);

5618

}

5619

5620

int unit_thaw(Unit *u) {

5621

return unit_freezer_action(u, FREEZER_THAW);

5622

}

5623

5624

/* Wrappers around low-level cgroup freezer operations common for service and scope units */

5625

int unit_freeze_vtable_common(Unit *u) {

5626

return unit_cgroup_freezer_action(u, FREEZER_FREEZE);

5627

}

5628

5629

int unit_thaw_vtable_common(Unit *u) {

5630

return unit_cgroup_freezer_action(u, FREEZER_THAW);

5631

}

5632

5633

static const char* const collect_mode_table[_COLLECT_MODE_MAX] = {

5634

[COLLECT_INACTIVE] = "inactive",

5635

[COLLECT_INACTIVE_OR_FAILED] = "inactive-or-failed",

5636

};

5637

5638

DEFINE_STRING_TABLE_LOOKUP(collect_mode, CollectMode)const char *collect_mode_to_string(CollectMode i) { if (i <
0 || i >= (CollectMode) __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(collect_mode_table), typeof
(&*(collect_mode_table))), sizeof(collect_mode_table)/sizeof
((collect_mode_table)[0]), ((void)0)))) return ((void*)0); return
collect_mode_table[i]; } CollectMode collect_mode_from_string
(const char *s) { return (CollectMode) string_table_lookup(collect_mode_table
, __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(collect_mode_table), typeof(&*(collect_mode_table
))), sizeof(collect_mode_table)/sizeof((collect_mode_table)[0
]), ((void)0))), s); };

File:	build-scan/../src/core/unit.c
Warning:	line 2520, column 25 Value stored to 'r' is never read

Bug Summary

Annotated Source Code