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