1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
25 #include <sys/epoll.h>
26 #include <sys/timerfd.h>
36 #include "path-util.h"
37 #include "load-fragment.h"
38 #include "load-dropin.h"
40 #include "unit-name.h"
41 #include "specifier.h"
42 #include "dbus-unit.h"
44 #include "cgroup-util.h"
46 #include "cgroup-attr.h"
48 const UnitVTable
* const unit_vtable
[_UNIT_TYPE_MAX
] = {
49 [UNIT_SERVICE
] = &service_vtable
,
50 [UNIT_TIMER
] = &timer_vtable
,
51 [UNIT_SOCKET
] = &socket_vtable
,
52 [UNIT_TARGET
] = &target_vtable
,
53 [UNIT_DEVICE
] = &device_vtable
,
54 [UNIT_MOUNT
] = &mount_vtable
,
55 [UNIT_AUTOMOUNT
] = &automount_vtable
,
56 [UNIT_SNAPSHOT
] = &snapshot_vtable
,
57 [UNIT_SWAP
] = &swap_vtable
,
58 [UNIT_PATH
] = &path_vtable
61 Unit
*unit_new(Manager
*m
, size_t size
) {
65 assert(size
>= sizeof(Unit
));
71 u
->names
= set_new(string_hash_func
, string_compare_func
);
78 u
->type
= _UNIT_TYPE_INVALID
;
79 u
->deserialized_job
= _JOB_TYPE_INVALID
;
80 u
->default_dependencies
= true;
81 u
->unit_file_state
= _UNIT_FILE_STATE_INVALID
;
86 bool unit_has_name(Unit
*u
, const char *name
) {
90 return !!set_get(u
->names
, (char*) name
);
93 int unit_add_name(Unit
*u
, const char *text
) {
101 if (unit_name_is_template(text
)) {
105 s
= unit_name_replace_instance(text
, u
->instance
);
112 if (!unit_name_is_valid(s
, false)) {
117 assert_se((t
= unit_name_to_type(s
)) >= 0);
119 if (u
->type
!= _UNIT_TYPE_INVALID
&& t
!= u
->type
) {
124 if ((r
= unit_name_to_instance(s
, &i
)) < 0)
127 if (i
&& unit_vtable
[t
]->no_instances
) {
132 /* Ensure that this unit is either instanced or not instanced,
134 if (u
->type
!= _UNIT_TYPE_INVALID
&& !u
->instance
!= !i
) {
139 if (unit_vtable
[t
]->no_alias
&&
140 !set_isempty(u
->names
) &&
141 !set_get(u
->names
, s
)) {
146 if (hashmap_size(u
->manager
->units
) >= MANAGER_MAX_NAMES
) {
151 if ((r
= set_put(u
->names
, s
)) < 0) {
157 if ((r
= hashmap_put(u
->manager
->units
, s
, u
)) < 0) {
158 set_remove(u
->names
, s
);
162 if (u
->type
== _UNIT_TYPE_INVALID
) {
168 LIST_PREPEND(Unit
, units_by_type
, u
->manager
->units_by_type
[t
], u
);
170 if (UNIT_VTABLE(u
)->init
)
171 UNIT_VTABLE(u
)->init(u
);
175 unit_add_to_dbus_queue(u
);
185 int unit_choose_id(Unit
*u
, const char *name
) {
186 char *s
, *t
= NULL
, *i
;
192 if (unit_name_is_template(name
)) {
197 if (!(t
= unit_name_replace_instance(name
, u
->instance
)))
203 /* Selects one of the names of this unit as the id */
204 s
= set_get(u
->names
, (char*) name
);
210 if ((r
= unit_name_to_instance(s
, &i
)) < 0)
218 unit_add_to_dbus_queue(u
);
223 int unit_set_description(Unit
*u
, const char *description
) {
228 if (!(s
= strdup(description
)))
231 free(u
->description
);
234 unit_add_to_dbus_queue(u
);
238 bool unit_check_gc(Unit
*u
) {
241 if (u
->load_state
== UNIT_STUB
)
244 if (UNIT_VTABLE(u
)->no_gc
)
256 if (unit_active_state(u
) != UNIT_INACTIVE
)
259 if (UNIT_VTABLE(u
)->check_gc
)
260 if (UNIT_VTABLE(u
)->check_gc(u
))
266 void unit_add_to_load_queue(Unit
*u
) {
268 assert(u
->type
!= _UNIT_TYPE_INVALID
);
270 if (u
->load_state
!= UNIT_STUB
|| u
->in_load_queue
)
273 LIST_PREPEND(Unit
, load_queue
, u
->manager
->load_queue
, u
);
274 u
->in_load_queue
= true;
277 void unit_add_to_cleanup_queue(Unit
*u
) {
280 if (u
->in_cleanup_queue
)
283 LIST_PREPEND(Unit
, cleanup_queue
, u
->manager
->cleanup_queue
, u
);
284 u
->in_cleanup_queue
= true;
287 void unit_add_to_gc_queue(Unit
*u
) {
290 if (u
->in_gc_queue
|| u
->in_cleanup_queue
)
293 if (unit_check_gc(u
))
296 LIST_PREPEND(Unit
, gc_queue
, u
->manager
->gc_queue
, u
);
297 u
->in_gc_queue
= true;
299 u
->manager
->n_in_gc_queue
++;
301 if (u
->manager
->gc_queue_timestamp
<= 0)
302 u
->manager
->gc_queue_timestamp
= now(CLOCK_MONOTONIC
);
305 void unit_add_to_dbus_queue(Unit
*u
) {
307 assert(u
->type
!= _UNIT_TYPE_INVALID
);
309 if (u
->load_state
== UNIT_STUB
|| u
->in_dbus_queue
)
312 /* Shortcut things if nobody cares */
313 if (!bus_has_subscriber(u
->manager
)) {
314 u
->sent_dbus_new_signal
= true;
318 LIST_PREPEND(Unit
, dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
319 u
->in_dbus_queue
= true;
322 static void bidi_set_free(Unit
*u
, Set
*s
) {
328 /* Frees the set and makes sure we are dropped from the
329 * inverse pointers */
331 SET_FOREACH(other
, s
, i
) {
334 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
335 set_remove(other
->dependencies
[d
], u
);
337 unit_add_to_gc_queue(other
);
343 void unit_free(Unit
*u
) {
350 bus_unit_send_removed_signal(u
);
352 if (u
->load_state
!= UNIT_STUB
)
353 if (UNIT_VTABLE(u
)->done
)
354 UNIT_VTABLE(u
)->done(u
);
356 SET_FOREACH(t
, u
->names
, i
)
357 hashmap_remove_value(u
->manager
->units
, t
, u
);
371 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
372 bidi_set_free(u
, u
->dependencies
[d
]);
374 if (u
->requires_mounts_for
) {
375 LIST_REMOVE(Unit
, has_requires_mounts_for
, u
->manager
->has_requires_mounts_for
, u
);
376 strv_free(u
->requires_mounts_for
);
379 if (u
->type
!= _UNIT_TYPE_INVALID
)
380 LIST_REMOVE(Unit
, units_by_type
, u
->manager
->units_by_type
[u
->type
], u
);
382 if (u
->in_load_queue
)
383 LIST_REMOVE(Unit
, load_queue
, u
->manager
->load_queue
, u
);
385 if (u
->in_dbus_queue
)
386 LIST_REMOVE(Unit
, dbus_queue
, u
->manager
->dbus_unit_queue
, u
);
388 if (u
->in_cleanup_queue
)
389 LIST_REMOVE(Unit
, cleanup_queue
, u
->manager
->cleanup_queue
, u
);
391 if (u
->in_gc_queue
) {
392 LIST_REMOVE(Unit
, gc_queue
, u
->manager
->gc_queue
, u
);
393 u
->manager
->n_in_gc_queue
--;
396 cgroup_bonding_free_list(u
->cgroup_bondings
, u
->manager
->n_reloading
<= 0);
397 cgroup_attribute_free_list(u
->cgroup_attributes
);
399 free(u
->description
);
400 free(u
->fragment_path
);
403 set_free_free(u
->names
);
405 condition_free_list(u
->conditions
);
408 unit_ref_unset(u
->refs
);
413 UnitActiveState
unit_active_state(Unit
*u
) {
416 if (u
->load_state
== UNIT_MERGED
)
417 return unit_active_state(unit_follow_merge(u
));
419 /* After a reload it might happen that a unit is not correctly
420 * loaded but still has a process around. That's why we won't
421 * shortcut failed loading to UNIT_INACTIVE_FAILED. */
423 return UNIT_VTABLE(u
)->active_state(u
);
426 const char* unit_sub_state_to_string(Unit
*u
) {
429 return UNIT_VTABLE(u
)->sub_state_to_string(u
);
432 static void complete_move(Set
**s
, Set
**other
) {
440 set_move(*s
, *other
);
447 static void merge_names(Unit
*u
, Unit
*other
) {
454 complete_move(&u
->names
, &other
->names
);
456 set_free_free(other
->names
);
460 SET_FOREACH(t
, u
->names
, i
)
461 assert_se(hashmap_replace(u
->manager
->units
, t
, u
) == 0);
464 static void merge_dependencies(Unit
*u
, Unit
*other
, UnitDependency d
) {
471 assert(d
< _UNIT_DEPENDENCY_MAX
);
473 /* Fix backwards pointers */
474 SET_FOREACH(back
, other
->dependencies
[d
], i
) {
477 for (k
= 0; k
< _UNIT_DEPENDENCY_MAX
; k
++)
478 if ((r
= set_remove_and_put(back
->dependencies
[k
], other
, u
)) < 0) {
481 set_remove(back
->dependencies
[k
], other
);
483 assert(r
== -ENOENT
);
487 complete_move(&u
->dependencies
[d
], &other
->dependencies
[d
]);
489 set_free(other
->dependencies
[d
]);
490 other
->dependencies
[d
] = NULL
;
493 int unit_merge(Unit
*u
, Unit
*other
) {
498 assert(u
->manager
== other
->manager
);
499 assert(u
->type
!= _UNIT_TYPE_INVALID
);
501 other
= unit_follow_merge(other
);
506 if (u
->type
!= other
->type
)
509 if (!u
->instance
!= !other
->instance
)
512 if (other
->load_state
!= UNIT_STUB
&&
513 other
->load_state
!= UNIT_ERROR
)
522 if (!UNIT_IS_INACTIVE_OR_FAILED(unit_active_state(other
)))
526 merge_names(u
, other
);
528 /* Redirect all references */
530 unit_ref_set(other
->refs
, u
);
532 /* Merge dependencies */
533 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++)
534 merge_dependencies(u
, other
, d
);
536 other
->load_state
= UNIT_MERGED
;
537 other
->merged_into
= u
;
539 /* If there is still some data attached to the other node, we
540 * don't need it anymore, and can free it. */
541 if (other
->load_state
!= UNIT_STUB
)
542 if (UNIT_VTABLE(other
)->done
)
543 UNIT_VTABLE(other
)->done(other
);
545 unit_add_to_dbus_queue(u
);
546 unit_add_to_cleanup_queue(other
);
551 int unit_merge_by_name(Unit
*u
, const char *name
) {
559 if (unit_name_is_template(name
)) {
563 if (!(s
= unit_name_replace_instance(name
, u
->instance
)))
569 if (!(other
= manager_get_unit(u
->manager
, name
)))
570 r
= unit_add_name(u
, name
);
572 r
= unit_merge(u
, other
);
578 Unit
* unit_follow_merge(Unit
*u
) {
581 while (u
->load_state
== UNIT_MERGED
)
582 assert_se(u
= u
->merged_into
);
587 int unit_add_exec_dependencies(Unit
*u
, ExecContext
*c
) {
593 if (c
->std_output
!= EXEC_OUTPUT_KMSG
&&
594 c
->std_output
!= EXEC_OUTPUT_SYSLOG
&&
595 c
->std_output
!= EXEC_OUTPUT_JOURNAL
&&
596 c
->std_output
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
597 c
->std_output
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
&&
598 c
->std_output
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
599 c
->std_error
!= EXEC_OUTPUT_KMSG
&&
600 c
->std_error
!= EXEC_OUTPUT_SYSLOG
&&
601 c
->std_error
!= EXEC_OUTPUT_JOURNAL
&&
602 c
->std_error
!= EXEC_OUTPUT_KMSG_AND_CONSOLE
&&
603 c
->std_error
!= EXEC_OUTPUT_JOURNAL_AND_CONSOLE
&&
604 c
->std_error
!= EXEC_OUTPUT_SYSLOG_AND_CONSOLE
)
607 /* If syslog or kernel logging is requested, make sure our own
608 * logging daemon is run first. */
610 if (u
->manager
->running_as
== MANAGER_SYSTEM
)
611 if ((r
= unit_add_two_dependencies_by_name(u
, UNIT_REQUIRES
, UNIT_AFTER
, SPECIAL_JOURNALD_SOCKET
, NULL
, true)) < 0)
617 const char *unit_description(Unit
*u
) {
621 return u
->description
;
626 void unit_dump(Unit
*u
, FILE *f
, const char *prefix
) {
633 timestamp1
[FORMAT_TIMESTAMP_MAX
],
634 timestamp2
[FORMAT_TIMESTAMP_MAX
],
635 timestamp3
[FORMAT_TIMESTAMP_MAX
],
636 timestamp4
[FORMAT_TIMESTAMP_MAX
],
637 timespan
[FORMAT_TIMESPAN_MAX
];
641 assert(u
->type
>= 0);
645 p2
= strappend(prefix
, "\t");
646 prefix2
= p2
? p2
: prefix
;
650 "%s\tDescription: %s\n"
652 "%s\tUnit Load State: %s\n"
653 "%s\tUnit Active State: %s\n"
654 "%s\tInactive Exit Timestamp: %s\n"
655 "%s\tActive Enter Timestamp: %s\n"
656 "%s\tActive Exit Timestamp: %s\n"
657 "%s\tInactive Enter Timestamp: %s\n"
658 "%s\tGC Check Good: %s\n"
659 "%s\tNeed Daemon Reload: %s\n",
661 prefix
, unit_description(u
),
662 prefix
, strna(u
->instance
),
663 prefix
, unit_load_state_to_string(u
->load_state
),
664 prefix
, unit_active_state_to_string(unit_active_state(u
)),
665 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->inactive_exit_timestamp
.realtime
)),
666 prefix
, strna(format_timestamp(timestamp2
, sizeof(timestamp2
), u
->active_enter_timestamp
.realtime
)),
667 prefix
, strna(format_timestamp(timestamp3
, sizeof(timestamp3
), u
->active_exit_timestamp
.realtime
)),
668 prefix
, strna(format_timestamp(timestamp4
, sizeof(timestamp4
), u
->inactive_enter_timestamp
.realtime
)),
669 prefix
, yes_no(unit_check_gc(u
)),
670 prefix
, yes_no(unit_need_daemon_reload(u
)));
672 SET_FOREACH(t
, u
->names
, i
)
673 fprintf(f
, "%s\tName: %s\n", prefix
, t
);
675 if ((following
= unit_following(u
)))
676 fprintf(f
, "%s\tFollowing: %s\n", prefix
, following
->id
);
678 if (u
->fragment_path
)
679 fprintf(f
, "%s\tFragment Path: %s\n", prefix
, u
->fragment_path
);
681 if (u
->job_timeout
> 0)
682 fprintf(f
, "%s\tJob Timeout: %s\n", prefix
, format_timespan(timespan
, sizeof(timespan
), u
->job_timeout
));
684 condition_dump_list(u
->conditions
, f
, prefix
);
686 if (dual_timestamp_is_set(&u
->condition_timestamp
))
688 "%s\tCondition Timestamp: %s\n"
689 "%s\tCondition Result: %s\n",
690 prefix
, strna(format_timestamp(timestamp1
, sizeof(timestamp1
), u
->condition_timestamp
.realtime
)),
691 prefix
, yes_no(u
->condition_result
));
693 for (d
= 0; d
< _UNIT_DEPENDENCY_MAX
; d
++) {
696 SET_FOREACH(other
, u
->dependencies
[d
], i
)
697 fprintf(f
, "%s\t%s: %s\n", prefix
, unit_dependency_to_string(d
), other
->id
);
700 if (!strv_isempty(u
->requires_mounts_for
)) {
704 "%s\tRequiresMountsFor:", prefix
);
706 STRV_FOREACH(j
, u
->requires_mounts_for
)
707 fprintf(f
, " %s", *j
);
712 if (u
->load_state
== UNIT_LOADED
) {
717 "%s\tStopWhenUnneeded: %s\n"
718 "%s\tRefuseManualStart: %s\n"
719 "%s\tRefuseManualStop: %s\n"
720 "%s\tDefaultDependencies: %s\n"
721 "%s\tOnFailureIsolate: %s\n"
722 "%s\tIgnoreOnIsolate: %s\n"
723 "%s\tIgnoreOnSnapshot: %s\n",
724 prefix
, yes_no(u
->stop_when_unneeded
),
725 prefix
, yes_no(u
->refuse_manual_start
),
726 prefix
, yes_no(u
->refuse_manual_stop
),
727 prefix
, yes_no(u
->default_dependencies
),
728 prefix
, yes_no(u
->on_failure_isolate
),
729 prefix
, yes_no(u
->ignore_on_isolate
),
730 prefix
, yes_no(u
->ignore_on_snapshot
));
732 LIST_FOREACH(by_unit
, b
, u
->cgroup_bondings
)
733 fprintf(f
, "%s\tControlGroup: %s:%s\n",
734 prefix
, b
->controller
, b
->path
);
736 LIST_FOREACH(by_unit
, a
, u
->cgroup_attributes
) {
740 a
->map_callback(a
->controller
, a
->name
, a
->value
, &v
);
742 fprintf(f
, "%s\tControlGroupAttribute: %s %s \"%s\"\n",
743 prefix
, a
->controller
, a
->name
, v
? v
: a
->value
);
748 if (UNIT_VTABLE(u
)->dump
)
749 UNIT_VTABLE(u
)->dump(u
, f
, prefix2
);
751 } else if (u
->load_state
== UNIT_MERGED
)
753 "%s\tMerged into: %s\n",
754 prefix
, u
->merged_into
->id
);
755 else if (u
->load_state
== UNIT_ERROR
)
756 fprintf(f
, "%s\tLoad Error Code: %s\n", prefix
, strerror(-u
->load_error
));
760 job_dump(u
->job
, f
, prefix2
);
763 job_dump(u
->nop_job
, f
, prefix2
);
768 /* Common implementation for multiple backends */
769 int unit_load_fragment_and_dropin(Unit
*u
) {
774 /* Load a .service file */
775 if ((r
= unit_load_fragment(u
)) < 0)
778 if (u
->load_state
== UNIT_STUB
)
781 /* Load drop-in directory data */
782 if ((r
= unit_load_dropin(unit_follow_merge(u
))) < 0)
788 /* Common implementation for multiple backends */
789 int unit_load_fragment_and_dropin_optional(Unit
*u
) {
794 /* Same as unit_load_fragment_and_dropin(), but whether
795 * something can be loaded or not doesn't matter. */
797 /* Load a .service file */
798 if ((r
= unit_load_fragment(u
)) < 0)
801 if (u
->load_state
== UNIT_STUB
)
802 u
->load_state
= UNIT_LOADED
;
804 /* Load drop-in directory data */
805 if ((r
= unit_load_dropin(unit_follow_merge(u
))) < 0)
811 int unit_add_default_target_dependency(Unit
*u
, Unit
*target
) {
815 if (target
->type
!= UNIT_TARGET
)
818 /* Only add the dependency if both units are loaded, so that
819 * that loop check below is reliable */
820 if (u
->load_state
!= UNIT_LOADED
||
821 target
->load_state
!= UNIT_LOADED
)
824 /* If either side wants no automatic dependencies, then let's
826 if (!u
->default_dependencies
||
827 !target
->default_dependencies
)
830 /* Don't create loops */
831 if (set_get(target
->dependencies
[UNIT_BEFORE
], u
))
834 return unit_add_dependency(target
, UNIT_AFTER
, u
, true);
837 static int unit_add_default_dependencies(Unit
*u
) {
838 static const UnitDependency deps
[] = {
840 UNIT_REQUIRED_BY_OVERRIDABLE
,
852 for (k
= 0; k
< ELEMENTSOF(deps
); k
++)
853 SET_FOREACH(target
, u
->dependencies
[deps
[k
]], i
)
854 if ((r
= unit_add_default_target_dependency(u
, target
)) < 0)
860 int unit_load(Unit
*u
) {
865 if (u
->in_load_queue
) {
866 LIST_REMOVE(Unit
, load_queue
, u
->manager
->load_queue
, u
);
867 u
->in_load_queue
= false;
870 if (u
->type
== _UNIT_TYPE_INVALID
)
873 if (u
->load_state
!= UNIT_STUB
)
876 if (UNIT_VTABLE(u
)->load
)
877 if ((r
= UNIT_VTABLE(u
)->load(u
)) < 0)
880 if (u
->load_state
== UNIT_STUB
) {
885 if (u
->load_state
== UNIT_LOADED
&&
886 u
->default_dependencies
)
887 if ((r
= unit_add_default_dependencies(u
)) < 0)
890 if (u
->load_state
== UNIT_LOADED
) {
891 r
= unit_add_mount_links(u
);
896 if (u
->on_failure_isolate
&&
897 set_size(u
->dependencies
[UNIT_ON_FAILURE
]) > 1) {
899 log_error("More than one OnFailure= dependencies specified for %s but OnFailureIsolate= enabled. Refusing.",
906 assert((u
->load_state
!= UNIT_MERGED
) == !u
->merged_into
);
908 unit_add_to_dbus_queue(unit_follow_merge(u
));
909 unit_add_to_gc_queue(u
);
914 u
->load_state
= UNIT_ERROR
;
916 unit_add_to_dbus_queue(u
);
917 unit_add_to_gc_queue(u
);
919 log_debug("Failed to load configuration for %s: %s", u
->id
, strerror(-r
));
924 bool unit_condition_test(Unit
*u
) {
927 dual_timestamp_get(&u
->condition_timestamp
);
928 u
->condition_result
= condition_test_list(u
->conditions
);
930 return u
->condition_result
;
934 * -EBADR: This unit type does not support starting.
935 * -EALREADY: Unit is already started.
936 * -EAGAIN: An operation is already in progress. Retry later.
937 * -ECANCELED: Too many requests for now.
939 int unit_start(Unit
*u
) {
940 UnitActiveState state
;
945 if (u
->load_state
!= UNIT_LOADED
)
948 /* If this is already started, then this will succeed. Note
949 * that this will even succeed if this unit is not startable
950 * by the user. This is relied on to detect when we need to
951 * wait for units and when waiting is finished. */
952 state
= unit_active_state(u
);
953 if (UNIT_IS_ACTIVE_OR_RELOADING(state
))
956 /* If the conditions failed, don't do anything at all. If we
957 * already are activating this call might still be useful to
958 * speed up activation in case there is some hold-off time,
959 * but we don't want to recheck the condition in that case. */
960 if (state
!= UNIT_ACTIVATING
&&
961 !unit_condition_test(u
)) {
962 log_debug("Starting of %s requested but condition failed. Ignoring.", u
->id
);
966 /* Forward to the main object, if we aren't it. */
967 if ((following
= unit_following(u
))) {
968 log_debug("Redirecting start request from %s to %s.", u
->id
, following
->id
);
969 return unit_start(following
);
972 /* If it is stopped, but we cannot start it, then fail */
973 if (!UNIT_VTABLE(u
)->start
)
976 /* We don't suppress calls to ->start() here when we are
977 * already starting, to allow this request to be used as a
978 * "hurry up" call, for example when the unit is in some "auto
979 * restart" state where it waits for a holdoff timer to elapse
980 * before it will start again. */
982 unit_add_to_dbus_queue(u
);
984 unit_status_printf(u
, "", "Starting %s...", unit_description(u
));
985 return UNIT_VTABLE(u
)->start(u
);
988 bool unit_can_start(Unit
*u
) {
991 return !!UNIT_VTABLE(u
)->start
;
994 bool unit_can_isolate(Unit
*u
) {
997 return unit_can_start(u
) &&
1002 * -EBADR: This unit type does not support stopping.
1003 * -EALREADY: Unit is already stopped.
1004 * -EAGAIN: An operation is already in progress. Retry later.
1006 int unit_stop(Unit
*u
) {
1007 UnitActiveState state
;
1012 state
= unit_active_state(u
);
1013 if (UNIT_IS_INACTIVE_OR_FAILED(state
))
1016 if ((following
= unit_following(u
))) {
1017 log_debug("Redirecting stop request from %s to %s.", u
->id
, following
->id
);
1018 return unit_stop(following
);
1021 if (!UNIT_VTABLE(u
)->stop
)
1024 unit_add_to_dbus_queue(u
);
1026 unit_status_printf(u
, "", "Stopping %s...", unit_description(u
));
1027 return UNIT_VTABLE(u
)->stop(u
);
1031 * -EBADR: This unit type does not support reloading.
1032 * -ENOEXEC: Unit is not started.
1033 * -EAGAIN: An operation is already in progress. Retry later.
1035 int unit_reload(Unit
*u
) {
1036 UnitActiveState state
;
1041 if (u
->load_state
!= UNIT_LOADED
)
1044 if (!unit_can_reload(u
))
1047 state
= unit_active_state(u
);
1048 if (state
== UNIT_RELOADING
)
1051 if (state
!= UNIT_ACTIVE
)
1054 if ((following
= unit_following(u
))) {
1055 log_debug("Redirecting reload request from %s to %s.", u
->id
, following
->id
);
1056 return unit_reload(following
);
1059 unit_add_to_dbus_queue(u
);
1060 return UNIT_VTABLE(u
)->reload(u
);
1063 bool unit_can_reload(Unit
*u
) {
1066 if (!UNIT_VTABLE(u
)->reload
)
1069 if (!UNIT_VTABLE(u
)->can_reload
)
1072 return UNIT_VTABLE(u
)->can_reload(u
);
1075 static void unit_check_unneeded(Unit
*u
) {
1081 /* If this service shall be shut down when unneeded then do
1084 if (!u
->stop_when_unneeded
)
1087 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
1090 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRED_BY
], i
)
1091 if (unit_pending_active(other
))
1094 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRED_BY_OVERRIDABLE
], i
)
1095 if (unit_pending_active(other
))
1098 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTED_BY
], i
)
1099 if (unit_pending_active(other
))
1102 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1103 if (unit_pending_active(other
))
1106 log_info("Service %s is not needed anymore. Stopping.", u
->id
);
1108 /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
1109 manager_add_job(u
->manager
, JOB_STOP
, u
, JOB_FAIL
, true, NULL
, NULL
);
1112 static void retroactively_start_dependencies(Unit
*u
) {
1117 assert(UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)));
1119 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1120 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1121 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1122 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1124 SET_FOREACH(other
, u
->dependencies
[UNIT_BIND_TO
], i
)
1125 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1126 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1127 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1129 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES_OVERRIDABLE
], i
)
1130 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1131 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1132 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, false, NULL
, NULL
);
1134 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1135 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1136 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1137 manager_add_job(u
->manager
, JOB_START
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1139 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1140 if (!set_get(u
->dependencies
[UNIT_AFTER
], other
) &&
1141 !UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other
)))
1142 manager_add_job(u
->manager
, JOB_START
, other
, JOB_FAIL
, false, NULL
, NULL
);
1144 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTS
], i
)
1145 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1146 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1148 SET_FOREACH(other
, u
->dependencies
[UNIT_CONFLICTED_BY
], i
)
1149 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1150 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1153 static void retroactively_stop_dependencies(Unit
*u
) {
1158 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1160 /* Pull down units which are bound to us recursively if enabled */
1161 SET_FOREACH(other
, u
->dependencies
[UNIT_BOUND_BY
], i
)
1162 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1163 manager_add_job(u
->manager
, JOB_STOP
, other
, JOB_REPLACE
, true, NULL
, NULL
);
1166 static void check_unneeded_dependencies(Unit
*u
) {
1171 assert(UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)));
1173 /* Garbage collect services that might not be needed anymore, if enabled */
1174 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES
], i
)
1175 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1176 unit_check_unneeded(other
);
1177 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUIRES_OVERRIDABLE
], i
)
1178 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1179 unit_check_unneeded(other
);
1180 SET_FOREACH(other
, u
->dependencies
[UNIT_WANTS
], i
)
1181 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1182 unit_check_unneeded(other
);
1183 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE
], i
)
1184 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1185 unit_check_unneeded(other
);
1186 SET_FOREACH(other
, u
->dependencies
[UNIT_REQUISITE_OVERRIDABLE
], i
)
1187 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1188 unit_check_unneeded(other
);
1189 SET_FOREACH(other
, u
->dependencies
[UNIT_BIND_TO
], i
)
1190 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other
)))
1191 unit_check_unneeded(other
);
1194 void unit_trigger_on_failure(Unit
*u
) {
1200 if (set_size(u
->dependencies
[UNIT_ON_FAILURE
]) <= 0)
1203 log_info("Triggering OnFailure= dependencies of %s.", u
->id
);
1205 SET_FOREACH(other
, u
->dependencies
[UNIT_ON_FAILURE
], i
) {
1208 if ((r
= manager_add_job(u
->manager
, JOB_START
, other
, u
->on_failure_isolate
? JOB_ISOLATE
: JOB_REPLACE
, true, NULL
, NULL
)) < 0)
1209 log_error("Failed to enqueue OnFailure= job: %s", strerror(-r
));
1213 void unit_notify(Unit
*u
, UnitActiveState os
, UnitActiveState ns
, bool reload_success
) {
1217 assert(os
< _UNIT_ACTIVE_STATE_MAX
);
1218 assert(ns
< _UNIT_ACTIVE_STATE_MAX
);
1220 /* Note that this is called for all low-level state changes,
1221 * even if they might map to the same high-level
1222 * UnitActiveState! That means that ns == os is OK an expected
1223 * behaviour here. For example: if a mount point is remounted
1224 * this function will be called too! */
1226 if (u
->manager
->n_reloading
<= 0) {
1229 dual_timestamp_get(&ts
);
1231 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && !UNIT_IS_INACTIVE_OR_FAILED(ns
))
1232 u
->inactive_exit_timestamp
= ts
;
1233 else if (!UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_INACTIVE_OR_FAILED(ns
))
1234 u
->inactive_enter_timestamp
= ts
;
1236 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
) && UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1237 u
->active_enter_timestamp
= ts
;
1238 else if (UNIT_IS_ACTIVE_OR_RELOADING(os
) && !UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1239 u
->active_exit_timestamp
= ts
;
1241 timer_unit_notify(u
, ns
);
1242 path_unit_notify(u
, ns
);
1245 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1246 cgroup_bonding_trim_list(u
->cgroup_bondings
, true);
1251 if (u
->job
->state
== JOB_WAITING
)
1253 /* So we reached a different state for this
1254 * job. Let's see if we can run it now if it
1255 * failed previously due to EAGAIN. */
1256 job_add_to_run_queue(u
->job
);
1258 /* Let's check whether this state change constitutes a
1259 * finished job, or maybe contradicts a running job and
1260 * hence needs to invalidate jobs. */
1262 switch (u
->job
->type
) {
1265 case JOB_VERIFY_ACTIVE
:
1267 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
))
1268 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1269 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_ACTIVATING
) {
1272 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1273 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1279 case JOB_RELOAD_OR_START
:
1281 if (u
->job
->state
== JOB_RUNNING
) {
1282 if (ns
== UNIT_ACTIVE
)
1283 job_finish_and_invalidate(u
->job
, reload_success
? JOB_DONE
: JOB_FAILED
, true);
1284 else if (ns
!= UNIT_ACTIVATING
&& ns
!= UNIT_RELOADING
) {
1287 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1288 job_finish_and_invalidate(u
->job
, ns
== UNIT_FAILED
? JOB_FAILED
: JOB_DONE
, true);
1296 case JOB_TRY_RESTART
:
1298 if (UNIT_IS_INACTIVE_OR_FAILED(ns
))
1299 job_finish_and_invalidate(u
->job
, JOB_DONE
, true);
1300 else if (u
->job
->state
== JOB_RUNNING
&& ns
!= UNIT_DEACTIVATING
) {
1302 job_finish_and_invalidate(u
->job
, JOB_FAILED
, true);
1308 assert_not_reached("Job type unknown");
1314 if (u
->manager
->n_reloading
<= 0) {
1316 /* If this state change happened without being
1317 * requested by a job, then let's retroactively start
1318 * or stop dependencies. We skip that step when
1319 * deserializing, since we don't want to create any
1320 * additional jobs just because something is already
1324 if (UNIT_IS_INACTIVE_OR_FAILED(os
) && UNIT_IS_ACTIVE_OR_ACTIVATING(ns
))
1325 retroactively_start_dependencies(u
);
1326 else if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1327 retroactively_stop_dependencies(u
);
1330 /* stop unneeded units regardless if going down was expected or not */
1331 if (UNIT_IS_ACTIVE_OR_ACTIVATING(os
) && UNIT_IS_INACTIVE_OR_DEACTIVATING(ns
))
1332 check_unneeded_dependencies(u
);
1334 if (ns
!= os
&& ns
== UNIT_FAILED
) {
1335 log_notice("Unit %s entered failed state.", u
->id
);
1336 unit_trigger_on_failure(u
);
1340 /* Some names are special */
1341 if (UNIT_IS_ACTIVE_OR_RELOADING(ns
)) {
1343 if (unit_has_name(u
, SPECIAL_DBUS_SERVICE
))
1344 /* The bus just might have become available,
1345 * hence try to connect to it, if we aren't
1347 bus_init(u
->manager
, true);
1349 if (u
->type
== UNIT_SERVICE
&&
1350 !UNIT_IS_ACTIVE_OR_RELOADING(os
) &&
1351 u
->manager
->n_reloading
<= 0) {
1352 /* Write audit record if we have just finished starting up */
1353 manager_send_unit_audit(u
->manager
, u
, AUDIT_SERVICE_START
, true);
1357 if (!UNIT_IS_ACTIVE_OR_RELOADING(os
))
1358 manager_send_unit_plymouth(u
->manager
, u
);
1362 /* We don't care about D-Bus here, since we'll get an
1363 * asynchronous notification for it anyway. */
1365 if (u
->type
== UNIT_SERVICE
&&
1366 UNIT_IS_INACTIVE_OR_FAILED(ns
) &&
1367 !UNIT_IS_INACTIVE_OR_FAILED(os
) &&
1368 u
->manager
->n_reloading
<= 0) {
1370 /* Hmm, if there was no start record written
1371 * write it now, so that we always have a nice
1374 manager_send_unit_audit(u
->manager
, u
, AUDIT_SERVICE_START
, ns
== UNIT_INACTIVE
);
1376 if (ns
== UNIT_INACTIVE
)
1377 manager_send_unit_audit(u
->manager
, u
, AUDIT_SERVICE_STOP
, true);
1379 /* Write audit record if we have just finished shutting down */
1380 manager_send_unit_audit(u
->manager
, u
, AUDIT_SERVICE_STOP
, ns
== UNIT_INACTIVE
);
1382 u
->in_audit
= false;
1386 manager_recheck_journal(u
->manager
);
1388 /* Maybe we finished startup and are now ready for being
1389 * stopped because unneeded? */
1390 unit_check_unneeded(u
);
1392 unit_add_to_dbus_queue(u
);
1393 unit_add_to_gc_queue(u
);
1396 int unit_watch_fd(Unit
*u
, int fd
, uint32_t events
, Watch
*w
) {
1397 struct epoll_event ev
;
1402 assert(w
->type
== WATCH_INVALID
|| (w
->type
== WATCH_FD
&& w
->fd
== fd
&& w
->data
.unit
== u
));
1408 if (epoll_ctl(u
->manager
->epoll_fd
,
1409 w
->type
== WATCH_INVALID
? EPOLL_CTL_ADD
: EPOLL_CTL_MOD
,
1421 void unit_unwatch_fd(Unit
*u
, Watch
*w
) {
1425 if (w
->type
== WATCH_INVALID
)
1428 assert(w
->type
== WATCH_FD
);
1429 assert(w
->data
.unit
== u
);
1430 assert_se(epoll_ctl(u
->manager
->epoll_fd
, EPOLL_CTL_DEL
, w
->fd
, NULL
) >= 0);
1433 w
->type
= WATCH_INVALID
;
1434 w
->data
.unit
= NULL
;
1437 int unit_watch_pid(Unit
*u
, pid_t pid
) {
1441 /* Watch a specific PID. We only support one unit watching
1442 * each PID for now. */
1444 return hashmap_put(u
->manager
->watch_pids
, LONG_TO_PTR(pid
), u
);
1447 void unit_unwatch_pid(Unit
*u
, pid_t pid
) {
1451 hashmap_remove_value(u
->manager
->watch_pids
, LONG_TO_PTR(pid
), u
);
1454 int unit_watch_timer(Unit
*u
, usec_t delay
, Watch
*w
) {
1455 struct itimerspec its
;
1461 assert(w
->type
== WATCH_INVALID
|| (w
->type
== WATCH_UNIT_TIMER
&& w
->data
.unit
== u
));
1463 /* This will try to reuse the old timer if there is one */
1465 if (w
->type
== WATCH_UNIT_TIMER
) {
1466 assert(w
->data
.unit
== u
);
1471 } else if (w
->type
== WATCH_INVALID
) {
1474 if ((fd
= timerfd_create(CLOCK_MONOTONIC
, TFD_NONBLOCK
|TFD_CLOEXEC
)) < 0)
1477 assert_not_reached("Invalid watch type");
1482 /* Set absolute time in the past, but not 0, since we
1483 * don't want to disarm the timer */
1484 its
.it_value
.tv_sec
= 0;
1485 its
.it_value
.tv_nsec
= 1;
1487 flags
= TFD_TIMER_ABSTIME
;
1489 timespec_store(&its
.it_value
, delay
);
1493 /* This will also flush the elapse counter */
1494 if (timerfd_settime(fd
, flags
, &its
, NULL
) < 0)
1497 if (w
->type
== WATCH_INVALID
) {
1498 struct epoll_event ev
;
1502 ev
.events
= EPOLLIN
;
1504 if (epoll_ctl(u
->manager
->epoll_fd
, EPOLL_CTL_ADD
, fd
, &ev
) < 0)
1508 w
->type
= WATCH_UNIT_TIMER
;
1516 close_nointr_nofail(fd
);
1521 void unit_unwatch_timer(Unit
*u
, Watch
*w
) {
1525 if (w
->type
== WATCH_INVALID
)
1528 assert(w
->type
== WATCH_UNIT_TIMER
);
1529 assert(w
->data
.unit
== u
);
1532 assert_se(epoll_ctl(u
->manager
->epoll_fd
, EPOLL_CTL_DEL
, w
->fd
, NULL
) >= 0);
1533 close_nointr_nofail(w
->fd
);
1536 w
->type
= WATCH_INVALID
;
1537 w
->data
.unit
= NULL
;
1540 bool unit_job_is_applicable(Unit
*u
, JobType j
) {
1542 assert(j
>= 0 && j
< _JOB_TYPE_MAX
);
1546 case JOB_VERIFY_ACTIVE
:
1553 case JOB_TRY_RESTART
:
1554 return unit_can_start(u
);
1557 return unit_can_reload(u
);
1559 case JOB_RELOAD_OR_START
:
1560 return unit_can_reload(u
) && unit_can_start(u
);
1563 assert_not_reached("Invalid job type");
1567 int unit_add_dependency(Unit
*u
, UnitDependency d
, Unit
*other
, bool add_reference
) {
1569 static const UnitDependency inverse_table
[_UNIT_DEPENDENCY_MAX
] = {
1570 [UNIT_REQUIRES
] = UNIT_REQUIRED_BY
,
1571 [UNIT_REQUIRES_OVERRIDABLE
] = UNIT_REQUIRED_BY_OVERRIDABLE
,
1572 [UNIT_WANTS
] = UNIT_WANTED_BY
,
1573 [UNIT_REQUISITE
] = UNIT_REQUIRED_BY
,
1574 [UNIT_REQUISITE_OVERRIDABLE
] = UNIT_REQUIRED_BY_OVERRIDABLE
,
1575 [UNIT_BIND_TO
] = UNIT_BOUND_BY
,
1576 [UNIT_REQUIRED_BY
] = _UNIT_DEPENDENCY_INVALID
,
1577 [UNIT_REQUIRED_BY_OVERRIDABLE
] = _UNIT_DEPENDENCY_INVALID
,
1578 [UNIT_WANTED_BY
] = _UNIT_DEPENDENCY_INVALID
,
1579 [UNIT_BOUND_BY
] = UNIT_BIND_TO
,
1580 [UNIT_CONFLICTS
] = UNIT_CONFLICTED_BY
,
1581 [UNIT_CONFLICTED_BY
] = UNIT_CONFLICTS
,
1582 [UNIT_BEFORE
] = UNIT_AFTER
,
1583 [UNIT_AFTER
] = UNIT_BEFORE
,
1584 [UNIT_ON_FAILURE
] = _UNIT_DEPENDENCY_INVALID
,
1585 [UNIT_REFERENCES
] = UNIT_REFERENCED_BY
,
1586 [UNIT_REFERENCED_BY
] = UNIT_REFERENCES
,
1587 [UNIT_TRIGGERS
] = UNIT_TRIGGERED_BY
,
1588 [UNIT_TRIGGERED_BY
] = UNIT_TRIGGERS
,
1589 [UNIT_PROPAGATE_RELOAD_TO
] = UNIT_PROPAGATE_RELOAD_FROM
,
1590 [UNIT_PROPAGATE_RELOAD_FROM
] = UNIT_PROPAGATE_RELOAD_TO
1592 int r
, q
= 0, v
= 0, w
= 0;
1595 assert(d
>= 0 && d
< _UNIT_DEPENDENCY_MAX
);
1598 u
= unit_follow_merge(u
);
1599 other
= unit_follow_merge(other
);
1601 /* We won't allow dependencies on ourselves. We will not
1602 * consider them an error however. */
1606 if ((r
= set_ensure_allocated(&u
->dependencies
[d
], trivial_hash_func
, trivial_compare_func
)) < 0)
1609 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
)
1610 if ((r
= set_ensure_allocated(&other
->dependencies
[inverse_table
[d
]], trivial_hash_func
, trivial_compare_func
)) < 0)
1614 if ((r
= set_ensure_allocated(&u
->dependencies
[UNIT_REFERENCES
], trivial_hash_func
, trivial_compare_func
)) < 0 ||
1615 (r
= set_ensure_allocated(&other
->dependencies
[UNIT_REFERENCED_BY
], trivial_hash_func
, trivial_compare_func
)) < 0)
1618 if ((q
= set_put(u
->dependencies
[d
], other
)) < 0)
1621 if (inverse_table
[d
] != _UNIT_DEPENDENCY_INVALID
)
1622 if ((v
= set_put(other
->dependencies
[inverse_table
[d
]], u
)) < 0) {
1627 if (add_reference
) {
1628 if ((w
= set_put(u
->dependencies
[UNIT_REFERENCES
], other
)) < 0) {
1633 if ((r
= set_put(other
->dependencies
[UNIT_REFERENCED_BY
], u
)) < 0)
1637 unit_add_to_dbus_queue(u
);
1642 set_remove(u
->dependencies
[d
], other
);
1645 set_remove(other
->dependencies
[inverse_table
[d
]], u
);
1648 set_remove(u
->dependencies
[UNIT_REFERENCES
], other
);
1653 int unit_add_two_dependencies(Unit
*u
, UnitDependency d
, UnitDependency e
, Unit
*other
, bool add_reference
) {
1658 if ((r
= unit_add_dependency(u
, d
, other
, add_reference
)) < 0)
1661 if ((r
= unit_add_dependency(u
, e
, other
, add_reference
)) < 0)
1667 static const char *resolve_template(Unit
*u
, const char *name
, const char*path
, char **p
) {
1671 assert(name
|| path
);
1674 name
= path_get_file_name(path
);
1676 if (!unit_name_is_template(name
)) {
1682 s
= unit_name_replace_instance(name
, u
->instance
);
1686 if (!(i
= unit_name_to_prefix(u
->id
)))
1689 s
= unit_name_replace_instance(name
, i
);
1700 int unit_add_dependency_by_name(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
1706 assert(name
|| path
);
1708 if (!(name
= resolve_template(u
, name
, path
, &s
)))
1711 if ((r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
)) < 0)
1714 r
= unit_add_dependency(u
, d
, other
, add_reference
);
1721 int unit_add_two_dependencies_by_name(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
1727 assert(name
|| path
);
1729 if (!(name
= resolve_template(u
, name
, path
, &s
)))
1732 if ((r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
)) < 0)
1735 r
= unit_add_two_dependencies(u
, d
, e
, other
, add_reference
);
1742 int unit_add_dependency_by_name_inverse(Unit
*u
, UnitDependency d
, const char *name
, const char *path
, bool add_reference
) {
1748 assert(name
|| path
);
1750 if (!(name
= resolve_template(u
, name
, path
, &s
)))
1753 if ((r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
)) < 0)
1756 r
= unit_add_dependency(other
, d
, u
, add_reference
);
1763 int unit_add_two_dependencies_by_name_inverse(Unit
*u
, UnitDependency d
, UnitDependency e
, const char *name
, const char *path
, bool add_reference
) {
1769 assert(name
|| path
);
1771 if (!(name
= resolve_template(u
, name
, path
, &s
)))
1774 if ((r
= manager_load_unit(u
->manager
, name
, path
, NULL
, &other
)) < 0)
1777 if ((r
= unit_add_two_dependencies(other
, d
, e
, u
, add_reference
)) < 0)
1785 int set_unit_path(const char *p
) {
1789 /* This is mostly for debug purposes */
1791 if (path_is_absolute(p
)) {
1792 if (!(c
= strdup(p
)))
1795 if (!(cwd
= get_current_dir_name()))
1798 r
= asprintf(&c
, "%s/%s", cwd
, p
);
1805 if (setenv("SYSTEMD_UNIT_PATH", c
, 0) < 0) {
1814 char *unit_dbus_path(Unit
*u
) {
1822 if (!(e
= bus_path_escape(u
->id
)))
1825 p
= strappend("/org/freedesktop/systemd1/unit/", e
);
1831 int unit_add_cgroup(Unit
*u
, CGroupBonding
*b
) {
1839 if (!b
->controller
) {
1840 if (!(b
->controller
= strdup(SYSTEMD_CGROUP_CONTROLLER
)))
1846 /* Ensure this hasn't been added yet */
1849 if (streq(b
->controller
, SYSTEMD_CGROUP_CONTROLLER
)) {
1852 l
= hashmap_get(u
->manager
->cgroup_bondings
, b
->path
);
1853 LIST_PREPEND(CGroupBonding
, by_path
, l
, b
);
1855 if ((r
= hashmap_replace(u
->manager
->cgroup_bondings
, b
->path
, l
)) < 0) {
1856 LIST_REMOVE(CGroupBonding
, by_path
, l
, b
);
1861 LIST_PREPEND(CGroupBonding
, by_unit
, u
->cgroup_bondings
, b
);
1867 static char *default_cgroup_path(Unit
*u
) {
1875 t
= unit_name_template(u
->id
);
1879 p
= join(u
->manager
->cgroup_hierarchy
, "/", t
, "/", u
->instance
, NULL
);
1882 p
= join(u
->manager
->cgroup_hierarchy
, "/", u
->id
, NULL
);
1887 int unit_add_cgroup_from_text(Unit
*u
, const char *name
) {
1888 char *controller
= NULL
, *path
= NULL
;
1889 CGroupBonding
*b
= NULL
;
1896 if ((r
= cg_split_spec(name
, &controller
, &path
)) < 0)
1900 path
= default_cgroup_path(u
);
1905 controller
= strdup(SYSTEMD_CGROUP_CONTROLLER
);
1909 if (!path
|| !controller
) {
1916 if (cgroup_bonding_find_list(u
->cgroup_bondings
, controller
)) {
1921 if (!(b
= new0(CGroupBonding
, 1))) {
1926 b
->controller
= controller
;
1929 b
->essential
= streq(controller
, SYSTEMD_CGROUP_CONTROLLER
);
1931 if ((r
= unit_add_cgroup(u
, b
)) < 0)
1944 static int unit_add_one_default_cgroup(Unit
*u
, const char *controller
) {
1945 CGroupBonding
*b
= NULL
;
1951 controller
= SYSTEMD_CGROUP_CONTROLLER
;
1953 if (cgroup_bonding_find_list(u
->cgroup_bondings
, controller
))
1956 if (!(b
= new0(CGroupBonding
, 1)))
1959 if (!(b
->controller
= strdup(controller
)))
1962 if (!(b
->path
= default_cgroup_path(u
)))
1966 b
->essential
= streq(controller
, SYSTEMD_CGROUP_CONTROLLER
);
1968 if ((r
= unit_add_cgroup(u
, b
)) < 0)
1975 free(b
->controller
);
1981 int unit_add_default_cgroups(Unit
*u
) {
1988 /* Adds in the default cgroups, if they weren't specified
1991 if (!u
->manager
->cgroup_hierarchy
)
1994 if ((r
= unit_add_one_default_cgroup(u
, NULL
)) < 0)
1997 STRV_FOREACH(c
, u
->manager
->default_controllers
)
1998 unit_add_one_default_cgroup(u
, *c
);
2000 LIST_FOREACH(by_unit
, a
, u
->cgroup_attributes
)
2001 unit_add_one_default_cgroup(u
, a
->controller
);
2006 CGroupBonding
* unit_get_default_cgroup(Unit
*u
) {
2009 return cgroup_bonding_find_list(u
->cgroup_bondings
, SYSTEMD_CGROUP_CONTROLLER
);
2012 int unit_add_cgroup_attribute(Unit
*u
, const char *controller
, const char *name
, const char *value
, CGroupAttributeMapCallback map_callback
) {
2024 dot
= strchr(name
, '.');
2028 c
= strndup(name
, dot
- name
);
2035 if (streq(controller
, SYSTEMD_CGROUP_CONTROLLER
)) {
2040 a
= new0(CGroupAttribute
, 1);
2050 a
->controller
= strdup(controller
);
2052 a
->name
= strdup(name
);
2053 a
->value
= strdup(value
);
2055 if (!a
->controller
|| !a
->name
|| !a
->value
) {
2056 free(a
->controller
);
2064 a
->map_callback
= map_callback
;
2066 LIST_PREPEND(CGroupAttribute
, by_unit
, u
->cgroup_attributes
, a
);
2075 int unit_load_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2083 if (!(t
= unit_name_change_suffix(u
->id
, type
)))
2086 assert(!unit_has_name(u
, t
));
2088 r
= manager_load_unit(u
->manager
, t
, NULL
, NULL
, _found
);
2091 assert(r
< 0 || *_found
!= u
);
2096 int unit_get_related_unit(Unit
*u
, const char *type
, Unit
**_found
) {
2104 if (!(t
= unit_name_change_suffix(u
->id
, type
)))
2107 assert(!unit_has_name(u
, t
));
2109 found
= manager_get_unit(u
->manager
, t
);
2119 static char *specifier_prefix_and_instance(char specifier
, void *data
, void *userdata
) {
2123 return unit_name_to_prefix_and_instance(u
->id
);
2126 static char *specifier_prefix(char specifier
, void *data
, void *userdata
) {
2130 return unit_name_to_prefix(u
->id
);
2133 static char *specifier_prefix_unescaped(char specifier
, void *data
, void *userdata
) {
2139 if (!(p
= unit_name_to_prefix(u
->id
)))
2142 r
= unit_name_unescape(p
);
2148 static char *specifier_instance_unescaped(char specifier
, void *data
, void *userdata
) {
2153 return unit_name_unescape(u
->instance
);
2158 static char *specifier_filename(char specifier
, void *data
, void *userdata
) {
2163 return unit_name_path_unescape(u
->instance
);
2165 return unit_name_to_path(u
->instance
);
2168 static char *specifier_cgroup(char specifier
, void *data
, void *userdata
) {
2172 return default_cgroup_path(u
);
2175 static char *specifier_cgroup_root(char specifier
, void *data
, void *userdata
) {
2180 if (specifier
== 'r')
2181 return strdup(u
->manager
->cgroup_hierarchy
);
2183 if (path_get_parent(u
->manager
->cgroup_hierarchy
, &p
) < 0)
2186 if (streq(p
, "/")) {
2194 static char *specifier_runtime(char specifier
, void *data
, void *userdata
) {
2198 if (u
->manager
->running_as
== MANAGER_USER
) {
2201 e
= getenv("XDG_RUNTIME_DIR");
2206 return strdup("/run");
2209 char *unit_name_printf(Unit
*u
, const char* format
) {
2212 * This will use the passed string as format string and
2213 * replace the following specifiers:
2215 * %n: the full id of the unit (foo@bar.waldo)
2216 * %N: the id of the unit without the suffix (foo@bar)
2217 * %p: the prefix (foo)
2218 * %i: the instance (bar)
2221 const Specifier table
[] = {
2222 { 'n', specifier_string
, u
->id
},
2223 { 'N', specifier_prefix_and_instance
, NULL
},
2224 { 'p', specifier_prefix
, NULL
},
2225 { 'i', specifier_string
, u
->instance
},
2232 return specifier_printf(format
, table
, u
);
2235 char *unit_full_printf(Unit
*u
, const char *format
) {
2237 /* This is similar to unit_name_printf() but also supports
2238 * unescaping. Also, adds a couple of additional codes:
2240 * %c cgroup path of unit
2241 * %r root cgroup path of this systemd instance (e.g. "/user/lennart/shared/systemd-4711")
2242 * %R parent of root cgroup path (e.g. "/usr/lennart/shared")
2243 * %t the runtime directory to place sockets in (e.g. "/run" or $XDG_RUNTIME_DIR)
2246 const Specifier table
[] = {
2247 { 'n', specifier_string
, u
->id
},
2248 { 'N', specifier_prefix_and_instance
, NULL
},
2249 { 'p', specifier_prefix
, NULL
},
2250 { 'P', specifier_prefix_unescaped
, NULL
},
2251 { 'i', specifier_string
, u
->instance
},
2252 { 'I', specifier_instance_unescaped
, NULL
},
2253 { 'f', specifier_filename
, NULL
},
2254 { 'c', specifier_cgroup
, NULL
},
2255 { 'r', specifier_cgroup_root
, NULL
},
2256 { 'R', specifier_cgroup_root
, NULL
},
2257 { 't', specifier_runtime
, NULL
},
2264 return specifier_printf(format
, table
, u
);
2267 char **unit_full_printf_strv(Unit
*u
, char **l
) {
2271 /* Applies unit_full_printf to every entry in l */
2276 if (!(r
= new(char*, n
+1)))
2279 for (i
= l
, j
= r
; *i
; i
++, j
++)
2280 if (!(*j
= unit_full_printf(u
, *i
)))
2287 for (j
--; j
>= r
; j
--)
2295 int unit_watch_bus_name(Unit
*u
, const char *name
) {
2299 /* Watch a specific name on the bus. We only support one unit
2300 * watching each name for now. */
2302 return hashmap_put(u
->manager
->watch_bus
, name
, u
);
2305 void unit_unwatch_bus_name(Unit
*u
, const char *name
) {
2309 hashmap_remove_value(u
->manager
->watch_bus
, name
, u
);
2312 bool unit_can_serialize(Unit
*u
) {
2315 return UNIT_VTABLE(u
)->serialize
&& UNIT_VTABLE(u
)->deserialize_item
;
2318 int unit_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2325 if (!unit_can_serialize(u
))
2328 if ((r
= UNIT_VTABLE(u
)->serialize(u
, f
, fds
)) < 0)
2332 fprintf(f
, "job\n");
2333 job_serialize(u
->job
, f
, fds
);
2337 fprintf(f
, "job\n");
2338 job_serialize(u
->nop_job
, f
, fds
);
2341 dual_timestamp_serialize(f
, "inactive-exit-timestamp", &u
->inactive_exit_timestamp
);
2342 dual_timestamp_serialize(f
, "active-enter-timestamp", &u
->active_enter_timestamp
);
2343 dual_timestamp_serialize(f
, "active-exit-timestamp", &u
->active_exit_timestamp
);
2344 dual_timestamp_serialize(f
, "inactive-enter-timestamp", &u
->inactive_enter_timestamp
);
2345 dual_timestamp_serialize(f
, "condition-timestamp", &u
->condition_timestamp
);
2347 if (dual_timestamp_is_set(&u
->condition_timestamp
))
2348 unit_serialize_item(u
, f
, "condition-result", yes_no(u
->condition_result
));
2355 void unit_serialize_item_format(Unit
*u
, FILE *f
, const char *key
, const char *format
, ...) {
2366 va_start(ap
, format
);
2367 vfprintf(f
, format
, ap
);
2373 void unit_serialize_item(Unit
*u
, FILE *f
, const char *key
, const char *value
) {
2379 fprintf(f
, "%s=%s\n", key
, value
);
2382 int unit_deserialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
2389 if (!unit_can_serialize(u
))
2393 char line
[LINE_MAX
], *l
, *v
;
2396 if (!fgets(line
, sizeof(line
), f
)) {
2409 k
= strcspn(l
, "=");
2417 if (streq(l
, "job")) {
2419 /* new-style serialized job */
2420 Job
*j
= job_new_raw(u
);
2424 r
= job_deserialize(j
, f
, fds
);
2430 r
= hashmap_put(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
), j
);
2436 r
= job_install_deserialized(j
);
2438 hashmap_remove(u
->manager
->jobs
, UINT32_TO_PTR(j
->id
));
2444 JobType type
= job_type_from_string(v
);
2446 log_debug("Failed to parse job type value %s", v
);
2448 u
->deserialized_job
= type
;
2451 } else if (streq(l
, "inactive-exit-timestamp")) {
2452 dual_timestamp_deserialize(v
, &u
->inactive_exit_timestamp
);
2454 } else if (streq(l
, "active-enter-timestamp")) {
2455 dual_timestamp_deserialize(v
, &u
->active_enter_timestamp
);
2457 } else if (streq(l
, "active-exit-timestamp")) {
2458 dual_timestamp_deserialize(v
, &u
->active_exit_timestamp
);
2460 } else if (streq(l
, "inactive-enter-timestamp")) {
2461 dual_timestamp_deserialize(v
, &u
->inactive_enter_timestamp
);
2463 } else if (streq(l
, "condition-timestamp")) {
2464 dual_timestamp_deserialize(v
, &u
->condition_timestamp
);
2466 } else if (streq(l
, "condition-result")) {
2469 if ((b
= parse_boolean(v
)) < 0)
2470 log_debug("Failed to parse condition result value %s", v
);
2472 u
->condition_result
= b
;
2477 if ((r
= UNIT_VTABLE(u
)->deserialize_item(u
, l
, v
, fds
)) < 0)
2482 int unit_add_node_link(Unit
*u
, const char *what
, bool wants
) {
2492 /* Adds in links to the device node that this unit is based on */
2494 if (!is_device_path(what
))
2497 if (!(e
= unit_name_build_escape(what
+1, NULL
, ".device")))
2500 r
= manager_load_unit(u
->manager
, e
, NULL
, NULL
, &device
);
2506 if ((r
= unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_BIND_TO
, device
, true)) < 0)
2510 if ((r
= unit_add_dependency(device
, UNIT_WANTS
, u
, false)) < 0)
2516 int unit_coldplug(Unit
*u
) {
2521 if (UNIT_VTABLE(u
)->coldplug
)
2522 if ((r
= UNIT_VTABLE(u
)->coldplug(u
)) < 0)
2526 r
= job_coldplug(u
->job
);
2529 } else if (u
->deserialized_job
>= 0) {
2531 r
= manager_add_job(u
->manager
, u
->deserialized_job
, u
, JOB_IGNORE_REQUIREMENTS
, false, NULL
, NULL
);
2535 u
->deserialized_job
= _JOB_TYPE_INVALID
;
2541 void unit_status_printf(Unit
*u
, const char *status
, const char *format
, ...) {
2547 if (!UNIT_VTABLE(u
)->show_status
)
2550 if (!manager_get_show_status(u
->manager
))
2553 if (!manager_is_booting_or_shutting_down(u
->manager
))
2556 va_start(ap
, format
);
2557 status_vprintf(status
, true, format
, ap
);
2561 bool unit_need_daemon_reload(Unit
*u
) {
2564 if (u
->fragment_path
) {
2568 if (stat(u
->fragment_path
, &st
) < 0)
2569 /* What, cannot access this anymore? */
2572 if (u
->fragment_mtime
> 0 &&
2573 timespec_load(&st
.st_mtim
) != u
->fragment_mtime
)
2577 if (UNIT_VTABLE(u
)->need_daemon_reload
)
2578 return UNIT_VTABLE(u
)->need_daemon_reload(u
);
2583 void unit_reset_failed(Unit
*u
) {
2586 if (UNIT_VTABLE(u
)->reset_failed
)
2587 UNIT_VTABLE(u
)->reset_failed(u
);
2590 Unit
*unit_following(Unit
*u
) {
2593 if (UNIT_VTABLE(u
)->following
)
2594 return UNIT_VTABLE(u
)->following(u
);
2599 bool unit_pending_inactive(Unit
*u
) {
2602 /* Returns true if the unit is inactive or going down */
2604 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(u
)))
2607 if (u
->job
&& u
->job
->type
== JOB_STOP
)
2613 bool unit_pending_active(Unit
*u
) {
2616 /* Returns true if the unit is active or going up */
2618 if (UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(u
)))
2622 (u
->job
->type
== JOB_START
||
2623 u
->job
->type
== JOB_RELOAD_OR_START
||
2624 u
->job
->type
== JOB_RESTART
))
2630 UnitType
unit_name_to_type(const char *n
) {
2635 for (t
= 0; t
< _UNIT_TYPE_MAX
; t
++)
2636 if (endswith(n
, unit_vtable
[t
]->suffix
))
2639 return _UNIT_TYPE_INVALID
;
2642 bool unit_name_is_valid(const char *n
, bool template_ok
) {
2645 t
= unit_name_to_type(n
);
2646 if (t
< 0 || t
>= _UNIT_TYPE_MAX
)
2649 return unit_name_is_valid_no_type(n
, template_ok
);
2652 int unit_kill(Unit
*u
, KillWho w
, KillMode m
, int signo
, DBusError
*error
) {
2654 assert(w
>= 0 && w
< _KILL_WHO_MAX
);
2655 assert(m
>= 0 && m
< _KILL_MODE_MAX
);
2657 assert(signo
< _NSIG
);
2662 if (!UNIT_VTABLE(u
)->kill
)
2665 return UNIT_VTABLE(u
)->kill(u
, w
, m
, signo
, error
);
2668 int unit_following_set(Unit
*u
, Set
**s
) {
2672 if (UNIT_VTABLE(u
)->following_set
)
2673 return UNIT_VTABLE(u
)->following_set(u
, s
);
2679 UnitFileState
unit_get_unit_file_state(Unit
*u
) {
2682 if (u
->unit_file_state
< 0 && u
->fragment_path
)
2683 u
->unit_file_state
= unit_file_get_state(
2684 u
->manager
->running_as
== MANAGER_SYSTEM
? UNIT_FILE_SYSTEM
: UNIT_FILE_USER
,
2685 NULL
, path_get_file_name(u
->fragment_path
));
2687 return u
->unit_file_state
;
2690 Unit
* unit_ref_set(UnitRef
*ref
, Unit
*u
) {
2695 unit_ref_unset(ref
);
2698 LIST_PREPEND(UnitRef
, refs
, u
->refs
, ref
);
2702 void unit_ref_unset(UnitRef
*ref
) {
2708 LIST_REMOVE(UnitRef
, refs
, ref
->unit
->refs
, ref
);
2712 int unit_add_one_mount_link(Unit
*u
, Mount
*m
) {
2718 if (u
->load_state
!= UNIT_LOADED
||
2719 UNIT(m
)->load_state
!= UNIT_LOADED
)
2722 STRV_FOREACH(i
, u
->requires_mounts_for
) {
2727 if (!path_startswith(*i
, m
->where
))
2730 return unit_add_two_dependencies(u
, UNIT_AFTER
, UNIT_REQUIRES
, UNIT(m
), true);
2736 int unit_add_mount_links(Unit
*u
) {
2742 LIST_FOREACH(units_by_type
, other
, u
->manager
->units_by_type
[UNIT_MOUNT
]) {
2743 r
= unit_add_one_mount_link(u
, MOUNT(other
));
2751 static const char* const unit_load_state_table
[_UNIT_LOAD_STATE_MAX
] = {
2752 [UNIT_STUB
] = "stub",
2753 [UNIT_LOADED
] = "loaded",
2754 [UNIT_ERROR
] = "error",
2755 [UNIT_MERGED
] = "merged",
2756 [UNIT_MASKED
] = "masked"
2759 DEFINE_STRING_TABLE_LOOKUP(unit_load_state
, UnitLoadState
);
2761 static const char* const unit_active_state_table
[_UNIT_ACTIVE_STATE_MAX
] = {
2762 [UNIT_ACTIVE
] = "active",
2763 [UNIT_RELOADING
] = "reloading",
2764 [UNIT_INACTIVE
] = "inactive",
2765 [UNIT_FAILED
] = "failed",
2766 [UNIT_ACTIVATING
] = "activating",
2767 [UNIT_DEACTIVATING
] = "deactivating"
2770 DEFINE_STRING_TABLE_LOOKUP(unit_active_state
, UnitActiveState
);
2772 static const char* const unit_dependency_table
[_UNIT_DEPENDENCY_MAX
] = {
2773 [UNIT_REQUIRES
] = "Requires",
2774 [UNIT_REQUIRES_OVERRIDABLE
] = "RequiresOverridable",
2775 [UNIT_WANTS
] = "Wants",
2776 [UNIT_REQUISITE
] = "Requisite",
2777 [UNIT_REQUISITE_OVERRIDABLE
] = "RequisiteOverridable",
2778 [UNIT_REQUIRED_BY
] = "RequiredBy",
2779 [UNIT_REQUIRED_BY_OVERRIDABLE
] = "RequiredByOverridable",
2780 [UNIT_BIND_TO
] = "BindTo",
2781 [UNIT_WANTED_BY
] = "WantedBy",
2782 [UNIT_CONFLICTS
] = "Conflicts",
2783 [UNIT_CONFLICTED_BY
] = "ConflictedBy",
2784 [UNIT_BOUND_BY
] = "BoundBy",
2785 [UNIT_BEFORE
] = "Before",
2786 [UNIT_AFTER
] = "After",
2787 [UNIT_REFERENCES
] = "References",
2788 [UNIT_REFERENCED_BY
] = "ReferencedBy",
2789 [UNIT_ON_FAILURE
] = "OnFailure",
2790 [UNIT_TRIGGERS
] = "Triggers",
2791 [UNIT_TRIGGERED_BY
] = "TriggeredBy",
2792 [UNIT_PROPAGATE_RELOAD_TO
] = "PropagateReloadTo",
2793 [UNIT_PROPAGATE_RELOAD_FROM
] = "PropagateReloadFrom"
2796 DEFINE_STRING_TABLE_LOOKUP(unit_dependency
, UnitDependency
);