]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/unit.c
util-lib: move yes_no() and friends to string-util.h
[thirdparty/systemd.git] / src / core / unit.c
CommitLineData
53e1b683 1/* SPDX-License-Identifier: LGPL-2.1+ */
a7334b09 2
87f0e418 3#include <errno.h>
0301abf4 4#include <stdlib.h>
4f5dd394 5#include <string.h>
4c253ed1 6#include <sys/prctl.h>
45fb0699 7#include <sys/stat.h>
4f5dd394 8#include <unistd.h>
87f0e418 9
718db961
LP
10#include "sd-id128.h"
11#include "sd-messages.h"
4f5dd394 12
57b7a260 13#include "all-units.h"
d68c645b 14#include "alloc-util.h"
fab34748 15#include "bpf-firewall.h"
4f5dd394
LP
16#include "bus-common-errors.h"
17#include "bus-util.h"
c6c18be3 18#include "cgroup-util.h"
4f5dd394
LP
19#include "dbus-unit.h"
20#include "dbus.h"
21#include "dropin.h"
22#include "escape.h"
23#include "execute.h"
6a48d82f 24#include "fd-util.h"
a5c32cff 25#include "fileio-label.h"
ee228be1 26#include "fileio.h"
f97b34a6 27#include "format-util.h"
d3070fbd 28#include "fs-util.h"
4b58153d 29#include "id128-util.h"
915b1d01 30#include "io-util.h"
5cfa33e0 31#include "install.h"
4f5dd394
LP
32#include "load-dropin.h"
33#include "load-fragment.h"
34#include "log.h"
35#include "macro.h"
36#include "missing.h"
37#include "mkdir.h"
6bedfcbb 38#include "parse-util.h"
4f5dd394 39#include "path-util.h"
0b452006 40#include "process-util.h"
810ef318 41#include "rm-rf.h"
d68c645b 42#include "serialize.h"
4f5dd394 43#include "set.h"
6eb7c172 44#include "signal-util.h"
d3070fbd 45#include "sparse-endian.h"
e9db43d5 46#include "special.h"
2e59b241 47#include "specifier.h"
8fcde012 48#include "stat-util.h"
d054f0a4 49#include "stdio-util.h"
5afe510c 50#include "string-table.h"
07630cea 51#include "string-util.h"
4f5dd394 52#include "strv.h"
5b262f74 53#include "terminal-util.h"
e4de7287 54#include "tmpfile-util.h"
4f4afc88 55#include "umask-util.h"
4f5dd394 56#include "unit-name.h"
e9db43d5 57#include "unit.h"
b1d4f8e1
LP
58#include "user-util.h"
59#include "virt.h"
87f0e418 60
37109b85
ZJS
61/* Thresholds for logging at INFO level about resource consumption */
62#define MENTIONWORTHY_CPU_NSEC (1 * NSEC_PER_SEC)
63#define MENTIONWORTHY_IO_BYTES (1024 * 1024ULL)
64#define MENTIONWORTHY_IP_BYTES (0ULL)
65
66/* Thresholds for logging at INFO level about resource consumption */
67#define NOTICEWORTHY_CPU_NSEC (10*60 * NSEC_PER_SEC) /* 10 minutes */
68#define NOTICEWORTHY_IO_BYTES (10 * 1024 * 1024ULL) /* 10 MB */
69#define NOTICEWORTHY_IP_BYTES (128 * 1024 * 1024ULL) /* 128 MB */
70
87f0e418
LP
71const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
72 [UNIT_SERVICE] = &service_vtable,
87f0e418
LP
73 [UNIT_SOCKET] = &socket_vtable,
74 [UNIT_TARGET] = &target_vtable,
75 [UNIT_DEVICE] = &device_vtable,
76 [UNIT_MOUNT] = &mount_vtable,
77 [UNIT_AUTOMOUNT] = &automount_vtable,
01f78473 78 [UNIT_SWAP] = &swap_vtable,
e821075a 79 [UNIT_TIMER] = &timer_vtable,
a016b922 80 [UNIT_PATH] = &path_vtable,
6c12b52e 81 [UNIT_SLICE] = &slice_vtable,
5afe510c 82 [UNIT_SCOPE] = &scope_vtable,
87f0e418
LP
83};
84
f2341e0a 85static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency);
d1fab3fe 86
7d17cfbc 87Unit *unit_new(Manager *m, size_t size) {
87f0e418
LP
88 Unit *u;
89
90 assert(m);
ac155bb8 91 assert(size >= sizeof(Unit));
87f0e418 92
7d17cfbc
MS
93 u = malloc0(size);
94 if (!u)
87f0e418
LP
95 return NULL;
96
d5099efc 97 u->names = set_new(&string_hash_ops);
6b430fdb
ZJS
98 if (!u->names)
99 return mfree(u);
87f0e418 100
ac155bb8
MS
101 u->manager = m;
102 u->type = _UNIT_TYPE_INVALID;
ac155bb8
MS
103 u->default_dependencies = true;
104 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
d2dc52db 105 u->unit_file_preset = -1;
d420282b 106 u->on_failure_job_mode = JOB_REPLACE;
0bb814c2 107 u->cgroup_control_inotify_wd = -1;
afcfaa69 108 u->cgroup_memory_inotify_wd = -1;
36c16a7c 109 u->job_timeout = USEC_INFINITY;
a2df3ea4 110 u->job_running_timeout = USEC_INFINITY;
00d9ef85
LP
111 u->ref_uid = UID_INVALID;
112 u->ref_gid = GID_INVALID;
fe700f46 113 u->cpu_usage_last = NSEC_INFINITY;
17f14955 114 u->cgroup_invalidated_mask |= CGROUP_MASK_BPF_FIREWALL;
7af67e9a 115 u->failure_action_exit_status = u->success_action_exit_status = -1;
87f0e418 116
6a48d82f
DM
117 u->ip_accounting_ingress_map_fd = -1;
118 u->ip_accounting_egress_map_fd = -1;
119 u->ipv4_allow_map_fd = -1;
120 u->ipv6_allow_map_fd = -1;
121 u->ipv4_deny_map_fd = -1;
122 u->ipv6_deny_map_fd = -1;
123
2e59b241
LP
124 u->last_section_private = -1;
125
6bf0f408 126 RATELIMIT_INIT(u->start_limit, m->default_start_limit_interval, m->default_start_limit_burst);
67bfdc97 127 RATELIMIT_INIT(u->auto_stop_ratelimit, 10 * USEC_PER_SEC, 16);
bea355da 128
fbe14fc9
LP
129 for (CGroupIOAccountingMetric i = 0; i < _CGROUP_IO_ACCOUNTING_METRIC_MAX; i++)
130 u->io_accounting_last[i] = UINT64_MAX;
131
87f0e418
LP
132 return u;
133}
134
a581e45a 135int unit_new_for_name(Manager *m, size_t size, const char *name, Unit **ret) {
dc409696 136 _cleanup_(unit_freep) Unit *u = NULL;
a581e45a
LP
137 int r;
138
139 u = unit_new(m, size);
140 if (!u)
141 return -ENOMEM;
142
143 r = unit_add_name(u, name);
dc409696 144 if (r < 0)
a581e45a 145 return r;
a581e45a 146
1cc6c93a
YW
147 *ret = TAKE_PTR(u);
148
a581e45a
LP
149 return r;
150}
151
303ee601 152bool unit_has_name(const Unit *u, const char *name) {
f278026d
LP
153 assert(u);
154 assert(name);
155
390bc2b1 156 return set_contains(u->names, (char*) name);
f278026d
LP
157}
158
598459ce
LP
159static void unit_init(Unit *u) {
160 CGroupContext *cc;
161 ExecContext *ec;
162 KillContext *kc;
163
164 assert(u);
165 assert(u->manager);
166 assert(u->type >= 0);
167
168 cc = unit_get_cgroup_context(u);
169 if (cc) {
170 cgroup_context_init(cc);
171
172 /* Copy in the manager defaults into the cgroup
173 * context, _before_ the rest of the settings have
174 * been initialized */
175
176 cc->cpu_accounting = u->manager->default_cpu_accounting;
13c31542 177 cc->io_accounting = u->manager->default_io_accounting;
598459ce
LP
178 cc->blockio_accounting = u->manager->default_blockio_accounting;
179 cc->memory_accounting = u->manager->default_memory_accounting;
03a7b521 180 cc->tasks_accounting = u->manager->default_tasks_accounting;
6a48d82f 181 cc->ip_accounting = u->manager->default_ip_accounting;
0af20ea2
LP
182
183 if (u->type != UNIT_SLICE)
184 cc->tasks_max = u->manager->default_tasks_max;
598459ce
LP
185 }
186
187 ec = unit_get_exec_context(u);
b1edf445 188 if (ec) {
598459ce
LP
189 exec_context_init(ec);
190
b1edf445 191 ec->keyring_mode = MANAGER_IS_SYSTEM(u->manager) ?
00f5ad93 192 EXEC_KEYRING_SHARED : EXEC_KEYRING_INHERIT;
b1edf445
LP
193 }
194
598459ce
LP
195 kc = unit_get_kill_context(u);
196 if (kc)
197 kill_context_init(kc);
198
199 if (UNIT_VTABLE(u)->init)
200 UNIT_VTABLE(u)->init(u);
201}
202
87f0e418 203int unit_add_name(Unit *u, const char *text) {
598459ce 204 _cleanup_free_ char *s = NULL, *i = NULL;
87f0e418 205 UnitType t;
87f0e418
LP
206 int r;
207
208 assert(u);
209 assert(text);
210
7410616c 211 if (unit_name_is_valid(text, UNIT_NAME_TEMPLATE)) {
598459ce 212
ac155bb8 213 if (!u->instance)
9e2f7c11 214 return -EINVAL;
87f0e418 215
7410616c
LP
216 r = unit_name_replace_instance(text, u->instance, &s);
217 if (r < 0)
218 return r;
219 } else {
9e2f7c11 220 s = strdup(text);
7410616c
LP
221 if (!s)
222 return -ENOMEM;
223 }
87f0e418 224
7410616c
LP
225 if (set_contains(u->names, s))
226 return 0;
227 if (hashmap_contains(u->manager->units, s))
228 return -EEXIST;
229
230 if (!unit_name_is_valid(s, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
598459ce 231 return -EINVAL;
e537352b 232
7410616c
LP
233 t = unit_name_to_type(s);
234 if (t < 0)
235 return -EINVAL;
87f0e418 236
598459ce
LP
237 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
238 return -EINVAL;
87f0e418 239
e48614c4
ZJS
240 r = unit_name_to_instance(s, &i);
241 if (r < 0)
598459ce 242 return r;
87f0e418 243
ce99c68a 244 if (i && !unit_type_may_template(t))
598459ce 245 return -EINVAL;
9e2f7c11 246
276c3e78 247 /* Ensure that this unit is either instanced or not instanced,
7410616c
LP
248 * but not both. Note that we do allow names with different
249 * instance names however! */
598459ce
LP
250 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
251 return -EINVAL;
9e2f7c11 252
8a993b61 253 if (!unit_type_may_alias(t) && !set_isempty(u->names))
598459ce 254 return -EEXIST;
9e2f7c11 255
598459ce
LP
256 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
257 return -E2BIG;
4f0f902f 258
e48614c4 259 r = set_put(u->names, s);
7410616c 260 if (r < 0)
598459ce 261 return r;
7410616c 262 assert(r > 0);
87f0e418 263
e48614c4
ZJS
264 r = hashmap_put(u->manager->units, s, u);
265 if (r < 0) {
7410616c 266 (void) set_remove(u->names, s);
598459ce 267 return r;
87f0e418
LP
268 }
269
ac155bb8 270 if (u->type == _UNIT_TYPE_INVALID) {
ac155bb8
MS
271 u->type = t;
272 u->id = s;
1cc6c93a 273 u->instance = TAKE_PTR(i);
9e2f7c11 274
71fda00f 275 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
e537352b 276
598459ce 277 unit_init(u);
598459ce 278 }
9e2f7c11 279
598459ce 280 s = NULL;
9e2f7c11 281
598459ce
LP
282 unit_add_to_dbus_queue(u);
283 return 0;
87f0e418
LP
284}
285
0ae97ec1 286int unit_choose_id(Unit *u, const char *name) {
68eda4bd 287 _cleanup_free_ char *t = NULL;
598459ce 288 char *s, *i;
276c3e78 289 int r;
0ae97ec1
LP
290
291 assert(u);
292 assert(name);
293
7410616c 294 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
9e2f7c11 295
ac155bb8 296 if (!u->instance)
9e2f7c11
LP
297 return -EINVAL;
298
7410616c
LP
299 r = unit_name_replace_instance(name, u->instance, &t);
300 if (r < 0)
301 return r;
9e2f7c11
LP
302
303 name = t;
304 }
305
0ae97ec1 306 /* Selects one of the names of this unit as the id */
ac155bb8 307 s = set_get(u->names, (char*) name);
9e2f7c11 308 if (!s)
0ae97ec1
LP
309 return -ENOENT;
310
7410616c 311 /* Determine the new instance from the new id */
e48614c4
ZJS
312 r = unit_name_to_instance(s, &i);
313 if (r < 0)
276c3e78
LP
314 return r;
315
ac155bb8 316 u->id = s;
276c3e78 317
ac155bb8
MS
318 free(u->instance);
319 u->instance = i;
276c3e78 320
c1e1601e 321 unit_add_to_dbus_queue(u);
9e2f7c11 322
0ae97ec1
LP
323 return 0;
324}
325
f50e0a01 326int unit_set_description(Unit *u, const char *description) {
84b26d51 327 int r;
f50e0a01
LP
328
329 assert(u);
330
84b26d51
LP
331 r = free_and_strdup(&u->description, empty_to_null(description));
332 if (r < 0)
333 return r;
334 if (r > 0)
335 unit_add_to_dbus_queue(u);
c1e1601e 336
f50e0a01
LP
337 return 0;
338}
339
f2f725e5 340bool unit_may_gc(Unit *u) {
a354329f 341 UnitActiveState state;
e98b2fbb 342 int r;
5afe510c 343
701cc384
LP
344 assert(u);
345
f2f725e5
ZJS
346 /* Checks whether the unit is ready to be unloaded for garbage collection.
347 * Returns true when the unit may be collected, and false if there's some
2641f02e
ZJS
348 * reason to keep it loaded.
349 *
350 * References from other units are *not* checked here. Instead, this is done
351 * in unit_gc_sweep(), but using markers to properly collect dependency loops.
352 */
5afe510c 353
a354329f 354 if (u->job)
f2f725e5 355 return false;
701cc384 356
a354329f 357 if (u->nop_job)
f2f725e5 358 return false;
6c073082 359
a354329f
LP
360 state = unit_active_state(u);
361
7eb2a8a1 362 /* If the unit is inactive and failed and no job is queued for it, then release its runtime resources */
a354329f
LP
363 if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
364 UNIT_VTABLE(u)->release_resources)
7eb2a8a1 365 UNIT_VTABLE(u)->release_resources(u);
a354329f 366
f5869324 367 if (u->perpetual)
f2f725e5 368 return false;
9d576438 369
05a98afd 370 if (sd_bus_track_count(u->bus_track) > 0)
f2f725e5 371 return false;
05a98afd 372
5afe510c
LP
373 /* But we keep the unit object around for longer when it is referenced or configured to not be gc'ed */
374 switch (u->collect_mode) {
375
376 case COLLECT_INACTIVE:
377 if (state != UNIT_INACTIVE)
f2f725e5 378 return false;
5afe510c
LP
379
380 break;
381
382 case COLLECT_INACTIVE_OR_FAILED:
383 if (!IN_SET(state, UNIT_INACTIVE, UNIT_FAILED))
f2f725e5 384 return false;
5afe510c
LP
385
386 break;
387
388 default:
389 assert_not_reached("Unknown garbage collection mode");
390 }
391
e98b2fbb
LP
392 if (u->cgroup_path) {
393 /* If the unit has a cgroup, then check whether there's anything in it. If so, we should stay
394 * around. Units with active processes should never be collected. */
395
396 r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path);
397 if (r < 0)
398 log_unit_debug_errno(u, r, "Failed to determine whether cgroup %s is empty: %m", u->cgroup_path);
399 if (r <= 0)
f2f725e5 400 return false;
e98b2fbb
LP
401 }
402
f2f725e5
ZJS
403 if (UNIT_VTABLE(u)->may_gc && !UNIT_VTABLE(u)->may_gc(u))
404 return false;
701cc384 405
f2f725e5 406 return true;
701cc384
LP
407}
408
87f0e418
LP
409void unit_add_to_load_queue(Unit *u) {
410 assert(u);
ac155bb8 411 assert(u->type != _UNIT_TYPE_INVALID);
87f0e418 412
ac155bb8 413 if (u->load_state != UNIT_STUB || u->in_load_queue)
87f0e418
LP
414 return;
415
71fda00f 416 LIST_PREPEND(load_queue, u->manager->load_queue, u);
ac155bb8 417 u->in_load_queue = true;
87f0e418
LP
418}
419
23a177ef
LP
420void unit_add_to_cleanup_queue(Unit *u) {
421 assert(u);
422
ac155bb8 423 if (u->in_cleanup_queue)
23a177ef
LP
424 return;
425
71fda00f 426 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
ac155bb8 427 u->in_cleanup_queue = true;
23a177ef
LP
428}
429
701cc384
LP
430void unit_add_to_gc_queue(Unit *u) {
431 assert(u);
432
ac155bb8 433 if (u->in_gc_queue || u->in_cleanup_queue)
701cc384
LP
434 return;
435
f2f725e5 436 if (!unit_may_gc(u))
701cc384
LP
437 return;
438
c5a97ed1 439 LIST_PREPEND(gc_queue, u->manager->gc_unit_queue, u);
ac155bb8 440 u->in_gc_queue = true;
701cc384
LP
441}
442
c1e1601e
LP
443void unit_add_to_dbus_queue(Unit *u) {
444 assert(u);
ac155bb8 445 assert(u->type != _UNIT_TYPE_INVALID);
c1e1601e 446
ac155bb8 447 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
c1e1601e
LP
448 return;
449
a567261a 450 /* Shortcut things if nobody cares */
8f8f05a9 451 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
ae572acd 452 sd_bus_track_count(u->bus_track) <= 0 &&
8f8f05a9 453 set_isempty(u->manager->private_buses)) {
ac155bb8 454 u->sent_dbus_new_signal = true;
94b6dfa2
LP
455 return;
456 }
457
71fda00f 458 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
ac155bb8 459 u->in_dbus_queue = true;
c1e1601e
LP
460}
461
fda09318 462void unit_submit_to_stop_when_unneeded_queue(Unit *u) {
a3c1168a
LP
463 assert(u);
464
465 if (u->in_stop_when_unneeded_queue)
466 return;
467
468 if (!u->stop_when_unneeded)
469 return;
470
471 if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
472 return;
473
474 LIST_PREPEND(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u);
475 u->in_stop_when_unneeded_queue = true;
476}
477
eef85c4a 478static void bidi_set_free(Unit *u, Hashmap *h) {
87f0e418 479 Unit *other;
eef85c4a
LP
480 Iterator i;
481 void *v;
87f0e418
LP
482
483 assert(u);
484
eef85c4a 485 /* Frees the hashmap and makes sure we are dropped from the inverse pointers */
87f0e418 486
eef85c4a 487 HASHMAP_FOREACH_KEY(v, other, h, i) {
87f0e418
LP
488 UnitDependency d;
489
490 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
eef85c4a 491 hashmap_remove(other->dependencies[d], u);
701cc384
LP
492
493 unit_add_to_gc_queue(other);
87f0e418
LP
494 }
495
eef85c4a 496 hashmap_free(h);
87f0e418
LP
497}
498
c2756a68
LP
499static void unit_remove_transient(Unit *u) {
500 char **i;
501
502 assert(u);
503
504 if (!u->transient)
505 return;
506
507 if (u->fragment_path)
3f5e8115 508 (void) unlink(u->fragment_path);
c2756a68
LP
509
510 STRV_FOREACH(i, u->dropin_paths) {
39591351 511 _cleanup_free_ char *p = NULL, *pp = NULL;
c2756a68 512
39591351
LP
513 p = dirname_malloc(*i); /* Get the drop-in directory from the drop-in file */
514 if (!p)
515 continue;
516
517 pp = dirname_malloc(p); /* Get the config directory from the drop-in directory */
518 if (!pp)
519 continue;
520
521 /* Only drop transient drop-ins */
522 if (!path_equal(u->manager->lookup_paths.transient, pp))
523 continue;
c2756a68 524
39591351
LP
525 (void) unlink(*i);
526 (void) rmdir(p);
c2756a68
LP
527 }
528}
529
a57f7e2c 530static void unit_free_requires_mounts_for(Unit *u) {
eef85c4a 531 assert(u);
a57f7e2c 532
eef85c4a
LP
533 for (;;) {
534 _cleanup_free_ char *path;
a57f7e2c 535
eef85c4a
LP
536 path = hashmap_steal_first_key(u->requires_mounts_for);
537 if (!path)
538 break;
539 else {
540 char s[strlen(path) + 1];
a57f7e2c 541
eef85c4a
LP
542 PATH_FOREACH_PREFIX_MORE(s, path) {
543 char *y;
544 Set *x;
545
546 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
547 if (!x)
548 continue;
a57f7e2c 549
eef85c4a 550 (void) set_remove(x, u);
a57f7e2c 551
eef85c4a
LP
552 if (set_isempty(x)) {
553 (void) hashmap_remove(u->manager->units_requiring_mounts_for, y);
554 free(y);
555 set_free(x);
556 }
a57f7e2c
LP
557 }
558 }
559 }
560
eef85c4a 561 u->requires_mounts_for = hashmap_free(u->requires_mounts_for);
a57f7e2c
LP
562}
563
598459ce
LP
564static void unit_done(Unit *u) {
565 ExecContext *ec;
566 CGroupContext *cc;
567
568 assert(u);
569
570 if (u->type < 0)
571 return;
572
573 if (UNIT_VTABLE(u)->done)
574 UNIT_VTABLE(u)->done(u);
575
576 ec = unit_get_exec_context(u);
577 if (ec)
578 exec_context_done(ec);
579
580 cc = unit_get_cgroup_context(u);
581 if (cc)
582 cgroup_context_done(cc);
583}
584
87f0e418
LP
585void unit_free(Unit *u) {
586 UnitDependency d;
587 Iterator i;
588 char *t;
589
c9d5c9c0
LP
590 if (!u)
591 return;
87f0e418 592
b8b6f321
LP
593 if (UNIT_ISSET(u->slice)) {
594 /* A unit is being dropped from the tree, make sure our parent slice recalculates the member mask */
595 unit_invalidate_cgroup_members_masks(UNIT_DEREF(u->slice));
596
597 /* And make sure the parent is realized again, updating cgroup memberships */
598 unit_add_to_cgroup_realize_queue(UNIT_DEREF(u->slice));
599 }
600
50fb00b7 601 u->transient_file = safe_fclose(u->transient_file);
4f4afc88 602
2c289ea8 603 if (!MANAGER_IS_RELOADING(u->manager))
c2756a68
LP
604 unit_remove_transient(u);
605
c1e1601e
LP
606 bus_unit_send_removed_signal(u);
607
598459ce 608 unit_done(u);
a013b84b 609
50be4f4a 610 unit_dequeue_rewatch_pids(u);
cf9fd508 611
50be4f4a 612 sd_bus_slot_unref(u->match_bus_slot);
05a98afd
LP
613 sd_bus_track_unref(u->bus_track);
614 u->deserialized_refs = strv_free(u->deserialized_refs);
615
a57f7e2c
LP
616 unit_free_requires_mounts_for(u);
617
ac155bb8
MS
618 SET_FOREACH(t, u->names, i)
619 hashmap_remove_value(u->manager->units, t, u);
87f0e418 620
4b58153d
LP
621 if (!sd_id128_is_null(u->invocation_id))
622 hashmap_remove_value(u->manager->units_by_invocation_id, &u->invocation_id, u);
623
97e7d748
MS
624 if (u->job) {
625 Job *j = u->job;
626 job_uninstall(j);
627 job_free(j);
628 }
964e0949 629
e0209d83
MS
630 if (u->nop_job) {
631 Job *j = u->nop_job;
632 job_uninstall(j);
633 job_free(j);
634 }
635
964e0949 636 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
ac155bb8 637 bidi_set_free(u, u->dependencies[d]);
964e0949 638
adefcf28
LP
639 if (u->on_console)
640 manager_unref_console(u->manager);
641
efdb0237 642 unit_release_cgroup(u);
72673e86 643
d3070fbd
LP
644 if (!MANAGER_IS_RELOADING(u->manager))
645 unit_unlink_state_files(u);
646
00d9ef85
LP
647 unit_unref_uid_gid(u, false);
648
5269eb6b 649 (void) manager_update_failed_units(u->manager, u, false);
db785129 650 set_remove(u->manager->startup_units, u);
f755e3b7 651
a911bb9a
LP
652 unit_unwatch_all_pids(u);
653
702a2d8f 654 unit_ref_unset(&u->slice);
7f7d01ed
ZJS
655 while (u->refs_by_target)
656 unit_ref_unset(u->refs_by_target);
57020a3a 657
ac155bb8 658 if (u->type != _UNIT_TYPE_INVALID)
71fda00f 659 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
ef734fd6 660
ac155bb8 661 if (u->in_load_queue)
71fda00f 662 LIST_REMOVE(load_queue, u->manager->load_queue, u);
87f0e418 663
ac155bb8 664 if (u->in_dbus_queue)
71fda00f 665 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
c1e1601e 666
a2d72e26 667 if (u->in_gc_queue)
c5a97ed1 668 LIST_REMOVE(gc_queue, u->manager->gc_unit_queue, u);
701cc384 669
91a6073e
LP
670 if (u->in_cgroup_realize_queue)
671 LIST_REMOVE(cgroup_realize_queue, u->manager->cgroup_realize_queue, u);
87f0e418 672
09e24654
LP
673 if (u->in_cgroup_empty_queue)
674 LIST_REMOVE(cgroup_empty_queue, u->manager->cgroup_empty_queue, u);
675
1bdf2790
ZJS
676 if (u->in_cleanup_queue)
677 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
adefcf28 678
19496554
MS
679 if (u->in_target_deps_queue)
680 LIST_REMOVE(target_deps_queue, u->manager->target_deps_queue, u);
681
a3c1168a
LP
682 if (u->in_stop_when_unneeded_queue)
683 LIST_REMOVE(stop_when_unneeded_queue, u->manager->stop_when_unneeded_queue, u);
684
6a48d82f
DM
685 safe_close(u->ip_accounting_ingress_map_fd);
686 safe_close(u->ip_accounting_egress_map_fd);
72673e86 687
6a48d82f
DM
688 safe_close(u->ipv4_allow_map_fd);
689 safe_close(u->ipv6_allow_map_fd);
690 safe_close(u->ipv4_deny_map_fd);
691 safe_close(u->ipv6_deny_map_fd);
d3070fbd 692
6a48d82f 693 bpf_program_unref(u->ip_bpf_ingress);
aa2b6f1d 694 bpf_program_unref(u->ip_bpf_ingress_installed);
6a48d82f 695 bpf_program_unref(u->ip_bpf_egress);
aa2b6f1d 696 bpf_program_unref(u->ip_bpf_egress_installed);
00d9ef85 697
fab34748
KL
698 set_free(u->ip_bpf_custom_ingress);
699 set_free(u->ip_bpf_custom_egress);
700 set_free(u->ip_bpf_custom_ingress_installed);
701 set_free(u->ip_bpf_custom_egress_installed);
702
084c7007
RG
703 bpf_program_unref(u->bpf_device_control_installed);
704
a946fa9b
ZJS
705 condition_free_list(u->conditions);
706 condition_free_list(u->asserts);
f755e3b7 707
ac155bb8 708 free(u->description);
49dbfa7b 709 strv_free(u->documentation);
ac155bb8 710 free(u->fragment_path);
1b64d026 711 free(u->source_path);
ae7a7182 712 strv_free(u->dropin_paths);
ac155bb8 713 free(u->instance);
87f0e418 714
f189ab18
LP
715 free(u->job_timeout_reboot_arg);
716
ac155bb8 717 set_free_free(u->names);
87f0e418 718
6bf0f408
LP
719 free(u->reboot_arg);
720
87f0e418
LP
721 free(u);
722}
723
724UnitActiveState unit_active_state(Unit *u) {
725 assert(u);
726
ac155bb8 727 if (u->load_state == UNIT_MERGED)
6124958c
LP
728 return unit_active_state(unit_follow_merge(u));
729
730 /* After a reload it might happen that a unit is not correctly
731 * loaded but still has a process around. That's why we won't
fdf20a31 732 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
87f0e418
LP
733
734 return UNIT_VTABLE(u)->active_state(u);
735}
736
10a94420
LP
737const char* unit_sub_state_to_string(Unit *u) {
738 assert(u);
739
740 return UNIT_VTABLE(u)->sub_state_to_string(u);
741}
742
eef85c4a
LP
743static int set_complete_move(Set **s, Set **other) {
744 assert(s);
745 assert(other);
746
747 if (!other)
748 return 0;
749
750 if (*s)
751 return set_move(*s, *other);
ae2a15bc
LP
752 else
753 *s = TAKE_PTR(*other);
7c0b05e5 754
eef85c4a
LP
755 return 0;
756}
757
758static int hashmap_complete_move(Hashmap **s, Hashmap **other) {
23a177ef
LP
759 assert(s);
760 assert(other);
87f0e418 761
23a177ef 762 if (!*other)
7c0b05e5 763 return 0;
87f0e418 764
eef85c4a
LP
765 if (*s)
766 return hashmap_move(*s, *other);
ae2a15bc
LP
767 else
768 *s = TAKE_PTR(*other);
7c0b05e5
MS
769
770 return 0;
23a177ef 771}
87f0e418 772
7c0b05e5 773static int merge_names(Unit *u, Unit *other) {
23a177ef
LP
774 char *t;
775 Iterator i;
7c0b05e5 776 int r;
87f0e418 777
23a177ef
LP
778 assert(u);
779 assert(other);
780
eef85c4a 781 r = set_complete_move(&u->names, &other->names);
7c0b05e5
MS
782 if (r < 0)
783 return r;
23a177ef 784
ac155bb8
MS
785 set_free_free(other->names);
786 other->names = NULL;
787 other->id = NULL;
23a177ef 788
ac155bb8
MS
789 SET_FOREACH(t, u->names, i)
790 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
7c0b05e5
MS
791
792 return 0;
87f0e418
LP
793}
794
09a65f92
MS
795static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
796 unsigned n_reserve;
797
798 assert(u);
799 assert(other);
800 assert(d < _UNIT_DEPENDENCY_MAX);
801
802 /*
803 * If u does not have this dependency set allocated, there is no need
f131770b 804 * to reserve anything. In that case other's set will be transferred
09a65f92
MS
805 * as a whole to u by complete_move().
806 */
807 if (!u->dependencies[d])
808 return 0;
809
810 /* merge_dependencies() will skip a u-on-u dependency */
eef85c4a 811 n_reserve = hashmap_size(other->dependencies[d]) - !!hashmap_get(other->dependencies[d], u);
09a65f92 812
eef85c4a 813 return hashmap_reserve(u->dependencies[d], n_reserve);
09a65f92
MS
814}
815
d1fab3fe 816static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
23a177ef
LP
817 Iterator i;
818 Unit *back;
eef85c4a 819 void *v;
87f0e418 820 int r;
23a177ef 821
eef85c4a
LP
822 /* Merges all dependencies of type 'd' of the unit 'other' into the deps of the unit 'u' */
823
23a177ef
LP
824 assert(u);
825 assert(other);
826 assert(d < _UNIT_DEPENDENCY_MAX);
827
5238e957 828 /* Fix backwards pointers. Let's iterate through all dependent units of the other unit. */
eef85c4a 829 HASHMAP_FOREACH_KEY(v, back, other->dependencies[d], i) {
23a177ef
LP
830 UnitDependency k;
831
eef85c4a
LP
832 /* Let's now iterate through the dependencies of that dependencies of the other units, looking for
833 * pointers back, and let's fix them up, to instead point to 'u'. */
834
e48614c4 835 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
e66047ff 836 if (back == u) {
eef85c4a
LP
837 /* Do not add dependencies between u and itself. */
838 if (hashmap_remove(back->dependencies[k], other))
f2341e0a 839 maybe_warn_about_dependency(u, other_id, k);
e66047ff 840 } else {
eef85c4a
LP
841 UnitDependencyInfo di_u, di_other, di_merged;
842
843 /* Let's drop this dependency between "back" and "other", and let's create it between
844 * "back" and "u" instead. Let's merge the bit masks of the dependency we are moving,
845 * and any such dependency which might already exist */
846
847 di_other.data = hashmap_get(back->dependencies[k], other);
848 if (!di_other.data)
849 continue; /* dependency isn't set, let's try the next one */
850
851 di_u.data = hashmap_get(back->dependencies[k], u);
852
853 di_merged = (UnitDependencyInfo) {
854 .origin_mask = di_u.origin_mask | di_other.origin_mask,
855 .destination_mask = di_u.destination_mask | di_other.destination_mask,
856 };
857
858 r = hashmap_remove_and_replace(back->dependencies[k], other, u, di_merged.data);
859 if (r < 0)
860 log_warning_errno(r, "Failed to remove/replace: back=%s other=%s u=%s: %m", back->id, other_id, u->id);
861 assert(r >= 0);
862
863 /* assert_se(hashmap_remove_and_replace(back->dependencies[k], other, u, di_merged.data) >= 0); */
e66047ff 864 }
e48614c4 865 }
eef85c4a 866
23a177ef
LP
867 }
868
e66047ff 869 /* Also do not move dependencies on u to itself */
eef85c4a 870 back = hashmap_remove(other->dependencies[d], u);
d1fab3fe 871 if (back)
f2341e0a 872 maybe_warn_about_dependency(u, other_id, d);
e66047ff 873
7c0b05e5 874 /* The move cannot fail. The caller must have performed a reservation. */
eef85c4a 875 assert_se(hashmap_complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
23a177ef 876
eef85c4a 877 other->dependencies[d] = hashmap_free(other->dependencies[d]);
23a177ef
LP
878}
879
880int unit_merge(Unit *u, Unit *other) {
87f0e418 881 UnitDependency d;
d1fab3fe 882 const char *other_id = NULL;
09a65f92 883 int r;
87f0e418
LP
884
885 assert(u);
886 assert(other);
ac155bb8
MS
887 assert(u->manager == other->manager);
888 assert(u->type != _UNIT_TYPE_INVALID);
87f0e418 889
cc916967
LP
890 other = unit_follow_merge(other);
891
23a177ef
LP
892 if (other == u)
893 return 0;
894
ac155bb8 895 if (u->type != other->type)
9e2f7c11
LP
896 return -EINVAL;
897
ac155bb8 898 if (!u->instance != !other->instance)
87f0e418
LP
899 return -EINVAL;
900
8a993b61 901 if (!unit_type_may_alias(u->type)) /* Merging only applies to unit names that support aliases */
934e749e
LP
902 return -EEXIST;
903
ec2ce0c5 904 if (!IN_SET(other->load_state, UNIT_STUB, UNIT_NOT_FOUND))
23a177ef 905 return -EEXIST;
87f0e418 906
ac155bb8 907 if (other->job)
819e213f
LP
908 return -EEXIST;
909
e0209d83
MS
910 if (other->nop_job)
911 return -EEXIST;
912
fdf20a31 913 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
819e213f
LP
914 return -EEXIST;
915
d1fab3fe
ZJS
916 if (other->id)
917 other_id = strdupa(other->id);
918
09a65f92
MS
919 /* Make reservations to ensure merge_dependencies() won't fail */
920 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
921 r = reserve_dependencies(u, other, d);
922 /*
923 * We don't rollback reservations if we fail. We don't have
924 * a way to undo reservations. A reservation is not a leak.
925 */
926 if (r < 0)
927 return r;
928 }
929
87f0e418 930 /* Merge names */
7c0b05e5
MS
931 r = merge_names(u, other);
932 if (r < 0)
933 return r;
87f0e418 934
57020a3a 935 /* Redirect all references */
7f7d01ed
ZJS
936 while (other->refs_by_target)
937 unit_ref_set(other->refs_by_target, other->refs_by_target->source, u);
57020a3a 938
87f0e418
LP
939 /* Merge dependencies */
940 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
d1fab3fe 941 merge_dependencies(u, other, other_id, d);
87f0e418 942
ac155bb8
MS
943 other->load_state = UNIT_MERGED;
944 other->merged_into = u;
23a177ef 945
3616a49c
LP
946 /* If there is still some data attached to the other node, we
947 * don't need it anymore, and can free it. */
ac155bb8 948 if (other->load_state != UNIT_STUB)
3616a49c
LP
949 if (UNIT_VTABLE(other)->done)
950 UNIT_VTABLE(other)->done(other);
951
952 unit_add_to_dbus_queue(u);
23a177ef
LP
953 unit_add_to_cleanup_queue(other);
954
955 return 0;
956}
957
958int unit_merge_by_name(Unit *u, const char *name) {
934e749e 959 _cleanup_free_ char *s = NULL;
23a177ef 960 Unit *other;
9e2f7c11 961 int r;
23a177ef 962
e8630e69
ZJS
963 /* Either add name to u, or if a unit with name already exists, merge it with u.
964 * If name is a template, do the same for name@instance, where instance is u's instance. */
965
23a177ef
LP
966 assert(u);
967 assert(name);
968
7410616c 969 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
ac155bb8 970 if (!u->instance)
9e2f7c11
LP
971 return -EINVAL;
972
7410616c
LP
973 r = unit_name_replace_instance(name, u->instance, &s);
974 if (r < 0)
975 return r;
9e2f7c11
LP
976
977 name = s;
978 }
979
c2756a68 980 other = manager_get_unit(u->manager, name);
7410616c
LP
981 if (other)
982 return unit_merge(u, other);
23a177ef 983
7410616c 984 return unit_add_name(u, name);
23a177ef
LP
985}
986
987Unit* unit_follow_merge(Unit *u) {
988 assert(u);
989
ac155bb8
MS
990 while (u->load_state == UNIT_MERGED)
991 assert_se(u = u->merged_into);
23a177ef
LP
992
993 return u;
994}
995
996int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
ada5e276
YW
997 ExecDirectoryType dt;
998 char **dp;
23a177ef
LP
999 int r;
1000
1001 assert(u);
1002 assert(c);
1003
e1e74614 1004 if (c->working_directory && !c->working_directory_missing_ok) {
eef85c4a 1005 r = unit_require_mounts_for(u, c->working_directory, UNIT_DEPENDENCY_FILE);
36be24c8
ZJS
1006 if (r < 0)
1007 return r;
1008 }
1009
1010 if (c->root_directory) {
eef85c4a 1011 r = unit_require_mounts_for(u, c->root_directory, UNIT_DEPENDENCY_FILE);
36be24c8
ZJS
1012 if (r < 0)
1013 return r;
1014 }
1015
915e6d16 1016 if (c->root_image) {
eef85c4a 1017 r = unit_require_mounts_for(u, c->root_image, UNIT_DEPENDENCY_FILE);
915e6d16
LP
1018 if (r < 0)
1019 return r;
1020 }
1021
72fd1768 1022 for (dt = 0; dt < _EXEC_DIRECTORY_TYPE_MAX; dt++) {
ada5e276
YW
1023 if (!u->manager->prefix[dt])
1024 continue;
1025
1026 STRV_FOREACH(dp, c->directories[dt].paths) {
1027 _cleanup_free_ char *p;
1028
657ee2d8 1029 p = path_join(u->manager->prefix[dt], *dp);
ada5e276
YW
1030 if (!p)
1031 return -ENOMEM;
1032
eef85c4a 1033 r = unit_require_mounts_for(u, p, UNIT_DEPENDENCY_FILE);
ada5e276
YW
1034 if (r < 0)
1035 return r;
1036 }
1037 }
1038
463d0d15 1039 if (!MANAGER_IS_SYSTEM(u->manager))
b46a529c
LP
1040 return 0;
1041
1042 if (c->private_tmp) {
d71f0505
LP
1043 const char *p;
1044
1045 FOREACH_STRING(p, "/tmp", "/var/tmp") {
eef85c4a 1046 r = unit_require_mounts_for(u, p, UNIT_DEPENDENCY_FILE);
d71f0505
LP
1047 if (r < 0)
1048 return r;
1049 }
b46a529c 1050
35d8c19a 1051 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_TMPFILES_SETUP_SERVICE, true, UNIT_DEPENDENCY_FILE);
b46a529c
LP
1052 if (r < 0)
1053 return r;
1054 }
1055
52c239d7
LB
1056 if (!IN_SET(c->std_output,
1057 EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE,
1058 EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE,
1059 EXEC_OUTPUT_SYSLOG, EXEC_OUTPUT_SYSLOG_AND_CONSOLE) &&
1060 !IN_SET(c->std_error,
1061 EXEC_OUTPUT_JOURNAL, EXEC_OUTPUT_JOURNAL_AND_CONSOLE,
1062 EXEC_OUTPUT_KMSG, EXEC_OUTPUT_KMSG_AND_CONSOLE,
1063 EXEC_OUTPUT_SYSLOG, EXEC_OUTPUT_SYSLOG_AND_CONSOLE))
23a177ef
LP
1064 return 0;
1065
1066 /* If syslog or kernel logging is requested, make sure our own
1067 * logging daemon is run first. */
1068
35d8c19a 1069 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, true, UNIT_DEPENDENCY_FILE);
b46a529c
LP
1070 if (r < 0)
1071 return r;
23a177ef 1072
87f0e418
LP
1073 return 0;
1074}
1075
87f0e418
LP
1076const char *unit_description(Unit *u) {
1077 assert(u);
1078
ac155bb8
MS
1079 if (u->description)
1080 return u->description;
87f0e418 1081
ac155bb8 1082 return strna(u->id);
87f0e418
LP
1083}
1084
2a8f53c6
ZJS
1085const char *unit_status_string(Unit *u) {
1086 assert(u);
1087
1088 if (u->manager->status_unit_format == STATUS_UNIT_FORMAT_NAME && u->id)
1089 return u->id;
1090
1091 return unit_description(u);
1092}
1093
eef85c4a
LP
1094static void print_unit_dependency_mask(FILE *f, const char *kind, UnitDependencyMask mask, bool *space) {
1095 const struct {
1096 UnitDependencyMask mask;
1097 const char *name;
1098 } table[] = {
1099 { UNIT_DEPENDENCY_FILE, "file" },
1100 { UNIT_DEPENDENCY_IMPLICIT, "implicit" },
1101 { UNIT_DEPENDENCY_DEFAULT, "default" },
1102 { UNIT_DEPENDENCY_UDEV, "udev" },
1103 { UNIT_DEPENDENCY_PATH, "path" },
1104 { UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT, "mountinfo-implicit" },
1105 { UNIT_DEPENDENCY_MOUNTINFO_DEFAULT, "mountinfo-default" },
1106 { UNIT_DEPENDENCY_PROC_SWAP, "proc-swap" },
1107 };
1108 size_t i;
1109
1110 assert(f);
1111 assert(kind);
1112 assert(space);
1113
1114 for (i = 0; i < ELEMENTSOF(table); i++) {
1115
1116 if (mask == 0)
1117 break;
1118
d94a24ca 1119 if (FLAGS_SET(mask, table[i].mask)) {
eef85c4a
LP
1120 if (*space)
1121 fputc(' ', f);
1122 else
1123 *space = true;
1124
1125 fputs(kind, f);
1126 fputs("-", f);
1127 fputs(table[i].name, f);
1128
1129 mask &= ~table[i].mask;
1130 }
1131 }
1132
1133 assert(mask == 0);
1134}
1135
87f0e418 1136void unit_dump(Unit *u, FILE *f, const char *prefix) {
49dbfa7b 1137 char *t, **j;
87f0e418
LP
1138 UnitDependency d;
1139 Iterator i;
47be870b 1140 const char *prefix2;
8d5e5931 1141 char timestamp[5][FORMAT_TIMESTAMP_MAX], timespan[FORMAT_TIMESPAN_MAX];
a7f241db 1142 Unit *following;
eeaedb7c 1143 _cleanup_set_free_ Set *following_set = NULL;
05a98afd 1144 const char *n;
02638280
LP
1145 CGroupMask m;
1146 int r;
87f0e418
LP
1147
1148 assert(u);
ac155bb8 1149 assert(u->type >= 0);
87f0e418 1150
4c940960 1151 prefix = strempty(prefix);
63c372cb 1152 prefix2 = strjoina(prefix, "\t");
87f0e418
LP
1153
1154 fprintf(f,
0121d1f2
ZJS
1155 "%s-> Unit %s:\n",
1156 prefix, u->id);
1157
1158 SET_FOREACH(t, u->names, i)
1159 if (!streq(t, u->id))
1160 fprintf(f, "%s\tAlias: %s\n", prefix, t);
1161
1162 fprintf(f,
87f0e418 1163 "%s\tDescription: %s\n"
9e2f7c11 1164 "%s\tInstance: %s\n"
87f0e418 1165 "%s\tUnit Load State: %s\n"
2fad8195 1166 "%s\tUnit Active State: %s\n"
b895d155 1167 "%s\tState Change Timestamp: %s\n"
173e3821 1168 "%s\tInactive Exit Timestamp: %s\n"
2fad8195 1169 "%s\tActive Enter Timestamp: %s\n"
701cc384 1170 "%s\tActive Exit Timestamp: %s\n"
173e3821 1171 "%s\tInactive Enter Timestamp: %s\n"
f2f725e5 1172 "%s\tMay GC: %s\n"
9444b1f2 1173 "%s\tNeed Daemon Reload: %s\n"
c2756a68 1174 "%s\tTransient: %s\n"
f5869324 1175 "%s\tPerpetual: %s\n"
5afe510c 1176 "%s\tGarbage Collection Mode: %s\n"
4ad49000
LP
1177 "%s\tSlice: %s\n"
1178 "%s\tCGroup: %s\n"
aae7e17f 1179 "%s\tCGroup realized: %s\n",
87f0e418 1180 prefix, unit_description(u),
ac155bb8
MS
1181 prefix, strna(u->instance),
1182 prefix, unit_load_state_to_string(u->load_state),
2fad8195 1183 prefix, unit_active_state_to_string(unit_active_state(u)),
8d5e5931
ZJS
1184 prefix, strna(format_timestamp(timestamp[0], sizeof(timestamp[0]), u->state_change_timestamp.realtime)),
1185 prefix, strna(format_timestamp(timestamp[1], sizeof(timestamp[1]), u->inactive_exit_timestamp.realtime)),
1186 prefix, strna(format_timestamp(timestamp[2], sizeof(timestamp[2]), u->active_enter_timestamp.realtime)),
1187 prefix, strna(format_timestamp(timestamp[3], sizeof(timestamp[3]), u->active_exit_timestamp.realtime)),
1188 prefix, strna(format_timestamp(timestamp[4], sizeof(timestamp[4]), u->inactive_enter_timestamp.realtime)),
f2f725e5 1189 prefix, yes_no(unit_may_gc(u)),
9444b1f2 1190 prefix, yes_no(unit_need_daemon_reload(u)),
c2756a68 1191 prefix, yes_no(u->transient),
f5869324 1192 prefix, yes_no(u->perpetual),
5afe510c 1193 prefix, collect_mode_to_string(u->collect_mode),
4ad49000
LP
1194 prefix, strna(unit_slice_name(u)),
1195 prefix, strna(u->cgroup_path),
aae7e17f
FB
1196 prefix, yes_no(u->cgroup_realized));
1197
1198 if (u->cgroup_realized_mask != 0) {
1199 _cleanup_free_ char *s = NULL;
1200 (void) cg_mask_to_string(u->cgroup_realized_mask, &s);
02638280
LP
1201 fprintf(f, "%s\tCGroup realized mask: %s\n", prefix, strnull(s));
1202 }
0adf88b6 1203
02638280
LP
1204 if (u->cgroup_enabled_mask != 0) {
1205 _cleanup_free_ char *s = NULL;
1206 (void) cg_mask_to_string(u->cgroup_enabled_mask, &s);
1207 fprintf(f, "%s\tCGroup enabled mask: %s\n", prefix, strnull(s));
1208 }
0adf88b6 1209
02638280
LP
1210 m = unit_get_own_mask(u);
1211 if (m != 0) {
1212 _cleanup_free_ char *s = NULL;
1213 (void) cg_mask_to_string(m, &s);
1214 fprintf(f, "%s\tCGroup own mask: %s\n", prefix, strnull(s));
aae7e17f 1215 }
0adf88b6 1216
02638280
LP
1217 m = unit_get_members_mask(u);
1218 if (m != 0) {
aae7e17f 1219 _cleanup_free_ char *s = NULL;
02638280 1220 (void) cg_mask_to_string(m, &s);
aae7e17f
FB
1221 fprintf(f, "%s\tCGroup members mask: %s\n", prefix, strnull(s));
1222 }
0301abf4 1223
0adf88b6
LP
1224 m = unit_get_delegate_mask(u);
1225 if (m != 0) {
1226 _cleanup_free_ char *s = NULL;
1227 (void) cg_mask_to_string(m, &s);
1228 fprintf(f, "%s\tCGroup delegate mask: %s\n", prefix, strnull(s));
1229 }
1230
4b58153d
LP
1231 if (!sd_id128_is_null(u->invocation_id))
1232 fprintf(f, "%s\tInvocation ID: " SD_ID128_FORMAT_STR "\n",
1233 prefix, SD_ID128_FORMAT_VAL(u->invocation_id));
1234
49dbfa7b
LP
1235 STRV_FOREACH(j, u->documentation)
1236 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
1237
eeaedb7c
LP
1238 following = unit_following(u);
1239 if (following)
ac155bb8 1240 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
8fe914ec 1241
eeaedb7c
LP
1242 r = unit_following_set(u, &following_set);
1243 if (r >= 0) {
1244 Unit *other;
1245
1246 SET_FOREACH(other, following_set, i)
1247 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
1248 }
1249
ac155bb8
MS
1250 if (u->fragment_path)
1251 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
23a177ef 1252
1b64d026
LP
1253 if (u->source_path)
1254 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
1255
ae7a7182 1256 STRV_FOREACH(j, u->dropin_paths)
2875e22b 1257 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
ae7a7182 1258
e7dfbb4e
LP
1259 if (u->failure_action != EMERGENCY_ACTION_NONE)
1260 fprintf(f, "%s\tFailure Action: %s\n", prefix, emergency_action_to_string(u->failure_action));
7af67e9a
LP
1261 if (u->failure_action_exit_status >= 0)
1262 fprintf(f, "%s\tFailure Action Exit Status: %i\n", prefix, u->failure_action_exit_status);
e7dfbb4e
LP
1263 if (u->success_action != EMERGENCY_ACTION_NONE)
1264 fprintf(f, "%s\tSuccess Action: %s\n", prefix, emergency_action_to_string(u->success_action));
7af67e9a
LP
1265 if (u->success_action_exit_status >= 0)
1266 fprintf(f, "%s\tSuccess Action Exit Status: %i\n", prefix, u->success_action_exit_status);
e7dfbb4e 1267
36c16a7c 1268 if (u->job_timeout != USEC_INFINITY)
2fa4092c 1269 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
faf919f1 1270
87a47f99
LN
1271 if (u->job_timeout_action != EMERGENCY_ACTION_NONE)
1272 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, emergency_action_to_string(u->job_timeout_action));
f189ab18
LP
1273
1274 if (u->job_timeout_reboot_arg)
1275 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
1276
59fccdc5
LP
1277 condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
1278 condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
52661efd 1279
ac155bb8 1280 if (dual_timestamp_is_set(&u->condition_timestamp))
2791a8f8
LP
1281 fprintf(f,
1282 "%s\tCondition Timestamp: %s\n"
1283 "%s\tCondition Result: %s\n",
8d5e5931 1284 prefix, strna(format_timestamp(timestamp[0], sizeof(timestamp[0]), u->condition_timestamp.realtime)),
ac155bb8 1285 prefix, yes_no(u->condition_result));
2791a8f8 1286
59fccdc5
LP
1287 if (dual_timestamp_is_set(&u->assert_timestamp))
1288 fprintf(f,
1289 "%s\tAssert Timestamp: %s\n"
1290 "%s\tAssert Result: %s\n",
8d5e5931 1291 prefix, strna(format_timestamp(timestamp[0], sizeof(timestamp[0]), u->assert_timestamp.realtime)),
59fccdc5
LP
1292 prefix, yes_no(u->assert_result));
1293
87f0e418 1294 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
eef85c4a 1295 UnitDependencyInfo di;
87f0e418
LP
1296 Unit *other;
1297
eef85c4a
LP
1298 HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i) {
1299 bool space = false;
1300
1301 fprintf(f, "%s\t%s: %s (", prefix, unit_dependency_to_string(d), other->id);
1302
1303 print_unit_dependency_mask(f, "origin", di.origin_mask, &space);
1304 print_unit_dependency_mask(f, "destination", di.destination_mask, &space);
1305
1306 fputs(")\n", f);
1307 }
87f0e418
LP
1308 }
1309
eef85c4a
LP
1310 if (!hashmap_isempty(u->requires_mounts_for)) {
1311 UnitDependencyInfo di;
1312 const char *path;
1313
1314 HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i) {
1315 bool space = false;
7c8fa05c 1316
eef85c4a 1317 fprintf(f, "%s\tRequiresMountsFor: %s (", prefix, path);
7c8fa05c 1318
eef85c4a
LP
1319 print_unit_dependency_mask(f, "origin", di.origin_mask, &space);
1320 print_unit_dependency_mask(f, "destination", di.destination_mask, &space);
1321
1322 fputs(")\n", f);
1323 }
7c8fa05c
LP
1324 }
1325
ac155bb8 1326 if (u->load_state == UNIT_LOADED) {
ab1f0633 1327
b0650475 1328 fprintf(f,
a40eb732 1329 "%s\tStopWhenUnneeded: %s\n"
b5e9dba8
LP
1330 "%s\tRefuseManualStart: %s\n"
1331 "%s\tRefuseManualStop: %s\n"
222ae6a8 1332 "%s\tDefaultDependencies: %s\n"
d420282b 1333 "%s\tOnFailureJobMode: %s\n"
36b4a7ba 1334 "%s\tIgnoreOnIsolate: %s\n",
ac155bb8
MS
1335 prefix, yes_no(u->stop_when_unneeded),
1336 prefix, yes_no(u->refuse_manual_start),
1337 prefix, yes_no(u->refuse_manual_stop),
1338 prefix, yes_no(u->default_dependencies),
d420282b 1339 prefix, job_mode_to_string(u->on_failure_job_mode),
36b4a7ba 1340 prefix, yes_no(u->ignore_on_isolate));
ac155bb8 1341
23a177ef
LP
1342 if (UNIT_VTABLE(u)->dump)
1343 UNIT_VTABLE(u)->dump(u, f, prefix2);
b0650475 1344
ac155bb8 1345 } else if (u->load_state == UNIT_MERGED)
b0650475
LP
1346 fprintf(f,
1347 "%s\tMerged into: %s\n",
ac155bb8
MS
1348 prefix, u->merged_into->id);
1349 else if (u->load_state == UNIT_ERROR)
4bbccb02 1350 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror_safe(u->load_error));
8821a00f 1351
05a98afd
LP
1352 for (n = sd_bus_track_first(u->bus_track); n; n = sd_bus_track_next(u->bus_track))
1353 fprintf(f, "%s\tBus Ref: %s\n", prefix, n);
87f0e418 1354
ac155bb8
MS
1355 if (u->job)
1356 job_dump(u->job, f, prefix2);
87f0e418 1357
e0209d83
MS
1358 if (u->nop_job)
1359 job_dump(u->nop_job, f, prefix2);
87f0e418
LP
1360}
1361
1362/* Common implementation for multiple backends */
e537352b 1363int unit_load_fragment_and_dropin(Unit *u) {
23a177ef
LP
1364 int r;
1365
1366 assert(u);
23a177ef 1367
e48614c4 1368 /* Load a .{service,socket,...} file */
4ad49000
LP
1369 r = unit_load_fragment(u);
1370 if (r < 0)
23a177ef
LP
1371 return r;
1372
ac155bb8 1373 if (u->load_state == UNIT_STUB)
23a177ef
LP
1374 return -ENOENT;
1375
9e4ea9cc
ZJS
1376 /* Load drop-in directory data. If u is an alias, we might be reloading the
1377 * target unit needlessly. But we cannot be sure which drops-ins have already
1378 * been loaded and which not, at least without doing complicated book-keeping,
1379 * so let's always reread all drop-ins. */
1380 return unit_load_dropin(unit_follow_merge(u));
23a177ef
LP
1381}
1382
1383/* Common implementation for multiple backends */
e537352b 1384int unit_load_fragment_and_dropin_optional(Unit *u) {
23a177ef 1385 int r;
87f0e418
LP
1386
1387 assert(u);
1388
23a177ef
LP
1389 /* Same as unit_load_fragment_and_dropin(), but whether
1390 * something can be loaded or not doesn't matter. */
1391
e9e8cbc8 1392 /* Load a .service/.socket/.slice/… file */
4ad49000
LP
1393 r = unit_load_fragment(u);
1394 if (r < 0)
87f0e418
LP
1395 return r;
1396
ac155bb8
MS
1397 if (u->load_state == UNIT_STUB)
1398 u->load_state = UNIT_LOADED;
d46de8a1 1399
9e4ea9cc
ZJS
1400 /* Load drop-in directory data */
1401 return unit_load_dropin(unit_follow_merge(u));
87f0e418
LP
1402}
1403
19496554
MS
1404void unit_add_to_target_deps_queue(Unit *u) {
1405 Manager *m = u->manager;
1406
1407 assert(u);
1408
1409 if (u->in_target_deps_queue)
1410 return;
1411
1412 LIST_PREPEND(target_deps_queue, m->target_deps_queue, u);
1413 u->in_target_deps_queue = true;
1414}
1415
bba34eed 1416int unit_add_default_target_dependency(Unit *u, Unit *target) {
98bc2000
LP
1417 assert(u);
1418 assert(target);
1419
ac155bb8 1420 if (target->type != UNIT_TARGET)
98bc2000
LP
1421 return 0;
1422
35b8ca3a 1423 /* Only add the dependency if both units are loaded, so that
bba34eed 1424 * that loop check below is reliable */
ac155bb8
MS
1425 if (u->load_state != UNIT_LOADED ||
1426 target->load_state != UNIT_LOADED)
bba34eed
LP
1427 return 0;
1428
21256a2b
LP
1429 /* If either side wants no automatic dependencies, then let's
1430 * skip this */
ac155bb8
MS
1431 if (!u->default_dependencies ||
1432 !target->default_dependencies)
21256a2b
LP
1433 return 0;
1434
98bc2000 1435 /* Don't create loops */
eef85c4a 1436 if (hashmap_get(target->dependencies[UNIT_BEFORE], u))
98bc2000
LP
1437 return 0;
1438
eef85c4a 1439 return unit_add_dependency(target, UNIT_AFTER, u, true, UNIT_DEPENDENCY_DEFAULT);
98bc2000
LP
1440}
1441
e954c9cf 1442static int unit_add_slice_dependencies(Unit *u) {
eef85c4a 1443 UnitDependencyMask mask;
e954c9cf 1444 assert(u);
b81884e7 1445
35b7ff80 1446 if (!UNIT_HAS_CGROUP_CONTEXT(u))
e954c9cf
LP
1447 return 0;
1448
eef85c4a
LP
1449 /* Slice units are implicitly ordered against their parent slices (as this relationship is encoded in the
1450 name), while all other units are ordered based on configuration (as in their case Slice= configures the
1451 relationship). */
1452 mask = u->type == UNIT_SLICE ? UNIT_DEPENDENCY_IMPLICIT : UNIT_DEPENDENCY_FILE;
1453
e954c9cf 1454 if (UNIT_ISSET(u->slice))
eef85c4a 1455 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT_DEREF(u->slice), true, mask);
e954c9cf 1456
8c8da0e0 1457 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
d1fab3fe
ZJS
1458 return 0;
1459
5a724170 1460 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_ROOT_SLICE, true, mask);
98bc2000
LP
1461}
1462
e954c9cf 1463static int unit_add_mount_dependencies(Unit *u) {
eef85c4a
LP
1464 UnitDependencyInfo di;
1465 const char *path;
1466 Iterator i;
9588bc32
LP
1467 int r;
1468
1469 assert(u);
1470
eef85c4a
LP
1471 HASHMAP_FOREACH_KEY(di.data, path, u->requires_mounts_for, i) {
1472 char prefix[strlen(path) + 1];
9588bc32 1473
eef85c4a 1474 PATH_FOREACH_PREFIX_MORE(prefix, path) {
c7c89abb 1475 _cleanup_free_ char *p = NULL;
9588bc32
LP
1476 Unit *m;
1477
c7c89abb 1478 r = unit_name_from_path(prefix, ".mount", &p);
9588bc32
LP
1479 if (r < 0)
1480 return r;
c7c89abb
FB
1481
1482 m = manager_get_unit(u->manager, p);
1483 if (!m) {
1484 /* Make sure to load the mount unit if
1485 * it exists. If so the dependencies
1486 * on this unit will be added later
1487 * during the loading of the mount
1488 * unit. */
1489 (void) manager_load_unit_prepare(u->manager, p, NULL, NULL, &m);
9588bc32 1490 continue;
c7c89abb 1491 }
9588bc32
LP
1492 if (m == u)
1493 continue;
1494
1495 if (m->load_state != UNIT_LOADED)
1496 continue;
1497
eef85c4a 1498 r = unit_add_dependency(u, UNIT_AFTER, m, true, di.origin_mask);
9588bc32
LP
1499 if (r < 0)
1500 return r;
1501
1502 if (m->fragment_path) {
eef85c4a 1503 r = unit_add_dependency(u, UNIT_REQUIRES, m, true, di.origin_mask);
9588bc32
LP
1504 if (r < 0)
1505 return r;
1506 }
1507 }
1508 }
1509
1510 return 0;
1511}
1512
95ae05c0
WC
1513static int unit_add_startup_units(Unit *u) {
1514 CGroupContext *c;
5269eb6b 1515 int r;
95ae05c0
WC
1516
1517 c = unit_get_cgroup_context(u);
db785129
LP
1518 if (!c)
1519 return 0;
1520
d53d9474 1521 if (c->startup_cpu_shares == CGROUP_CPU_SHARES_INVALID &&
13c31542 1522 c->startup_io_weight == CGROUP_WEIGHT_INVALID &&
d53d9474 1523 c->startup_blockio_weight == CGROUP_BLKIO_WEIGHT_INVALID)
db785129
LP
1524 return 0;
1525
5269eb6b
LP
1526 r = set_ensure_allocated(&u->manager->startup_units, NULL);
1527 if (r < 0)
1528 return r;
1529
756c09e6 1530 return set_put(u->manager->startup_units, u);
95ae05c0
WC
1531}
1532
87f0e418
LP
1533int unit_load(Unit *u) {
1534 int r;
1535
1536 assert(u);
1537
ac155bb8 1538 if (u->in_load_queue) {
71fda00f 1539 LIST_REMOVE(load_queue, u->manager->load_queue, u);
ac155bb8 1540 u->in_load_queue = false;
87f0e418
LP
1541 }
1542
ac155bb8 1543 if (u->type == _UNIT_TYPE_INVALID)
e537352b
LP
1544 return -EINVAL;
1545
ac155bb8 1546 if (u->load_state != UNIT_STUB)
87f0e418
LP
1547 return 0;
1548
4f4afc88 1549 if (u->transient_file) {
66fa4bdd
LP
1550 /* Finalize transient file: if this is a transient unit file, as soon as we reach unit_load() the setup
1551 * is complete, hence let's synchronize the unit file we just wrote to disk. */
1552
4f4afc88
LP
1553 r = fflush_and_check(u->transient_file);
1554 if (r < 0)
1555 goto fail;
1556
50fb00b7 1557 u->transient_file = safe_fclose(u->transient_file);
f76707da 1558 u->fragment_mtime = now(CLOCK_REALTIME);
4f4afc88
LP
1559 }
1560
c2756a68
LP
1561 if (UNIT_VTABLE(u)->load) {
1562 r = UNIT_VTABLE(u)->load(u);
1563 if (r < 0)
87f0e418 1564 goto fail;
c2756a68 1565 }
23a177ef 1566
ac155bb8 1567 if (u->load_state == UNIT_STUB) {
23a177ef
LP
1568 r = -ENOENT;
1569 goto fail;
1570 }
1571
7c8fa05c 1572 if (u->load_state == UNIT_LOADED) {
19496554 1573 unit_add_to_target_deps_queue(u);
e954c9cf
LP
1574
1575 r = unit_add_slice_dependencies(u);
1576 if (r < 0)
1577 goto fail;
c2756a68 1578
e954c9cf 1579 r = unit_add_mount_dependencies(u);
7c8fa05c 1580 if (r < 0)
c2756a68 1581 goto fail;
7c8fa05c 1582
95ae05c0
WC
1583 r = unit_add_startup_units(u);
1584 if (r < 0)
1585 goto fail;
1586
eef85c4a 1587 if (u->on_failure_job_mode == JOB_ISOLATE && hashmap_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
f2341e0a 1588 log_unit_error(u, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
6f40aa45 1589 r = -ENOEXEC;
c2756a68
LP
1590 goto fail;
1591 }
bc432dc7 1592
a2df3ea4
MK
1593 if (u->job_running_timeout != USEC_INFINITY && u->job_running_timeout > u->job_timeout)
1594 log_unit_warning(u, "JobRunningTimeoutSec= is greater than JobTimeoutSec=, it has no effect.");
1595
5af88058
LP
1596 /* We finished loading, let's ensure our parents recalculate the members mask */
1597 unit_invalidate_cgroup_members_masks(u);
f68319bb
LP
1598 }
1599
ac155bb8 1600 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
23a177ef
LP
1601
1602 unit_add_to_dbus_queue(unit_follow_merge(u));
701cc384 1603 unit_add_to_gc_queue(u);
87f0e418 1604
87f0e418
LP
1605 return 0;
1606
1607fail:
c4555ad8
LP
1608 /* We convert ENOEXEC errors to the UNIT_BAD_SETTING load state here. Configuration parsing code should hence
1609 * return ENOEXEC to ensure units are placed in this state after loading */
1610
1611 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND :
1612 r == -ENOEXEC ? UNIT_BAD_SETTING :
1613 UNIT_ERROR;
ac155bb8 1614 u->load_error = r;
c4555ad8 1615
c1e1601e 1616 unit_add_to_dbus_queue(u);
9a46fc3b 1617 unit_add_to_gc_queue(u);
23a177ef 1618
c4555ad8 1619 return log_unit_debug_errno(u, r, "Failed to load configuration: %m");
87f0e418
LP
1620}
1621
f9f88198
YW
1622_printf_(7, 8)
1623static int log_unit_internal(void *userdata, int level, int error, const char *file, int line, const char *func, const char *format, ...) {
1624 Unit *u = userdata;
1625 va_list ap;
1626 int r;
49365733 1627
f9f88198
YW
1628 va_start(ap, format);
1629 if (u)
1630 r = log_object_internalv(level, error, file, line, func,
1631 u->manager->unit_log_field,
1632 u->id,
1633 u->manager->invocation_log_field,
1634 u->invocation_id_string,
1635 format, ap);
1636 else
1637 r = log_internalv(level, error, file, line, func, format, ap);
1638 va_end(ap);
49365733 1639
f9f88198 1640 return r;
49365733
LP
1641}
1642
97a3f4ee 1643static bool unit_test_condition(Unit *u) {
90bbc946
LP
1644 assert(u);
1645
ac155bb8 1646 dual_timestamp_get(&u->condition_timestamp);
f9f88198 1647 u->condition_result = condition_test_list(u->conditions, condition_type_to_string, log_unit_internal, u);
90bbc946 1648
e18f8852
LP
1649 unit_add_to_dbus_queue(u);
1650
ac155bb8 1651 return u->condition_result;
90bbc946
LP
1652}
1653
97a3f4ee 1654static bool unit_test_assert(Unit *u) {
59fccdc5
LP
1655 assert(u);
1656
1657 dual_timestamp_get(&u->assert_timestamp);
f9f88198 1658 u->assert_result = condition_test_list(u->asserts, assert_type_to_string, log_unit_internal, u);
59fccdc5 1659
e18f8852
LP
1660 unit_add_to_dbus_queue(u);
1661
59fccdc5
LP
1662 return u->assert_result;
1663}
1664
df446f96 1665void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
5b262f74
LP
1666 const char *d;
1667
2a8f53c6 1668 d = unit_status_string(u);
5b262f74
LP
1669 if (log_get_show_color())
1670 d = strjoina(ANSI_HIGHLIGHT, d, ANSI_NORMAL);
1671
df446f96 1672 DISABLE_WARNING_FORMAT_NONLITERAL;
5b262f74 1673 manager_status_printf(u->manager, STATUS_TYPE_NORMAL, status, unit_status_msg_format, d);
df446f96
LP
1674 REENABLE_WARNING;
1675}
1676
97a3f4ee 1677int unit_test_start_limit(Unit *u) {
429926e9
TR
1678 const char *reason;
1679
6bf0f408
LP
1680 assert(u);
1681
7994ac1d 1682 if (ratelimit_below(&u->start_limit)) {
6bf0f408
LP
1683 u->start_limit_hit = false;
1684 return 0;
1685 }
1686
1687 log_unit_warning(u, "Start request repeated too quickly.");
1688 u->start_limit_hit = true;
1689
429926e9
TR
1690 reason = strjoina("unit ", u->id, " failed");
1691
36c4dc08
LP
1692 emergency_action(u->manager, u->start_limit_action,
1693 EMERGENCY_ACTION_IS_WATCHDOG|EMERGENCY_ACTION_WARN,
1694 u->reboot_arg, -1, reason);
1695
1696 return -ECANCELED;
6bf0f408
LP
1697}
1698
c891efaf 1699bool unit_shall_confirm_spawn(Unit *u) {
631b676b 1700 assert(u);
c891efaf
FB
1701
1702 if (manager_is_confirm_spawn_disabled(u->manager))
1703 return false;
1704
1705 /* For some reasons units remaining in the same process group
1706 * as PID 1 fail to acquire the console even if it's not used
1707 * by any process. So skip the confirmation question for them. */
1708 return !unit_get_exec_context(u)->same_pgrp;
1709}
1710
631b676b
LP
1711static bool unit_verify_deps(Unit *u) {
1712 Unit *other;
1713 Iterator j;
eef85c4a 1714 void *v;
631b676b
LP
1715
1716 assert(u);
1717
1718 /* Checks whether all BindsTo= dependencies of this unit are fulfilled — if they are also combined with
1719 * After=. We do not check Requires= or Requisite= here as they only should have an effect on the job
1720 * processing, but do not have any effect afterwards. We don't check BindsTo= dependencies that are not used in
1721 * conjunction with After= as for them any such check would make things entirely racy. */
1722
eef85c4a 1723 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], j) {
631b676b 1724
eef85c4a 1725 if (!hashmap_contains(u->dependencies[UNIT_AFTER], other))
631b676b
LP
1726 continue;
1727
1728 if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(other))) {
1729 log_unit_notice(u, "Bound to unit %s, but unit isn't active.", other->id);
1730 return false;
1731 }
1732 }
1733
1734 return true;
1735}
1736
9adb6959 1737/* Errors that aren't really errors:
6bf0f408 1738 * -EALREADY: Unit is already started.
9adb6959 1739 * -ECOMM: Condition failed
6bf0f408 1740 * -EAGAIN: An operation is already in progress. Retry later.
9adb6959
LP
1741 *
1742 * Errors that are real errors:
1743 * -EBADR: This unit type does not support starting.
2de9b979 1744 * -ECANCELED: Start limit hit, too many requests for now
6bf0f408
LP
1745 * -EPROTO: Assert failed
1746 * -EINVAL: Unit not loaded
1747 * -EOPNOTSUPP: Unit type not supported
631b676b 1748 * -ENOLINK: The necessary dependencies are not fulfilled.
d4fd1cf2 1749 * -ESTALE: This unit has been started before and can't be started a second time
a4191c9f 1750 * -ENOENT: This is a triggering unit and unit to trigger is not loaded
87f0e418
LP
1751 */
1752int unit_start(Unit *u) {
1753 UnitActiveState state;
92ab323c 1754 Unit *following;
87f0e418
LP
1755
1756 assert(u);
1757
5766aca8
LP
1758 /* If this is already started, then this will succeed. Note that this will even succeed if this unit
1759 * is not startable by the user. This is relied on to detect when we need to wait for units and when
1760 * waiting is finished. */
87f0e418
LP
1761 state = unit_active_state(u);
1762 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1763 return -EALREADY;
380dc8b0
LP
1764 if (state == UNIT_MAINTENANCE)
1765 return -EAGAIN;
87f0e418 1766
6bf0f408
LP
1767 /* Units that aren't loaded cannot be started */
1768 if (u->load_state != UNIT_LOADED)
1769 return -EINVAL;
1770
d4fd1cf2
LP
1771 /* Refuse starting scope units more than once */
1772 if (UNIT_VTABLE(u)->once_only && dual_timestamp_is_set(&u->inactive_enter_timestamp))
1773 return -ESTALE;
1774
5766aca8
LP
1775 /* If the conditions failed, don't do anything at all. If we already are activating this call might
1776 * still be useful to speed up activation in case there is some hold-off time, but we don't want to
1777 * recheck the condition in that case. */
a82e5507 1778 if (state != UNIT_ACTIVATING &&
5af6aa58 1779 !unit_test_condition(u))
5766aca8 1780 return log_unit_debug_errno(u, SYNTHETIC_ERRNO(ECOMM), "Starting requested but condition failed. Not starting unit.");
52661efd 1781
59fccdc5
LP
1782 /* If the asserts failed, fail the entire job */
1783 if (state != UNIT_ACTIVATING &&
5766aca8
LP
1784 !unit_test_assert(u))
1785 return log_unit_notice_errno(u, SYNTHETIC_ERRNO(EPROTO), "Starting requested but asserts failed.");
59fccdc5 1786
5766aca8
LP
1787 /* Units of types that aren't supported cannot be started. Note that we do this test only after the
1788 * condition checks, so that we rather return condition check errors (which are usually not
1789 * considered a true failure) than "not supported" errors (which are considered a failure).
d11a7645 1790 */
96cf3ec9 1791 if (!unit_type_supported(u->type))
d11a7645
LP
1792 return -EOPNOTSUPP;
1793
5766aca8
LP
1794 /* Let's make sure that the deps really are in order before we start this. Normally the job engine
1795 * should have taken care of this already, but let's check this here again. After all, our
1796 * dependencies might not be in effect anymore, due to a reload or due to a failed condition. */
631b676b
LP
1797 if (!unit_verify_deps(u))
1798 return -ENOLINK;
1799
92ab323c 1800 /* Forward to the main object, if we aren't it. */
52990c2e
ZJS
1801 following = unit_following(u);
1802 if (following) {
f2341e0a 1803 log_unit_debug(u, "Redirecting start request from %s to %s.", u->id, following->id);
92ab323c
LP
1804 return unit_start(following);
1805 }
1806
1807 /* If it is stopped, but we cannot start it, then fail */
1808 if (!UNIT_VTABLE(u)->start)
1809 return -EBADR;
1810
5766aca8
LP
1811 /* We don't suppress calls to ->start() here when we are already starting, to allow this request to
1812 * be used as a "hurry up" call, for example when the unit is in some "auto restart" state where it
1813 * waits for a holdoff timer to elapse before it will start again. */
87f0e418 1814
c1e1601e 1815 unit_add_to_dbus_queue(u);
9e58ff9c 1816
d1a34ae9 1817 return UNIT_VTABLE(u)->start(u);
87f0e418
LP
1818}
1819
1820bool unit_can_start(Unit *u) {
1821 assert(u);
1822
8ff4d2ab
LP
1823 if (u->load_state != UNIT_LOADED)
1824 return false;
1825
96cf3ec9 1826 if (!unit_type_supported(u->type))
8ff4d2ab
LP
1827 return false;
1828
d4fd1cf2
LP
1829 /* Scope units may be started only once */
1830 if (UNIT_VTABLE(u)->once_only && dual_timestamp_is_set(&u->inactive_exit_timestamp))
1831 return false;
1832
87f0e418
LP
1833 return !!UNIT_VTABLE(u)->start;
1834}
1835
2528a7a6
LP
1836bool unit_can_isolate(Unit *u) {
1837 assert(u);
1838
1839 return unit_can_start(u) &&
ac155bb8 1840 u->allow_isolate;
2528a7a6
LP
1841}
1842
87f0e418
LP
1843/* Errors:
1844 * -EBADR: This unit type does not support stopping.
1845 * -EALREADY: Unit is already stopped.
1846 * -EAGAIN: An operation is already in progress. Retry later.
1847 */
1848int unit_stop(Unit *u) {
1849 UnitActiveState state;
92ab323c 1850 Unit *following;
87f0e418
LP
1851
1852 assert(u);
1853
87f0e418 1854 state = unit_active_state(u);
fdf20a31 1855 if (UNIT_IS_INACTIVE_OR_FAILED(state))
87f0e418
LP
1856 return -EALREADY;
1857
0faacd47
LP
1858 following = unit_following(u);
1859 if (following) {
f2341e0a 1860 log_unit_debug(u, "Redirecting stop request from %s to %s.", u->id, following->id);
92ab323c
LP
1861 return unit_stop(following);
1862 }
1863
7898b0cf
LP
1864 if (!UNIT_VTABLE(u)->stop)
1865 return -EBADR;
1866
c1e1601e 1867 unit_add_to_dbus_queue(u);
9e58ff9c 1868
d1a34ae9 1869 return UNIT_VTABLE(u)->stop(u);
87f0e418
LP
1870}
1871
f5869324
LP
1872bool unit_can_stop(Unit *u) {
1873 assert(u);
1874
96cf3ec9 1875 if (!unit_type_supported(u->type))
f5869324
LP
1876 return false;
1877
1878 if (u->perpetual)
1879 return false;
1880
1881 return !!UNIT_VTABLE(u)->stop;
1882}
1883
87f0e418
LP
1884/* Errors:
1885 * -EBADR: This unit type does not support reloading.
1886 * -ENOEXEC: Unit is not started.
1887 * -EAGAIN: An operation is already in progress. Retry later.
1888 */
1889int unit_reload(Unit *u) {
1890 UnitActiveState state;
92ab323c 1891 Unit *following;
87f0e418
LP
1892
1893 assert(u);
1894
ac155bb8 1895 if (u->load_state != UNIT_LOADED)
6124958c
LP
1896 return -EINVAL;
1897
87f0e418
LP
1898 if (!unit_can_reload(u))
1899 return -EBADR;
1900
1901 state = unit_active_state(u);
e364ad06 1902 if (state == UNIT_RELOADING)
6255af75 1903 return -EAGAIN;
87f0e418 1904
6a371e23 1905 if (state != UNIT_ACTIVE) {
f2341e0a 1906 log_unit_warning(u, "Unit cannot be reloaded because it is inactive.");
87f0e418 1907 return -ENOEXEC;
6a371e23 1908 }
87f0e418 1909
e48614c4
ZJS
1910 following = unit_following(u);
1911 if (following) {
f2341e0a 1912 log_unit_debug(u, "Redirecting reload request from %s to %s.", u->id, following->id);
92ab323c
LP
1913 return unit_reload(following);
1914 }
1915
c1e1601e 1916 unit_add_to_dbus_queue(u);
82a2b6bb 1917
f54bcca5
JR
1918 if (!UNIT_VTABLE(u)->reload) {
1919 /* Unit doesn't have a reload function, but we need to propagate the reload anyway */
2ad2e41a 1920 unit_notify(u, unit_active_state(u), unit_active_state(u), 0);
f54bcca5
JR
1921 return 0;
1922 }
1923
d1a34ae9 1924 return UNIT_VTABLE(u)->reload(u);
87f0e418
LP
1925}
1926
1927bool unit_can_reload(Unit *u) {
1928 assert(u);
1929
f54bcca5
JR
1930 if (UNIT_VTABLE(u)->can_reload)
1931 return UNIT_VTABLE(u)->can_reload(u);
87f0e418 1932
eef85c4a 1933 if (!hashmap_isempty(u->dependencies[UNIT_PROPAGATES_RELOAD_TO]))
87f0e418
LP
1934 return true;
1935
f54bcca5 1936 return UNIT_VTABLE(u)->reload;
87f0e418
LP
1937}
1938
a3c1168a
LP
1939bool unit_is_unneeded(Unit *u) {
1940 static const UnitDependency deps[] = {
be7d9ff7 1941 UNIT_REQUIRED_BY,
084918ba 1942 UNIT_REQUISITE_OF,
be7d9ff7
LP
1943 UNIT_WANTED_BY,
1944 UNIT_BOUND_BY,
1945 };
a3c1168a 1946 size_t j;
f3bff0eb
LP
1947
1948 assert(u);
1949
ac155bb8 1950 if (!u->stop_when_unneeded)
a3c1168a 1951 return false;
f3bff0eb 1952
a3c1168a
LP
1953 /* Don't clean up while the unit is transitioning or is even inactive. */
1954 if (!UNIT_IS_ACTIVE_OR_RELOADING(unit_active_state(u)))
1955 return false;
1956 if (u->job)
1957 return false;
f3bff0eb 1958
a3c1168a 1959 for (j = 0; j < ELEMENTSOF(deps); j++) {
eef85c4a
LP
1960 Unit *other;
1961 Iterator i;
1962 void *v;
1963
fda09318 1964 /* If a dependent unit has a job queued, is active or transitioning, or is marked for
a3c1168a 1965 * restart, then don't clean this one up. */
b81884e7 1966
a3c1168a 1967 HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i) {
93d4cb09 1968 if (other->job)
a3c1168a
LP
1969 return false;
1970
1971 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1972 return false;
1973
1974 if (unit_will_restart(other))
1975 return false;
1976 }
bea355da
LP
1977 }
1978
a3c1168a
LP
1979 return true;
1980}
f3bff0eb 1981
a3c1168a
LP
1982static void check_unneeded_dependencies(Unit *u) {
1983
1984 static const UnitDependency deps[] = {
1985 UNIT_REQUIRES,
1986 UNIT_REQUISITE,
1987 UNIT_WANTS,
1988 UNIT_BINDS_TO,
1989 };
1990 size_t j;
1991
1992 assert(u);
1993
1994 /* Add all units this unit depends on to the queue that processes StopWhenUnneeded= behaviour. */
1995
1996 for (j = 0; j < ELEMENTSOF(deps); j++) {
1997 Unit *other;
1998 Iterator i;
1999 void *v;
2000
2001 HASHMAP_FOREACH_KEY(v, other, u->dependencies[deps[j]], i)
fda09318 2002 unit_submit_to_stop_when_unneeded_queue(other);
a3c1168a 2003 }
f3bff0eb
LP
2004}
2005
ff502445 2006static void unit_check_binds_to(Unit *u) {
4afd3348 2007 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ff502445
LP
2008 bool stop = false;
2009 Unit *other;
2010 Iterator i;
eef85c4a 2011 void *v;
67bfdc97 2012 int r;
ff502445
LP
2013
2014 assert(u);
2015
2016 if (u->job)
2017 return;
2018
2019 if (unit_active_state(u) != UNIT_ACTIVE)
2020 return;
2021
eef85c4a 2022 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i) {
ff502445
LP
2023 if (other->job)
2024 continue;
13ddc3fc
ZJS
2025
2026 if (!other->coldplugged)
2027 /* We might yet create a job for the other unit… */
2028 continue;
ff502445
LP
2029
2030 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
2031 continue;
2032
2033 stop = true;
98f738b6 2034 break;
ff502445
LP
2035 }
2036
2037 if (!stop)
2038 return;
2039
595bfe7d 2040 /* If stopping a unit fails continuously we might enter a stop
67bfdc97
LP
2041 * loop here, hence stop acting on the service being
2042 * unnecessary after a while. */
7994ac1d 2043 if (!ratelimit_below(&u->auto_stop_ratelimit)) {
67bfdc97
LP
2044 log_unit_warning(u, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other->id);
2045 return;
2046 }
2047
98f738b6 2048 assert(other);
f2341e0a 2049 log_unit_info(u, "Unit is bound to inactive unit %s. Stopping, too.", other->id);
ff502445
LP
2050
2051 /* A unit we need to run is gone. Sniff. Let's stop this. */
50cbaba4 2052 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, NULL, &error, NULL);
67bfdc97 2053 if (r < 0)
4bd29fe5 2054 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %s", bus_error_message(&error, r));
ff502445
LP
2055}
2056
87f0e418
LP
2057static void retroactively_start_dependencies(Unit *u) {
2058 Iterator i;
2059 Unit *other;
eef85c4a 2060 void *v;
87f0e418
LP
2061
2062 assert(u);
2063 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
2064
eef85c4a
LP
2065 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_REQUIRES], i)
2066 if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
b81884e7 2067 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
50cbaba4 2068 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL, NULL, NULL);
b81884e7 2069
eef85c4a
LP
2070 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BINDS_TO], i)
2071 if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
b81884e7 2072 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
50cbaba4 2073 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, NULL, NULL, NULL);
87f0e418 2074
eef85c4a
LP
2075 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_WANTS], i)
2076 if (!hashmap_get(u->dependencies[UNIT_AFTER], other) &&
b81884e7 2077 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
50cbaba4 2078 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, NULL, NULL, NULL);
87f0e418 2079
eef85c4a 2080 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTS], i)
b81884e7 2081 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
50cbaba4 2082 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
69dd2852 2083
eef85c4a 2084 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_CONFLICTED_BY], i)
b81884e7 2085 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
50cbaba4 2086 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
87f0e418
LP
2087}
2088
2089static void retroactively_stop_dependencies(Unit *u) {
87f0e418 2090 Unit *other;
eef85c4a
LP
2091 Iterator i;
2092 void *v;
87f0e418
LP
2093
2094 assert(u);
2095 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
2096
b81884e7 2097 /* Pull down units which are bound to us recursively if enabled */
eef85c4a 2098 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BOUND_BY], i)
b81884e7 2099 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
50cbaba4 2100 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, NULL, NULL, NULL);
cd0504d0
MS
2101}
2102
3ecaa09b 2103void unit_start_on_failure(Unit *u) {
c0daa706
LP
2104 Unit *other;
2105 Iterator i;
eef85c4a 2106 void *v;
7f66b026 2107 int r;
c0daa706
LP
2108
2109 assert(u);
2110
eef85c4a 2111 if (hashmap_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
222ae6a8
LP
2112 return;
2113
f2341e0a 2114 log_unit_info(u, "Triggering OnFailure= dependencies.");
222ae6a8 2115
eef85c4a 2116 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_ON_FAILURE], i) {
7f66b026 2117 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
222ae6a8 2118
50cbaba4 2119 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, NULL, &error, NULL);
c1b6628d 2120 if (r < 0)
7f66b026 2121 log_unit_warning_errno(u, r, "Failed to enqueue OnFailure= job, ignoring: %s", bus_error_message(&error, r));
222ae6a8 2122 }
c0daa706
LP
2123}
2124
3ecaa09b
LP
2125void unit_trigger_notify(Unit *u) {
2126 Unit *other;
2127 Iterator i;
eef85c4a 2128 void *v;
3ecaa09b
LP
2129
2130 assert(u);
2131
eef85c4a 2132 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_TRIGGERED_BY], i)
3ecaa09b
LP
2133 if (UNIT_VTABLE(other)->trigger_notify)
2134 UNIT_VTABLE(other)->trigger_notify(other, u);
2135}
2136
37109b85
ZJS
2137static int raise_level(int log_level, bool condition_info, bool condition_notice) {
2138 if (condition_notice && log_level > LOG_NOTICE)
2139 return LOG_NOTICE;
2140 if (condition_info && log_level > LOG_INFO)
2141 return LOG_INFO;
2142 return log_level;
2143}
2144
915b1d01 2145static int unit_log_resources(Unit *u) {
bc40a20e
LP
2146 struct iovec iovec[1 + _CGROUP_IP_ACCOUNTING_METRIC_MAX + _CGROUP_IO_ACCOUNTING_METRIC_MAX + 4];
2147 bool any_traffic = false, have_ip_accounting = false, any_io = false, have_io_accounting = false;
2148 _cleanup_free_ char *igress = NULL, *egress = NULL, *rr = NULL, *wr = NULL;
37109b85 2149 int log_level = LOG_DEBUG; /* May be raised if resources consumed over a treshold */
915b1d01 2150 size_t n_message_parts = 0, n_iovec = 0;
bc40a20e 2151 char* message_parts[1 + 2 + 2 + 1], *t;
915b1d01
LP
2152 nsec_t nsec = NSEC_INFINITY;
2153 CGroupIPAccountingMetric m;
2154 size_t i;
2155 int r;
2156 const char* const ip_fields[_CGROUP_IP_ACCOUNTING_METRIC_MAX] = {
2157 [CGROUP_IP_INGRESS_BYTES] = "IP_METRIC_INGRESS_BYTES",
2158 [CGROUP_IP_INGRESS_PACKETS] = "IP_METRIC_INGRESS_PACKETS",
2159 [CGROUP_IP_EGRESS_BYTES] = "IP_METRIC_EGRESS_BYTES",
2160 [CGROUP_IP_EGRESS_PACKETS] = "IP_METRIC_EGRESS_PACKETS",
2161 };
bc40a20e
LP
2162 const char* const io_fields[_CGROUP_IO_ACCOUNTING_METRIC_MAX] = {
2163 [CGROUP_IO_READ_BYTES] = "IO_METRIC_READ_BYTES",
2164 [CGROUP_IO_WRITE_BYTES] = "IO_METRIC_WRITE_BYTES",
2165 [CGROUP_IO_READ_OPERATIONS] = "IO_METRIC_READ_OPERATIONS",
2166 [CGROUP_IO_WRITE_OPERATIONS] = "IO_METRIC_WRITE_OPERATIONS",
2167 };
915b1d01
LP
2168
2169 assert(u);
2170
2171 /* Invoked whenever a unit enters failed or dead state. Logs information about consumed resources if resource
2172 * accounting was enabled for a unit. It does this in two ways: a friendly human readable string with reduced
2173 * information and the complete data in structured fields. */
2174
2175 (void) unit_get_cpu_usage(u, &nsec);
2176 if (nsec != NSEC_INFINITY) {
2177 char buf[FORMAT_TIMESPAN_MAX] = "";
2178
2179 /* Format the CPU time for inclusion in the structured log message */
2180 if (asprintf(&t, "CPU_USAGE_NSEC=%" PRIu64, nsec) < 0) {
2181 r = log_oom();
2182 goto finish;
2183 }
2184 iovec[n_iovec++] = IOVEC_MAKE_STRING(t);
2185
2186 /* Format the CPU time for inclusion in the human language message string */
2187 format_timespan(buf, sizeof(buf), nsec / NSEC_PER_USEC, USEC_PER_MSEC);
ec9d636b 2188 t = strjoin("consumed ", buf, " CPU time");
915b1d01
LP
2189 if (!t) {
2190 r = log_oom();
2191 goto finish;
2192 }
2193
2194 message_parts[n_message_parts++] = t;
37109b85
ZJS
2195
2196 log_level = raise_level(log_level,
2197 nsec > NOTICEWORTHY_CPU_NSEC,
2198 nsec > MENTIONWORTHY_CPU_NSEC);
915b1d01
LP
2199 }
2200
bc40a20e
LP
2201 for (CGroupIOAccountingMetric k = 0; k < _CGROUP_IO_ACCOUNTING_METRIC_MAX; k++) {
2202 char buf[FORMAT_BYTES_MAX] = "";
2203 uint64_t value = UINT64_MAX;
2204
2205 assert(io_fields[k]);
2206
2207 (void) unit_get_io_accounting(u, k, k > 0, &value);
2208 if (value == UINT64_MAX)
2209 continue;
2210
2211 have_io_accounting = true;
2212 if (value > 0)
2213 any_io = true;
2214
2215 /* Format IO accounting data for inclusion in the structured log message */
2216 if (asprintf(&t, "%s=%" PRIu64, io_fields[k], value) < 0) {
2217 r = log_oom();
2218 goto finish;
2219 }
2220 iovec[n_iovec++] = IOVEC_MAKE_STRING(t);
2221
2222 /* Format the IO accounting data for inclusion in the human language message string, but only
2223 * for the bytes counters (and not for the operations counters) */
2224 if (k == CGROUP_IO_READ_BYTES) {
2225 assert(!rr);
2226 rr = strjoin("read ", format_bytes(buf, sizeof(buf), value), " from disk");
2227 if (!rr) {
2228 r = log_oom();
2229 goto finish;
2230 }
2231 } else if (k == CGROUP_IO_WRITE_BYTES) {
2232 assert(!wr);
2233 wr = strjoin("written ", format_bytes(buf, sizeof(buf), value), " to disk");
2234 if (!wr) {
2235 r = log_oom();
2236 goto finish;
2237 }
2238 }
37109b85
ZJS
2239
2240 if (IN_SET(k, CGROUP_IO_READ_BYTES, CGROUP_IO_WRITE_BYTES))
2241 log_level = raise_level(log_level,
2242 value > MENTIONWORTHY_IO_BYTES,
2243 value > NOTICEWORTHY_IO_BYTES);
bc40a20e
LP
2244 }
2245
2246 if (have_io_accounting) {
2247 if (any_io) {
2248 if (rr)
2249 message_parts[n_message_parts++] = TAKE_PTR(rr);
2250 if (wr)
2251 message_parts[n_message_parts++] = TAKE_PTR(wr);
2252
2253 } else {
2254 char *k;
2255
2256 k = strdup("no IO");
2257 if (!k) {
2258 r = log_oom();
2259 goto finish;
2260 }
2261
2262 message_parts[n_message_parts++] = k;
2263 }
2264 }
2265
915b1d01
LP
2266 for (m = 0; m < _CGROUP_IP_ACCOUNTING_METRIC_MAX; m++) {
2267 char buf[FORMAT_BYTES_MAX] = "";
2268 uint64_t value = UINT64_MAX;
2269
2270 assert(ip_fields[m]);
2271
2272 (void) unit_get_ip_accounting(u, m, &value);
2273 if (value == UINT64_MAX)
2274 continue;
82044702
LP
2275
2276 have_ip_accounting = true;
a87b1faa
LP
2277 if (value > 0)
2278 any_traffic = true;
915b1d01
LP
2279
2280 /* Format IP accounting data for inclusion in the structured log message */
2281 if (asprintf(&t, "%s=%" PRIu64, ip_fields[m], value) < 0) {
2282 r = log_oom();
2283 goto finish;
2284 }
2285 iovec[n_iovec++] = IOVEC_MAKE_STRING(t);
2286
2287 /* Format the IP accounting data for inclusion in the human language message string, but only for the
2288 * bytes counters (and not for the packets counters) */
a87b1faa
LP
2289 if (m == CGROUP_IP_INGRESS_BYTES) {
2290 assert(!igress);
ec9d636b 2291 igress = strjoin("received ", format_bytes(buf, sizeof(buf), value), " IP traffic");
a87b1faa
LP
2292 if (!igress) {
2293 r = log_oom();
2294 goto finish;
2295 }
2296 } else if (m == CGROUP_IP_EGRESS_BYTES) {
2297 assert(!egress);
ec9d636b 2298 egress = strjoin("sent ", format_bytes(buf, sizeof(buf), value), " IP traffic");
a87b1faa
LP
2299 if (!egress) {
2300 r = log_oom();
2301 goto finish;
2302 }
2303 }
37109b85
ZJS
2304
2305 if (IN_SET(m, CGROUP_IP_INGRESS_BYTES, CGROUP_IP_EGRESS_BYTES))
2306 log_level = raise_level(log_level,
2307 value > MENTIONWORTHY_IP_BYTES,
2308 value > NOTICEWORTHY_IP_BYTES);
a87b1faa
LP
2309 }
2310
82044702
LP
2311 if (have_ip_accounting) {
2312 if (any_traffic) {
2313 if (igress)
2314 message_parts[n_message_parts++] = TAKE_PTR(igress);
2315 if (egress)
2316 message_parts[n_message_parts++] = TAKE_PTR(egress);
a87b1faa 2317
82044702
LP
2318 } else {
2319 char *k;
915b1d01 2320
82044702
LP
2321 k = strdup("no IP traffic");
2322 if (!k) {
2323 r = log_oom();
2324 goto finish;
2325 }
2326
2327 message_parts[n_message_parts++] = k;
2328 }
915b1d01
LP
2329 }
2330
2331 /* Is there any accounting data available at all? */
2332 if (n_iovec == 0) {
2333 r = 0;
2334 goto finish;
2335 }
2336
2337 if (n_message_parts == 0)
a87b1faa 2338 t = strjoina("MESSAGE=", u->id, ": Completed.");
915b1d01
LP
2339 else {
2340 _cleanup_free_ char *joined;
2341
2342 message_parts[n_message_parts] = NULL;
2343
2344 joined = strv_join(message_parts, ", ");
2345 if (!joined) {
2346 r = log_oom();
2347 goto finish;
2348 }
2349
ec9d636b 2350 joined[0] = ascii_toupper(joined[0]);
a87b1faa 2351 t = strjoina("MESSAGE=", u->id, ": ", joined, ".");
915b1d01
LP
2352 }
2353
2354 /* The following four fields we allocate on the stack or are static strings, we hence don't want to free them,
2355 * and hence don't increase n_iovec for them */
2356 iovec[n_iovec] = IOVEC_MAKE_STRING(t);
2357 iovec[n_iovec + 1] = IOVEC_MAKE_STRING("MESSAGE_ID=" SD_MESSAGE_UNIT_RESOURCES_STR);
2358
2359 t = strjoina(u->manager->unit_log_field, u->id);
2360 iovec[n_iovec + 2] = IOVEC_MAKE_STRING(t);
2361
2362 t = strjoina(u->manager->invocation_log_field, u->invocation_id_string);
2363 iovec[n_iovec + 3] = IOVEC_MAKE_STRING(t);
2364
37109b85 2365 log_struct_iovec(log_level, iovec, n_iovec + 4);
915b1d01
LP
2366 r = 0;
2367
2368finish:
2369 for (i = 0; i < n_message_parts; i++)
2370 free(message_parts[i]);
2371
2372 for (i = 0; i < n_iovec; i++)
2373 free(iovec[i].iov_base);
2374
2375 return r;
2376
2377}
2378
adefcf28
LP
2379static void unit_update_on_console(Unit *u) {
2380 bool b;
2381
2382 assert(u);
2383
2384 b = unit_needs_console(u);
2385 if (u->on_console == b)
2386 return;
2387
2388 u->on_console = b;
2389 if (b)
2390 manager_ref_console(u->manager);
2391 else
2392 manager_unref_console(u->manager);
adefcf28
LP
2393}
2394
6eb65e7c
LP
2395static void unit_emit_audit_start(Unit *u) {
2396 assert(u);
2397
2398 if (u->type != UNIT_SERVICE)
2399 return;
2400
2401 /* Write audit record if we have just finished starting up */
2402 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, true);
2403 u->in_audit = true;
2404}
2405
2406static void unit_emit_audit_stop(Unit *u, UnitActiveState state) {
2407 assert(u);
2408
2409 if (u->type != UNIT_SERVICE)
2410 return;
2411
2412 if (u->in_audit) {
2413 /* Write audit record if we have just finished shutting down */
2414 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, state == UNIT_INACTIVE);
2415 u->in_audit = false;
2416 } else {
2417 /* Hmm, if there was no start record written write it now, so that we always have a nice pair */
2418 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_START, state == UNIT_INACTIVE);
2419
2420 if (state == UNIT_INACTIVE)
2421 manager_send_unit_audit(u->manager, u, AUDIT_SERVICE_STOP, true);
2422 }
2423}
2424
16c74914
LP
2425static bool unit_process_job(Job *j, UnitActiveState ns, UnitNotifyFlags flags) {
2426 bool unexpected = false;
31cd5f63 2427 JobResult result;
16c74914
LP
2428
2429 assert(j);
2430
2431 if (j->state == JOB_WAITING)
2432
2433 /* So we reached a different state for this job. Let's see if we can run it now if it failed previously
2434 * due to EAGAIN. */
2435 job_add_to_run_queue(j);
2436
2437 /* Let's check whether the unit's new state constitutes a finished job, or maybe contradicts a running job and
2438 * hence needs to invalidate jobs. */
2439
2440 switch (j->type) {
2441
2442 case JOB_START:
2443 case JOB_VERIFY_ACTIVE:
2444
2445 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
2446 job_finish_and_invalidate(j, JOB_DONE, true, false);
2447 else if (j->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
2448 unexpected = true;
2449
31cd5f63
AZ
2450 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
2451 if (ns == UNIT_FAILED)
2452 result = JOB_FAILED;
2453 else if (FLAGS_SET(flags, UNIT_NOTIFY_SKIP_CONDITION))
2454 result = JOB_SKIPPED;
2455 else
2456 result = JOB_DONE;
2457
2458 job_finish_and_invalidate(j, result, true, false);
2459 }
16c74914
LP
2460 }
2461
2462 break;
2463
2464 case JOB_RELOAD:
2465 case JOB_RELOAD_OR_START:
2466 case JOB_TRY_RELOAD:
2467
2468 if (j->state == JOB_RUNNING) {
2469 if (ns == UNIT_ACTIVE)
2470 job_finish_and_invalidate(j, (flags & UNIT_NOTIFY_RELOAD_FAILURE) ? JOB_FAILED : JOB_DONE, true, false);
2471 else if (!IN_SET(ns, UNIT_ACTIVATING, UNIT_RELOADING)) {
2472 unexpected = true;
2473
2474 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
2475 job_finish_and_invalidate(j, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true, false);
2476 }
2477 }
2478
2479 break;
2480
2481 case JOB_STOP:
2482 case JOB_RESTART:
2483 case JOB_TRY_RESTART:
2484
2485 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
2486 job_finish_and_invalidate(j, JOB_DONE, true, false);
2487 else if (j->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
2488 unexpected = true;
2489 job_finish_and_invalidate(j, JOB_FAILED, true, false);
2490 }
2491
2492 break;
2493
2494 default:
2495 assert_not_reached("Job type unknown");
2496 }
2497
2498 return unexpected;
2499}
2500
2ad2e41a 2501void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, UnitNotifyFlags flags) {
429926e9 2502 const char *reason;
8559b3b7 2503 Manager *m;
a096ed36 2504
87f0e418
LP
2505 assert(u);
2506 assert(os < _UNIT_ACTIVE_STATE_MAX);
2507 assert(ns < _UNIT_ACTIVE_STATE_MAX);
87f0e418 2508
8559b3b7
LP
2509 /* Note that this is called for all low-level state changes, even if they might map to the same high-level
2510 * UnitActiveState! That means that ns == os is an expected behavior here. For example: if a mount point is
2511 * remounted this function will be called too! */
87f0e418 2512
546ac4f0
MS
2513 m = u->manager;
2514
3c4832ad
LP
2515 /* Let's enqueue the change signal early. In case this unit has a job associated we want that this unit is in
2516 * the bus queue, so that any job change signal queued will force out the unit change signal first. */
2517 unit_add_to_dbus_queue(u);
2518
f755e3b7 2519 /* Update timestamps for state changes */
2c289ea8 2520 if (!MANAGER_IS_RELOADING(m)) {
a483fb59 2521 dual_timestamp_get(&u->state_change_timestamp);
173e3821 2522
bdbf9951 2523 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
a483fb59 2524 u->inactive_exit_timestamp = u->state_change_timestamp;
bdbf9951 2525 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
a483fb59 2526 u->inactive_enter_timestamp = u->state_change_timestamp;
bdbf9951
LP
2527
2528 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
a483fb59 2529 u->active_enter_timestamp = u->state_change_timestamp;
bdbf9951 2530 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
a483fb59 2531 u->active_exit_timestamp = u->state_change_timestamp;
bdbf9951 2532 }
87f0e418 2533
865cc19a 2534 /* Keep track of failed units */
8724defe 2535 (void) manager_update_failed_units(m, u, ns == UNIT_FAILED);
f755e3b7 2536
d3070fbd
LP
2537 /* Make sure the cgroup and state files are always removed when we become inactive */
2538 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
efdb0237 2539 unit_prune_cgroup(u);
d3070fbd
LP
2540 unit_unlink_state_files(u);
2541 }
fb385181 2542
adefcf28 2543 unit_update_on_console(u);
7ed9f6cd 2544
2c289ea8 2545 if (!MANAGER_IS_RELOADING(m)) {
a1c7334b
LP
2546 bool unexpected;
2547
2548 /* Let's propagate state changes to the job */
2549 if (u->job)
2550 unexpected = unit_process_job(u->job, ns, flags);
2551 else
2552 unexpected = true;
f3bff0eb 2553
a1c7334b
LP
2554 /* If this state change happened without being requested by a job, then let's retroactively start or
2555 * stop dependencies. We skip that step when deserializing, since we don't want to create any
2556 * additional jobs just because something is already activated. */
bdbf9951
LP
2557
2558 if (unexpected) {
2559 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
2560 retroactively_start_dependencies(u);
2561 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
2562 retroactively_stop_dependencies(u);
2563 }
5de9682c 2564
cd0504d0 2565 /* stop unneeded units regardless if going down was expected or not */
a3c1168a 2566 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
cd0504d0
MS
2567 check_unneeded_dependencies(u);
2568
bdbf9951 2569 if (ns != os && ns == UNIT_FAILED) {
ed77d407 2570 log_unit_debug(u, "Unit entered failed state.");
2ad2e41a
LP
2571
2572 if (!(flags & UNIT_NOTIFY_WILL_AUTO_RESTART))
2573 unit_start_on_failure(u);
cd6d0a45 2574 }
e537352b 2575
256f65d0
LP
2576 if (UNIT_IS_ACTIVE_OR_RELOADING(ns) && !UNIT_IS_ACTIVE_OR_RELOADING(os)) {
2577 /* This unit just finished starting up */
3b2775c5 2578
6eb65e7c 2579 unit_emit_audit_start(u);
546ac4f0 2580 manager_send_unit_plymouth(m, u);
256f65d0 2581 }
bdbf9951 2582
256f65d0 2583 if (UNIT_IS_INACTIVE_OR_FAILED(ns) && !UNIT_IS_INACTIVE_OR_FAILED(os)) {
915b1d01 2584 /* This unit just stopped/failed. */
256f65d0 2585
6eb65e7c 2586 unit_emit_audit_stop(u, ns);
915b1d01 2587 unit_log_resources(u);
cd6d0a45 2588 }
f278026d
LP
2589 }
2590
31dc1ca3
LP
2591 manager_recheck_journal(m);
2592 manager_recheck_dbus(m);
e63ebf71 2593
3ecaa09b 2594 unit_trigger_notify(u);
3b2775c5 2595
8724defe 2596 if (!MANAGER_IS_RELOADING(m)) {
8559b3b7 2597 /* Maybe we finished startup and are now ready for being stopped because unneeded? */
fda09318 2598 unit_submit_to_stop_when_unneeded_queue(u);
c1e1601e 2599
8559b3b7
LP
2600 /* Maybe we finished startup, but something we needed has vanished? Let's die then. (This happens when
2601 * something BindsTo= to a Type=oneshot unit, as these units go directly from starting to inactive,
ff502445
LP
2602 * without ever entering started.) */
2603 unit_check_binds_to(u);
53c35a76 2604
429926e9
TR
2605 if (os != UNIT_FAILED && ns == UNIT_FAILED) {
2606 reason = strjoina("unit ", u->id, " failed");
36c4dc08 2607 emergency_action(m, u->failure_action, 0, u->reboot_arg, unit_failure_action_exit_status(u), reason);
429926e9
TR
2608 } else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && ns == UNIT_INACTIVE) {
2609 reason = strjoina("unit ", u->id, " succeeded");
36c4dc08 2610 emergency_action(m, u->success_action, 0, u->reboot_arg, unit_success_action_exit_status(u), reason);
429926e9 2611 }
ff502445
LP
2612 }
2613
701cc384 2614 unit_add_to_gc_queue(u);
87f0e418
LP
2615}
2616
f75f613d 2617int unit_watch_pid(Unit *u, pid_t pid, bool exclusive) {
62a76913 2618 int r;
a911bb9a 2619
87f0e418 2620 assert(u);
62a76913 2621 assert(pid_is_valid(pid));
87f0e418 2622
62a76913 2623 /* Watch a specific PID */
5ba6985b 2624
f75f613d
FB
2625 /* Caller might be sure that this PID belongs to this unit only. Let's take this
2626 * opportunity to remove any stalled references to this PID as they can be created
2627 * easily (when watching a process which is not our direct child). */
2628 if (exclusive)
2629 manager_unwatch_pid(u->manager, pid);
2630
d5099efc 2631 r = set_ensure_allocated(&u->pids, NULL);
5ba6985b
LP
2632 if (r < 0)
2633 return r;
2634
62a76913 2635 r = hashmap_ensure_allocated(&u->manager->watch_pids, NULL);
a911bb9a
LP
2636 if (r < 0)
2637 return r;
2638
62a76913
LP
2639 /* First try, let's add the unit keyed by "pid". */
2640 r = hashmap_put(u->manager->watch_pids, PID_TO_PTR(pid), u);
2641 if (r == -EEXIST) {
2642 Unit **array;
2643 bool found = false;
2644 size_t n = 0;
05e343b7 2645
62a76913
LP
2646 /* OK, the "pid" key is already assigned to a different unit. Let's see if the "-pid" key (which points
2647 * to an array of Units rather than just a Unit), lists us already. */
a911bb9a 2648
62a76913
LP
2649 array = hashmap_get(u->manager->watch_pids, PID_TO_PTR(-pid));
2650 if (array)
2651 for (; array[n]; n++)
2652 if (array[n] == u)
2653 found = true;
a911bb9a 2654
62a76913
LP
2655 if (found) /* Found it already? if so, do nothing */
2656 r = 0;
2657 else {
2658 Unit **new_array;
2659
2660 /* Allocate a new array */
2661 new_array = new(Unit*, n + 2);
2662 if (!new_array)
2663 return -ENOMEM;
2664
2665 memcpy_safe(new_array, array, sizeof(Unit*) * n);
2666 new_array[n] = u;
2667 new_array[n+1] = NULL;
2668
2669 /* Add or replace the old array */
2670 r = hashmap_replace(u->manager->watch_pids, PID_TO_PTR(-pid), new_array);
2671 if (r < 0) {
2672 free(new_array);
2673 return r;
2674 }
2675
2676 free(array);
2677 }
2678 } else if (r < 0)
2679 return r;
2680
2681 r = set_put(u->pids, PID_TO_PTR(pid));
2682 if (r < 0)
2683 return r;
2684
2685 return 0;
87f0e418
LP
2686}
2687
2688void unit_unwatch_pid(Unit *u, pid_t pid) {
62a76913
LP
2689 Unit **array;
2690
87f0e418 2691 assert(u);
62a76913
LP
2692 assert(pid_is_valid(pid));
2693
2694 /* First let's drop the unit in case it's keyed as "pid". */
2695 (void) hashmap_remove_value(u->manager->watch_pids, PID_TO_PTR(pid), u);
2696
2697 /* Then, let's also drop the unit, in case it's in the array keyed by -pid */
2698 array = hashmap_get(u->manager->watch_pids, PID_TO_PTR(-pid));
2699 if (array) {
2700 size_t n, m = 0;
2701
2702 /* Let's iterate through the array, dropping our own entry */
2703 for (n = 0; array[n]; n++)
2704 if (array[n] != u)
2705 array[m++] = array[n];
2706 array[m] = NULL;
2707
2708 if (m == 0) {
2709 /* The array is now empty, remove the entire entry */
2710 assert(hashmap_remove(u->manager->watch_pids, PID_TO_PTR(-pid)) == array);
2711 free(array);
2712 }
2713 }
87f0e418 2714
fea72cc0 2715 (void) set_remove(u->pids, PID_TO_PTR(pid));
a911bb9a
LP
2716}
2717
bd44e61b
LP
2718void unit_unwatch_all_pids(Unit *u) {
2719 assert(u);
2720
2721 while (!set_isempty(u->pids))
fea72cc0 2722 unit_unwatch_pid(u, PTR_TO_PID(set_first(u->pids)));
bd44e61b 2723
efdb0237 2724 u->pids = set_free(u->pids);
a911bb9a
LP
2725}
2726
50be4f4a
LP
2727static void unit_tidy_watch_pids(Unit *u) {
2728 pid_t except1, except2;
a911bb9a
LP
2729 Iterator i;
2730 void *e;
2731
2732 assert(u);
2733
2734 /* Cleans dead PIDs from our list */
2735
50be4f4a
LP
2736 except1 = unit_main_pid(u);
2737 except2 = unit_control_pid(u);
2738
a911bb9a 2739 SET_FOREACH(e, u->pids, i) {
fea72cc0 2740 pid_t pid = PTR_TO_PID(e);
a911bb9a
LP
2741
2742 if (pid == except1 || pid == except2)
2743 continue;
2744
9f5650ae 2745 if (!pid_is_unwaited(pid))
bd44e61b 2746 unit_unwatch_pid(u, pid);
a911bb9a 2747 }
87f0e418
LP
2748}
2749
50be4f4a
LP
2750static int on_rewatch_pids_event(sd_event_source *s, void *userdata) {
2751 Unit *u = userdata;
2752
2753 assert(s);
2754 assert(u);
2755
2756 unit_tidy_watch_pids(u);
2757 unit_watch_all_pids(u);
2758
2759 /* If the PID set is empty now, then let's finish this off. */
2760 unit_synthesize_cgroup_empty_event(u);
2761
2762 return 0;
2763}
2764
2765int unit_enqueue_rewatch_pids(Unit *u) {
2766 int r;
2767
2768 assert(u);
2769
2770 if (!u->cgroup_path)
2771 return -ENOENT;
2772
2773 r = cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER);
2774 if (r < 0)
2775 return r;
2776 if (r > 0) /* On unified we can use proper notifications */
2777 return 0;
2778
2779 /* Enqueues a low-priority job that will clean up dead PIDs from our list of PIDs to watch and subscribe to new
2780 * PIDs that might have appeared. We do this in a delayed job because the work might be quite slow, as it
2781 * involves issuing kill(pid, 0) on all processes we watch. */
2782
2783 if (!u->rewatch_pids_event_source) {
2784 _cleanup_(sd_event_source_unrefp) sd_event_source *s = NULL;
2785
2786 r = sd_event_add_defer(u->manager->event, &s, on_rewatch_pids_event, u);
2787 if (r < 0)
2788 return log_error_errno(r, "Failed to allocate event source for tidying watched PIDs: %m");
2789
2790 r = sd_event_source_set_priority(s, SD_EVENT_PRIORITY_IDLE);
2791 if (r < 0)
2792 return log_error_errno(r, "Failed to adjust priority of event source for tidying watched PIDs: m");
2793
2794 (void) sd_event_source_set_description(s, "tidy-watch-pids");
2795
2796 u->rewatch_pids_event_source = TAKE_PTR(s);
2797 }
2798
2799 r = sd_event_source_set_enabled(u->rewatch_pids_event_source, SD_EVENT_ONESHOT);
2800 if (r < 0)
2801 return log_error_errno(r, "Failed to enable event source for tidying watched PIDs: %m");
2802
2803 return 0;
2804}
2805
2806void unit_dequeue_rewatch_pids(Unit *u) {
2807 int r;
2808 assert(u);
2809
2810 if (!u->rewatch_pids_event_source)
2811 return;
2812
2813 r = sd_event_source_set_enabled(u->rewatch_pids_event_source, SD_EVENT_OFF);
2814 if (r < 0)
2815 log_warning_errno(r, "Failed to disable event source for tidying watched PIDs, ignoring: %m");
2816
2817 u->rewatch_pids_event_source = sd_event_source_unref(u->rewatch_pids_event_source);
2818}
2819
87f0e418
LP
2820bool unit_job_is_applicable(Unit *u, JobType j) {
2821 assert(u);
2822 assert(j >= 0 && j < _JOB_TYPE_MAX);
2823
2824 switch (j) {
2825
2826 case JOB_VERIFY_ACTIVE:
2827 case JOB_START:
e0209d83 2828 case JOB_NOP:
f5869324
LP
2829 /* Note that we don't check unit_can_start() here. That's because .device units and suchlike are not
2830 * startable by us but may appear due to external events, and it thus makes sense to permit enqueing
2831 * jobs for it. */
87f0e418
LP
2832 return true;
2833
f5869324
LP
2834 case JOB_STOP:
2835 /* Similar as above. However, perpetual units can never be stopped (neither explicitly nor due to
2836 * external events), hence it makes no sense to permit enqueing such a request either. */
2837 return !u->perpetual;
2838
87f0e418
LP
2839 case JOB_RESTART:
2840 case JOB_TRY_RESTART:
f5869324 2841 return unit_can_stop(u) && unit_can_start(u);
87f0e418
LP
2842
2843 case JOB_RELOAD:
3282591d 2844 case JOB_TRY_RELOAD:
87f0e418
LP
2845 return unit_can_reload(u);
2846
2847 case JOB_RELOAD_OR_START:
2848 return unit_can_reload(u) && unit_can_start(u);
2849
2850 default:
2851 assert_not_reached("Invalid job type");
2852 }
2853}
2854
f2341e0a
LP
2855static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency) {
2856 assert(u);
d1fab3fe 2857
f2341e0a
LP
2858 /* Only warn about some unit types */
2859 if (!IN_SET(dependency, UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY))
2860 return;
3f3cc397 2861
f2341e0a
LP
2862 if (streq_ptr(u->id, other))
2863 log_unit_warning(u, "Dependency %s=%s dropped", unit_dependency_to_string(dependency), u->id);
2864 else
2865 log_unit_warning(u, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency), strna(other), u->id);
d1fab3fe
ZJS
2866}
2867
eef85c4a
LP
2868static int unit_add_dependency_hashmap(
2869 Hashmap **h,
2870 Unit *other,
2871 UnitDependencyMask origin_mask,
2872 UnitDependencyMask destination_mask) {
2873
2874 UnitDependencyInfo info;
2875 int r;
2876
2877 assert(h);
2878 assert(other);
2879 assert(origin_mask < _UNIT_DEPENDENCY_MASK_FULL);
2880 assert(destination_mask < _UNIT_DEPENDENCY_MASK_FULL);
2881 assert(origin_mask > 0 || destination_mask > 0);
2882
2883 r = hashmap_ensure_allocated(h, NULL);
2884 if (r < 0)
2885 return r;
2886
2887 assert_cc(sizeof(void*) == sizeof(info));
2888
2889 info.data = hashmap_get(*h, other);
2890 if (info.data) {
2891 /* Entry already exists. Add in our mask. */
2892
d94a24ca
ZJS
2893 if (FLAGS_SET(origin_mask, info.origin_mask) &&
2894 FLAGS_SET(destination_mask, info.destination_mask))
eef85c4a
LP
2895 return 0; /* NOP */
2896
2897 info.origin_mask |= origin_mask;
2898 info.destination_mask |= destination_mask;
2899
2900 r = hashmap_update(*h, other, info.data);
2901 } else {
2902 info = (UnitDependencyInfo) {
2903 .origin_mask = origin_mask,
2904 .destination_mask = destination_mask,
2905 };
2906
2907 r = hashmap_put(*h, other, info.data);
2908 }
2909 if (r < 0)
2910 return r;
2911
2912 return 1;
2913}
2914
2915int unit_add_dependency(
2916 Unit *u,
2917 UnitDependency d,
2918 Unit *other,
2919 bool add_reference,
2920 UnitDependencyMask mask) {
87f0e418
LP
2921
2922 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2923 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
87f0e418 2924 [UNIT_WANTS] = UNIT_WANTED_BY,
be7d9ff7 2925 [UNIT_REQUISITE] = UNIT_REQUISITE_OF,
7f2cddae 2926 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
60649f17 2927 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
be7d9ff7 2928 [UNIT_REQUIRED_BY] = UNIT_REQUIRES,
be7d9ff7 2929 [UNIT_REQUISITE_OF] = UNIT_REQUISITE,
be7d9ff7 2930 [UNIT_WANTED_BY] = UNIT_WANTS,
7f2cddae 2931 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
60649f17 2932 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
69dd2852
LP
2933 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2934 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
87f0e418 2935 [UNIT_BEFORE] = UNIT_AFTER,
701cc384 2936 [UNIT_AFTER] = UNIT_BEFORE,
5de9682c 2937 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
701cc384 2938 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
57020a3a
LP
2939 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2940 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
4dcc1cb4 2941 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
7f2cddae 2942 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
85e9a101 2943 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
613b411c 2944 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
87f0e418 2945 };
eef85c4a
LP
2946 Unit *original_u = u, *original_other = other;
2947 int r;
87f0e418
LP
2948
2949 assert(u);
2950 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
87f0e418
LP
2951 assert(other);
2952
9f151f29
LP
2953 u = unit_follow_merge(u);
2954 other = unit_follow_merge(other);
2955
87f0e418
LP
2956 /* We won't allow dependencies on ourselves. We will not
2957 * consider them an error however. */
d1fab3fe 2958 if (u == other) {
eef85c4a 2959 maybe_warn_about_dependency(original_u, original_other->id, d);
87f0e418 2960 return 0;
d1fab3fe 2961 }
87f0e418 2962
eef85c4a
LP
2963 if ((d == UNIT_BEFORE && other->type == UNIT_DEVICE) ||
2964 (d == UNIT_AFTER && u->type == UNIT_DEVICE)) {
dd5e7000
ZJS
2965 log_unit_warning(u, "Dependency Before=%s ignored (.device units cannot be delayed)", other->id);
2966 return 0;
2967 }
2968
eef85c4a 2969 r = unit_add_dependency_hashmap(u->dependencies + d, other, mask, 0);
613b411c 2970 if (r < 0)
87f0e418
LP
2971 return r;
2972
eef85c4a
LP
2973 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2974 r = unit_add_dependency_hashmap(other->dependencies + inverse_table[d], u, 0, mask);
613b411c
LP
2975 if (r < 0)
2976 return r;
2977 }
2978
2979 if (add_reference) {
eef85c4a 2980 r = unit_add_dependency_hashmap(u->dependencies + UNIT_REFERENCES, other, mask, 0);
613b411c 2981 if (r < 0)
5de9682c
LP
2982 return r;
2983
eef85c4a 2984 r = unit_add_dependency_hashmap(other->dependencies + UNIT_REFERENCED_BY, u, 0, mask);
613b411c 2985 if (r < 0)
701cc384 2986 return r;
613b411c 2987 }
87f0e418 2988
c1e1601e 2989 unit_add_to_dbus_queue(u);
87f0e418
LP
2990 return 0;
2991}
0301abf4 2992
eef85c4a 2993int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference, UnitDependencyMask mask) {
2c966c03
LP
2994 int r;
2995
2996 assert(u);
2997
eef85c4a 2998 r = unit_add_dependency(u, d, other, add_reference, mask);
3f3cc397 2999 if (r < 0)
2c966c03
LP
3000 return r;
3001
eef85c4a 3002 return unit_add_dependency(u, e, other, add_reference, mask);
2c966c03
LP
3003}
3004
23e8c796 3005static int resolve_template(Unit *u, const char *name, char **buf, const char **ret) {
7410616c 3006 int r;
9e2f7c11
LP
3007
3008 assert(u);
23e8c796 3009 assert(name);
7410616c
LP
3010 assert(buf);
3011 assert(ret);
9e2f7c11 3012
7410616c
LP
3013 if (!unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
3014 *buf = NULL;
3015 *ret = name;
3016 return 0;
9e2f7c11
LP
3017 }
3018
ac155bb8 3019 if (u->instance)
7410616c 3020 r = unit_name_replace_instance(name, u->instance, buf);
9e2f7c11 3021 else {
ae018d9b 3022 _cleanup_free_ char *i = NULL;
9e2f7c11 3023
7410616c
LP
3024 r = unit_name_to_prefix(u->id, &i);
3025 if (r < 0)
3026 return r;
9e2f7c11 3027
7410616c 3028 r = unit_name_replace_instance(name, i, buf);
9e2f7c11 3029 }
7410616c
LP
3030 if (r < 0)
3031 return r;
9e2f7c11 3032
7410616c
LP
3033 *ret = *buf;
3034 return 0;
9e2f7c11
LP
3035}
3036
35d8c19a 3037int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, bool add_reference, UnitDependencyMask mask) {
7410616c 3038 _cleanup_free_ char *buf = NULL;
09b6b09f
LP
3039 Unit *other;
3040 int r;
3041
9e2f7c11 3042 assert(u);
35d8c19a 3043 assert(name);
09b6b09f 3044
23e8c796 3045 r = resolve_template(u, name, &buf, &name);
7410616c
LP
3046 if (r < 0)
3047 return r;
09b6b09f 3048
35d8c19a 3049 r = manager_load_unit(u->manager, name, NULL, NULL, &other);
8afbb8e1
LP
3050 if (r < 0)
3051 return r;
9e2f7c11 3052
eef85c4a 3053 return unit_add_dependency(u, d, other, add_reference, mask);
09b6b09f
LP
3054}
3055
5a724170 3056int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, bool add_reference, UnitDependencyMask mask) {
7410616c 3057 _cleanup_free_ char *buf = NULL;
2c966c03
LP
3058 Unit *other;
3059 int r;
2c966c03
LP
3060
3061 assert(u);
5a724170 3062 assert(name);
2c966c03 3063
23e8c796 3064 r = resolve_template(u, name, &buf, &name);
7410616c
LP
3065 if (r < 0)
3066 return r;
2c966c03 3067
5a724170 3068 r = manager_load_unit(u->manager, name, NULL, NULL, &other);
3f3cc397 3069 if (r < 0)
68eda4bd 3070 return r;
2c966c03 3071
eef85c4a 3072 return unit_add_two_dependencies(u, d, e, other, add_reference, mask);
2c966c03
LP
3073}
3074
0301abf4 3075int set_unit_path(const char *p) {
0301abf4 3076 /* This is mostly for debug purposes */
cbe46ead 3077 if (setenv("SYSTEMD_UNIT_PATH", p, 1) < 0)
26d04f86 3078 return -errno;
0301abf4
LP
3079
3080 return 0;
3081}
88066b3a 3082
ea430986 3083char *unit_dbus_path(Unit *u) {
ea430986
LP
3084 assert(u);
3085
ac155bb8 3086 if (!u->id)
04ade7d2
LP
3087 return NULL;
3088
48899192 3089 return unit_dbus_path_from_name(u->id);
ea430986
LP
3090}
3091
4b58153d
LP
3092char *unit_dbus_path_invocation_id(Unit *u) {
3093 assert(u);
3094
3095 if (sd_id128_is_null(u->invocation_id))
3096 return NULL;
3097
3098 return unit_dbus_path_from_name(u->invocation_id_string);
3099}
3100
d79200e2
LP
3101int unit_set_slice(Unit *u, Unit *slice) {
3102 assert(u);
3103 assert(slice);
3104
3105 /* Sets the unit slice if it has not been set before. Is extra
3106 * careful, to only allow this for units that actually have a
3107 * cgroup context. Also, we don't allow to set this for slices
3108 * (since the parent slice is derived from the name). Make
3109 * sure the unit we set is actually a slice. */
3110
3111 if (!UNIT_HAS_CGROUP_CONTEXT(u))
3112 return -EOPNOTSUPP;
3113
3114 if (u->type == UNIT_SLICE)
3115 return -EINVAL;
3116
102ef982
LP
3117 if (unit_active_state(u) != UNIT_INACTIVE)
3118 return -EBUSY;
3119
d79200e2
LP
3120 if (slice->type != UNIT_SLICE)
3121 return -EINVAL;
3122
efdb0237
LP
3123 if (unit_has_name(u, SPECIAL_INIT_SCOPE) &&
3124 !unit_has_name(slice, SPECIAL_ROOT_SLICE))
3125 return -EPERM;
3126
d79200e2
LP
3127 if (UNIT_DEREF(u->slice) == slice)
3128 return 0;
3129
99e66921
TH
3130 /* Disallow slice changes if @u is already bound to cgroups */
3131 if (UNIT_ISSET(u->slice) && u->cgroup_realized)
d79200e2
LP
3132 return -EBUSY;
3133
7f7d01ed 3134 unit_ref_set(&u->slice, u, slice);
d79200e2
LP
3135 return 1;
3136}
3137
3138int unit_set_default_slice(Unit *u) {
a8833944 3139 const char *slice_name;
a016b922
LP
3140 Unit *slice;
3141 int r;
3142
3143 assert(u);
3144
9444b1f2 3145 if (UNIT_ISSET(u->slice))
a016b922
LP
3146 return 0;
3147
a8833944
LP
3148 if (u->instance) {
3149 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
68eda4bd 3150
a8833944
LP
3151 /* Implicitly place all instantiated units in their
3152 * own per-template slice */
3153
7410616c
LP
3154 r = unit_name_to_prefix(u->id, &prefix);
3155 if (r < 0)
3156 return r;
a8833944
LP
3157
3158 /* The prefix is already escaped, but it might include
3159 * "-" which has a special meaning for slice units,
3160 * hence escape it here extra. */
7410616c 3161 escaped = unit_name_escape(prefix);
a8833944
LP
3162 if (!escaped)
3163 return -ENOMEM;
3164
463d0d15 3165 if (MANAGER_IS_SYSTEM(u->manager))
00e7b3c8 3166 slice_name = strjoina("system-", escaped, ".slice");
a8833944 3167 else
00e7b3c8 3168 slice_name = strjoina(escaped, ".slice");
a8833944
LP
3169 } else
3170 slice_name =
463d0d15 3171 MANAGER_IS_SYSTEM(u->manager) && !unit_has_name(u, SPECIAL_INIT_SCOPE)
a8833944
LP
3172 ? SPECIAL_SYSTEM_SLICE
3173 : SPECIAL_ROOT_SLICE;
3174
3175 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
a016b922
LP
3176 if (r < 0)
3177 return r;
3178
d79200e2 3179 return unit_set_slice(u, slice);
a016b922
LP
3180}
3181
9444b1f2
LP
3182const char *unit_slice_name(Unit *u) {
3183 assert(u);
3184
3185 if (!UNIT_ISSET(u->slice))
3186 return NULL;
3187
3188 return UNIT_DEREF(u->slice)->id;
3189}
3190
f6ff8c29 3191int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
78edb35a 3192 _cleanup_free_ char *t = NULL;
f6ff8c29
LP
3193 int r;
3194
3195 assert(u);
3196 assert(type);
3197 assert(_found);
3198
7410616c
LP
3199 r = unit_name_change_suffix(u->id, type, &t);
3200 if (r < 0)
3201 return r;
3202 if (unit_has_name(u, t))
3203 return -EINVAL;
f6ff8c29 3204
ac155bb8 3205 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
9e2f7c11 3206 assert(r < 0 || *_found != u);
f6ff8c29
LP
3207 return r;
3208}
3209
bbc29086
DM
3210static int signal_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
3211 const char *name, *old_owner, *new_owner;
3212 Unit *u = userdata;
3213 int r;
3214
3215 assert(message);
3216 assert(u);
3217
3218 r = sd_bus_message_read(message, "sss", &name, &old_owner, &new_owner);
3219 if (r < 0) {
3220 bus_log_parse_error(r);
3221 return 0;
3222 }
3223
a8ea93a5
LP
3224 old_owner = empty_to_null(old_owner);
3225 new_owner = empty_to_null(new_owner);
b0076268 3226
bbc29086 3227 if (UNIT_VTABLE(u)->bus_name_owner_change)
a5a8776a
MJ
3228 UNIT_VTABLE(u)->bus_name_owner_change(u, old_owner, new_owner);
3229
3230 return 0;
3231}
3232
3233static int get_name_owner_handler(sd_bus_message *message, void *userdata, sd_bus_error *error) {
3234 const sd_bus_error *e;
3235 const char *new_owner;
3236 Unit *u = userdata;
3237 int r;
3238
3239 assert(message);
3240 assert(u);
3241
3242 u->get_name_owner_slot = sd_bus_slot_unref(u->get_name_owner_slot);
3243
3244 if (sd_bus_error_is_set(error)) {
3245 log_error("Failed to get name owner from bus: %s", error->message);
3246 return 0;
3247 }
3248
3249 e = sd_bus_message_get_error(message);
3250 if (sd_bus_error_has_name(e, "org.freedesktop.DBus.Error.NameHasNoOwner"))
3251 return 0;
3252
3253 if (e) {
3254 log_error("Unexpected error response from GetNameOwner: %s", e->message);
3255 return 0;
3256 }
3257
3258 r = sd_bus_message_read(message, "s", &new_owner);
3259 if (r < 0) {
3260 bus_log_parse_error(r);
3261 return 0;
3262 }
3263
3264 new_owner = empty_to_null(new_owner);
3265
3266 if (UNIT_VTABLE(u)->bus_name_owner_change)
3267 UNIT_VTABLE(u)->bus_name_owner_change(u, NULL, new_owner);
bbc29086
DM
3268
3269 return 0;
3270}
3271
9806e87d
LP
3272int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name) {
3273 const char *match;
bbc29086 3274
9806e87d
LP
3275 assert(u);
3276 assert(bus);
3277 assert(name);
bbc29086
DM
3278
3279 if (u->match_bus_slot)
3280 return -EBUSY;
3281
9806e87d 3282 match = strjoina("type='signal',"
81d62103
ZJS
3283 "sender='org.freedesktop.DBus',"
3284 "path='/org/freedesktop/DBus',"
3285 "interface='org.freedesktop.DBus',"
3286 "member='NameOwnerChanged',"
3287 "arg0='", name, "'");
bbc29086 3288
a5a8776a
MJ
3289 int r = sd_bus_add_match_async(bus, &u->match_bus_slot, match, signal_name_owner_changed, NULL, u);
3290 if (r < 0)
3291 return r;
3292
3293 return sd_bus_call_method_async(bus,
3294 &u->get_name_owner_slot,
3295 "org.freedesktop.DBus",
3296 "/org/freedesktop/DBus",
3297 "org.freedesktop.DBus",
3298 "GetNameOwner",
3299 get_name_owner_handler,
3300 u,
3301 "s", name);
bbc29086
DM
3302}
3303
05e343b7 3304int unit_watch_bus_name(Unit *u, const char *name) {
bbc29086
DM
3305 int r;
3306
05e343b7
LP
3307 assert(u);
3308 assert(name);
3309
3310 /* Watch a specific name on the bus. We only support one unit
3311 * watching each name for now. */
3312
bbc29086
DM
3313 if (u->manager->api_bus) {
3314 /* If the bus is already available, install the match directly.
3315 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
9806e87d 3316 r = unit_install_bus_match(u, u->manager->api_bus, name);
bbc29086 3317 if (r < 0)
8ea823b6 3318 return log_warning_errno(r, "Failed to subscribe to NameOwnerChanged signal for '%s': %m", name);
bbc29086
DM
3319 }
3320
3321 r = hashmap_put(u->manager->watch_bus, name, u);
3322 if (r < 0) {
3323 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
3324 return log_warning_errno(r, "Failed to put bus name to hashmap: %m");
3325 }
3326
3327 return 0;
05e343b7
LP
3328}
3329
3330void unit_unwatch_bus_name(Unit *u, const char *name) {
3331 assert(u);
3332 assert(name);
3333
8367fea5 3334 (void) hashmap_remove_value(u->manager->watch_bus, name, u);
bbc29086 3335 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
a5a8776a 3336 u->get_name_owner_slot = sd_bus_slot_unref(u->get_name_owner_slot);
05e343b7
LP
3337}
3338
a16e1123
LP
3339bool unit_can_serialize(Unit *u) {
3340 assert(u);
3341
3342 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
3343}
3344
d68c645b 3345static int serialize_cgroup_mask(FILE *f, const char *key, CGroupMask mask) {
8b108bd0 3346 _cleanup_free_ char *s = NULL;
d68c645b 3347 int r;
8b108bd0
FB
3348
3349 assert(f);
3350 assert(key);
3351
d68c645b
LP
3352 if (mask == 0)
3353 return 0;
3354
3355 r = cg_mask_to_string(mask, &s);
3356 if (r < 0)
3357 return log_error_errno(r, "Failed to format cgroup mask: %m");
3358
3359 return serialize_item(f, key, s);
8b108bd0
FB
3360}
3361
b82f71c7 3362static const char *const ip_accounting_metric_field[_CGROUP_IP_ACCOUNTING_METRIC_MAX] = {
6b659ed8
LP
3363 [CGROUP_IP_INGRESS_BYTES] = "ip-accounting-ingress-bytes",
3364 [CGROUP_IP_INGRESS_PACKETS] = "ip-accounting-ingress-packets",
3365 [CGROUP_IP_EGRESS_BYTES] = "ip-accounting-egress-bytes",
3366 [CGROUP_IP_EGRESS_PACKETS] = "ip-accounting-egress-packets",
3367};
3368
fbe14fc9
LP
3369static const char *const io_accounting_metric_field_base[_CGROUP_IO_ACCOUNTING_METRIC_MAX] = {
3370 [CGROUP_IO_READ_BYTES] = "io-accounting-read-bytes-base",
3371 [CGROUP_IO_WRITE_BYTES] = "io-accounting-write-bytes-base",
3372 [CGROUP_IO_READ_OPERATIONS] = "io-accounting-read-operations-base",
3373 [CGROUP_IO_WRITE_OPERATIONS] = "io-accounting-write-operations-base",
3374};
3375
3376static const char *const io_accounting_metric_field_last[_CGROUP_IO_ACCOUNTING_METRIC_MAX] = {
3377 [CGROUP_IO_READ_BYTES] = "io-accounting-read-bytes-last",
3378 [CGROUP_IO_WRITE_BYTES] = "io-accounting-write-bytes-last",
3379 [CGROUP_IO_READ_OPERATIONS] = "io-accounting-read-operations-last",
3380 [CGROUP_IO_WRITE_OPERATIONS] = "io-accounting-write-operations-last",
3381};
3382
6b78f9b4 3383int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
6b659ed8 3384 CGroupIPAccountingMetric m;
a16e1123
LP
3385 int r;
3386
3387 assert(u);
3388 assert(f);
3389 assert(fds);
3390
9bdb98c5 3391 if (unit_can_serialize(u)) {
9bdb98c5 3392 r = UNIT_VTABLE(u)->serialize(u, f, fds);
613b411c
LP
3393 if (r < 0)
3394 return r;
e0209d83
MS
3395 }
3396
d68c645b 3397 (void) serialize_dual_timestamp(f, "state-change-timestamp", &u->state_change_timestamp);
a483fb59 3398
d68c645b
LP
3399 (void) serialize_dual_timestamp(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
3400 (void) serialize_dual_timestamp(f, "active-enter-timestamp", &u->active_enter_timestamp);
3401 (void) serialize_dual_timestamp(f, "active-exit-timestamp", &u->active_exit_timestamp);
3402 (void) serialize_dual_timestamp(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
a483fb59 3403
d68c645b
LP
3404 (void) serialize_dual_timestamp(f, "condition-timestamp", &u->condition_timestamp);
3405 (void) serialize_dual_timestamp(f, "assert-timestamp", &u->assert_timestamp);
2791a8f8 3406
ac155bb8 3407 if (dual_timestamp_is_set(&u->condition_timestamp))
d68c645b 3408 (void) serialize_bool(f, "condition-result", u->condition_result);
10717a1a 3409
59fccdc5 3410 if (dual_timestamp_is_set(&u->assert_timestamp))
d68c645b 3411 (void) serialize_bool(f, "assert-result", u->assert_result);
59fccdc5 3412
d68c645b
LP
3413 (void) serialize_bool(f, "transient", u->transient);
3414 (void) serialize_bool(f, "in-audit", u->in_audit);
fe700f46 3415
d68c645b
LP
3416 (void) serialize_bool(f, "exported-invocation-id", u->exported_invocation_id);
3417 (void) serialize_bool(f, "exported-log-level-max", u->exported_log_level_max);
3418 (void) serialize_bool(f, "exported-log-extra-fields", u->exported_log_extra_fields);
3419 (void) serialize_bool(f, "exported-log-rate-limit-interval", u->exported_log_rate_limit_interval);
3420 (void) serialize_bool(f, "exported-log-rate-limit-burst", u->exported_log_rate_limit_burst);
0e699122 3421
d68c645b 3422 (void) serialize_item_format(f, "cpu-usage-base", "%" PRIu64, u->cpu_usage_base);
fe700f46 3423 if (u->cpu_usage_last != NSEC_INFINITY)
d68c645b 3424 (void) serialize_item_format(f, "cpu-usage-last", "%" PRIu64, u->cpu_usage_last);
c2756a68 3425
afcfaa69
LP
3426 if (u->oom_kill_last > 0)
3427 (void) serialize_item_format(f, "oom-kill-last", "%" PRIu64, u->oom_kill_last);
3428
fbe14fc9
LP
3429 for (CGroupIOAccountingMetric im = 0; im < _CGROUP_IO_ACCOUNTING_METRIC_MAX; im++) {
3430 (void) serialize_item_format(f, io_accounting_metric_field_base[im], "%" PRIu64, u->io_accounting_base[im]);
3431
3432 if (u->io_accounting_last[im] != UINT64_MAX)
3433 (void) serialize_item_format(f, io_accounting_metric_field_last[im], "%" PRIu64, u->io_accounting_last[im]);
3434 }
3435
c2756a68 3436 if (u->cgroup_path)
d68c645b
LP
3437 (void) serialize_item(f, "cgroup", u->cgroup_path);
3438
3439 (void) serialize_bool(f, "cgroup-realized", u->cgroup_realized);
3440 (void) serialize_cgroup_mask(f, "cgroup-realized-mask", u->cgroup_realized_mask);
3441 (void) serialize_cgroup_mask(f, "cgroup-enabled-mask", u->cgroup_enabled_mask);
3442 (void) serialize_cgroup_mask(f, "cgroup-invalidated-mask", u->cgroup_invalidated_mask);
c2756a68 3443
00d9ef85 3444 if (uid_is_valid(u->ref_uid))
d68c645b 3445 (void) serialize_item_format(f, "ref-uid", UID_FMT, u->ref_uid);
00d9ef85 3446 if (gid_is_valid(u->ref_gid))
d68c645b 3447 (void) serialize_item_format(f, "ref-gid", GID_FMT, u->ref_gid);
00d9ef85 3448
4b58153d 3449 if (!sd_id128_is_null(u->invocation_id))
d68c645b 3450 (void) serialize_item_format(f, "invocation-id", SD_ID128_FORMAT_STR, SD_ID128_FORMAT_VAL(u->invocation_id));
4b58153d 3451
05a98afd
LP
3452 bus_track_serialize(u->bus_track, f, "ref");
3453
6b659ed8
LP
3454 for (m = 0; m < _CGROUP_IP_ACCOUNTING_METRIC_MAX; m++) {
3455 uint64_t v;
3456
3457 r = unit_get_ip_accounting(u, m, &v);
3458 if (r >= 0)
d68c645b 3459 (void) serialize_item_format(f, ip_accounting_metric_field[m], "%" PRIu64, v);
6b659ed8
LP
3460 }
3461
613b411c
LP
3462 if (serialize_jobs) {
3463 if (u->job) {
d68c645b 3464 fputs("job\n", f);
05a98afd 3465 job_serialize(u->job, f);
613b411c
LP
3466 }
3467
3468 if (u->nop_job) {
d68c645b 3469 fputs("job\n", f);
05a98afd 3470 job_serialize(u->nop_job, f);
613b411c
LP
3471 }
3472 }
3473
a16e1123
LP
3474 /* End marker */
3475 fputc('\n', f);
3476 return 0;
3477}
3478
b17c9620
LP
3479static int unit_deserialize_job(Unit *u, FILE *f) {
3480 _cleanup_(job_freep) Job *j = NULL;
3481 int r;
3482
3483 assert(u);
3484 assert(f);
3485
3486 j = job_new_raw(u);
3487 if (!j)
3488 return log_oom();
3489
3490 r = job_deserialize(j, f);
3491 if (r < 0)
3492 return r;
3493
3494 r = job_install_deserialized(j);
3495 if (r < 0)
3496 return r;
3497
3498 TAKE_PTR(j);
3499 return 0;
3500}
3501
a16e1123
LP
3502int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
3503 int r;
3504
3505 assert(u);
3506 assert(f);
3507 assert(fds);
3508
a16e1123 3509 for (;;) {
8948b341 3510 _cleanup_free_ char *line = NULL;
8948b341 3511 char *l, *v;
83f18c91 3512 ssize_t m;
a16e1123
LP
3513 size_t k;
3514
8948b341
LP
3515 r = read_line(f, LONG_LINE_MAX, &line);
3516 if (r < 0)
3517 return log_error_errno(r, "Failed to read serialization line: %m");
3518 if (r == 0) /* eof */
3519 break;
a16e1123
LP
3520
3521 l = strstrip(line);
8948b341 3522 if (isempty(l)) /* End marker */
a483fb59 3523 break;
a16e1123
LP
3524
3525 k = strcspn(l, "=");
3526
3527 if (l[k] == '=') {
3528 l[k] = 0;
3529 v = l+k+1;
3530 } else
3531 v = l+k;
3532
cca098b0 3533 if (streq(l, "job")) {
39a18c60 3534 if (v[0] == '\0') {
b17c9620
LP
3535 /* New-style serialized job */
3536 r = unit_deserialize_job(u, f);
3537 if (r < 0)
e0209d83 3538 return r;
b17c9620 3539 } else /* Legacy for pre-44 */
ed10fa8c 3540 log_unit_warning(u, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v);
cca098b0 3541 continue;
a483fb59 3542 } else if (streq(l, "state-change-timestamp")) {
d68c645b 3543 (void) deserialize_dual_timestamp(v, &u->state_change_timestamp);
a483fb59 3544 continue;
8aaf019b 3545 } else if (streq(l, "inactive-exit-timestamp")) {
d68c645b 3546 (void) deserialize_dual_timestamp(v, &u->inactive_exit_timestamp);
8aaf019b
LP
3547 continue;
3548 } else if (streq(l, "active-enter-timestamp")) {
d68c645b 3549 (void) deserialize_dual_timestamp(v, &u->active_enter_timestamp);
8aaf019b
LP
3550 continue;
3551 } else if (streq(l, "active-exit-timestamp")) {
d68c645b 3552 (void) deserialize_dual_timestamp(v, &u->active_exit_timestamp);
8aaf019b
LP
3553 continue;
3554 } else if (streq(l, "inactive-enter-timestamp")) {
d68c645b 3555 (void) deserialize_dual_timestamp(v, &u->inactive_enter_timestamp);
8aaf019b 3556 continue;
2791a8f8 3557 } else if (streq(l, "condition-timestamp")) {
d68c645b 3558 (void) deserialize_dual_timestamp(v, &u->condition_timestamp);
2791a8f8 3559 continue;
59fccdc5 3560 } else if (streq(l, "assert-timestamp")) {
d68c645b 3561 (void) deserialize_dual_timestamp(v, &u->assert_timestamp);
59fccdc5 3562 continue;
2791a8f8 3563 } else if (streq(l, "condition-result")) {
2791a8f8 3564
e911de99
LP
3565 r = parse_boolean(v);
3566 if (r < 0)
f2341e0a 3567 log_unit_debug(u, "Failed to parse condition result value %s, ignoring.", v);
2791a8f8 3568 else
e911de99 3569 u->condition_result = r;
efbac6d2
LP
3570
3571 continue;
c2756a68 3572
59fccdc5 3573 } else if (streq(l, "assert-result")) {
59fccdc5 3574
e911de99
LP
3575 r = parse_boolean(v);
3576 if (r < 0)
f2341e0a 3577 log_unit_debug(u, "Failed to parse assert result value %s, ignoring.", v);
59fccdc5 3578 else
e911de99 3579 u->assert_result = r;
59fccdc5
LP
3580
3581 continue;
3582
c2756a68 3583 } else if (streq(l, "transient")) {
c2756a68 3584
e911de99
LP
3585 r = parse_boolean(v);
3586 if (r < 0)
f2341e0a 3587 log_unit_debug(u, "Failed to parse transient bool %s, ignoring.", v);
c2756a68 3588 else
e911de99 3589 u->transient = r;
c2756a68
LP
3590
3591 continue;
e911de99 3592
0e699122
LP
3593 } else if (streq(l, "in-audit")) {
3594
3595 r = parse_boolean(v);
3596 if (r < 0)
3597 log_unit_debug(u, "Failed to parse in-audit bool %s, ignoring.", v);
3598 else
3599 u->in_audit = r;
3600
3601 continue;
3602
d3070fbd
LP
3603 } else if (streq(l, "exported-invocation-id")) {
3604
3605 r = parse_boolean(v);
3606 if (r < 0)
3607 log_unit_debug(u, "Failed to parse exported invocation ID bool %s, ignoring.", v);
3608 else
3609 u->exported_invocation_id = r;
3610
3611 continue;
3612
3613 } else if (streq(l, "exported-log-level-max")) {
3614
3615 r = parse_boolean(v);
3616 if (r < 0)
3617 log_unit_debug(u, "Failed to parse exported log level max bool %s, ignoring.", v);
3618 else
3619 u->exported_log_level_max = r;
3620
3621 continue;
3622
3623 } else if (streq(l, "exported-log-extra-fields")) {
3624
3625 r = parse_boolean(v);
3626 if (r < 0)
3627 log_unit_debug(u, "Failed to parse exported log extra fields bool %s, ignoring.", v);
3628 else
3629 u->exported_log_extra_fields = r;
3630
3631 continue;
3632
90fc172e
AZ
3633 } else if (streq(l, "exported-log-rate-limit-interval")) {
3634
3635 r = parse_boolean(v);
3636 if (r < 0)
3637 log_unit_debug(u, "Failed to parse exported log rate limit interval %s, ignoring.", v);
3638 else
3639 u->exported_log_rate_limit_interval = r;
3640
3641 continue;
3642
3643 } else if (streq(l, "exported-log-rate-limit-burst")) {
3644
3645 r = parse_boolean(v);
3646 if (r < 0)
3647 log_unit_debug(u, "Failed to parse exported log rate limit burst %s, ignoring.", v);
3648 else
3649 u->exported_log_rate_limit_burst = r;
3650
3651 continue;
3652
fe700f46 3653 } else if (STR_IN_SET(l, "cpu-usage-base", "cpuacct-usage-base")) {
5ad096b3 3654
66ebf6c0 3655 r = safe_atou64(v, &u->cpu_usage_base);
5ad096b3 3656 if (r < 0)
fe700f46
LP
3657 log_unit_debug(u, "Failed to parse CPU usage base %s, ignoring.", v);
3658
3659 continue;
3660
3661 } else if (streq(l, "cpu-usage-last")) {
3662
3663 r = safe_atou64(v, &u->cpu_usage_last);
3664 if (r < 0)
3665 log_unit_debug(u, "Failed to read CPU usage last %s, ignoring.", v);
5ad096b3 3666
0f908397 3667 continue;
4e595329 3668
afcfaa69
LP
3669 } else if (streq(l, "oom-kill-last")) {
3670
3671 r = safe_atou64(v, &u->oom_kill_last);
3672 if (r < 0)
3673 log_unit_debug(u, "Failed to read OOM kill last %s, ignoring.", v);
3674
3675 continue;
3676
e911de99 3677 } else if (streq(l, "cgroup")) {
72673e86 3678
e911de99
LP
3679 r = unit_set_cgroup_path(u, v);
3680 if (r < 0)
f2341e0a 3681 log_unit_debug_errno(u, r, "Failed to set cgroup path %s, ignoring: %m", v);
4e595329 3682
efdb0237 3683 (void) unit_watch_cgroup(u);
afcfaa69 3684 (void) unit_watch_cgroup_memory(u);
efdb0237 3685
de1d4f9b
WF
3686 continue;
3687 } else if (streq(l, "cgroup-realized")) {
3688 int b;
3689
3690 b = parse_boolean(v);
3691 if (b < 0)
3692 log_unit_debug(u, "Failed to parse cgroup-realized bool %s, ignoring.", v);
3693 else
3694 u->cgroup_realized = b;
3695
c2756a68 3696 continue;
00d9ef85 3697
8b108bd0
FB
3698 } else if (streq(l, "cgroup-realized-mask")) {
3699
3700 r = cg_mask_from_string(v, &u->cgroup_realized_mask);
3701 if (r < 0)
3702 log_unit_debug(u, "Failed to parse cgroup-realized-mask %s, ignoring.", v);
3703 continue;
3704
3705 } else if (streq(l, "cgroup-enabled-mask")) {
3706
3707 r = cg_mask_from_string(v, &u->cgroup_enabled_mask);
3708 if (r < 0)
3709 log_unit_debug(u, "Failed to parse cgroup-enabled-mask %s, ignoring.", v);
3710 continue;
3711
17f14955 3712 } else if (streq(l, "cgroup-invalidated-mask")) {
906c06f6 3713
17f14955 3714 r = cg_mask_from_string(v, &u->cgroup_invalidated_mask);
906c06f6 3715 if (r < 0)
17f14955 3716 log_unit_debug(u, "Failed to parse cgroup-invalidated-mask %s, ignoring.", v);
906c06f6
DM
3717 continue;
3718
00d9ef85
LP
3719 } else if (streq(l, "ref-uid")) {
3720 uid_t uid;
3721
3722 r = parse_uid(v, &uid);
3723 if (r < 0)
3724 log_unit_debug(u, "Failed to parse referenced UID %s, ignoring.", v);
3725 else
3726 unit_ref_uid_gid(u, uid, GID_INVALID);
3727
3728 continue;
3729
3730 } else if (streq(l, "ref-gid")) {
3731 gid_t gid;
3732
3733 r = parse_gid(v, &gid);
3734 if (r < 0)
3735 log_unit_debug(u, "Failed to parse referenced GID %s, ignoring.", v);
3736 else
3737 unit_ref_uid_gid(u, UID_INVALID, gid);
3738
5f616d5f
LP
3739 continue;
3740
05a98afd
LP
3741 } else if (streq(l, "ref")) {
3742
3743 r = strv_extend(&u->deserialized_refs, v);
3744 if (r < 0)
d68c645b 3745 return log_oom();
05a98afd 3746
4b58153d
LP
3747 continue;
3748 } else if (streq(l, "invocation-id")) {
3749 sd_id128_t id;
3750
3751 r = sd_id128_from_string(v, &id);
3752 if (r < 0)
3753 log_unit_debug(u, "Failed to parse invocation id %s, ignoring.", v);
3754 else {
3755 r = unit_set_invocation_id(u, id);
3756 if (r < 0)
3757 log_unit_warning_errno(u, r, "Failed to set invocation ID for unit: %m");
3758 }
3759
00d9ef85 3760 continue;
8aaf019b 3761 }
cca098b0 3762
6b659ed8 3763 /* Check if this is an IP accounting metric serialization field */
83f18c91
LP
3764 m = string_table_lookup(ip_accounting_metric_field, ELEMENTSOF(ip_accounting_metric_field), l);
3765 if (m >= 0) {
6b659ed8
LP
3766 uint64_t c;
3767
3768 r = safe_atou64(v, &c);
3769 if (r < 0)
3770 log_unit_debug(u, "Failed to parse IP accounting value %s, ignoring.", v);
3771 else
3772 u->ip_accounting_extra[m] = c;
3773 continue;
3774 }
3775
fbe14fc9
LP
3776 m = string_table_lookup(io_accounting_metric_field_base, ELEMENTSOF(io_accounting_metric_field_base), l);
3777 if (m >= 0) {
3778 uint64_t c;
3779
3780 r = safe_atou64(v, &c);
3781 if (r < 0)
3782 log_unit_debug(u, "Failed to parse IO accounting base value %s, ignoring.", v);
3783 else
3784 u->io_accounting_base[m] = c;
3785 continue;
3786 }
3787
3788 m = string_table_lookup(io_accounting_metric_field_last, ELEMENTSOF(io_accounting_metric_field_last), l);
3789 if (m >= 0) {
3790 uint64_t c;
3791
3792 r = safe_atou64(v, &c);
3793 if (r < 0)
3794 log_unit_debug(u, "Failed to parse IO accounting last value %s, ignoring.", v);
3795 else
3796 u->io_accounting_last[m] = c;
3797 continue;
3798 }
3799
9bdb98c5 3800 if (unit_can_serialize(u)) {
e8a565cb
YW
3801 r = exec_runtime_deserialize_compat(u, l, v, fds);
3802 if (r < 0) {
3803 log_unit_warning(u, "Failed to deserialize runtime parameter '%s', ignoring.", l);
3804 continue;
9bdb98c5
LP
3805 }
3806
e8a565cb
YW
3807 /* Returns positive if key was handled by the call */
3808 if (r > 0)
3809 continue;
3810
9bdb98c5 3811 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
613b411c 3812 if (r < 0)
f2341e0a 3813 log_unit_warning(u, "Failed to deserialize unit parameter '%s', ignoring.", l);
613b411c 3814 }
a16e1123 3815 }
a483fb59
LP
3816
3817 /* Versions before 228 did not carry a state change timestamp. In this case, take the current time. This is
3818 * useful, so that timeouts based on this timestamp don't trigger too early, and is in-line with the logic from
1f133e0d 3819 * before 228 where the base for timeouts was not persistent across reboots. */
a483fb59
LP
3820
3821 if (!dual_timestamp_is_set(&u->state_change_timestamp))
3822 dual_timestamp_get(&u->state_change_timestamp);
3823
58d83430
LP
3824 /* Let's make sure that everything that is deserialized also gets any potential new cgroup settings applied
3825 * after we are done. For that we invalidate anything already realized, so that we can realize it again. */
3826 unit_invalidate_cgroup(u, _CGROUP_MASK_ALL);
3827 unit_invalidate_cgroup_bpf(u);
3828
a483fb59 3829 return 0;
a16e1123
LP
3830}
3831
8948b341
LP
3832int unit_deserialize_skip(FILE *f) {
3833 int r;
07429866
ZJS
3834 assert(f);
3835
3836 /* Skip serialized data for this unit. We don't know what it is. */
3837
3838 for (;;) {
8948b341
LP
3839 _cleanup_free_ char *line = NULL;
3840 char *l;
07429866 3841
8948b341
LP
3842 r = read_line(f, LONG_LINE_MAX, &line);
3843 if (r < 0)
3844 return log_error_errno(r, "Failed to read serialization line: %m");
3845 if (r == 0)
3846 return 0;
07429866 3847
07429866
ZJS
3848 l = strstrip(line);
3849
3850 /* End marker */
3851 if (isempty(l))
8948b341 3852 return 1;
07429866
ZJS
3853 }
3854}
3855
eef85c4a 3856int unit_add_node_dependency(Unit *u, const char *what, bool wants, UnitDependency dep, UnitDependencyMask mask) {
6e2ef85b 3857 Unit *device;
68eda4bd 3858 _cleanup_free_ char *e = NULL;
6e2ef85b
LP
3859 int r;
3860
3861 assert(u);
3862
6e2ef85b 3863 /* Adds in links to the device node that this unit is based on */
47bc12e1
LP
3864 if (isempty(what))
3865 return 0;
6e2ef85b 3866
8407a5d0 3867 if (!is_device_path(what))
6e2ef85b
LP
3868 return 0;
3869
47bc12e1
LP
3870 /* When device units aren't supported (such as in a
3871 * container), don't create dependencies on them. */
1c2e9646 3872 if (!unit_type_supported(UNIT_DEVICE))
47bc12e1
LP
3873 return 0;
3874
7410616c
LP
3875 r = unit_name_from_path(what, ".device", &e);
3876 if (r < 0)
3877 return r;
6e2ef85b 3878
ac155bb8 3879 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
6e2ef85b
LP
3880 if (r < 0)
3881 return r;
3882
ebc8968b
FB
3883 if (dep == UNIT_REQUIRES && device_shall_be_bound_by(device, u))
3884 dep = UNIT_BINDS_TO;
3885
9d06297e 3886 r = unit_add_two_dependencies(u, UNIT_AFTER,
463d0d15 3887 MANAGER_IS_SYSTEM(u->manager) ? dep : UNIT_WANTS,
eef85c4a 3888 device, true, mask);
faa368e3 3889 if (r < 0)
6e2ef85b
LP
3890 return r;
3891
faa368e3 3892 if (wants) {
eef85c4a 3893 r = unit_add_dependency(device, UNIT_WANTS, u, false, mask);
faa368e3 3894 if (r < 0)
6e2ef85b 3895 return r;
faa368e3 3896 }
6e2ef85b
LP
3897
3898 return 0;
3899}
a16e1123 3900
be847e82 3901int unit_coldplug(Unit *u) {
05a98afd
LP
3902 int r = 0, q;
3903 char **i;
cca098b0
LP
3904
3905 assert(u);
3906
f0831ed2 3907 /* Make sure we don't enter a loop, when coldplugging recursively. */
f78f265f
LP
3908 if (u->coldplugged)
3909 return 0;
3910
3911 u->coldplugged = true;
3912
05a98afd
LP
3913 STRV_FOREACH(i, u->deserialized_refs) {
3914 q = bus_unit_track_add_name(u, *i);
3915 if (q < 0 && r >= 0)
3916 r = q;
3917 }
3918 u->deserialized_refs = strv_free(u->deserialized_refs);
cca098b0 3919
05a98afd
LP
3920 if (UNIT_VTABLE(u)->coldplug) {
3921 q = UNIT_VTABLE(u)->coldplug(u);
3922 if (q < 0 && r >= 0)
3923 r = q;
3924 }
5a6158b6 3925
05a98afd
LP
3926 if (u->job) {
3927 q = job_coldplug(u->job);
3928 if (q < 0 && r >= 0)
3929 r = q;
3930 }
cca098b0 3931
05a98afd 3932 return r;
cca098b0
LP
3933}
3934
f0831ed2
LP
3935void unit_catchup(Unit *u) {
3936 assert(u);
3937
3938 if (UNIT_VTABLE(u)->catchup)
3939 UNIT_VTABLE(u)->catchup(u);
3940}
3941
ba25d39e 3942static bool fragment_mtime_newer(const char *path, usec_t mtime, bool path_masked) {
21b95806
ZJS
3943 struct stat st;
3944
3945 if (!path)
3946 return false;
3947
77969722
LP
3948 /* If the source is some virtual kernel file system, then we assume we watch it anyway, and hence pretend we
3949 * are never out-of-date. */
3950 if (PATH_STARTSWITH_SET(path, "/proc", "/sys"))
3951 return false;
3952
21b95806
ZJS
3953 if (stat(path, &st) < 0)
3954 /* What, cannot access this anymore? */
3955 return true;
3956
ba25d39e
ZJS
3957 if (path_masked)
3958 /* For masked files check if they are still so */
3959 return !null_or_empty(&st);
3960 else
3a8db9fe 3961 /* For non-empty files check the mtime */
87ec20ef 3962 return timespec_load(&st.st_mtim) > mtime;
21b95806
ZJS
3963
3964 return false;
3965}
3966
45fb0699 3967bool unit_need_daemon_reload(Unit *u) {
ae7a7182
OS
3968 _cleanup_strv_free_ char **t = NULL;
3969 char **path;
1b64d026 3970
45fb0699
LP
3971 assert(u);
3972
ba25d39e
ZJS
3973 /* For unit files, we allow masking… */
3974 if (fragment_mtime_newer(u->fragment_path, u->fragment_mtime,
3975 u->load_state == UNIT_MASKED))
21b95806 3976 return true;
5f4b19f4 3977
ba25d39e
ZJS
3978 /* Source paths should not be masked… */
3979 if (fragment_mtime_newer(u->source_path, u->source_mtime, false))
ab932a62 3980 return true;
ae7a7182 3981
19a44dfe
LR
3982 if (u->load_state == UNIT_LOADED)
3983 (void) unit_find_dropin_paths(u, &t);
ab932a62
LP
3984 if (!strv_equal(u->dropin_paths, t))
3985 return true;
6d10d308 3986
ba25d39e 3987 /* … any drop-ins that are masked are simply omitted from the list. */
ab932a62 3988 STRV_FOREACH(path, u->dropin_paths)
ba25d39e 3989 if (fragment_mtime_newer(*path, u->dropin_mtime, false))
ab932a62 3990 return true;
21b95806 3991
ab932a62 3992 return false;
45fb0699
LP
3993}
3994
fdf20a31 3995void unit_reset_failed(Unit *u) {
5632e374
LP
3996 assert(u);
3997
fdf20a31
MM
3998 if (UNIT_VTABLE(u)->reset_failed)
3999 UNIT_VTABLE(u)->reset_failed(u);
6bf0f408
LP
4000
4001 RATELIMIT_RESET(u->start_limit);
4002 u->start_limit_hit = false;
5632e374
LP
4003}
4004
a7f241db
LP
4005Unit *unit_following(Unit *u) {
4006 assert(u);
4007
4008 if (UNIT_VTABLE(u)->following)
4009 return UNIT_VTABLE(u)->following(u);
4010
4011 return NULL;
4012}
4013
31afa0a4 4014bool unit_stop_pending(Unit *u) {
18ffdfda
LP
4015 assert(u);
4016
31afa0a4
LP
4017 /* This call does check the current state of the unit. It's
4018 * hence useful to be called from state change calls of the
4019 * unit itself, where the state isn't updated yet. This is
4020 * different from unit_inactive_or_pending() which checks both
4021 * the current state and for a queued job. */
18ffdfda 4022
31afa0a4
LP
4023 return u->job && u->job->type == JOB_STOP;
4024}
4025
4026bool unit_inactive_or_pending(Unit *u) {
4027 assert(u);
4028
4029 /* Returns true if the unit is inactive or going down */
18ffdfda 4030
d956ac29
LP
4031 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
4032 return true;
4033
31afa0a4 4034 if (unit_stop_pending(u))
18ffdfda
LP
4035 return true;
4036
4037 return false;
4038}
4039
31afa0a4 4040bool unit_active_or_pending(Unit *u) {
f976f3f6
LP
4041 assert(u);
4042
f60c2665 4043 /* Returns true if the unit is active or going up */
f976f3f6
LP
4044
4045 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
4046 return true;
4047
ac155bb8 4048 if (u->job &&
3742095b 4049 IN_SET(u->job->type, JOB_START, JOB_RELOAD_OR_START, JOB_RESTART))
f976f3f6
LP
4050 return true;
4051
4052 return false;
4053}
4054
52a12341
YW
4055bool unit_will_restart_default(Unit *u) {
4056 assert(u);
4057
4058 if (!u->job)
4059 return false;
4060 if (u->job->type == JOB_START)
4061 return true;
4062
4063 return false;
4064}
4065
deb4e708
MK
4066bool unit_will_restart(Unit *u) {
4067 assert(u);
4068
4069 if (!UNIT_VTABLE(u)->will_restart)
4070 return false;
4071
4072 return UNIT_VTABLE(u)->will_restart(u);
4073}
4074
718db961 4075int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
8a0867d6
LP
4076 assert(u);
4077 assert(w >= 0 && w < _KILL_WHO_MAX);
6eb7c172 4078 assert(SIGNAL_VALID(signo));
8a0867d6 4079
8a0867d6 4080 if (!UNIT_VTABLE(u)->kill)
15411c0c 4081 return -EOPNOTSUPP;
8a0867d6 4082
c74f17d9 4083 return UNIT_VTABLE(u)->kill(u, w, signo, error);
8a0867d6
LP
4084}
4085
82659fd7 4086static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
af4fa99d 4087 _cleanup_set_free_ Set *pid_set = NULL;
82659fd7
LP
4088 int r;
4089
d5099efc 4090 pid_set = set_new(NULL);
82659fd7
LP
4091 if (!pid_set)
4092 return NULL;
4093
4094 /* Exclude the main/control pids from being killed via the cgroup */
4095 if (main_pid > 0) {
fea72cc0 4096 r = set_put(pid_set, PID_TO_PTR(main_pid));
82659fd7 4097 if (r < 0)
95f14a3e 4098 return NULL;
82659fd7
LP
4099 }
4100
4101 if (control_pid > 0) {
fea72cc0 4102 r = set_put(pid_set, PID_TO_PTR(control_pid));
82659fd7 4103 if (r < 0)
95f14a3e 4104 return NULL;
82659fd7
LP
4105 }
4106
95f14a3e 4107 return TAKE_PTR(pid_set);
82659fd7
LP
4108}
4109
d91c34f2
LP
4110int unit_kill_common(
4111 Unit *u,
4112 KillWho who,
4113 int signo,
4114 pid_t main_pid,
4115 pid_t control_pid,
718db961 4116 sd_bus_error *error) {
d91c34f2 4117
814cc562 4118 int r = 0;
ac5e3a50 4119 bool killed = false;
814cc562 4120
ac5e3a50 4121 if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL)) {
814cc562 4122 if (main_pid < 0)
7358dc02 4123 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
52f448c3 4124 else if (main_pid == 0)
7358dc02 4125 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
814cc562
MS
4126 }
4127
ac5e3a50 4128 if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL)) {
814cc562 4129 if (control_pid < 0)
7358dc02 4130 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
52f448c3 4131 else if (control_pid == 0)
7358dc02 4132 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
814cc562
MS
4133 }
4134
ac5e3a50
JS
4135 if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL, KILL_ALL_FAIL))
4136 if (control_pid > 0) {
814cc562
MS
4137 if (kill(control_pid, signo) < 0)
4138 r = -errno;
ac5e3a50
JS
4139 else
4140 killed = true;
4141 }
814cc562 4142
ac5e3a50
JS
4143 if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL))
4144 if (main_pid > 0) {
814cc562
MS
4145 if (kill(main_pid, signo) < 0)
4146 r = -errno;
ac5e3a50
JS
4147 else
4148 killed = true;
4149 }
814cc562 4150
ac5e3a50 4151 if (IN_SET(who, KILL_ALL, KILL_ALL_FAIL) && u->cgroup_path) {
814cc562
MS
4152 _cleanup_set_free_ Set *pid_set = NULL;
4153 int q;
4154
82659fd7
LP
4155 /* Exclude the main/control pids from being killed via the cgroup */
4156 pid_set = unit_pid_set(main_pid, control_pid);
814cc562
MS
4157 if (!pid_set)
4158 return -ENOMEM;
4159
1d98fef1 4160 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, 0, pid_set, NULL, NULL);
4c701096 4161 if (q < 0 && !IN_SET(q, -EAGAIN, -ESRCH, -ENOENT))
814cc562 4162 r = q;
ac5e3a50
JS
4163 else
4164 killed = true;
814cc562
MS
4165 }
4166
201f0c91 4167 if (r == 0 && !killed && IN_SET(who, KILL_ALL_FAIL, KILL_CONTROL_FAIL))
ac5e3a50
JS
4168 return -ESRCH;
4169
814cc562
MS
4170 return r;
4171}
4172
6210e7fc
LP
4173int unit_following_set(Unit *u, Set **s) {
4174 assert(u);
4175 assert(s);
4176
4177 if (UNIT_VTABLE(u)->following_set)
4178 return UNIT_VTABLE(u)->following_set(u, s);
4179
4180 *s = NULL;
4181 return 0;
4182}
4183
a4375746 4184UnitFileState unit_get_unit_file_state(Unit *u) {
0ec0deaa
LP
4185 int r;
4186
a4375746
LP
4187 assert(u);
4188
0ec0deaa
LP
4189 if (u->unit_file_state < 0 && u->fragment_path) {
4190 r = unit_file_get_state(
463d0d15 4191 u->manager->unit_file_scope,
0ec0deaa 4192 NULL,
9ea3a0e7 4193 u->id,
0ec0deaa
LP
4194 &u->unit_file_state);
4195 if (r < 0)
4196 u->unit_file_state = UNIT_FILE_BAD;
4197 }
a4375746 4198
ac155bb8 4199 return u->unit_file_state;
a4375746
LP
4200}
4201
d2dc52db
LP
4202int unit_get_unit_file_preset(Unit *u) {
4203 assert(u);
4204
4205 if (u->unit_file_preset < 0 && u->fragment_path)
4206 u->unit_file_preset = unit_file_query_preset(
463d0d15 4207 u->manager->unit_file_scope,
0ec0deaa
LP
4208 NULL,
4209 basename(u->fragment_path));
d2dc52db
LP
4210
4211 return u->unit_file_preset;
4212}
4213
7f7d01ed 4214Unit* unit_ref_set(UnitRef *ref, Unit *source, Unit *target) {
57020a3a 4215 assert(ref);
7f7d01ed
ZJS
4216 assert(source);
4217 assert(target);
57020a3a 4218
7f7d01ed 4219 if (ref->target)
57020a3a
LP
4220 unit_ref_unset(ref);
4221
7f7d01ed
ZJS
4222 ref->source = source;
4223 ref->target = target;
4224 LIST_PREPEND(refs_by_target, target->refs_by_target, ref);
4225 return target;
57020a3a
LP
4226}
4227
4228void unit_ref_unset(UnitRef *ref) {
4229 assert(ref);
4230
7f7d01ed 4231 if (!ref->target)
57020a3a
LP
4232 return;
4233
b75102e5
LP
4234 /* We are about to drop a reference to the unit, make sure the garbage collection has a look at it as it might
4235 * be unreferenced now. */
7f7d01ed 4236 unit_add_to_gc_queue(ref->target);
b75102e5 4237
7f7d01ed
ZJS
4238 LIST_REMOVE(refs_by_target, ref->target->refs_by_target, ref);
4239 ref->source = ref->target = NULL;
57020a3a
LP
4240}
4241
29206d46
LP
4242static int user_from_unit_name(Unit *u, char **ret) {
4243
4244 static const uint8_t hash_key[] = {
4245 0x58, 0x1a, 0xaf, 0xe6, 0x28, 0x58, 0x4e, 0x96,
4246 0xb4, 0x4e, 0xf5, 0x3b, 0x8c, 0x92, 0x07, 0xec
4247 };
4248
4249 _cleanup_free_ char *n = NULL;
4250 int r;
4251
4252 r = unit_name_to_prefix(u->id, &n);
4253 if (r < 0)
4254 return r;
4255
4256 if (valid_user_group_name(n)) {
ae2a15bc 4257 *ret = TAKE_PTR(n);
29206d46
LP
4258 return 0;
4259 }
4260
4261 /* If we can't use the unit name as a user name, then let's hash it and use that */
4262 if (asprintf(ret, "_du%016" PRIx64, siphash24(n, strlen(n), hash_key)) < 0)
4263 return -ENOMEM;
4264
4265 return 0;
4266}
4267
598459ce
LP
4268int unit_patch_contexts(Unit *u) {
4269 CGroupContext *cc;
4270 ExecContext *ec;
cba6e062
LP
4271 unsigned i;
4272 int r;
4273
e06c73cc 4274 assert(u);
e06c73cc 4275
598459ce
LP
4276 /* Patch in the manager defaults into the exec and cgroup
4277 * contexts, _after_ the rest of the settings have been
4278 * initialized */
085afe36 4279
598459ce
LP
4280 ec = unit_get_exec_context(u);
4281 if (ec) {
4282 /* This only copies in the ones that need memory */
4283 for (i = 0; i < _RLIMIT_MAX; i++)
4284 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
4285 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
4286 if (!ec->rlimit[i])
4287 return -ENOMEM;
4288 }
4289
463d0d15 4290 if (MANAGER_IS_USER(u->manager) &&
598459ce
LP
4291 !ec->working_directory) {
4292
4293 r = get_home_dir(&ec->working_directory);
4294 if (r < 0)
4295 return r;
4c08c824
LP
4296
4297 /* Allow user services to run, even if the
4298 * home directory is missing */
4299 ec->working_directory_missing_ok = true;
cba6e062
LP
4300 }
4301
598459ce 4302 if (ec->private_devices)
2cd0a735 4303 ec->capability_bounding_set &= ~((UINT64_C(1) << CAP_MKNOD) | (UINT64_C(1) << CAP_SYS_RAWIO));
502d704e
DH
4304
4305 if (ec->protect_kernel_modules)
4306 ec->capability_bounding_set &= ~(UINT64_C(1) << CAP_SYS_MODULE);
29206d46
LP
4307
4308 if (ec->dynamic_user) {
4309 if (!ec->user) {
4310 r = user_from_unit_name(u, &ec->user);
4311 if (r < 0)
4312 return r;
4313 }
4314
4315 if (!ec->group) {
4316 ec->group = strdup(ec->user);
4317 if (!ec->group)
4318 return -ENOMEM;
4319 }
4320
bf65b7e0
LP
4321 /* If the dynamic user option is on, let's make sure that the unit can't leave its
4322 * UID/GID around in the file system or on IPC objects. Hence enforce a strict
4323 * sandbox. */
63bb64a0 4324
29206d46 4325 ec->private_tmp = true;
00d9ef85 4326 ec->remove_ipc = true;
63bb64a0
LP
4327 ec->protect_system = PROTECT_SYSTEM_STRICT;
4328 if (ec->protect_home == PROTECT_HOME_NO)
4329 ec->protect_home = PROTECT_HOME_READ_ONLY;
bf65b7e0
LP
4330
4331 /* Make sure this service can neither benefit from SUID/SGID binaries nor create
4332 * them. */
4333 ec->no_new_privileges = true;
4334 ec->restrict_suid_sgid = true;
29206d46 4335 }
cba6e062
LP
4336 }
4337
598459ce 4338 cc = unit_get_cgroup_context(u);
fe65e88b 4339 if (cc && ec) {
f513e420 4340
fe65e88b 4341 if (ec->private_devices &&
598459ce
LP
4342 cc->device_policy == CGROUP_AUTO)
4343 cc->device_policy = CGROUP_CLOSED;
fe65e88b
YW
4344
4345 if (ec->root_image &&
4346 (cc->device_policy != CGROUP_AUTO || cc->device_allow)) {
4347
4348 /* When RootImage= is specified, the following devices are touched. */
4349 r = cgroup_add_device_allow(cc, "/dev/loop-control", "rw");
4350 if (r < 0)
4351 return r;
4352
4353 r = cgroup_add_device_allow(cc, "block-loop", "rwm");
4354 if (r < 0)
4355 return r;
4356
4357 r = cgroup_add_device_allow(cc, "block-blkext", "rwm");
4358 if (r < 0)
4359 return r;
4360 }
598459ce 4361 }
f1660f96 4362
cba6e062 4363 return 0;
e06c73cc
LP
4364}
4365
3ef63c31
LP
4366ExecContext *unit_get_exec_context(Unit *u) {
4367 size_t offset;
4368 assert(u);
4369
598459ce
LP
4370 if (u->type < 0)
4371 return NULL;
4372
3ef63c31
LP
4373 offset = UNIT_VTABLE(u)->exec_context_offset;
4374 if (offset <= 0)
4375 return NULL;
4376
4377 return (ExecContext*) ((uint8_t*) u + offset);
4378}
4379
718db961
LP
4380KillContext *unit_get_kill_context(Unit *u) {
4381 size_t offset;
4382 assert(u);
4383
598459ce
LP
4384 if (u->type < 0)
4385 return NULL;
4386
718db961
LP
4387 offset = UNIT_VTABLE(u)->kill_context_offset;
4388 if (offset <= 0)
4389 return NULL;
4390
4391 return (KillContext*) ((uint8_t*) u + offset);
4392}
4393
4ad49000
LP
4394CGroupContext *unit_get_cgroup_context(Unit *u) {
4395 size_t offset;
4396
598459ce
LP
4397 if (u->type < 0)
4398 return NULL;
4399
4ad49000
LP
4400 offset = UNIT_VTABLE(u)->cgroup_context_offset;
4401 if (offset <= 0)
4402 return NULL;
4403
4404 return (CGroupContext*) ((uint8_t*) u + offset);
4405}
4406
613b411c
LP
4407ExecRuntime *unit_get_exec_runtime(Unit *u) {
4408 size_t offset;
4409
598459ce
LP
4410 if (u->type < 0)
4411 return NULL;
4412
613b411c
LP
4413 offset = UNIT_VTABLE(u)->exec_runtime_offset;
4414 if (offset <= 0)
4415 return NULL;
4416
4417 return *(ExecRuntime**) ((uint8_t*) u + offset);
4418}
4419
2e59b241 4420static const char* unit_drop_in_dir(Unit *u, UnitWriteFlags flags) {
3f5e8115
LP
4421 assert(u);
4422
2e59b241 4423 if (UNIT_WRITE_FLAGS_NOOP(flags))
4f4afc88
LP
4424 return NULL;
4425
39591351
LP
4426 if (u->transient) /* Redirect drop-ins for transient units always into the transient directory. */
4427 return u->manager->lookup_paths.transient;
26d04f86 4428
2e59b241 4429 if (flags & UNIT_PERSISTENT)
4f4afc88 4430 return u->manager->lookup_paths.persistent_control;
26d04f86 4431
2e59b241
LP
4432 if (flags & UNIT_RUNTIME)
4433 return u->manager->lookup_paths.runtime_control;
4434
39591351 4435 return NULL;
71645aca
LP
4436}
4437
2e59b241
LP
4438char* unit_escape_setting(const char *s, UnitWriteFlags flags, char **buf) {
4439 char *ret = NULL;
4440
4441 if (!s)
4442 return NULL;
4443
4444 /* Escapes the input string as requested. Returns the escaped string. If 'buf' is specified then the allocated
4445 * return buffer pointer is also written to *buf, except if no escaping was necessary, in which case *buf is
4446 * set to NULL, and the input pointer is returned as-is. This means the return value always contains a properly
4447 * escaped version, but *buf when passed only contains a pointer if an allocation was necessary. If *buf is
4448 * not specified, then the return value always needs to be freed. Callers can use this to optimize memory
4449 * allocations. */
4450
4451 if (flags & UNIT_ESCAPE_SPECIFIERS) {
4452 ret = specifier_escape(s);
4453 if (!ret)
4454 return NULL;
4455
4456 s = ret;
4457 }
4458
4459 if (flags & UNIT_ESCAPE_C) {
4460 char *a;
4461
4462 a = cescape(s);
4463 free(ret);
4464 if (!a)
4465 return NULL;
4466
4467 ret = a;
4468 }
4469
4470 if (buf) {
4471 *buf = ret;
4472 return ret ?: (char*) s;
4473 }
4474
4475 return ret ?: strdup(s);
4476}
4477
4478char* unit_concat_strv(char **l, UnitWriteFlags flags) {
4479 _cleanup_free_ char *result = NULL;
4480 size_t n = 0, allocated = 0;
ae2a15bc 4481 char **i;
2e59b241
LP
4482
4483 /* Takes a list of strings, escapes them, and concatenates them. This may be used to format command lines in a
4484 * way suitable for ExecStart= stanzas */
4485
4486 STRV_FOREACH(i, l) {
4487 _cleanup_free_ char *buf = NULL;
4488 const char *p;
4489 size_t a;
4490 char *q;
4491
4492 p = unit_escape_setting(*i, flags, &buf);
4493 if (!p)
4494 return NULL;
4495
4496 a = (n > 0) + 1 + strlen(p) + 1; /* separating space + " + entry + " */
4497 if (!GREEDY_REALLOC(result, allocated, n + a + 1))
4498 return NULL;
4499
4500 q = result + n;
4501 if (n > 0)
4502 *(q++) = ' ';
4503
4504 *(q++) = '"';
4505 q = stpcpy(q, p);
4506 *(q++) = '"';
4507
4508 n += a;
4509 }
4510
4511 if (!GREEDY_REALLOC(result, allocated, n + 1))
4512 return NULL;
4513
4514 result[n] = 0;
4515
ae2a15bc 4516 return TAKE_PTR(result);
2e59b241
LP
4517}
4518
4519int unit_write_setting(Unit *u, UnitWriteFlags flags, const char *name, const char *data) {
4520 _cleanup_free_ char *p = NULL, *q = NULL, *escaped = NULL;
2a9a6f8a 4521 const char *dir, *wrapped;
26d04f86 4522 int r;
71645aca
LP
4523
4524 assert(u);
2e59b241
LP
4525 assert(name);
4526 assert(data);
4527
4528 if (UNIT_WRITE_FLAGS_NOOP(flags))
4529 return 0;
4530
4531 data = unit_escape_setting(data, flags, &escaped);
4532 if (!data)
4533 return -ENOMEM;
4534
4535 /* Prefix the section header. If we are writing this out as transient file, then let's suppress this if the
4536 * previous section header is the same */
4537
4538 if (flags & UNIT_PRIVATE) {
4539 if (!UNIT_VTABLE(u)->private_section)
4540 return -EINVAL;
4541
4542 if (!u->transient_file || u->last_section_private < 0)
4543 data = strjoina("[", UNIT_VTABLE(u)->private_section, "]\n", data);
4544 else if (u->last_section_private == 0)
4545 data = strjoina("\n[", UNIT_VTABLE(u)->private_section, "]\n", data);
4546 } else {
4547 if (!u->transient_file || u->last_section_private < 0)
4548 data = strjoina("[Unit]\n", data);
4549 else if (u->last_section_private > 0)
4550 data = strjoina("\n[Unit]\n", data);
4551 }
71645aca 4552
4f4afc88
LP
4553 if (u->transient_file) {
4554 /* When this is a transient unit file in creation, then let's not create a new drop-in but instead
4555 * write to the transient unit file. */
4556 fputs(data, u->transient_file);
4f4afc88 4557
2e59b241
LP
4558 if (!endswith(data, "\n"))
4559 fputc('\n', u->transient_file);
4560
4561 /* Remember which section we wrote this entry to */
4562 u->last_section_private = !!(flags & UNIT_PRIVATE);
8e2af478 4563 return 0;
2e59b241 4564 }
8e2af478 4565
2e59b241 4566 dir = unit_drop_in_dir(u, flags);
39591351
LP
4567 if (!dir)
4568 return -EINVAL;
71645aca 4569
2a9a6f8a 4570 wrapped = strjoina("# This is a drop-in unit file extension, created via \"systemctl set-property\"\n"
3f71dec5 4571 "# or an equivalent operation. Do not edit.\n",
2a9a6f8a
ZJS
4572 data,
4573 "\n");
e20b2a86 4574
815b09d3 4575 r = drop_in_file(dir, u->id, 50, name, &p, &q);
adb76a70
WC
4576 if (r < 0)
4577 return r;
4578
45639f1b 4579 (void) mkdir_p_label(p, 0755);
4dba44a5
ZJS
4580
4581 /* Make sure the drop-in dir is registered in our path cache. This way we don't need to stupidly
4582 * recreate the cache after every drop-in we write. */
4583 if (u->manager->unit_path_cache) {
4584 r = set_put_strdup(u->manager->unit_path_cache, p);
4585 if (r < 0)
4586 return r;
4587 }
4588
2a9a6f8a 4589 r = write_string_file_atomic_label(q, wrapped);
adb76a70
WC
4590 if (r < 0)
4591 return r;
4592
815b09d3 4593 r = strv_push(&u->dropin_paths, q);
adb76a70
WC
4594 if (r < 0)
4595 return r;
815b09d3 4596 q = NULL;
adb76a70 4597
adb76a70
WC
4598 strv_uniq(u->dropin_paths);
4599
4600 u->dropin_mtime = now(CLOCK_REALTIME);
4601
4602 return 0;
26d04f86 4603}
71645aca 4604
2e59b241 4605int unit_write_settingf(Unit *u, UnitWriteFlags flags, const char *name, const char *format, ...) {
b9ec9359
LP
4606 _cleanup_free_ char *p = NULL;
4607 va_list ap;
4608 int r;
4609
4610 assert(u);
4611 assert(name);
4612 assert(format);
4613
2e59b241 4614 if (UNIT_WRITE_FLAGS_NOOP(flags))
b9ec9359
LP
4615 return 0;
4616
4617 va_start(ap, format);
4618 r = vasprintf(&p, format, ap);
4619 va_end(ap);
4620
4621 if (r < 0)
4622 return -ENOMEM;
4623
2e59b241 4624 return unit_write_setting(u, flags, name, p);
b9ec9359 4625}
71645aca 4626
c2756a68 4627int unit_make_transient(Unit *u) {
0126c8f3 4628 _cleanup_free_ char *path = NULL;
4f4afc88 4629 FILE *f;
4f4afc88 4630
c2756a68
LP
4631 assert(u);
4632
3f5e8115
LP
4633 if (!UNIT_VTABLE(u)->can_transient)
4634 return -EOPNOTSUPP;
4635
45639f1b
LP
4636 (void) mkdir_p_label(u->manager->lookup_paths.transient, 0755);
4637
657ee2d8 4638 path = path_join(u->manager->lookup_paths.transient, u->id);
4f4afc88
LP
4639 if (!path)
4640 return -ENOMEM;
4641
4642 /* Let's open the file we'll write the transient settings into. This file is kept open as long as we are
4643 * creating the transient, and is closed in unit_load(), as soon as we start loading the file. */
4644
78e334b5 4645 RUN_WITH_UMASK(0022) {
4f4afc88 4646 f = fopen(path, "we");
0126c8f3 4647 if (!f)
78e334b5 4648 return -errno;
4f4afc88
LP
4649 }
4650
0126c8f3 4651 safe_fclose(u->transient_file);
4f4afc88
LP
4652 u->transient_file = f;
4653
0126c8f3 4654 free_and_replace(u->fragment_path, path);
7c65093a 4655
7c65093a
LP
4656 u->source_path = mfree(u->source_path);
4657 u->dropin_paths = strv_free(u->dropin_paths);
4658 u->fragment_mtime = u->source_mtime = u->dropin_mtime = 0;
4659
4f4afc88
LP
4660 u->load_state = UNIT_STUB;
4661 u->load_error = 0;
4662 u->transient = true;
4663
7c65093a
LP
4664 unit_add_to_dbus_queue(u);
4665 unit_add_to_gc_queue(u);
c2756a68 4666
4f4afc88
LP
4667 fputs("# This is a transient unit file, created programmatically via the systemd API. Do not edit.\n",
4668 u->transient_file);
4669
3f5e8115 4670 return 0;
c2756a68
LP
4671}
4672
c53d2d54 4673static int log_kill(pid_t pid, int sig, void *userdata) {
1d98fef1
LP
4674 _cleanup_free_ char *comm = NULL;
4675
4676 (void) get_process_comm(pid, &comm);
4677
4678 /* Don't log about processes marked with brackets, under the assumption that these are temporary processes
4679 only, like for example systemd's own PAM stub process. */
4680 if (comm && comm[0] == '(')
c53d2d54 4681 return 0;
1d98fef1
LP
4682
4683 log_unit_notice(userdata,
4684 "Killing process " PID_FMT " (%s) with signal SIG%s.",
4685 pid,
4686 strna(comm),
4687 signal_to_string(sig));
c53d2d54
DB
4688
4689 return 1;
1d98fef1
LP
4690}
4691
4692static int operation_to_signal(KillContext *c, KillOperation k) {
4693 assert(c);
4694
4695 switch (k) {
4696
4697 case KILL_TERMINATE:
4698 case KILL_TERMINATE_AND_LOG:
4699 return c->kill_signal;
4700
4701 case KILL_KILL:
fbb48d4c 4702 return c->final_kill_signal;
1d98fef1 4703
c87700a1
AZ
4704 case KILL_WATCHDOG:
4705 return c->watchdog_signal;
1d98fef1
LP
4706
4707 default:
4708 assert_not_reached("KillOperation unknown");
4709 }
4710}
4711
cd2086fe
LP
4712int unit_kill_context(
4713 Unit *u,
4714 KillContext *c,
db2cb23b 4715 KillOperation k,
cd2086fe
LP
4716 pid_t main_pid,
4717 pid_t control_pid,
4718 bool main_pid_alien) {
4719
1d98fef1 4720 bool wait_for_exit = false, send_sighup;
59ec09a8 4721 cg_kill_log_func_t log_func = NULL;
b821a397 4722 int sig, r;
cd2086fe
LP
4723
4724 assert(u);
4725 assert(c);
4726
59ec09a8
ZJS
4727 /* Kill the processes belonging to this unit, in preparation for shutting the unit down.
4728 * Returns > 0 if we killed something worth waiting for, 0 otherwise. */
1d98fef1 4729
cd2086fe
LP
4730 if (c->kill_mode == KILL_NONE)
4731 return 0;
4732
1d98fef1
LP
4733 sig = operation_to_signal(c, k);
4734
4735 send_sighup =
4736 c->send_sighup &&
4737 IN_SET(k, KILL_TERMINATE, KILL_TERMINATE_AND_LOG) &&
4738 sig != SIGHUP;
4739
59ec09a8
ZJS
4740 if (k != KILL_TERMINATE || IN_SET(sig, SIGKILL, SIGABRT))
4741 log_func = log_kill;
cd2086fe
LP
4742
4743 if (main_pid > 0) {
1d98fef1
LP
4744 if (log_func)
4745 log_func(main_pid, sig, u);
cd2086fe 4746
1d98fef1 4747 r = kill_and_sigcont(main_pid, sig);
cd2086fe
LP
4748 if (r < 0 && r != -ESRCH) {
4749 _cleanup_free_ char *comm = NULL;
1d98fef1 4750 (void) get_process_comm(main_pid, &comm);
cd2086fe 4751
b821a397 4752 log_unit_warning_errno(u, r, "Failed to kill main process " PID_FMT " (%s), ignoring: %m", main_pid, strna(comm));
82659fd7 4753 } else {
bc6aed7b
LP
4754 if (!main_pid_alien)
4755 wait_for_exit = true;
82659fd7 4756
1d98fef1 4757 if (r != -ESRCH && send_sighup)
d0667321 4758 (void) kill(main_pid, SIGHUP);
82659fd7 4759 }
cd2086fe
LP
4760 }
4761
4762 if (control_pid > 0) {
1d98fef1
LP
4763 if (log_func)
4764 log_func(control_pid, sig, u);
cd2086fe 4765
1d98fef1 4766 r = kill_and_sigcont(control_pid, sig);
cd2086fe
LP
4767 if (r < 0 && r != -ESRCH) {
4768 _cleanup_free_ char *comm = NULL;
1d98fef1 4769 (void) get_process_comm(control_pid, &comm);
cd2086fe 4770
b821a397 4771 log_unit_warning_errno(u, r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m", control_pid, strna(comm));
82659fd7 4772 } else {
cd2086fe 4773 wait_for_exit = true;
82659fd7 4774
1d98fef1 4775 if (r != -ESRCH && send_sighup)
d0667321 4776 (void) kill(control_pid, SIGHUP);
82659fd7 4777 }
cd2086fe
LP
4778 }
4779
b821a397
LP
4780 if (u->cgroup_path &&
4781 (c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL))) {
cd2086fe
LP
4782 _cleanup_set_free_ Set *pid_set = NULL;
4783
82659fd7
LP
4784 /* Exclude the main/control pids from being killed via the cgroup */
4785 pid_set = unit_pid_set(main_pid, control_pid);
cd2086fe
LP
4786 if (!pid_set)
4787 return -ENOMEM;
4788
1d98fef1
LP
4789 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path,
4790 sig,
4791 CGROUP_SIGCONT|CGROUP_IGNORE_SELF,
4792 pid_set,
4793 log_func, u);
cd2086fe 4794 if (r < 0) {
4c701096 4795 if (!IN_SET(r, -EAGAIN, -ESRCH, -ENOENT))
b821a397
LP
4796 log_unit_warning_errno(u, r, "Failed to kill control group %s, ignoring: %m", u->cgroup_path);
4797
82659fd7 4798 } else if (r > 0) {
bc6aed7b 4799
1d9cc876
LP
4800 /* FIXME: For now, on the legacy hierarchy, we will not wait for the cgroup members to die if
4801 * we are running in a container or if this is a delegation unit, simply because cgroup
4802 * notification is unreliable in these cases. It doesn't work at all in containers, and outside
4803 * of containers it can be confused easily by left-over directories in the cgroup — which
4804 * however should not exist in non-delegated units. On the unified hierarchy that's different,
4805 * there we get proper events. Hence rely on them. */
efdb0237 4806
c22800e4 4807 if (cg_unified_controller(SYSTEMD_CGROUP_CONTROLLER) > 0 ||
1d9cc876 4808 (detect_container() == 0 && !unit_cgroup_delegate(u)))
e9db43d5 4809 wait_for_exit = true;
58ea275a 4810
1d98fef1 4811 if (send_sighup) {
82659fd7
LP
4812 set_free(pid_set);
4813
4814 pid_set = unit_pid_set(main_pid, control_pid);
4815 if (!pid_set)
4816 return -ENOMEM;
4817
1d98fef1
LP
4818 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path,
4819 SIGHUP,
4820 CGROUP_IGNORE_SELF,
4821 pid_set,
4822 NULL, NULL);
82659fd7
LP
4823 }
4824 }
cd2086fe
LP
4825 }
4826
4827 return wait_for_exit;
4828}
4829
eef85c4a 4830int unit_require_mounts_for(Unit *u, const char *path, UnitDependencyMask mask) {
ca8700e9 4831 _cleanup_free_ char *p = NULL;
eef85c4a 4832 UnitDependencyInfo di;
a57f7e2c
LP
4833 int r;
4834
4835 assert(u);
4836 assert(path);
4837
eef85c4a
LP
4838 /* Registers a unit for requiring a certain path and all its prefixes. We keep a hashtable of these paths in
4839 * the unit (from the path to the UnitDependencyInfo structure indicating how to the dependency came to
4840 * be). However, we build a prefix table for all possible prefixes so that new appearing mount units can easily
4841 * determine which units to make themselves a dependency of. */
a57f7e2c 4842
70b64bd3
ZJS
4843 if (!path_is_absolute(path))
4844 return -EINVAL;
4845
548f6937 4846 r = hashmap_ensure_allocated(&u->requires_mounts_for, &path_hash_ops);
eef85c4a
LP
4847 if (r < 0)
4848 return r;
4849
a57f7e2c
LP
4850 p = strdup(path);
4851 if (!p)
4852 return -ENOMEM;
4853
106bf8e4 4854 path = path_simplify(p, true);
a57f7e2c 4855
ca8700e9 4856 if (!path_is_normalized(path))
a57f7e2c 4857 return -EPERM;
a57f7e2c 4858
ca8700e9 4859 if (hashmap_contains(u->requires_mounts_for, path))
a57f7e2c 4860 return 0;
a57f7e2c 4861
eef85c4a
LP
4862 di = (UnitDependencyInfo) {
4863 .origin_mask = mask
4864 };
4865
ca8700e9
ZJS
4866 r = hashmap_put(u->requires_mounts_for, path, di.data);
4867 if (r < 0)
a57f7e2c 4868 return r;
ca8700e9 4869 p = NULL;
a57f7e2c 4870
4cb06c59 4871 char prefix[strlen(path) + 1];
ca8700e9 4872 PATH_FOREACH_PREFIX_MORE(prefix, path) {
a57f7e2c
LP
4873 Set *x;
4874
4875 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
4876 if (!x) {
ca8700e9 4877 _cleanup_free_ char *q = NULL;
a57f7e2c 4878
548f6937 4879 r = hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for, &path_hash_ops);
742f41ad
LP
4880 if (r < 0)
4881 return r;
a57f7e2c
LP
4882
4883 q = strdup(prefix);
4884 if (!q)
4885 return -ENOMEM;
4886
d5099efc 4887 x = set_new(NULL);
ca8700e9 4888 if (!x)
a57f7e2c 4889 return -ENOMEM;
a57f7e2c
LP
4890
4891 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
4892 if (r < 0) {
a57f7e2c
LP
4893 set_free(x);
4894 return r;
4895 }
ca8700e9 4896 q = NULL;
a57f7e2c
LP
4897 }
4898
4899 r = set_put(x, u);
4900 if (r < 0)
4901 return r;
4902 }
4903
4904 return 0;
4905}
4906
613b411c
LP
4907int unit_setup_exec_runtime(Unit *u) {
4908 ExecRuntime **rt;
4909 size_t offset;
613b411c 4910 Unit *other;
eef85c4a
LP
4911 Iterator i;
4912 void *v;
e8a565cb 4913 int r;
613b411c
LP
4914
4915 offset = UNIT_VTABLE(u)->exec_runtime_offset;
4916 assert(offset > 0);
4917
06b643e7 4918 /* Check if there already is an ExecRuntime for this unit? */
613b411c
LP
4919 rt = (ExecRuntime**) ((uint8_t*) u + offset);
4920 if (*rt)
4921 return 0;
4922
4923 /* Try to get it from somebody else */
eef85c4a 4924 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
e8a565cb
YW
4925 r = exec_runtime_acquire(u->manager, NULL, other->id, false, rt);
4926 if (r == 1)
4927 return 1;
613b411c
LP
4928 }
4929
e8a565cb 4930 return exec_runtime_acquire(u->manager, unit_get_exec_context(u), u->id, true, rt);
613b411c
LP
4931}
4932
29206d46
LP
4933int unit_setup_dynamic_creds(Unit *u) {
4934 ExecContext *ec;
4935 DynamicCreds *dcreds;
4936 size_t offset;
4937
4938 assert(u);
4939
4940 offset = UNIT_VTABLE(u)->dynamic_creds_offset;
4941 assert(offset > 0);
4942 dcreds = (DynamicCreds*) ((uint8_t*) u + offset);
4943
4944 ec = unit_get_exec_context(u);
4945 assert(ec);
4946
4947 if (!ec->dynamic_user)
4948 return 0;
4949
4950 return dynamic_creds_acquire(dcreds, u->manager, ec->user, ec->group);
4951}
4952
1c2e9646
LP
4953bool unit_type_supported(UnitType t) {
4954 if (_unlikely_(t < 0))
4955 return false;
4956 if (_unlikely_(t >= _UNIT_TYPE_MAX))
4957 return false;
4958
4959 if (!unit_vtable[t]->supported)
4960 return true;
4961
4962 return unit_vtable[t]->supported();
4963}
4964
8b4305c7
LP
4965void unit_warn_if_dir_nonempty(Unit *u, const char* where) {
4966 int r;
4967
4968 assert(u);
4969 assert(where);
4970
4971 r = dir_is_empty(where);
3f602115 4972 if (r > 0 || r == -ENOTDIR)
8b4305c7
LP
4973 return;
4974 if (r < 0) {
4975 log_unit_warning_errno(u, r, "Failed to check directory %s: %m", where);
4976 return;
4977 }
4978
4979 log_struct(LOG_NOTICE,
2b044526 4980 "MESSAGE_ID=" SD_MESSAGE_OVERMOUNTING_STR,
8b4305c7 4981 LOG_UNIT_ID(u),
f1c50bec 4982 LOG_UNIT_INVOCATION_ID(u),
8b4305c7 4983 LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),
a1230ff9 4984 "WHERE=%s", where);
8b4305c7
LP
4985}
4986
25cd4964 4987int unit_fail_if_noncanonical(Unit *u, const char* where) {
58d9d89b 4988 _cleanup_free_ char *canonical_where = NULL;
8b4305c7
LP
4989 int r;
4990
4991 assert(u);
4992 assert(where);
4993
25cd4964 4994 r = chase_symlinks(where, NULL, CHASE_NONEXISTENT, &canonical_where);
8b4305c7 4995 if (r < 0) {
25cd4964 4996 log_unit_debug_errno(u, r, "Failed to check %s for symlinks, ignoring: %m", where);
8b4305c7
LP
4997 return 0;
4998 }
25cd4964
AJ
4999
5000 /* We will happily ignore a trailing slash (or any redundant slashes) */
5001 if (path_equal(where, canonical_where))
8b4305c7
LP
5002 return 0;
5003
25cd4964 5004 /* No need to mention "." or "..", they would already have been rejected by unit_name_from_path() */
8b4305c7 5005 log_struct(LOG_ERR,
2b044526 5006 "MESSAGE_ID=" SD_MESSAGE_OVERMOUNTING_STR,
8b4305c7 5007 LOG_UNIT_ID(u),
f1c50bec 5008 LOG_UNIT_INVOCATION_ID(u),
25cd4964 5009 LOG_UNIT_MESSAGE(u, "Mount path %s is not canonical (contains a symlink).", where),
a1230ff9 5010 "WHERE=%s", where);
8b4305c7
LP
5011
5012 return -ELOOP;
5013}
0f13f3bd
LP
5014
5015bool unit_is_pristine(Unit *u) {
5016 assert(u);
5017
7c65093a 5018 /* Check if the unit already exists or is already around,
0f13f3bd
LP
5019 * in a number of different ways. Note that to cater for unit
5020 * types such as slice, we are generally fine with units that
e9e8cbc8
ZJS
5021 * are marked UNIT_LOADED even though nothing was actually
5022 * loaded, as those unit types don't require a file on disk. */
0f13f3bd
LP
5023
5024 return !(!IN_SET(u->load_state, UNIT_NOT_FOUND, UNIT_LOADED) ||
5025 u->fragment_path ||
5026 u->source_path ||
5027 !strv_isempty(u->dropin_paths) ||
0f13f3bd
LP
5028 u->job ||
5029 u->merged_into);
5030}
291d565a
LP
5031
5032pid_t unit_control_pid(Unit *u) {
5033 assert(u);
5034
5035 if (UNIT_VTABLE(u)->control_pid)
5036 return UNIT_VTABLE(u)->control_pid(u);
5037
5038 return 0;
5039}
5040
5041pid_t unit_main_pid(Unit *u) {
5042 assert(u);
5043
5044 if (UNIT_VTABLE(u)->main_pid)
5045 return UNIT_VTABLE(u)->main_pid(u);
5046
5047 return 0;
5048}
00d9ef85
LP
5049
5050static void unit_unref_uid_internal(
5051 Unit *u,
5052 uid_t *ref_uid,
5053 bool destroy_now,
5054 void (*_manager_unref_uid)(Manager *m, uid_t uid, bool destroy_now)) {
5055
5056 assert(u);
5057 assert(ref_uid);
5058 assert(_manager_unref_uid);
5059
5060 /* Generic implementation of both unit_unref_uid() and unit_unref_gid(), under the assumption that uid_t and
5061 * gid_t are actually the same time, with the same validity rules.
5062 *
5063 * Drops a reference to UID/GID from a unit. */
5064
5065 assert_cc(sizeof(uid_t) == sizeof(gid_t));
5066 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
5067
5068 if (!uid_is_valid(*ref_uid))
5069 return;
5070
5071 _manager_unref_uid(u->manager, *ref_uid, destroy_now);
5072 *ref_uid = UID_INVALID;
5073}
5074
5075void unit_unref_uid(Unit *u, bool destroy_now) {
5076 unit_unref_uid_internal(u, &u->ref_uid, destroy_now, manager_unref_uid);
5077}
5078
5079void unit_unref_gid(Unit *u, bool destroy_now) {
5080 unit_unref_uid_internal(u, (uid_t*) &u->ref_gid, destroy_now, manager_unref_gid);
5081}
5082
5083static int unit_ref_uid_internal(
5084 Unit *u,
5085 uid_t *ref_uid,
5086 uid_t uid,
5087 bool clean_ipc,
5088 int (*_manager_ref_uid)(Manager *m, uid_t uid, bool clean_ipc)) {
5089
5090 int r;
5091
5092 assert(u);
5093 assert(ref_uid);
5094 assert(uid_is_valid(uid));
5095 assert(_manager_ref_uid);
5096
5097 /* Generic implementation of both unit_ref_uid() and unit_ref_guid(), under the assumption that uid_t and gid_t
5098 * are actually the same type, and have the same validity rules.
5099 *
5100 * Adds a reference on a specific UID/GID to this unit. Each unit referencing the same UID/GID maintains a
5101 * reference so that we can destroy the UID/GID's IPC resources as soon as this is requested and the counter
5102 * drops to zero. */
5103
5104 assert_cc(sizeof(uid_t) == sizeof(gid_t));
5105 assert_cc(UID_INVALID == (uid_t) GID_INVALID);
5106
5107 if (*ref_uid == uid)
5108 return 0;
5109
5110 if (uid_is_valid(*ref_uid)) /* Already set? */
5111 return -EBUSY;
5112
5113 r = _manager_ref_uid(u->manager, uid, clean_ipc);
5114 if (r < 0)
5115 return r;
5116
5117 *ref_uid = uid;
5118 return 1;
5119}
5120
5121int unit_ref_uid(Unit *u, uid_t uid, bool clean_ipc) {
5122 return unit_ref_uid_internal(u, &u->ref_uid, uid, clean_ipc, manager_ref_uid);
5123}
5124
5125int unit_ref_gid(Unit *u, gid_t gid, bool clean_ipc) {
5126 return unit_ref_uid_internal(u, (uid_t*) &u->ref_gid, (uid_t) gid, clean_ipc, manager_ref_gid);
5127}
5128
5129static int unit_ref_uid_gid_internal(Unit *u, uid_t uid, gid_t gid, bool clean_ipc) {
5130 int r = 0, q = 0;
5131
5132 assert(u);
5133
5134 /* Reference both a UID and a GID in one go. Either references both, or neither. */
5135
5136 if (uid_is_valid(uid)) {
5137 r = unit_ref_uid(u, uid, clean_ipc);
5138 if (r < 0)
5139 return r;
5140 }
5141
5142 if (gid_is_valid(gid)) {
5143 q = unit_ref_gid(u, gid, clean_ipc);
5144 if (q < 0) {
5145 if (r > 0)
5146 unit_unref_uid(u, false);
5147
5148 return q;
5149 }
5150 }
5151
5152 return r > 0 || q > 0;
5153}
5154
5155int unit_ref_uid_gid(Unit *u, uid_t uid, gid_t gid) {
5156 ExecContext *c;
5157 int r;
5158
5159 assert(u);
5160
5161 c = unit_get_exec_context(u);
5162
5163 r = unit_ref_uid_gid_internal(u, uid, gid, c ? c->remove_ipc : false);
5164 if (r < 0)
5165 return log_unit_warning_errno(u, r, "Couldn't add UID/GID reference to unit, proceeding without: %m");
5166
5167 return r;
5168}
5169
5170void unit_unref_uid_gid(Unit *u, bool destroy_now) {
5171 assert(u);
5172
5173 unit_unref_uid(u, destroy_now);
5174 unit_unref_gid(u, destroy_now);
5175}
5176
5177void unit_notify_user_lookup(Unit *u, uid_t uid, gid_t gid) {
5178 int r;
5179
5180 assert(u);
5181
5182 /* This is invoked whenever one of the forked off processes let's us know the UID/GID its user name/group names
5183 * resolved to. We keep track of which UID/GID is currently assigned in order to be able to destroy its IPC
5184 * objects when no service references the UID/GID anymore. */
5185
5186 r = unit_ref_uid_gid(u, uid, gid);
5187 if (r > 0)
37d0b962 5188 unit_add_to_dbus_queue(u);
00d9ef85 5189}
4b58153d
LP
5190
5191int unit_set_invocation_id(Unit *u, sd_id128_t id) {
5192 int r;
5193
5194 assert(u);
5195
5196 /* Set the invocation ID for this unit. If we cannot, this will not roll back, but reset the whole thing. */
5197
5198 if (sd_id128_equal(u->invocation_id, id))
5199 return 0;
5200
5201 if (!sd_id128_is_null(u->invocation_id))
5202 (void) hashmap_remove_value(u->manager->units_by_invocation_id, &u->invocation_id, u);
5203
5204 if (sd_id128_is_null(id)) {
5205 r = 0;
5206 goto reset;
5207 }
5208
5209 r = hashmap_ensure_allocated(&u->manager->units_by_invocation_id, &id128_hash_ops);
5210 if (r < 0)
5211 goto reset;
5212
5213 u->invocation_id = id;
5214 sd_id128_to_string(id, u->invocation_id_string);
5215
5216 r = hashmap_put(u->manager->units_by_invocation_id, &u->invocation_id, u);
5217 if (r < 0)
5218 goto reset;
5219
5220 return 0;
5221
5222reset:
5223 u->invocation_id = SD_ID128_NULL;
5224 u->invocation_id_string[0] = 0;
5225 return r;
5226}
5227
5228int unit_acquire_invocation_id(Unit *u) {
5229 sd_id128_t id;
5230 int r;
5231
5232 assert(u);
5233
5234 r = sd_id128_randomize(&id);
5235 if (r < 0)
5236 return log_unit_error_errno(u, r, "Failed to generate invocation ID for unit: %m");
5237
5238 r = unit_set_invocation_id(u, id);
5239 if (r < 0)
5240 return log_unit_error_errno(u, r, "Failed to set invocation ID for unit: %m");
5241
af92c603 5242 unit_add_to_dbus_queue(u);
4b58153d
LP
5243 return 0;
5244}
f0d47797 5245
1ad6e8b3
LP
5246int unit_set_exec_params(Unit *u, ExecParameters *p) {
5247 int r;
5248
7960b0c7
LP
5249 assert(u);
5250 assert(p);
f0d47797 5251
004c7f16 5252 /* Copy parameters from manager */
1ad6e8b3
LP
5253 r = manager_get_effective_environment(u->manager, &p->environment);
5254 if (r < 0)
5255 return r;
5256
004c7f16
LP
5257 p->confirm_spawn = manager_get_confirm_spawn(u->manager);
5258 p->cgroup_supported = u->manager->cgroup_supported;
5259 p->prefix = u->manager->prefix;
5260 SET_FLAG(p->flags, EXEC_PASS_LOG_UNIT|EXEC_CHOWN_DIRECTORIES, MANAGER_IS_SYSTEM(u->manager));
5261
5238e957 5262 /* Copy parameters from unit */
7960b0c7 5263 p->cgroup_path = u->cgroup_path;
1d9cc876 5264 SET_FLAG(p->flags, EXEC_CGROUP_DELEGATE, unit_cgroup_delegate(u));
1ad6e8b3
LP
5265
5266 return 0;
f0d47797 5267}
a79279c7 5268
4c253ed1 5269int unit_fork_helper_process(Unit *u, const char *name, pid_t *ret) {
a79279c7
LP
5270 int r;
5271
5272 assert(u);
5273 assert(ret);
5274
5275 /* Forks off a helper process and makes sure it is a member of the unit's cgroup. Returns == 0 in the child,
5276 * and > 0 in the parent. The pid parameter is always filled in with the child's PID. */
5277
5278 (void) unit_realize_cgroup(u);
5279
4c253ed1
LP
5280 r = safe_fork(name, FORK_REOPEN_LOG, ret);
5281 if (r != 0)
5282 return r;
a79279c7 5283
4c253ed1
LP
5284 (void) default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
5285 (void) ignore_signals(SIGPIPE, -1);
a79279c7 5286
4c253ed1 5287 (void) prctl(PR_SET_PDEATHSIG, SIGTERM);
a79279c7 5288
4c253ed1
LP
5289 if (u->cgroup_path) {
5290 r = cg_attach_everywhere(u->manager->cgroup_supported, u->cgroup_path, 0, NULL, NULL);
5291 if (r < 0) {
5292 log_unit_error_errno(u, r, "Failed to join unit cgroup %s: %m", u->cgroup_path);
5293 _exit(EXIT_CGROUP);
a79279c7 5294 }
a79279c7
LP
5295 }
5296
4c253ed1 5297 return 0;
a79279c7 5298}
c999cf38 5299
810ef318
YW
5300int unit_fork_and_watch_rm_rf(Unit *u, char **paths, pid_t *ret_pid) {
5301 pid_t pid;
5302 int r;
5303
5304 assert(u);
5305 assert(ret_pid);
5306
5307 r = unit_fork_helper_process(u, "(sd-rmrf)", &pid);
5308 if (r < 0)
5309 return r;
5310 if (r == 0) {
5311 int ret = EXIT_SUCCESS;
5312 char **i;
5313
5314 STRV_FOREACH(i, paths) {
5315 r = rm_rf(*i, REMOVE_ROOT|REMOVE_PHYSICAL|REMOVE_MISSING_OK);
5316 if (r < 0) {
5317 log_error_errno(r, "Failed to remove '%s': %m", *i);
5318 ret = EXIT_FAILURE;
5319 }
5320 }
5321
5322 _exit(ret);
5323 }
5324
5325 r = unit_watch_pid(u, pid, true);
5326 if (r < 0)
5327 return r;
5328
5329 *ret_pid = pid;
5330 return 0;
5331}
5332
c999cf38
LP
5333static void unit_update_dependency_mask(Unit *u, UnitDependency d, Unit *other, UnitDependencyInfo di) {
5334 assert(u);
5335 assert(d >= 0);
5336 assert(d < _UNIT_DEPENDENCY_MAX);
5337 assert(other);
5338
5339 if (di.origin_mask == 0 && di.destination_mask == 0) {
5340 /* No bit set anymore, let's drop the whole entry */
5341 assert_se(hashmap_remove(u->dependencies[d], other));
5342 log_unit_debug(u, "%s lost dependency %s=%s", u->id, unit_dependency_to_string(d), other->id);
5343 } else
5344 /* Mask was reduced, let's update the entry */
5345 assert_se(hashmap_update(u->dependencies[d], other, di.data) == 0);
5346}
5347
5348void unit_remove_dependencies(Unit *u, UnitDependencyMask mask) {
5349 UnitDependency d;
5350
5351 assert(u);
5352
5353 /* Removes all dependencies u has on other units marked for ownership by 'mask'. */
5354
5355 if (mask == 0)
5356 return;
5357
5358 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
5359 bool done;
5360
5361 do {
5362 UnitDependencyInfo di;
5363 Unit *other;
5364 Iterator i;
5365
5366 done = true;
5367
5368 HASHMAP_FOREACH_KEY(di.data, other, u->dependencies[d], i) {
5369 UnitDependency q;
5370
5371 if ((di.origin_mask & ~mask) == di.origin_mask)
5372 continue;
5373 di.origin_mask &= ~mask;
5374 unit_update_dependency_mask(u, d, other, di);
5375
5376 /* We updated the dependency from our unit to the other unit now. But most dependencies
5377 * imply a reverse dependency. Hence, let's delete that one too. For that we go through
5378 * all dependency types on the other unit and delete all those which point to us and
5379 * have the right mask set. */
5380
5381 for (q = 0; q < _UNIT_DEPENDENCY_MAX; q++) {
5382 UnitDependencyInfo dj;
5383
5384 dj.data = hashmap_get(other->dependencies[q], u);
5385 if ((dj.destination_mask & ~mask) == dj.destination_mask)
5386 continue;
5387 dj.destination_mask &= ~mask;
5388
5389 unit_update_dependency_mask(other, q, u, dj);
5390 }
5391
5392 unit_add_to_gc_queue(other);
5393
5394 done = false;
5395 break;
5396 }
5397
5398 } while (!done);
5399 }
5400}
d3070fbd
LP
5401
5402static int unit_export_invocation_id(Unit *u) {
5403 const char *p;
5404 int r;
5405
5406 assert(u);
5407
5408 if (u->exported_invocation_id)
5409 return 0;
5410
5411 if (sd_id128_is_null(u->invocation_id))
5412 return 0;
5413
5414 p = strjoina("/run/systemd/units/invocation:", u->id);
5415 r = symlink_atomic(u->invocation_id_string, p);
5416 if (r < 0)
5417 return log_unit_debug_errno(u, r, "Failed to create invocation ID symlink %s: %m", p);
5418
5419 u->exported_invocation_id = true;
5420 return 0;
5421}
5422
5423static int unit_export_log_level_max(Unit *u, const ExecContext *c) {
5424 const char *p;
5425 char buf[2];
5426 int r;
5427
5428 assert(u);
5429 assert(c);
5430
5431 if (u->exported_log_level_max)
5432 return 0;
5433
5434 if (c->log_level_max < 0)
5435 return 0;
5436
5437 assert(c->log_level_max <= 7);
5438
5439 buf[0] = '0' + c->log_level_max;
5440 buf[1] = 0;
5441
5442 p = strjoina("/run/systemd/units/log-level-max:", u->id);
5443 r = symlink_atomic(buf, p);
5444 if (r < 0)
5445 return log_unit_debug_errno(u, r, "Failed to create maximum log level symlink %s: %m", p);
5446
5447 u->exported_log_level_max = true;
5448 return 0;
5449}
5450
5451static int unit_export_log_extra_fields(Unit *u, const ExecContext *c) {
5452 _cleanup_close_ int fd = -1;
5453 struct iovec *iovec;
5454 const char *p;
5455 char *pattern;
5456 le64_t *sizes;
5457 ssize_t n;
5458 size_t i;
5459 int r;
5460
5461 if (u->exported_log_extra_fields)
5462 return 0;
5463
5464 if (c->n_log_extra_fields <= 0)
5465 return 0;
5466
5467 sizes = newa(le64_t, c->n_log_extra_fields);
5468 iovec = newa(struct iovec, c->n_log_extra_fields * 2);
5469
5470 for (i = 0; i < c->n_log_extra_fields; i++) {
5471 sizes[i] = htole64(c->log_extra_fields[i].iov_len);
5472
5473 iovec[i*2] = IOVEC_MAKE(sizes + i, sizeof(le64_t));
5474 iovec[i*2+1] = c->log_extra_fields[i];
5475 }
5476
5477 p = strjoina("/run/systemd/units/log-extra-fields:", u->id);
5478 pattern = strjoina(p, ".XXXXXX");
5479
5480 fd = mkostemp_safe(pattern);
5481 if (fd < 0)
5482 return log_unit_debug_errno(u, fd, "Failed to create extra fields file %s: %m", p);
5483
5484 n = writev(fd, iovec, c->n_log_extra_fields*2);
5485 if (n < 0) {
5486 r = log_unit_debug_errno(u, errno, "Failed to write extra fields: %m");
5487 goto fail;
5488 }
5489
5490 (void) fchmod(fd, 0644);
5491
5492 if (rename(pattern, p) < 0) {
5493 r = log_unit_debug_errno(u, errno, "Failed to rename extra fields file: %m");
5494 goto fail;
5495 }
5496
5497 u->exported_log_extra_fields = true;
5498 return 0;
5499
5500fail:
5501 (void) unlink(pattern);
5502 return r;
5503}
5504
90fc172e
AZ
5505static int unit_export_log_rate_limit_interval(Unit *u, const ExecContext *c) {
5506 _cleanup_free_ char *buf = NULL;
5507 const char *p;
5508 int r;
5509
5510 assert(u);
5511 assert(c);
5512
5513 if (u->exported_log_rate_limit_interval)
5514 return 0;
5515
5516 if (c->log_rate_limit_interval_usec == 0)
5517 return 0;
5518
5519 p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id);
5520
5521 if (asprintf(&buf, "%" PRIu64, c->log_rate_limit_interval_usec) < 0)
5522 return log_oom();
5523
5524 r = symlink_atomic(buf, p);
5525 if (r < 0)
5526 return log_unit_debug_errno(u, r, "Failed to create log rate limit interval symlink %s: %m", p);
5527
5528 u->exported_log_rate_limit_interval = true;
5529 return 0;
5530}
5531
5532static int unit_export_log_rate_limit_burst(Unit *u, const ExecContext *c) {
5533 _cleanup_free_ char *buf = NULL;
5534 const char *p;
5535 int r;
5536
5537 assert(u);
5538 assert(c);
5539
5540 if (u->exported_log_rate_limit_burst)
5541 return 0;
5542
5543 if (c->log_rate_limit_burst == 0)
5544 return 0;
5545
5546 p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id);
5547
5548 if (asprintf(&buf, "%u", c->log_rate_limit_burst) < 0)
5549 return log_oom();
5550
5551 r = symlink_atomic(buf, p);
5552 if (r < 0)
5553 return log_unit_debug_errno(u, r, "Failed to create log rate limit burst symlink %s: %m", p);
5554
5555 u->exported_log_rate_limit_burst = true;
5556 return 0;
5557}
5558
d3070fbd
LP
5559void unit_export_state_files(Unit *u) {
5560 const ExecContext *c;
5561
5562 assert(u);
5563
5564 if (!u->id)
5565 return;
5566
5567 if (!MANAGER_IS_SYSTEM(u->manager))
5568 return;
5569
638cece4 5570 if (MANAGER_IS_TEST_RUN(u->manager))
8f632531
LP
5571 return;
5572
d3070fbd
LP
5573 /* Exports a couple of unit properties to /run/systemd/units/, so that journald can quickly query this data
5574 * from there. Ideally, journald would use IPC to query this, like everybody else, but that's hard, as long as
5575 * the IPC system itself and PID 1 also log to the journal.
5576 *
5577 * Note that these files really shouldn't be considered API for anyone else, as use a runtime file system as
5578 * IPC replacement is not compatible with today's world of file system namespaces. However, this doesn't really
5579 * apply to communication between the journal and systemd, as we assume that these two daemons live in the same
5580 * namespace at least.
5581 *
5582 * Note that some of the "files" exported here are actually symlinks and not regular files. Symlinks work
5583 * better for storing small bits of data, in particular as we can write them with two system calls, and read
5584 * them with one. */
5585
5586 (void) unit_export_invocation_id(u);
5587
5588 c = unit_get_exec_context(u);
5589 if (c) {
5590 (void) unit_export_log_level_max(u, c);
5591 (void) unit_export_log_extra_fields(u, c);
90fc172e
AZ
5592 (void) unit_export_log_rate_limit_interval(u, c);
5593 (void) unit_export_log_rate_limit_burst(u, c);
d3070fbd
LP
5594 }
5595}
5596
5597void unit_unlink_state_files(Unit *u) {
5598 const char *p;
5599
5600 assert(u);
5601
5602 if (!u->id)
5603 return;
5604
5605 if (!MANAGER_IS_SYSTEM(u->manager))
5606 return;
5607
5608 /* Undoes the effect of unit_export_state() */
5609
5610 if (u->exported_invocation_id) {
5611 p = strjoina("/run/systemd/units/invocation:", u->id);
5612 (void) unlink(p);
5613
5614 u->exported_invocation_id = false;
5615 }
5616
5617 if (u->exported_log_level_max) {
5618 p = strjoina("/run/systemd/units/log-level-max:", u->id);
5619 (void) unlink(p);
5620
5621 u->exported_log_level_max = false;
5622 }
5623
5624 if (u->exported_log_extra_fields) {
5625 p = strjoina("/run/systemd/units/extra-fields:", u->id);
5626 (void) unlink(p);
5627
5628 u->exported_log_extra_fields = false;
5629 }
90fc172e
AZ
5630
5631 if (u->exported_log_rate_limit_interval) {
5632 p = strjoina("/run/systemd/units/log-rate-limit-interval:", u->id);
5633 (void) unlink(p);
5634
5635 u->exported_log_rate_limit_interval = false;
5636 }
5637
5638 if (u->exported_log_rate_limit_burst) {
5639 p = strjoina("/run/systemd/units/log-rate-limit-burst:", u->id);
5640 (void) unlink(p);
5641
5642 u->exported_log_rate_limit_burst = false;
5643 }
d3070fbd 5644}
5afe510c 5645
3c7416b6
LP
5646int unit_prepare_exec(Unit *u) {
5647 int r;
5648
5649 assert(u);
5650
fab34748
KL
5651 /* Load any custom firewall BPF programs here once to test if they are existing and actually loadable.
5652 * Fail here early since later errors in the call chain unit_realize_cgroup to cgroup_context_apply are ignored. */
5653 r = bpf_firewall_load_custom(u);
5654 if (r < 0)
5655 return r;
5656
3c7416b6
LP
5657 /* Prepares everything so that we can fork of a process for this unit */
5658
5659 (void) unit_realize_cgroup(u);
5660
5661 if (u->reset_accounting) {
9b2559a1 5662 (void) unit_reset_accounting(u);
3c7416b6
LP
5663 u->reset_accounting = false;
5664 }
5665
5666 unit_export_state_files(u);
5667
5668 r = unit_setup_exec_runtime(u);
5669 if (r < 0)
5670 return r;
5671
5672 r = unit_setup_dynamic_creds(u);
5673 if (r < 0)
5674 return r;
5675
5676 return 0;
5677}
5678
c53d2d54 5679static int log_leftover(pid_t pid, int sig, void *userdata) {
a4634b21
LP
5680 _cleanup_free_ char *comm = NULL;
5681
5682 (void) get_process_comm(pid, &comm);
5683
5684 if (comm && comm[0] == '(') /* Most likely our own helper process (PAM?), ignore */
c53d2d54 5685 return 0;
a4634b21
LP
5686
5687 log_unit_warning(userdata,
5688 "Found left-over process " PID_FMT " (%s) in control group while starting unit. Ignoring.\n"
5689 "This usually indicates unclean termination of a previous run, or service implementation deficiencies.",
5690 pid, strna(comm));
c53d2d54
DB
5691
5692 return 1;
a4634b21
LP
5693}
5694
c53d2d54 5695int unit_warn_leftover_processes(Unit *u) {
a4634b21
LP
5696 assert(u);
5697
5698 (void) unit_pick_cgroup_path(u);
5699
5700 if (!u->cgroup_path)
c53d2d54 5701 return 0;
a4634b21 5702
c53d2d54 5703 return cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, 0, 0, NULL, log_leftover, u);
a4634b21
LP
5704}
5705
bb2c7685
LP
5706bool unit_needs_console(Unit *u) {
5707 ExecContext *ec;
5708 UnitActiveState state;
5709
5710 assert(u);
5711
5712 state = unit_active_state(u);
5713
5714 if (UNIT_IS_INACTIVE_OR_FAILED(state))
5715 return false;
5716
5717 if (UNIT_VTABLE(u)->needs_console)
5718 return UNIT_VTABLE(u)->needs_console(u);
5719
5720 /* If this unit type doesn't implement this call, let's use a generic fallback implementation: */
5721 ec = unit_get_exec_context(u);
5722 if (!ec)
5723 return false;
5724
5725 return exec_context_may_touch_console(ec);
5726}
5727
81e9871e
LP
5728const char *unit_label_path(Unit *u) {
5729 const char *p;
5730
5731 /* Returns the file system path to use for MAC access decisions, i.e. the file to read the SELinux label off
5732 * when validating access checks. */
5733
5734 p = u->source_path ?: u->fragment_path;
5735 if (!p)
5736 return NULL;
5737
5738 /* If a unit is masked, then don't read the SELinux label of /dev/null, as that really makes no sense */
5739 if (path_equal(p, "/dev/null"))
5740 return NULL;
5741
5742 return p;
5743}
5744
6592b975
LP
5745int unit_pid_attachable(Unit *u, pid_t pid, sd_bus_error *error) {
5746 int r;
5747
5748 assert(u);
5749
5750 /* Checks whether the specified PID is generally good for attaching, i.e. a valid PID, not our manager itself,
5751 * and not a kernel thread either */
5752
5753 /* First, a simple range check */
5754 if (!pid_is_valid(pid))
5755 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Process identifier " PID_FMT " is not valid.", pid);
5756
5757 /* Some extra safety check */
5758 if (pid == 1 || pid == getpid_cached())
3fe91079 5759 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Process " PID_FMT " is a manager process, refusing.", pid);
6592b975
LP
5760
5761 /* Don't even begin to bother with kernel threads */
5762 r = is_kernel_thread(pid);
5763 if (r == -ESRCH)
5764 return sd_bus_error_setf(error, SD_BUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "Process with ID " PID_FMT " does not exist.", pid);
5765 if (r < 0)
5766 return sd_bus_error_set_errnof(error, r, "Failed to determine whether process " PID_FMT " is a kernel thread: %m", pid);
5767 if (r > 0)
5768 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Process " PID_FMT " is a kernel thread, refusing.", pid);
5769
5770 return 0;
5771}
5772
523ee2d4
LP
5773void unit_log_success(Unit *u) {
5774 assert(u);
5775
5776 log_struct(LOG_INFO,
5777 "MESSAGE_ID=" SD_MESSAGE_UNIT_SUCCESS_STR,
5778 LOG_UNIT_ID(u),
5779 LOG_UNIT_INVOCATION_ID(u),
5780 LOG_UNIT_MESSAGE(u, "Succeeded."));
5781}
5782
7c047d74
LP
5783void unit_log_failure(Unit *u, const char *result) {
5784 assert(u);
5785 assert(result);
5786
5787 log_struct(LOG_WARNING,
5788 "MESSAGE_ID=" SD_MESSAGE_UNIT_FAILURE_RESULT_STR,
5789 LOG_UNIT_ID(u),
5790 LOG_UNIT_INVOCATION_ID(u),
5791 LOG_UNIT_MESSAGE(u, "Failed with result '%s'.", result),
5792 "UNIT_RESULT=%s", result);
5793}
5794
31cd5f63
AZ
5795void unit_log_skip(Unit *u, const char *result) {
5796 assert(u);
5797 assert(result);
5798
5799 log_struct(LOG_INFO,
5800 "MESSAGE_ID=" SD_MESSAGE_UNIT_SKIPPED_STR,
5801 LOG_UNIT_ID(u),
5802 LOG_UNIT_INVOCATION_ID(u),
5803 LOG_UNIT_MESSAGE(u, "Skipped due to '%s'.", result),
5804 "UNIT_RESULT=%s", result);
5805}
5806
91bbd9b7
LP
5807void unit_log_process_exit(
5808 Unit *u,
91bbd9b7
LP
5809 const char *kind,
5810 const char *command,
5cc2cd1c 5811 bool success,
91bbd9b7
LP
5812 int code,
5813 int status) {
5814
5cc2cd1c
ZJS
5815 int level;
5816
91bbd9b7
LP
5817 assert(u);
5818 assert(kind);
5819
5cc2cd1c
ZJS
5820 /* If this is a successful exit, let's log about the exit code on DEBUG level. If this is a failure
5821 * and the process exited on its own via exit(), then let's make this a NOTICE, under the assumption
5822 * that the service already logged the reason at a higher log level on its own. Otherwise, make it a
5823 * WARNING. */
5824 if (success)
5825 level = LOG_DEBUG;
5826 else if (code == CLD_EXITED)
5827 level = LOG_NOTICE;
5828 else
91bbd9b7
LP
5829 level = LOG_WARNING;
5830
5831 log_struct(level,
5832 "MESSAGE_ID=" SD_MESSAGE_UNIT_PROCESS_EXIT_STR,
5833 LOG_UNIT_MESSAGE(u, "%s exited, code=%s, status=%i/%s",
5834 kind,
5835 sigchld_code_to_string(code), status,
5836 strna(code == CLD_EXITED
5837 ? exit_status_to_string(status, EXIT_STATUS_FULL)
5838 : signal_to_string(status))),
5839 "EXIT_CODE=%s", sigchld_code_to_string(code),
5840 "EXIT_STATUS=%i", status,
5841 "COMMAND=%s", strna(command),
5842 LOG_UNIT_ID(u),
5843 LOG_UNIT_INVOCATION_ID(u));
5844}
5845
7af67e9a
LP
5846int unit_exit_status(Unit *u) {
5847 assert(u);
5848
5849 /* Returns the exit status to propagate for the most recent cycle of this unit. Returns a value in the range
5850 * 0…255 if there's something to propagate. EOPNOTSUPP if the concept does not apply to this unit type, ENODATA
5851 * if no data is currently known (for example because the unit hasn't deactivated yet) and EBADE if the main
5852 * service process has exited abnormally (signal/coredump). */
5853
5854 if (!UNIT_VTABLE(u)->exit_status)
5855 return -EOPNOTSUPP;
5856
5857 return UNIT_VTABLE(u)->exit_status(u);
5858}
5859
5860int unit_failure_action_exit_status(Unit *u) {
5861 int r;
5862
5863 assert(u);
5864
5865 /* Returns the exit status to propagate on failure, or an error if there's nothing to propagate */
5866
5867 if (u->failure_action_exit_status >= 0)
5868 return u->failure_action_exit_status;
5869
5870 r = unit_exit_status(u);
5871 if (r == -EBADE) /* Exited, but not cleanly (i.e. by signal or such) */
5872 return 255;
5873
5874 return r;
5875}
5876
5877int unit_success_action_exit_status(Unit *u) {
5878 int r;
5879
5880 assert(u);
5881
5882 /* Returns the exit status to propagate on success, or an error if there's nothing to propagate */
5883
5884 if (u->success_action_exit_status >= 0)
5885 return u->success_action_exit_status;
5886
5887 r = unit_exit_status(u);
5888 if (r == -EBADE) /* Exited, but not cleanly (i.e. by signal or such) */
5889 return 255;
5890
5891 return r;
5892}
5893
a4191c9f
LP
5894int unit_test_trigger_loaded(Unit *u) {
5895 Unit *trigger;
5896
5897 /* Tests whether the unit to trigger is loaded */
5898
5899 trigger = UNIT_TRIGGER(u);
5900 if (!trigger)
e7b9f4d9
ZJS
5901 return log_unit_error_errno(u, SYNTHETIC_ERRNO(ENOENT),
5902 "Refusing to start, no unit to trigger.");
a4191c9f 5903 if (trigger->load_state != UNIT_LOADED)
e7b9f4d9
ZJS
5904 return log_unit_error_errno(u, SYNTHETIC_ERRNO(ENOENT),
5905 "Refusing to start, unit %s to trigger not loaded.", trigger->id);
a4191c9f
LP
5906
5907 return 0;
5908}
5909
95939aed
YW
5910void unit_destroy_runtime_directory(Unit *u, const ExecContext *context) {
5911 if (context->runtime_directory_preserve_mode == EXEC_PRESERVE_NO ||
5912 (context->runtime_directory_preserve_mode == EXEC_PRESERVE_RESTART && !unit_will_restart(u)))
5913 exec_context_destroy_runtime_directory(context, u->manager->prefix[EXEC_DIRECTORY_RUNTIME]);
5914}
5915
380dc8b0
LP
5916int unit_clean(Unit *u, ExecCleanMask mask) {
5917 UnitActiveState state;
5918
5919 assert(u);
5920
5921 /* Special return values:
5922 *
5923 * -EOPNOTSUPP → cleaning not supported for this unit type
5924 * -EUNATCH → cleaning not defined for this resource type
5925 * -EBUSY → unit currently can't be cleaned since it's running or not properly loaded, or has
5926 * a job queued or similar
5927 */
5928
5929 if (!UNIT_VTABLE(u)->clean)
5930 return -EOPNOTSUPP;
5931
5932 if (mask == 0)
5933 return -EUNATCH;
5934
5935 if (u->load_state != UNIT_LOADED)
5936 return -EBUSY;
5937
5938 if (u->job)
5939 return -EBUSY;
5940
5941 state = unit_active_state(u);
5942 if (!IN_SET(state, UNIT_INACTIVE))
5943 return -EBUSY;
5944
5945 return UNIT_VTABLE(u)->clean(u, mask);
5946}
5947
5948int unit_can_clean(Unit *u, ExecCleanMask *ret) {
5949 assert(u);
5950
5951 if (!UNIT_VTABLE(u)->clean ||
5952 u->load_state != UNIT_LOADED) {
5953 *ret = 0;
5954 return 0;
5955 }
5956
5957 /* When the clean() method is set, can_clean() really should be set too */
5958 assert(UNIT_VTABLE(u)->can_clean);
5959
5960 return UNIT_VTABLE(u)->can_clean(u, ret);
5961}
5962
5afe510c
LP
5963static const char* const collect_mode_table[_COLLECT_MODE_MAX] = {
5964 [COLLECT_INACTIVE] = "inactive",
5965 [COLLECT_INACTIVE_OR_FAILED] = "inactive-or-failed",
5966};
5967
5968DEFINE_STRING_TABLE_LOOKUP(collect_mode, CollectMode);