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


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