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