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


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