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