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