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