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