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