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