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