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