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