]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/unit.c
projects / thirdparty / systemd.git / blob
? search:


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