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