1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
6 #include "alloc-util.h"
7 #include "cgroup-setup.h"
8 #include "dbus-scope.h"
10 #include "exit-status.h"
11 #include "load-dropin.h"
13 #include "process-util.h"
14 #include "random-util.h"
16 #include "serialize.h"
18 #include "string-table.h"
19 #include "string-util.h"
21 #include "unit-name.h"
23 #include "user-util.h"
25 static const UnitActiveState state_translation_table
[_SCOPE_STATE_MAX
] = {
26 [SCOPE_DEAD
] = UNIT_INACTIVE
,
27 [SCOPE_START_CHOWN
] = UNIT_ACTIVATING
,
28 [SCOPE_RUNNING
] = UNIT_ACTIVE
,
29 [SCOPE_ABANDONED
] = UNIT_ACTIVE
,
30 [SCOPE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
31 [SCOPE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
32 [SCOPE_FAILED
] = UNIT_FAILED
,
35 static int scope_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
37 static void scope_init(Unit
*u
) {
41 assert(u
->load_state
== UNIT_STUB
);
43 s
->runtime_max_usec
= USEC_INFINITY
;
44 s
->timeout_stop_usec
= u
->manager
->defaults
.timeout_stop_usec
;
45 u
->ignore_on_isolate
= true;
46 s
->user
= s
->group
= NULL
;
47 s
->oom_policy
= _OOM_POLICY_INVALID
;
50 static void scope_done(Unit
*u
) {
55 s
->controller
= mfree(s
->controller
);
56 s
->controller_track
= sd_bus_track_unref(s
->controller_track
);
58 s
->timer_event_source
= sd_event_source_disable_unref(s
->timer_event_source
);
60 s
->user
= mfree(s
->user
);
61 s
->group
= mfree(s
->group
);
64 static usec_t
scope_running_timeout(Scope
*s
) {
69 if (s
->runtime_rand_extra_usec
!= 0) {
70 delta
= random_u64_range(s
->runtime_rand_extra_usec
);
71 log_unit_debug(UNIT(s
), "Adding delta of %s sec to timeout", FORMAT_TIMESPAN(delta
, USEC_PER_SEC
));
74 return usec_add(usec_add(UNIT(s
)->active_enter_timestamp
.monotonic
,
79 static int scope_arm_timer(Scope
*s
, bool relative
, usec_t usec
) {
82 return unit_arm_timer(UNIT(s
), &s
->timer_event_source
, relative
, usec
, scope_dispatch_timer
);
85 static void scope_set_state(Scope
*s
, ScopeState state
) {
89 if (s
->state
!= state
)
90 bus_unit_send_pending_change_signal(UNIT(s
), false);
95 if (!IN_SET(state
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
, SCOPE_START_CHOWN
, SCOPE_RUNNING
))
96 s
->timer_event_source
= sd_event_source_disable_unref(s
->timer_event_source
);
98 if (!IN_SET(old_state
, SCOPE_DEAD
, SCOPE_FAILED
) && IN_SET(state
, SCOPE_DEAD
, SCOPE_FAILED
)) {
99 unit_unwatch_all_pids(UNIT(s
));
100 unit_dequeue_rewatch_pids(UNIT(s
));
103 if (state
!= old_state
)
104 log_debug("%s changed %s -> %s", UNIT(s
)->id
, scope_state_to_string(old_state
), scope_state_to_string(state
));
106 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], /* reload_success = */ true);
109 static int scope_add_default_dependencies(Scope
*s
) {
114 if (!UNIT(s
)->default_dependencies
)
117 /* Make sure scopes are unloaded on shutdown */
118 r
= unit_add_two_dependencies_by_name(
120 UNIT_BEFORE
, UNIT_CONFLICTS
,
121 SPECIAL_SHUTDOWN_TARGET
, true,
122 UNIT_DEPENDENCY_DEFAULT
);
129 static int scope_verify(Scope
*s
) {
131 assert(UNIT(s
)->load_state
== UNIT_LOADED
);
133 if (set_isempty(UNIT(s
)->pids
) &&
134 !MANAGER_IS_RELOADING(UNIT(s
)->manager
) &&
135 !unit_has_name(UNIT(s
), SPECIAL_INIT_SCOPE
))
136 return log_unit_error_errno(UNIT(s
), SYNTHETIC_ERRNO(ENOENT
), "Scope has no PIDs. Refusing.");
141 static int scope_load_init_scope(Unit
*u
) {
144 if (!unit_has_name(u
, SPECIAL_INIT_SCOPE
))
150 /* init.scope is a bit special, as it has to stick around forever. Because of its special semantics we
151 * synthesize it here, instead of relying on the unit file on disk. */
153 u
->default_dependencies
= false;
155 /* Prettify things, if we can. */
157 u
->description
= strdup("System and Service Manager");
158 if (!u
->documentation
)
159 (void) strv_extend(&u
->documentation
, "man:systemd(1)");
164 static int scope_add_extras(Scope
*s
) {
167 r
= unit_patch_contexts(UNIT(s
));
171 r
= unit_set_default_slice(UNIT(s
));
175 if (s
->oom_policy
< 0)
176 s
->oom_policy
= s
->cgroup_context
.delegate
? OOM_CONTINUE
: UNIT(s
)->manager
->defaults
.oom_policy
;
178 s
->cgroup_context
.memory_oom_group
= s
->oom_policy
== OOM_KILL
;
180 return scope_add_default_dependencies(s
);
183 static int scope_load(Unit
*u
) {
188 assert(u
->load_state
== UNIT_STUB
);
190 if (!u
->transient
&& !MANAGER_IS_RELOADING(u
->manager
))
191 /* Refuse to load non-transient scope units, but allow them while reloading. */
194 r
= scope_load_init_scope(u
);
198 r
= unit_load_fragment_and_dropin(u
, false);
202 if (u
->load_state
!= UNIT_LOADED
)
205 r
= scope_add_extras(s
);
209 return scope_verify(s
);
212 static usec_t
scope_coldplug_timeout(Scope
*s
) {
215 switch (s
->deserialized_state
) {
218 return scope_running_timeout(s
);
220 case SCOPE_STOP_SIGKILL
:
221 case SCOPE_STOP_SIGTERM
:
222 return usec_add(UNIT(s
)->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
);
225 return USEC_INFINITY
;
229 static int scope_coldplug(Unit
*u
) {
234 assert(s
->state
== SCOPE_DEAD
);
236 if (s
->deserialized_state
== s
->state
)
239 r
= scope_arm_timer(s
, /* relative= */ false, scope_coldplug_timeout(s
));
243 if (!IN_SET(s
->deserialized_state
, SCOPE_DEAD
, SCOPE_FAILED
)) {
247 SET_FOREACH(pid
, u
->pids
) {
248 r
= unit_watch_pidref(u
, pid
, /* exclusive= */ false);
249 if (r
< 0 && r
!= -EEXIST
)
253 (void) unit_enqueue_rewatch_pids(u
);
256 bus_scope_track_controller(s
);
258 scope_set_state(s
, s
->deserialized_state
);
262 static void scope_dump(Unit
*u
, FILE *f
, const char *prefix
) {
269 "%sScope State: %s\n"
271 "%sRuntimeMaxSec: %s\n"
272 "%sRuntimeRandomizedExtraSec: %s\n"
274 prefix
, scope_state_to_string(s
->state
),
275 prefix
, scope_result_to_string(s
->result
),
276 prefix
, FORMAT_TIMESPAN(s
->runtime_max_usec
, USEC_PER_SEC
),
277 prefix
, FORMAT_TIMESPAN(s
->runtime_rand_extra_usec
, USEC_PER_SEC
),
278 prefix
, oom_policy_to_string(s
->oom_policy
));
280 cgroup_context_dump(UNIT(s
), f
, prefix
);
281 kill_context_dump(&s
->kill_context
, f
, prefix
);
284 static void scope_enter_dead(Scope
*s
, ScopeResult f
) {
287 if (s
->result
== SCOPE_SUCCESS
)
290 unit_log_result(UNIT(s
), s
->result
== SCOPE_SUCCESS
, scope_result_to_string(s
->result
));
291 scope_set_state(s
, s
->result
!= SCOPE_SUCCESS
? SCOPE_FAILED
: SCOPE_DEAD
);
294 static void scope_enter_signal(Scope
*s
, ScopeState state
, ScopeResult f
) {
295 bool skip_signal
= false;
300 if (s
->result
== SCOPE_SUCCESS
)
303 /* Before sending any signal, make sure we track all members of this cgroup */
304 (void) unit_watch_all_pids(UNIT(s
));
306 /* Also, enqueue a job that we recheck all our PIDs a bit later, given that it's likely some processes have
308 (void) unit_enqueue_rewatch_pids(UNIT(s
));
310 /* If we have a controller set let's ask the controller nicely to terminate the scope, instead of us going
311 * directly into SIGTERM berserk mode */
312 if (state
== SCOPE_STOP_SIGTERM
)
313 skip_signal
= bus_scope_send_request_stop(s
) > 0;
318 r
= unit_kill_context(
320 state
!= SCOPE_STOP_SIGTERM
? KILL_KILL
:
321 s
->was_abandoned
? KILL_TERMINATE_AND_LOG
:
324 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
330 r
= scope_arm_timer(s
, /* relative= */ true, s
->timeout_stop_usec
);
332 log_unit_warning_errno(UNIT(s
), r
, "Failed to install timer: %m");
336 scope_set_state(s
, state
);
337 } else if (state
== SCOPE_STOP_SIGTERM
)
338 scope_enter_signal(s
, SCOPE_STOP_SIGKILL
, SCOPE_SUCCESS
);
340 scope_enter_dead(s
, SCOPE_SUCCESS
);
345 scope_enter_dead(s
, SCOPE_FAILURE_RESOURCES
);
348 static int scope_enter_start_chown(Scope
*s
) {
349 _cleanup_(pidref_done
) PidRef pidref
= PIDREF_NULL
;
356 if (!s
->cgroup_runtime
)
359 r
= scope_arm_timer(s
, /* relative= */ true, u
->manager
->defaults
.timeout_start_usec
);
363 r
= unit_fork_helper_process(u
, "(sd-chown-cgroup)", &pidref
);
368 uid_t uid
= UID_INVALID
;
369 gid_t gid
= GID_INVALID
;
371 if (!isempty(s
->user
)) {
372 const char *user
= s
->user
;
374 r
= get_user_creds(&user
, &uid
, &gid
, NULL
, NULL
, 0);
376 log_unit_error_errno(UNIT(s
), r
, "Failed to resolve user \"%s\": %m", user
);
381 if (!isempty(s
->group
)) {
382 const char *group
= s
->group
;
384 r
= get_group_creds(&group
, &gid
, 0);
386 log_unit_error_errno(UNIT(s
), r
, "Failed to resolve group \"%s\": %m", group
);
391 r
= cg_set_access(SYSTEMD_CGROUP_CONTROLLER
, s
->cgroup_runtime
->cgroup_path
, uid
, gid
);
393 log_unit_error_errno(UNIT(s
), r
, "Failed to adjust control group access: %m");
400 r
= unit_watch_pidref(UNIT(s
), &pidref
, /* exclusive= */ true);
404 scope_set_state(s
, SCOPE_START_CHOWN
);
408 s
->timer_event_source
= sd_event_source_disable_unref(s
->timer_event_source
);
412 static int scope_enter_running(Scope
*s
) {
418 (void) bus_scope_track_controller(s
);
420 r
= unit_acquire_invocation_id(u
);
424 unit_export_state_files(u
);
426 r
= unit_attach_pids_to_cgroup(u
, u
->pids
, NULL
);
428 log_unit_warning_errno(u
, r
, "Failed to add PIDs to scope's control group: %m");
432 r
= log_unit_warning_errno(u
, SYNTHETIC_ERRNO(ECHILD
), "No PIDs left to attach to the scope's control group, refusing.");
435 log_unit_debug(u
, "%i %s added to scope's control group.", r
, r
== 1 ? "process" : "processes");
437 s
->result
= SCOPE_SUCCESS
;
439 scope_set_state(s
, SCOPE_RUNNING
);
441 /* Set the maximum runtime timeout. */
442 scope_arm_timer(s
, /* relative= */ false, scope_running_timeout(s
));
444 /* On unified we use proper notifications hence we can unwatch the PIDs
445 * we just attached to the scope. This can also be done on legacy as
446 * we're going to update the list of the processes we watch with the
447 * PIDs currently in the scope anyway. */
448 unit_unwatch_all_pids(u
);
450 /* Start watching the PIDs currently in the scope (legacy hierarchy only) */
451 (void) unit_enqueue_rewatch_pids(u
);
455 scope_enter_dead(s
, SCOPE_FAILURE_RESOURCES
);
459 static int scope_start(Unit
*u
) {
464 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
))
467 if (s
->state
== SCOPE_FAILED
)
470 /* We can't fulfill this right now, please try again later */
471 if (IN_SET(s
->state
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
))
474 assert(s
->state
== SCOPE_DEAD
);
476 if (!u
->transient
&& !MANAGER_IS_RELOADING(u
->manager
))
479 (void) unit_realize_cgroup(u
);
480 (void) unit_reset_accounting(u
);
482 /* We check only for User= option to keep behavior consistent with logic for service units,
483 * i.e. having 'Delegate=true Group=foo' w/o specifying User= has no effect. */
484 if (s
->user
&& unit_cgroup_delegate(u
))
485 return scope_enter_start_chown(s
);
487 return scope_enter_running(s
);
490 static int scope_stop(Unit
*u
) {
495 if (IN_SET(s
->state
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
))
498 assert(IN_SET(s
->state
, SCOPE_RUNNING
, SCOPE_ABANDONED
));
500 scope_enter_signal(s
, SCOPE_STOP_SIGTERM
, SCOPE_SUCCESS
);
504 static void scope_reset_failed(Unit
*u
) {
509 if (s
->state
== SCOPE_FAILED
)
510 scope_set_state(s
, SCOPE_DEAD
);
512 s
->result
= SCOPE_SUCCESS
;
515 static int scope_get_timeout(Unit
*u
, usec_t
*timeout
) {
520 if (!s
->timer_event_source
)
523 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
526 if (t
== USEC_INFINITY
)
533 static int scope_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
541 (void) serialize_item(f
, "state", scope_state_to_string(s
->state
));
542 (void) serialize_bool(f
, "was-abandoned", s
->was_abandoned
);
545 (void) serialize_item(f
, "controller", s
->controller
);
547 SET_FOREACH(pid
, u
->pids
)
548 serialize_pidref(f
, fds
, "pids", pid
);
553 static int scope_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
562 if (streq(key
, "state")) {
565 state
= scope_state_from_string(value
);
567 log_unit_debug(u
, "Failed to parse state value: %s", value
);
569 s
->deserialized_state
= state
;
571 } else if (streq(key
, "was-abandoned")) {
574 k
= parse_boolean(value
);
576 log_unit_debug(u
, "Failed to parse boolean value: %s", value
);
578 s
->was_abandoned
= k
;
579 } else if (streq(key
, "controller")) {
581 r
= free_and_strdup(&s
->controller
, value
);
585 } else if (streq(key
, "pids")) {
586 _cleanup_(pidref_done
) PidRef pidref
= PIDREF_NULL
;
588 if (deserialize_pidref(fds
, value
, &pidref
) >= 0) {
589 r
= unit_watch_pidref(u
, &pidref
, /* exclusive= */ false);
591 log_unit_debug(u
, "Failed to watch PID, ignoring: %s", value
);
594 log_unit_debug(u
, "Unknown serialization key: %s", key
);
599 static void scope_notify_cgroup_empty_event(Unit
*u
) {
603 log_unit_debug(u
, "cgroup is empty");
605 if (IN_SET(s
->state
, SCOPE_RUNNING
, SCOPE_ABANDONED
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
))
606 scope_enter_dead(s
, SCOPE_SUCCESS
);
609 static void scope_notify_cgroup_oom_event(Unit
*u
, bool managed_oom
) {
613 log_unit_debug(u
, "Process(es) of control group were killed by systemd-oomd.");
615 log_unit_debug(u
, "Process of control group was killed by the OOM killer.");
617 if (s
->oom_policy
== OOM_CONTINUE
)
622 case SCOPE_START_CHOWN
:
624 scope_enter_signal(s
, SCOPE_STOP_SIGTERM
, SCOPE_FAILURE_OOM_KILL
);
627 case SCOPE_STOP_SIGTERM
:
628 scope_enter_signal(s
, SCOPE_STOP_SIGKILL
, SCOPE_FAILURE_OOM_KILL
);
631 case SCOPE_STOP_SIGKILL
:
632 if (s
->result
== SCOPE_SUCCESS
)
633 s
->result
= SCOPE_FAILURE_OOM_KILL
;
635 /* SCOPE_DEAD, SCOPE_ABANDONED, and SCOPE_FAILED end up in default */
641 static void scope_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
646 if (s
->state
== SCOPE_START_CHOWN
) {
647 if (!is_clean_exit(code
, status
, EXIT_CLEAN_COMMAND
, NULL
))
648 scope_enter_dead(s
, SCOPE_FAILURE_RESOURCES
);
650 scope_enter_running(s
);
654 /* If we get a SIGCHLD event for one of the processes we were interested in, then we look for others to
655 * watch, under the assumption that we'll sooner or later get a SIGCHLD for them, as the original
656 * process we watched was probably the parent of them, and they are hence now our children. */
658 (void) unit_enqueue_rewatch_pids(u
);
661 static int scope_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
662 Scope
*s
= SCOPE(userdata
);
665 assert(s
->timer_event_source
== source
);
670 log_unit_warning(UNIT(s
), "Scope reached runtime time limit. Stopping.");
671 scope_enter_signal(s
, SCOPE_STOP_SIGTERM
, SCOPE_FAILURE_TIMEOUT
);
674 case SCOPE_STOP_SIGTERM
:
675 if (s
->kill_context
.send_sigkill
) {
676 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
677 scope_enter_signal(s
, SCOPE_STOP_SIGKILL
, SCOPE_FAILURE_TIMEOUT
);
679 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL.");
680 scope_enter_dead(s
, SCOPE_FAILURE_TIMEOUT
);
685 case SCOPE_STOP_SIGKILL
:
686 log_unit_warning(UNIT(s
), "Still around after SIGKILL. Ignoring.");
687 scope_enter_dead(s
, SCOPE_FAILURE_TIMEOUT
);
690 case SCOPE_START_CHOWN
:
691 log_unit_warning(UNIT(s
), "User lookup timed out. Entering failed state.");
692 scope_enter_dead(s
, SCOPE_FAILURE_TIMEOUT
);
696 assert_not_reached();
702 int scope_abandon(Scope
*s
) {
705 if (unit_has_name(UNIT(s
), SPECIAL_INIT_SCOPE
))
708 if (!IN_SET(s
->state
, SCOPE_RUNNING
, SCOPE_ABANDONED
))
711 s
->was_abandoned
= true;
713 s
->controller
= mfree(s
->controller
);
714 s
->controller_track
= sd_bus_track_unref(s
->controller_track
);
716 scope_set_state(s
, SCOPE_ABANDONED
);
718 /* The client is no longer watching the remaining processes, so let's step in here, under the assumption that
719 * the remaining processes will be sooner or later reassigned to us as parent. */
720 (void) unit_enqueue_rewatch_pids(UNIT(s
));
725 static UnitActiveState
scope_active_state(Unit
*u
) {
728 return state_translation_table
[SCOPE(u
)->state
];
731 static const char *scope_sub_state_to_string(Unit
*u
) {
734 return scope_state_to_string(SCOPE(u
)->state
);
737 static void scope_enumerate_perpetual(Manager
*m
) {
743 /* Let's unconditionally add the "init.scope" special unit
744 * that encapsulates PID 1. Note that PID 1 already is in the
745 * cgroup for this, we hence just need to allocate the object
746 * for it and that's it. */
748 u
= manager_get_unit(m
, SPECIAL_INIT_SCOPE
);
750 r
= unit_new_for_name(m
, sizeof(Scope
), SPECIAL_INIT_SCOPE
, &u
);
752 log_error_errno(r
, "Failed to allocate the special " SPECIAL_INIT_SCOPE
" unit: %m");
759 SCOPE(u
)->deserialized_state
= SCOPE_RUNNING
;
761 unit_add_to_load_queue(u
);
762 unit_add_to_dbus_queue(u
);
763 /* Enqueue an explicit cgroup realization here. Unlike other cgroups this one already exists and is
764 * populated (by us, after all!) already, even when we are not in a reload cycle. Hence we cannot
765 * apply the settings at creation time anymore, but let's at least apply them asynchronously. */
766 unit_add_to_cgroup_realize_queue(u
);
769 static const char* const scope_result_table
[_SCOPE_RESULT_MAX
] = {
770 [SCOPE_SUCCESS
] = "success",
771 [SCOPE_FAILURE_RESOURCES
] = "resources",
772 [SCOPE_FAILURE_TIMEOUT
] = "timeout",
773 [SCOPE_FAILURE_OOM_KILL
] = "oom-kill",
776 DEFINE_STRING_TABLE_LOOKUP(scope_result
, ScopeResult
);
778 const UnitVTable scope_vtable
= {
779 .object_size
= sizeof(Scope
),
780 .cgroup_context_offset
= offsetof(Scope
, cgroup_context
),
781 .kill_context_offset
= offsetof(Scope
, kill_context
),
782 .cgroup_runtime_offset
= offsetof(Scope
, cgroup_runtime
),
788 .private_section
= "Scope",
790 .can_transient
= true,
791 .can_delegate
= true,
794 .can_set_managed_oom
= true,
800 .coldplug
= scope_coldplug
,
804 .start
= scope_start
,
807 .freezer_action
= unit_cgroup_freezer_action
,
809 .get_timeout
= scope_get_timeout
,
811 .serialize
= scope_serialize
,
812 .deserialize_item
= scope_deserialize_item
,
814 .active_state
= scope_active_state
,
815 .sub_state_to_string
= scope_sub_state_to_string
,
817 .sigchld_event
= scope_sigchld_event
,
819 .reset_failed
= scope_reset_failed
,
821 .notify_cgroup_empty
= scope_notify_cgroup_empty_event
,
822 .notify_cgroup_oom
= scope_notify_cgroup_oom_event
,
824 .bus_set_property
= bus_scope_set_property
,
825 .bus_commit_properties
= bus_scope_commit_properties
,
827 .enumerate_perpetual
= scope_enumerate_perpetual
,