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