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