]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/unit.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
util-lib: split our string related calls from util.[ch] into its own file string...
[thirdparty/systemd.git] / src / core / unit.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <errno.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <sys/stat.h>
26 #include <unistd.h>
27
28 #include "sd-id128.h"
29 #include "sd-messages.h"
30
31 #include "bus-common-errors.h"
32 #include "bus-util.h"
33 #include "cgroup-util.h"
34 #include "dbus-unit.h"
35 #include "dbus.h"
36 #include "dropin.h"
37 #include "escape.h"
38 #include "execute.h"
39 #include "fileio-label.h"
40 #include "formats-util.h"
41 #include "load-dropin.h"
42 #include "load-fragment.h"
43 #include "log.h"
44 #include "macro.h"
45 #include "missing.h"
46 #include "mkdir.h"
47 #include "path-util.h"
48 #include "process-util.h"
49 #include "set.h"
50 #include "special.h"
51 #include "string-util.h"
52 #include "strv.h"
53 #include "unit-name.h"
54 #include "virt.h"
55 #include "unit.h"
56
57 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
58 [UNIT_SERVICE] = &service_vtable,
59 [UNIT_SOCKET] = &socket_vtable,
60 [UNIT_BUSNAME] = &busname_vtable,
61 [UNIT_TARGET] = &target_vtable,
62 [UNIT_SNAPSHOT] = &snapshot_vtable,
63 [UNIT_DEVICE] = &device_vtable,
64 [UNIT_MOUNT] = &mount_vtable,
65 [UNIT_AUTOMOUNT] = &automount_vtable,
66 [UNIT_SWAP] = &swap_vtable,
67 [UNIT_TIMER] = &timer_vtable,
68 [UNIT_PATH] = &path_vtable,
69 [UNIT_SLICE] = &slice_vtable,
70 [UNIT_SCOPE] = &scope_vtable
71 };
72
73 static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency);
74
75 Unit *unit_new(Manager *m, size_t size) {
76 Unit *u;
77
78 assert(m);
79 assert(size >= sizeof(Unit));
80
81 u = malloc0(size);
82 if (!u)
83 return NULL;
84
85 u->names = set_new(&string_hash_ops);
86 if (!u->names) {
87 free(u);
88 return NULL;
89 }
90
91 u->manager = m;
92 u->type = _UNIT_TYPE_INVALID;
93 u->default_dependencies = true;
94 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
95 u->unit_file_preset = -1;
96 u->on_failure_job_mode = JOB_REPLACE;
97 u->cgroup_inotify_wd = -1;
98
99 RATELIMIT_INIT(u->auto_stop_ratelimit, 10 * USEC_PER_SEC, 16);
100
101 return u;
102 }
103
104 bool unit_has_name(Unit *u, const char *name) {
105 assert(u);
106 assert(name);
107
108 return !!set_get(u->names, (char*) name);
109 }
110
111 static void unit_init(Unit *u) {
112 CGroupContext *cc;
113 ExecContext *ec;
114 KillContext *kc;
115
116 assert(u);
117 assert(u->manager);
118 assert(u->type >= 0);
119
120 cc = unit_get_cgroup_context(u);
121 if (cc) {
122 cgroup_context_init(cc);
123
124 /* Copy in the manager defaults into the cgroup
125 * context, _before_ the rest of the settings have
126 * been initialized */
127
128 cc->cpu_accounting = u->manager->default_cpu_accounting;
129 cc->blockio_accounting = u->manager->default_blockio_accounting;
130 cc->memory_accounting = u->manager->default_memory_accounting;
131 cc->tasks_accounting = u->manager->default_tasks_accounting;
132 }
133
134 ec = unit_get_exec_context(u);
135 if (ec)
136 exec_context_init(ec);
137
138 kc = unit_get_kill_context(u);
139 if (kc)
140 kill_context_init(kc);
141
142 if (UNIT_VTABLE(u)->init)
143 UNIT_VTABLE(u)->init(u);
144 }
145
146 int unit_add_name(Unit *u, const char *text) {
147 _cleanup_free_ char *s = NULL, *i = NULL;
148 UnitType t;
149 int r;
150
151 assert(u);
152 assert(text);
153
154 if (unit_name_is_valid(text, UNIT_NAME_TEMPLATE)) {
155
156 if (!u->instance)
157 return -EINVAL;
158
159 r = unit_name_replace_instance(text, u->instance, &s);
160 if (r < 0)
161 return r;
162 } else {
163 s = strdup(text);
164 if (!s)
165 return -ENOMEM;
166 }
167
168 if (set_contains(u->names, s))
169 return 0;
170 if (hashmap_contains(u->manager->units, s))
171 return -EEXIST;
172
173 if (!unit_name_is_valid(s, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
174 return -EINVAL;
175
176 t = unit_name_to_type(s);
177 if (t < 0)
178 return -EINVAL;
179
180 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
181 return -EINVAL;
182
183 r = unit_name_to_instance(s, &i);
184 if (r < 0)
185 return r;
186
187 if (i && unit_vtable[t]->no_instances)
188 return -EINVAL;
189
190 /* Ensure that this unit is either instanced or not instanced,
191 * but not both. Note that we do allow names with different
192 * instance names however! */
193 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
194 return -EINVAL;
195
196 if (unit_vtable[t]->no_alias && !set_isempty(u->names))
197 return -EEXIST;
198
199 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
200 return -E2BIG;
201
202 r = set_put(u->names, s);
203 if (r < 0)
204 return r;
205 assert(r > 0);
206
207 r = hashmap_put(u->manager->units, s, u);
208 if (r < 0) {
209 (void) set_remove(u->names, s);
210 return r;
211 }
212
213 if (u->type == _UNIT_TYPE_INVALID) {
214 u->type = t;
215 u->id = s;
216 u->instance = i;
217
218 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
219
220 unit_init(u);
221
222 i = NULL;
223 }
224
225 s = NULL;
226
227 unit_add_to_dbus_queue(u);
228 return 0;
229 }
230
231 int unit_choose_id(Unit *u, const char *name) {
232 _cleanup_free_ char *t = NULL;
233 char *s, *i;
234 int r;
235
236 assert(u);
237 assert(name);
238
239 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
240
241 if (!u->instance)
242 return -EINVAL;
243
244 r = unit_name_replace_instance(name, u->instance, &t);
245 if (r < 0)
246 return r;
247
248 name = t;
249 }
250
251 /* Selects one of the names of this unit as the id */
252 s = set_get(u->names, (char*) name);
253 if (!s)
254 return -ENOENT;
255
256 /* Determine the new instance from the new id */
257 r = unit_name_to_instance(s, &i);
258 if (r < 0)
259 return r;
260
261 u->id = s;
262
263 free(u->instance);
264 u->instance = i;
265
266 unit_add_to_dbus_queue(u);
267
268 return 0;
269 }
270
271 int unit_set_description(Unit *u, const char *description) {
272 char *s;
273
274 assert(u);
275
276 if (isempty(description))
277 s = NULL;
278 else {
279 s = strdup(description);
280 if (!s)
281 return -ENOMEM;
282 }
283
284 free(u->description);
285 u->description = s;
286
287 unit_add_to_dbus_queue(u);
288 return 0;
289 }
290
291 bool unit_check_gc(Unit *u) {
292 UnitActiveState state;
293 assert(u);
294
295 if (u->job)
296 return true;
297
298 if (u->nop_job)
299 return true;
300
301 state = unit_active_state(u);
302
303 /* If the unit is inactive and failed and no job is queued for
304 * it, then release its runtime resources */
305 if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
306 UNIT_VTABLE(u)->release_resources)
307 UNIT_VTABLE(u)->release_resources(u);
308
309 /* But we keep the unit object around for longer when it is
310 * referenced or configured to not be gc'ed */
311 if (state != UNIT_INACTIVE)
312 return true;
313
314 if (UNIT_VTABLE(u)->no_gc)
315 return true;
316
317 if (u->no_gc)
318 return true;
319
320 if (u->refs)
321 return true;
322
323 if (UNIT_VTABLE(u)->check_gc)
324 if (UNIT_VTABLE(u)->check_gc(u))
325 return true;
326
327 return false;
328 }
329
330 void unit_add_to_load_queue(Unit *u) {
331 assert(u);
332 assert(u->type != _UNIT_TYPE_INVALID);
333
334 if (u->load_state != UNIT_STUB || u->in_load_queue)
335 return;
336
337 LIST_PREPEND(load_queue, u->manager->load_queue, u);
338 u->in_load_queue = true;
339 }
340
341 void unit_add_to_cleanup_queue(Unit *u) {
342 assert(u);
343
344 if (u->in_cleanup_queue)
345 return;
346
347 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
348 u->in_cleanup_queue = true;
349 }
350
351 void unit_add_to_gc_queue(Unit *u) {
352 assert(u);
353
354 if (u->in_gc_queue || u->in_cleanup_queue)
355 return;
356
357 if (unit_check_gc(u))
358 return;
359
360 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
361 u->in_gc_queue = true;
362
363 u->manager->n_in_gc_queue ++;
364 }
365
366 void unit_add_to_dbus_queue(Unit *u) {
367 assert(u);
368 assert(u->type != _UNIT_TYPE_INVALID);
369
370 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
371 return;
372
373 /* Shortcut things if nobody cares */
374 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
375 set_isempty(u->manager->private_buses)) {
376 u->sent_dbus_new_signal = true;
377 return;
378 }
379
380 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
381 u->in_dbus_queue = true;
382 }
383
384 static void bidi_set_free(Unit *u, Set *s) {
385 Iterator i;
386 Unit *other;
387
388 assert(u);
389
390 /* Frees the set and makes sure we are dropped from the
391 * inverse pointers */
392
393 SET_FOREACH(other, s, i) {
394 UnitDependency d;
395
396 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
397 set_remove(other->dependencies[d], u);
398
399 unit_add_to_gc_queue(other);
400 }
401
402 set_free(s);
403 }
404
405 static void unit_remove_transient(Unit *u) {
406 char **i;
407
408 assert(u);
409
410 if (!u->transient)
411 return;
412
413 if (u->fragment_path)
414 (void) unlink(u->fragment_path);
415
416 STRV_FOREACH(i, u->dropin_paths) {
417 _cleanup_free_ char *p = NULL;
418 int r;
419
420 (void) unlink(*i);
421
422 r = path_get_parent(*i, &p);
423 if (r >= 0)
424 (void) rmdir(p);
425 }
426 }
427
428 static void unit_free_requires_mounts_for(Unit *u) {
429 char **j;
430
431 STRV_FOREACH(j, u->requires_mounts_for) {
432 char s[strlen(*j) + 1];
433
434 PATH_FOREACH_PREFIX_MORE(s, *j) {
435 char *y;
436 Set *x;
437
438 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
439 if (!x)
440 continue;
441
442 set_remove(x, u);
443
444 if (set_isempty(x)) {
445 hashmap_remove(u->manager->units_requiring_mounts_for, y);
446 free(y);
447 set_free(x);
448 }
449 }
450 }
451
452 u->requires_mounts_for = strv_free(u->requires_mounts_for);
453 }
454
455 static void unit_done(Unit *u) {
456 ExecContext *ec;
457 CGroupContext *cc;
458 int r;
459
460 assert(u);
461
462 if (u->type < 0)
463 return;
464
465 if (UNIT_VTABLE(u)->done)
466 UNIT_VTABLE(u)->done(u);
467
468 ec = unit_get_exec_context(u);
469 if (ec)
470 exec_context_done(ec);
471
472 cc = unit_get_cgroup_context(u);
473 if (cc)
474 cgroup_context_done(cc);
475
476 r = unit_remove_from_netclass_cgroup(u);
477 if (r < 0)
478 log_warning_errno(r, "Unable to remove unit from netclass group: %m");
479 }
480
481 void unit_free(Unit *u) {
482 UnitDependency d;
483 Iterator i;
484 char *t;
485
486 assert(u);
487
488 if (u->manager->n_reloading <= 0)
489 unit_remove_transient(u);
490
491 bus_unit_send_removed_signal(u);
492
493 unit_done(u);
494
495 sd_bus_slot_unref(u->match_bus_slot);
496
497 unit_free_requires_mounts_for(u);
498
499 SET_FOREACH(t, u->names, i)
500 hashmap_remove_value(u->manager->units, t, u);
501
502 if (u->job) {
503 Job *j = u->job;
504 job_uninstall(j);
505 job_free(j);
506 }
507
508 if (u->nop_job) {
509 Job *j = u->nop_job;
510 job_uninstall(j);
511 job_free(j);
512 }
513
514 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
515 bidi_set_free(u, u->dependencies[d]);
516
517 if (u->type != _UNIT_TYPE_INVALID)
518 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
519
520 if (u->in_load_queue)
521 LIST_REMOVE(load_queue, u->manager->load_queue, u);
522
523 if (u->in_dbus_queue)
524 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
525
526 if (u->in_cleanup_queue)
527 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
528
529 if (u->in_gc_queue) {
530 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
531 u->manager->n_in_gc_queue--;
532 }
533
534 if (u->in_cgroup_queue)
535 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
536
537 unit_release_cgroup(u);
538
539 (void) manager_update_failed_units(u->manager, u, false);
540 set_remove(u->manager->startup_units, u);
541
542 free(u->description);
543 strv_free(u->documentation);
544 free(u->fragment_path);
545 free(u->source_path);
546 strv_free(u->dropin_paths);
547 free(u->instance);
548
549 free(u->job_timeout_reboot_arg);
550
551 set_free_free(u->names);
552
553 unit_unwatch_all_pids(u);
554
555 condition_free_list(u->conditions);
556 condition_free_list(u->asserts);
557
558 unit_ref_unset(&u->slice);
559
560 while (u->refs)
561 unit_ref_unset(u->refs);
562
563 free(u);
564 }
565
566 UnitActiveState unit_active_state(Unit *u) {
567 assert(u);
568
569 if (u->load_state == UNIT_MERGED)
570 return unit_active_state(unit_follow_merge(u));
571
572 /* After a reload it might happen that a unit is not correctly
573 * loaded but still has a process around. That's why we won't
574 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
575
576 return UNIT_VTABLE(u)->active_state(u);
577 }
578
579 const char* unit_sub_state_to_string(Unit *u) {
580 assert(u);
581
582 return UNIT_VTABLE(u)->sub_state_to_string(u);
583 }
584
585 static int complete_move(Set **s, Set **other) {
586 int r;
587
588 assert(s);
589 assert(other);
590
591 if (!*other)
592 return 0;
593
594 if (*s) {
595 r = set_move(*s, *other);
596 if (r < 0)
597 return r;
598 } else {
599 *s = *other;
600 *other = NULL;
601 }
602
603 return 0;
604 }
605
606 static int merge_names(Unit *u, Unit *other) {
607 char *t;
608 Iterator i;
609 int r;
610
611 assert(u);
612 assert(other);
613
614 r = complete_move(&u->names, &other->names);
615 if (r < 0)
616 return r;
617
618 set_free_free(other->names);
619 other->names = NULL;
620 other->id = NULL;
621
622 SET_FOREACH(t, u->names, i)
623 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
624
625 return 0;
626 }
627
628 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
629 unsigned n_reserve;
630
631 assert(u);
632 assert(other);
633 assert(d < _UNIT_DEPENDENCY_MAX);
634
635 /*
636 * If u does not have this dependency set allocated, there is no need
637 * to reserve anything. In that case other's set will be transferred
638 * as a whole to u by complete_move().
639 */
640 if (!u->dependencies[d])
641 return 0;
642
643 /* merge_dependencies() will skip a u-on-u dependency */
644 n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
645
646 return set_reserve(u->dependencies[d], n_reserve);
647 }
648
649 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
650 Iterator i;
651 Unit *back;
652 int r;
653
654 assert(u);
655 assert(other);
656 assert(d < _UNIT_DEPENDENCY_MAX);
657
658 /* Fix backwards pointers */
659 SET_FOREACH(back, other->dependencies[d], i) {
660 UnitDependency k;
661
662 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
663 /* Do not add dependencies between u and itself */
664 if (back == u) {
665 if (set_remove(back->dependencies[k], other))
666 maybe_warn_about_dependency(u, other_id, k);
667 } else {
668 r = set_remove_and_put(back->dependencies[k], other, u);
669 if (r == -EEXIST)
670 set_remove(back->dependencies[k], other);
671 else
672 assert(r >= 0 || r == -ENOENT);
673 }
674 }
675 }
676
677 /* Also do not move dependencies on u to itself */
678 back = set_remove(other->dependencies[d], u);
679 if (back)
680 maybe_warn_about_dependency(u, other_id, d);
681
682 /* The move cannot fail. The caller must have performed a reservation. */
683 assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
684
685 other->dependencies[d] = set_free(other->dependencies[d]);
686 }
687
688 int unit_merge(Unit *u, Unit *other) {
689 UnitDependency d;
690 const char *other_id = NULL;
691 int r;
692
693 assert(u);
694 assert(other);
695 assert(u->manager == other->manager);
696 assert(u->type != _UNIT_TYPE_INVALID);
697
698 other = unit_follow_merge(other);
699
700 if (other == u)
701 return 0;
702
703 if (u->type != other->type)
704 return -EINVAL;
705
706 if (!u->instance != !other->instance)
707 return -EINVAL;
708
709 if (other->load_state != UNIT_STUB &&
710 other->load_state != UNIT_NOT_FOUND)
711 return -EEXIST;
712
713 if (other->job)
714 return -EEXIST;
715
716 if (other->nop_job)
717 return -EEXIST;
718
719 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
720 return -EEXIST;
721
722 if (other->id)
723 other_id = strdupa(other->id);
724
725 /* Make reservations to ensure merge_dependencies() won't fail */
726 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
727 r = reserve_dependencies(u, other, d);
728 /*
729 * We don't rollback reservations if we fail. We don't have
730 * a way to undo reservations. A reservation is not a leak.
731 */
732 if (r < 0)
733 return r;
734 }
735
736 /* Merge names */
737 r = merge_names(u, other);
738 if (r < 0)
739 return r;
740
741 /* Redirect all references */
742 while (other->refs)
743 unit_ref_set(other->refs, u);
744
745 /* Merge dependencies */
746 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
747 merge_dependencies(u, other, other_id, d);
748
749 other->load_state = UNIT_MERGED;
750 other->merged_into = u;
751
752 /* If there is still some data attached to the other node, we
753 * don't need it anymore, and can free it. */
754 if (other->load_state != UNIT_STUB)
755 if (UNIT_VTABLE(other)->done)
756 UNIT_VTABLE(other)->done(other);
757
758 unit_add_to_dbus_queue(u);
759 unit_add_to_cleanup_queue(other);
760
761 return 0;
762 }
763
764 int unit_merge_by_name(Unit *u, const char *name) {
765 Unit *other;
766 int r;
767 _cleanup_free_ char *s = NULL;
768
769 assert(u);
770 assert(name);
771
772 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
773 if (!u->instance)
774 return -EINVAL;
775
776 r = unit_name_replace_instance(name, u->instance, &s);
777 if (r < 0)
778 return r;
779
780 name = s;
781 }
782
783 other = manager_get_unit(u->manager, name);
784 if (other)
785 return unit_merge(u, other);
786
787 return unit_add_name(u, name);
788 }
789
790 Unit* unit_follow_merge(Unit *u) {
791 assert(u);
792
793 while (u->load_state == UNIT_MERGED)
794 assert_se(u = u->merged_into);
795
796 return u;
797 }
798
799 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
800 int r;
801
802 assert(u);
803 assert(c);
804
805 if (c->working_directory) {
806 r = unit_require_mounts_for(u, c->working_directory);
807 if (r < 0)
808 return r;
809 }
810
811 if (c->root_directory) {
812 r = unit_require_mounts_for(u, c->root_directory);
813 if (r < 0)
814 return r;
815 }
816
817 if (u->manager->running_as != MANAGER_SYSTEM)
818 return 0;
819
820 if (c->private_tmp) {
821 r = unit_require_mounts_for(u, "/tmp");
822 if (r < 0)
823 return r;
824
825 r = unit_require_mounts_for(u, "/var/tmp");
826 if (r < 0)
827 return r;
828 }
829
830 if (c->std_output != EXEC_OUTPUT_KMSG &&
831 c->std_output != EXEC_OUTPUT_SYSLOG &&
832 c->std_output != EXEC_OUTPUT_JOURNAL &&
833 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
834 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
835 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
836 c->std_error != EXEC_OUTPUT_KMSG &&
837 c->std_error != EXEC_OUTPUT_SYSLOG &&
838 c->std_error != EXEC_OUTPUT_JOURNAL &&
839 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
840 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
841 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
842 return 0;
843
844 /* If syslog or kernel logging is requested, make sure our own
845 * logging daemon is run first. */
846
847 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
848 if (r < 0)
849 return r;
850
851 return 0;
852 }
853
854 const char *unit_description(Unit *u) {
855 assert(u);
856
857 if (u->description)
858 return u->description;
859
860 return strna(u->id);
861 }
862
863 void unit_dump(Unit *u, FILE *f, const char *prefix) {
864 char *t, **j;
865 UnitDependency d;
866 Iterator i;
867 const char *prefix2;
868 char
869 timestamp1[FORMAT_TIMESTAMP_MAX],
870 timestamp2[FORMAT_TIMESTAMP_MAX],
871 timestamp3[FORMAT_TIMESTAMP_MAX],
872 timestamp4[FORMAT_TIMESTAMP_MAX],
873 timespan[FORMAT_TIMESPAN_MAX];
874 Unit *following;
875 _cleanup_set_free_ Set *following_set = NULL;
876 int r;
877
878 assert(u);
879 assert(u->type >= 0);
880
881 prefix = strempty(prefix);
882 prefix2 = strjoina(prefix, "\t");
883
884 fprintf(f,
885 "%s-> Unit %s:\n"
886 "%s\tDescription: %s\n"
887 "%s\tInstance: %s\n"
888 "%s\tUnit Load State: %s\n"
889 "%s\tUnit Active State: %s\n"
890 "%s\tInactive Exit Timestamp: %s\n"
891 "%s\tActive Enter Timestamp: %s\n"
892 "%s\tActive Exit Timestamp: %s\n"
893 "%s\tInactive Enter Timestamp: %s\n"
894 "%s\tGC Check Good: %s\n"
895 "%s\tNeed Daemon Reload: %s\n"
896 "%s\tTransient: %s\n"
897 "%s\tSlice: %s\n"
898 "%s\tCGroup: %s\n"
899 "%s\tCGroup realized: %s\n"
900 "%s\tCGroup mask: 0x%x\n"
901 "%s\tCGroup members mask: 0x%x\n",
902 prefix, u->id,
903 prefix, unit_description(u),
904 prefix, strna(u->instance),
905 prefix, unit_load_state_to_string(u->load_state),
906 prefix, unit_active_state_to_string(unit_active_state(u)),
907 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
908 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
909 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
910 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
911 prefix, yes_no(unit_check_gc(u)),
912 prefix, yes_no(unit_need_daemon_reload(u)),
913 prefix, yes_no(u->transient),
914 prefix, strna(unit_slice_name(u)),
915 prefix, strna(u->cgroup_path),
916 prefix, yes_no(u->cgroup_realized),
917 prefix, u->cgroup_realized_mask,
918 prefix, u->cgroup_members_mask);
919
920 SET_FOREACH(t, u->names, i)
921 fprintf(f, "%s\tName: %s\n", prefix, t);
922
923 STRV_FOREACH(j, u->documentation)
924 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
925
926 following = unit_following(u);
927 if (following)
928 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
929
930 r = unit_following_set(u, &following_set);
931 if (r >= 0) {
932 Unit *other;
933
934 SET_FOREACH(other, following_set, i)
935 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
936 }
937
938 if (u->fragment_path)
939 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
940
941 if (u->source_path)
942 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
943
944 STRV_FOREACH(j, u->dropin_paths)
945 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
946
947 if (u->job_timeout > 0)
948 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
949
950 if (u->job_timeout_action != FAILURE_ACTION_NONE)
951 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
952
953 if (u->job_timeout_reboot_arg)
954 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
955
956 condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
957 condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
958
959 if (dual_timestamp_is_set(&u->condition_timestamp))
960 fprintf(f,
961 "%s\tCondition Timestamp: %s\n"
962 "%s\tCondition Result: %s\n",
963 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
964 prefix, yes_no(u->condition_result));
965
966 if (dual_timestamp_is_set(&u->assert_timestamp))
967 fprintf(f,
968 "%s\tAssert Timestamp: %s\n"
969 "%s\tAssert Result: %s\n",
970 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),
971 prefix, yes_no(u->assert_result));
972
973 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
974 Unit *other;
975
976 SET_FOREACH(other, u->dependencies[d], i)
977 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
978 }
979
980 if (!strv_isempty(u->requires_mounts_for)) {
981 fprintf(f,
982 "%s\tRequiresMountsFor:", prefix);
983
984 STRV_FOREACH(j, u->requires_mounts_for)
985 fprintf(f, " %s", *j);
986
987 fputs("\n", f);
988 }
989
990 if (u->load_state == UNIT_LOADED) {
991
992 fprintf(f,
993 "%s\tStopWhenUnneeded: %s\n"
994 "%s\tRefuseManualStart: %s\n"
995 "%s\tRefuseManualStop: %s\n"
996 "%s\tDefaultDependencies: %s\n"
997 "%s\tOnFailureJobMode: %s\n"
998 "%s\tIgnoreOnIsolate: %s\n"
999 "%s\tIgnoreOnSnapshot: %s\n",
1000 prefix, yes_no(u->stop_when_unneeded),
1001 prefix, yes_no(u->refuse_manual_start),
1002 prefix, yes_no(u->refuse_manual_stop),
1003 prefix, yes_no(u->default_dependencies),
1004 prefix, job_mode_to_string(u->on_failure_job_mode),
1005 prefix, yes_no(u->ignore_on_isolate),
1006 prefix, yes_no(u->ignore_on_snapshot));
1007
1008 if (UNIT_VTABLE(u)->dump)
1009 UNIT_VTABLE(u)->dump(u, f, prefix2);
1010
1011 } else if (u->load_state == UNIT_MERGED)
1012 fprintf(f,
1013 "%s\tMerged into: %s\n",
1014 prefix, u->merged_into->id);
1015 else if (u->load_state == UNIT_ERROR)
1016 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
1017
1018
1019 if (u->job)
1020 job_dump(u->job, f, prefix2);
1021
1022 if (u->nop_job)
1023 job_dump(u->nop_job, f, prefix2);
1024
1025 }
1026
1027 /* Common implementation for multiple backends */
1028 int unit_load_fragment_and_dropin(Unit *u) {
1029 int r;
1030
1031 assert(u);
1032
1033 /* Load a .{service,socket,...} file */
1034 r = unit_load_fragment(u);
1035 if (r < 0)
1036 return r;
1037
1038 if (u->load_state == UNIT_STUB)
1039 return -ENOENT;
1040
1041 /* Load drop-in directory data */
1042 r = unit_load_dropin(unit_follow_merge(u));
1043 if (r < 0)
1044 return r;
1045
1046 return 0;
1047 }
1048
1049 /* Common implementation for multiple backends */
1050 int unit_load_fragment_and_dropin_optional(Unit *u) {
1051 int r;
1052
1053 assert(u);
1054
1055 /* Same as unit_load_fragment_and_dropin(), but whether
1056 * something can be loaded or not doesn't matter. */
1057
1058 /* Load a .service file */
1059 r = unit_load_fragment(u);
1060 if (r < 0)
1061 return r;
1062
1063 if (u->load_state == UNIT_STUB)
1064 u->load_state = UNIT_LOADED;
1065
1066 /* Load drop-in directory data */
1067 r = unit_load_dropin(unit_follow_merge(u));
1068 if (r < 0)
1069 return r;
1070
1071 return 0;
1072 }
1073
1074 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1075 assert(u);
1076 assert(target);
1077
1078 if (target->type != UNIT_TARGET)
1079 return 0;
1080
1081 /* Only add the dependency if both units are loaded, so that
1082 * that loop check below is reliable */
1083 if (u->load_state != UNIT_LOADED ||
1084 target->load_state != UNIT_LOADED)
1085 return 0;
1086
1087 /* If either side wants no automatic dependencies, then let's
1088 * skip this */
1089 if (!u->default_dependencies ||
1090 !target->default_dependencies)
1091 return 0;
1092
1093 /* Don't create loops */
1094 if (set_get(target->dependencies[UNIT_BEFORE], u))
1095 return 0;
1096
1097 return unit_add_dependency(target, UNIT_AFTER, u, true);
1098 }
1099
1100 static int unit_add_target_dependencies(Unit *u) {
1101
1102 static const UnitDependency deps[] = {
1103 UNIT_REQUIRED_BY,
1104 UNIT_REQUIRED_BY_OVERRIDABLE,
1105 UNIT_REQUISITE_OF,
1106 UNIT_REQUISITE_OF_OVERRIDABLE,
1107 UNIT_WANTED_BY,
1108 UNIT_BOUND_BY
1109 };
1110
1111 Unit *target;
1112 Iterator i;
1113 unsigned k;
1114 int r = 0;
1115
1116 assert(u);
1117
1118 for (k = 0; k < ELEMENTSOF(deps); k++)
1119 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1120 r = unit_add_default_target_dependency(u, target);
1121 if (r < 0)
1122 return r;
1123 }
1124
1125 return r;
1126 }
1127
1128 static int unit_add_slice_dependencies(Unit *u) {
1129 assert(u);
1130
1131 if (!UNIT_HAS_CGROUP_CONTEXT(u))
1132 return 0;
1133
1134 if (UNIT_ISSET(u->slice))
1135 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT_DEREF(u->slice), true);
1136
1137 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
1138 return 0;
1139
1140 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_REQUIRES, SPECIAL_ROOT_SLICE, NULL, true);
1141 }
1142
1143 static int unit_add_mount_dependencies(Unit *u) {
1144 char **i;
1145 int r;
1146
1147 assert(u);
1148
1149 STRV_FOREACH(i, u->requires_mounts_for) {
1150 char prefix[strlen(*i) + 1];
1151
1152 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1153 _cleanup_free_ char *p = NULL;
1154 Unit *m;
1155
1156 r = unit_name_from_path(prefix, ".mount", &p);
1157 if (r < 0)
1158 return r;
1159
1160 m = manager_get_unit(u->manager, p);
1161 if (!m) {
1162 /* Make sure to load the mount unit if
1163 * it exists. If so the dependencies
1164 * on this unit will be added later
1165 * during the loading of the mount
1166 * unit. */
1167 (void) manager_load_unit_prepare(u->manager, p, NULL, NULL, &m);
1168 continue;
1169 }
1170 if (m == u)
1171 continue;
1172
1173 if (m->load_state != UNIT_LOADED)
1174 continue;
1175
1176 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1177 if (r < 0)
1178 return r;
1179
1180 if (m->fragment_path) {
1181 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1182 if (r < 0)
1183 return r;
1184 }
1185 }
1186 }
1187
1188 return 0;
1189 }
1190
1191 static int unit_add_startup_units(Unit *u) {
1192 CGroupContext *c;
1193 int r;
1194
1195 c = unit_get_cgroup_context(u);
1196 if (!c)
1197 return 0;
1198
1199 if (c->startup_cpu_shares == CGROUP_CPU_SHARES_INVALID &&
1200 c->startup_blockio_weight == CGROUP_BLKIO_WEIGHT_INVALID)
1201 return 0;
1202
1203 r = set_ensure_allocated(&u->manager->startup_units, NULL);
1204 if (r < 0)
1205 return r;
1206
1207 return set_put(u->manager->startup_units, u);
1208 }
1209
1210 int unit_load(Unit *u) {
1211 int r;
1212
1213 assert(u);
1214
1215 if (u->in_load_queue) {
1216 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1217 u->in_load_queue = false;
1218 }
1219
1220 if (u->type == _UNIT_TYPE_INVALID)
1221 return -EINVAL;
1222
1223 if (u->load_state != UNIT_STUB)
1224 return 0;
1225
1226 if (UNIT_VTABLE(u)->load) {
1227 r = UNIT_VTABLE(u)->load(u);
1228 if (r < 0)
1229 goto fail;
1230 }
1231
1232 if (u->load_state == UNIT_STUB) {
1233 r = -ENOENT;
1234 goto fail;
1235 }
1236
1237 if (u->load_state == UNIT_LOADED) {
1238
1239 r = unit_add_target_dependencies(u);
1240 if (r < 0)
1241 goto fail;
1242
1243 r = unit_add_slice_dependencies(u);
1244 if (r < 0)
1245 goto fail;
1246
1247 r = unit_add_mount_dependencies(u);
1248 if (r < 0)
1249 goto fail;
1250
1251 r = unit_add_startup_units(u);
1252 if (r < 0)
1253 goto fail;
1254
1255 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1256 log_unit_error(u, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1257 r = -EINVAL;
1258 goto fail;
1259 }
1260
1261 unit_update_cgroup_members_masks(u);
1262
1263 /* If we are reloading, we need to wait for the deserializer
1264 * to restore the net_cls ids that have been set previously */
1265 if (u->manager->n_reloading <= 0) {
1266 r = unit_add_to_netclass_cgroup(u);
1267 if (r < 0)
1268 return r;
1269 }
1270 }
1271
1272 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1273
1274 unit_add_to_dbus_queue(unit_follow_merge(u));
1275 unit_add_to_gc_queue(u);
1276
1277 return 0;
1278
1279 fail:
1280 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1281 u->load_error = r;
1282 unit_add_to_dbus_queue(u);
1283 unit_add_to_gc_queue(u);
1284
1285 log_unit_debug_errno(u, r, "Failed to load configuration: %m");
1286
1287 return r;
1288 }
1289
1290 static bool unit_condition_test_list(Unit *u, Condition *first, const char *(*to_string)(ConditionType t)) {
1291 Condition *c;
1292 int triggered = -1;
1293
1294 assert(u);
1295 assert(to_string);
1296
1297 /* If the condition list is empty, then it is true */
1298 if (!first)
1299 return true;
1300
1301 /* Otherwise, if all of the non-trigger conditions apply and
1302 * if any of the trigger conditions apply (unless there are
1303 * none) we return true */
1304 LIST_FOREACH(conditions, c, first) {
1305 int r;
1306
1307 r = condition_test(c);
1308 if (r < 0)
1309 log_unit_warning(u,
1310 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1311 to_string(c->type),
1312 c->trigger ? "|" : "",
1313 c->negate ? "!" : "",
1314 c->parameter);
1315 else
1316 log_unit_debug(u,
1317 "%s=%s%s%s %s.",
1318 to_string(c->type),
1319 c->trigger ? "|" : "",
1320 c->negate ? "!" : "",
1321 c->parameter,
1322 condition_result_to_string(c->result));
1323
1324 if (!c->trigger && r <= 0)
1325 return false;
1326
1327 if (c->trigger && triggered <= 0)
1328 triggered = r > 0;
1329 }
1330
1331 return triggered != 0;
1332 }
1333
1334 static bool unit_condition_test(Unit *u) {
1335 assert(u);
1336
1337 dual_timestamp_get(&u->condition_timestamp);
1338 u->condition_result = unit_condition_test_list(u, u->conditions, condition_type_to_string);
1339
1340 return u->condition_result;
1341 }
1342
1343 static bool unit_assert_test(Unit *u) {
1344 assert(u);
1345
1346 dual_timestamp_get(&u->assert_timestamp);
1347 u->assert_result = unit_condition_test_list(u, u->asserts, assert_type_to_string);
1348
1349 return u->assert_result;
1350 }
1351
1352 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1353 const char *format;
1354 const UnitStatusMessageFormats *format_table;
1355
1356 assert(u);
1357 assert(t == JOB_START || t == JOB_STOP || t == JOB_RELOAD);
1358
1359 if (t != JOB_RELOAD) {
1360 format_table = &UNIT_VTABLE(u)->status_message_formats;
1361 if (format_table) {
1362 format = format_table->starting_stopping[t == JOB_STOP];
1363 if (format)
1364 return format;
1365 }
1366 }
1367
1368 /* Return generic strings */
1369 if (t == JOB_START)
1370 return "Starting %s.";
1371 else if (t == JOB_STOP)
1372 return "Stopping %s.";
1373 else
1374 return "Reloading %s.";
1375 }
1376
1377 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1378 const char *format;
1379
1380 assert(u);
1381
1382 format = unit_get_status_message_format(u, t);
1383
1384 DISABLE_WARNING_FORMAT_NONLITERAL;
1385 unit_status_printf(u, "", format);
1386 REENABLE_WARNING;
1387 }
1388
1389 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1390 const char *format;
1391 char buf[LINE_MAX];
1392 sd_id128_t mid;
1393
1394 assert(u);
1395
1396 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1397 return;
1398
1399 if (log_on_console())
1400 return;
1401
1402 /* We log status messages for all units and all operations. */
1403
1404 format = unit_get_status_message_format(u, t);
1405
1406 DISABLE_WARNING_FORMAT_NONLITERAL;
1407 snprintf(buf, sizeof(buf), format, unit_description(u));
1408 REENABLE_WARNING;
1409
1410 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1411 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1412 SD_MESSAGE_UNIT_RELOADING;
1413
1414 /* Note that we deliberately use LOG_MESSAGE() instead of
1415 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1416 * closely what is written to screen using the status output,
1417 * which is supposed the highest level, friendliest output
1418 * possible, which means we should avoid the low-level unit
1419 * name. */
1420 log_struct(LOG_INFO,
1421 LOG_MESSAGE_ID(mid),
1422 LOG_UNIT_ID(u),
1423 LOG_MESSAGE("%s", buf),
1424 NULL);
1425 }
1426
1427 void unit_status_emit_starting_stopping_reloading(Unit *u, JobType t) {
1428
1429 unit_status_log_starting_stopping_reloading(u, t);
1430
1431 /* Reload status messages have traditionally not been printed to console. */
1432 if (t != JOB_RELOAD)
1433 unit_status_print_starting_stopping(u, t);
1434 }
1435
1436 /* Errors:
1437 * -EBADR: This unit type does not support starting.
1438 * -EALREADY: Unit is already started.
1439 * -EAGAIN: An operation is already in progress. Retry later.
1440 * -ECANCELED: Too many requests for now.
1441 * -EPROTO: Assert failed
1442 */
1443 int unit_start(Unit *u) {
1444 UnitActiveState state;
1445 Unit *following;
1446
1447 assert(u);
1448
1449 /* Units that aren't loaded cannot be started */
1450 if (u->load_state != UNIT_LOADED)
1451 return -EINVAL;
1452
1453 /* If this is already started, then this will succeed. Note
1454 * that this will even succeed if this unit is not startable
1455 * by the user. This is relied on to detect when we need to
1456 * wait for units and when waiting is finished. */
1457 state = unit_active_state(u);
1458 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1459 return -EALREADY;
1460
1461 /* If the conditions failed, don't do anything at all. If we
1462 * already are activating this call might still be useful to
1463 * speed up activation in case there is some hold-off time,
1464 * but we don't want to recheck the condition in that case. */
1465 if (state != UNIT_ACTIVATING &&
1466 !unit_condition_test(u)) {
1467 log_unit_debug(u, "Starting requested but condition failed. Not starting unit.");
1468 return -EALREADY;
1469 }
1470
1471 /* If the asserts failed, fail the entire job */
1472 if (state != UNIT_ACTIVATING &&
1473 !unit_assert_test(u)) {
1474 log_unit_notice(u, "Starting requested but asserts failed.");
1475 return -EPROTO;
1476 }
1477
1478 /* Units of types that aren't supported cannot be
1479 * started. Note that we do this test only after the condition
1480 * checks, so that we rather return condition check errors
1481 * (which are usually not considered a true failure) than "not
1482 * supported" errors (which are considered a failure).
1483 */
1484 if (!unit_supported(u))
1485 return -EOPNOTSUPP;
1486
1487 /* Forward to the main object, if we aren't it. */
1488 following = unit_following(u);
1489 if (following) {
1490 log_unit_debug(u, "Redirecting start request from %s to %s.", u->id, following->id);
1491 return unit_start(following);
1492 }
1493
1494 /* If it is stopped, but we cannot start it, then fail */
1495 if (!UNIT_VTABLE(u)->start)
1496 return -EBADR;
1497
1498 /* We don't suppress calls to ->start() here when we are
1499 * already starting, to allow this request to be used as a
1500 * "hurry up" call, for example when the unit is in some "auto
1501 * restart" state where it waits for a holdoff timer to elapse
1502 * before it will start again. */
1503
1504 unit_add_to_dbus_queue(u);
1505
1506 return UNIT_VTABLE(u)->start(u);
1507 }
1508
1509 bool unit_can_start(Unit *u) {
1510 assert(u);
1511
1512 if (u->load_state != UNIT_LOADED)
1513 return false;
1514
1515 if (!unit_supported(u))
1516 return false;
1517
1518 return !!UNIT_VTABLE(u)->start;
1519 }
1520
1521 bool unit_can_isolate(Unit *u) {
1522 assert(u);
1523
1524 return unit_can_start(u) &&
1525 u->allow_isolate;
1526 }
1527
1528 /* Errors:
1529 * -EBADR: This unit type does not support stopping.
1530 * -EALREADY: Unit is already stopped.
1531 * -EAGAIN: An operation is already in progress. Retry later.
1532 */
1533 int unit_stop(Unit *u) {
1534 UnitActiveState state;
1535 Unit *following;
1536
1537 assert(u);
1538
1539 state = unit_active_state(u);
1540 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1541 return -EALREADY;
1542
1543 following = unit_following(u);
1544 if (following) {
1545 log_unit_debug(u, "Redirecting stop request from %s to %s.", u->id, following->id);
1546 return unit_stop(following);
1547 }
1548
1549 if (!UNIT_VTABLE(u)->stop)
1550 return -EBADR;
1551
1552 unit_add_to_dbus_queue(u);
1553
1554 return UNIT_VTABLE(u)->stop(u);
1555 }
1556
1557 /* Errors:
1558 * -EBADR: This unit type does not support reloading.
1559 * -ENOEXEC: Unit is not started.
1560 * -EAGAIN: An operation is already in progress. Retry later.
1561 */
1562 int unit_reload(Unit *u) {
1563 UnitActiveState state;
1564 Unit *following;
1565
1566 assert(u);
1567
1568 if (u->load_state != UNIT_LOADED)
1569 return -EINVAL;
1570
1571 if (!unit_can_reload(u))
1572 return -EBADR;
1573
1574 state = unit_active_state(u);
1575 if (state == UNIT_RELOADING)
1576 return -EALREADY;
1577
1578 if (state != UNIT_ACTIVE) {
1579 log_unit_warning(u, "Unit cannot be reloaded because it is inactive.");
1580 return -ENOEXEC;
1581 }
1582
1583 following = unit_following(u);
1584 if (following) {
1585 log_unit_debug(u, "Redirecting reload request from %s to %s.", u->id, following->id);
1586 return unit_reload(following);
1587 }
1588
1589 unit_add_to_dbus_queue(u);
1590
1591 return UNIT_VTABLE(u)->reload(u);
1592 }
1593
1594 bool unit_can_reload(Unit *u) {
1595 assert(u);
1596
1597 if (!UNIT_VTABLE(u)->reload)
1598 return false;
1599
1600 if (!UNIT_VTABLE(u)->can_reload)
1601 return true;
1602
1603 return UNIT_VTABLE(u)->can_reload(u);
1604 }
1605
1606 static void unit_check_unneeded(Unit *u) {
1607
1608 static const UnitDependency needed_dependencies[] = {
1609 UNIT_REQUIRED_BY,
1610 UNIT_REQUIRED_BY_OVERRIDABLE,
1611 UNIT_REQUISITE_OF,
1612 UNIT_REQUISITE_OF_OVERRIDABLE,
1613 UNIT_WANTED_BY,
1614 UNIT_BOUND_BY,
1615 };
1616
1617 Unit *other;
1618 Iterator i;
1619 unsigned j;
1620 int r;
1621
1622 assert(u);
1623
1624 /* If this service shall be shut down when unneeded then do
1625 * so. */
1626
1627 if (!u->stop_when_unneeded)
1628 return;
1629
1630 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1631 return;
1632
1633 for (j = 0; j < ELEMENTSOF(needed_dependencies); j++)
1634 SET_FOREACH(other, u->dependencies[needed_dependencies[j]], i)
1635 if (unit_active_or_pending(other))
1636 return;
1637
1638 /* If stopping a unit fails continously we might enter a stop
1639 * loop here, hence stop acting on the service being
1640 * unnecessary after a while. */
1641 if (!ratelimit_test(&u->auto_stop_ratelimit)) {
1642 log_unit_warning(u, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1643 return;
1644 }
1645
1646 log_unit_info(u, "Unit not needed anymore. Stopping.");
1647
1648 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1649 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1650 if (r < 0)
1651 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %m");
1652 }
1653
1654 static void unit_check_binds_to(Unit *u) {
1655 bool stop = false;
1656 Unit *other;
1657 Iterator i;
1658 int r;
1659
1660 assert(u);
1661
1662 if (u->job)
1663 return;
1664
1665 if (unit_active_state(u) != UNIT_ACTIVE)
1666 return;
1667
1668 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1669 if (other->job)
1670 continue;
1671
1672 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1673 continue;
1674
1675 stop = true;
1676 break;
1677 }
1678
1679 if (!stop)
1680 return;
1681
1682 /* If stopping a unit fails continously we might enter a stop
1683 * loop here, hence stop acting on the service being
1684 * unnecessary after a while. */
1685 if (!ratelimit_test(&u->auto_stop_ratelimit)) {
1686 log_unit_warning(u, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other->id);
1687 return;
1688 }
1689
1690 assert(other);
1691 log_unit_info(u, "Unit is bound to inactive unit %s. Stopping, too.", other->id);
1692
1693 /* A unit we need to run is gone. Sniff. Let's stop this. */
1694 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1695 if (r < 0)
1696 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %m");
1697 }
1698
1699 static void retroactively_start_dependencies(Unit *u) {
1700 Iterator i;
1701 Unit *other;
1702
1703 assert(u);
1704 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1705
1706 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1707 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1708 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1709 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1710
1711 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1712 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1713 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1714 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1715
1716 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1717 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1718 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1719 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1720
1721 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1722 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1723 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1724 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1725
1726 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1727 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1728 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1729
1730 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1731 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1732 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1733 }
1734
1735 static void retroactively_stop_dependencies(Unit *u) {
1736 Iterator i;
1737 Unit *other;
1738
1739 assert(u);
1740 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1741
1742 /* Pull down units which are bound to us recursively if enabled */
1743 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1744 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1745 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1746 }
1747
1748 static void check_unneeded_dependencies(Unit *u) {
1749 Iterator i;
1750 Unit *other;
1751
1752 assert(u);
1753 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1754
1755 /* Garbage collect services that might not be needed anymore, if enabled */
1756 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1757 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1758 unit_check_unneeded(other);
1759 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1760 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1761 unit_check_unneeded(other);
1762 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1763 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1764 unit_check_unneeded(other);
1765 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1766 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1767 unit_check_unneeded(other);
1768 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1769 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1770 unit_check_unneeded(other);
1771 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1772 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1773 unit_check_unneeded(other);
1774 }
1775
1776 void unit_start_on_failure(Unit *u) {
1777 Unit *other;
1778 Iterator i;
1779
1780 assert(u);
1781
1782 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1783 return;
1784
1785 log_unit_info(u, "Triggering OnFailure= dependencies.");
1786
1787 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1788 int r;
1789
1790 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1791 if (r < 0)
1792 log_unit_error_errno(u, r, "Failed to enqueue OnFailure= job: %m");
1793 }
1794 }
1795
1796 void unit_trigger_notify(Unit *u) {
1797 Unit *other;
1798 Iterator i;
1799
1800 assert(u);
1801
1802 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1803 if (UNIT_VTABLE(other)->trigger_notify)
1804 UNIT_VTABLE(other)->trigger_notify(other, u);
1805 }
1806
1807 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1808 Manager *m;
1809 bool unexpected;
1810
1811 assert(u);
1812 assert(os < _UNIT_ACTIVE_STATE_MAX);
1813 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1814
1815 /* Note that this is called for all low-level state changes,
1816 * even if they might map to the same high-level
1817 * UnitActiveState! That means that ns == os is an expected
1818 * behavior here. For example: if a mount point is remounted
1819 * this function will be called too! */
1820
1821 m = u->manager;
1822
1823 /* Update timestamps for state changes */
1824 if (m->n_reloading <= 0) {
1825 dual_timestamp ts;
1826
1827 dual_timestamp_get(&ts);
1828
1829 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1830 u->inactive_exit_timestamp = ts;
1831 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1832 u->inactive_enter_timestamp = ts;
1833
1834 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1835 u->active_enter_timestamp = ts;
1836 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1837 u->active_exit_timestamp = ts;
1838 }
1839
1840 /* Keep track of failed units */
1841 (void) manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);
1842
1843 /* Make sure the cgroup is always removed when we become inactive */
1844 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1845 unit_prune_cgroup(u);
1846
1847 /* Note that this doesn't apply to RemainAfterExit services exiting
1848 * successfully, since there's no change of state in that case. Which is
1849 * why it is handled in service_set_state() */
1850 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1851 ExecContext *ec;
1852
1853 ec = unit_get_exec_context(u);
1854 if (ec && exec_context_may_touch_console(ec)) {
1855 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1856 m->n_on_console --;
1857
1858 if (m->n_on_console == 0)
1859 /* unset no_console_output flag, since the console is free */
1860 m->no_console_output = false;
1861 } else
1862 m->n_on_console ++;
1863 }
1864 }
1865
1866 if (u->job) {
1867 unexpected = false;
1868
1869 if (u->job->state == JOB_WAITING)
1870
1871 /* So we reached a different state for this
1872 * job. Let's see if we can run it now if it
1873 * failed previously due to EAGAIN. */
1874 job_add_to_run_queue(u->job);
1875
1876 /* Let's check whether this state change constitutes a
1877 * finished job, or maybe contradicts a running job and
1878 * hence needs to invalidate jobs. */
1879
1880 switch (u->job->type) {
1881
1882 case JOB_START:
1883 case JOB_VERIFY_ACTIVE:
1884
1885 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1886 job_finish_and_invalidate(u->job, JOB_DONE, true);
1887 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1888 unexpected = true;
1889
1890 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1891 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1892 }
1893
1894 break;
1895
1896 case JOB_RELOAD:
1897 case JOB_RELOAD_OR_START:
1898
1899 if (u->job->state == JOB_RUNNING) {
1900 if (ns == UNIT_ACTIVE)
1901 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1902 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1903 unexpected = true;
1904
1905 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1906 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1907 }
1908 }
1909
1910 break;
1911
1912 case JOB_STOP:
1913 case JOB_RESTART:
1914 case JOB_TRY_RESTART:
1915
1916 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1917 job_finish_and_invalidate(u->job, JOB_DONE, true);
1918 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1919 unexpected = true;
1920 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1921 }
1922
1923 break;
1924
1925 default:
1926 assert_not_reached("Job type unknown");
1927 }
1928
1929 } else
1930 unexpected = true;
1931
1932 if (m->n_reloading <= 0) {
1933
1934 /* If this state change happened without being
1935 * requested by a job, then let's retroactively start
1936 * or stop dependencies. We skip that step when
1937 * deserializing, since we don't want to create any
1938 * additional jobs just because something is already
1939 * activated. */
1940
1941 if (unexpected) {
1942 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1943 retroactively_start_dependencies(u);
1944 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1945 retroactively_stop_dependencies(u);
1946 }
1947
1948 /* stop unneeded units regardless if going down was expected or not */
1949 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1950 check_unneeded_dependencies(u);
1951
1952 if (ns != os && ns == UNIT_FAILED) {
1953 log_unit_notice(u, "Unit entered failed state.");
1954 unit_start_on_failure(u);
1955 }
1956 }
1957
1958 /* Some names are special */
1959 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1960
1961 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1962 /* The bus might have just become available,
1963 * hence try to connect to it, if we aren't
1964 * yet connected. */
1965 bus_init(m, true);
1966
1967 if (u->type == UNIT_SERVICE &&
1968 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1969 m->n_reloading <= 0) {
1970 /* Write audit record if we have just finished starting up */
1971 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1972 u->in_audit = true;
1973 }
1974
1975 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1976 manager_send_unit_plymouth(m, u);
1977
1978 } else {
1979
1980 /* We don't care about D-Bus here, since we'll get an
1981 * asynchronous notification for it anyway. */
1982
1983 if (u->type == UNIT_SERVICE &&
1984 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1985 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1986 m->n_reloading <= 0) {
1987
1988 /* Hmm, if there was no start record written
1989 * write it now, so that we always have a nice
1990 * pair */
1991 if (!u->in_audit) {
1992 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1993
1994 if (ns == UNIT_INACTIVE)
1995 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1996 } else
1997 /* Write audit record if we have just finished shutting down */
1998 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1999
2000 u->in_audit = false;
2001 }
2002 }
2003
2004 manager_recheck_journal(m);
2005 unit_trigger_notify(u);
2006
2007 if (u->manager->n_reloading <= 0) {
2008 /* Maybe we finished startup and are now ready for
2009 * being stopped because unneeded? */
2010 unit_check_unneeded(u);
2011
2012 /* Maybe we finished startup, but something we needed
2013 * has vanished? Let's die then. (This happens when
2014 * something BindsTo= to a Type=oneshot unit, as these
2015 * units go directly from starting to inactive,
2016 * without ever entering started.) */
2017 unit_check_binds_to(u);
2018 }
2019
2020 unit_add_to_dbus_queue(u);
2021 unit_add_to_gc_queue(u);
2022 }
2023
2024 int unit_watch_pid(Unit *u, pid_t pid) {
2025 int q, r;
2026
2027 assert(u);
2028 assert(pid >= 1);
2029
2030 /* Watch a specific PID. We only support one or two units
2031 * watching each PID for now, not more. */
2032
2033 r = set_ensure_allocated(&u->pids, NULL);
2034 if (r < 0)
2035 return r;
2036
2037 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
2038 if (r < 0)
2039 return r;
2040
2041 r = hashmap_put(u->manager->watch_pids1, PID_TO_PTR(pid), u);
2042 if (r == -EEXIST) {
2043 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
2044 if (r < 0)
2045 return r;
2046
2047 r = hashmap_put(u->manager->watch_pids2, PID_TO_PTR(pid), u);
2048 }
2049
2050 q = set_put(u->pids, PID_TO_PTR(pid));
2051 if (q < 0)
2052 return q;
2053
2054 return r;
2055 }
2056
2057 void unit_unwatch_pid(Unit *u, pid_t pid) {
2058 assert(u);
2059 assert(pid >= 1);
2060
2061 (void) hashmap_remove_value(u->manager->watch_pids1, PID_TO_PTR(pid), u);
2062 (void) hashmap_remove_value(u->manager->watch_pids2, PID_TO_PTR(pid), u);
2063 (void) set_remove(u->pids, PID_TO_PTR(pid));
2064 }
2065
2066 void unit_unwatch_all_pids(Unit *u) {
2067 assert(u);
2068
2069 while (!set_isempty(u->pids))
2070 unit_unwatch_pid(u, PTR_TO_PID(set_first(u->pids)));
2071
2072 u->pids = set_free(u->pids);
2073 }
2074
2075 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2076 Iterator i;
2077 void *e;
2078
2079 assert(u);
2080
2081 /* Cleans dead PIDs from our list */
2082
2083 SET_FOREACH(e, u->pids, i) {
2084 pid_t pid = PTR_TO_PID(e);
2085
2086 if (pid == except1 || pid == except2)
2087 continue;
2088
2089 if (!pid_is_unwaited(pid))
2090 unit_unwatch_pid(u, pid);
2091 }
2092 }
2093
2094 bool unit_job_is_applicable(Unit *u, JobType j) {
2095 assert(u);
2096 assert(j >= 0 && j < _JOB_TYPE_MAX);
2097
2098 switch (j) {
2099
2100 case JOB_VERIFY_ACTIVE:
2101 case JOB_START:
2102 case JOB_STOP:
2103 case JOB_NOP:
2104 return true;
2105
2106 case JOB_RESTART:
2107 case JOB_TRY_RESTART:
2108 return unit_can_start(u);
2109
2110 case JOB_RELOAD:
2111 return unit_can_reload(u);
2112
2113 case JOB_RELOAD_OR_START:
2114 return unit_can_reload(u) && unit_can_start(u);
2115
2116 default:
2117 assert_not_reached("Invalid job type");
2118 }
2119 }
2120
2121 static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency) {
2122 assert(u);
2123
2124 /* Only warn about some unit types */
2125 if (!IN_SET(dependency, UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY))
2126 return;
2127
2128 if (streq_ptr(u->id, other))
2129 log_unit_warning(u, "Dependency %s=%s dropped", unit_dependency_to_string(dependency), u->id);
2130 else
2131 log_unit_warning(u, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency), strna(other), u->id);
2132 }
2133
2134 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2135
2136 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2137 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2138 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2139 [UNIT_WANTS] = UNIT_WANTED_BY,
2140 [UNIT_REQUISITE] = UNIT_REQUISITE_OF,
2141 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUISITE_OF_OVERRIDABLE,
2142 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2143 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2144 [UNIT_REQUIRED_BY] = UNIT_REQUIRES,
2145 [UNIT_REQUIRED_BY_OVERRIDABLE] = UNIT_REQUIRES_OVERRIDABLE,
2146 [UNIT_REQUISITE_OF] = UNIT_REQUISITE,
2147 [UNIT_REQUISITE_OF_OVERRIDABLE] = UNIT_REQUISITE_OVERRIDABLE,
2148 [UNIT_WANTED_BY] = UNIT_WANTS,
2149 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2150 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2151 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2152 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2153 [UNIT_BEFORE] = UNIT_AFTER,
2154 [UNIT_AFTER] = UNIT_BEFORE,
2155 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2156 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2157 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2158 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2159 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2160 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2161 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2162 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2163 };
2164 int r, q = 0, v = 0, w = 0;
2165 Unit *orig_u = u, *orig_other = other;
2166
2167 assert(u);
2168 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2169 assert(other);
2170
2171 u = unit_follow_merge(u);
2172 other = unit_follow_merge(other);
2173
2174 /* We won't allow dependencies on ourselves. We will not
2175 * consider them an error however. */
2176 if (u == other) {
2177 maybe_warn_about_dependency(orig_u, orig_other->id, d);
2178 return 0;
2179 }
2180
2181 r = set_ensure_allocated(&u->dependencies[d], NULL);
2182 if (r < 0)
2183 return r;
2184
2185 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2186 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2187 if (r < 0)
2188 return r;
2189 }
2190
2191 if (add_reference) {
2192 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2193 if (r < 0)
2194 return r;
2195
2196 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2197 if (r < 0)
2198 return r;
2199 }
2200
2201 q = set_put(u->dependencies[d], other);
2202 if (q < 0)
2203 return q;
2204
2205 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2206 v = set_put(other->dependencies[inverse_table[d]], u);
2207 if (v < 0) {
2208 r = v;
2209 goto fail;
2210 }
2211 }
2212
2213 if (add_reference) {
2214 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2215 if (w < 0) {
2216 r = w;
2217 goto fail;
2218 }
2219
2220 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2221 if (r < 0)
2222 goto fail;
2223 }
2224
2225 unit_add_to_dbus_queue(u);
2226 return 0;
2227
2228 fail:
2229 if (q > 0)
2230 set_remove(u->dependencies[d], other);
2231
2232 if (v > 0)
2233 set_remove(other->dependencies[inverse_table[d]], u);
2234
2235 if (w > 0)
2236 set_remove(u->dependencies[UNIT_REFERENCES], other);
2237
2238 return r;
2239 }
2240
2241 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2242 int r;
2243
2244 assert(u);
2245
2246 r = unit_add_dependency(u, d, other, add_reference);
2247 if (r < 0)
2248 return r;
2249
2250 return unit_add_dependency(u, e, other, add_reference);
2251 }
2252
2253 static int resolve_template(Unit *u, const char *name, const char*path, char **buf, const char **ret) {
2254 int r;
2255
2256 assert(u);
2257 assert(name || path);
2258 assert(buf);
2259 assert(ret);
2260
2261 if (!name)
2262 name = basename(path);
2263
2264 if (!unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
2265 *buf = NULL;
2266 *ret = name;
2267 return 0;
2268 }
2269
2270 if (u->instance)
2271 r = unit_name_replace_instance(name, u->instance, buf);
2272 else {
2273 _cleanup_free_ char *i = NULL;
2274
2275 r = unit_name_to_prefix(u->id, &i);
2276 if (r < 0)
2277 return r;
2278
2279 r = unit_name_replace_instance(name, i, buf);
2280 }
2281 if (r < 0)
2282 return r;
2283
2284 *ret = *buf;
2285 return 0;
2286 }
2287
2288 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2289 _cleanup_free_ char *buf = NULL;
2290 Unit *other;
2291 int r;
2292
2293 assert(u);
2294 assert(name || path);
2295
2296 r = resolve_template(u, name, path, &buf, &name);
2297 if (r < 0)
2298 return r;
2299
2300 r = manager_load_unit(u->manager, name, path, NULL, &other);
2301 if (r < 0)
2302 return r;
2303
2304 return unit_add_dependency(u, d, other, add_reference);
2305 }
2306
2307 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2308 _cleanup_free_ char *buf = NULL;
2309 Unit *other;
2310 int r;
2311
2312 assert(u);
2313 assert(name || path);
2314
2315 r = resolve_template(u, name, path, &buf, &name);
2316 if (r < 0)
2317 return r;
2318
2319 r = manager_load_unit(u->manager, name, path, NULL, &other);
2320 if (r < 0)
2321 return r;
2322
2323 return unit_add_two_dependencies(u, d, e, other, add_reference);
2324 }
2325
2326 int set_unit_path(const char *p) {
2327 /* This is mostly for debug purposes */
2328 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2329 return -errno;
2330
2331 return 0;
2332 }
2333
2334 char *unit_dbus_path(Unit *u) {
2335 assert(u);
2336
2337 if (!u->id)
2338 return NULL;
2339
2340 return unit_dbus_path_from_name(u->id);
2341 }
2342
2343 int unit_set_slice(Unit *u, Unit *slice) {
2344 assert(u);
2345 assert(slice);
2346
2347 /* Sets the unit slice if it has not been set before. Is extra
2348 * careful, to only allow this for units that actually have a
2349 * cgroup context. Also, we don't allow to set this for slices
2350 * (since the parent slice is derived from the name). Make
2351 * sure the unit we set is actually a slice. */
2352
2353 if (!UNIT_HAS_CGROUP_CONTEXT(u))
2354 return -EOPNOTSUPP;
2355
2356 if (u->type == UNIT_SLICE)
2357 return -EINVAL;
2358
2359 if (unit_active_state(u) != UNIT_INACTIVE)
2360 return -EBUSY;
2361
2362 if (slice->type != UNIT_SLICE)
2363 return -EINVAL;
2364
2365 if (unit_has_name(u, SPECIAL_INIT_SCOPE) &&
2366 !unit_has_name(slice, SPECIAL_ROOT_SLICE))
2367 return -EPERM;
2368
2369 if (UNIT_DEREF(u->slice) == slice)
2370 return 0;
2371
2372 if (UNIT_ISSET(u->slice))
2373 return -EBUSY;
2374
2375 unit_ref_set(&u->slice, slice);
2376 return 1;
2377 }
2378
2379 int unit_set_default_slice(Unit *u) {
2380 _cleanup_free_ char *b = NULL;
2381 const char *slice_name;
2382 Unit *slice;
2383 int r;
2384
2385 assert(u);
2386
2387 if (UNIT_ISSET(u->slice))
2388 return 0;
2389
2390 if (u->instance) {
2391 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2392
2393 /* Implicitly place all instantiated units in their
2394 * own per-template slice */
2395
2396 r = unit_name_to_prefix(u->id, &prefix);
2397 if (r < 0)
2398 return r;
2399
2400 /* The prefix is already escaped, but it might include
2401 * "-" which has a special meaning for slice units,
2402 * hence escape it here extra. */
2403 escaped = unit_name_escape(prefix);
2404 if (!escaped)
2405 return -ENOMEM;
2406
2407 if (u->manager->running_as == MANAGER_SYSTEM)
2408 b = strjoin("system-", escaped, ".slice", NULL);
2409 else
2410 b = strappend(escaped, ".slice");
2411 if (!b)
2412 return -ENOMEM;
2413
2414 slice_name = b;
2415 } else
2416 slice_name =
2417 u->manager->running_as == MANAGER_SYSTEM && !unit_has_name(u, SPECIAL_INIT_SCOPE)
2418 ? SPECIAL_SYSTEM_SLICE
2419 : SPECIAL_ROOT_SLICE;
2420
2421 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2422 if (r < 0)
2423 return r;
2424
2425 return unit_set_slice(u, slice);
2426 }
2427
2428 const char *unit_slice_name(Unit *u) {
2429 assert(u);
2430
2431 if (!UNIT_ISSET(u->slice))
2432 return NULL;
2433
2434 return UNIT_DEREF(u->slice)->id;
2435 }
2436
2437 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2438 _cleanup_free_ char *t = NULL;
2439 int r;
2440
2441 assert(u);
2442 assert(type);
2443 assert(_found);
2444
2445 r = unit_name_change_suffix(u->id, type, &t);
2446 if (r < 0)
2447 return r;
2448 if (unit_has_name(u, t))
2449 return -EINVAL;
2450
2451 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2452 assert(r < 0 || *_found != u);
2453 return r;
2454 }
2455
2456 static int signal_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2457 const char *name, *old_owner, *new_owner;
2458 Unit *u = userdata;
2459 int r;
2460
2461 assert(message);
2462 assert(u);
2463
2464 r = sd_bus_message_read(message, "sss", &name, &old_owner, &new_owner);
2465 if (r < 0) {
2466 bus_log_parse_error(r);
2467 return 0;
2468 }
2469
2470 if (UNIT_VTABLE(u)->bus_name_owner_change)
2471 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2472
2473 return 0;
2474 }
2475
2476 int unit_install_bus_match(Unit *u, sd_bus *bus, const char *name) {
2477 const char *match;
2478
2479 assert(u);
2480 assert(bus);
2481 assert(name);
2482
2483 if (u->match_bus_slot)
2484 return -EBUSY;
2485
2486 match = strjoina("type='signal',"
2487 "sender='org.freedesktop.DBus',"
2488 "path='/org/freedesktop/DBus',"
2489 "interface='org.freedesktop.DBus',"
2490 "member='NameOwnerChanged',"
2491 "arg0='", name, "'",
2492 NULL);
2493
2494 return sd_bus_add_match(bus, &u->match_bus_slot, match, signal_name_owner_changed, u);
2495 }
2496
2497 int unit_watch_bus_name(Unit *u, const char *name) {
2498 int r;
2499
2500 assert(u);
2501 assert(name);
2502
2503 /* Watch a specific name on the bus. We only support one unit
2504 * watching each name for now. */
2505
2506 if (u->manager->api_bus) {
2507 /* If the bus is already available, install the match directly.
2508 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2509 r = unit_install_bus_match(u, u->manager->api_bus, name);
2510 if (r < 0)
2511 return log_warning_errno(r, "Failed to subscribe to NameOwnerChanged signal: %m");
2512 }
2513
2514 r = hashmap_put(u->manager->watch_bus, name, u);
2515 if (r < 0) {
2516 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
2517 return log_warning_errno(r, "Failed to put bus name to hashmap: %m");
2518 }
2519
2520 return 0;
2521 }
2522
2523 void unit_unwatch_bus_name(Unit *u, const char *name) {
2524 assert(u);
2525 assert(name);
2526
2527 hashmap_remove_value(u->manager->watch_bus, name, u);
2528 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
2529 }
2530
2531 bool unit_can_serialize(Unit *u) {
2532 assert(u);
2533
2534 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2535 }
2536
2537 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2538 int r;
2539
2540 assert(u);
2541 assert(f);
2542 assert(fds);
2543
2544 if (unit_can_serialize(u)) {
2545 ExecRuntime *rt;
2546
2547 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2548 if (r < 0)
2549 return r;
2550
2551 rt = unit_get_exec_runtime(u);
2552 if (rt) {
2553 r = exec_runtime_serialize(u, rt, f, fds);
2554 if (r < 0)
2555 return r;
2556 }
2557 }
2558
2559 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2560 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2561 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2562 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2563 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2564 dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2565
2566 if (dual_timestamp_is_set(&u->condition_timestamp))
2567 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2568
2569 if (dual_timestamp_is_set(&u->assert_timestamp))
2570 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2571
2572 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2573 unit_serialize_item_format(u, f, "cpuacct-usage-base", "%" PRIu64, u->cpuacct_usage_base);
2574
2575 if (u->cgroup_path)
2576 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2577 unit_serialize_item(u, f, "cgroup-realized", yes_no(u->cgroup_realized));
2578
2579 if (u->cgroup_netclass_id)
2580 unit_serialize_item_format(u, f, "netclass-id", "%" PRIu32, u->cgroup_netclass_id);
2581
2582 if (serialize_jobs) {
2583 if (u->job) {
2584 fprintf(f, "job\n");
2585 job_serialize(u->job, f, fds);
2586 }
2587
2588 if (u->nop_job) {
2589 fprintf(f, "job\n");
2590 job_serialize(u->nop_job, f, fds);
2591 }
2592 }
2593
2594 /* End marker */
2595 fputc('\n', f);
2596 return 0;
2597 }
2598
2599 int unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2600 assert(u);
2601 assert(f);
2602 assert(key);
2603
2604 if (!value)
2605 return 0;
2606
2607 fputs(key, f);
2608 fputc('=', f);
2609 fputs(value, f);
2610 fputc('\n', f);
2611
2612 return 1;
2613 }
2614
2615 int unit_serialize_item_escaped(Unit *u, FILE *f, const char *key, const char *value) {
2616 _cleanup_free_ char *c = NULL;
2617
2618 assert(u);
2619 assert(f);
2620 assert(key);
2621
2622 if (!value)
2623 return 0;
2624
2625 c = cescape(value);
2626 if (!c)
2627 return -ENOMEM;
2628
2629 fputs(key, f);
2630 fputc('=', f);
2631 fputs(c, f);
2632 fputc('\n', f);
2633
2634 return 1;
2635 }
2636
2637 int unit_serialize_item_fd(Unit *u, FILE *f, FDSet *fds, const char *key, int fd) {
2638 int copy;
2639
2640 assert(u);
2641 assert(f);
2642 assert(key);
2643
2644 if (fd < 0)
2645 return 0;
2646
2647 copy = fdset_put_dup(fds, fd);
2648 if (copy < 0)
2649 return copy;
2650
2651 fprintf(f, "%s=%i\n", key, copy);
2652 return 1;
2653 }
2654
2655 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2656 va_list ap;
2657
2658 assert(u);
2659 assert(f);
2660 assert(key);
2661 assert(format);
2662
2663 fputs(key, f);
2664 fputc('=', f);
2665
2666 va_start(ap, format);
2667 vfprintf(f, format, ap);
2668 va_end(ap);
2669
2670 fputc('\n', f);
2671 }
2672
2673 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2674 ExecRuntime **rt = NULL;
2675 size_t offset;
2676 int r;
2677
2678 assert(u);
2679 assert(f);
2680 assert(fds);
2681
2682 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2683 if (offset > 0)
2684 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2685
2686 for (;;) {
2687 char line[LINE_MAX], *l, *v;
2688 size_t k;
2689
2690 if (!fgets(line, sizeof(line), f)) {
2691 if (feof(f))
2692 return 0;
2693 return -errno;
2694 }
2695
2696 char_array_0(line);
2697 l = strstrip(line);
2698
2699 /* End marker */
2700 if (isempty(l))
2701 return 0;
2702
2703 k = strcspn(l, "=");
2704
2705 if (l[k] == '=') {
2706 l[k] = 0;
2707 v = l+k+1;
2708 } else
2709 v = l+k;
2710
2711 if (streq(l, "job")) {
2712 if (v[0] == '\0') {
2713 /* new-style serialized job */
2714 Job *j;
2715
2716 j = job_new_raw(u);
2717 if (!j)
2718 return log_oom();
2719
2720 r = job_deserialize(j, f, fds);
2721 if (r < 0) {
2722 job_free(j);
2723 return r;
2724 }
2725
2726 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2727 if (r < 0) {
2728 job_free(j);
2729 return r;
2730 }
2731
2732 r = job_install_deserialized(j);
2733 if (r < 0) {
2734 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2735 job_free(j);
2736 return r;
2737 }
2738 } else /* legacy for pre-44 */
2739 log_unit_warning(u, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v);
2740 continue;
2741 } else if (streq(l, "inactive-exit-timestamp")) {
2742 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2743 continue;
2744 } else if (streq(l, "active-enter-timestamp")) {
2745 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2746 continue;
2747 } else if (streq(l, "active-exit-timestamp")) {
2748 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2749 continue;
2750 } else if (streq(l, "inactive-enter-timestamp")) {
2751 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2752 continue;
2753 } else if (streq(l, "condition-timestamp")) {
2754 dual_timestamp_deserialize(v, &u->condition_timestamp);
2755 continue;
2756 } else if (streq(l, "assert-timestamp")) {
2757 dual_timestamp_deserialize(v, &u->assert_timestamp);
2758 continue;
2759 } else if (streq(l, "condition-result")) {
2760
2761 r = parse_boolean(v);
2762 if (r < 0)
2763 log_unit_debug(u, "Failed to parse condition result value %s, ignoring.", v);
2764 else
2765 u->condition_result = r;
2766
2767 continue;
2768
2769 } else if (streq(l, "assert-result")) {
2770
2771 r = parse_boolean(v);
2772 if (r < 0)
2773 log_unit_debug(u, "Failed to parse assert result value %s, ignoring.", v);
2774 else
2775 u->assert_result = r;
2776
2777 continue;
2778
2779 } else if (streq(l, "transient")) {
2780
2781 r = parse_boolean(v);
2782 if (r < 0)
2783 log_unit_debug(u, "Failed to parse transient bool %s, ignoring.", v);
2784 else
2785 u->transient = r;
2786
2787 continue;
2788
2789 } else if (streq(l, "cpuacct-usage-base")) {
2790
2791 r = safe_atou64(v, &u->cpuacct_usage_base);
2792 if (r < 0)
2793 log_unit_debug(u, "Failed to parse CPU usage %s, ignoring.", v);
2794
2795 continue;
2796
2797 } else if (streq(l, "cgroup")) {
2798
2799 r = unit_set_cgroup_path(u, v);
2800 if (r < 0)
2801 log_unit_debug_errno(u, r, "Failed to set cgroup path %s, ignoring: %m", v);
2802
2803 (void) unit_watch_cgroup(u);
2804
2805 continue;
2806 } else if (streq(l, "cgroup-realized")) {
2807 int b;
2808
2809 b = parse_boolean(v);
2810 if (b < 0)
2811 log_unit_debug(u, "Failed to parse cgroup-realized bool %s, ignoring.", v);
2812 else
2813 u->cgroup_realized = b;
2814
2815 continue;
2816 } else if (streq(l, "netclass-id")) {
2817 r = safe_atou32(v, &u->cgroup_netclass_id);
2818 if (r < 0)
2819 log_unit_debug(u, "Failed to parse netclass ID %s, ignoring.", v);
2820 else {
2821 r = unit_add_to_netclass_cgroup(u);
2822 if (r < 0)
2823 log_unit_debug_errno(u, r, "Failed to add unit to netclass cgroup, ignoring: %m");
2824 }
2825
2826 continue;
2827 }
2828
2829 if (unit_can_serialize(u)) {
2830 if (rt) {
2831 r = exec_runtime_deserialize_item(u, rt, l, v, fds);
2832 if (r < 0) {
2833 log_unit_warning(u, "Failed to deserialize runtime parameter '%s', ignoring.", l);
2834 continue;
2835 }
2836
2837 /* Returns positive if key was handled by the call */
2838 if (r > 0)
2839 continue;
2840 }
2841
2842 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2843 if (r < 0)
2844 log_unit_warning(u, "Failed to deserialize unit parameter '%s', ignoring.", l);
2845 }
2846 }
2847 }
2848
2849 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2850 Unit *device;
2851 _cleanup_free_ char *e = NULL;
2852 int r;
2853
2854 assert(u);
2855
2856 /* Adds in links to the device node that this unit is based on */
2857 if (isempty(what))
2858 return 0;
2859
2860 if (!is_device_path(what))
2861 return 0;
2862
2863 /* When device units aren't supported (such as in a
2864 * container), don't create dependencies on them. */
2865 if (!unit_type_supported(UNIT_DEVICE))
2866 return 0;
2867
2868 r = unit_name_from_path(what, ".device", &e);
2869 if (r < 0)
2870 return r;
2871
2872 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2873 if (r < 0)
2874 return r;
2875
2876 r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == MANAGER_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2877 if (r < 0)
2878 return r;
2879
2880 if (wants) {
2881 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2882 if (r < 0)
2883 return r;
2884 }
2885
2886 return 0;
2887 }
2888
2889 int unit_coldplug(Unit *u) {
2890 int r;
2891
2892 assert(u);
2893
2894 /* Make sure we don't enter a loop, when coldplugging
2895 * recursively. */
2896 if (u->coldplugged)
2897 return 0;
2898
2899 u->coldplugged = true;
2900
2901 if (UNIT_VTABLE(u)->coldplug) {
2902 r = UNIT_VTABLE(u)->coldplug(u);
2903 if (r < 0)
2904 return r;
2905 }
2906
2907 if (u->job) {
2908 r = job_coldplug(u->job);
2909 if (r < 0)
2910 return r;
2911 }
2912
2913 return 0;
2914 }
2915
2916 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2917 DISABLE_WARNING_FORMAT_NONLITERAL;
2918 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2919 status, unit_status_msg_format, unit_description(u));
2920 REENABLE_WARNING;
2921 }
2922
2923 bool unit_need_daemon_reload(Unit *u) {
2924 _cleanup_strv_free_ char **t = NULL;
2925 char **path;
2926 struct stat st;
2927 unsigned loaded_cnt, current_cnt;
2928
2929 assert(u);
2930
2931 if (u->fragment_path) {
2932 zero(st);
2933 if (stat(u->fragment_path, &st) < 0)
2934 /* What, cannot access this anymore? */
2935 return true;
2936
2937 if (u->fragment_mtime > 0 &&
2938 timespec_load(&st.st_mtim) != u->fragment_mtime)
2939 return true;
2940 }
2941
2942 if (u->source_path) {
2943 zero(st);
2944 if (stat(u->source_path, &st) < 0)
2945 return true;
2946
2947 if (u->source_mtime > 0 &&
2948 timespec_load(&st.st_mtim) != u->source_mtime)
2949 return true;
2950 }
2951
2952 (void) unit_find_dropin_paths(u, &t);
2953 loaded_cnt = strv_length(t);
2954 current_cnt = strv_length(u->dropin_paths);
2955
2956 if (loaded_cnt == current_cnt) {
2957 if (loaded_cnt == 0)
2958 return false;
2959
2960 if (strv_overlap(u->dropin_paths, t)) {
2961 STRV_FOREACH(path, u->dropin_paths) {
2962 zero(st);
2963 if (stat(*path, &st) < 0)
2964 return true;
2965
2966 if (u->dropin_mtime > 0 &&
2967 timespec_load(&st.st_mtim) > u->dropin_mtime)
2968 return true;
2969 }
2970
2971 return false;
2972 } else
2973 return true;
2974 } else
2975 return true;
2976 }
2977
2978 void unit_reset_failed(Unit *u) {
2979 assert(u);
2980
2981 if (UNIT_VTABLE(u)->reset_failed)
2982 UNIT_VTABLE(u)->reset_failed(u);
2983 }
2984
2985 Unit *unit_following(Unit *u) {
2986 assert(u);
2987
2988 if (UNIT_VTABLE(u)->following)
2989 return UNIT_VTABLE(u)->following(u);
2990
2991 return NULL;
2992 }
2993
2994 bool unit_stop_pending(Unit *u) {
2995 assert(u);
2996
2997 /* This call does check the current state of the unit. It's
2998 * hence useful to be called from state change calls of the
2999 * unit itself, where the state isn't updated yet. This is
3000 * different from unit_inactive_or_pending() which checks both
3001 * the current state and for a queued job. */
3002
3003 return u->job && u->job->type == JOB_STOP;
3004 }
3005
3006 bool unit_inactive_or_pending(Unit *u) {
3007 assert(u);
3008
3009 /* Returns true if the unit is inactive or going down */
3010
3011 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
3012 return true;
3013
3014 if (unit_stop_pending(u))
3015 return true;
3016
3017 return false;
3018 }
3019
3020 bool unit_active_or_pending(Unit *u) {
3021 assert(u);
3022
3023 /* Returns true if the unit is active or going up */
3024
3025 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
3026 return true;
3027
3028 if (u->job &&
3029 (u->job->type == JOB_START ||
3030 u->job->type == JOB_RELOAD_OR_START ||
3031 u->job->type == JOB_RESTART))
3032 return true;
3033
3034 return false;
3035 }
3036
3037 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
3038 assert(u);
3039 assert(w >= 0 && w < _KILL_WHO_MAX);
3040 assert(signo > 0);
3041 assert(signo < _NSIG);
3042
3043 if (!UNIT_VTABLE(u)->kill)
3044 return -EOPNOTSUPP;
3045
3046 return UNIT_VTABLE(u)->kill(u, w, signo, error);
3047 }
3048
3049 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
3050 Set *pid_set;
3051 int r;
3052
3053 pid_set = set_new(NULL);
3054 if (!pid_set)
3055 return NULL;
3056
3057 /* Exclude the main/control pids from being killed via the cgroup */
3058 if (main_pid > 0) {
3059 r = set_put(pid_set, PID_TO_PTR(main_pid));
3060 if (r < 0)
3061 goto fail;
3062 }
3063
3064 if (control_pid > 0) {
3065 r = set_put(pid_set, PID_TO_PTR(control_pid));
3066 if (r < 0)
3067 goto fail;
3068 }
3069
3070 return pid_set;
3071
3072 fail:
3073 set_free(pid_set);
3074 return NULL;
3075 }
3076
3077 int unit_kill_common(
3078 Unit *u,
3079 KillWho who,
3080 int signo,
3081 pid_t main_pid,
3082 pid_t control_pid,
3083 sd_bus_error *error) {
3084
3085 int r = 0;
3086 bool killed = false;
3087
3088 if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL)) {
3089 if (main_pid < 0)
3090 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3091 else if (main_pid == 0)
3092 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3093 }
3094
3095 if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL)) {
3096 if (control_pid < 0)
3097 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3098 else if (control_pid == 0)
3099 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3100 }
3101
3102 if (IN_SET(who, KILL_CONTROL, KILL_CONTROL_FAIL, KILL_ALL, KILL_ALL_FAIL))
3103 if (control_pid > 0) {
3104 if (kill(control_pid, signo) < 0)
3105 r = -errno;
3106 else
3107 killed = true;
3108 }
3109
3110 if (IN_SET(who, KILL_MAIN, KILL_MAIN_FAIL, KILL_ALL, KILL_ALL_FAIL))
3111 if (main_pid > 0) {
3112 if (kill(main_pid, signo) < 0)
3113 r = -errno;
3114 else
3115 killed = true;
3116 }
3117
3118 if (IN_SET(who, KILL_ALL, KILL_ALL_FAIL) && u->cgroup_path) {
3119 _cleanup_set_free_ Set *pid_set = NULL;
3120 int q;
3121
3122 /* Exclude the main/control pids from being killed via the cgroup */
3123 pid_set = unit_pid_set(main_pid, control_pid);
3124 if (!pid_set)
3125 return -ENOMEM;
3126
3127 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, false, false, pid_set);
3128 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3129 r = q;
3130 else
3131 killed = true;
3132 }
3133
3134 if (r == 0 && !killed && IN_SET(who, KILL_ALL_FAIL, KILL_CONTROL_FAIL, KILL_ALL_FAIL))
3135 return -ESRCH;
3136
3137 return r;
3138 }
3139
3140 int unit_following_set(Unit *u, Set **s) {
3141 assert(u);
3142 assert(s);
3143
3144 if (UNIT_VTABLE(u)->following_set)
3145 return UNIT_VTABLE(u)->following_set(u, s);
3146
3147 *s = NULL;
3148 return 0;
3149 }
3150
3151 UnitFileState unit_get_unit_file_state(Unit *u) {
3152 assert(u);
3153
3154 if (u->unit_file_state < 0 && u->fragment_path)
3155 u->unit_file_state = unit_file_get_state(
3156 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3157 NULL, basename(u->fragment_path));
3158
3159 return u->unit_file_state;
3160 }
3161
3162 int unit_get_unit_file_preset(Unit *u) {
3163 assert(u);
3164
3165 if (u->unit_file_preset < 0 && u->fragment_path)
3166 u->unit_file_preset = unit_file_query_preset(
3167 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3168 NULL, basename(u->fragment_path));
3169
3170 return u->unit_file_preset;
3171 }
3172
3173 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3174 assert(ref);
3175 assert(u);
3176
3177 if (ref->unit)
3178 unit_ref_unset(ref);
3179
3180 ref->unit = u;
3181 LIST_PREPEND(refs, u->refs, ref);
3182 return u;
3183 }
3184
3185 void unit_ref_unset(UnitRef *ref) {
3186 assert(ref);
3187
3188 if (!ref->unit)
3189 return;
3190
3191 LIST_REMOVE(refs, ref->unit->refs, ref);
3192 ref->unit = NULL;
3193 }
3194
3195 int unit_patch_contexts(Unit *u) {
3196 CGroupContext *cc;
3197 ExecContext *ec;
3198 unsigned i;
3199 int r;
3200
3201 assert(u);
3202
3203 /* Patch in the manager defaults into the exec and cgroup
3204 * contexts, _after_ the rest of the settings have been
3205 * initialized */
3206
3207 ec = unit_get_exec_context(u);
3208 if (ec) {
3209 /* This only copies in the ones that need memory */
3210 for (i = 0; i < _RLIMIT_MAX; i++)
3211 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3212 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3213 if (!ec->rlimit[i])
3214 return -ENOMEM;
3215 }
3216
3217 if (u->manager->running_as == MANAGER_USER &&
3218 !ec->working_directory) {
3219
3220 r = get_home_dir(&ec->working_directory);
3221 if (r < 0)
3222 return r;
3223
3224 /* Allow user services to run, even if the
3225 * home directory is missing */
3226 ec->working_directory_missing_ok = true;
3227 }
3228
3229 if (u->manager->running_as == MANAGER_USER &&
3230 (ec->syscall_whitelist ||
3231 !set_isempty(ec->syscall_filter) ||
3232 !set_isempty(ec->syscall_archs) ||
3233 ec->address_families_whitelist ||
3234 !set_isempty(ec->address_families)))
3235 ec->no_new_privileges = true;
3236
3237 if (ec->private_devices)
3238 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3239 }
3240
3241 cc = unit_get_cgroup_context(u);
3242 if (cc) {
3243
3244 if (ec &&
3245 ec->private_devices &&
3246 cc->device_policy == CGROUP_AUTO)
3247 cc->device_policy = CGROUP_CLOSED;
3248 }
3249
3250 return 0;
3251 }
3252
3253 ExecContext *unit_get_exec_context(Unit *u) {
3254 size_t offset;
3255 assert(u);
3256
3257 if (u->type < 0)
3258 return NULL;
3259
3260 offset = UNIT_VTABLE(u)->exec_context_offset;
3261 if (offset <= 0)
3262 return NULL;
3263
3264 return (ExecContext*) ((uint8_t*) u + offset);
3265 }
3266
3267 KillContext *unit_get_kill_context(Unit *u) {
3268 size_t offset;
3269 assert(u);
3270
3271 if (u->type < 0)
3272 return NULL;
3273
3274 offset = UNIT_VTABLE(u)->kill_context_offset;
3275 if (offset <= 0)
3276 return NULL;
3277
3278 return (KillContext*) ((uint8_t*) u + offset);
3279 }
3280
3281 CGroupContext *unit_get_cgroup_context(Unit *u) {
3282 size_t offset;
3283
3284 if (u->type < 0)
3285 return NULL;
3286
3287 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3288 if (offset <= 0)
3289 return NULL;
3290
3291 return (CGroupContext*) ((uint8_t*) u + offset);
3292 }
3293
3294 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3295 size_t offset;
3296
3297 if (u->type < 0)
3298 return NULL;
3299
3300 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3301 if (offset <= 0)
3302 return NULL;
3303
3304 return *(ExecRuntime**) ((uint8_t*) u + offset);
3305 }
3306
3307 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3308 assert(u);
3309
3310 if (u->manager->running_as == MANAGER_USER) {
3311 int r;
3312
3313 if (mode == UNIT_PERSISTENT && !transient)
3314 r = user_config_home(dir);
3315 else
3316 r = user_runtime_dir(dir);
3317 if (r == 0)
3318 return -ENOENT;
3319
3320 return r;
3321 }
3322
3323 if (mode == UNIT_PERSISTENT && !transient)
3324 *dir = strdup("/etc/systemd/system");
3325 else
3326 *dir = strdup("/run/systemd/system");
3327 if (!*dir)
3328 return -ENOMEM;
3329
3330 return 0;
3331 }
3332
3333 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3334
3335 _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3336 int r;
3337
3338 assert(u);
3339
3340 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3341 return 0;
3342
3343 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3344 if (r < 0)
3345 return r;
3346
3347 r = write_drop_in(dir, u->id, 50, name, data);
3348 if (r < 0)
3349 return r;
3350
3351 r = drop_in_file(dir, u->id, 50, name, &p, &q);
3352 if (r < 0)
3353 return r;
3354
3355 r = strv_extend(&u->dropin_paths, q);
3356 if (r < 0)
3357 return r;
3358
3359 strv_sort(u->dropin_paths);
3360 strv_uniq(u->dropin_paths);
3361
3362 u->dropin_mtime = now(CLOCK_REALTIME);
3363
3364 return 0;
3365 }
3366
3367 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3368 _cleanup_free_ char *p = NULL;
3369 va_list ap;
3370 int r;
3371
3372 assert(u);
3373 assert(name);
3374 assert(format);
3375
3376 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3377 return 0;
3378
3379 va_start(ap, format);
3380 r = vasprintf(&p, format, ap);
3381 va_end(ap);
3382
3383 if (r < 0)
3384 return -ENOMEM;
3385
3386 return unit_write_drop_in(u, mode, name, p);
3387 }
3388
3389 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3390 _cleanup_free_ char *ndata = NULL;
3391
3392 assert(u);
3393 assert(name);
3394 assert(data);
3395
3396 if (!UNIT_VTABLE(u)->private_section)
3397 return -EINVAL;
3398
3399 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3400 return 0;
3401
3402 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3403 if (!ndata)
3404 return -ENOMEM;
3405
3406 return unit_write_drop_in(u, mode, name, ndata);
3407 }
3408
3409 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3410 _cleanup_free_ char *p = NULL;
3411 va_list ap;
3412 int r;
3413
3414 assert(u);
3415 assert(name);
3416 assert(format);
3417
3418 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3419 return 0;
3420
3421 va_start(ap, format);
3422 r = vasprintf(&p, format, ap);
3423 va_end(ap);
3424
3425 if (r < 0)
3426 return -ENOMEM;
3427
3428 return unit_write_drop_in_private(u, mode, name, p);
3429 }
3430
3431 int unit_make_transient(Unit *u) {
3432 assert(u);
3433
3434 if (!UNIT_VTABLE(u)->can_transient)
3435 return -EOPNOTSUPP;
3436
3437 u->load_state = UNIT_STUB;
3438 u->load_error = 0;
3439 u->transient = true;
3440 u->fragment_path = mfree(u->fragment_path);
3441
3442 return 0;
3443 }
3444
3445 int unit_kill_context(
3446 Unit *u,
3447 KillContext *c,
3448 KillOperation k,
3449 pid_t main_pid,
3450 pid_t control_pid,
3451 bool main_pid_alien) {
3452
3453 bool wait_for_exit = false;
3454 int sig, r;
3455
3456 assert(u);
3457 assert(c);
3458
3459 if (c->kill_mode == KILL_NONE)
3460 return 0;
3461
3462 switch (k) {
3463 case KILL_KILL:
3464 sig = SIGKILL;
3465 break;
3466 case KILL_ABORT:
3467 sig = SIGABRT;
3468 break;
3469 case KILL_TERMINATE:
3470 sig = c->kill_signal;
3471 break;
3472 default:
3473 assert_not_reached("KillOperation unknown");
3474 }
3475
3476 if (main_pid > 0) {
3477 r = kill_and_sigcont(main_pid, sig);
3478
3479 if (r < 0 && r != -ESRCH) {
3480 _cleanup_free_ char *comm = NULL;
3481 get_process_comm(main_pid, &comm);
3482
3483 log_unit_warning_errno(u, r, "Failed to kill main process " PID_FMT " (%s), ignoring: %m", main_pid, strna(comm));
3484 } else {
3485 if (!main_pid_alien)
3486 wait_for_exit = true;
3487
3488 if (c->send_sighup && k == KILL_TERMINATE)
3489 (void) kill(main_pid, SIGHUP);
3490 }
3491 }
3492
3493 if (control_pid > 0) {
3494 r = kill_and_sigcont(control_pid, sig);
3495
3496 if (r < 0 && r != -ESRCH) {
3497 _cleanup_free_ char *comm = NULL;
3498 get_process_comm(control_pid, &comm);
3499
3500 log_unit_warning_errno(u, r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m", control_pid, strna(comm));
3501 } else {
3502 wait_for_exit = true;
3503
3504 if (c->send_sighup && k == KILL_TERMINATE)
3505 (void) kill(control_pid, SIGHUP);
3506 }
3507 }
3508
3509 if (u->cgroup_path &&
3510 (c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL))) {
3511 _cleanup_set_free_ Set *pid_set = NULL;
3512
3513 /* Exclude the main/control pids from being killed via the cgroup */
3514 pid_set = unit_pid_set(main_pid, control_pid);
3515 if (!pid_set)
3516 return -ENOMEM;
3517
3518 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, k != KILL_TERMINATE, false, pid_set);
3519 if (r < 0) {
3520 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3521 log_unit_warning_errno(u, r, "Failed to kill control group %s, ignoring: %m", u->cgroup_path);
3522
3523 } else if (r > 0) {
3524
3525 /* FIXME: For now, on the legacy hierarchy, we
3526 * will not wait for the cgroup members to die
3527 * if we are running in a container or if this
3528 * is a delegation unit, simply because cgroup
3529 * notification is unreliable in these
3530 * cases. It doesn't work at all in
3531 * containers, and outside of containers it
3532 * can be confused easily by left-over
3533 * directories in the cgroup -- which however
3534 * should not exist in non-delegated units. On
3535 * the unified hierarchy that's different,
3536 * there we get proper events. Hence rely on
3537 * them.*/
3538
3539 if (cg_unified() > 0 ||
3540 (detect_container() == 0 && !unit_cgroup_delegate(u)))
3541 wait_for_exit = true;
3542
3543 if (c->send_sighup && k != KILL_KILL) {
3544 set_free(pid_set);
3545
3546 pid_set = unit_pid_set(main_pid, control_pid);
3547 if (!pid_set)
3548 return -ENOMEM;
3549
3550 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3551 }
3552 }
3553 }
3554
3555 return wait_for_exit;
3556 }
3557
3558 int unit_require_mounts_for(Unit *u, const char *path) {
3559 char prefix[strlen(path) + 1], *p;
3560 int r;
3561
3562 assert(u);
3563 assert(path);
3564
3565 /* Registers a unit for requiring a certain path and all its
3566 * prefixes. We keep a simple array of these paths in the
3567 * unit, since its usually short. However, we build a prefix
3568 * table for all possible prefixes so that new appearing mount
3569 * units can easily determine which units to make themselves a
3570 * dependency of. */
3571
3572 if (!path_is_absolute(path))
3573 return -EINVAL;
3574
3575 p = strdup(path);
3576 if (!p)
3577 return -ENOMEM;
3578
3579 path_kill_slashes(p);
3580
3581 if (!path_is_safe(p)) {
3582 free(p);
3583 return -EPERM;
3584 }
3585
3586 if (strv_contains(u->requires_mounts_for, p)) {
3587 free(p);
3588 return 0;
3589 }
3590
3591 r = strv_consume(&u->requires_mounts_for, p);
3592 if (r < 0)
3593 return r;
3594
3595 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3596 Set *x;
3597
3598 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3599 if (!x) {
3600 char *q;
3601
3602 r = hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for, &string_hash_ops);
3603 if (r < 0)
3604 return r;
3605
3606 q = strdup(prefix);
3607 if (!q)
3608 return -ENOMEM;
3609
3610 x = set_new(NULL);
3611 if (!x) {
3612 free(q);
3613 return -ENOMEM;
3614 }
3615
3616 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3617 if (r < 0) {
3618 free(q);
3619 set_free(x);
3620 return r;
3621 }
3622 }
3623
3624 r = set_put(x, u);
3625 if (r < 0)
3626 return r;
3627 }
3628
3629 return 0;
3630 }
3631
3632 int unit_setup_exec_runtime(Unit *u) {
3633 ExecRuntime **rt;
3634 size_t offset;
3635 Iterator i;
3636 Unit *other;
3637
3638 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3639 assert(offset > 0);
3640
3641 /* Check if there already is an ExecRuntime for this unit? */
3642 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3643 if (*rt)
3644 return 0;
3645
3646 /* Try to get it from somebody else */
3647 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3648
3649 *rt = unit_get_exec_runtime(other);
3650 if (*rt) {
3651 exec_runtime_ref(*rt);
3652 return 0;
3653 }
3654 }
3655
3656 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3657 }
3658
3659 bool unit_type_supported(UnitType t) {
3660 if (_unlikely_(t < 0))
3661 return false;
3662 if (_unlikely_(t >= _UNIT_TYPE_MAX))
3663 return false;
3664
3665 if (!unit_vtable[t]->supported)
3666 return true;
3667
3668 return unit_vtable[t]->supported();
3669 }
3670
3671 void unit_warn_if_dir_nonempty(Unit *u, const char* where) {
3672 int r;
3673
3674 assert(u);
3675 assert(where);
3676
3677 r = dir_is_empty(where);
3678 if (r > 0)
3679 return;
3680 if (r < 0) {
3681 log_unit_warning_errno(u, r, "Failed to check directory %s: %m", where);
3682 return;
3683 }
3684
3685 log_struct(LOG_NOTICE,
3686 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
3687 LOG_UNIT_ID(u),
3688 LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),
3689 "WHERE=%s", where,
3690 NULL);
3691 }
3692
3693 int unit_fail_if_symlink(Unit *u, const char* where) {
3694 int r;
3695
3696 assert(u);
3697 assert(where);
3698
3699 r = is_symlink(where);
3700 if (r < 0) {
3701 log_unit_debug_errno(u, r, "Failed to check symlink %s, ignoring: %m", where);
3702 return 0;
3703 }
3704 if (r == 0)
3705 return 0;
3706
3707 log_struct(LOG_ERR,
3708 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
3709 LOG_UNIT_ID(u),
3710 LOG_UNIT_MESSAGE(u, "Mount on symlink %s not allowed.", where),
3711 "WHERE=%s", where,
3712 NULL);
3713
3714 return -ELOOP;
3715 }
Unnamed repository; edit this file 'description' to name the repository.