2 This file is part of systemd.
4 Copyright 2013 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include "alloc-util.h"
24 #include "dbus-scope.h"
25 #include "load-dropin.h"
29 #include "string-table.h"
30 #include "string-util.h"
32 #include "unit-name.h"
35 static const UnitActiveState state_translation_table
[_SCOPE_STATE_MAX
] = {
36 [SCOPE_DEAD
] = UNIT_INACTIVE
,
37 [SCOPE_RUNNING
] = UNIT_ACTIVE
,
38 [SCOPE_ABANDONED
] = UNIT_ACTIVE
,
39 [SCOPE_STOP_SIGTERM
] = UNIT_DEACTIVATING
,
40 [SCOPE_STOP_SIGKILL
] = UNIT_DEACTIVATING
,
41 [SCOPE_FAILED
] = UNIT_FAILED
44 static int scope_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
46 static void scope_init(Unit
*u
) {
50 assert(u
->load_state
== UNIT_STUB
);
52 s
->timeout_stop_usec
= u
->manager
->default_timeout_stop_usec
;
53 u
->ignore_on_isolate
= true;
56 static void scope_done(Unit
*u
) {
63 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
66 static int scope_arm_timer(Scope
*s
, usec_t usec
) {
71 if (s
->timer_event_source
) {
72 r
= sd_event_source_set_time(s
->timer_event_source
, usec
);
76 return sd_event_source_set_enabled(s
->timer_event_source
, SD_EVENT_ONESHOT
);
79 if (usec
== USEC_INFINITY
)
82 r
= sd_event_add_time(
83 UNIT(s
)->manager
->event
,
84 &s
->timer_event_source
,
87 scope_dispatch_timer
, s
);
91 (void) sd_event_source_set_description(s
->timer_event_source
, "scope-timer");
96 static void scope_set_state(Scope
*s
, ScopeState state
) {
100 old_state
= s
->state
;
103 if (!IN_SET(state
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
))
104 s
->timer_event_source
= sd_event_source_unref(s
->timer_event_source
);
106 if (IN_SET(state
, SCOPE_DEAD
, SCOPE_FAILED
))
107 unit_unwatch_all_pids(UNIT(s
));
109 if (state
!= old_state
)
110 log_debug("%s changed %s -> %s", UNIT(s
)->id
, scope_state_to_string(old_state
), scope_state_to_string(state
));
112 unit_notify(UNIT(s
), state_translation_table
[old_state
], state_translation_table
[state
], true);
115 static int scope_add_default_dependencies(Scope
*s
) {
120 if (!UNIT(s
)->default_dependencies
)
123 /* Make sure scopes are unloaded on shutdown */
124 r
= unit_add_two_dependencies_by_name(
126 UNIT_BEFORE
, UNIT_CONFLICTS
,
127 SPECIAL_SHUTDOWN_TARGET
, NULL
, true);
134 static int scope_verify(Scope
*s
) {
137 if (UNIT(s
)->load_state
!= UNIT_LOADED
)
140 if (set_isempty(UNIT(s
)->pids
) &&
141 !MANAGER_IS_RELOADING(UNIT(s
)->manager
) &&
142 !unit_has_name(UNIT(s
), SPECIAL_INIT_SCOPE
)) {
143 log_unit_error(UNIT(s
), "Scope has no PIDs. Refusing.");
150 static int scope_load(Unit
*u
) {
155 assert(u
->load_state
== UNIT_STUB
);
157 if (!u
->transient
&& !MANAGER_IS_RELOADING(u
->manager
))
158 /* Refuse to load non-transient scope units, but allow them while reloading. */
161 r
= unit_load_fragment_and_dropin_optional(u
);
165 if (u
->load_state
== UNIT_LOADED
) {
166 r
= unit_patch_contexts(u
);
170 r
= unit_set_default_slice(u
);
174 r
= scope_add_default_dependencies(s
);
179 return scope_verify(s
);
182 static int scope_coldplug(Unit
*u
) {
187 assert(s
->state
== SCOPE_DEAD
);
189 if (s
->deserialized_state
== s
->state
)
192 if (IN_SET(s
->deserialized_state
, SCOPE_STOP_SIGKILL
, SCOPE_STOP_SIGTERM
)) {
193 r
= scope_arm_timer(s
, usec_add(u
->state_change_timestamp
.monotonic
, s
->timeout_stop_usec
));
198 if (!IN_SET(s
->deserialized_state
, SCOPE_DEAD
, SCOPE_FAILED
))
199 unit_watch_all_pids(UNIT(s
));
201 scope_set_state(s
, s
->deserialized_state
);
205 static void scope_dump(Unit
*u
, FILE *f
, const char *prefix
) {
212 "%sScope State: %s\n"
214 prefix
, scope_state_to_string(s
->state
),
215 prefix
, scope_result_to_string(s
->result
));
217 cgroup_context_dump(&s
->cgroup_context
, f
, prefix
);
218 kill_context_dump(&s
->kill_context
, f
, prefix
);
221 static void scope_enter_dead(Scope
*s
, ScopeResult f
) {
224 if (f
!= SCOPE_SUCCESS
)
227 scope_set_state(s
, s
->result
!= SCOPE_SUCCESS
? SCOPE_FAILED
: SCOPE_DEAD
);
230 static void scope_enter_signal(Scope
*s
, ScopeState state
, ScopeResult f
) {
231 bool skip_signal
= false;
236 if (f
!= SCOPE_SUCCESS
)
239 unit_watch_all_pids(UNIT(s
));
241 /* If we have a controller set let's ask the controller nicely
242 * to terminate the scope, instead of us going directly into
243 * SIGTERM beserk mode */
244 if (state
== SCOPE_STOP_SIGTERM
)
245 skip_signal
= bus_scope_send_request_stop(s
) > 0;
248 r
= unit_kill_context(
251 state
!= SCOPE_STOP_SIGTERM
? KILL_KILL
: KILL_TERMINATE
,
259 r
= scope_arm_timer(s
, usec_add(now(CLOCK_MONOTONIC
), s
->timeout_stop_usec
));
263 scope_set_state(s
, state
);
264 } else if (state
== SCOPE_STOP_SIGTERM
)
265 scope_enter_signal(s
, SCOPE_STOP_SIGKILL
, SCOPE_SUCCESS
);
267 scope_enter_dead(s
, SCOPE_SUCCESS
);
272 log_unit_warning_errno(UNIT(s
), r
, "Failed to kill processes: %m");
274 scope_enter_dead(s
, SCOPE_FAILURE_RESOURCES
);
277 static int scope_start(Unit
*u
) {
283 if (unit_has_name(u
, SPECIAL_INIT_SCOPE
))
286 if (s
->state
== SCOPE_FAILED
)
289 /* We can't fulfill this right now, please try again later */
290 if (s
->state
== SCOPE_STOP_SIGTERM
||
291 s
->state
== SCOPE_STOP_SIGKILL
)
294 assert(s
->state
== SCOPE_DEAD
);
296 if (!u
->transient
&& !MANAGER_IS_RELOADING(u
->manager
))
299 (void) unit_realize_cgroup(u
);
300 (void) unit_reset_cpu_usage(u
);
302 r
= unit_attach_pids_to_cgroup(u
);
304 log_unit_warning_errno(UNIT(s
), r
, "Failed to add PIDs to scope's control group: %m");
305 scope_enter_dead(s
, SCOPE_FAILURE_RESOURCES
);
309 s
->result
= SCOPE_SUCCESS
;
311 scope_set_state(s
, SCOPE_RUNNING
);
315 static int scope_stop(Unit
*u
) {
320 if (s
->state
== SCOPE_STOP_SIGTERM
||
321 s
->state
== SCOPE_STOP_SIGKILL
)
324 assert(s
->state
== SCOPE_RUNNING
||
325 s
->state
== SCOPE_ABANDONED
);
327 scope_enter_signal(s
, SCOPE_STOP_SIGTERM
, SCOPE_SUCCESS
);
331 static void scope_reset_failed(Unit
*u
) {
336 if (s
->state
== SCOPE_FAILED
)
337 scope_set_state(s
, SCOPE_DEAD
);
339 s
->result
= SCOPE_SUCCESS
;
342 static int scope_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
343 return unit_kill_common(u
, who
, signo
, -1, -1, error
);
346 static int scope_get_timeout(Unit
*u
, usec_t
*timeout
) {
351 if (!s
->timer_event_source
)
354 r
= sd_event_source_get_time(s
->timer_event_source
, &t
);
357 if (t
== USEC_INFINITY
)
364 static int scope_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
371 unit_serialize_item(u
, f
, "state", scope_state_to_string(s
->state
));
375 static int scope_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
383 if (streq(key
, "state")) {
386 state
= scope_state_from_string(value
);
388 log_unit_debug(u
, "Failed to parse state value: %s", value
);
390 s
->deserialized_state
= state
;
393 log_unit_debug(u
, "Unknown serialization key: %s", key
);
398 static bool scope_check_gc(Unit
*u
) {
401 /* Never clean up scopes that still have a process around,
402 * even if the scope is formally dead. */
407 return cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER
, u
->cgroup_path
) <= 0;
410 static void scope_notify_cgroup_empty_event(Unit
*u
) {
414 log_unit_debug(u
, "cgroup is empty");
416 if (IN_SET(s
->state
, SCOPE_RUNNING
, SCOPE_ABANDONED
, SCOPE_STOP_SIGTERM
, SCOPE_STOP_SIGKILL
))
417 scope_enter_dead(s
, SCOPE_SUCCESS
);
420 static void scope_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
422 /* If we get a SIGCHLD event for one of the processes we were
423 interested in, then we look for others to watch, under the
424 assumption that we'll sooner or later get a SIGCHLD for
425 them, as the original process we watched was probably the
426 parent of them, and they are hence now our children. */
428 unit_tidy_watch_pids(u
, 0, 0);
429 unit_watch_all_pids(u
);
431 /* If the PID set is empty now, then let's finish this off */
432 if (set_isempty(u
->pids
))
433 scope_notify_cgroup_empty_event(u
);
436 static int scope_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
437 Scope
*s
= SCOPE(userdata
);
440 assert(s
->timer_event_source
== source
);
444 case SCOPE_STOP_SIGTERM
:
445 if (s
->kill_context
.send_sigkill
) {
446 log_unit_warning(UNIT(s
), "Stopping timed out. Killing.");
447 scope_enter_signal(s
, SCOPE_STOP_SIGKILL
, SCOPE_FAILURE_TIMEOUT
);
449 log_unit_warning(UNIT(s
), "Stopping timed out. Skipping SIGKILL.");
450 scope_enter_dead(s
, SCOPE_FAILURE_TIMEOUT
);
455 case SCOPE_STOP_SIGKILL
:
456 log_unit_warning(UNIT(s
), "Still around after SIGKILL. Ignoring.");
457 scope_enter_dead(s
, SCOPE_FAILURE_TIMEOUT
);
461 assert_not_reached("Timeout at wrong time.");
467 int scope_abandon(Scope
*s
) {
470 if (unit_has_name(UNIT(s
), SPECIAL_INIT_SCOPE
))
473 if (!IN_SET(s
->state
, SCOPE_RUNNING
, SCOPE_ABANDONED
))
476 s
->controller
= mfree(s
->controller
);
478 /* The client is no longer watching the remaining processes,
479 * so let's step in here, under the assumption that the
480 * remaining processes will be sooner or later reassigned to
483 unit_tidy_watch_pids(UNIT(s
), 0, 0);
484 unit_watch_all_pids(UNIT(s
));
486 /* If the PID set is empty now, then let's finish this off */
487 if (set_isempty(UNIT(s
)->pids
))
488 scope_notify_cgroup_empty_event(UNIT(s
));
490 scope_set_state(s
, SCOPE_ABANDONED
);
495 _pure_
static UnitActiveState
scope_active_state(Unit
*u
) {
498 return state_translation_table
[SCOPE(u
)->state
];
501 _pure_
static const char *scope_sub_state_to_string(Unit
*u
) {
504 return scope_state_to_string(SCOPE(u
)->state
);
507 static void scope_enumerate(Manager
*m
) {
513 /* Let's unconditionally add the "init.scope" special unit
514 * that encapsulates PID 1. Note that PID 1 already is in the
515 * cgroup for this, we hence just need to allocate the object
516 * for it and that's it. */
518 u
= manager_get_unit(m
, SPECIAL_INIT_SCOPE
);
520 u
= unit_new(m
, sizeof(Scope
));
526 r
= unit_add_name(u
, SPECIAL_INIT_SCOPE
);
529 log_error_errno(r
, "Failed to add init.scope name");
535 u
->default_dependencies
= false;
537 u
->ignore_on_isolate
= true;
538 u
->refuse_manual_start
= true;
539 u
->refuse_manual_stop
= true;
540 SCOPE(u
)->deserialized_state
= SCOPE_RUNNING
;
541 SCOPE(u
)->kill_context
.kill_signal
= SIGRTMIN
+14;
543 /* Prettify things, if we can. */
545 u
->description
= strdup("System and Service Manager");
546 if (!u
->documentation
)
547 (void) strv_extend(&u
->documentation
, "man:systemd(1)");
549 unit_add_to_load_queue(u
);
550 unit_add_to_dbus_queue(u
);
553 static const char* const scope_result_table
[_SCOPE_RESULT_MAX
] = {
554 [SCOPE_SUCCESS
] = "success",
555 [SCOPE_FAILURE_RESOURCES
] = "resources",
556 [SCOPE_FAILURE_TIMEOUT
] = "timeout",
559 DEFINE_STRING_TABLE_LOOKUP(scope_result
, ScopeResult
);
561 const UnitVTable scope_vtable
= {
562 .object_size
= sizeof(Scope
),
563 .cgroup_context_offset
= offsetof(Scope
, cgroup_context
),
564 .kill_context_offset
= offsetof(Scope
, kill_context
),
570 .private_section
= "Scope",
572 .can_transient
= true,
578 .coldplug
= scope_coldplug
,
582 .start
= scope_start
,
587 .get_timeout
= scope_get_timeout
,
589 .serialize
= scope_serialize
,
590 .deserialize_item
= scope_deserialize_item
,
592 .active_state
= scope_active_state
,
593 .sub_state_to_string
= scope_sub_state_to_string
,
595 .check_gc
= scope_check_gc
,
597 .sigchld_event
= scope_sigchld_event
,
599 .reset_failed
= scope_reset_failed
,
601 .notify_cgroup_empty
= scope_notify_cgroup_empty_event
,
603 .bus_vtable
= bus_scope_vtable
,
604 .bus_set_property
= bus_scope_set_property
,
605 .bus_commit_properties
= bus_scope_commit_properties
,
607 .enumerate
= scope_enumerate
,