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