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