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