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