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