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