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