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


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