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