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