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