]> 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
core: unified cgroup hierarchy support
[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 if (u->load_state != UNIT_LOADED)
1420 return -EINVAL;
1421
1422 /* If this is already started, then this will succeed. Note
1423 * that this will even succeed if this unit is not startable
1424 * by the user. This is relied on to detect when we need to
1425 * wait for units and when waiting is finished. */
1426 state = unit_active_state(u);
1427 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1428 return -EALREADY;
1429
1430 /* If the conditions failed, don't do anything at all. If we
1431 * already are activating this call might still be useful to
1432 * speed up activation in case there is some hold-off time,
1433 * but we don't want to recheck the condition in that case. */
1434 if (state != UNIT_ACTIVATING &&
1435 !unit_condition_test(u)) {
1436 log_unit_debug(u, "Starting requested but condition failed. Not starting unit.");
1437 return -EALREADY;
1438 }
1439
1440 /* If the asserts failed, fail the entire job */
1441 if (state != UNIT_ACTIVATING &&
1442 !unit_assert_test(u)) {
1443 log_unit_notice(u, "Starting requested but asserts failed.");
1444 return -EPROTO;
1445 }
1446
1447 /* Forward to the main object, if we aren't it. */
1448 following = unit_following(u);
1449 if (following) {
1450 log_unit_debug(u, "Redirecting start request from %s to %s.", u->id, following->id);
1451 return unit_start(following);
1452 }
1453
1454 if (!unit_supported(u))
1455 return -EOPNOTSUPP;
1456
1457 /* If it is stopped, but we cannot start it, then fail */
1458 if (!UNIT_VTABLE(u)->start)
1459 return -EBADR;
1460
1461 /* We don't suppress calls to ->start() here when we are
1462 * already starting, to allow this request to be used as a
1463 * "hurry up" call, for example when the unit is in some "auto
1464 * restart" state where it waits for a holdoff timer to elapse
1465 * before it will start again. */
1466
1467 unit_add_to_dbus_queue(u);
1468
1469 return UNIT_VTABLE(u)->start(u);
1470 }
1471
1472 bool unit_can_start(Unit *u) {
1473 assert(u);
1474
1475 return !!UNIT_VTABLE(u)->start;
1476 }
1477
1478 bool unit_can_isolate(Unit *u) {
1479 assert(u);
1480
1481 return unit_can_start(u) &&
1482 u->allow_isolate;
1483 }
1484
1485 /* Errors:
1486 * -EBADR: This unit type does not support stopping.
1487 * -EALREADY: Unit is already stopped.
1488 * -EAGAIN: An operation is already in progress. Retry later.
1489 */
1490 int unit_stop(Unit *u) {
1491 UnitActiveState state;
1492 Unit *following;
1493
1494 assert(u);
1495
1496 state = unit_active_state(u);
1497 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1498 return -EALREADY;
1499
1500 following = unit_following(u);
1501 if (following) {
1502 log_unit_debug(u, "Redirecting stop request from %s to %s.", u->id, following->id);
1503 return unit_stop(following);
1504 }
1505
1506 if (!UNIT_VTABLE(u)->stop)
1507 return -EBADR;
1508
1509 unit_add_to_dbus_queue(u);
1510
1511 return UNIT_VTABLE(u)->stop(u);
1512 }
1513
1514 /* Errors:
1515 * -EBADR: This unit type does not support reloading.
1516 * -ENOEXEC: Unit is not started.
1517 * -EAGAIN: An operation is already in progress. Retry later.
1518 */
1519 int unit_reload(Unit *u) {
1520 UnitActiveState state;
1521 Unit *following;
1522
1523 assert(u);
1524
1525 if (u->load_state != UNIT_LOADED)
1526 return -EINVAL;
1527
1528 if (!unit_can_reload(u))
1529 return -EBADR;
1530
1531 state = unit_active_state(u);
1532 if (state == UNIT_RELOADING)
1533 return -EALREADY;
1534
1535 if (state != UNIT_ACTIVE) {
1536 log_unit_warning(u, "Unit cannot be reloaded because it is inactive.");
1537 return -ENOEXEC;
1538 }
1539
1540 following = unit_following(u);
1541 if (following) {
1542 log_unit_debug(u, "Redirecting reload request from %s to %s.", u->id, following->id);
1543 return unit_reload(following);
1544 }
1545
1546 unit_add_to_dbus_queue(u);
1547
1548 return UNIT_VTABLE(u)->reload(u);
1549 }
1550
1551 bool unit_can_reload(Unit *u) {
1552 assert(u);
1553
1554 if (!UNIT_VTABLE(u)->reload)
1555 return false;
1556
1557 if (!UNIT_VTABLE(u)->can_reload)
1558 return true;
1559
1560 return UNIT_VTABLE(u)->can_reload(u);
1561 }
1562
1563 static void unit_check_unneeded(Unit *u) {
1564
1565 static const UnitDependency needed_dependencies[] = {
1566 UNIT_REQUIRED_BY,
1567 UNIT_REQUIRED_BY_OVERRIDABLE,
1568 UNIT_REQUISITE_OF,
1569 UNIT_REQUISITE_OF_OVERRIDABLE,
1570 UNIT_WANTED_BY,
1571 UNIT_BOUND_BY,
1572 };
1573
1574 Unit *other;
1575 Iterator i;
1576 unsigned j;
1577 int r;
1578
1579 assert(u);
1580
1581 /* If this service shall be shut down when unneeded then do
1582 * so. */
1583
1584 if (!u->stop_when_unneeded)
1585 return;
1586
1587 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1588 return;
1589
1590 for (j = 0; j < ELEMENTSOF(needed_dependencies); j++)
1591 SET_FOREACH(other, u->dependencies[needed_dependencies[j]], i)
1592 if (unit_active_or_pending(other))
1593 return;
1594
1595 /* If stopping a unit fails continously we might enter a stop
1596 * loop here, hence stop acting on the service being
1597 * unnecessary after a while. */
1598 if (!ratelimit_test(&u->auto_stop_ratelimit)) {
1599 log_unit_warning(u, "Unit not needed anymore, but not stopping since we tried this too often recently.");
1600 return;
1601 }
1602
1603 log_unit_info(u, "Unit not needed anymore. Stopping.");
1604
1605 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1606 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1607 if (r < 0)
1608 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %m");
1609 }
1610
1611 static void unit_check_binds_to(Unit *u) {
1612 bool stop = false;
1613 Unit *other;
1614 Iterator i;
1615 int r;
1616
1617 assert(u);
1618
1619 if (u->job)
1620 return;
1621
1622 if (unit_active_state(u) != UNIT_ACTIVE)
1623 return;
1624
1625 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1626 if (other->job)
1627 continue;
1628
1629 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1630 continue;
1631
1632 stop = true;
1633 break;
1634 }
1635
1636 if (!stop)
1637 return;
1638
1639 /* If stopping a unit fails continously we might enter a stop
1640 * loop here, hence stop acting on the service being
1641 * unnecessary after a while. */
1642 if (!ratelimit_test(&u->auto_stop_ratelimit)) {
1643 log_unit_warning(u, "Unit is bound to inactive unit %s, but not stopping since we tried this too often recently.", other->id);
1644 return;
1645 }
1646
1647 assert(other);
1648 log_unit_info(u, "Unit is bound to inactive unit %s. Stopping, too.", other->id);
1649
1650 /* A unit we need to run is gone. Sniff. Let's stop this. */
1651 r = manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1652 if (r < 0)
1653 log_unit_warning_errno(u, r, "Failed to enqueue stop job, ignoring: %m");
1654 }
1655
1656 static void retroactively_start_dependencies(Unit *u) {
1657 Iterator i;
1658 Unit *other;
1659
1660 assert(u);
1661 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1662
1663 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1664 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1665 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1666 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1667
1668 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1669 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1670 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1671 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1672
1673 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1674 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1675 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1676 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1677
1678 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1679 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1680 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1681 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1682
1683 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1684 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1685 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1686
1687 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1688 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1689 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1690 }
1691
1692 static void retroactively_stop_dependencies(Unit *u) {
1693 Iterator i;
1694 Unit *other;
1695
1696 assert(u);
1697 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1698
1699 /* Pull down units which are bound to us recursively if enabled */
1700 SET_FOREACH(other, u->dependencies[UNIT_BOUND_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 check_unneeded_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 /* Garbage collect services that might not be needed anymore, if enabled */
1713 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1714 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1715 unit_check_unneeded(other);
1716 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1717 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1718 unit_check_unneeded(other);
1719 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1720 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1721 unit_check_unneeded(other);
1722 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1723 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1724 unit_check_unneeded(other);
1725 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1726 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1727 unit_check_unneeded(other);
1728 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1729 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1730 unit_check_unneeded(other);
1731 }
1732
1733 void unit_start_on_failure(Unit *u) {
1734 Unit *other;
1735 Iterator i;
1736
1737 assert(u);
1738
1739 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1740 return;
1741
1742 log_unit_info(u, "Triggering OnFailure= dependencies.");
1743
1744 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1745 int r;
1746
1747 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1748 if (r < 0)
1749 log_unit_error_errno(u, r, "Failed to enqueue OnFailure= job: %m");
1750 }
1751 }
1752
1753 void unit_trigger_notify(Unit *u) {
1754 Unit *other;
1755 Iterator i;
1756
1757 assert(u);
1758
1759 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1760 if (UNIT_VTABLE(other)->trigger_notify)
1761 UNIT_VTABLE(other)->trigger_notify(other, u);
1762 }
1763
1764 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1765 Manager *m;
1766 bool unexpected;
1767
1768 assert(u);
1769 assert(os < _UNIT_ACTIVE_STATE_MAX);
1770 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1771
1772 /* Note that this is called for all low-level state changes,
1773 * even if they might map to the same high-level
1774 * UnitActiveState! That means that ns == os is an expected
1775 * behavior here. For example: if a mount point is remounted
1776 * this function will be called too! */
1777
1778 m = u->manager;
1779
1780 /* Update timestamps for state changes */
1781 if (m->n_reloading <= 0) {
1782 dual_timestamp ts;
1783
1784 dual_timestamp_get(&ts);
1785
1786 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1787 u->inactive_exit_timestamp = ts;
1788 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1789 u->inactive_enter_timestamp = ts;
1790
1791 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1792 u->active_enter_timestamp = ts;
1793 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1794 u->active_exit_timestamp = ts;
1795 }
1796
1797 /* Keep track of failed units */
1798 manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);
1799
1800 /* Make sure the cgroup is always removed when we become inactive */
1801 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1802 unit_prune_cgroup(u);
1803
1804 /* Note that this doesn't apply to RemainAfterExit services exiting
1805 * successfully, since there's no change of state in that case. Which is
1806 * why it is handled in service_set_state() */
1807 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1808 ExecContext *ec;
1809
1810 ec = unit_get_exec_context(u);
1811 if (ec && exec_context_may_touch_console(ec)) {
1812 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1813 m->n_on_console --;
1814
1815 if (m->n_on_console == 0)
1816 /* unset no_console_output flag, since the console is free */
1817 m->no_console_output = false;
1818 } else
1819 m->n_on_console ++;
1820 }
1821 }
1822
1823 if (u->job) {
1824 unexpected = false;
1825
1826 if (u->job->state == JOB_WAITING)
1827
1828 /* So we reached a different state for this
1829 * job. Let's see if we can run it now if it
1830 * failed previously due to EAGAIN. */
1831 job_add_to_run_queue(u->job);
1832
1833 /* Let's check whether this state change constitutes a
1834 * finished job, or maybe contradicts a running job and
1835 * hence needs to invalidate jobs. */
1836
1837 switch (u->job->type) {
1838
1839 case JOB_START:
1840 case JOB_VERIFY_ACTIVE:
1841
1842 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1843 job_finish_and_invalidate(u->job, JOB_DONE, true);
1844 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1845 unexpected = true;
1846
1847 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1848 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1849 }
1850
1851 break;
1852
1853 case JOB_RELOAD:
1854 case JOB_RELOAD_OR_START:
1855
1856 if (u->job->state == JOB_RUNNING) {
1857 if (ns == UNIT_ACTIVE)
1858 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1859 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1860 unexpected = true;
1861
1862 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1863 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1864 }
1865 }
1866
1867 break;
1868
1869 case JOB_STOP:
1870 case JOB_RESTART:
1871 case JOB_TRY_RESTART:
1872
1873 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1874 job_finish_and_invalidate(u->job, JOB_DONE, true);
1875 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1876 unexpected = true;
1877 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1878 }
1879
1880 break;
1881
1882 default:
1883 assert_not_reached("Job type unknown");
1884 }
1885
1886 } else
1887 unexpected = true;
1888
1889 if (m->n_reloading <= 0) {
1890
1891 /* If this state change happened without being
1892 * requested by a job, then let's retroactively start
1893 * or stop dependencies. We skip that step when
1894 * deserializing, since we don't want to create any
1895 * additional jobs just because something is already
1896 * activated. */
1897
1898 if (unexpected) {
1899 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1900 retroactively_start_dependencies(u);
1901 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1902 retroactively_stop_dependencies(u);
1903 }
1904
1905 /* stop unneeded units regardless if going down was expected or not */
1906 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1907 check_unneeded_dependencies(u);
1908
1909 if (ns != os && ns == UNIT_FAILED) {
1910 log_unit_notice(u, "Unit entered failed state.");
1911 unit_start_on_failure(u);
1912 }
1913 }
1914
1915 /* Some names are special */
1916 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1917
1918 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1919 /* The bus might have just become available,
1920 * hence try to connect to it, if we aren't
1921 * yet connected. */
1922 bus_init(m, true);
1923
1924 if (u->type == UNIT_SERVICE &&
1925 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1926 m->n_reloading <= 0) {
1927 /* Write audit record if we have just finished starting up */
1928 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1929 u->in_audit = true;
1930 }
1931
1932 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1933 manager_send_unit_plymouth(m, u);
1934
1935 } else {
1936
1937 /* We don't care about D-Bus here, since we'll get an
1938 * asynchronous notification for it anyway. */
1939
1940 if (u->type == UNIT_SERVICE &&
1941 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1942 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1943 m->n_reloading <= 0) {
1944
1945 /* Hmm, if there was no start record written
1946 * write it now, so that we always have a nice
1947 * pair */
1948 if (!u->in_audit) {
1949 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1950
1951 if (ns == UNIT_INACTIVE)
1952 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1953 } else
1954 /* Write audit record if we have just finished shutting down */
1955 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1956
1957 u->in_audit = false;
1958 }
1959 }
1960
1961 manager_recheck_journal(m);
1962 unit_trigger_notify(u);
1963
1964 if (u->manager->n_reloading <= 0) {
1965 /* Maybe we finished startup and are now ready for
1966 * being stopped because unneeded? */
1967 unit_check_unneeded(u);
1968
1969 /* Maybe we finished startup, but something we needed
1970 * has vanished? Let's die then. (This happens when
1971 * something BindsTo= to a Type=oneshot unit, as these
1972 * units go directly from starting to inactive,
1973 * without ever entering started.) */
1974 unit_check_binds_to(u);
1975 }
1976
1977 unit_add_to_dbus_queue(u);
1978 unit_add_to_gc_queue(u);
1979 }
1980
1981 int unit_watch_pid(Unit *u, pid_t pid) {
1982 int q, r;
1983
1984 assert(u);
1985 assert(pid >= 1);
1986
1987 /* Watch a specific PID. We only support one or two units
1988 * watching each PID for now, not more. */
1989
1990 r = set_ensure_allocated(&u->pids, NULL);
1991 if (r < 0)
1992 return r;
1993
1994 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
1995 if (r < 0)
1996 return r;
1997
1998 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
1999 if (r == -EEXIST) {
2000 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
2001 if (r < 0)
2002 return r;
2003
2004 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2005 }
2006
2007 q = set_put(u->pids, LONG_TO_PTR(pid));
2008 if (q < 0)
2009 return q;
2010
2011 return r;
2012 }
2013
2014 void unit_unwatch_pid(Unit *u, pid_t pid) {
2015 assert(u);
2016 assert(pid >= 1);
2017
2018 (void) hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2019 (void) hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2020 (void) set_remove(u->pids, LONG_TO_PTR(pid));
2021 }
2022
2023 void unit_unwatch_all_pids(Unit *u) {
2024 assert(u);
2025
2026 while (!set_isempty(u->pids))
2027 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
2028
2029 u->pids = set_free(u->pids);
2030 }
2031
2032 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2033 Iterator i;
2034 void *e;
2035
2036 assert(u);
2037
2038 /* Cleans dead PIDs from our list */
2039
2040 SET_FOREACH(e, u->pids, i) {
2041 pid_t pid = PTR_TO_LONG(e);
2042
2043 if (pid == except1 || pid == except2)
2044 continue;
2045
2046 if (!pid_is_unwaited(pid))
2047 unit_unwatch_pid(u, pid);
2048 }
2049 }
2050
2051 bool unit_job_is_applicable(Unit *u, JobType j) {
2052 assert(u);
2053 assert(j >= 0 && j < _JOB_TYPE_MAX);
2054
2055 switch (j) {
2056
2057 case JOB_VERIFY_ACTIVE:
2058 case JOB_START:
2059 case JOB_STOP:
2060 case JOB_NOP:
2061 return true;
2062
2063 case JOB_RESTART:
2064 case JOB_TRY_RESTART:
2065 return unit_can_start(u);
2066
2067 case JOB_RELOAD:
2068 return unit_can_reload(u);
2069
2070 case JOB_RELOAD_OR_START:
2071 return unit_can_reload(u) && unit_can_start(u);
2072
2073 default:
2074 assert_not_reached("Invalid job type");
2075 }
2076 }
2077
2078 static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency) {
2079 assert(u);
2080
2081 /* Only warn about some unit types */
2082 if (!IN_SET(dependency, UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY))
2083 return;
2084
2085 if (streq_ptr(u->id, other))
2086 log_unit_warning(u, "Dependency %s=%s dropped", unit_dependency_to_string(dependency), u->id);
2087 else
2088 log_unit_warning(u, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency), strna(other), u->id);
2089 }
2090
2091 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2092
2093 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2094 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2095 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2096 [UNIT_WANTS] = UNIT_WANTED_BY,
2097 [UNIT_REQUISITE] = UNIT_REQUISITE_OF,
2098 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUISITE_OF_OVERRIDABLE,
2099 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2100 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2101 [UNIT_REQUIRED_BY] = UNIT_REQUIRES,
2102 [UNIT_REQUIRED_BY_OVERRIDABLE] = UNIT_REQUIRES_OVERRIDABLE,
2103 [UNIT_REQUISITE_OF] = UNIT_REQUISITE,
2104 [UNIT_REQUISITE_OF_OVERRIDABLE] = UNIT_REQUISITE_OVERRIDABLE,
2105 [UNIT_WANTED_BY] = UNIT_WANTS,
2106 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2107 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2108 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2109 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2110 [UNIT_BEFORE] = UNIT_AFTER,
2111 [UNIT_AFTER] = UNIT_BEFORE,
2112 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2113 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2114 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2115 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2116 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2117 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2118 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2119 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2120 };
2121 int r, q = 0, v = 0, w = 0;
2122 Unit *orig_u = u, *orig_other = other;
2123
2124 assert(u);
2125 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2126 assert(other);
2127
2128 u = unit_follow_merge(u);
2129 other = unit_follow_merge(other);
2130
2131 /* We won't allow dependencies on ourselves. We will not
2132 * consider them an error however. */
2133 if (u == other) {
2134 maybe_warn_about_dependency(orig_u, orig_other->id, d);
2135 return 0;
2136 }
2137
2138 r = set_ensure_allocated(&u->dependencies[d], NULL);
2139 if (r < 0)
2140 return r;
2141
2142 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2143 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2144 if (r < 0)
2145 return r;
2146 }
2147
2148 if (add_reference) {
2149 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2150 if (r < 0)
2151 return r;
2152
2153 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2154 if (r < 0)
2155 return r;
2156 }
2157
2158 q = set_put(u->dependencies[d], other);
2159 if (q < 0)
2160 return q;
2161
2162 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2163 v = set_put(other->dependencies[inverse_table[d]], u);
2164 if (v < 0) {
2165 r = v;
2166 goto fail;
2167 }
2168 }
2169
2170 if (add_reference) {
2171 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2172 if (w < 0) {
2173 r = w;
2174 goto fail;
2175 }
2176
2177 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2178 if (r < 0)
2179 goto fail;
2180 }
2181
2182 unit_add_to_dbus_queue(u);
2183 return 0;
2184
2185 fail:
2186 if (q > 0)
2187 set_remove(u->dependencies[d], other);
2188
2189 if (v > 0)
2190 set_remove(other->dependencies[inverse_table[d]], u);
2191
2192 if (w > 0)
2193 set_remove(u->dependencies[UNIT_REFERENCES], other);
2194
2195 return r;
2196 }
2197
2198 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2199 int r;
2200
2201 assert(u);
2202
2203 r = unit_add_dependency(u, d, other, add_reference);
2204 if (r < 0)
2205 return r;
2206
2207 return unit_add_dependency(u, e, other, add_reference);
2208 }
2209
2210 static int resolve_template(Unit *u, const char *name, const char*path, char **buf, const char **ret) {
2211 int r;
2212
2213 assert(u);
2214 assert(name || path);
2215 assert(buf);
2216 assert(ret);
2217
2218 if (!name)
2219 name = basename(path);
2220
2221 if (!unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
2222 *buf = NULL;
2223 *ret = name;
2224 return 0;
2225 }
2226
2227 if (u->instance)
2228 r = unit_name_replace_instance(name, u->instance, buf);
2229 else {
2230 _cleanup_free_ char *i = NULL;
2231
2232 r = unit_name_to_prefix(u->id, &i);
2233 if (r < 0)
2234 return r;
2235
2236 r = unit_name_replace_instance(name, i, buf);
2237 }
2238 if (r < 0)
2239 return r;
2240
2241 *ret = *buf;
2242 return 0;
2243 }
2244
2245 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2246 _cleanup_free_ char *buf = NULL;
2247 Unit *other;
2248 int r;
2249
2250 assert(u);
2251 assert(name || path);
2252
2253 r = resolve_template(u, name, path, &buf, &name);
2254 if (r < 0)
2255 return r;
2256
2257 r = manager_load_unit(u->manager, name, path, NULL, &other);
2258 if (r < 0)
2259 return r;
2260
2261 return unit_add_dependency(u, d, other, add_reference);
2262 }
2263
2264 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2265 _cleanup_free_ char *buf = NULL;
2266 Unit *other;
2267 int r;
2268
2269 assert(u);
2270 assert(name || path);
2271
2272 r = resolve_template(u, name, path, &buf, &name);
2273 if (r < 0)
2274 return r;
2275
2276 r = manager_load_unit(u->manager, name, path, NULL, &other);
2277 if (r < 0)
2278 return r;
2279
2280 return unit_add_two_dependencies(u, d, e, other, add_reference);
2281 }
2282
2283 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2284 _cleanup_free_ char *buf = NULL;
2285 Unit *other;
2286 int r;
2287
2288 assert(u);
2289 assert(name || path);
2290
2291 r = resolve_template(u, name, path, &buf, &name);
2292 if (r < 0)
2293 return r;
2294
2295 r = manager_load_unit(u->manager, name, path, NULL, &other);
2296 if (r < 0)
2297 return r;
2298
2299 return unit_add_dependency(other, d, u, add_reference);
2300 }
2301
2302 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2303 _cleanup_free_ char *buf = NULL;
2304 Unit *other;
2305 int r;
2306
2307 assert(u);
2308 assert(name || path);
2309
2310 r = resolve_template(u, name, path, &buf, &name);
2311 if (r < 0)
2312 return r;
2313
2314 r = manager_load_unit(u->manager, name, path, NULL, &other);
2315 if (r < 0)
2316 return r;
2317
2318 return unit_add_two_dependencies(other, d, e, u, add_reference);
2319 }
2320
2321 int set_unit_path(const char *p) {
2322 /* This is mostly for debug purposes */
2323 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2324 return -errno;
2325
2326 return 0;
2327 }
2328
2329 char *unit_dbus_path(Unit *u) {
2330 assert(u);
2331
2332 if (!u->id)
2333 return NULL;
2334
2335 return unit_dbus_path_from_name(u->id);
2336 }
2337
2338 int unit_set_slice(Unit *u, Unit *slice) {
2339 assert(u);
2340 assert(slice);
2341
2342 /* Sets the unit slice if it has not been set before. Is extra
2343 * careful, to only allow this for units that actually have a
2344 * cgroup context. Also, we don't allow to set this for slices
2345 * (since the parent slice is derived from the name). Make
2346 * sure the unit we set is actually a slice. */
2347
2348 if (!UNIT_HAS_CGROUP_CONTEXT(u))
2349 return -EOPNOTSUPP;
2350
2351 if (u->type == UNIT_SLICE)
2352 return -EINVAL;
2353
2354 if (unit_active_state(u) != UNIT_INACTIVE)
2355 return -EBUSY;
2356
2357 if (slice->type != UNIT_SLICE)
2358 return -EINVAL;
2359
2360 if (unit_has_name(u, SPECIAL_INIT_SCOPE) &&
2361 !unit_has_name(slice, SPECIAL_ROOT_SLICE))
2362 return -EPERM;
2363
2364 if (UNIT_DEREF(u->slice) == slice)
2365 return 0;
2366
2367 if (UNIT_ISSET(u->slice))
2368 return -EBUSY;
2369
2370 unit_ref_set(&u->slice, slice);
2371 return 1;
2372 }
2373
2374 int unit_set_default_slice(Unit *u) {
2375 _cleanup_free_ char *b = NULL;
2376 const char *slice_name;
2377 Unit *slice;
2378 int r;
2379
2380 assert(u);
2381
2382 if (UNIT_ISSET(u->slice))
2383 return 0;
2384
2385 if (u->instance) {
2386 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2387
2388 /* Implicitly place all instantiated units in their
2389 * own per-template slice */
2390
2391 r = unit_name_to_prefix(u->id, &prefix);
2392 if (r < 0)
2393 return r;
2394
2395 /* The prefix is already escaped, but it might include
2396 * "-" which has a special meaning for slice units,
2397 * hence escape it here extra. */
2398 escaped = unit_name_escape(prefix);
2399 if (!escaped)
2400 return -ENOMEM;
2401
2402 if (u->manager->running_as == MANAGER_SYSTEM)
2403 b = strjoin("system-", escaped, ".slice", NULL);
2404 else
2405 b = strappend(escaped, ".slice");
2406 if (!b)
2407 return -ENOMEM;
2408
2409 slice_name = b;
2410 } else
2411 slice_name =
2412 u->manager->running_as == MANAGER_SYSTEM && !unit_has_name(u, SPECIAL_INIT_SCOPE)
2413 ? SPECIAL_SYSTEM_SLICE
2414 : SPECIAL_ROOT_SLICE;
2415
2416 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2417 if (r < 0)
2418 return r;
2419
2420 return unit_set_slice(u, slice);
2421 }
2422
2423 const char *unit_slice_name(Unit *u) {
2424 assert(u);
2425
2426 if (!UNIT_ISSET(u->slice))
2427 return NULL;
2428
2429 return UNIT_DEREF(u->slice)->id;
2430 }
2431
2432 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2433 _cleanup_free_ char *t = NULL;
2434 int r;
2435
2436 assert(u);
2437 assert(type);
2438 assert(_found);
2439
2440 r = unit_name_change_suffix(u->id, type, &t);
2441 if (r < 0)
2442 return r;
2443 if (unit_has_name(u, t))
2444 return -EINVAL;
2445
2446 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2447 assert(r < 0 || *_found != u);
2448 return r;
2449 }
2450
2451 static int signal_name_owner_changed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2452 const char *name, *old_owner, *new_owner;
2453 Unit *u = userdata;
2454 int r;
2455
2456 assert(message);
2457 assert(u);
2458
2459 r = sd_bus_message_read(message, "sss", &name, &old_owner, &new_owner);
2460 if (r < 0) {
2461 bus_log_parse_error(r);
2462 return 0;
2463 }
2464
2465 if (UNIT_VTABLE(u)->bus_name_owner_change)
2466 UNIT_VTABLE(u)->bus_name_owner_change(u, name, old_owner, new_owner);
2467
2468 return 0;
2469 }
2470
2471 int unit_install_bus_match(sd_bus *bus, Unit *u, const char *name) {
2472 _cleanup_free_ char *match = NULL;
2473 Manager *m = u->manager;
2474
2475 assert(m);
2476
2477 if (u->match_bus_slot)
2478 return -EBUSY;
2479
2480 match = strjoin("type='signal',"
2481 "sender='org.freedesktop.DBus',"
2482 "path='/org/freedesktop/DBus',"
2483 "interface='org.freedesktop.DBus',"
2484 "member='NameOwnerChanged',"
2485 "arg0='",
2486 name,
2487 "'",
2488 NULL);
2489 if (!match)
2490 return -ENOMEM;
2491
2492 return sd_bus_add_match(bus, &u->match_bus_slot, match, signal_name_owner_changed, u);
2493 }
2494
2495 int unit_watch_bus_name(Unit *u, const char *name) {
2496 int r;
2497
2498 assert(u);
2499 assert(name);
2500
2501 /* Watch a specific name on the bus. We only support one unit
2502 * watching each name for now. */
2503
2504 if (u->manager->api_bus) {
2505 /* If the bus is already available, install the match directly.
2506 * Otherwise, just put the name in the list. bus_setup_api() will take care later. */
2507 r = unit_install_bus_match(u->manager->api_bus, u, name);
2508 if (r < 0)
2509 return log_warning_errno(r, "Failed to subscribe to NameOwnerChanged signal: %m");
2510 }
2511
2512 r = hashmap_put(u->manager->watch_bus, name, u);
2513 if (r < 0) {
2514 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
2515 return log_warning_errno(r, "Failed to put bus name to hashmap: %m");
2516 }
2517
2518 return 0;
2519 }
2520
2521 void unit_unwatch_bus_name(Unit *u, const char *name) {
2522 assert(u);
2523 assert(name);
2524
2525 hashmap_remove_value(u->manager->watch_bus, name, u);
2526 u->match_bus_slot = sd_bus_slot_unref(u->match_bus_slot);
2527 }
2528
2529 bool unit_can_serialize(Unit *u) {
2530 assert(u);
2531
2532 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2533 }
2534
2535 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2536 int r;
2537
2538 assert(u);
2539 assert(f);
2540 assert(fds);
2541
2542 if (unit_can_serialize(u)) {
2543 ExecRuntime *rt;
2544
2545 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2546 if (r < 0)
2547 return r;
2548
2549 rt = unit_get_exec_runtime(u);
2550 if (rt) {
2551 r = exec_runtime_serialize(u, rt, f, fds);
2552 if (r < 0)
2553 return r;
2554 }
2555 }
2556
2557 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2558 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2559 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2560 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2561 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2562 dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2563
2564 if (dual_timestamp_is_set(&u->condition_timestamp))
2565 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2566
2567 if (dual_timestamp_is_set(&u->assert_timestamp))
2568 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2569
2570 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2571 unit_serialize_item_format(u, f, "cpuacct-usage-base", "%" PRIu64, u->cpuacct_usage_base);
2572
2573 if (u->cgroup_path)
2574 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2575 unit_serialize_item(u, f, "cgroup-realized", yes_no(u->cgroup_realized));
2576
2577 if (serialize_jobs) {
2578 if (u->job) {
2579 fprintf(f, "job\n");
2580 job_serialize(u->job, f, fds);
2581 }
2582
2583 if (u->nop_job) {
2584 fprintf(f, "job\n");
2585 job_serialize(u->nop_job, f, fds);
2586 }
2587 }
2588
2589 /* End marker */
2590 fputc('\n', f);
2591 return 0;
2592 }
2593
2594 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2595 va_list ap;
2596
2597 assert(u);
2598 assert(f);
2599 assert(key);
2600 assert(format);
2601
2602 fputs(key, f);
2603 fputc('=', f);
2604
2605 va_start(ap, format);
2606 vfprintf(f, format, ap);
2607 va_end(ap);
2608
2609 fputc('\n', f);
2610 }
2611
2612 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2613 assert(u);
2614 assert(f);
2615 assert(key);
2616 assert(value);
2617
2618 fprintf(f, "%s=%s\n", key, value);
2619 }
2620
2621 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2622 ExecRuntime **rt = NULL;
2623 size_t offset;
2624 int r;
2625
2626 assert(u);
2627 assert(f);
2628 assert(fds);
2629
2630 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2631 if (offset > 0)
2632 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2633
2634 for (;;) {
2635 char line[LINE_MAX], *l, *v;
2636 size_t k;
2637
2638 if (!fgets(line, sizeof(line), f)) {
2639 if (feof(f))
2640 return 0;
2641 return -errno;
2642 }
2643
2644 char_array_0(line);
2645 l = strstrip(line);
2646
2647 /* End marker */
2648 if (isempty(l))
2649 return 0;
2650
2651 k = strcspn(l, "=");
2652
2653 if (l[k] == '=') {
2654 l[k] = 0;
2655 v = l+k+1;
2656 } else
2657 v = l+k;
2658
2659 if (streq(l, "job")) {
2660 if (v[0] == '\0') {
2661 /* new-style serialized job */
2662 Job *j;
2663
2664 j = job_new_raw(u);
2665 if (!j)
2666 return log_oom();
2667
2668 r = job_deserialize(j, f, fds);
2669 if (r < 0) {
2670 job_free(j);
2671 return r;
2672 }
2673
2674 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2675 if (r < 0) {
2676 job_free(j);
2677 return r;
2678 }
2679
2680 r = job_install_deserialized(j);
2681 if (r < 0) {
2682 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2683 job_free(j);
2684 return r;
2685 }
2686 } else /* legacy for pre-44 */
2687 log_unit_warning(u, "Update from too old systemd versions are unsupported, cannot deserialize job: %s", v);
2688 continue;
2689 } else if (streq(l, "inactive-exit-timestamp")) {
2690 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2691 continue;
2692 } else if (streq(l, "active-enter-timestamp")) {
2693 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2694 continue;
2695 } else if (streq(l, "active-exit-timestamp")) {
2696 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2697 continue;
2698 } else if (streq(l, "inactive-enter-timestamp")) {
2699 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2700 continue;
2701 } else if (streq(l, "condition-timestamp")) {
2702 dual_timestamp_deserialize(v, &u->condition_timestamp);
2703 continue;
2704 } else if (streq(l, "assert-timestamp")) {
2705 dual_timestamp_deserialize(v, &u->assert_timestamp);
2706 continue;
2707 } else if (streq(l, "condition-result")) {
2708
2709 r = parse_boolean(v);
2710 if (r < 0)
2711 log_unit_debug(u, "Failed to parse condition result value %s, ignoring.", v);
2712 else
2713 u->condition_result = r;
2714
2715 continue;
2716
2717 } else if (streq(l, "assert-result")) {
2718
2719 r = parse_boolean(v);
2720 if (r < 0)
2721 log_unit_debug(u, "Failed to parse assert result value %s, ignoring.", v);
2722 else
2723 u->assert_result = r;
2724
2725 continue;
2726
2727 } else if (streq(l, "transient")) {
2728
2729 r = parse_boolean(v);
2730 if (r < 0)
2731 log_unit_debug(u, "Failed to parse transient bool %s, ignoring.", v);
2732 else
2733 u->transient = r;
2734
2735 continue;
2736
2737 } else if (streq(l, "cpuacct-usage-base")) {
2738
2739 r = safe_atou64(v, &u->cpuacct_usage_base);
2740 if (r < 0)
2741 log_unit_debug(u, "Failed to parse CPU usage %s, ignoring.", v);
2742
2743 continue;
2744
2745 } else if (streq(l, "cgroup")) {
2746
2747 r = unit_set_cgroup_path(u, v);
2748 if (r < 0)
2749 log_unit_debug_errno(u, r, "Failed to set cgroup path %s, ignoring: %m", v);
2750
2751 (void) unit_watch_cgroup(u);
2752
2753 continue;
2754 } else if (streq(l, "cgroup-realized")) {
2755 int b;
2756
2757 b = parse_boolean(v);
2758 if (b < 0)
2759 log_unit_debug(u, "Failed to parse cgroup-realized bool %s, ignoring.", v);
2760 else
2761 u->cgroup_realized = b;
2762
2763 continue;
2764 }
2765
2766 if (unit_can_serialize(u)) {
2767 if (rt) {
2768 r = exec_runtime_deserialize_item(u, rt, l, v, fds);
2769 if (r < 0) {
2770 log_unit_warning(u, "Failed to deserialize runtime parameter '%s', ignoring.", l);
2771 continue;
2772 }
2773
2774 /* Returns positive if key was handled by the call */
2775 if (r > 0)
2776 continue;
2777 }
2778
2779 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2780 if (r < 0)
2781 log_unit_warning(u, "Failed to deserialize unit parameter '%s', ignoring.", l);
2782 }
2783 }
2784 }
2785
2786 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2787 Unit *device;
2788 _cleanup_free_ char *e = NULL;
2789 int r;
2790
2791 assert(u);
2792
2793 /* Adds in links to the device node that this unit is based on */
2794 if (isempty(what))
2795 return 0;
2796
2797 if (!is_device_path(what))
2798 return 0;
2799
2800 /* When device units aren't supported (such as in a
2801 * container), don't create dependencies on them. */
2802 if (!unit_type_supported(UNIT_DEVICE))
2803 return 0;
2804
2805 r = unit_name_from_path(what, ".device", &e);
2806 if (r < 0)
2807 return r;
2808
2809 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2810 if (r < 0)
2811 return r;
2812
2813 r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == MANAGER_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2814 if (r < 0)
2815 return r;
2816
2817 if (wants) {
2818 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2819 if (r < 0)
2820 return r;
2821 }
2822
2823 return 0;
2824 }
2825
2826 int unit_coldplug(Unit *u) {
2827 int r;
2828
2829 assert(u);
2830
2831 /* Make sure we don't enter a loop, when coldplugging
2832 * recursively. */
2833 if (u->coldplugged)
2834 return 0;
2835
2836 u->coldplugged = true;
2837
2838 if (UNIT_VTABLE(u)->coldplug) {
2839 r = UNIT_VTABLE(u)->coldplug(u);
2840 if (r < 0)
2841 return r;
2842 }
2843
2844 if (u->job) {
2845 r = job_coldplug(u->job);
2846 if (r < 0)
2847 return r;
2848 }
2849
2850 return 0;
2851 }
2852
2853 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2854 DISABLE_WARNING_FORMAT_NONLITERAL;
2855 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2856 status, unit_status_msg_format, unit_description(u));
2857 REENABLE_WARNING;
2858 }
2859
2860 bool unit_need_daemon_reload(Unit *u) {
2861 _cleanup_strv_free_ char **t = NULL;
2862 char **path;
2863 struct stat st;
2864 unsigned loaded_cnt, current_cnt;
2865
2866 assert(u);
2867
2868 if (u->fragment_path) {
2869 zero(st);
2870 if (stat(u->fragment_path, &st) < 0)
2871 /* What, cannot access this anymore? */
2872 return true;
2873
2874 if (u->fragment_mtime > 0 &&
2875 timespec_load(&st.st_mtim) != u->fragment_mtime)
2876 return true;
2877 }
2878
2879 if (u->source_path) {
2880 zero(st);
2881 if (stat(u->source_path, &st) < 0)
2882 return true;
2883
2884 if (u->source_mtime > 0 &&
2885 timespec_load(&st.st_mtim) != u->source_mtime)
2886 return true;
2887 }
2888
2889 (void) unit_find_dropin_paths(u, &t);
2890 loaded_cnt = strv_length(t);
2891 current_cnt = strv_length(u->dropin_paths);
2892
2893 if (loaded_cnt == current_cnt) {
2894 if (loaded_cnt == 0)
2895 return false;
2896
2897 if (strv_overlap(u->dropin_paths, t)) {
2898 STRV_FOREACH(path, u->dropin_paths) {
2899 zero(st);
2900 if (stat(*path, &st) < 0)
2901 return true;
2902
2903 if (u->dropin_mtime > 0 &&
2904 timespec_load(&st.st_mtim) > u->dropin_mtime)
2905 return true;
2906 }
2907
2908 return false;
2909 } else
2910 return true;
2911 } else
2912 return true;
2913 }
2914
2915 void unit_reset_failed(Unit *u) {
2916 assert(u);
2917
2918 if (UNIT_VTABLE(u)->reset_failed)
2919 UNIT_VTABLE(u)->reset_failed(u);
2920 }
2921
2922 Unit *unit_following(Unit *u) {
2923 assert(u);
2924
2925 if (UNIT_VTABLE(u)->following)
2926 return UNIT_VTABLE(u)->following(u);
2927
2928 return NULL;
2929 }
2930
2931 bool unit_stop_pending(Unit *u) {
2932 assert(u);
2933
2934 /* This call does check the current state of the unit. It's
2935 * hence useful to be called from state change calls of the
2936 * unit itself, where the state isn't updated yet. This is
2937 * different from unit_inactive_or_pending() which checks both
2938 * the current state and for a queued job. */
2939
2940 return u->job && u->job->type == JOB_STOP;
2941 }
2942
2943 bool unit_inactive_or_pending(Unit *u) {
2944 assert(u);
2945
2946 /* Returns true if the unit is inactive or going down */
2947
2948 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2949 return true;
2950
2951 if (unit_stop_pending(u))
2952 return true;
2953
2954 return false;
2955 }
2956
2957 bool unit_active_or_pending(Unit *u) {
2958 assert(u);
2959
2960 /* Returns true if the unit is active or going up */
2961
2962 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2963 return true;
2964
2965 if (u->job &&
2966 (u->job->type == JOB_START ||
2967 u->job->type == JOB_RELOAD_OR_START ||
2968 u->job->type == JOB_RESTART))
2969 return true;
2970
2971 return false;
2972 }
2973
2974 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
2975 assert(u);
2976 assert(w >= 0 && w < _KILL_WHO_MAX);
2977 assert(signo > 0);
2978 assert(signo < _NSIG);
2979
2980 if (!UNIT_VTABLE(u)->kill)
2981 return -EOPNOTSUPP;
2982
2983 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2984 }
2985
2986 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
2987 Set *pid_set;
2988 int r;
2989
2990 pid_set = set_new(NULL);
2991 if (!pid_set)
2992 return NULL;
2993
2994 /* Exclude the main/control pids from being killed via the cgroup */
2995 if (main_pid > 0) {
2996 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2997 if (r < 0)
2998 goto fail;
2999 }
3000
3001 if (control_pid > 0) {
3002 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3003 if (r < 0)
3004 goto fail;
3005 }
3006
3007 return pid_set;
3008
3009 fail:
3010 set_free(pid_set);
3011 return NULL;
3012 }
3013
3014 int unit_kill_common(
3015 Unit *u,
3016 KillWho who,
3017 int signo,
3018 pid_t main_pid,
3019 pid_t control_pid,
3020 sd_bus_error *error) {
3021
3022 int r = 0;
3023
3024 if (who == KILL_MAIN) {
3025 if (main_pid < 0)
3026 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3027 else if (main_pid == 0)
3028 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3029 }
3030
3031 if (who == KILL_CONTROL) {
3032 if (control_pid < 0)
3033 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3034 else if (control_pid == 0)
3035 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3036 }
3037
3038 if (who == KILL_CONTROL || who == KILL_ALL)
3039 if (control_pid > 0)
3040 if (kill(control_pid, signo) < 0)
3041 r = -errno;
3042
3043 if (who == KILL_MAIN || who == KILL_ALL)
3044 if (main_pid > 0)
3045 if (kill(main_pid, signo) < 0)
3046 r = -errno;
3047
3048 if (who == KILL_ALL && u->cgroup_path) {
3049 _cleanup_set_free_ Set *pid_set = NULL;
3050 int q;
3051
3052 /* Exclude the main/control pids from being killed via the cgroup */
3053 pid_set = unit_pid_set(main_pid, control_pid);
3054 if (!pid_set)
3055 return -ENOMEM;
3056
3057 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, false, false, pid_set);
3058 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3059 r = q;
3060 }
3061
3062 return r;
3063 }
3064
3065 int unit_following_set(Unit *u, Set **s) {
3066 assert(u);
3067 assert(s);
3068
3069 if (UNIT_VTABLE(u)->following_set)
3070 return UNIT_VTABLE(u)->following_set(u, s);
3071
3072 *s = NULL;
3073 return 0;
3074 }
3075
3076 UnitFileState unit_get_unit_file_state(Unit *u) {
3077 assert(u);
3078
3079 if (u->unit_file_state < 0 && u->fragment_path)
3080 u->unit_file_state = unit_file_get_state(
3081 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3082 NULL, basename(u->fragment_path));
3083
3084 return u->unit_file_state;
3085 }
3086
3087 int unit_get_unit_file_preset(Unit *u) {
3088 assert(u);
3089
3090 if (u->unit_file_preset < 0 && u->fragment_path)
3091 u->unit_file_preset = unit_file_query_preset(
3092 u->manager->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3093 NULL, basename(u->fragment_path));
3094
3095 return u->unit_file_preset;
3096 }
3097
3098 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3099 assert(ref);
3100 assert(u);
3101
3102 if (ref->unit)
3103 unit_ref_unset(ref);
3104
3105 ref->unit = u;
3106 LIST_PREPEND(refs, u->refs, ref);
3107 return u;
3108 }
3109
3110 void unit_ref_unset(UnitRef *ref) {
3111 assert(ref);
3112
3113 if (!ref->unit)
3114 return;
3115
3116 LIST_REMOVE(refs, ref->unit->refs, ref);
3117 ref->unit = NULL;
3118 }
3119
3120 int unit_patch_contexts(Unit *u) {
3121 CGroupContext *cc;
3122 ExecContext *ec;
3123 unsigned i;
3124 int r;
3125
3126 assert(u);
3127
3128 /* Patch in the manager defaults into the exec and cgroup
3129 * contexts, _after_ the rest of the settings have been
3130 * initialized */
3131
3132 ec = unit_get_exec_context(u);
3133 if (ec) {
3134 /* This only copies in the ones that need memory */
3135 for (i = 0; i < _RLIMIT_MAX; i++)
3136 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3137 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3138 if (!ec->rlimit[i])
3139 return -ENOMEM;
3140 }
3141
3142 if (u->manager->running_as == MANAGER_USER &&
3143 !ec->working_directory) {
3144
3145 r = get_home_dir(&ec->working_directory);
3146 if (r < 0)
3147 return r;
3148
3149 /* Allow user services to run, even if the
3150 * home directory is missing */
3151 ec->working_directory_missing_ok = true;
3152 }
3153
3154 if (u->manager->running_as == MANAGER_USER &&
3155 (ec->syscall_whitelist ||
3156 !set_isempty(ec->syscall_filter) ||
3157 !set_isempty(ec->syscall_archs) ||
3158 ec->address_families_whitelist ||
3159 !set_isempty(ec->address_families)))
3160 ec->no_new_privileges = true;
3161
3162 if (ec->private_devices)
3163 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3164 }
3165
3166 cc = unit_get_cgroup_context(u);
3167 if (cc) {
3168
3169 if (ec &&
3170 ec->private_devices &&
3171 cc->device_policy == CGROUP_AUTO)
3172 cc->device_policy = CGROUP_CLOSED;
3173 }
3174
3175 return 0;
3176 }
3177
3178 ExecContext *unit_get_exec_context(Unit *u) {
3179 size_t offset;
3180 assert(u);
3181
3182 if (u->type < 0)
3183 return NULL;
3184
3185 offset = UNIT_VTABLE(u)->exec_context_offset;
3186 if (offset <= 0)
3187 return NULL;
3188
3189 return (ExecContext*) ((uint8_t*) u + offset);
3190 }
3191
3192 KillContext *unit_get_kill_context(Unit *u) {
3193 size_t offset;
3194 assert(u);
3195
3196 if (u->type < 0)
3197 return NULL;
3198
3199 offset = UNIT_VTABLE(u)->kill_context_offset;
3200 if (offset <= 0)
3201 return NULL;
3202
3203 return (KillContext*) ((uint8_t*) u + offset);
3204 }
3205
3206 CGroupContext *unit_get_cgroup_context(Unit *u) {
3207 size_t offset;
3208
3209 if (u->type < 0)
3210 return NULL;
3211
3212 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3213 if (offset <= 0)
3214 return NULL;
3215
3216 return (CGroupContext*) ((uint8_t*) u + offset);
3217 }
3218
3219 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3220 size_t offset;
3221
3222 if (u->type < 0)
3223 return NULL;
3224
3225 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3226 if (offset <= 0)
3227 return NULL;
3228
3229 return *(ExecRuntime**) ((uint8_t*) u + offset);
3230 }
3231
3232 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3233 assert(u);
3234
3235 if (u->manager->running_as == MANAGER_USER) {
3236 int r;
3237
3238 if (mode == UNIT_PERSISTENT && !transient)
3239 r = user_config_home(dir);
3240 else
3241 r = user_runtime_dir(dir);
3242 if (r == 0)
3243 return -ENOENT;
3244
3245 return r;
3246 }
3247
3248 if (mode == UNIT_PERSISTENT && !transient)
3249 *dir = strdup("/etc/systemd/system");
3250 else
3251 *dir = strdup("/run/systemd/system");
3252 if (!*dir)
3253 return -ENOMEM;
3254
3255 return 0;
3256 }
3257
3258 static int unit_drop_in_file(Unit *u, UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3259 _cleanup_free_ char *dir = NULL;
3260 int r;
3261
3262 assert(u);
3263
3264 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3265 if (r < 0)
3266 return r;
3267
3268 return drop_in_file(dir, u->id, 50, name, p, q);
3269 }
3270
3271 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3272
3273 _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3274 int r;
3275
3276 assert(u);
3277
3278 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3279 return 0;
3280
3281 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3282 if (r < 0)
3283 return r;
3284
3285 r = write_drop_in(dir, u->id, 50, name, data);
3286 if (r < 0)
3287 return r;
3288
3289 r = drop_in_file(dir, u->id, 50, name, &p, &q);
3290 if (r < 0)
3291 return r;
3292
3293 r = strv_extend(&u->dropin_paths, q);
3294 if (r < 0)
3295 return r;
3296
3297 strv_sort(u->dropin_paths);
3298 strv_uniq(u->dropin_paths);
3299
3300 u->dropin_mtime = now(CLOCK_REALTIME);
3301
3302 return 0;
3303 }
3304
3305 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3306 _cleanup_free_ char *p = NULL;
3307 va_list ap;
3308 int r;
3309
3310 assert(u);
3311 assert(name);
3312 assert(format);
3313
3314 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3315 return 0;
3316
3317 va_start(ap, format);
3318 r = vasprintf(&p, format, ap);
3319 va_end(ap);
3320
3321 if (r < 0)
3322 return -ENOMEM;
3323
3324 return unit_write_drop_in(u, mode, name, p);
3325 }
3326
3327 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3328 _cleanup_free_ char *ndata = NULL;
3329
3330 assert(u);
3331 assert(name);
3332 assert(data);
3333
3334 if (!UNIT_VTABLE(u)->private_section)
3335 return -EINVAL;
3336
3337 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3338 return 0;
3339
3340 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3341 if (!ndata)
3342 return -ENOMEM;
3343
3344 return unit_write_drop_in(u, mode, name, ndata);
3345 }
3346
3347 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3348 _cleanup_free_ char *p = NULL;
3349 va_list ap;
3350 int r;
3351
3352 assert(u);
3353 assert(name);
3354 assert(format);
3355
3356 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3357 return 0;
3358
3359 va_start(ap, format);
3360 r = vasprintf(&p, format, ap);
3361 va_end(ap);
3362
3363 if (r < 0)
3364 return -ENOMEM;
3365
3366 return unit_write_drop_in_private(u, mode, name, p);
3367 }
3368
3369 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3370 _cleanup_free_ char *p = NULL, *q = NULL;
3371 int r;
3372
3373 assert(u);
3374
3375 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3376 return 0;
3377
3378 r = unit_drop_in_file(u, mode, name, &p, &q);
3379 if (r < 0)
3380 return r;
3381
3382 if (unlink(q) < 0)
3383 r = errno == ENOENT ? 0 : -errno;
3384 else
3385 r = 1;
3386
3387 rmdir(p);
3388 return r;
3389 }
3390
3391 int unit_make_transient(Unit *u) {
3392 assert(u);
3393
3394 if (!UNIT_VTABLE(u)->can_transient)
3395 return -EOPNOTSUPP;
3396
3397 u->load_state = UNIT_STUB;
3398 u->load_error = 0;
3399 u->transient = true;
3400 u->fragment_path = mfree(u->fragment_path);
3401
3402 return 0;
3403 }
3404
3405 int unit_kill_context(
3406 Unit *u,
3407 KillContext *c,
3408 KillOperation k,
3409 pid_t main_pid,
3410 pid_t control_pid,
3411 bool main_pid_alien) {
3412
3413 bool wait_for_exit = false;
3414 int sig, r;
3415
3416 assert(u);
3417 assert(c);
3418
3419 if (c->kill_mode == KILL_NONE)
3420 return 0;
3421
3422 switch (k) {
3423 case KILL_KILL:
3424 sig = SIGKILL;
3425 break;
3426 case KILL_ABORT:
3427 sig = SIGABRT;
3428 break;
3429 case KILL_TERMINATE:
3430 sig = c->kill_signal;
3431 break;
3432 default:
3433 assert_not_reached("KillOperation unknown");
3434 }
3435
3436 if (main_pid > 0) {
3437 r = kill_and_sigcont(main_pid, sig);
3438
3439 if (r < 0 && r != -ESRCH) {
3440 _cleanup_free_ char *comm = NULL;
3441 get_process_comm(main_pid, &comm);
3442
3443 log_unit_warning_errno(u, r, "Failed to kill main process " PID_FMT " (%s), ignoring: %m", main_pid, strna(comm));
3444 } else {
3445 if (!main_pid_alien)
3446 wait_for_exit = true;
3447
3448 if (c->send_sighup && k == KILL_TERMINATE)
3449 (void) kill(main_pid, SIGHUP);
3450 }
3451 }
3452
3453 if (control_pid > 0) {
3454 r = kill_and_sigcont(control_pid, sig);
3455
3456 if (r < 0 && r != -ESRCH) {
3457 _cleanup_free_ char *comm = NULL;
3458 get_process_comm(control_pid, &comm);
3459
3460 log_unit_warning_errno(u, r, "Failed to kill control process " PID_FMT " (%s), ignoring: %m", control_pid, strna(comm));
3461 } else {
3462 wait_for_exit = true;
3463
3464 if (c->send_sighup && k == KILL_TERMINATE)
3465 (void) kill(control_pid, SIGHUP);
3466 }
3467 }
3468
3469 if (u->cgroup_path &&
3470 (c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL))) {
3471 _cleanup_set_free_ Set *pid_set = NULL;
3472
3473 /* Exclude the main/control pids from being killed via the cgroup */
3474 pid_set = unit_pid_set(main_pid, control_pid);
3475 if (!pid_set)
3476 return -ENOMEM;
3477
3478 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, k != KILL_TERMINATE, false, pid_set);
3479 if (r < 0) {
3480 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3481 log_unit_warning_errno(u, r, "Failed to kill control group %s, ignoring: %m", u->cgroup_path);
3482
3483 } else if (r > 0) {
3484
3485 /* FIXME: For now, on the legacy hierarchy, we
3486 * will not wait for the cgroup members to die
3487 * if we are running in a container or if this
3488 * is a delegation unit, simply because cgroup
3489 * notification is unreliable in these
3490 * cases. It doesn't work at all in
3491 * containers, and outside of containers it
3492 * can be confused easily by left-over
3493 * directories in the cgroup -- which however
3494 * should not exist in non-delegated units. On
3495 * the unified hierarchy that's different,
3496 * there we get proper events. Hence rely on
3497 * them.*/
3498
3499 if (cg_unified() > 0 ||
3500 (detect_container(NULL) == 0 && !unit_cgroup_delegate(u)))
3501 wait_for_exit = true;
3502
3503 if (c->send_sighup && k != KILL_KILL) {
3504 set_free(pid_set);
3505
3506 pid_set = unit_pid_set(main_pid, control_pid);
3507 if (!pid_set)
3508 return -ENOMEM;
3509
3510 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3511 }
3512 }
3513 }
3514
3515 return wait_for_exit;
3516 }
3517
3518 int unit_require_mounts_for(Unit *u, const char *path) {
3519 char prefix[strlen(path) + 1], *p;
3520 int r;
3521
3522 assert(u);
3523 assert(path);
3524
3525 /* Registers a unit for requiring a certain path and all its
3526 * prefixes. We keep a simple array of these paths in the
3527 * unit, since its usually short. However, we build a prefix
3528 * table for all possible prefixes so that new appearing mount
3529 * units can easily determine which units to make themselves a
3530 * dependency of. */
3531
3532 if (!path_is_absolute(path))
3533 return -EINVAL;
3534
3535 p = strdup(path);
3536 if (!p)
3537 return -ENOMEM;
3538
3539 path_kill_slashes(p);
3540
3541 if (!path_is_safe(p)) {
3542 free(p);
3543 return -EPERM;
3544 }
3545
3546 if (strv_contains(u->requires_mounts_for, p)) {
3547 free(p);
3548 return 0;
3549 }
3550
3551 r = strv_consume(&u->requires_mounts_for, p);
3552 if (r < 0)
3553 return r;
3554
3555 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3556 Set *x;
3557
3558 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3559 if (!x) {
3560 char *q;
3561
3562 r = hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for, &string_hash_ops);
3563 if (r < 0)
3564 return r;
3565
3566 q = strdup(prefix);
3567 if (!q)
3568 return -ENOMEM;
3569
3570 x = set_new(NULL);
3571 if (!x) {
3572 free(q);
3573 return -ENOMEM;
3574 }
3575
3576 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3577 if (r < 0) {
3578 free(q);
3579 set_free(x);
3580 return r;
3581 }
3582 }
3583
3584 r = set_put(x, u);
3585 if (r < 0)
3586 return r;
3587 }
3588
3589 return 0;
3590 }
3591
3592 int unit_setup_exec_runtime(Unit *u) {
3593 ExecRuntime **rt;
3594 size_t offset;
3595 Iterator i;
3596 Unit *other;
3597
3598 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3599 assert(offset > 0);
3600
3601 /* Check if there already is an ExecRuntime for this unit? */
3602 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3603 if (*rt)
3604 return 0;
3605
3606 /* Try to get it from somebody else */
3607 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3608
3609 *rt = unit_get_exec_runtime(other);
3610 if (*rt) {
3611 exec_runtime_ref(*rt);
3612 return 0;
3613 }
3614 }
3615
3616 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3617 }
3618
3619 bool unit_type_supported(UnitType t) {
3620 if (_unlikely_(t < 0))
3621 return false;
3622 if (_unlikely_(t >= _UNIT_TYPE_MAX))
3623 return false;
3624
3625 if (!unit_vtable[t]->supported)
3626 return true;
3627
3628 return unit_vtable[t]->supported();
3629 }
3630
3631 void unit_warn_if_dir_nonempty(Unit *u, const char* where) {
3632 int r;
3633
3634 assert(u);
3635 assert(where);
3636
3637 r = dir_is_empty(where);
3638 if (r > 0)
3639 return;
3640 if (r < 0) {
3641 log_unit_warning_errno(u, r, "Failed to check directory %s: %m", where);
3642 return;
3643 }
3644
3645 log_struct(LOG_NOTICE,
3646 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
3647 LOG_UNIT_ID(u),
3648 LOG_UNIT_MESSAGE(u, "Directory %s to mount over is not empty, mounting anyway.", where),
3649 "WHERE=%s", where,
3650 NULL);
3651 }
3652
3653 int unit_fail_if_symlink(Unit *u, const char* where) {
3654 int r;
3655
3656 assert(u);
3657 assert(where);
3658
3659 r = is_symlink(where);
3660 if (r < 0) {
3661 log_unit_debug_errno(u, r, "Failed to check symlink %s, ignoring: %m", where);
3662 return 0;
3663 }
3664 if (r == 0)
3665 return 0;
3666
3667 log_struct(LOG_ERR,
3668 LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
3669 LOG_UNIT_ID(u),
3670 LOG_UNIT_MESSAGE(u, "Mount on symlink %s not allowed.", where),
3671 "WHERE=%s", where,
3672 NULL);
3673
3674 return -ELOOP;
3675 }
3676
3677 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3678 [UNIT_ACTIVE] = "active",
3679 [UNIT_RELOADING] = "reloading",
3680 [UNIT_INACTIVE] = "inactive",
3681 [UNIT_FAILED] = "failed",
3682 [UNIT_ACTIVATING] = "activating",
3683 [UNIT_DEACTIVATING] = "deactivating"
3684 };
3685
3686 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
Unnamed repository; edit this file 'description' to name the repository.