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