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