]> 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
automount: various smaller fixes
[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 continue;
2780 } else if (streq(l, "cgroup")) {
2781 char *s;
2782
2783 s = strdup(v);
2784 if (!s)
2785 return -ENOMEM;
2786
2787 if (u->cgroup_path) {
2788 void *p;
2789
2790 p = hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2791 log_info("Removing cgroup_path %s from hashmap (%p)", u->cgroup_path, p);
2792 free(u->cgroup_path);
2793 }
2794
2795 u->cgroup_path = s;
2796 assert(hashmap_put(u->manager->cgroup_unit, s, u) == 1);
2797
2798 continue;
2799 }
2800
2801 if (unit_can_serialize(u)) {
2802 if (rt) {
2803 r = exec_runtime_deserialize_item(rt, u, l, v, fds);
2804 if (r < 0)
2805 return r;
2806 if (r > 0)
2807 continue;
2808 }
2809
2810 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2811 if (r < 0)
2812 return r;
2813 }
2814 }
2815 }
2816
2817 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2818 Unit *device;
2819 _cleanup_free_ char *e = NULL;
2820 int r;
2821
2822 assert(u);
2823
2824 if (!what)
2825 return 0;
2826
2827 /* Adds in links to the device node that this unit is based on */
2828
2829 if (!is_device_path(what))
2830 return 0;
2831
2832 e = unit_name_from_path(what, ".device");
2833 if (!e)
2834 return -ENOMEM;
2835
2836 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2837 if (r < 0)
2838 return r;
2839
2840 r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2841 if (r < 0)
2842 return r;
2843
2844 if (wants) {
2845 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2846 if (r < 0)
2847 return r;
2848 }
2849
2850 return 0;
2851 }
2852
2853 static int unit_add_deserialized_job_coldplug(Unit *u) {
2854 int r;
2855
2856 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2857 if (r < 0)
2858 return r;
2859
2860 u->deserialized_job = _JOB_TYPE_INVALID;
2861
2862 return 0;
2863 }
2864
2865 int unit_coldplug(Unit *u, Hashmap *deferred_work) {
2866 int r;
2867
2868 assert(u);
2869
2870 if (UNIT_VTABLE(u)->coldplug)
2871 if ((r = UNIT_VTABLE(u)->coldplug(u, deferred_work)) < 0)
2872 return r;
2873
2874 if (u->job) {
2875 r = job_coldplug(u->job);
2876 if (r < 0)
2877 return r;
2878 } else if (u->deserialized_job >= 0)
2879 /* legacy */
2880 hashmap_put(deferred_work, u, &unit_add_deserialized_job_coldplug);
2881
2882 return 0;
2883 }
2884
2885 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2886 DISABLE_WARNING_FORMAT_NONLITERAL;
2887 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2888 status, unit_status_msg_format, unit_description(u));
2889 REENABLE_WARNING;
2890 }
2891
2892 bool unit_need_daemon_reload(Unit *u) {
2893 _cleanup_strv_free_ char **t = NULL;
2894 char **path;
2895 struct stat st;
2896 unsigned loaded_cnt, current_cnt;
2897
2898 assert(u);
2899
2900 if (u->fragment_path) {
2901 zero(st);
2902 if (stat(u->fragment_path, &st) < 0)
2903 /* What, cannot access this anymore? */
2904 return true;
2905
2906 if (u->fragment_mtime > 0 &&
2907 timespec_load(&st.st_mtim) != u->fragment_mtime)
2908 return true;
2909 }
2910
2911 if (u->source_path) {
2912 zero(st);
2913 if (stat(u->source_path, &st) < 0)
2914 return true;
2915
2916 if (u->source_mtime > 0 &&
2917 timespec_load(&st.st_mtim) != u->source_mtime)
2918 return true;
2919 }
2920
2921 (void) unit_find_dropin_paths(u, &t);
2922 loaded_cnt = strv_length(t);
2923 current_cnt = strv_length(u->dropin_paths);
2924
2925 if (loaded_cnt == current_cnt) {
2926 if (loaded_cnt == 0)
2927 return false;
2928
2929 if (strv_overlap(u->dropin_paths, t)) {
2930 STRV_FOREACH(path, u->dropin_paths) {
2931 zero(st);
2932 if (stat(*path, &st) < 0)
2933 return true;
2934
2935 if (u->dropin_mtime > 0 &&
2936 timespec_load(&st.st_mtim) > u->dropin_mtime)
2937 return true;
2938 }
2939
2940 return false;
2941 } else
2942 return true;
2943 } else
2944 return true;
2945 }
2946
2947 void unit_reset_failed(Unit *u) {
2948 assert(u);
2949
2950 if (UNIT_VTABLE(u)->reset_failed)
2951 UNIT_VTABLE(u)->reset_failed(u);
2952 }
2953
2954 Unit *unit_following(Unit *u) {
2955 assert(u);
2956
2957 if (UNIT_VTABLE(u)->following)
2958 return UNIT_VTABLE(u)->following(u);
2959
2960 return NULL;
2961 }
2962
2963 bool unit_stop_pending(Unit *u) {
2964 assert(u);
2965
2966 /* This call does check the current state of the unit. It's
2967 * hence useful to be called from state change calls of the
2968 * unit itself, where the state isn't updated yet. This is
2969 * different from unit_inactive_or_pending() which checks both
2970 * the current state and for a queued job. */
2971
2972 return u->job && u->job->type == JOB_STOP;
2973 }
2974
2975 bool unit_inactive_or_pending(Unit *u) {
2976 assert(u);
2977
2978 /* Returns true if the unit is inactive or going down */
2979
2980 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2981 return true;
2982
2983 if (unit_stop_pending(u))
2984 return true;
2985
2986 return false;
2987 }
2988
2989 bool unit_active_or_pending(Unit *u) {
2990 assert(u);
2991
2992 /* Returns true if the unit is active or going up */
2993
2994 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2995 return true;
2996
2997 if (u->job &&
2998 (u->job->type == JOB_START ||
2999 u->job->type == JOB_RELOAD_OR_START ||
3000 u->job->type == JOB_RESTART))
3001 return true;
3002
3003 return false;
3004 }
3005
3006 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
3007 assert(u);
3008 assert(w >= 0 && w < _KILL_WHO_MAX);
3009 assert(signo > 0);
3010 assert(signo < _NSIG);
3011
3012 if (!UNIT_VTABLE(u)->kill)
3013 return -EOPNOTSUPP;
3014
3015 return UNIT_VTABLE(u)->kill(u, w, signo, error);
3016 }
3017
3018 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
3019 Set *pid_set;
3020 int r;
3021
3022 pid_set = set_new(NULL);
3023 if (!pid_set)
3024 return NULL;
3025
3026 /* Exclude the main/control pids from being killed via the cgroup */
3027 if (main_pid > 0) {
3028 r = set_put(pid_set, LONG_TO_PTR(main_pid));
3029 if (r < 0)
3030 goto fail;
3031 }
3032
3033 if (control_pid > 0) {
3034 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3035 if (r < 0)
3036 goto fail;
3037 }
3038
3039 return pid_set;
3040
3041 fail:
3042 set_free(pid_set);
3043 return NULL;
3044 }
3045
3046 int unit_kill_common(
3047 Unit *u,
3048 KillWho who,
3049 int signo,
3050 pid_t main_pid,
3051 pid_t control_pid,
3052 sd_bus_error *error) {
3053
3054 int r = 0;
3055
3056 if (who == KILL_MAIN && main_pid <= 0) {
3057 if (main_pid < 0)
3058 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3059 else
3060 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3061 }
3062
3063 if (who == KILL_CONTROL && control_pid <= 0) {
3064 if (control_pid < 0)
3065 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3066 else
3067 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3068 }
3069
3070 if (who == KILL_CONTROL || who == KILL_ALL)
3071 if (control_pid > 0)
3072 if (kill(control_pid, signo) < 0)
3073 r = -errno;
3074
3075 if (who == KILL_MAIN || who == KILL_ALL)
3076 if (main_pid > 0)
3077 if (kill(main_pid, signo) < 0)
3078 r = -errno;
3079
3080 if (who == KILL_ALL && u->cgroup_path) {
3081 _cleanup_set_free_ Set *pid_set = NULL;
3082 int q;
3083
3084 /* Exclude the main/control pids from being killed via the cgroup */
3085 pid_set = unit_pid_set(main_pid, control_pid);
3086 if (!pid_set)
3087 return -ENOMEM;
3088
3089 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3090 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3091 r = q;
3092 }
3093
3094 return r;
3095 }
3096
3097 int unit_following_set(Unit *u, Set **s) {
3098 assert(u);
3099 assert(s);
3100
3101 if (UNIT_VTABLE(u)->following_set)
3102 return UNIT_VTABLE(u)->following_set(u, s);
3103
3104 *s = NULL;
3105 return 0;
3106 }
3107
3108 UnitFileState unit_get_unit_file_state(Unit *u) {
3109 assert(u);
3110
3111 if (u->unit_file_state < 0 && u->fragment_path)
3112 u->unit_file_state = unit_file_get_state(
3113 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3114 NULL, basename(u->fragment_path));
3115
3116 return u->unit_file_state;
3117 }
3118
3119 int unit_get_unit_file_preset(Unit *u) {
3120 assert(u);
3121
3122 if (u->unit_file_preset < 0 && u->fragment_path)
3123 u->unit_file_preset = unit_file_query_preset(
3124 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3125 NULL, basename(u->fragment_path));
3126
3127 return u->unit_file_preset;
3128 }
3129
3130 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3131 assert(ref);
3132 assert(u);
3133
3134 if (ref->unit)
3135 unit_ref_unset(ref);
3136
3137 ref->unit = u;
3138 LIST_PREPEND(refs, u->refs, ref);
3139 return u;
3140 }
3141
3142 void unit_ref_unset(UnitRef *ref) {
3143 assert(ref);
3144
3145 if (!ref->unit)
3146 return;
3147
3148 LIST_REMOVE(refs, ref->unit->refs, ref);
3149 ref->unit = NULL;
3150 }
3151
3152 int unit_patch_contexts(Unit *u) {
3153 CGroupContext *cc;
3154 ExecContext *ec;
3155 unsigned i;
3156 int r;
3157
3158 assert(u);
3159
3160 /* Patch in the manager defaults into the exec and cgroup
3161 * contexts, _after_ the rest of the settings have been
3162 * initialized */
3163
3164 ec = unit_get_exec_context(u);
3165 if (ec) {
3166 /* This only copies in the ones that need memory */
3167 for (i = 0; i < _RLIMIT_MAX; i++)
3168 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3169 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3170 if (!ec->rlimit[i])
3171 return -ENOMEM;
3172 }
3173
3174 if (u->manager->running_as == SYSTEMD_USER &&
3175 !ec->working_directory) {
3176
3177 r = get_home_dir(&ec->working_directory);
3178 if (r < 0)
3179 return r;
3180
3181 /* Allow user services to run, even if the
3182 * home directory is missing */
3183 ec->working_directory_missing_ok = true;
3184 }
3185
3186 if (u->manager->running_as == SYSTEMD_USER &&
3187 (ec->syscall_whitelist ||
3188 !set_isempty(ec->syscall_filter) ||
3189 !set_isempty(ec->syscall_archs) ||
3190 ec->address_families_whitelist ||
3191 !set_isempty(ec->address_families)))
3192 ec->no_new_privileges = true;
3193
3194 if (ec->private_devices)
3195 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3196 }
3197
3198 cc = unit_get_cgroup_context(u);
3199 if (cc) {
3200
3201 if (ec &&
3202 ec->private_devices &&
3203 cc->device_policy == CGROUP_AUTO)
3204 cc->device_policy = CGROUP_CLOSED;
3205 }
3206
3207 return 0;
3208 }
3209
3210 ExecContext *unit_get_exec_context(Unit *u) {
3211 size_t offset;
3212 assert(u);
3213
3214 if (u->type < 0)
3215 return NULL;
3216
3217 offset = UNIT_VTABLE(u)->exec_context_offset;
3218 if (offset <= 0)
3219 return NULL;
3220
3221 return (ExecContext*) ((uint8_t*) u + offset);
3222 }
3223
3224 KillContext *unit_get_kill_context(Unit *u) {
3225 size_t offset;
3226 assert(u);
3227
3228 if (u->type < 0)
3229 return NULL;
3230
3231 offset = UNIT_VTABLE(u)->kill_context_offset;
3232 if (offset <= 0)
3233 return NULL;
3234
3235 return (KillContext*) ((uint8_t*) u + offset);
3236 }
3237
3238 CGroupContext *unit_get_cgroup_context(Unit *u) {
3239 size_t offset;
3240
3241 if (u->type < 0)
3242 return NULL;
3243
3244 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3245 if (offset <= 0)
3246 return NULL;
3247
3248 return (CGroupContext*) ((uint8_t*) u + offset);
3249 }
3250
3251 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3252 size_t offset;
3253
3254 if (u->type < 0)
3255 return NULL;
3256
3257 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3258 if (offset <= 0)
3259 return NULL;
3260
3261 return *(ExecRuntime**) ((uint8_t*) u + offset);
3262 }
3263
3264 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3265 if (u->manager->running_as == SYSTEMD_USER) {
3266 int r;
3267
3268 if (mode == UNIT_PERSISTENT && !transient)
3269 r = user_config_home(dir);
3270 else
3271 r = user_runtime_dir(dir);
3272
3273 if (r == 0)
3274 return -ENOENT;
3275 return r;
3276 }
3277
3278 if (mode == UNIT_PERSISTENT && !transient)
3279 *dir = strdup("/etc/systemd/system");
3280 else
3281 *dir = strdup("/run/systemd/system");
3282 if (!*dir)
3283 return -ENOMEM;
3284
3285 return 0;
3286 }
3287
3288 static int unit_drop_in_file(Unit *u,
3289 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3290 _cleanup_free_ char *dir = NULL;
3291 int r;
3292
3293 assert(u);
3294
3295 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3296 if (r < 0)
3297 return r;
3298
3299 return drop_in_file(dir, u->id, 50, name, p, q);
3300 }
3301
3302 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3303
3304 _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3305 int r;
3306
3307 assert(u);
3308
3309 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3310 return 0;
3311
3312 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3313 if (r < 0)
3314 return r;
3315
3316 r = write_drop_in(dir, u->id, 50, name, data);
3317 if (r < 0)
3318 return r;
3319
3320 r = drop_in_file(dir, u->id, 50, name, &p, &q);
3321 if (r < 0)
3322 return r;
3323
3324 r = strv_extend(&u->dropin_paths, q);
3325 if (r < 0)
3326 return r;
3327
3328 strv_sort(u->dropin_paths);
3329 strv_uniq(u->dropin_paths);
3330
3331 u->dropin_mtime = now(CLOCK_REALTIME);
3332
3333 return 0;
3334 }
3335
3336 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3337 _cleanup_free_ char *p = NULL;
3338 va_list ap;
3339 int r;
3340
3341 assert(u);
3342 assert(name);
3343 assert(format);
3344
3345 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3346 return 0;
3347
3348 va_start(ap, format);
3349 r = vasprintf(&p, format, ap);
3350 va_end(ap);
3351
3352 if (r < 0)
3353 return -ENOMEM;
3354
3355 return unit_write_drop_in(u, mode, name, p);
3356 }
3357
3358 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3359 _cleanup_free_ char *ndata = NULL;
3360
3361 assert(u);
3362 assert(name);
3363 assert(data);
3364
3365 if (!UNIT_VTABLE(u)->private_section)
3366 return -EINVAL;
3367
3368 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3369 return 0;
3370
3371 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3372 if (!ndata)
3373 return -ENOMEM;
3374
3375 return unit_write_drop_in(u, mode, name, ndata);
3376 }
3377
3378 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3379 _cleanup_free_ char *p = NULL;
3380 va_list ap;
3381 int r;
3382
3383 assert(u);
3384 assert(name);
3385 assert(format);
3386
3387 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3388 return 0;
3389
3390 va_start(ap, format);
3391 r = vasprintf(&p, format, ap);
3392 va_end(ap);
3393
3394 if (r < 0)
3395 return -ENOMEM;
3396
3397 return unit_write_drop_in_private(u, mode, name, p);
3398 }
3399
3400 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3401 _cleanup_free_ char *p = NULL, *q = NULL;
3402 int r;
3403
3404 assert(u);
3405
3406 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3407 return 0;
3408
3409 r = unit_drop_in_file(u, mode, name, &p, &q);
3410 if (r < 0)
3411 return r;
3412
3413 if (unlink(q) < 0)
3414 r = errno == ENOENT ? 0 : -errno;
3415 else
3416 r = 1;
3417
3418 rmdir(p);
3419 return r;
3420 }
3421
3422 int unit_make_transient(Unit *u) {
3423 int r;
3424
3425 assert(u);
3426
3427 u->load_state = UNIT_STUB;
3428 u->load_error = 0;
3429 u->transient = true;
3430
3431 free(u->fragment_path);
3432 u->fragment_path = NULL;
3433
3434 if (u->manager->running_as == SYSTEMD_USER) {
3435 _cleanup_free_ char *c = NULL;
3436
3437 r = user_runtime_dir(&c);
3438 if (r < 0)
3439 return r;
3440 if (r == 0)
3441 return -ENOENT;
3442
3443 u->fragment_path = strjoin(c, "/", u->id, NULL);
3444 if (!u->fragment_path)
3445 return -ENOMEM;
3446
3447 mkdir_p(c, 0755);
3448 } else {
3449 u->fragment_path = strappend("/run/systemd/system/", u->id);
3450 if (!u->fragment_path)
3451 return -ENOMEM;
3452
3453 mkdir_p("/run/systemd/system", 0755);
3454 }
3455
3456 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3457 }
3458
3459 int unit_kill_context(
3460 Unit *u,
3461 KillContext *c,
3462 KillOperation k,
3463 pid_t main_pid,
3464 pid_t control_pid,
3465 bool main_pid_alien) {
3466
3467 int sig, wait_for_exit = false, r;
3468
3469 assert(u);
3470 assert(c);
3471
3472 if (c->kill_mode == KILL_NONE)
3473 return 0;
3474
3475 switch (k) {
3476 case KILL_KILL:
3477 sig = SIGKILL;
3478 break;
3479 case KILL_ABORT:
3480 sig = SIGABRT;
3481 break;
3482 case KILL_TERMINATE:
3483 sig = c->kill_signal;
3484 break;
3485 default:
3486 assert_not_reached("KillOperation unknown");
3487 }
3488
3489 if (main_pid > 0) {
3490 r = kill_and_sigcont(main_pid, sig);
3491
3492 if (r < 0 && r != -ESRCH) {
3493 _cleanup_free_ char *comm = NULL;
3494 get_process_comm(main_pid, &comm);
3495
3496 log_unit_warning_errno(u->id, r, "Failed to kill main process " PID_FMT " (%s): %m", main_pid, strna(comm));
3497 } else {
3498 if (!main_pid_alien)
3499 wait_for_exit = true;
3500
3501 if (c->send_sighup && k != KILL_KILL)
3502 kill(main_pid, SIGHUP);
3503 }
3504 }
3505
3506 if (control_pid > 0) {
3507 r = kill_and_sigcont(control_pid, sig);
3508
3509 if (r < 0 && r != -ESRCH) {
3510 _cleanup_free_ char *comm = NULL;
3511 get_process_comm(control_pid, &comm);
3512
3513 log_unit_warning_errno(u->id, r, "Failed to kill control process " PID_FMT " (%s): %m", control_pid, strna(comm));
3514 } else {
3515 wait_for_exit = true;
3516
3517 if (c->send_sighup && k != KILL_KILL)
3518 kill(control_pid, SIGHUP);
3519 }
3520 }
3521
3522 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3523 _cleanup_set_free_ Set *pid_set = NULL;
3524
3525 /* Exclude the main/control pids from being killed via the cgroup */
3526 pid_set = unit_pid_set(main_pid, control_pid);
3527 if (!pid_set)
3528 return -ENOMEM;
3529
3530 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3531 if (r < 0) {
3532 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3533 log_unit_warning_errno(u->id, r, "Failed to kill control group: %m");
3534 } else if (r > 0) {
3535
3536 /* FIXME: For now, we will not wait for the
3537 * cgroup members to die, simply because
3538 * cgroup notification is unreliable. It
3539 * doesn't work at all in containers, and
3540 * outside of containers it can be confused
3541 * easily by leaving directories in the
3542 * cgroup. */
3543
3544 /* wait_for_exit = true; */
3545
3546 if (c->send_sighup && k != KILL_KILL) {
3547 set_free(pid_set);
3548
3549 pid_set = unit_pid_set(main_pid, control_pid);
3550 if (!pid_set)
3551 return -ENOMEM;
3552
3553 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3554 }
3555 }
3556 }
3557
3558 return wait_for_exit;
3559 }
3560
3561 int unit_require_mounts_for(Unit *u, const char *path) {
3562 char prefix[strlen(path) + 1], *p;
3563 int r;
3564
3565 assert(u);
3566 assert(path);
3567
3568 /* Registers a unit for requiring a certain path and all its
3569 * prefixes. We keep a simple array of these paths in the
3570 * unit, since its usually short. However, we build a prefix
3571 * table for all possible prefixes so that new appearing mount
3572 * units can easily determine which units to make themselves a
3573 * dependency of. */
3574
3575 if (!path_is_absolute(path))
3576 return -EINVAL;
3577
3578 p = strdup(path);
3579 if (!p)
3580 return -ENOMEM;
3581
3582 path_kill_slashes(p);
3583
3584 if (!path_is_safe(p)) {
3585 free(p);
3586 return -EPERM;
3587 }
3588
3589 if (strv_contains(u->requires_mounts_for, p)) {
3590 free(p);
3591 return 0;
3592 }
3593
3594 r = strv_consume(&u->requires_mounts_for, p);
3595 if (r < 0)
3596 return r;
3597
3598 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3599 Set *x;
3600
3601 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3602 if (!x) {
3603 char *q;
3604
3605 if (!u->manager->units_requiring_mounts_for) {
3606 u->manager->units_requiring_mounts_for = hashmap_new(&string_hash_ops);
3607 if (!u->manager->units_requiring_mounts_for)
3608 return -ENOMEM;
3609 }
3610
3611 q = strdup(prefix);
3612 if (!q)
3613 return -ENOMEM;
3614
3615 x = set_new(NULL);
3616 if (!x) {
3617 free(q);
3618 return -ENOMEM;
3619 }
3620
3621 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3622 if (r < 0) {
3623 free(q);
3624 set_free(x);
3625 return r;
3626 }
3627 }
3628
3629 r = set_put(x, u);
3630 if (r < 0)
3631 return r;
3632 }
3633
3634 return 0;
3635 }
3636
3637 int unit_setup_exec_runtime(Unit *u) {
3638 ExecRuntime **rt;
3639 size_t offset;
3640 Iterator i;
3641 Unit *other;
3642
3643 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3644 assert(offset > 0);
3645
3646 /* Check if there already is an ExecRuntime for this unit? */
3647 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3648 if (*rt)
3649 return 0;
3650
3651 /* Try to get it from somebody else */
3652 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3653
3654 *rt = unit_get_exec_runtime(other);
3655 if (*rt) {
3656 exec_runtime_ref(*rt);
3657 return 0;
3658 }
3659 }
3660
3661 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3662 }
3663
3664 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3665 [UNIT_ACTIVE] = "active",
3666 [UNIT_RELOADING] = "reloading",
3667 [UNIT_INACTIVE] = "inactive",
3668 [UNIT_FAILED] = "failed",
3669 [UNIT_ACTIVATING] = "activating",
3670 [UNIT_DEACTIVATING] = "deactivating"
3671 };
3672
3673 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
Unnamed repository; edit this file 'description' to name the repository.