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