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