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