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