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