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


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