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