]> 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,network: major per-object logging rework
[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 <errno.h>
23 #include <string.h>
24 #include <stdlib.h>
25 #include <unistd.h>
26 #include <sys/stat.h>
27
28 #include "sd-id128.h"
29 #include "sd-messages.h"
30 #include "set.h"
31 #include "unit.h"
32 #include "macro.h"
33 #include "strv.h"
34 #include "path-util.h"
35 #include "load-fragment.h"
36 #include "load-dropin.h"
37 #include "log.h"
38 #include "unit-name.h"
39 #include "dbus-unit.h"
40 #include "special.h"
41 #include "cgroup-util.h"
42 #include "missing.h"
43 #include "mkdir.h"
44 #include "fileio-label.h"
45 #include "bus-common-errors.h"
46 #include "dbus.h"
47 #include "execute.h"
48 #include "dropin.h"
49 #include "formats-util.h"
50 #include "process-util.h"
51
52 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
53 [UNIT_SERVICE] = &service_vtable,
54 [UNIT_SOCKET] = &socket_vtable,
55 [UNIT_BUSNAME] = &busname_vtable,
56 [UNIT_TARGET] = &target_vtable,
57 [UNIT_SNAPSHOT] = &snapshot_vtable,
58 [UNIT_DEVICE] = &device_vtable,
59 [UNIT_MOUNT] = &mount_vtable,
60 [UNIT_AUTOMOUNT] = &automount_vtable,
61 [UNIT_SWAP] = &swap_vtable,
62 [UNIT_TIMER] = &timer_vtable,
63 [UNIT_PATH] = &path_vtable,
64 [UNIT_SLICE] = &slice_vtable,
65 [UNIT_SCOPE] = &scope_vtable
66 };
67
68 static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency);
69
70 Unit *unit_new(Manager *m, size_t size) {
71 Unit *u;
72
73 assert(m);
74 assert(size >= sizeof(Unit));
75
76 u = malloc0(size);
77 if (!u)
78 return NULL;
79
80 u->names = set_new(&string_hash_ops);
81 if (!u->names) {
82 free(u);
83 return NULL;
84 }
85
86 u->manager = m;
87 u->type = _UNIT_TYPE_INVALID;
88 u->deserialized_job = _JOB_TYPE_INVALID;
89 u->default_dependencies = true;
90 u->unit_file_state = _UNIT_FILE_STATE_INVALID;
91 u->unit_file_preset = -1;
92 u->on_failure_job_mode = JOB_REPLACE;
93
94 return u;
95 }
96
97 bool unit_has_name(Unit *u, const char *name) {
98 assert(u);
99 assert(name);
100
101 return !!set_get(u->names, (char*) name);
102 }
103
104 static void unit_init(Unit *u) {
105 CGroupContext *cc;
106 ExecContext *ec;
107 KillContext *kc;
108
109 assert(u);
110 assert(u->manager);
111 assert(u->type >= 0);
112
113 cc = unit_get_cgroup_context(u);
114 if (cc) {
115 cgroup_context_init(cc);
116
117 /* Copy in the manager defaults into the cgroup
118 * context, _before_ the rest of the settings have
119 * been initialized */
120
121 cc->cpu_accounting = u->manager->default_cpu_accounting;
122 cc->blockio_accounting = u->manager->default_blockio_accounting;
123 cc->memory_accounting = u->manager->default_memory_accounting;
124 }
125
126 ec = unit_get_exec_context(u);
127 if (ec)
128 exec_context_init(ec);
129
130 kc = unit_get_kill_context(u);
131 if (kc)
132 kill_context_init(kc);
133
134 if (UNIT_VTABLE(u)->init)
135 UNIT_VTABLE(u)->init(u);
136 }
137
138 int unit_add_name(Unit *u, const char *text) {
139 _cleanup_free_ char *s = NULL, *i = NULL;
140 UnitType t;
141 int r;
142
143 assert(u);
144 assert(text);
145
146 if (unit_name_is_valid(text, UNIT_NAME_TEMPLATE)) {
147
148 if (!u->instance)
149 return -EINVAL;
150
151 r = unit_name_replace_instance(text, u->instance, &s);
152 if (r < 0)
153 return r;
154 } else {
155 s = strdup(text);
156 if (!s)
157 return -ENOMEM;
158 }
159
160 if (set_contains(u->names, s))
161 return 0;
162 if (hashmap_contains(u->manager->units, s))
163 return -EEXIST;
164
165 if (!unit_name_is_valid(s, UNIT_NAME_PLAIN|UNIT_NAME_INSTANCE))
166 return -EINVAL;
167
168 t = unit_name_to_type(s);
169 if (t < 0)
170 return -EINVAL;
171
172 if (u->type != _UNIT_TYPE_INVALID && t != u->type)
173 return -EINVAL;
174
175 r = unit_name_to_instance(s, &i);
176 if (r < 0)
177 return r;
178
179 if (i && unit_vtable[t]->no_instances)
180 return -EINVAL;
181
182 /* Ensure that this unit is either instanced or not instanced,
183 * but not both. Note that we do allow names with different
184 * instance names however! */
185 if (u->type != _UNIT_TYPE_INVALID && !u->instance != !i)
186 return -EINVAL;
187
188 if (unit_vtable[t]->no_alias && !set_isempty(u->names))
189 return -EEXIST;
190
191 if (hashmap_size(u->manager->units) >= MANAGER_MAX_NAMES)
192 return -E2BIG;
193
194 r = set_put(u->names, s);
195 if (r < 0)
196 return r;
197 assert(r > 0);
198
199 r = hashmap_put(u->manager->units, s, u);
200 if (r < 0) {
201 (void) set_remove(u->names, s);
202 return r;
203 }
204
205 if (u->type == _UNIT_TYPE_INVALID) {
206 u->type = t;
207 u->id = s;
208 u->instance = i;
209
210 LIST_PREPEND(units_by_type, u->manager->units_by_type[t], u);
211
212 unit_init(u);
213
214 i = NULL;
215 }
216
217 s = NULL;
218
219 unit_add_to_dbus_queue(u);
220 return 0;
221 }
222
223 int unit_choose_id(Unit *u, const char *name) {
224 _cleanup_free_ char *t = NULL;
225 char *s, *i;
226 int r;
227
228 assert(u);
229 assert(name);
230
231 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
232
233 if (!u->instance)
234 return -EINVAL;
235
236 r = unit_name_replace_instance(name, u->instance, &t);
237 if (r < 0)
238 return r;
239
240 name = t;
241 }
242
243 /* Selects one of the names of this unit as the id */
244 s = set_get(u->names, (char*) name);
245 if (!s)
246 return -ENOENT;
247
248 /* Determine the new instance from the new id */
249 r = unit_name_to_instance(s, &i);
250 if (r < 0)
251 return r;
252
253 u->id = s;
254
255 free(u->instance);
256 u->instance = i;
257
258 unit_add_to_dbus_queue(u);
259
260 return 0;
261 }
262
263 int unit_set_description(Unit *u, const char *description) {
264 char *s;
265
266 assert(u);
267
268 if (isempty(description))
269 s = NULL;
270 else {
271 s = strdup(description);
272 if (!s)
273 return -ENOMEM;
274 }
275
276 free(u->description);
277 u->description = s;
278
279 unit_add_to_dbus_queue(u);
280 return 0;
281 }
282
283 bool unit_check_gc(Unit *u) {
284 UnitActiveState state;
285 assert(u);
286
287 if (u->job)
288 return true;
289
290 if (u->nop_job)
291 return true;
292
293 state = unit_active_state(u);
294
295 /* If the unit is inactive and failed and no job is queued for
296 * it, then release its runtime resources */
297 if (UNIT_IS_INACTIVE_OR_FAILED(state) &&
298 UNIT_VTABLE(u)->release_resources)
299 UNIT_VTABLE(u)->release_resources(u);
300
301 /* But we keep the unit object around for longer when it is
302 * referenced or configured to not be gc'ed */
303 if (state != UNIT_INACTIVE)
304 return true;
305
306 if (UNIT_VTABLE(u)->no_gc)
307 return true;
308
309 if (u->no_gc)
310 return true;
311
312 if (u->refs)
313 return true;
314
315 if (UNIT_VTABLE(u)->check_gc)
316 if (UNIT_VTABLE(u)->check_gc(u))
317 return true;
318
319 return false;
320 }
321
322 void unit_add_to_load_queue(Unit *u) {
323 assert(u);
324 assert(u->type != _UNIT_TYPE_INVALID);
325
326 if (u->load_state != UNIT_STUB || u->in_load_queue)
327 return;
328
329 LIST_PREPEND(load_queue, u->manager->load_queue, u);
330 u->in_load_queue = true;
331 }
332
333 void unit_add_to_cleanup_queue(Unit *u) {
334 assert(u);
335
336 if (u->in_cleanup_queue)
337 return;
338
339 LIST_PREPEND(cleanup_queue, u->manager->cleanup_queue, u);
340 u->in_cleanup_queue = true;
341 }
342
343 void unit_add_to_gc_queue(Unit *u) {
344 assert(u);
345
346 if (u->in_gc_queue || u->in_cleanup_queue)
347 return;
348
349 if (unit_check_gc(u))
350 return;
351
352 LIST_PREPEND(gc_queue, u->manager->gc_queue, u);
353 u->in_gc_queue = true;
354
355 u->manager->n_in_gc_queue ++;
356 }
357
358 void unit_add_to_dbus_queue(Unit *u) {
359 assert(u);
360 assert(u->type != _UNIT_TYPE_INVALID);
361
362 if (u->load_state == UNIT_STUB || u->in_dbus_queue)
363 return;
364
365 /* Shortcut things if nobody cares */
366 if (sd_bus_track_count(u->manager->subscribed) <= 0 &&
367 set_isempty(u->manager->private_buses)) {
368 u->sent_dbus_new_signal = true;
369 return;
370 }
371
372 LIST_PREPEND(dbus_queue, u->manager->dbus_unit_queue, u);
373 u->in_dbus_queue = true;
374 }
375
376 static void bidi_set_free(Unit *u, Set *s) {
377 Iterator i;
378 Unit *other;
379
380 assert(u);
381
382 /* Frees the set and makes sure we are dropped from the
383 * inverse pointers */
384
385 SET_FOREACH(other, s, i) {
386 UnitDependency d;
387
388 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
389 set_remove(other->dependencies[d], u);
390
391 unit_add_to_gc_queue(other);
392 }
393
394 set_free(s);
395 }
396
397 static void unit_remove_transient(Unit *u) {
398 char **i;
399
400 assert(u);
401
402 if (!u->transient)
403 return;
404
405 if (u->fragment_path)
406 unlink(u->fragment_path);
407
408 STRV_FOREACH(i, u->dropin_paths) {
409 _cleanup_free_ char *p = NULL;
410 int r;
411
412 unlink(*i);
413
414 r = path_get_parent(*i, &p);
415 if (r >= 0)
416 rmdir(p);
417 }
418 }
419
420 static void unit_free_requires_mounts_for(Unit *u) {
421 char **j;
422
423 STRV_FOREACH(j, u->requires_mounts_for) {
424 char s[strlen(*j) + 1];
425
426 PATH_FOREACH_PREFIX_MORE(s, *j) {
427 char *y;
428 Set *x;
429
430 x = hashmap_get2(u->manager->units_requiring_mounts_for, s, (void**) &y);
431 if (!x)
432 continue;
433
434 set_remove(x, u);
435
436 if (set_isempty(x)) {
437 hashmap_remove(u->manager->units_requiring_mounts_for, y);
438 free(y);
439 set_free(x);
440 }
441 }
442 }
443
444 strv_free(u->requires_mounts_for);
445 u->requires_mounts_for = NULL;
446 }
447
448 static void unit_done(Unit *u) {
449 ExecContext *ec;
450 CGroupContext *cc;
451
452 assert(u);
453
454 if (u->type < 0)
455 return;
456
457 if (UNIT_VTABLE(u)->done)
458 UNIT_VTABLE(u)->done(u);
459
460 ec = unit_get_exec_context(u);
461 if (ec)
462 exec_context_done(ec);
463
464 cc = unit_get_cgroup_context(u);
465 if (cc)
466 cgroup_context_done(cc);
467 }
468
469 void unit_free(Unit *u) {
470 UnitDependency d;
471 Iterator i;
472 char *t;
473
474 assert(u);
475
476 if (u->manager->n_reloading <= 0)
477 unit_remove_transient(u);
478
479 bus_unit_send_removed_signal(u);
480
481 unit_done(u);
482
483 unit_free_requires_mounts_for(u);
484
485 SET_FOREACH(t, u->names, i)
486 hashmap_remove_value(u->manager->units, t, u);
487
488 if (u->job) {
489 Job *j = u->job;
490 job_uninstall(j);
491 job_free(j);
492 }
493
494 if (u->nop_job) {
495 Job *j = u->nop_job;
496 job_uninstall(j);
497 job_free(j);
498 }
499
500 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
501 bidi_set_free(u, u->dependencies[d]);
502
503 if (u->type != _UNIT_TYPE_INVALID)
504 LIST_REMOVE(units_by_type, u->manager->units_by_type[u->type], u);
505
506 if (u->in_load_queue)
507 LIST_REMOVE(load_queue, u->manager->load_queue, u);
508
509 if (u->in_dbus_queue)
510 LIST_REMOVE(dbus_queue, u->manager->dbus_unit_queue, u);
511
512 if (u->in_cleanup_queue)
513 LIST_REMOVE(cleanup_queue, u->manager->cleanup_queue, u);
514
515 if (u->in_gc_queue) {
516 LIST_REMOVE(gc_queue, u->manager->gc_queue, u);
517 u->manager->n_in_gc_queue--;
518 }
519
520 if (u->in_cgroup_queue)
521 LIST_REMOVE(cgroup_queue, u->manager->cgroup_queue, u);
522
523 if (u->cgroup_path) {
524 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
525 free(u->cgroup_path);
526 }
527
528 manager_update_failed_units(u->manager, u, false);
529 set_remove(u->manager->startup_units, u);
530
531 free(u->description);
532 strv_free(u->documentation);
533 free(u->fragment_path);
534 free(u->source_path);
535 strv_free(u->dropin_paths);
536 free(u->instance);
537
538 free(u->job_timeout_reboot_arg);
539
540 set_free_free(u->names);
541
542 unit_unwatch_all_pids(u);
543
544 condition_free_list(u->conditions);
545 condition_free_list(u->asserts);
546
547 unit_ref_unset(&u->slice);
548
549 while (u->refs)
550 unit_ref_unset(u->refs);
551
552 free(u);
553 }
554
555 UnitActiveState unit_active_state(Unit *u) {
556 assert(u);
557
558 if (u->load_state == UNIT_MERGED)
559 return unit_active_state(unit_follow_merge(u));
560
561 /* After a reload it might happen that a unit is not correctly
562 * loaded but still has a process around. That's why we won't
563 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
564
565 return UNIT_VTABLE(u)->active_state(u);
566 }
567
568 const char* unit_sub_state_to_string(Unit *u) {
569 assert(u);
570
571 return UNIT_VTABLE(u)->sub_state_to_string(u);
572 }
573
574 static int complete_move(Set **s, Set **other) {
575 int r;
576
577 assert(s);
578 assert(other);
579
580 if (!*other)
581 return 0;
582
583 if (*s) {
584 r = set_move(*s, *other);
585 if (r < 0)
586 return r;
587 } else {
588 *s = *other;
589 *other = NULL;
590 }
591
592 return 0;
593 }
594
595 static int merge_names(Unit *u, Unit *other) {
596 char *t;
597 Iterator i;
598 int r;
599
600 assert(u);
601 assert(other);
602
603 r = complete_move(&u->names, &other->names);
604 if (r < 0)
605 return r;
606
607 set_free_free(other->names);
608 other->names = NULL;
609 other->id = NULL;
610
611 SET_FOREACH(t, u->names, i)
612 assert_se(hashmap_replace(u->manager->units, t, u) == 0);
613
614 return 0;
615 }
616
617 static int reserve_dependencies(Unit *u, Unit *other, UnitDependency d) {
618 unsigned n_reserve;
619
620 assert(u);
621 assert(other);
622 assert(d < _UNIT_DEPENDENCY_MAX);
623
624 /*
625 * If u does not have this dependency set allocated, there is no need
626 * to reserve anything. In that case other's set will be transferred
627 * as a whole to u by complete_move().
628 */
629 if (!u->dependencies[d])
630 return 0;
631
632 /* merge_dependencies() will skip a u-on-u dependency */
633 n_reserve = set_size(other->dependencies[d]) - !!set_get(other->dependencies[d], u);
634
635 return set_reserve(u->dependencies[d], n_reserve);
636 }
637
638 static void merge_dependencies(Unit *u, Unit *other, const char *other_id, UnitDependency d) {
639 Iterator i;
640 Unit *back;
641 int r;
642
643 assert(u);
644 assert(other);
645 assert(d < _UNIT_DEPENDENCY_MAX);
646
647 /* Fix backwards pointers */
648 SET_FOREACH(back, other->dependencies[d], i) {
649 UnitDependency k;
650
651 for (k = 0; k < _UNIT_DEPENDENCY_MAX; k++) {
652 /* Do not add dependencies between u and itself */
653 if (back == u) {
654 if (set_remove(back->dependencies[k], other))
655 maybe_warn_about_dependency(u, other_id, k);
656 } else {
657 r = set_remove_and_put(back->dependencies[k], other, u);
658 if (r == -EEXIST)
659 set_remove(back->dependencies[k], other);
660 else
661 assert(r >= 0 || r == -ENOENT);
662 }
663 }
664 }
665
666 /* Also do not move dependencies on u to itself */
667 back = set_remove(other->dependencies[d], u);
668 if (back)
669 maybe_warn_about_dependency(u, other_id, d);
670
671 /* The move cannot fail. The caller must have performed a reservation. */
672 assert_se(complete_move(&u->dependencies[d], &other->dependencies[d]) == 0);
673
674 set_free(other->dependencies[d]);
675 other->dependencies[d] = NULL;
676 }
677
678 int unit_merge(Unit *u, Unit *other) {
679 UnitDependency d;
680 const char *other_id = NULL;
681 int r;
682
683 assert(u);
684 assert(other);
685 assert(u->manager == other->manager);
686 assert(u->type != _UNIT_TYPE_INVALID);
687
688 other = unit_follow_merge(other);
689
690 if (other == u)
691 return 0;
692
693 if (u->type != other->type)
694 return -EINVAL;
695
696 if (!u->instance != !other->instance)
697 return -EINVAL;
698
699 if (other->load_state != UNIT_STUB &&
700 other->load_state != UNIT_NOT_FOUND)
701 return -EEXIST;
702
703 if (other->job)
704 return -EEXIST;
705
706 if (other->nop_job)
707 return -EEXIST;
708
709 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
710 return -EEXIST;
711
712 if (other->id)
713 other_id = strdupa(other->id);
714
715 /* Make reservations to ensure merge_dependencies() won't fail */
716 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
717 r = reserve_dependencies(u, other, d);
718 /*
719 * We don't rollback reservations if we fail. We don't have
720 * a way to undo reservations. A reservation is not a leak.
721 */
722 if (r < 0)
723 return r;
724 }
725
726 /* Merge names */
727 r = merge_names(u, other);
728 if (r < 0)
729 return r;
730
731 /* Redirect all references */
732 while (other->refs)
733 unit_ref_set(other->refs, u);
734
735 /* Merge dependencies */
736 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
737 merge_dependencies(u, other, other_id, d);
738
739 other->load_state = UNIT_MERGED;
740 other->merged_into = u;
741
742 /* If there is still some data attached to the other node, we
743 * don't need it anymore, and can free it. */
744 if (other->load_state != UNIT_STUB)
745 if (UNIT_VTABLE(other)->done)
746 UNIT_VTABLE(other)->done(other);
747
748 unit_add_to_dbus_queue(u);
749 unit_add_to_cleanup_queue(other);
750
751 return 0;
752 }
753
754 int unit_merge_by_name(Unit *u, const char *name) {
755 Unit *other;
756 int r;
757 _cleanup_free_ char *s = NULL;
758
759 assert(u);
760 assert(name);
761
762 if (unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
763 if (!u->instance)
764 return -EINVAL;
765
766 r = unit_name_replace_instance(name, u->instance, &s);
767 if (r < 0)
768 return r;
769
770 name = s;
771 }
772
773 other = manager_get_unit(u->manager, name);
774 if (other)
775 return unit_merge(u, other);
776
777 return unit_add_name(u, name);
778 }
779
780 Unit* unit_follow_merge(Unit *u) {
781 assert(u);
782
783 while (u->load_state == UNIT_MERGED)
784 assert_se(u = u->merged_into);
785
786 return u;
787 }
788
789 int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
790 int r;
791
792 assert(u);
793 assert(c);
794
795 if (c->working_directory) {
796 r = unit_require_mounts_for(u, c->working_directory);
797 if (r < 0)
798 return r;
799 }
800
801 if (c->root_directory) {
802 r = unit_require_mounts_for(u, c->root_directory);
803 if (r < 0)
804 return r;
805 }
806
807 if (u->manager->running_as != SYSTEMD_SYSTEM)
808 return 0;
809
810 if (c->private_tmp) {
811 r = unit_require_mounts_for(u, "/tmp");
812 if (r < 0)
813 return r;
814
815 r = unit_require_mounts_for(u, "/var/tmp");
816 if (r < 0)
817 return r;
818 }
819
820 if (c->std_output != EXEC_OUTPUT_KMSG &&
821 c->std_output != EXEC_OUTPUT_SYSLOG &&
822 c->std_output != EXEC_OUTPUT_JOURNAL &&
823 c->std_output != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
824 c->std_output != EXEC_OUTPUT_SYSLOG_AND_CONSOLE &&
825 c->std_output != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
826 c->std_error != EXEC_OUTPUT_KMSG &&
827 c->std_error != EXEC_OUTPUT_SYSLOG &&
828 c->std_error != EXEC_OUTPUT_JOURNAL &&
829 c->std_error != EXEC_OUTPUT_KMSG_AND_CONSOLE &&
830 c->std_error != EXEC_OUTPUT_JOURNAL_AND_CONSOLE &&
831 c->std_error != EXEC_OUTPUT_SYSLOG_AND_CONSOLE)
832 return 0;
833
834 /* If syslog or kernel logging is requested, make sure our own
835 * logging daemon is run first. */
836
837 r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_JOURNALD_SOCKET, NULL, true);
838 if (r < 0)
839 return r;
840
841 return 0;
842 }
843
844 const char *unit_description(Unit *u) {
845 assert(u);
846
847 if (u->description)
848 return u->description;
849
850 return strna(u->id);
851 }
852
853 void unit_dump(Unit *u, FILE *f, const char *prefix) {
854 char *t, **j;
855 UnitDependency d;
856 Iterator i;
857 const char *prefix2;
858 char
859 timestamp1[FORMAT_TIMESTAMP_MAX],
860 timestamp2[FORMAT_TIMESTAMP_MAX],
861 timestamp3[FORMAT_TIMESTAMP_MAX],
862 timestamp4[FORMAT_TIMESTAMP_MAX],
863 timespan[FORMAT_TIMESPAN_MAX];
864 Unit *following;
865 _cleanup_set_free_ Set *following_set = NULL;
866 int r;
867
868 assert(u);
869 assert(u->type >= 0);
870
871 prefix = strempty(prefix);
872 prefix2 = strjoina(prefix, "\t");
873
874 fprintf(f,
875 "%s-> Unit %s:\n"
876 "%s\tDescription: %s\n"
877 "%s\tInstance: %s\n"
878 "%s\tUnit Load State: %s\n"
879 "%s\tUnit Active State: %s\n"
880 "%s\tInactive Exit Timestamp: %s\n"
881 "%s\tActive Enter Timestamp: %s\n"
882 "%s\tActive Exit Timestamp: %s\n"
883 "%s\tInactive Enter Timestamp: %s\n"
884 "%s\tGC Check Good: %s\n"
885 "%s\tNeed Daemon Reload: %s\n"
886 "%s\tTransient: %s\n"
887 "%s\tSlice: %s\n"
888 "%s\tCGroup: %s\n"
889 "%s\tCGroup realized: %s\n"
890 "%s\tCGroup mask: 0x%x\n"
891 "%s\tCGroup members mask: 0x%x\n",
892 prefix, u->id,
893 prefix, unit_description(u),
894 prefix, strna(u->instance),
895 prefix, unit_load_state_to_string(u->load_state),
896 prefix, unit_active_state_to_string(unit_active_state(u)),
897 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->inactive_exit_timestamp.realtime)),
898 prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->active_enter_timestamp.realtime)),
899 prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->active_exit_timestamp.realtime)),
900 prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->inactive_enter_timestamp.realtime)),
901 prefix, yes_no(unit_check_gc(u)),
902 prefix, yes_no(unit_need_daemon_reload(u)),
903 prefix, yes_no(u->transient),
904 prefix, strna(unit_slice_name(u)),
905 prefix, strna(u->cgroup_path),
906 prefix, yes_no(u->cgroup_realized),
907 prefix, u->cgroup_realized_mask,
908 prefix, u->cgroup_members_mask);
909
910 SET_FOREACH(t, u->names, i)
911 fprintf(f, "%s\tName: %s\n", prefix, t);
912
913 STRV_FOREACH(j, u->documentation)
914 fprintf(f, "%s\tDocumentation: %s\n", prefix, *j);
915
916 following = unit_following(u);
917 if (following)
918 fprintf(f, "%s\tFollowing: %s\n", prefix, following->id);
919
920 r = unit_following_set(u, &following_set);
921 if (r >= 0) {
922 Unit *other;
923
924 SET_FOREACH(other, following_set, i)
925 fprintf(f, "%s\tFollowing Set Member: %s\n", prefix, other->id);
926 }
927
928 if (u->fragment_path)
929 fprintf(f, "%s\tFragment Path: %s\n", prefix, u->fragment_path);
930
931 if (u->source_path)
932 fprintf(f, "%s\tSource Path: %s\n", prefix, u->source_path);
933
934 STRV_FOREACH(j, u->dropin_paths)
935 fprintf(f, "%s\tDropIn Path: %s\n", prefix, *j);
936
937 if (u->job_timeout > 0)
938 fprintf(f, "%s\tJob Timeout: %s\n", prefix, format_timespan(timespan, sizeof(timespan), u->job_timeout, 0));
939
940 if (u->job_timeout_action != FAILURE_ACTION_NONE)
941 fprintf(f, "%s\tJob Timeout Action: %s\n", prefix, failure_action_to_string(u->job_timeout_action));
942
943 if (u->job_timeout_reboot_arg)
944 fprintf(f, "%s\tJob Timeout Reboot Argument: %s\n", prefix, u->job_timeout_reboot_arg);
945
946 condition_dump_list(u->conditions, f, prefix, condition_type_to_string);
947 condition_dump_list(u->asserts, f, prefix, assert_type_to_string);
948
949 if (dual_timestamp_is_set(&u->condition_timestamp))
950 fprintf(f,
951 "%s\tCondition Timestamp: %s\n"
952 "%s\tCondition Result: %s\n",
953 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->condition_timestamp.realtime)),
954 prefix, yes_no(u->condition_result));
955
956 if (dual_timestamp_is_set(&u->assert_timestamp))
957 fprintf(f,
958 "%s\tAssert Timestamp: %s\n"
959 "%s\tAssert Result: %s\n",
960 prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->assert_timestamp.realtime)),
961 prefix, yes_no(u->assert_result));
962
963 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
964 Unit *other;
965
966 SET_FOREACH(other, u->dependencies[d], i)
967 fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->id);
968 }
969
970 if (!strv_isempty(u->requires_mounts_for)) {
971 fprintf(f,
972 "%s\tRequiresMountsFor:", prefix);
973
974 STRV_FOREACH(j, u->requires_mounts_for)
975 fprintf(f, " %s", *j);
976
977 fputs("\n", f);
978 }
979
980 if (u->load_state == UNIT_LOADED) {
981
982 fprintf(f,
983 "%s\tStopWhenUnneeded: %s\n"
984 "%s\tRefuseManualStart: %s\n"
985 "%s\tRefuseManualStop: %s\n"
986 "%s\tDefaultDependencies: %s\n"
987 "%s\tOnFailureJobMode: %s\n"
988 "%s\tIgnoreOnIsolate: %s\n"
989 "%s\tIgnoreOnSnapshot: %s\n",
990 prefix, yes_no(u->stop_when_unneeded),
991 prefix, yes_no(u->refuse_manual_start),
992 prefix, yes_no(u->refuse_manual_stop),
993 prefix, yes_no(u->default_dependencies),
994 prefix, job_mode_to_string(u->on_failure_job_mode),
995 prefix, yes_no(u->ignore_on_isolate),
996 prefix, yes_no(u->ignore_on_snapshot));
997
998 if (UNIT_VTABLE(u)->dump)
999 UNIT_VTABLE(u)->dump(u, f, prefix2);
1000
1001 } else if (u->load_state == UNIT_MERGED)
1002 fprintf(f,
1003 "%s\tMerged into: %s\n",
1004 prefix, u->merged_into->id);
1005 else if (u->load_state == UNIT_ERROR)
1006 fprintf(f, "%s\tLoad Error Code: %s\n", prefix, strerror(-u->load_error));
1007
1008
1009 if (u->job)
1010 job_dump(u->job, f, prefix2);
1011
1012 if (u->nop_job)
1013 job_dump(u->nop_job, f, prefix2);
1014
1015 }
1016
1017 /* Common implementation for multiple backends */
1018 int unit_load_fragment_and_dropin(Unit *u) {
1019 int r;
1020
1021 assert(u);
1022
1023 /* Load a .{service,socket,...} file */
1024 r = unit_load_fragment(u);
1025 if (r < 0)
1026 return r;
1027
1028 if (u->load_state == UNIT_STUB)
1029 return -ENOENT;
1030
1031 /* Load drop-in directory data */
1032 r = unit_load_dropin(unit_follow_merge(u));
1033 if (r < 0)
1034 return r;
1035
1036 return 0;
1037 }
1038
1039 /* Common implementation for multiple backends */
1040 int unit_load_fragment_and_dropin_optional(Unit *u) {
1041 int r;
1042
1043 assert(u);
1044
1045 /* Same as unit_load_fragment_and_dropin(), but whether
1046 * something can be loaded or not doesn't matter. */
1047
1048 /* Load a .service file */
1049 r = unit_load_fragment(u);
1050 if (r < 0)
1051 return r;
1052
1053 if (u->load_state == UNIT_STUB)
1054 u->load_state = UNIT_LOADED;
1055
1056 /* Load drop-in directory data */
1057 r = unit_load_dropin(unit_follow_merge(u));
1058 if (r < 0)
1059 return r;
1060
1061 return 0;
1062 }
1063
1064 int unit_add_default_target_dependency(Unit *u, Unit *target) {
1065 assert(u);
1066 assert(target);
1067
1068 if (target->type != UNIT_TARGET)
1069 return 0;
1070
1071 /* Only add the dependency if both units are loaded, so that
1072 * that loop check below is reliable */
1073 if (u->load_state != UNIT_LOADED ||
1074 target->load_state != UNIT_LOADED)
1075 return 0;
1076
1077 /* If either side wants no automatic dependencies, then let's
1078 * skip this */
1079 if (!u->default_dependencies ||
1080 !target->default_dependencies)
1081 return 0;
1082
1083 /* Don't create loops */
1084 if (set_get(target->dependencies[UNIT_BEFORE], u))
1085 return 0;
1086
1087 return unit_add_dependency(target, UNIT_AFTER, u, true);
1088 }
1089
1090 static int unit_add_target_dependencies(Unit *u) {
1091
1092 static const UnitDependency deps[] = {
1093 UNIT_REQUIRED_BY,
1094 UNIT_REQUIRED_BY_OVERRIDABLE,
1095 UNIT_WANTED_BY,
1096 UNIT_BOUND_BY
1097 };
1098
1099 Unit *target;
1100 Iterator i;
1101 unsigned k;
1102 int r = 0;
1103
1104 assert(u);
1105
1106 for (k = 0; k < ELEMENTSOF(deps); k++)
1107 SET_FOREACH(target, u->dependencies[deps[k]], i) {
1108 r = unit_add_default_target_dependency(u, target);
1109 if (r < 0)
1110 return r;
1111 }
1112
1113 return r;
1114 }
1115
1116 static int unit_add_slice_dependencies(Unit *u) {
1117 assert(u);
1118
1119 if (!unit_get_cgroup_context(u))
1120 return 0;
1121
1122 if (UNIT_ISSET(u->slice))
1123 return unit_add_two_dependencies(u, UNIT_AFTER, UNIT_WANTS, UNIT_DEREF(u->slice), true);
1124
1125 if (streq(u->id, SPECIAL_ROOT_SLICE))
1126 return 0;
1127
1128 return unit_add_two_dependencies_by_name(u, UNIT_AFTER, UNIT_WANTS, SPECIAL_ROOT_SLICE, NULL, true);
1129 }
1130
1131 static int unit_add_mount_dependencies(Unit *u) {
1132 char **i;
1133 int r;
1134
1135 assert(u);
1136
1137 STRV_FOREACH(i, u->requires_mounts_for) {
1138 char prefix[strlen(*i) + 1];
1139
1140 PATH_FOREACH_PREFIX_MORE(prefix, *i) {
1141 Unit *m;
1142
1143 r = manager_get_unit_by_path(u->manager, prefix, ".mount", &m);
1144 if (r < 0)
1145 return r;
1146 if (r == 0)
1147 continue;
1148 if (m == u)
1149 continue;
1150
1151 if (m->load_state != UNIT_LOADED)
1152 continue;
1153
1154 r = unit_add_dependency(u, UNIT_AFTER, m, true);
1155 if (r < 0)
1156 return r;
1157
1158 if (m->fragment_path) {
1159 r = unit_add_dependency(u, UNIT_REQUIRES, m, true);
1160 if (r < 0)
1161 return r;
1162 }
1163 }
1164 }
1165
1166 return 0;
1167 }
1168
1169 static int unit_add_startup_units(Unit *u) {
1170 CGroupContext *c;
1171
1172 c = unit_get_cgroup_context(u);
1173 if (!c)
1174 return 0;
1175
1176 if (c->startup_cpu_shares == (unsigned long) -1 &&
1177 c->startup_blockio_weight == (unsigned long) -1)
1178 return 0;
1179
1180 return set_put(u->manager->startup_units, u);
1181 }
1182
1183 int unit_load(Unit *u) {
1184 int r;
1185
1186 assert(u);
1187
1188 if (u->in_load_queue) {
1189 LIST_REMOVE(load_queue, u->manager->load_queue, u);
1190 u->in_load_queue = false;
1191 }
1192
1193 if (u->type == _UNIT_TYPE_INVALID)
1194 return -EINVAL;
1195
1196 if (u->load_state != UNIT_STUB)
1197 return 0;
1198
1199 if (UNIT_VTABLE(u)->load) {
1200 r = UNIT_VTABLE(u)->load(u);
1201 if (r < 0)
1202 goto fail;
1203 }
1204
1205 if (u->load_state == UNIT_STUB) {
1206 r = -ENOENT;
1207 goto fail;
1208 }
1209
1210 if (u->load_state == UNIT_LOADED) {
1211
1212 r = unit_add_target_dependencies(u);
1213 if (r < 0)
1214 goto fail;
1215
1216 r = unit_add_slice_dependencies(u);
1217 if (r < 0)
1218 goto fail;
1219
1220 r = unit_add_mount_dependencies(u);
1221 if (r < 0)
1222 goto fail;
1223
1224 r = unit_add_startup_units(u);
1225 if (r < 0)
1226 goto fail;
1227
1228 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
1229 log_unit_error(u, "More than one OnFailure= dependencies specified but OnFailureJobMode=isolate set. Refusing.");
1230 r = -EINVAL;
1231 goto fail;
1232 }
1233
1234 unit_update_cgroup_members_masks(u);
1235 }
1236
1237 assert((u->load_state != UNIT_MERGED) == !u->merged_into);
1238
1239 unit_add_to_dbus_queue(unit_follow_merge(u));
1240 unit_add_to_gc_queue(u);
1241
1242 return 0;
1243
1244 fail:
1245 u->load_state = u->load_state == UNIT_STUB ? UNIT_NOT_FOUND : UNIT_ERROR;
1246 u->load_error = r;
1247 unit_add_to_dbus_queue(u);
1248 unit_add_to_gc_queue(u);
1249
1250 log_unit_debug_errno(u, r, "Failed to load configuration: %m");
1251
1252 return r;
1253 }
1254
1255 static bool unit_condition_test_list(Unit *u, Condition *first, const char *(*to_string)(ConditionType t)) {
1256 Condition *c;
1257 int triggered = -1;
1258
1259 assert(u);
1260 assert(to_string);
1261
1262 /* If the condition list is empty, then it is true */
1263 if (!first)
1264 return true;
1265
1266 /* Otherwise, if all of the non-trigger conditions apply and
1267 * if any of the trigger conditions apply (unless there are
1268 * none) we return true */
1269 LIST_FOREACH(conditions, c, first) {
1270 int r;
1271
1272 r = condition_test(c);
1273 if (r < 0)
1274 log_unit_warning(u,
1275 "Couldn't determine result for %s=%s%s%s, assuming failed: %m",
1276 to_string(c->type),
1277 c->trigger ? "|" : "",
1278 c->negate ? "!" : "",
1279 c->parameter);
1280 else
1281 log_unit_debug(u,
1282 "%s=%s%s%s %s.",
1283 to_string(c->type),
1284 c->trigger ? "|" : "",
1285 c->negate ? "!" : "",
1286 c->parameter,
1287 condition_result_to_string(c->result));
1288
1289 if (!c->trigger && r <= 0)
1290 return false;
1291
1292 if (c->trigger && triggered <= 0)
1293 triggered = r > 0;
1294 }
1295
1296 return triggered != 0;
1297 }
1298
1299 static bool unit_condition_test(Unit *u) {
1300 assert(u);
1301
1302 dual_timestamp_get(&u->condition_timestamp);
1303 u->condition_result = unit_condition_test_list(u, u->conditions, condition_type_to_string);
1304
1305 return u->condition_result;
1306 }
1307
1308 static bool unit_assert_test(Unit *u) {
1309 assert(u);
1310
1311 dual_timestamp_get(&u->assert_timestamp);
1312 u->assert_result = unit_condition_test_list(u, u->asserts, assert_type_to_string);
1313
1314 return u->assert_result;
1315 }
1316
1317 _pure_ static const char* unit_get_status_message_format(Unit *u, JobType t) {
1318 const UnitStatusMessageFormats *format_table;
1319
1320 assert(u);
1321 assert(t >= 0);
1322 assert(t < _JOB_TYPE_MAX);
1323
1324 if (t != JOB_START && t != JOB_STOP)
1325 return NULL;
1326
1327 format_table = &UNIT_VTABLE(u)->status_message_formats;
1328 if (!format_table)
1329 return NULL;
1330
1331 return format_table->starting_stopping[t == JOB_STOP];
1332 }
1333
1334 _pure_ static const char *unit_get_status_message_format_try_harder(Unit *u, JobType t) {
1335 const char *format;
1336
1337 assert(u);
1338 assert(t >= 0);
1339 assert(t < _JOB_TYPE_MAX);
1340
1341 format = unit_get_status_message_format(u, t);
1342 if (format)
1343 return format;
1344
1345 /* Return generic strings */
1346 if (t == JOB_START)
1347 return "Starting %s.";
1348 else if (t == JOB_STOP)
1349 return "Stopping %s.";
1350 else if (t == JOB_RELOAD)
1351 return "Reloading %s.";
1352
1353 return NULL;
1354 }
1355
1356 static void unit_status_print_starting_stopping(Unit *u, JobType t) {
1357 const char *format;
1358
1359 assert(u);
1360
1361 /* We only print status messages for selected units on
1362 * selected operations. */
1363
1364 format = unit_get_status_message_format(u, t);
1365 if (!format)
1366 return;
1367
1368 DISABLE_WARNING_FORMAT_NONLITERAL;
1369 unit_status_printf(u, "", format);
1370 REENABLE_WARNING;
1371 }
1372
1373 static void unit_status_log_starting_stopping_reloading(Unit *u, JobType t) {
1374 const char *format;
1375 char buf[LINE_MAX];
1376 sd_id128_t mid;
1377
1378 assert(u);
1379
1380 if (t != JOB_START && t != JOB_STOP && t != JOB_RELOAD)
1381 return;
1382
1383 if (log_on_console())
1384 return;
1385
1386 /* We log status messages for all units and all operations. */
1387
1388 format = unit_get_status_message_format_try_harder(u, t);
1389 if (!format)
1390 return;
1391
1392 DISABLE_WARNING_FORMAT_NONLITERAL;
1393 snprintf(buf, sizeof(buf), format, unit_description(u));
1394 REENABLE_WARNING;
1395
1396 mid = t == JOB_START ? SD_MESSAGE_UNIT_STARTING :
1397 t == JOB_STOP ? SD_MESSAGE_UNIT_STOPPING :
1398 SD_MESSAGE_UNIT_RELOADING;
1399
1400 /* Note that we deliberately use LOG_MESSAGE() instead of
1401 * LOG_UNIT_MESSAGE() here, since this is supposed to mimic
1402 * closely what is written to screen using the status output,
1403 * which is supposed the highest level, friendliest output
1404 * possible, which means we should avoid the low-level unit
1405 * name. */
1406 log_struct(LOG_INFO,
1407 LOG_MESSAGE_ID(mid),
1408 LOG_UNIT_ID(u),
1409 LOG_MESSAGE("%s", buf),
1410 NULL);
1411 }
1412
1413 /* Errors:
1414 * -EBADR: This unit type does not support starting.
1415 * -EALREADY: Unit is already started.
1416 * -EAGAIN: An operation is already in progress. Retry later.
1417 * -ECANCELED: Too many requests for now.
1418 * -EPROTO: Assert failed
1419 */
1420 int unit_start(Unit *u) {
1421 UnitActiveState state;
1422 Unit *following;
1423 int r;
1424
1425 assert(u);
1426
1427 if (u->load_state != UNIT_LOADED)
1428 return -EINVAL;
1429
1430 /* If this is already started, then this will succeed. Note
1431 * that this will even succeed if this unit is not startable
1432 * by the user. This is relied on to detect when we need to
1433 * wait for units and when waiting is finished. */
1434 state = unit_active_state(u);
1435 if (UNIT_IS_ACTIVE_OR_RELOADING(state))
1436 return -EALREADY;
1437
1438 /* If the conditions failed, don't do anything at all. If we
1439 * already are activating this call might still be useful to
1440 * speed up activation in case there is some hold-off time,
1441 * but we don't want to recheck the condition in that case. */
1442 if (state != UNIT_ACTIVATING &&
1443 !unit_condition_test(u)) {
1444 log_unit_debug(u, "Starting requested but condition failed. Not starting unit.");
1445 return -EALREADY;
1446 }
1447
1448 /* If the asserts failed, fail the entire job */
1449 if (state != UNIT_ACTIVATING &&
1450 !unit_assert_test(u)) {
1451 log_unit_notice(u, "Starting requested but asserts failed.");
1452 return -EPROTO;
1453 }
1454
1455 /* Forward to the main object, if we aren't it. */
1456 following = unit_following(u);
1457 if (following) {
1458 log_unit_debug(u, "Redirecting start request from %s to %s.", u->id, following->id);
1459 return unit_start(following);
1460 }
1461
1462 if (!unit_supported(u))
1463 return -EOPNOTSUPP;
1464
1465 /* If it is stopped, but we cannot start it, then fail */
1466 if (!UNIT_VTABLE(u)->start)
1467 return -EBADR;
1468
1469 /* We don't suppress calls to ->start() here when we are
1470 * already starting, to allow this request to be used as a
1471 * "hurry up" call, for example when the unit is in some "auto
1472 * restart" state where it waits for a holdoff timer to elapse
1473 * before it will start again. */
1474
1475 unit_add_to_dbus_queue(u);
1476
1477 r = UNIT_VTABLE(u)->start(u);
1478 if (r <= 0)
1479 return r;
1480
1481 /* Log if the start function actually did something */
1482 unit_status_log_starting_stopping_reloading(u, JOB_START);
1483 unit_status_print_starting_stopping(u, JOB_START);
1484 return r;
1485 }
1486
1487 bool unit_can_start(Unit *u) {
1488 assert(u);
1489
1490 return !!UNIT_VTABLE(u)->start;
1491 }
1492
1493 bool unit_can_isolate(Unit *u) {
1494 assert(u);
1495
1496 return unit_can_start(u) &&
1497 u->allow_isolate;
1498 }
1499
1500 /* Errors:
1501 * -EBADR: This unit type does not support stopping.
1502 * -EALREADY: Unit is already stopped.
1503 * -EAGAIN: An operation is already in progress. Retry later.
1504 */
1505 int unit_stop(Unit *u) {
1506 UnitActiveState state;
1507 Unit *following;
1508 int r;
1509
1510 assert(u);
1511
1512 state = unit_active_state(u);
1513 if (UNIT_IS_INACTIVE_OR_FAILED(state))
1514 return -EALREADY;
1515
1516 following = unit_following(u);
1517 if (following) {
1518 log_unit_debug(u, "Redirecting stop request from %s to %s.", u->id, following->id);
1519 return unit_stop(following);
1520 }
1521
1522 if (!UNIT_VTABLE(u)->stop)
1523 return -EBADR;
1524
1525 unit_add_to_dbus_queue(u);
1526
1527 r = UNIT_VTABLE(u)->stop(u);
1528 if (r <= 0)
1529 return r;
1530
1531 unit_status_log_starting_stopping_reloading(u, JOB_STOP);
1532 unit_status_print_starting_stopping(u, JOB_STOP);
1533 return r;
1534 }
1535
1536 /* Errors:
1537 * -EBADR: This unit type does not support reloading.
1538 * -ENOEXEC: Unit is not started.
1539 * -EAGAIN: An operation is already in progress. Retry later.
1540 */
1541 int unit_reload(Unit *u) {
1542 UnitActiveState state;
1543 Unit *following;
1544 int r;
1545
1546 assert(u);
1547
1548 if (u->load_state != UNIT_LOADED)
1549 return -EINVAL;
1550
1551 if (!unit_can_reload(u))
1552 return -EBADR;
1553
1554 state = unit_active_state(u);
1555 if (state == UNIT_RELOADING)
1556 return -EALREADY;
1557
1558 if (state != UNIT_ACTIVE) {
1559 log_unit_warning(u, "Unit cannot be reloaded because it is inactive.");
1560 return -ENOEXEC;
1561 }
1562
1563 following = unit_following(u);
1564 if (following) {
1565 log_unit_debug(u, "Redirecting reload request from %s to %s.", u->id, following->id);
1566 return unit_reload(following);
1567 }
1568
1569 unit_add_to_dbus_queue(u);
1570
1571 r = UNIT_VTABLE(u)->reload(u);
1572 if (r <= 0)
1573 return r;
1574
1575 unit_status_log_starting_stopping_reloading(u, JOB_RELOAD);
1576 return r;
1577 }
1578
1579 bool unit_can_reload(Unit *u) {
1580 assert(u);
1581
1582 if (!UNIT_VTABLE(u)->reload)
1583 return false;
1584
1585 if (!UNIT_VTABLE(u)->can_reload)
1586 return true;
1587
1588 return UNIT_VTABLE(u)->can_reload(u);
1589 }
1590
1591 static void unit_check_unneeded(Unit *u) {
1592 Iterator i;
1593 Unit *other;
1594
1595 assert(u);
1596
1597 /* If this service shall be shut down when unneeded then do
1598 * so. */
1599
1600 if (!u->stop_when_unneeded)
1601 return;
1602
1603 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
1604 return;
1605
1606 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
1607 if (unit_active_or_pending(other))
1608 return;
1609
1610 SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
1611 if (unit_active_or_pending(other))
1612 return;
1613
1614 SET_FOREACH(other, u->dependencies[UNIT_WANTED_BY], i)
1615 if (unit_active_or_pending(other))
1616 return;
1617
1618 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1619 if (unit_active_or_pending(other))
1620 return;
1621
1622 log_unit_info(u, "Unit not needed anymore. Stopping.");
1623
1624 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1625 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1626 }
1627
1628 static void unit_check_binds_to(Unit *u) {
1629 bool stop = false;
1630 Unit *other;
1631 Iterator i;
1632
1633 assert(u);
1634
1635 if (u->job)
1636 return;
1637
1638 if (unit_active_state(u) != UNIT_ACTIVE)
1639 return;
1640
1641 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i) {
1642 if (other->job)
1643 continue;
1644
1645 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other)))
1646 continue;
1647
1648 stop = true;
1649 break;
1650 }
1651
1652 if (!stop)
1653 return;
1654
1655 assert(other);
1656 log_unit_info(u, "Unit is bound to inactive unit %s. Stopping, too.", other->id);
1657
1658 /* A unit we need to run is gone. Sniff. Let's stop this. */
1659 manager_add_job(u->manager, JOB_STOP, u, JOB_FAIL, true, NULL, NULL);
1660 }
1661
1662 static void retroactively_start_dependencies(Unit *u) {
1663 Iterator i;
1664 Unit *other;
1665
1666 assert(u);
1667 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)));
1668
1669 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1670 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1671 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1672 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1673
1674 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1675 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1676 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1677 manager_add_job(u->manager, JOB_START, other, JOB_REPLACE, true, NULL, NULL);
1678
1679 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1680 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1681 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1682 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1683
1684 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1685 if (!set_get(u->dependencies[UNIT_AFTER], other) &&
1686 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
1687 manager_add_job(u->manager, JOB_START, other, JOB_FAIL, false, NULL, NULL);
1688
1689 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTS], i)
1690 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1691 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1692
1693 SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
1694 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1695 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1696 }
1697
1698 static void retroactively_stop_dependencies(Unit *u) {
1699 Iterator i;
1700 Unit *other;
1701
1702 assert(u);
1703 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1704
1705 /* Pull down units which are bound to us recursively if enabled */
1706 SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
1707 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1708 manager_add_job(u->manager, JOB_STOP, other, JOB_REPLACE, true, NULL, NULL);
1709 }
1710
1711 static void check_unneeded_dependencies(Unit *u) {
1712 Iterator i;
1713 Unit *other;
1714
1715 assert(u);
1716 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)));
1717
1718 /* Garbage collect services that might not be needed anymore, if enabled */
1719 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES], i)
1720 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1721 unit_check_unneeded(other);
1722 SET_FOREACH(other, u->dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
1723 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1724 unit_check_unneeded(other);
1725 SET_FOREACH(other, u->dependencies[UNIT_WANTS], i)
1726 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1727 unit_check_unneeded(other);
1728 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE], i)
1729 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1730 unit_check_unneeded(other);
1731 SET_FOREACH(other, u->dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
1732 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1733 unit_check_unneeded(other);
1734 SET_FOREACH(other, u->dependencies[UNIT_BINDS_TO], i)
1735 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
1736 unit_check_unneeded(other);
1737 }
1738
1739 void unit_start_on_failure(Unit *u) {
1740 Unit *other;
1741 Iterator i;
1742
1743 assert(u);
1744
1745 if (set_size(u->dependencies[UNIT_ON_FAILURE]) <= 0)
1746 return;
1747
1748 log_unit_info(u, "Triggering OnFailure= dependencies.");
1749
1750 SET_FOREACH(other, u->dependencies[UNIT_ON_FAILURE], i) {
1751 int r;
1752
1753 r = manager_add_job(u->manager, JOB_START, other, u->on_failure_job_mode, true, NULL, NULL);
1754 if (r < 0)
1755 log_unit_error_errno(u, r, "Failed to enqueue OnFailure= job: %m");
1756 }
1757 }
1758
1759 void unit_trigger_notify(Unit *u) {
1760 Unit *other;
1761 Iterator i;
1762
1763 assert(u);
1764
1765 SET_FOREACH(other, u->dependencies[UNIT_TRIGGERED_BY], i)
1766 if (UNIT_VTABLE(other)->trigger_notify)
1767 UNIT_VTABLE(other)->trigger_notify(other, u);
1768 }
1769
1770 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns, bool reload_success) {
1771 Manager *m;
1772 bool unexpected;
1773
1774 assert(u);
1775 assert(os < _UNIT_ACTIVE_STATE_MAX);
1776 assert(ns < _UNIT_ACTIVE_STATE_MAX);
1777
1778 /* Note that this is called for all low-level state changes,
1779 * even if they might map to the same high-level
1780 * UnitActiveState! That means that ns == os is an expected
1781 * behavior here. For example: if a mount point is remounted
1782 * this function will be called too! */
1783
1784 m = u->manager;
1785
1786 /* Update timestamps for state changes */
1787 if (m->n_reloading <= 0) {
1788 dual_timestamp ts;
1789
1790 dual_timestamp_get(&ts);
1791
1792 if (UNIT_IS_INACTIVE_OR_FAILED(os) && !UNIT_IS_INACTIVE_OR_FAILED(ns))
1793 u->inactive_exit_timestamp = ts;
1794 else if (!UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_INACTIVE_OR_FAILED(ns))
1795 u->inactive_enter_timestamp = ts;
1796
1797 if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
1798 u->active_enter_timestamp = ts;
1799 else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
1800 u->active_exit_timestamp = ts;
1801 }
1802
1803 /* Keep track of failed units */
1804 manager_update_failed_units(u->manager, u, ns == UNIT_FAILED);
1805
1806 /* Make sure the cgroup is always removed when we become inactive */
1807 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1808 unit_destroy_cgroup_if_empty(u);
1809
1810 /* Note that this doesn't apply to RemainAfterExit services exiting
1811 * successfully, since there's no change of state in that case. Which is
1812 * why it is handled in service_set_state() */
1813 if (UNIT_IS_INACTIVE_OR_FAILED(os) != UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1814 ExecContext *ec;
1815
1816 ec = unit_get_exec_context(u);
1817 if (ec && exec_context_may_touch_console(ec)) {
1818 if (UNIT_IS_INACTIVE_OR_FAILED(ns)) {
1819 m->n_on_console --;
1820
1821 if (m->n_on_console == 0)
1822 /* unset no_console_output flag, since the console is free */
1823 m->no_console_output = false;
1824 } else
1825 m->n_on_console ++;
1826 }
1827 }
1828
1829 if (u->job) {
1830 unexpected = false;
1831
1832 if (u->job->state == JOB_WAITING)
1833
1834 /* So we reached a different state for this
1835 * job. Let's see if we can run it now if it
1836 * failed previously due to EAGAIN. */
1837 job_add_to_run_queue(u->job);
1838
1839 /* Let's check whether this state change constitutes a
1840 * finished job, or maybe contradicts a running job and
1841 * hence needs to invalidate jobs. */
1842
1843 switch (u->job->type) {
1844
1845 case JOB_START:
1846 case JOB_VERIFY_ACTIVE:
1847
1848 if (UNIT_IS_ACTIVE_OR_RELOADING(ns))
1849 job_finish_and_invalidate(u->job, JOB_DONE, true);
1850 else if (u->job->state == JOB_RUNNING && ns != UNIT_ACTIVATING) {
1851 unexpected = true;
1852
1853 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1854 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1855 }
1856
1857 break;
1858
1859 case JOB_RELOAD:
1860 case JOB_RELOAD_OR_START:
1861
1862 if (u->job->state == JOB_RUNNING) {
1863 if (ns == UNIT_ACTIVE)
1864 job_finish_and_invalidate(u->job, reload_success ? JOB_DONE : JOB_FAILED, true);
1865 else if (ns != UNIT_ACTIVATING && ns != UNIT_RELOADING) {
1866 unexpected = true;
1867
1868 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1869 job_finish_and_invalidate(u->job, ns == UNIT_FAILED ? JOB_FAILED : JOB_DONE, true);
1870 }
1871 }
1872
1873 break;
1874
1875 case JOB_STOP:
1876 case JOB_RESTART:
1877 case JOB_TRY_RESTART:
1878
1879 if (UNIT_IS_INACTIVE_OR_FAILED(ns))
1880 job_finish_and_invalidate(u->job, JOB_DONE, true);
1881 else if (u->job->state == JOB_RUNNING && ns != UNIT_DEACTIVATING) {
1882 unexpected = true;
1883 job_finish_and_invalidate(u->job, JOB_FAILED, true);
1884 }
1885
1886 break;
1887
1888 default:
1889 assert_not_reached("Job type unknown");
1890 }
1891
1892 } else
1893 unexpected = true;
1894
1895 if (m->n_reloading <= 0) {
1896
1897 /* If this state change happened without being
1898 * requested by a job, then let's retroactively start
1899 * or stop dependencies. We skip that step when
1900 * deserializing, since we don't want to create any
1901 * additional jobs just because something is already
1902 * activated. */
1903
1904 if (unexpected) {
1905 if (UNIT_IS_INACTIVE_OR_FAILED(os) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns))
1906 retroactively_start_dependencies(u);
1907 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1908 retroactively_stop_dependencies(u);
1909 }
1910
1911 /* stop unneeded units regardless if going down was expected or not */
1912 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(ns))
1913 check_unneeded_dependencies(u);
1914
1915 if (ns != os && ns == UNIT_FAILED) {
1916 log_unit_notice(u, "Unit entered failed state.");
1917 unit_start_on_failure(u);
1918 }
1919 }
1920
1921 /* Some names are special */
1922 if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
1923
1924 if (unit_has_name(u, SPECIAL_DBUS_SERVICE))
1925 /* The bus might have just become available,
1926 * hence try to connect to it, if we aren't
1927 * yet connected. */
1928 bus_init(m, true);
1929
1930 if (u->type == UNIT_SERVICE &&
1931 !UNIT_IS_ACTIVE_OR_RELOADING(os) &&
1932 m->n_reloading <= 0) {
1933 /* Write audit record if we have just finished starting up */
1934 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, true);
1935 u->in_audit = true;
1936 }
1937
1938 if (!UNIT_IS_ACTIVE_OR_RELOADING(os))
1939 manager_send_unit_plymouth(m, u);
1940
1941 } else {
1942
1943 /* We don't care about D-Bus here, since we'll get an
1944 * asynchronous notification for it anyway. */
1945
1946 if (u->type == UNIT_SERVICE &&
1947 UNIT_IS_INACTIVE_OR_FAILED(ns) &&
1948 !UNIT_IS_INACTIVE_OR_FAILED(os) &&
1949 m->n_reloading <= 0) {
1950
1951 /* Hmm, if there was no start record written
1952 * write it now, so that we always have a nice
1953 * pair */
1954 if (!u->in_audit) {
1955 manager_send_unit_audit(m, u, AUDIT_SERVICE_START, ns == UNIT_INACTIVE);
1956
1957 if (ns == UNIT_INACTIVE)
1958 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, true);
1959 } else
1960 /* Write audit record if we have just finished shutting down */
1961 manager_send_unit_audit(m, u, AUDIT_SERVICE_STOP, ns == UNIT_INACTIVE);
1962
1963 u->in_audit = false;
1964 }
1965 }
1966
1967 manager_recheck_journal(m);
1968 unit_trigger_notify(u);
1969
1970 if (u->manager->n_reloading <= 0) {
1971 /* Maybe we finished startup and are now ready for
1972 * being stopped because unneeded? */
1973 unit_check_unneeded(u);
1974
1975 /* Maybe we finished startup, but something we needed
1976 * has vanished? Let's die then. (This happens when
1977 * something BindsTo= to a Type=oneshot unit, as these
1978 * units go directly from starting to inactive,
1979 * without ever entering started.) */
1980 unit_check_binds_to(u);
1981 }
1982
1983 unit_add_to_dbus_queue(u);
1984 unit_add_to_gc_queue(u);
1985 }
1986
1987 int unit_watch_pid(Unit *u, pid_t pid) {
1988 int q, r;
1989
1990 assert(u);
1991 assert(pid >= 1);
1992
1993 /* Watch a specific PID. We only support one or two units
1994 * watching each PID for now, not more. */
1995
1996 r = set_ensure_allocated(&u->pids, NULL);
1997 if (r < 0)
1998 return r;
1999
2000 r = hashmap_ensure_allocated(&u->manager->watch_pids1, NULL);
2001 if (r < 0)
2002 return r;
2003
2004 r = hashmap_put(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2005 if (r == -EEXIST) {
2006 r = hashmap_ensure_allocated(&u->manager->watch_pids2, NULL);
2007 if (r < 0)
2008 return r;
2009
2010 r = hashmap_put(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2011 }
2012
2013 q = set_put(u->pids, LONG_TO_PTR(pid));
2014 if (q < 0)
2015 return q;
2016
2017 return r;
2018 }
2019
2020 void unit_unwatch_pid(Unit *u, pid_t pid) {
2021 assert(u);
2022 assert(pid >= 1);
2023
2024 hashmap_remove_value(u->manager->watch_pids1, LONG_TO_PTR(pid), u);
2025 hashmap_remove_value(u->manager->watch_pids2, LONG_TO_PTR(pid), u);
2026 set_remove(u->pids, LONG_TO_PTR(pid));
2027 }
2028
2029 void unit_unwatch_all_pids(Unit *u) {
2030 assert(u);
2031
2032 while (!set_isempty(u->pids))
2033 unit_unwatch_pid(u, PTR_TO_LONG(set_first(u->pids)));
2034
2035 set_free(u->pids);
2036 u->pids = NULL;
2037 }
2038
2039 static int unit_watch_pids_in_path(Unit *u, const char *path) {
2040 _cleanup_closedir_ DIR *d = NULL;
2041 _cleanup_fclose_ FILE *f = NULL;
2042 int ret = 0, r;
2043
2044 assert(u);
2045 assert(path);
2046
2047 /* Adds all PIDs from a specific cgroup path to the set of PIDs we watch. */
2048
2049 r = cg_enumerate_processes(SYSTEMD_CGROUP_CONTROLLER, path, &f);
2050 if (r >= 0) {
2051 pid_t pid;
2052
2053 while ((r = cg_read_pid(f, &pid)) > 0) {
2054 r = unit_watch_pid(u, pid);
2055 if (r < 0 && ret >= 0)
2056 ret = r;
2057 }
2058 if (r < 0 && ret >= 0)
2059 ret = r;
2060
2061 } else if (ret >= 0)
2062 ret = r;
2063
2064 r = cg_enumerate_subgroups(SYSTEMD_CGROUP_CONTROLLER, path, &d);
2065 if (r >= 0) {
2066 char *fn;
2067
2068 while ((r = cg_read_subgroup(d, &fn)) > 0) {
2069 _cleanup_free_ char *p = NULL;
2070
2071 p = strjoin(path, "/", fn, NULL);
2072 free(fn);
2073
2074 if (!p)
2075 return -ENOMEM;
2076
2077 r = unit_watch_pids_in_path(u, p);
2078 if (r < 0 && ret >= 0)
2079 ret = r;
2080 }
2081 if (r < 0 && ret >= 0)
2082 ret = r;
2083
2084 } else if (ret >= 0)
2085 ret = r;
2086
2087 return ret;
2088 }
2089
2090 int unit_watch_all_pids(Unit *u) {
2091 assert(u);
2092
2093 /* Adds all PIDs from our cgroup to the set of PIDs we watch */
2094
2095 if (!u->cgroup_path)
2096 return -ENOENT;
2097
2098 return unit_watch_pids_in_path(u, u->cgroup_path);
2099 }
2100
2101 void unit_tidy_watch_pids(Unit *u, pid_t except1, pid_t except2) {
2102 Iterator i;
2103 void *e;
2104
2105 assert(u);
2106
2107 /* Cleans dead PIDs from our list */
2108
2109 SET_FOREACH(e, u->pids, i) {
2110 pid_t pid = PTR_TO_LONG(e);
2111
2112 if (pid == except1 || pid == except2)
2113 continue;
2114
2115 if (!pid_is_unwaited(pid))
2116 unit_unwatch_pid(u, pid);
2117 }
2118 }
2119
2120 bool unit_job_is_applicable(Unit *u, JobType j) {
2121 assert(u);
2122 assert(j >= 0 && j < _JOB_TYPE_MAX);
2123
2124 switch (j) {
2125
2126 case JOB_VERIFY_ACTIVE:
2127 case JOB_START:
2128 case JOB_STOP:
2129 case JOB_NOP:
2130 return true;
2131
2132 case JOB_RESTART:
2133 case JOB_TRY_RESTART:
2134 return unit_can_start(u);
2135
2136 case JOB_RELOAD:
2137 return unit_can_reload(u);
2138
2139 case JOB_RELOAD_OR_START:
2140 return unit_can_reload(u) && unit_can_start(u);
2141
2142 default:
2143 assert_not_reached("Invalid job type");
2144 }
2145 }
2146
2147 static void maybe_warn_about_dependency(Unit *u, const char *other, UnitDependency dependency) {
2148 assert(u);
2149
2150 /* Only warn about some unit types */
2151 if (!IN_SET(dependency, UNIT_CONFLICTS, UNIT_CONFLICTED_BY, UNIT_BEFORE, UNIT_AFTER, UNIT_ON_FAILURE, UNIT_TRIGGERS, UNIT_TRIGGERED_BY))
2152 return;
2153
2154 if (streq_ptr(u->id, other))
2155 log_unit_warning(u, "Dependency %s=%s dropped", unit_dependency_to_string(dependency), u->id);
2156 else
2157 log_unit_warning(u, "Dependency %s=%s dropped, merged into %s", unit_dependency_to_string(dependency), strna(other), u->id);
2158 }
2159
2160 int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
2161
2162 static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
2163 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
2164 [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2165 [UNIT_WANTS] = UNIT_WANTED_BY,
2166 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
2167 [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
2168 [UNIT_BINDS_TO] = UNIT_BOUND_BY,
2169 [UNIT_PART_OF] = UNIT_CONSISTS_OF,
2170 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
2171 [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
2172 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
2173 [UNIT_BOUND_BY] = UNIT_BINDS_TO,
2174 [UNIT_CONSISTS_OF] = UNIT_PART_OF,
2175 [UNIT_CONFLICTS] = UNIT_CONFLICTED_BY,
2176 [UNIT_CONFLICTED_BY] = UNIT_CONFLICTS,
2177 [UNIT_BEFORE] = UNIT_AFTER,
2178 [UNIT_AFTER] = UNIT_BEFORE,
2179 [UNIT_ON_FAILURE] = _UNIT_DEPENDENCY_INVALID,
2180 [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
2181 [UNIT_REFERENCED_BY] = UNIT_REFERENCES,
2182 [UNIT_TRIGGERS] = UNIT_TRIGGERED_BY,
2183 [UNIT_TRIGGERED_BY] = UNIT_TRIGGERS,
2184 [UNIT_PROPAGATES_RELOAD_TO] = UNIT_RELOAD_PROPAGATED_FROM,
2185 [UNIT_RELOAD_PROPAGATED_FROM] = UNIT_PROPAGATES_RELOAD_TO,
2186 [UNIT_JOINS_NAMESPACE_OF] = UNIT_JOINS_NAMESPACE_OF,
2187 };
2188 int r, q = 0, v = 0, w = 0;
2189 Unit *orig_u = u, *orig_other = other;
2190
2191 assert(u);
2192 assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
2193 assert(other);
2194
2195 u = unit_follow_merge(u);
2196 other = unit_follow_merge(other);
2197
2198 /* We won't allow dependencies on ourselves. We will not
2199 * consider them an error however. */
2200 if (u == other) {
2201 maybe_warn_about_dependency(orig_u, orig_other->id, d);
2202 return 0;
2203 }
2204
2205 r = set_ensure_allocated(&u->dependencies[d], NULL);
2206 if (r < 0)
2207 return r;
2208
2209 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID) {
2210 r = set_ensure_allocated(&other->dependencies[inverse_table[d]], NULL);
2211 if (r < 0)
2212 return r;
2213 }
2214
2215 if (add_reference) {
2216 r = set_ensure_allocated(&u->dependencies[UNIT_REFERENCES], NULL);
2217 if (r < 0)
2218 return r;
2219
2220 r = set_ensure_allocated(&other->dependencies[UNIT_REFERENCED_BY], NULL);
2221 if (r < 0)
2222 return r;
2223 }
2224
2225 q = set_put(u->dependencies[d], other);
2226 if (q < 0)
2227 return q;
2228
2229 if (inverse_table[d] != _UNIT_DEPENDENCY_INVALID && inverse_table[d] != d) {
2230 v = set_put(other->dependencies[inverse_table[d]], u);
2231 if (v < 0) {
2232 r = v;
2233 goto fail;
2234 }
2235 }
2236
2237 if (add_reference) {
2238 w = set_put(u->dependencies[UNIT_REFERENCES], other);
2239 if (w < 0) {
2240 r = w;
2241 goto fail;
2242 }
2243
2244 r = set_put(other->dependencies[UNIT_REFERENCED_BY], u);
2245 if (r < 0)
2246 goto fail;
2247 }
2248
2249 unit_add_to_dbus_queue(u);
2250 return 0;
2251
2252 fail:
2253 if (q > 0)
2254 set_remove(u->dependencies[d], other);
2255
2256 if (v > 0)
2257 set_remove(other->dependencies[inverse_table[d]], u);
2258
2259 if (w > 0)
2260 set_remove(u->dependencies[UNIT_REFERENCES], other);
2261
2262 return r;
2263 }
2264
2265 int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference) {
2266 int r;
2267
2268 assert(u);
2269
2270 r = unit_add_dependency(u, d, other, add_reference);
2271 if (r < 0)
2272 return r;
2273
2274 return unit_add_dependency(u, e, other, add_reference);
2275 }
2276
2277 static int resolve_template(Unit *u, const char *name, const char*path, char **buf, const char **ret) {
2278 int r;
2279
2280 assert(u);
2281 assert(name || path);
2282 assert(buf);
2283 assert(ret);
2284
2285 if (!name)
2286 name = basename(path);
2287
2288 if (!unit_name_is_valid(name, UNIT_NAME_TEMPLATE)) {
2289 *buf = NULL;
2290 *ret = name;
2291 return 0;
2292 }
2293
2294 if (u->instance)
2295 r = unit_name_replace_instance(name, u->instance, buf);
2296 else {
2297 _cleanup_free_ char *i = NULL;
2298
2299 r = unit_name_to_prefix(u->id, &i);
2300 if (r < 0)
2301 return r;
2302
2303 r = unit_name_replace_instance(name, i, buf);
2304 }
2305 if (r < 0)
2306 return r;
2307
2308 *ret = *buf;
2309 return 0;
2310 }
2311
2312 int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2313 _cleanup_free_ char *buf = NULL;
2314 Unit *other;
2315 int r;
2316
2317 assert(u);
2318 assert(name || path);
2319
2320 r = resolve_template(u, name, path, &buf, &name);
2321 if (r < 0)
2322 return r;
2323
2324 r = manager_load_unit(u->manager, name, path, NULL, &other);
2325 if (r < 0)
2326 return r;
2327
2328 return unit_add_dependency(u, d, other, add_reference);
2329 }
2330
2331 int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2332 _cleanup_free_ char *buf = NULL;
2333 Unit *other;
2334 int r;
2335
2336 assert(u);
2337 assert(name || path);
2338
2339 r = resolve_template(u, name, path, &buf, &name);
2340 if (r < 0)
2341 return r;
2342
2343 r = manager_load_unit(u->manager, name, path, NULL, &other);
2344 if (r < 0)
2345 return r;
2346
2347 return unit_add_two_dependencies(u, d, e, other, add_reference);
2348 }
2349
2350 int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
2351 _cleanup_free_ char *buf = NULL;
2352 Unit *other;
2353 int r;
2354
2355 assert(u);
2356 assert(name || path);
2357
2358 r = resolve_template(u, name, path, &buf, &name);
2359 if (r < 0)
2360 return r;
2361
2362 r = manager_load_unit(u->manager, name, path, NULL, &other);
2363 if (r < 0)
2364 return r;
2365
2366 return unit_add_dependency(other, d, u, add_reference);
2367 }
2368
2369 int unit_add_two_dependencies_by_name_inverse(Unit *u, UnitDependency d, UnitDependency e, const char *name, const char *path, bool add_reference) {
2370 _cleanup_free_ char *buf = NULL;
2371 Unit *other;
2372 int r;
2373
2374 assert(u);
2375 assert(name || path);
2376
2377 r = resolve_template(u, name, path, &buf, &name);
2378 if (r < 0)
2379 return r;
2380
2381 r = manager_load_unit(u->manager, name, path, NULL, &other);
2382 if (r < 0)
2383 return r;
2384
2385 return unit_add_two_dependencies(other, d, e, u, add_reference);
2386 }
2387
2388 int set_unit_path(const char *p) {
2389 /* This is mostly for debug purposes */
2390 if (setenv("SYSTEMD_UNIT_PATH", p, 0) < 0)
2391 return -errno;
2392
2393 return 0;
2394 }
2395
2396 char *unit_dbus_path(Unit *u) {
2397 assert(u);
2398
2399 if (!u->id)
2400 return NULL;
2401
2402 return unit_dbus_path_from_name(u->id);
2403 }
2404
2405 char *unit_default_cgroup_path(Unit *u) {
2406 _cleanup_free_ char *escaped = NULL, *slice = NULL;
2407 int r;
2408
2409 assert(u);
2410
2411 if (unit_has_name(u, SPECIAL_ROOT_SLICE))
2412 return strdup(u->manager->cgroup_root);
2413
2414 if (UNIT_ISSET(u->slice) && !unit_has_name(UNIT_DEREF(u->slice), SPECIAL_ROOT_SLICE)) {
2415 r = cg_slice_to_path(UNIT_DEREF(u->slice)->id, &slice);
2416 if (r < 0)
2417 return NULL;
2418 }
2419
2420 escaped = cg_escape(u->id);
2421 if (!escaped)
2422 return NULL;
2423
2424 if (slice)
2425 return strjoin(u->manager->cgroup_root, "/", slice, "/", escaped, NULL);
2426 else
2427 return strjoin(u->manager->cgroup_root, "/", escaped, NULL);
2428 }
2429
2430 int unit_add_default_slice(Unit *u, CGroupContext *c) {
2431 _cleanup_free_ char *b = NULL;
2432 const char *slice_name;
2433 Unit *slice;
2434 int r;
2435
2436 assert(u);
2437 assert(c);
2438
2439 if (UNIT_ISSET(u->slice))
2440 return 0;
2441
2442 if (u->instance) {
2443 _cleanup_free_ char *prefix = NULL, *escaped = NULL;
2444
2445 /* Implicitly place all instantiated units in their
2446 * own per-template slice */
2447
2448 r = unit_name_to_prefix(u->id, &prefix);
2449 if (r < 0)
2450 return r;
2451
2452 /* The prefix is already escaped, but it might include
2453 * "-" which has a special meaning for slice units,
2454 * hence escape it here extra. */
2455 escaped = unit_name_escape(prefix);
2456 if (!escaped)
2457 return -ENOMEM;
2458
2459 if (u->manager->running_as == SYSTEMD_SYSTEM)
2460 b = strjoin("system-", escaped, ".slice", NULL);
2461 else
2462 b = strappend(escaped, ".slice");
2463 if (!b)
2464 return -ENOMEM;
2465
2466 slice_name = b;
2467 } else
2468 slice_name =
2469 u->manager->running_as == SYSTEMD_SYSTEM
2470 ? SPECIAL_SYSTEM_SLICE
2471 : SPECIAL_ROOT_SLICE;
2472
2473 r = manager_load_unit(u->manager, slice_name, NULL, NULL, &slice);
2474 if (r < 0)
2475 return r;
2476
2477 unit_ref_set(&u->slice, slice);
2478 return 0;
2479 }
2480
2481 const char *unit_slice_name(Unit *u) {
2482 assert(u);
2483
2484 if (!UNIT_ISSET(u->slice))
2485 return NULL;
2486
2487 return UNIT_DEREF(u->slice)->id;
2488 }
2489
2490 int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
2491 _cleanup_free_ char *t = NULL;
2492 int r;
2493
2494 assert(u);
2495 assert(type);
2496 assert(_found);
2497
2498 r = unit_name_change_suffix(u->id, type, &t);
2499 if (r < 0)
2500 return r;
2501 if (unit_has_name(u, t))
2502 return -EINVAL;
2503
2504 r = manager_load_unit(u->manager, t, NULL, NULL, _found);
2505 assert(r < 0 || *_found != u);
2506 return r;
2507 }
2508
2509 int unit_watch_bus_name(Unit *u, const char *name) {
2510 assert(u);
2511 assert(name);
2512
2513 /* Watch a specific name on the bus. We only support one unit
2514 * watching each name for now. */
2515
2516 return hashmap_put(u->manager->watch_bus, name, u);
2517 }
2518
2519 void unit_unwatch_bus_name(Unit *u, const char *name) {
2520 assert(u);
2521 assert(name);
2522
2523 hashmap_remove_value(u->manager->watch_bus, name, u);
2524 }
2525
2526 bool unit_can_serialize(Unit *u) {
2527 assert(u);
2528
2529 return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
2530 }
2531
2532 int unit_serialize(Unit *u, FILE *f, FDSet *fds, bool serialize_jobs) {
2533 int r;
2534
2535 assert(u);
2536 assert(f);
2537 assert(fds);
2538
2539 if (unit_can_serialize(u)) {
2540 ExecRuntime *rt;
2541
2542 r = UNIT_VTABLE(u)->serialize(u, f, fds);
2543 if (r < 0)
2544 return r;
2545
2546 rt = unit_get_exec_runtime(u);
2547 if (rt) {
2548 r = exec_runtime_serialize(u, rt, f, fds);
2549 if (r < 0)
2550 return r;
2551 }
2552 }
2553
2554 dual_timestamp_serialize(f, "inactive-exit-timestamp", &u->inactive_exit_timestamp);
2555 dual_timestamp_serialize(f, "active-enter-timestamp", &u->active_enter_timestamp);
2556 dual_timestamp_serialize(f, "active-exit-timestamp", &u->active_exit_timestamp);
2557 dual_timestamp_serialize(f, "inactive-enter-timestamp", &u->inactive_enter_timestamp);
2558 dual_timestamp_serialize(f, "condition-timestamp", &u->condition_timestamp);
2559 dual_timestamp_serialize(f, "assert-timestamp", &u->assert_timestamp);
2560
2561 if (dual_timestamp_is_set(&u->condition_timestamp))
2562 unit_serialize_item(u, f, "condition-result", yes_no(u->condition_result));
2563
2564 if (dual_timestamp_is_set(&u->assert_timestamp))
2565 unit_serialize_item(u, f, "assert-result", yes_no(u->assert_result));
2566
2567 unit_serialize_item(u, f, "transient", yes_no(u->transient));
2568 unit_serialize_item_format(u, f, "cpuacct-usage-base", "%" PRIu64, u->cpuacct_usage_base);
2569
2570 if (u->cgroup_path)
2571 unit_serialize_item(u, f, "cgroup", u->cgroup_path);
2572
2573 if (serialize_jobs) {
2574 if (u->job) {
2575 fprintf(f, "job\n");
2576 job_serialize(u->job, f, fds);
2577 }
2578
2579 if (u->nop_job) {
2580 fprintf(f, "job\n");
2581 job_serialize(u->nop_job, f, fds);
2582 }
2583 }
2584
2585 /* End marker */
2586 fputc('\n', f);
2587 return 0;
2588 }
2589
2590 void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
2591 va_list ap;
2592
2593 assert(u);
2594 assert(f);
2595 assert(key);
2596 assert(format);
2597
2598 fputs(key, f);
2599 fputc('=', f);
2600
2601 va_start(ap, format);
2602 vfprintf(f, format, ap);
2603 va_end(ap);
2604
2605 fputc('\n', f);
2606 }
2607
2608 void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
2609 assert(u);
2610 assert(f);
2611 assert(key);
2612 assert(value);
2613
2614 fprintf(f, "%s=%s\n", key, value);
2615 }
2616
2617 static int unit_set_cgroup_path(Unit *u, const char *path) {
2618 _cleanup_free_ char *p = NULL;
2619 int r;
2620
2621 assert(u);
2622
2623 if (path) {
2624 p = strdup(path);
2625 if (!p)
2626 return -ENOMEM;
2627 } else
2628 p = NULL;
2629
2630 if (streq_ptr(u->cgroup_path, p))
2631 return 0;
2632
2633 if (p) {
2634 r = hashmap_put(u->manager->cgroup_unit, p, u);
2635 if (r < 0)
2636 return r;
2637 }
2638
2639 if (u->cgroup_path) {
2640 log_unit_debug(u, "Changing cgroup path from %s to %s.", u->cgroup_path, strna(p));
2641 hashmap_remove(u->manager->cgroup_unit, u->cgroup_path);
2642 free(u->cgroup_path);
2643 }
2644
2645 u->cgroup_path = p;
2646 p = NULL;
2647
2648 return 0;
2649 }
2650
2651 int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
2652 ExecRuntime **rt = NULL;
2653 size_t offset;
2654 int r;
2655
2656 assert(u);
2657 assert(f);
2658 assert(fds);
2659
2660 offset = UNIT_VTABLE(u)->exec_runtime_offset;
2661 if (offset > 0)
2662 rt = (ExecRuntime**) ((uint8_t*) u + offset);
2663
2664 for (;;) {
2665 char line[LINE_MAX], *l, *v;
2666 size_t k;
2667
2668 if (!fgets(line, sizeof(line), f)) {
2669 if (feof(f))
2670 return 0;
2671 return -errno;
2672 }
2673
2674 char_array_0(line);
2675 l = strstrip(line);
2676
2677 /* End marker */
2678 if (isempty(l))
2679 return 0;
2680
2681 k = strcspn(l, "=");
2682
2683 if (l[k] == '=') {
2684 l[k] = 0;
2685 v = l+k+1;
2686 } else
2687 v = l+k;
2688
2689 if (streq(l, "job")) {
2690 if (v[0] == '\0') {
2691 /* new-style serialized job */
2692 Job *j;
2693
2694 j = job_new_raw(u);
2695 if (!j)
2696 return log_oom();
2697
2698 r = job_deserialize(j, f, fds);
2699 if (r < 0) {
2700 job_free(j);
2701 return r;
2702 }
2703
2704 r = hashmap_put(u->manager->jobs, UINT32_TO_PTR(j->id), j);
2705 if (r < 0) {
2706 job_free(j);
2707 return r;
2708 }
2709
2710 r = job_install_deserialized(j);
2711 if (r < 0) {
2712 hashmap_remove(u->manager->jobs, UINT32_TO_PTR(j->id));
2713 job_free(j);
2714 return r;
2715 }
2716 } else {
2717 /* legacy */
2718 JobType type;
2719
2720 type = job_type_from_string(v);
2721 if (type < 0)
2722 log_unit_debug(u, "Failed to parse job type value: %s", v);
2723 else
2724 u->deserialized_job = type;
2725 }
2726 continue;
2727 } else if (streq(l, "inactive-exit-timestamp")) {
2728 dual_timestamp_deserialize(v, &u->inactive_exit_timestamp);
2729 continue;
2730 } else if (streq(l, "active-enter-timestamp")) {
2731 dual_timestamp_deserialize(v, &u->active_enter_timestamp);
2732 continue;
2733 } else if (streq(l, "active-exit-timestamp")) {
2734 dual_timestamp_deserialize(v, &u->active_exit_timestamp);
2735 continue;
2736 } else if (streq(l, "inactive-enter-timestamp")) {
2737 dual_timestamp_deserialize(v, &u->inactive_enter_timestamp);
2738 continue;
2739 } else if (streq(l, "condition-timestamp")) {
2740 dual_timestamp_deserialize(v, &u->condition_timestamp);
2741 continue;
2742 } else if (streq(l, "assert-timestamp")) {
2743 dual_timestamp_deserialize(v, &u->assert_timestamp);
2744 continue;
2745 } else if (streq(l, "condition-result")) {
2746
2747 r = parse_boolean(v);
2748 if (r < 0)
2749 log_unit_debug(u, "Failed to parse condition result value %s, ignoring.", v);
2750 else
2751 u->condition_result = r;
2752
2753 continue;
2754
2755 } else if (streq(l, "assert-result")) {
2756
2757 r = parse_boolean(v);
2758 if (r < 0)
2759 log_unit_debug(u, "Failed to parse assert result value %s, ignoring.", v);
2760 else
2761 u->assert_result = r;
2762
2763 continue;
2764
2765 } else if (streq(l, "transient")) {
2766
2767 r = parse_boolean(v);
2768 if (r < 0)
2769 log_unit_debug(u, "Failed to parse transient bool %s, ignoring.", v);
2770 else
2771 u->transient = r;
2772
2773 continue;
2774
2775 } else if (streq(l, "cpuacct-usage-base")) {
2776
2777 r = safe_atou64(v, &u->cpuacct_usage_base);
2778 if (r < 0)
2779 log_unit_debug(u, "Failed to parse CPU usage %s, ignoring.", v);
2780
2781 continue;
2782
2783 } else if (streq(l, "cgroup")) {
2784
2785 r = unit_set_cgroup_path(u, v);
2786 if (r < 0)
2787 log_unit_debug_errno(u, r, "Failed to set cgroup path %s, ignoring: %m", v);
2788
2789 continue;
2790 }
2791
2792 if (unit_can_serialize(u)) {
2793 if (rt) {
2794 r = exec_runtime_deserialize_item(u, rt, l, v, fds);
2795 if (r < 0) {
2796 log_unit_warning(u, "Failed to deserialize runtime parameter '%s', ignoring.", l);
2797 continue;
2798 }
2799
2800 /* Returns positive if key was handled by the call */
2801 if (r > 0)
2802 continue;
2803 }
2804
2805 r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds);
2806 if (r < 0)
2807 log_unit_warning(u, "Failed to deserialize unit parameter '%s', ignoring.", l);
2808 }
2809 }
2810 }
2811
2812 int unit_add_node_link(Unit *u, const char *what, bool wants) {
2813 Unit *device;
2814 _cleanup_free_ char *e = NULL;
2815 int r;
2816
2817 assert(u);
2818
2819 /* Adds in links to the device node that this unit is based on */
2820 if (isempty(what))
2821 return 0;
2822
2823 if (!is_device_path(what))
2824 return 0;
2825
2826 /* When device units aren't supported (such as in a
2827 * container), don't create dependencies on them. */
2828 if (!unit_type_supported(UNIT_DEVICE))
2829 return 0;
2830
2831 r = unit_name_from_path(what, ".device", &e);
2832 if (r < 0)
2833 return r;
2834
2835 r = manager_load_unit(u->manager, e, NULL, NULL, &device);
2836 if (r < 0)
2837 return r;
2838
2839 r = unit_add_two_dependencies(u, UNIT_AFTER, u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_BINDS_TO : UNIT_WANTS, device, true);
2840 if (r < 0)
2841 return r;
2842
2843 if (wants) {
2844 r = unit_add_dependency(device, UNIT_WANTS, u, false);
2845 if (r < 0)
2846 return r;
2847 }
2848
2849 return 0;
2850 }
2851
2852 int unit_coldplug(Unit *u) {
2853 int r;
2854
2855 assert(u);
2856
2857 /* Make sure we don't enter a loop, when coldplugging
2858 * recursively. */
2859 if (u->coldplugged)
2860 return 0;
2861
2862 u->coldplugged = true;
2863
2864 if (UNIT_VTABLE(u)->coldplug) {
2865 r = UNIT_VTABLE(u)->coldplug(u);
2866 if (r < 0)
2867 return r;
2868 }
2869
2870 if (u->job) {
2871 r = job_coldplug(u->job);
2872 if (r < 0)
2873 return r;
2874 } else if (u->deserialized_job >= 0) {
2875 /* legacy */
2876 r = manager_add_job(u->manager, u->deserialized_job, u, JOB_IGNORE_REQUIREMENTS, false, NULL, NULL);
2877 if (r < 0)
2878 return r;
2879
2880 u->deserialized_job = _JOB_TYPE_INVALID;
2881 }
2882
2883 return 0;
2884 }
2885
2886 void unit_status_printf(Unit *u, const char *status, const char *unit_status_msg_format) {
2887 DISABLE_WARNING_FORMAT_NONLITERAL;
2888 manager_status_printf(u->manager, STATUS_TYPE_NORMAL,
2889 status, unit_status_msg_format, unit_description(u));
2890 REENABLE_WARNING;
2891 }
2892
2893 bool unit_need_daemon_reload(Unit *u) {
2894 _cleanup_strv_free_ char **t = NULL;
2895 char **path;
2896 struct stat st;
2897 unsigned loaded_cnt, current_cnt;
2898
2899 assert(u);
2900
2901 if (u->fragment_path) {
2902 zero(st);
2903 if (stat(u->fragment_path, &st) < 0)
2904 /* What, cannot access this anymore? */
2905 return true;
2906
2907 if (u->fragment_mtime > 0 &&
2908 timespec_load(&st.st_mtim) != u->fragment_mtime)
2909 return true;
2910 }
2911
2912 if (u->source_path) {
2913 zero(st);
2914 if (stat(u->source_path, &st) < 0)
2915 return true;
2916
2917 if (u->source_mtime > 0 &&
2918 timespec_load(&st.st_mtim) != u->source_mtime)
2919 return true;
2920 }
2921
2922 (void) unit_find_dropin_paths(u, &t);
2923 loaded_cnt = strv_length(t);
2924 current_cnt = strv_length(u->dropin_paths);
2925
2926 if (loaded_cnt == current_cnt) {
2927 if (loaded_cnt == 0)
2928 return false;
2929
2930 if (strv_overlap(u->dropin_paths, t)) {
2931 STRV_FOREACH(path, u->dropin_paths) {
2932 zero(st);
2933 if (stat(*path, &st) < 0)
2934 return true;
2935
2936 if (u->dropin_mtime > 0 &&
2937 timespec_load(&st.st_mtim) > u->dropin_mtime)
2938 return true;
2939 }
2940
2941 return false;
2942 } else
2943 return true;
2944 } else
2945 return true;
2946 }
2947
2948 void unit_reset_failed(Unit *u) {
2949 assert(u);
2950
2951 if (UNIT_VTABLE(u)->reset_failed)
2952 UNIT_VTABLE(u)->reset_failed(u);
2953 }
2954
2955 Unit *unit_following(Unit *u) {
2956 assert(u);
2957
2958 if (UNIT_VTABLE(u)->following)
2959 return UNIT_VTABLE(u)->following(u);
2960
2961 return NULL;
2962 }
2963
2964 bool unit_stop_pending(Unit *u) {
2965 assert(u);
2966
2967 /* This call does check the current state of the unit. It's
2968 * hence useful to be called from state change calls of the
2969 * unit itself, where the state isn't updated yet. This is
2970 * different from unit_inactive_or_pending() which checks both
2971 * the current state and for a queued job. */
2972
2973 return u->job && u->job->type == JOB_STOP;
2974 }
2975
2976 bool unit_inactive_or_pending(Unit *u) {
2977 assert(u);
2978
2979 /* Returns true if the unit is inactive or going down */
2980
2981 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u)))
2982 return true;
2983
2984 if (unit_stop_pending(u))
2985 return true;
2986
2987 return false;
2988 }
2989
2990 bool unit_active_or_pending(Unit *u) {
2991 assert(u);
2992
2993 /* Returns true if the unit is active or going up */
2994
2995 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u)))
2996 return true;
2997
2998 if (u->job &&
2999 (u->job->type == JOB_START ||
3000 u->job->type == JOB_RELOAD_OR_START ||
3001 u->job->type == JOB_RESTART))
3002 return true;
3003
3004 return false;
3005 }
3006
3007 int unit_kill(Unit *u, KillWho w, int signo, sd_bus_error *error) {
3008 assert(u);
3009 assert(w >= 0 && w < _KILL_WHO_MAX);
3010 assert(signo > 0);
3011 assert(signo < _NSIG);
3012
3013 if (!UNIT_VTABLE(u)->kill)
3014 return -EOPNOTSUPP;
3015
3016 return UNIT_VTABLE(u)->kill(u, w, signo, error);
3017 }
3018
3019 static Set *unit_pid_set(pid_t main_pid, pid_t control_pid) {
3020 Set *pid_set;
3021 int r;
3022
3023 pid_set = set_new(NULL);
3024 if (!pid_set)
3025 return NULL;
3026
3027 /* Exclude the main/control pids from being killed via the cgroup */
3028 if (main_pid > 0) {
3029 r = set_put(pid_set, LONG_TO_PTR(main_pid));
3030 if (r < 0)
3031 goto fail;
3032 }
3033
3034 if (control_pid > 0) {
3035 r = set_put(pid_set, LONG_TO_PTR(control_pid));
3036 if (r < 0)
3037 goto fail;
3038 }
3039
3040 return pid_set;
3041
3042 fail:
3043 set_free(pid_set);
3044 return NULL;
3045 }
3046
3047 int unit_kill_common(
3048 Unit *u,
3049 KillWho who,
3050 int signo,
3051 pid_t main_pid,
3052 pid_t control_pid,
3053 sd_bus_error *error) {
3054
3055 int r = 0;
3056
3057 if (who == KILL_MAIN && main_pid <= 0) {
3058 if (main_pid < 0)
3059 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no main processes", unit_type_to_string(u->type));
3060 else
3061 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No main process to kill");
3062 }
3063
3064 if (who == KILL_CONTROL && control_pid <= 0) {
3065 if (control_pid < 0)
3066 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_PROCESS, "%s units have no control processes", unit_type_to_string(u->type));
3067 else
3068 return sd_bus_error_set_const(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
3069 }
3070
3071 if (who == KILL_CONTROL || who == KILL_ALL)
3072 if (control_pid > 0)
3073 if (kill(control_pid, signo) < 0)
3074 r = -errno;
3075
3076 if (who == KILL_MAIN || who == KILL_ALL)
3077 if (main_pid > 0)
3078 if (kill(main_pid, signo) < 0)
3079 r = -errno;
3080
3081 if (who == KILL_ALL && u->cgroup_path) {
3082 _cleanup_set_free_ Set *pid_set = NULL;
3083 int q;
3084
3085 /* Exclude the main/control pids from being killed via the cgroup */
3086 pid_set = unit_pid_set(main_pid, control_pid);
3087 if (!pid_set)
3088 return -ENOMEM;
3089
3090 q = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, signo, false, true, false, pid_set);
3091 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
3092 r = q;
3093 }
3094
3095 return r;
3096 }
3097
3098 int unit_following_set(Unit *u, Set **s) {
3099 assert(u);
3100 assert(s);
3101
3102 if (UNIT_VTABLE(u)->following_set)
3103 return UNIT_VTABLE(u)->following_set(u, s);
3104
3105 *s = NULL;
3106 return 0;
3107 }
3108
3109 UnitFileState unit_get_unit_file_state(Unit *u) {
3110 assert(u);
3111
3112 if (u->unit_file_state < 0 && u->fragment_path)
3113 u->unit_file_state = unit_file_get_state(
3114 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3115 NULL, basename(u->fragment_path));
3116
3117 return u->unit_file_state;
3118 }
3119
3120 int unit_get_unit_file_preset(Unit *u) {
3121 assert(u);
3122
3123 if (u->unit_file_preset < 0 && u->fragment_path)
3124 u->unit_file_preset = unit_file_query_preset(
3125 u->manager->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER,
3126 NULL, basename(u->fragment_path));
3127
3128 return u->unit_file_preset;
3129 }
3130
3131 Unit* unit_ref_set(UnitRef *ref, Unit *u) {
3132 assert(ref);
3133 assert(u);
3134
3135 if (ref->unit)
3136 unit_ref_unset(ref);
3137
3138 ref->unit = u;
3139 LIST_PREPEND(refs, u->refs, ref);
3140 return u;
3141 }
3142
3143 void unit_ref_unset(UnitRef *ref) {
3144 assert(ref);
3145
3146 if (!ref->unit)
3147 return;
3148
3149 LIST_REMOVE(refs, ref->unit->refs, ref);
3150 ref->unit = NULL;
3151 }
3152
3153 int unit_patch_contexts(Unit *u) {
3154 CGroupContext *cc;
3155 ExecContext *ec;
3156 unsigned i;
3157 int r;
3158
3159 assert(u);
3160
3161 /* Patch in the manager defaults into the exec and cgroup
3162 * contexts, _after_ the rest of the settings have been
3163 * initialized */
3164
3165 ec = unit_get_exec_context(u);
3166 if (ec) {
3167 /* This only copies in the ones that need memory */
3168 for (i = 0; i < _RLIMIT_MAX; i++)
3169 if (u->manager->rlimit[i] && !ec->rlimit[i]) {
3170 ec->rlimit[i] = newdup(struct rlimit, u->manager->rlimit[i], 1);
3171 if (!ec->rlimit[i])
3172 return -ENOMEM;
3173 }
3174
3175 if (u->manager->running_as == SYSTEMD_USER &&
3176 !ec->working_directory) {
3177
3178 r = get_home_dir(&ec->working_directory);
3179 if (r < 0)
3180 return r;
3181
3182 /* Allow user services to run, even if the
3183 * home directory is missing */
3184 ec->working_directory_missing_ok = true;
3185 }
3186
3187 if (u->manager->running_as == SYSTEMD_USER &&
3188 (ec->syscall_whitelist ||
3189 !set_isempty(ec->syscall_filter) ||
3190 !set_isempty(ec->syscall_archs) ||
3191 ec->address_families_whitelist ||
3192 !set_isempty(ec->address_families)))
3193 ec->no_new_privileges = true;
3194
3195 if (ec->private_devices)
3196 ec->capability_bounding_set_drop |= (uint64_t) 1ULL << (uint64_t) CAP_MKNOD;
3197 }
3198
3199 cc = unit_get_cgroup_context(u);
3200 if (cc) {
3201
3202 if (ec &&
3203 ec->private_devices &&
3204 cc->device_policy == CGROUP_AUTO)
3205 cc->device_policy = CGROUP_CLOSED;
3206 }
3207
3208 return 0;
3209 }
3210
3211 ExecContext *unit_get_exec_context(Unit *u) {
3212 size_t offset;
3213 assert(u);
3214
3215 if (u->type < 0)
3216 return NULL;
3217
3218 offset = UNIT_VTABLE(u)->exec_context_offset;
3219 if (offset <= 0)
3220 return NULL;
3221
3222 return (ExecContext*) ((uint8_t*) u + offset);
3223 }
3224
3225 KillContext *unit_get_kill_context(Unit *u) {
3226 size_t offset;
3227 assert(u);
3228
3229 if (u->type < 0)
3230 return NULL;
3231
3232 offset = UNIT_VTABLE(u)->kill_context_offset;
3233 if (offset <= 0)
3234 return NULL;
3235
3236 return (KillContext*) ((uint8_t*) u + offset);
3237 }
3238
3239 CGroupContext *unit_get_cgroup_context(Unit *u) {
3240 size_t offset;
3241
3242 if (u->type < 0)
3243 return NULL;
3244
3245 offset = UNIT_VTABLE(u)->cgroup_context_offset;
3246 if (offset <= 0)
3247 return NULL;
3248
3249 return (CGroupContext*) ((uint8_t*) u + offset);
3250 }
3251
3252 ExecRuntime *unit_get_exec_runtime(Unit *u) {
3253 size_t offset;
3254
3255 if (u->type < 0)
3256 return NULL;
3257
3258 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3259 if (offset <= 0)
3260 return NULL;
3261
3262 return *(ExecRuntime**) ((uint8_t*) u + offset);
3263 }
3264
3265 static int unit_drop_in_dir(Unit *u, UnitSetPropertiesMode mode, bool transient, char **dir) {
3266 if (u->manager->running_as == SYSTEMD_USER) {
3267 int r;
3268
3269 if (mode == UNIT_PERSISTENT && !transient)
3270 r = user_config_home(dir);
3271 else
3272 r = user_runtime_dir(dir);
3273
3274 if (r == 0)
3275 return -ENOENT;
3276 return r;
3277 }
3278
3279 if (mode == UNIT_PERSISTENT && !transient)
3280 *dir = strdup("/etc/systemd/system");
3281 else
3282 *dir = strdup("/run/systemd/system");
3283 if (!*dir)
3284 return -ENOMEM;
3285
3286 return 0;
3287 }
3288
3289 static int unit_drop_in_file(Unit *u,
3290 UnitSetPropertiesMode mode, const char *name, char **p, char **q) {
3291 _cleanup_free_ char *dir = NULL;
3292 int r;
3293
3294 assert(u);
3295
3296 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3297 if (r < 0)
3298 return r;
3299
3300 return drop_in_file(dir, u->id, 50, name, p, q);
3301 }
3302
3303 int unit_write_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3304
3305 _cleanup_free_ char *dir = NULL, *p = NULL, *q = NULL;
3306 int r;
3307
3308 assert(u);
3309
3310 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3311 return 0;
3312
3313 r = unit_drop_in_dir(u, mode, u->transient, &dir);
3314 if (r < 0)
3315 return r;
3316
3317 r = write_drop_in(dir, u->id, 50, name, data);
3318 if (r < 0)
3319 return r;
3320
3321 r = drop_in_file(dir, u->id, 50, name, &p, &q);
3322 if (r < 0)
3323 return r;
3324
3325 r = strv_extend(&u->dropin_paths, q);
3326 if (r < 0)
3327 return r;
3328
3329 strv_sort(u->dropin_paths);
3330 strv_uniq(u->dropin_paths);
3331
3332 u->dropin_mtime = now(CLOCK_REALTIME);
3333
3334 return 0;
3335 }
3336
3337 int unit_write_drop_in_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3338 _cleanup_free_ char *p = NULL;
3339 va_list ap;
3340 int r;
3341
3342 assert(u);
3343 assert(name);
3344 assert(format);
3345
3346 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3347 return 0;
3348
3349 va_start(ap, format);
3350 r = vasprintf(&p, format, ap);
3351 va_end(ap);
3352
3353 if (r < 0)
3354 return -ENOMEM;
3355
3356 return unit_write_drop_in(u, mode, name, p);
3357 }
3358
3359 int unit_write_drop_in_private(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *data) {
3360 _cleanup_free_ char *ndata = NULL;
3361
3362 assert(u);
3363 assert(name);
3364 assert(data);
3365
3366 if (!UNIT_VTABLE(u)->private_section)
3367 return -EINVAL;
3368
3369 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3370 return 0;
3371
3372 ndata = strjoin("[", UNIT_VTABLE(u)->private_section, "]\n", data, NULL);
3373 if (!ndata)
3374 return -ENOMEM;
3375
3376 return unit_write_drop_in(u, mode, name, ndata);
3377 }
3378
3379 int unit_write_drop_in_private_format(Unit *u, UnitSetPropertiesMode mode, const char *name, const char *format, ...) {
3380 _cleanup_free_ char *p = NULL;
3381 va_list ap;
3382 int r;
3383
3384 assert(u);
3385 assert(name);
3386 assert(format);
3387
3388 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3389 return 0;
3390
3391 va_start(ap, format);
3392 r = vasprintf(&p, format, ap);
3393 va_end(ap);
3394
3395 if (r < 0)
3396 return -ENOMEM;
3397
3398 return unit_write_drop_in_private(u, mode, name, p);
3399 }
3400
3401 int unit_remove_drop_in(Unit *u, UnitSetPropertiesMode mode, const char *name) {
3402 _cleanup_free_ char *p = NULL, *q = NULL;
3403 int r;
3404
3405 assert(u);
3406
3407 if (!IN_SET(mode, UNIT_PERSISTENT, UNIT_RUNTIME))
3408 return 0;
3409
3410 r = unit_drop_in_file(u, mode, name, &p, &q);
3411 if (r < 0)
3412 return r;
3413
3414 if (unlink(q) < 0)
3415 r = errno == ENOENT ? 0 : -errno;
3416 else
3417 r = 1;
3418
3419 rmdir(p);
3420 return r;
3421 }
3422
3423 int unit_make_transient(Unit *u) {
3424 int r;
3425
3426 assert(u);
3427
3428 u->load_state = UNIT_STUB;
3429 u->load_error = 0;
3430 u->transient = true;
3431
3432 free(u->fragment_path);
3433 u->fragment_path = NULL;
3434
3435 if (u->manager->running_as == SYSTEMD_USER) {
3436 _cleanup_free_ char *c = NULL;
3437
3438 r = user_runtime_dir(&c);
3439 if (r < 0)
3440 return r;
3441 if (r == 0)
3442 return -ENOENT;
3443
3444 u->fragment_path = strjoin(c, "/", u->id, NULL);
3445 if (!u->fragment_path)
3446 return -ENOMEM;
3447
3448 mkdir_p(c, 0755);
3449 } else {
3450 u->fragment_path = strappend("/run/systemd/system/", u->id);
3451 if (!u->fragment_path)
3452 return -ENOMEM;
3453
3454 mkdir_p("/run/systemd/system", 0755);
3455 }
3456
3457 return write_string_file_atomic_label(u->fragment_path, "# Transient stub");
3458 }
3459
3460 int unit_kill_context(
3461 Unit *u,
3462 KillContext *c,
3463 KillOperation k,
3464 pid_t main_pid,
3465 pid_t control_pid,
3466 bool main_pid_alien) {
3467
3468 int sig, wait_for_exit = false, r;
3469
3470 assert(u);
3471 assert(c);
3472
3473 if (c->kill_mode == KILL_NONE)
3474 return 0;
3475
3476 switch (k) {
3477 case KILL_KILL:
3478 sig = SIGKILL;
3479 break;
3480 case KILL_ABORT:
3481 sig = SIGABRT;
3482 break;
3483 case KILL_TERMINATE:
3484 sig = c->kill_signal;
3485 break;
3486 default:
3487 assert_not_reached("KillOperation unknown");
3488 }
3489
3490 if (main_pid > 0) {
3491 r = kill_and_sigcont(main_pid, sig);
3492
3493 if (r < 0 && r != -ESRCH) {
3494 _cleanup_free_ char *comm = NULL;
3495 get_process_comm(main_pid, &comm);
3496
3497 log_unit_warning_errno(u, r, "Failed to kill main process " PID_FMT " (%s): %m", main_pid, strna(comm));
3498 } else {
3499 if (!main_pid_alien)
3500 wait_for_exit = true;
3501
3502 if (c->send_sighup && k != KILL_KILL)
3503 kill(main_pid, SIGHUP);
3504 }
3505 }
3506
3507 if (control_pid > 0) {
3508 r = kill_and_sigcont(control_pid, sig);
3509
3510 if (r < 0 && r != -ESRCH) {
3511 _cleanup_free_ char *comm = NULL;
3512 get_process_comm(control_pid, &comm);
3513
3514 log_unit_warning_errno(u, r, "Failed to kill control process " PID_FMT " (%s): %m", control_pid, strna(comm));
3515 } else {
3516 wait_for_exit = true;
3517
3518 if (c->send_sighup && k != KILL_KILL)
3519 kill(control_pid, SIGHUP);
3520 }
3521 }
3522
3523 if ((c->kill_mode == KILL_CONTROL_GROUP || (c->kill_mode == KILL_MIXED && k == KILL_KILL)) && u->cgroup_path) {
3524 _cleanup_set_free_ Set *pid_set = NULL;
3525
3526 /* Exclude the main/control pids from being killed via the cgroup */
3527 pid_set = unit_pid_set(main_pid, control_pid);
3528 if (!pid_set)
3529 return -ENOMEM;
3530
3531 r = cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, sig, true, true, false, pid_set);
3532 if (r < 0) {
3533 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
3534 log_unit_warning_errno(u, r, "Failed to kill control group: %m");
3535 } else if (r > 0) {
3536
3537 /* FIXME: For now, we will not wait for the
3538 * cgroup members to die, simply because
3539 * cgroup notification is unreliable. It
3540 * doesn't work at all in containers, and
3541 * outside of containers it can be confused
3542 * easily by leaving directories in the
3543 * cgroup. */
3544
3545 /* wait_for_exit = true; */
3546
3547 if (c->send_sighup && k != KILL_KILL) {
3548 set_free(pid_set);
3549
3550 pid_set = unit_pid_set(main_pid, control_pid);
3551 if (!pid_set)
3552 return -ENOMEM;
3553
3554 cg_kill_recursive(SYSTEMD_CGROUP_CONTROLLER, u->cgroup_path, SIGHUP, false, true, false, pid_set);
3555 }
3556 }
3557 }
3558
3559 return wait_for_exit;
3560 }
3561
3562 int unit_require_mounts_for(Unit *u, const char *path) {
3563 char prefix[strlen(path) + 1], *p;
3564 int r;
3565
3566 assert(u);
3567 assert(path);
3568
3569 /* Registers a unit for requiring a certain path and all its
3570 * prefixes. We keep a simple array of these paths in the
3571 * unit, since its usually short. However, we build a prefix
3572 * table for all possible prefixes so that new appearing mount
3573 * units can easily determine which units to make themselves a
3574 * dependency of. */
3575
3576 if (!path_is_absolute(path))
3577 return -EINVAL;
3578
3579 p = strdup(path);
3580 if (!p)
3581 return -ENOMEM;
3582
3583 path_kill_slashes(p);
3584
3585 if (!path_is_safe(p)) {
3586 free(p);
3587 return -EPERM;
3588 }
3589
3590 if (strv_contains(u->requires_mounts_for, p)) {
3591 free(p);
3592 return 0;
3593 }
3594
3595 r = strv_consume(&u->requires_mounts_for, p);
3596 if (r < 0)
3597 return r;
3598
3599 PATH_FOREACH_PREFIX_MORE(prefix, p) {
3600 Set *x;
3601
3602 x = hashmap_get(u->manager->units_requiring_mounts_for, prefix);
3603 if (!x) {
3604 char *q;
3605
3606 r = hashmap_ensure_allocated(&u->manager->units_requiring_mounts_for, &string_hash_ops);
3607 if (r < 0)
3608 return r;
3609
3610 q = strdup(prefix);
3611 if (!q)
3612 return -ENOMEM;
3613
3614 x = set_new(NULL);
3615 if (!x) {
3616 free(q);
3617 return -ENOMEM;
3618 }
3619
3620 r = hashmap_put(u->manager->units_requiring_mounts_for, q, x);
3621 if (r < 0) {
3622 free(q);
3623 set_free(x);
3624 return r;
3625 }
3626 }
3627
3628 r = set_put(x, u);
3629 if (r < 0)
3630 return r;
3631 }
3632
3633 return 0;
3634 }
3635
3636 int unit_setup_exec_runtime(Unit *u) {
3637 ExecRuntime **rt;
3638 size_t offset;
3639 Iterator i;
3640 Unit *other;
3641
3642 offset = UNIT_VTABLE(u)->exec_runtime_offset;
3643 assert(offset > 0);
3644
3645 /* Check if there already is an ExecRuntime for this unit? */
3646 rt = (ExecRuntime**) ((uint8_t*) u + offset);
3647 if (*rt)
3648 return 0;
3649
3650 /* Try to get it from somebody else */
3651 SET_FOREACH(other, u->dependencies[UNIT_JOINS_NAMESPACE_OF], i) {
3652
3653 *rt = unit_get_exec_runtime(other);
3654 if (*rt) {
3655 exec_runtime_ref(*rt);
3656 return 0;
3657 }
3658 }
3659
3660 return exec_runtime_make(rt, unit_get_exec_context(u), u->id);
3661 }
3662
3663 bool unit_type_supported(UnitType t) {
3664 if (_unlikely_(t < 0))
3665 return false;
3666 if (_unlikely_(t >= _UNIT_TYPE_MAX))
3667 return false;
3668
3669 if (!unit_vtable[t]->supported)
3670 return true;
3671
3672 return unit_vtable[t]->supported();
3673 }
3674
3675 static const char* const unit_active_state_table[_UNIT_ACTIVE_STATE_MAX] = {
3676 [UNIT_ACTIVE] = "active",
3677 [UNIT_RELOADING] = "reloading",
3678 [UNIT_INACTIVE] = "inactive",
3679 [UNIT_FAILED] = "failed",
3680 [UNIT_ACTIVATING] = "activating",
3681 [UNIT_DEACTIVATING] = "deactivating"
3682 };
3683
3684 DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
Unnamed repository; edit this file 'description' to name the repository.