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