]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/unit.c
projects / thirdparty / systemd.git / blob
? search:


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