]> 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
util: make time formatting a bit smarter
[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("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
918 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("Failed to load configuration for %s: %s", u->id, strerror(-r));
938
939 return r;
940 }
941
942 bool unit_condition_test(Unit *u) {
943 assert(u);
944
945 dual_timestamp_get(&u->condition_timestamp);
946 u->condition_result = condition_test_list(u->conditions);
947
948 return u->condition_result;
949 }
950
951 static const char* unit_get_status_message_format(Unit *u, JobType t) {
952 const UnitStatusMessageFormats *format_table;
953
954 assert(u);
955 assert(t >= 0);
956 assert(t < _JOB_TYPE_MAX);
957
958 if (t != JOB_START && t != JOB_STOP)
959 return NULL;
960
961 format_table = &UNIT_VTABLE(u)->status_message_formats;
962 if (!format_table)
963 return NULL;
964
965 return format_table->starting_stopping[t == JOB_STOP];
966 }
967
968 static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
969 const char *format;
970
971 assert(u);
972 assert(t >= 0);
973 assert(t < _JOB_TYPE_MAX);
974
975 format = unit_get_status_message_format(u, t);
976 if (format)
977 return format;
978
979 /* Return generic strings */
980 if (t == JOB_START)
981 return "Starting %s.";
982 else if (t == JOB_STOP)
983 return "Stopping %s.";
984 else if (t == JOB_RELOAD)
985 return "Reloading %s.";
986
987 return NULL;
988 }
989
990 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
991 const char *format;
992
993 assert(u);
994
995 /* We only print status messages for selected units on
996 * selected operations. */
997
998 format = unit_get_status_message_format(u, t);
999 if (!format)
1000 return;
1001
1002 unit_status_printf(u, "", format);
1003 }
1004
1005 #pragma GCC diagnostic push
1006 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
1007 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1008 const char *format;
1009 char buf[LINE_MAX];
1010 sd_id128_t mid;
1011
1012 assert(u);
1013
1014 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1015 return;
1016
1017 if (log_on_console())
1018 return;
1019
1020 /* We log status messages for all units and all operations. */
1021
1022 format = unit_get_status_message_format_try_harder(u, t);
1023 if (!format)
1024 return;
1025
1026 snprintf(buf, sizeof(buf), format, unit_description(u));
1027 char_array_0(buf);
1028
1029 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1030 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1031 SD_MESSAGE_UNIT_RELOADING;
1032
1033 log_struct_unit(LOG_INFO,
1034 u->id,
1035 MESSAGE_ID(mid),
1036 "MESSAGE=%s", buf,
1037 NULL);
1038 }
1039 #pragma GCC diagnostic pop
1040
1041 /* Errors:
1042 * -EBADR: This unit type does not support starting.
1043 * -EALREADY: Unit is already started.
1044 * -EAGAIN: An operation is already in progress. Retry later.
1045 * -ECANCELED: Too many requests for now.
1046 */
1047 int unit_start(Unit *u) {
1048 UnitActiveState state;
1049 Unit *following;
1050
1051 assert(u);
1052
1053 if (u->load_state != UNIT_LOADED)
1054 return -EINVAL;
1055
1056 /* If this is already started, then this will succeed. Note
1057 * that this will even succeed if this unit is not startable
1058 * by the user. This is relied on to detect when we need to
1059 * wait for units and when waiting is finished. */
1060 state = unit_active_state(u);
1061 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1062 return -EALREADY;
1063
1064 /* If the conditions failed, don't do anything at all. If we
1065 * already are activating this call might still be useful to
1066 * speed up activation in case there is some hold-off time,
1067 * but we don't want to recheck the condition in that case. */
1068 if (state != UNIT_ACTIVATING &&
1069 !unit_condition_test(u)) {
1070 log_debug("Starting of %s requested but condition failed. Ignoring.", u->id);
1071 return -EALREADY;
1072 }
1073
1074 /* Forward to the main object, if we aren't it. */
1075 if ((following = unit_following(u))) {
1076 log_debug("Redirecting start request from %s to %s.", u->id, following->id);
1077 return unit_start(following);
1078 }
1079
1080 unit_status_log_starting_stopping_reloading(u, JOB_START);
1081 unit_status_print_starting_stopping(u, JOB_START);
1082
1083 /* If it is stopped, but we cannot start it, then fail */
1084 if (!UNIT_VTABLE(u)->start)
1085 return -EBADR;
1086
1087 /* We don't suppress calls to ->start() here when we are
1088 * already starting, to allow this request to be used as a
1089 * "hurry up" call, for example when the unit is in some "auto
1090 * restart" state where it waits for a holdoff timer to elapse
1091 * before it will start again. */
1092
1093 unit_add_to_dbus_queue(u);
1094
1095 return UNIT_VTABLE(u)->start(u);
1096 }
1097
1098 bool unit_can_start(Unit *u) {
1099 assert(u);
1100
1101 return !!UNIT_VTABLE(u)->start;
1102 }
1103
1104 bool unit_can_isolate(Unit *u) {
1105 assert(u);
1106
1107 return unit_can_start(u) &&
1108 u->allow_isolate;
1109 }
1110
1111 /* Errors:
1112 * -EBADR: This unit type does not support stopping.
1113 * -EALREADY: Unit is already stopped.
1114 * -EAGAIN: An operation is already in progress. Retry later.
1115 */
1116 int unit_stop(Unit *u) {
1117 UnitActiveState state;
1118 Unit *following;
1119
1120 assert(u);
1121
1122 state = unit_active_state(u);
1123 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1124 return -EALREADY;
1125
1126 if ((following = unit_following(u))) {
1127 log_debug("Redirecting stop request from %s to %s.", u->id, following->id);
1128 return unit_stop(following);
1129 }
1130
1131 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1132 unit_status_print_starting_stopping(u, JOB_STOP);
1133
1134 if (!UNIT_VTABLE(u)->stop)
1135 return -EBADR;
1136
1137 unit_add_to_dbus_queue(u);
1138
1139 return UNIT_VTABLE(u)->stop(u);
1140 }
1141
1142 /* Errors:
1143 * -EBADR: This unit type does not support reloading.
1144 * -ENOEXEC: Unit is not started.
1145 * -EAGAIN: An operation is already in progress. Retry later.
1146 */
1147 int unit_reload(Unit *u) {
1148 UnitActiveState state;
1149 Unit *following;
1150
1151 assert(u);
1152
1153 if (u->load_state != UNIT_LOADED)
1154 return -EINVAL;
1155
1156 if (!unit_can_reload(u))
1157 return -EBADR;
1158
1159 state = unit_active_state(u);
1160 if (state == UNIT_RELOADING)
1161 return -EALREADY;
1162
1163 if (state != UNIT_ACTIVE)
1164 return -ENOEXEC;
1165
1166 if ((following = unit_following(u))) {
1167 log_debug("Redirecting reload request from %s to %s.", u->id, following->id);
1168 return unit_reload(following);
1169 }
1170
1171 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1172
1173 unit_add_to_dbus_queue(u);
1174 return UNIT_VTABLE(u)->reload(u);
1175 }
1176
1177 bool unit_can_reload(Unit *u) {
1178 assert(u);
1179
1180 if (!UNIT_VTABLE(u)->reload)
1181 return false;
1182
1183 if (!UNIT_VTABLE(u)->can_reload)
1184 return true;
1185
1186 return UNIT_VTABLE(u)->can_reload(u);
1187 }
1188
1189 static void unit_check_unneeded(Unit *u) {
1190 Iterator i;
1191 Unit *other;
1192
1193 assert(u);
1194
1195 /* If this service shall be shut down when unneeded then do
1196 * so. */
1197
1198 if (!u->stop_when_unneeded)
1199 return;
1200
1201 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1202 return;
1203
1204 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1205 if (unit_pending_active(other))
1206 return;
1207
1208 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1209 if (unit_pending_active(other))
1210 return;
1211
1212 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1213 if (unit_pending_active(other))
1214 return;
1215
1216 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1217 if (unit_pending_active(other))
1218 return;
1219
1220 log_info("Service %s is not needed anymore. Stopping.", u->id);
1221
1222 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1223 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1224 }
1225
1226 static void retroactively_start_dependencies(Unit *u) {
1227 Iterator i;
1228 Unit *other;
1229
1230 assert(u);
1231 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1232
1233 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1234 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1235 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1236 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1237
1238 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1239 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1240 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1241 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1242
1243 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1244 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1245 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1246 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1247
1248 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1249 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1250 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1251 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1252
1253 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1254 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1255 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1256
1257 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], 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
1262 static void retroactively_stop_dependencies(Unit *u) {
1263 Iterator i;
1264 Unit *other;
1265
1266 assert(u);
1267 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1268
1269 /* Pull down units which are bound to us recursively if enabled */
1270 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1271 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1272 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1273 }
1274
1275 static void check_unneeded_dependencies(Unit *u) {
1276 Iterator i;
1277 Unit *other;
1278
1279 assert(u);
1280 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1281
1282 /* Garbage collect services that might not be needed anymore, if enabled */
1283 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1284 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1285 unit_check_unneeded(other);
1286 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1287 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1288 unit_check_unneeded(other);
1289 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1290 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1291 unit_check_unneeded(other);
1292 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1293 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1294 unit_check_unneeded(other);
1295 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1296 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1297 unit_check_unneeded(other);
1298 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1299 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1300 unit_check_unneeded(other);
1301 }
1302
1303 void unit_trigger_on_failure(Unit *u) {
1304 Unit *other;
1305 Iterator i;
1306
1307 assert(u);
1308
1309 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1310 return;
1311
1312 log_info("Triggering OnFailure= dependencies of %s.", u->id);
1313
1314 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1315 int r;
1316
1317 if ((r = manager_add_job(u->manager, JOB_START, other, u->on_failure_isolate ? JOB_ISOLATE : JOB_REPLACE, true, NULL, NULL)) < 0)
1318 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r));
1319 }
1320 }
1321
1322 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1323 Manager *m;
1324 bool unexpected;
1325
1326 assert(u);
1327 assert(os < _UNIT_ACTIVE_STATE_MAX);
1328 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1329
1330 /* Note that this is called for all low-level state changes,
1331 * even if they might map to the same high-level
1332 * UnitActiveState! That means that ns == os is OK an expected
1333 * behavior here. For example: if a mount point is remounted
1334 * this function will be called too! */
1335
1336 m = u->manager;
1337
1338 if (m->n_reloading <= 0) {
1339 dual_timestamp ts;
1340
1341 dual_timestamp_get(&ts);
1342
1343 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1344 u->inactive_exit_timestamp = ts;
1345 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1346 u->inactive_enter_timestamp = ts;
1347
1348 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1349 u->active_enter_timestamp = ts;
1350 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1351 u->active_exit_timestamp = ts;
1352
1353 timer_unit_notify(u, ns);
1354 path_unit_notify(u, ns);
1355 }
1356
1357 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1358 cgroup_bonding_trim_list(u->cgroup_bondings, true);
1359
1360 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1361 ExecContext *ec = unit_get_exec_context(u);
1362 if (ec && exec_context_may_touch_console(ec)) {
1363 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1364 m->n_on_console--;
1365 else
1366 m->n_on_console++;
1367 }
1368 }
1369
1370 if (u->job) {
1371 unexpected = false;
1372
1373 if (u->job->state == JOB_WAITING)
1374
1375 /* So we reached a different state for this
1376 * job. Let's see if we can run it now if it
1377 * failed previously due to EAGAIN. */
1378 job_add_to_run_queue(u->job);
1379
1380 /* Let's check whether this state change constitutes a
1381 * finished job, or maybe contradicts a running job and
1382 * hence needs to invalidate jobs. */
1383
1384 switch (u->job->type) {
1385
1386 case JOB_START:
1387 case JOB_VERIFY_ACTIVE:
1388
1389 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1390 job_finish_and_invalidate(u->job, JOB_DONE, true);
1391 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1392 unexpected = true;
1393
1394 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1395 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1396 }
1397
1398 break;
1399
1400 case JOB_RELOAD:
1401 case JOB_RELOAD_OR_START:
1402
1403 if (u->job->state == JOB_RUNNING) {
1404 if (ns == UNIT_ACTIVE)
1405 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1406 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1407 unexpected = true;
1408
1409 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1410 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1411 }
1412 }
1413
1414 break;
1415
1416 case JOB_STOP:
1417 case JOB_RESTART:
1418 case JOB_TRY_RESTART:
1419
1420 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1421 job_finish_and_invalidate(u->job, JOB_DONE, true);
1422 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1423 unexpected = true;
1424 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1425 }
1426
1427 break;
1428
1429 default:
1430 assert_not_reached("Job type unknown");
1431 }
1432
1433 } else
1434 unexpected = true;
1435
1436 if (m->n_reloading <= 0) {
1437
1438 /* If this state change happened without being
1439 * requested by a job, then let's retroactively start
1440 * or stop dependencies. We skip that step when
1441 * deserializing, since we don't want to create any
1442 * additional jobs just because something is already
1443 * activated. */
1444
1445 if (unexpected) {
1446 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1447 retroactively_start_dependencies(u);
1448 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1449 retroactively_stop_dependencies(u);
1450 }
1451
1452 /* stop unneeded units regardless if going down was expected or not */
1453 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1454 check_unneeded_dependencies(u);
1455
1456 if (ns != os && ns == UNIT_FAILED) {
1457 log_struct_unit(LOG_NOTICE,
1458 u->id,
1459 "MESSAGE=Unit %s entered failed state", u->id,
1460 NULL);
1461 unit_trigger_on_failure(u);
1462 }
1463 }
1464
1465 /* Some names are special */
1466 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1467
1468 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1469 /* The bus just might have become available,
1470 * hence try to connect to it, if we aren't
1471 * yet connected. */
1472 bus_init(m, true);
1473
1474 if (u->type == UNIT_SERVICE &&
1475 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1476 m->n_reloading <= 0) {
1477 /* Write audit record if we have just finished starting up */
1478 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1479 u->in_audit = true;
1480 }
1481
1482 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1483 manager_send_unit_plymouth(m, u);
1484
1485 } else {
1486
1487 /* We don't care about D-Bus here, since we'll get an
1488 * asynchronous notification for it anyway. */
1489
1490 if (u->type == UNIT_SERVICE &&
1491 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1492 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1493 m->n_reloading <= 0) {
1494
1495 /* Hmm, if there was no start record written
1496 * write it now, so that we always have a nice
1497 * pair */
1498 if (!u->in_audit) {
1499 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1500
1501 if (ns == UNIT_INACTIVE)
1502 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1503 } else
1504 /* Write audit record if we have just finished shutting down */
1505 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1506
1507 u->in_audit = false;
1508 }
1509 }
1510
1511 manager_recheck_journal(m);
1512
1513 /* Maybe we finished startup and are now ready for being
1514 * stopped because unneeded? */
1515 if (u->manager->n_reloading <= 0)
1516 unit_check_unneeded(u);
1517
1518 unit_add_to_dbus_queue(u);
1519 unit_add_to_gc_queue(u);
1520 }
1521
1522 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
1523 struct epoll_event ev;
1524
1525 assert(u);
1526 assert(fd >= 0);
1527 assert(w);
1528 assert(w->type == WATCH_INVALID || (w->type == WATCH_FD && w->fd == fd && w->data.unit == u));
1529
1530 zero(ev);
1531 ev.data.ptr = w;
1532 ev.events = events;
1533
1534 if (epoll_ctl(u->manager->epoll_fd,
1535 w->type == WATCH_INVALID ? EPOLL_CTL_ADD : EPOLL_CTL_MOD,
1536 fd,
1537 &ev) < 0)
1538 return -errno;
1539
1540 w->fd = fd;
1541 w->type = WATCH_FD;
1542 w->data.unit = u;
1543
1544 return 0;
1545 }
1546
1547 void unit_unwatch_fd(Unit *u, Watch *w) {
1548 assert(u);
1549 assert(w);
1550
1551 if (w->type == WATCH_INVALID)
1552 return;
1553
1554 assert(w->type == WATCH_FD);
1555 assert(w->data.unit == u);
1556 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1557
1558 w->fd = -1;
1559 w->type = WATCH_INVALID;
1560 w->data.unit = NULL;
1561 }
1562
1563 int unit_watch_pid(Unit *u, pid_t pid) {
1564 assert(u);
1565 assert(pid >= 1);
1566
1567 /* Watch a specific PID. We only support one unit watching
1568 * each PID for now. */
1569
1570 return hashmap_put(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1571 }
1572
1573 void unit_unwatch_pid(Unit *u, pid_t pid) {
1574 assert(u);
1575 assert(pid >= 1);
1576
1577 hashmap_remove_value(u->manager->watch_pids, LONG_TO_PTR(pid), u);
1578 }
1579
1580 int unit_watch_timer(Unit *u, clockid_t clock_id, bool relative, usec_t usec, Watch *w) {
1581 struct itimerspec its;
1582 int flags, fd;
1583 bool ours;
1584
1585 assert(u);
1586 assert(w);
1587 assert(w->type == WATCH_INVALID || (w->type == WATCH_UNIT_TIMER && w->data.unit == u));
1588
1589 /* This will try to reuse the old timer if there is one */
1590
1591 if (w->type == WATCH_UNIT_TIMER) {
1592 assert(w->data.unit == u);
1593 assert(w->fd >= 0);
1594
1595 ours = false;
1596 fd = w->fd;
1597 } else if (w->type == WATCH_INVALID) {
1598
1599 ours = true;
1600 fd = timerfd_create(clock_id, TFD_NONBLOCK|TFD_CLOEXEC);
1601 if (fd < 0)
1602 return -errno;
1603 } else
1604 assert_not_reached("Invalid watch type");
1605
1606 zero(its);
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
1627 zero(ev);
1628 ev.data.ptr = w;
1629 ev.events = EPOLLIN;
1630
1631 if (epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
1632 goto fail;
1633 }
1634
1635 w->type = WATCH_UNIT_TIMER;
1636 w->fd = fd;
1637 w->data.unit = u;
1638
1639 return 0;
1640
1641 fail:
1642 if (ours)
1643 close_nointr_nofail(fd);
1644
1645 return -errno;
1646 }
1647
1648 void unit_unwatch_timer(Unit *u, Watch *w) {
1649 assert(u);
1650 assert(w);
1651
1652 if (w->type == WATCH_INVALID)
1653 return;
1654
1655 assert(w->type == WATCH_UNIT_TIMER);
1656 assert(w->data.unit == u);
1657 assert(w->fd >= 0);
1658
1659 assert_se(epoll_ctl(u->manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
1660 close_nointr_nofail(w->fd);
1661
1662 w->fd = -1;
1663 w->type = WATCH_INVALID;
1664 w->data.unit = NULL;
1665 }
1666
1667 bool unit_job_is_applicable(Unit *u, JobType j) {
1668 assert(u);
1669 assert(j >= 0 && j < _JOB_TYPE_MAX);
1670
1671 switch (j) {
1672
1673 case JOB_VERIFY_ACTIVE:
1674 case JOB_START:
1675 case JOB_STOP:
1676 case JOB_NOP:
1677 return true;
1678
1679 case JOB_RESTART:
1680 case JOB_TRY_RESTART:
1681 return unit_can_start(u);
1682
1683 case JOB_RELOAD:
1684 return unit_can_reload(u);
1685
1686 case JOB_RELOAD_OR_START:
1687 return unit_can_reload(u) && unit_can_start(u);
1688
1689 default:
1690 assert_not_reached("Invalid job type");
1691 }
1692 }
1693
1694 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
1695
1696 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
1697 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
1698 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1699 [UNIT_WANTS] = UNIT_WANTED_BY,
1700 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
1701 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
1702 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
1703 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
1704 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
1705 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
1706 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
1707 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
1708 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
1709 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
1710 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
1711 [UNIT_BEFORE] = UNIT_AFTER,
1712 [UNIT_AFTER] = UNIT_BEFORE,
1713 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
1714 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
1715 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
1716 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
1717 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
1718 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
1719 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
1720 };
1721 int r, q = 0, v = 0, w = 0;
1722
1723 assert(u);
1724 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
1725 assert(other);
1726
1727 u = unit_follow_merge(u);
1728 other = unit_follow_merge(other);
1729
1730 /* We won't allow dependencies on ourselves. We will not
1731 * consider them an error however. */
1732 if (u == other)
1733 return 0;
1734
1735 if ((r = set_ensure_allocated(&u->dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
1736 return r;
1737
1738 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1739 if ((r = set_ensure_allocated(&other->dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
1740 return r;
1741
1742 if (add_reference)
1743 if ((r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
1744 (r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
1745 return r;
1746
1747 if ((q = set_put(u->dependencies[d], other)) < 0)
1748 return q;
1749
1750 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID)
1751 if ((v = set_put(other->dependencies[inverse_table[d]], u)) < 0) {
1752 r = v;
1753 goto fail;
1754 }
1755
1756 if (add_reference) {
1757 if ((w = set_put(u->dependencies[UNIT_REFERENCES], other)) < 0) {
1758 r = w;
1759 goto fail;
1760 }
1761
1762 if ((r = set_put(other->dependencies[UNIT_REFERENCED_BY], u)) < 0)
1763 goto fail;
1764 }
1765
1766 unit_add_to_dbus_queue(u);
1767 return 0;
1768
1769 fail:
1770 if (q > 0)
1771 set_remove(u->dependencies[d], other);
1772
1773 if (v > 0)
1774 set_remove(other->dependencies[inverse_table[d]], u);
1775
1776 if (w > 0)
1777 set_remove(u->dependencies[UNIT_REFERENCES], other);
1778
1779 return r;
1780 }
1781
1782 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
1783 int r;
1784
1785 assert(u);
1786
1787 if ((r = unit_add_dependency(u, d, other, add_reference)) < 0)
1788 return r;
1789
1790 if ((r = unit_add_dependency(u, e, other, add_reference)) < 0)
1791 return r;
1792
1793 return 0;
1794 }
1795
1796 static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
1797 char *s;
1798
1799 assert(u);
1800 assert(name || path);
1801 assert(p);
1802
1803 if (!name)
1804 name = path_get_file_name(path);
1805
1806 if (!unit_name_is_template(name)) {
1807 *p = NULL;
1808 return name;
1809 }
1810
1811 if (u->instance)
1812 s = unit_name_replace_instance(name, u->instance);
1813 else {
1814 char *i;
1815
1816 i = unit_name_to_prefix(u->id);
1817 if (!i)
1818 return NULL;
1819
1820 s = unit_name_replace_instance(name, i);
1821 free(i);
1822 }
1823
1824 if (!s)
1825 return NULL;
1826
1827 *p = s;
1828 return s;
1829 }
1830
1831 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1832 Unit *other;
1833 int r;
1834 _cleanup_free_ char *s = NULL;
1835
1836 assert(u);
1837 assert(name || path);
1838
1839 name = resolve_template(u, name, path, &s);
1840 if (!name)
1841 return -ENOMEM;
1842
1843 r = manager_load_unit(u->manager, name, path, NULL, &other);
1844 if (r < 0)
1845 return r;
1846
1847 return unit_add_dependency(u, d, other, add_reference);
1848 }
1849
1850 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1851 Unit *other;
1852 int r;
1853 char *s;
1854
1855 assert(u);
1856 assert(name || path);
1857
1858 if (!(name = resolve_template(u, name, path, &s)))
1859 return -ENOMEM;
1860
1861 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1862 goto finish;
1863
1864 r = unit_add_two_dependencies(u, d, e, other, add_reference);
1865
1866 finish:
1867 free(s);
1868 return r;
1869 }
1870
1871 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
1872 Unit *other;
1873 int r;
1874 char *s;
1875
1876 assert(u);
1877 assert(name || path);
1878
1879 if (!(name = resolve_template(u, name, path, &s)))
1880 return -ENOMEM;
1881
1882 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1883 goto finish;
1884
1885 r = unit_add_dependency(other, d, u, add_reference);
1886
1887 finish:
1888 free(s);
1889 return r;
1890 }
1891
1892 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
1893 Unit *other;
1894 int r;
1895 char *s;
1896
1897 assert(u);
1898 assert(name || path);
1899
1900 if (!(name = resolve_template(u, name, path, &s)))
1901 return -ENOMEM;
1902
1903 if ((r = manager_load_unit(u->manager, name, path, NULL, &other)) < 0)
1904 goto finish;
1905
1906 if ((r = unit_add_two_dependencies(other, d, e, u, add_reference)) < 0)
1907 goto finish;
1908
1909 finish:
1910 free(s);
1911 return r;
1912 }
1913
1914 int set_unit_path(const char *p) {
1915 _cleanup_free_ char *c = NULL;
1916
1917 /* This is mostly for debug purposes */
1918 c = path_make_absolute_cwd(p);
1919 if (setenv("SYSTEMD_UNIT_PATH", c, 0) < 0)
1920 return -errno;
1921
1922 return 0;
1923 }
1924
1925 char *unit_dbus_path(Unit *u) {
1926 assert(u);
1927
1928 if (!u->id)
1929 return NULL;
1930
1931 return unit_dbus_path_from_name(u->id);
1932 }
1933
1934 int unit_add_cgroup(Unit *u, CGroupBonding *b) {
1935 int r;
1936
1937 assert(u);
1938 assert(b);
1939
1940 assert(b->path);
1941
1942 if (!b->controller) {
1943 b->controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
1944 if (!b->controller)
1945 return log_oom();
1946
1947 b->ours = true;
1948 }
1949
1950 /* Ensure this hasn't been added yet */
1951 assert(!b->unit);
1952
1953 if (streq(b->controller, SYSTEMD_CGROUP_CONTROLLER)) {
1954 CGroupBonding *l;
1955
1956 l = hashmap_get(u->manager->cgroup_bondings, b->path);
1957 LIST_PREPEND(CGroupBonding, by_path, l, b);
1958
1959 r = hashmap_replace(u->manager->cgroup_bondings, b->path, l);
1960 if (r < 0) {
1961 LIST_REMOVE(CGroupBonding, by_path, l, b);
1962 return r;
1963 }
1964 }
1965
1966 LIST_PREPEND(CGroupBonding, by_unit, u->cgroup_bondings, b);
1967 b->unit = u;
1968
1969 return 0;
1970 }
1971
1972 char *unit_default_cgroup_path(Unit *u) {
1973 assert(u);
1974
1975 if (u->instance) {
1976 _cleanup_free_ char *t = NULL;
1977
1978 t = unit_name_template(u->id);
1979 if (!t)
1980 return NULL;
1981
1982 return strjoin(u->manager->cgroup_hierarchy, "/", t, "/", u->instance, NULL);
1983 } else
1984 return strjoin(u->manager->cgroup_hierarchy, "/", u->id, NULL);
1985 }
1986
1987 int unit_add_cgroup_from_text(Unit *u, const char *name, bool overwrite, CGroupBonding **ret) {
1988 char *controller = NULL, *path = NULL;
1989 CGroupBonding *b = NULL;
1990 bool ours = false;
1991 int r;
1992
1993 assert(u);
1994 assert(name);
1995
1996 r = cg_split_spec(name, &controller, &path);
1997 if (r < 0)
1998 return r;
1999
2000 if (!path) {
2001 path = unit_default_cgroup_path(u);
2002 ours = true;
2003 }
2004
2005 if (!controller) {
2006 controller = strdup(SYSTEMD_CGROUP_CONTROLLER);
2007 ours = true;
2008 }
2009
2010 if (!path || !controller) {
2011 free(path);
2012 free(controller);
2013 return log_oom();
2014 }
2015
2016 b = cgroup_bonding_find_list(u->cgroup_bondings, controller);
2017 if (b) {
2018 if (streq(path, b->path)) {
2019 free(path);
2020 free(controller);
2021
2022 if (ret)
2023 *ret = b;
2024 return 0;
2025 }
2026
2027 if (overwrite && !b->essential) {
2028 free(controller);
2029
2030 free(b->path);
2031 b->path = path;
2032
2033 b->ours = ours;
2034 b->realized = false;
2035
2036 if (ret)
2037 *ret = b;
2038
2039 return 1;
2040 }
2041
2042 r = -EEXIST;
2043 b = NULL;
2044 goto fail;
2045 }
2046
2047 b = new0(CGroupBonding, 1);
2048 if (!b) {
2049 r = -ENOMEM;
2050 goto fail;
2051 }
2052
2053 b->controller = controller;
2054 b->path = path;
2055 b->ours = ours;
2056 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2057
2058 r = unit_add_cgroup(u, b);
2059 if (r < 0)
2060 goto fail;
2061
2062 if (ret)
2063 *ret = b;
2064
2065 return 1;
2066
2067 fail:
2068 free(path);
2069 free(controller);
2070 free(b);
2071
2072 return r;
2073 }
2074
2075 static int unit_add_one_default_cgroup(Unit *u, const char *controller) {
2076 CGroupBonding *b = NULL;
2077 int r = -ENOMEM;
2078
2079 assert(u);
2080
2081 if (!controller)
2082 controller = SYSTEMD_CGROUP_CONTROLLER;
2083
2084 if (cgroup_bonding_find_list(u->cgroup_bondings, controller))
2085 return 0;
2086
2087 b = new0(CGroupBonding, 1);
2088 if (!b)
2089 return -ENOMEM;
2090
2091 b->controller = strdup(controller);
2092 if (!b->controller)
2093 goto fail;
2094
2095 b->path = unit_default_cgroup_path(u);
2096 if (!b->path)
2097 goto fail;
2098
2099 b->ours = true;
2100 b->essential = streq(controller, SYSTEMD_CGROUP_CONTROLLER);
2101
2102 r = unit_add_cgroup(u, b);
2103 if (r < 0)
2104 goto fail;
2105
2106 return 1;
2107
2108 fail:
2109 free(b->path);
2110 free(b->controller);
2111 free(b);
2112
2113 return r;
2114 }
2115
2116 int unit_add_default_cgroups(Unit *u) {
2117 CGroupAttribute *a;
2118 char **c;
2119 int r;
2120
2121 assert(u);
2122
2123 /* Adds in the default cgroups, if they weren't specified
2124 * otherwise. */
2125
2126 if (!u->manager->cgroup_hierarchy)
2127 return 0;
2128
2129 r = unit_add_one_default_cgroup(u, NULL);
2130 if (r < 0)
2131 return r;
2132
2133 STRV_FOREACH(c, u->manager->default_controllers)
2134 unit_add_one_default_cgroup(u, *c);
2135
2136 LIST_FOREACH(by_unit, a, u->cgroup_attributes)
2137 unit_add_one_default_cgroup(u, a->controller);
2138
2139 return 0;
2140 }
2141
2142 CGroupBonding* unit_get_default_cgroup(Unit *u) {
2143 assert(u);
2144
2145 return cgroup_bonding_find_list(u->cgroup_bondings, NULL);
2146 }
2147
2148 int unit_add_cgroup_attribute(
2149 Unit *u,
2150 const CGroupSemantics *semantics,
2151 const char *controller,
2152 const char *name,
2153 const char *value,
2154 CGroupAttribute **ret) {
2155
2156 _cleanup_free_ char *c = NULL;
2157 CGroupAttribute *a;
2158 int r;
2159
2160 assert(u);
2161 assert(value);
2162
2163 if (semantics) {
2164 /* Semantics always take precedence */
2165 if (semantics->name)
2166 name = semantics->name;
2167
2168 if (semantics->controller)
2169 controller = semantics->controller;
2170 }
2171
2172 if (!name)
2173 return -EINVAL;
2174
2175 if (!controller) {
2176 r = cg_controller_from_attr(name, &c);
2177 if (r < 0)
2178 return -EINVAL;
2179
2180 controller = c;
2181 }
2182
2183 if (!controller || streq(controller, SYSTEMD_CGROUP_CONTROLLER))
2184 return -EINVAL;
2185
2186 if (!filename_is_safe(name))
2187 return -EINVAL;
2188
2189 if (!filename_is_safe(controller))
2190 return -EINVAL;
2191
2192 /* Check if this attribute already exists. Note that we will
2193 * explicitly check for the value here too, as there are
2194 * attributes which accept multiple values. */
2195 a = cgroup_attribute_find_list(u->cgroup_attributes, controller, name);
2196 if (a) {
2197 if (streq(value, a->value)) {
2198 /* Exactly the same value is always OK, let's ignore this */
2199 if (ret)
2200 *ret = a;
2201
2202 return 0;
2203 }
2204
2205 if (semantics && !semantics->multiple) {
2206 char *v;
2207
2208 /* If this is a single-item entry, we can
2209 * simply patch the existing attribute */
2210
2211 v = strdup(value);
2212 if (!v)
2213 return -ENOMEM;
2214
2215 free(a->value);
2216 a->value = v;
2217
2218 if (ret)
2219 *ret = a;
2220 return 1;
2221 }
2222 }
2223
2224 a = new0(CGroupAttribute, 1);
2225 if (!a)
2226 return -ENOMEM;
2227
2228 if (c) {
2229 a->controller = c;
2230 c = NULL;
2231 } else
2232 a->controller = strdup(controller);
2233
2234 a->name = strdup(name);
2235 a->value = strdup(value);
2236
2237 if (!a->controller || !a->name || !a->value) {
2238 free(a->controller);
2239 free(a->name);
2240 free(a->value);
2241 free(a);
2242 return -ENOMEM;
2243 }
2244
2245 a->semantics = semantics;
2246 a->unit = u;
2247
2248 LIST_PREPEND(CGroupAttribute, by_unit, u->cgroup_attributes, a);
2249
2250 if (ret)
2251 *ret = a;
2252
2253 return 1;
2254 }
2255
2256 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2257 char *t;
2258 int r;
2259
2260 assert(u);
2261 assert(type);
2262 assert(_found);
2263
2264 if (!(t = unit_name_change_suffix(u->id, type)))
2265 return -ENOMEM;
2266
2267 assert(!unit_has_name(u, t));
2268
2269 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2270 free(t);
2271
2272 assert(r < 0 || *_found != u);
2273
2274 return r;
2275 }
2276
2277 int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
2278 Unit *found;
2279 char *t;
2280
2281 assert(u);
2282 assert(type);
2283 assert(_found);
2284
2285 if (!(t = unit_name_change_suffix(u->id, type)))
2286 return -ENOMEM;
2287
2288 assert(!unit_has_name(u, t));
2289
2290 found = manager_get_unit(u->manager, t);
2291 free(t);
2292
2293 if (!found)
2294 return -ENOENT;
2295
2296 *_found = found;
2297 return 0;
2298 }
2299
2300 int unit_watch_bus_name(Unit *u, const char *name) {
2301 assert(u);
2302 assert(name);
2303
2304 /* Watch a specific name on the bus. We only support one unit
2305 * watching each name for now. */
2306
2307 return hashmap_put(u->manager->watch_bus, name, u);
2308 }
2309
2310 void unit_unwatch_bus_name(Unit *u, const char *name) {
2311 assert(u);
2312 assert(name);
2313
2314 hashmap_remove_value(u->manager->watch_bus, name, u);
2315 }
2316
2317 bool unit_can_serialize(Unit *u) {
2318 assert(u);
2319
2320 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2321 }
2322
2323 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2324 int r;
2325
2326 assert(u);
2327 assert(f);
2328 assert(fds);
2329
2330 if (!unit_can_serialize(u))
2331 return 0;
2332
2333 if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
2334 return r;
2335
2336
2337 if (serialize_jobs) {
2338 if (u->job) {
2339 fprintf(f, "job\n");
2340 job_serialize(u->job, f, fds);
2341 }
2342
2343 if (u->nop_job) {
2344 fprintf(f, "job\n");
2345 job_serialize(u->nop_job, f, fds);
2346 }
2347 }
2348
2349 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2350 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2351 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2352 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2353 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2354
2355 if (dual_timestamp_is_set(&u->condition_timestamp))
2356 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2357
2358 /* End marker */
2359 fputc('\n', f);
2360 return 0;
2361 }
2362
2363 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2364 va_list ap;
2365
2366 assert(u);
2367 assert(f);
2368 assert(key);
2369 assert(format);
2370
2371 fputs(key, f);
2372 fputc('=', f);
2373
2374 va_start(ap, format);
2375 vfprintf(f, format, ap);
2376 va_end(ap);
2377
2378 fputc('\n', f);
2379 }
2380
2381 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2382 assert(u);
2383 assert(f);
2384 assert(key);
2385 assert(value);
2386
2387 fprintf(f, "%s=%s\n", key, value);
2388 }
2389
2390 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2391 int r;
2392
2393 assert(u);
2394 assert(f);
2395 assert(fds);
2396
2397 if (!unit_can_serialize(u))
2398 return 0;
2399
2400 for (;;) {
2401 char line[LINE_MAX], *l, *v;
2402 size_t k;
2403
2404 if (!fgets(line, sizeof(line), f)) {
2405 if (feof(f))
2406 return 0;
2407 return -errno;
2408 }
2409
2410 char_array_0(line);
2411 l = strstrip(line);
2412
2413 /* End marker */
2414 if (l[0] == 0)
2415 return 0;
2416
2417 k = strcspn(l, "=");
2418
2419 if (l[k] == '=') {
2420 l[k] = 0;
2421 v = l+k+1;
2422 } else
2423 v = l+k;
2424
2425 if (streq(l, "job")) {
2426 if (v[0] == '\0') {
2427 /* new-style serialized job */
2428 Job *j = job_new_raw(u);
2429 if (!j)
2430 return -ENOMEM;
2431
2432 r = job_deserialize(j, f, fds);
2433 if (r < 0) {
2434 job_free(j);
2435 return r;
2436 }
2437
2438 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2439 if (r < 0) {
2440 job_free(j);
2441 return r;
2442 }
2443
2444 r = job_install_deserialized(j);
2445 if (r < 0) {
2446 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2447 job_free(j);
2448 return r;
2449 }
2450
2451 if (j->state == JOB_RUNNING)
2452 u->manager->n_running_jobs++;
2453 } else {
2454 /* legacy */
2455 JobType type = job_type_from_string(v);
2456 if (type < 0)
2457 log_debug("Failed to parse job type value %s", v);
2458 else
2459 u->deserialized_job = type;
2460 }
2461 continue;
2462 } else if (streq(l, "inactive-exit-timestamp")) {
2463 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2464 continue;
2465 } else if (streq(l, "active-enter-timestamp")) {
2466 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2467 continue;
2468 } else if (streq(l, "active-exit-timestamp")) {
2469 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2470 continue;
2471 } else if (streq(l, "inactive-enter-timestamp")) {
2472 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2473 continue;
2474 } else if (streq(l, "condition-timestamp")) {
2475 dual_timestamp_deserialize(v, &u->condition_timestamp);
2476 continue;
2477 } else if (streq(l, "condition-result")) {
2478 int b;
2479
2480 if ((b = parse_boolean(v)) < 0)
2481 log_debug("Failed to parse condition result value %s", v);
2482 else
2483 u->condition_result = b;
2484
2485 continue;
2486 }
2487
2488 if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
2489 return r;
2490 }
2491 }
2492
2493 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2494 Unit *device;
2495 char *e;
2496 int r;
2497
2498 assert(u);
2499
2500 if (!what)
2501 return 0;
2502
2503 /* Adds in links to the device node that this unit is based on */
2504
2505 if (!is_device_path(what))
2506 return 0;
2507
2508 e = unit_name_from_path(what, ".device");
2509 if (!e)
2510 return -ENOMEM;
2511
2512 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2513 free(e);
2514 if (r < 0)
2515 return r;
2516
2517 r = unit_add_two_dependencies(u, UNIT_AFTER, UNIT_BINDS_TO, device, true);
2518 if (r < 0)
2519 return r;
2520
2521 if (wants) {
2522 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2523 if (r < 0)
2524 return r;
2525 }
2526
2527 return 0;
2528 }
2529
2530 int unit_coldplug(Unit *u) {
2531 int r;
2532
2533 assert(u);
2534
2535 if (UNIT_VTABLE(u)->coldplug)
2536 if ((r = UNIT_VTABLE(u)->coldplug(u)) < 0)
2537 return r;
2538
2539 if (u->job) {
2540 r = job_coldplug(u->job);
2541 if (r < 0)
2542 return r;
2543 } else if (u->deserialized_job >= 0) {
2544 /* legacy */
2545 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2546 if (r < 0)
2547 return r;
2548
2549 u->deserialized_job = _JOB_TYPE_INVALID;
2550 }
2551
2552 return 0;
2553 }
2554
2555 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2556 manager_status_printf(u->manager, false, status, unit_status_msg_format, unit_description(u));
2557 }
2558
2559 bool unit_need_daemon_reload(Unit *u) {
2560 _cleanup_strv_free_ char **t = NULL;
2561 char **path;
2562 struct stat st;
2563 unsigned loaded_cnt, current_cnt;
2564
2565 assert(u);
2566
2567 if (u->fragment_path) {
2568 zero(st);
2569 if (stat(u->fragment_path, &st) < 0)
2570 /* What, cannot access this anymore? */
2571 return true;
2572
2573 if (u->fragment_mtime > 0 &&
2574 timespec_load(&st.st_mtim) != u->fragment_mtime)
2575 return true;
2576 }
2577
2578 if (u->source_path) {
2579 zero(st);
2580 if (stat(u->source_path, &st) < 0)
2581 return true;
2582
2583 if (u->source_mtime > 0 &&
2584 timespec_load(&st.st_mtim) != u->source_mtime)
2585 return true;
2586 }
2587
2588 t = unit_find_dropin_paths(u);
2589 loaded_cnt = strv_length(t);
2590 current_cnt = strv_length(u->dropin_paths);
2591
2592 if (loaded_cnt == current_cnt) {
2593 if (loaded_cnt == 0)
2594 return false;
2595
2596 if (strv_overlap(u->dropin_paths, t)) {
2597 STRV_FOREACH(path, u->dropin_paths) {
2598 zero(st);
2599 if (stat(*path, &st) < 0)
2600 return true;
2601
2602 if (u->dropin_mtime > 0 &&
2603 timespec_load(&st.st_mtim) > u->dropin_mtime)
2604 return true;
2605 }
2606
2607 return false;
2608 } else
2609 return true;
2610 } else
2611 return true;
2612 }
2613
2614 void unit_reset_failed(Unit *u) {
2615 assert(u);
2616
2617 if (UNIT_VTABLE(u)->reset_failed)
2618 UNIT_VTABLE(u)->reset_failed(u);
2619 }
2620
2621 Unit *unit_following(Unit *u) {
2622 assert(u);
2623
2624 if (UNIT_VTABLE(u)->following)
2625 return UNIT_VTABLE(u)->following(u);
2626
2627 return NULL;
2628 }
2629
2630 bool unit_pending_inactive(Unit *u) {
2631 assert(u);
2632
2633 /* Returns true if the unit is inactive or going down */
2634
2635 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2636 return true;
2637
2638 if (u->job && u->job->type == JOB_STOP)
2639 return true;
2640
2641 return false;
2642 }
2643
2644 bool unit_pending_active(Unit *u) {
2645 assert(u);
2646
2647 /* Returns true if the unit is active or going up */
2648
2649 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2650 return true;
2651
2652 if (u->job &&
2653 (u->job->type == JOB_START ||
2654 u->job->type == JOB_RELOAD_OR_START ||
2655 u->job->type == JOB_RESTART))
2656 return true;
2657
2658 return false;
2659 }
2660
2661 int unit_kill(Unit *u, KillWho w, int signo, DBusError *error) {
2662 assert(u);
2663 assert(w >= 0 && w < _KILL_WHO_MAX);
2664 assert(signo > 0);
2665 assert(signo < _NSIG);
2666
2667 if (!UNIT_VTABLE(u)->kill)
2668 return -ENOTSUP;
2669
2670 return UNIT_VTABLE(u)->kill(u, w, signo, error);
2671 }
2672
2673 int unit_kill_common(
2674 Unit *u,
2675 KillWho who,
2676 int signo,
2677 pid_t main_pid,
2678 pid_t control_pid,
2679 DBusError *error) {
2680
2681 int r = 0;
2682
2683 if (who == KILL_MAIN && main_pid <= 0) {
2684 if (main_pid < 0)
2685 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
2686 else
2687 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
2688 return -ESRCH;
2689 }
2690
2691 if (who == KILL_CONTROL && control_pid <= 0) {
2692 if (control_pid < 0)
2693 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
2694 else
2695 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
2696 return -ESRCH;
2697 }
2698
2699 if (who == KILL_CONTROL || who == KILL_ALL)
2700 if (control_pid > 0)
2701 if (kill(control_pid, signo) < 0)
2702 r = -errno;
2703
2704 if (who == KILL_MAIN || who == KILL_ALL)
2705 if (main_pid > 0)
2706 if (kill(main_pid, signo) < 0)
2707 r = -errno;
2708
2709 if (who == KILL_ALL) {
2710 _cleanup_set_free_ Set *pid_set = NULL;
2711 int q;
2712
2713 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2714 if (!pid_set)
2715 return -ENOMEM;
2716
2717 /* Exclude the control/main pid from being killed via the cgroup */
2718 if (control_pid > 0) {
2719 q = set_put(pid_set, LONG_TO_PTR(control_pid));
2720 if (q < 0)
2721 return q;
2722 }
2723
2724 if (main_pid > 0) {
2725 q = set_put(pid_set, LONG_TO_PTR(main_pid));
2726 if (q < 0)
2727 return q;
2728 }
2729
2730 q = cgroup_bonding_kill_list(u->cgroup_bondings, signo, false, false, pid_set, NULL);
2731 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
2732 r = q;
2733 }
2734
2735 return r;
2736 }
2737
2738 int unit_following_set(Unit *u, Set **s) {
2739 assert(u);
2740 assert(s);
2741
2742 if (UNIT_VTABLE(u)->following_set)
2743 return UNIT_VTABLE(u)->following_set(u, s);
2744
2745 *s = NULL;
2746 return 0;
2747 }
2748
2749 UnitFileState unit_get_unit_file_state(Unit *u) {
2750 assert(u);
2751
2752 if (u->unit_file_state < 0 && u->fragment_path)
2753 u->unit_file_state = unit_file_get_state(
2754 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
2755 NULL, path_get_file_name(u->fragment_path));
2756
2757 return u->unit_file_state;
2758 }
2759
2760 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
2761 assert(ref);
2762 assert(u);
2763
2764 if (ref->unit)
2765 unit_ref_unset(ref);
2766
2767 ref->unit = u;
2768 LIST_PREPEND(UnitRef, refs, u->refs, ref);
2769 return u;
2770 }
2771
2772 void unit_ref_unset(UnitRef *ref) {
2773 assert(ref);
2774
2775 if (!ref->unit)
2776 return;
2777
2778 LIST_REMOVE(UnitRef, refs, ref->unit->refs, ref);
2779 ref->unit = NULL;
2780 }
2781
2782 int unit_add_one_mount_link(Unit *u, Mount *m) {
2783 char **i;
2784
2785 assert(u);
2786 assert(m);
2787
2788 if (u->load_state != UNIT_LOADED ||
2789 UNIT(m)->load_state != UNIT_LOADED)
2790 return 0;
2791
2792 STRV_FOREACH(i, u->requires_mounts_for) {
2793
2794 if (UNIT(m) == u)
2795 continue;
2796
2797 if (!path_startswith(*i, m->where))
2798 continue;
2799
2800 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
2801 }
2802
2803 return 0;
2804 }
2805
2806 int unit_add_mount_links(Unit *u) {
2807 Unit *other;
2808 int r;
2809
2810 assert(u);
2811
2812 LIST_FOREACH(units_by_type, other, u->manager->units_by_type[UNIT_MOUNT]) {
2813 r = unit_add_one_mount_link(u, MOUNT(other));
2814 if (r < 0)
2815 return r;
2816 }
2817
2818 return 0;
2819 }
2820
2821 int unit_exec_context_defaults(Unit *u, ExecContext *c) {
2822 unsigned i;
2823 int r;
2824
2825 assert(u);
2826 assert(c);
2827
2828 /* This only copies in the ones that need memory */
2829
2830 for (i = 0; i < RLIMIT_NLIMITS; i++)
2831 if (u->manager->rlimit[i] && !c->rlimit[i]) {
2832 c->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
2833 if (!c->rlimit[i])
2834 return -ENOMEM;
2835 }
2836
2837 if (u->manager->running_as == SYSTEMD_USER &&
2838 !c->working_directory) {
2839
2840 r = get_home_dir(&c->working_directory);
2841 if (r < 0)
2842 return r;
2843 }
2844
2845 return 0;
2846 }
2847
2848 ExecContext *unit_get_exec_context(Unit *u) {
2849 size_t offset;
2850 assert(u);
2851
2852 offset = UNIT_VTABLE(u)->exec_context_offset;
2853 if (offset <= 0)
2854 return NULL;
2855
2856 return (ExecContext*) ((uint8_t*) u + offset);
2857 }
2858
2859 static int drop_in_file(Unit *u, bool runtime, const char *name, char **_p, char **_q) {
2860 char *p, *q;
2861 int r;
2862
2863 assert(u);
2864 assert(name);
2865 assert(_p);
2866 assert(_q);
2867
2868 if (u->manager->running_as == SYSTEMD_USER && runtime)
2869 return -ENOTSUP;
2870
2871 if (!filename_is_safe(name))
2872 return -EINVAL;
2873
2874 if (u->manager->running_as == SYSTEMD_USER) {
2875 _cleanup_free_ char *c = NULL;
2876
2877 r = user_config_home(&c);
2878 if (r < 0)
2879 return r;
2880 if (r == 0)
2881 return -ENOENT;
2882
2883 p = strjoin(c, "/", u->id, ".d", NULL);
2884 } else if (runtime)
2885 p = strjoin("/run/systemd/system/", u->id, ".d", NULL);
2886 else
2887 p = strjoin("/etc/systemd/system/", u->id, ".d", NULL);
2888 if (!p)
2889 return -ENOMEM;
2890
2891 q = strjoin(p, "/50-", name, ".conf", NULL);
2892 if (!q) {
2893 free(p);
2894 return -ENOMEM;
2895 }
2896
2897 *_p = p;
2898 *_q = q;
2899 return 0;
2900 }
2901
2902 int unit_write_drop_in(Unit *u, bool runtime, const char *name, const char *data) {
2903 _cleanup_free_ char *p = NULL, *q = NULL;
2904 int r;
2905
2906 assert(u);
2907
2908 r = drop_in_file(u, runtime, name, &p, &q);
2909 if (r < 0)
2910 return r;
2911
2912 mkdir_p(p, 0755);
2913 return write_string_file_atomic_label(q, data);
2914 }
2915
2916 int unit_remove_drop_in(Unit *u, bool runtime, const char *name) {
2917 _cleanup_free_ char *p = NULL, *q = NULL;
2918 int r;
2919
2920 assert(u);
2921
2922 r = drop_in_file(u, runtime, name, &p, &q);
2923 if (unlink(q) < 0)
2924 r = -errno;
2925 else
2926 r = 0;
2927
2928 rmdir(p);
2929 return r;
2930 }
2931
2932 int unit_kill_context(
2933 Unit *u,
2934 KillContext *c,
2935 bool sigkill,
2936 pid_t main_pid,
2937 pid_t control_pid,
2938 bool main_pid_alien) {
2939
2940 int sig, wait_for_exit = 0, r;
2941
2942 assert(u);
2943 assert(c);
2944
2945 if (c->kill_mode == KILL_NONE)
2946 return 0;
2947
2948 sig = sigkill ? SIGKILL : c->kill_signal;
2949
2950 if (main_pid > 0) {
2951 r = kill_and_sigcont(main_pid, sig);
2952
2953 if (r < 0 && r != -ESRCH) {
2954 _cleanup_free_ char *comm = NULL;
2955 get_process_comm(main_pid, &comm);
2956
2957 log_warning_unit(u->id, "Failed to kill main process %li (%s): %s",
2958 (long) main_pid, strna(comm), strerror(-r));
2959 } else
2960 wait_for_exit = !main_pid_alien;
2961 }
2962
2963 if (control_pid > 0) {
2964 r = kill_and_sigcont(control_pid, sig);
2965
2966 if (r < 0 && r != -ESRCH) {
2967 _cleanup_free_ char *comm = NULL;
2968 get_process_comm(control_pid, &comm);
2969
2970 log_warning_unit(u->id,
2971 "Failed to kill control process %li (%s): %s",
2972 (long) control_pid, strna(comm), strerror(-r));
2973 } else
2974 wait_for_exit = true;
2975 }
2976
2977 if (c->kill_mode == KILL_CONTROL_GROUP) {
2978 _cleanup_set_free_ Set *pid_set = NULL;
2979
2980 pid_set = set_new(trivial_hash_func, trivial_compare_func);
2981 if (!pid_set)
2982 return -ENOMEM;
2983
2984 /* Exclude the main/control pids from being killed via the cgroup */
2985 if (main_pid > 0) {
2986 r = set_put(pid_set, LONG_TO_PTR(main_pid));
2987 if (r < 0)
2988 return r;
2989 }
2990
2991 if (control_pid > 0) {
2992 r = set_put(pid_set, LONG_TO_PTR(control_pid));
2993 if (r < 0)
2994 return r;
2995 }
2996
2997 r = cgroup_bonding_kill_list(u->cgroup_bondings, sig, true, false, pid_set, NULL);
2998 if (r < 0) {
2999 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3000 log_warning_unit(u->id, "Failed to kill control group: %s", strerror(-r));
3001 } else if (r > 0)
3002 wait_for_exit = true;
3003 }
3004
3005 return wait_for_exit;
3006 }
3007
3008 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3009 [UNIT_ACTIVE] = "active",
3010 [UNIT_RELOADING] = "reloading",
3011 [UNIT_INACTIVE] = "inactive",
3012 [UNIT_FAILED] = "failed",
3013 [UNIT_ACTIVATING] = "activating",
3014 [UNIT_DEACTIVATING] = "deactivating"
3015 };
3016
3017 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
3018
3019 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
3020 [UNIT_REQUIRES] = "Requires",
3021 [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
3022 [UNIT_REQUISITE] = "Requisite",
3023 [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
3024 [UNIT_WANTS] = "Wants",
3025 [UNIT_BINDS_TO] = "BindsTo",
3026 [UNIT_PART_OF] = "PartOf",
3027 [UNIT_REQUIRED_BY] = "RequiredBy",
3028 [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
3029 [UNIT_WANTED_BY] = "WantedBy",
3030 [UNIT_BOUND_BY] = "BoundBy",
3031 [UNIT_CONSISTS_OF] = "ConsistsOf",
3032 [UNIT_CONFLICTS] = "Conflicts",
3033 [UNIT_CONFLICTED_BY] = "ConflictedBy",
3034 [UNIT_BEFORE] = "Before",
3035 [UNIT_AFTER] = "After",
3036 [UNIT_ON_FAILURE] = "OnFailure",
3037 [UNIT_TRIGGERS] = "Triggers",
3038 [UNIT_TRIGGERED_BY] = "TriggeredBy",
3039 [UNIT_PROPAGATES_RELOAD_TO] = "PropagatesReloadTo",
3040 [UNIT_RELOAD_PROPAGATED_FROM] = "ReloadPropagatedFrom",
3041 [UNIT_REFERENCES] = "References",
3042 [UNIT_REFERENCED_BY] = "ReferencedBy",
3043 };
3044
3045 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);
Unnamed repository; edit this file 'description' to name the repository.