[thirdparty/systemd.git] / src / core / scope.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2013 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>
#include <signal.h>
#include <unistd.h>

#include "unit.h"
#include "scope.h"
#include "load-fragment.h"
#include "log.h"
#include "dbus-scope.h"
#include "special.h"
#include "unit-name.h"
#include "load-dropin.h"

static const UnitActiveState state_translation_table[_SCOPE_STATE_MAX] = {
        [SCOPE_DEAD] = UNIT_INACTIVE,
        [SCOPE_RUNNING] = UNIT_ACTIVE,
        [SCOPE_STOP_SIGTERM] = UNIT_DEACTIVATING,
        [SCOPE_STOP_SIGKILL] = UNIT_DEACTIVATING,
        [SCOPE_FAILED] = UNIT_FAILED
};

static void scope_init(Unit *u) {
        Scope *s = SCOPE(u);

        assert(u);
        assert(u->load_state == UNIT_STUB);

        s->timeout_stop_usec = u->manager->default_timeout_stop_usec;

        watch_init(&s->timer_watch);

        cgroup_context_init(&s->cgroup_context);
        kill_context_init(&s->kill_context);

        UNIT(s)->ignore_on_isolate = true;
        UNIT(s)->ignore_on_snapshot = true;
}

static void scope_done(Unit *u) {
        Scope *s = SCOPE(u);

        assert(u);

        cgroup_context_done(&s->cgroup_context);

        set_free(s->pids);
        s->pids = NULL;

        unit_unwatch_timer(u, &s->timer_watch);
}

static void scope_set_state(Scope *s, ScopeState state) {
        ScopeState old_state;
        assert(s);

        old_state = s->state;
        s->state = state;

        if (state != SCOPE_STOP_SIGTERM &&
            state != SCOPE_STOP_SIGKILL)
                unit_unwatch_timer(UNIT(s), &s->timer_watch);

        if (state != old_state)
                log_debug("%s changed %s -> %s",
                          UNIT(s)->id,
                          scope_state_to_string(old_state),
                          scope_state_to_string(state));

        unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
}

static int scope_add_default_dependencies(Scope *s) {
        int r;

        assert(s);

        /* Make sure scopes are unloaded on shutdown */
        r = unit_add_two_dependencies_by_name(
                        UNIT(s),
                        UNIT_BEFORE, UNIT_CONFLICTS,
                        SPECIAL_SHUTDOWN_TARGET, NULL, true);
        if (r < 0)
                return r;

        return 0;
}

static int scope_verify(Scope *s) {
        assert(s);

        if (UNIT(s)->load_state != UNIT_LOADED)
                return 0;

        if (set_size(s->pids) <= 0 && UNIT(s)->manager->n_reloading <= 0) {
                log_error_unit(UNIT(s)->id, "Scope %s has no PIDs. Refusing.", UNIT(s)->id);
                return -EINVAL;
        }

        return 0;
}

static int scope_load(Unit *u) {
        Scope *s = SCOPE(u);
        int r;

        assert(s);
        assert(u->load_state == UNIT_STUB);

        if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
                return -ENOENT;

        u->load_state = UNIT_LOADED;

        r = unit_load_dropin(u);
        if (r < 0)
                return r;

        r = unit_add_default_slice(u);
        if (r < 0)
                return r;

        if (u->default_dependencies) {
                r = scope_add_default_dependencies(s);
                if (r < 0)
                        return r;
        }

        return scope_verify(s);
}

static int scope_coldplug(Unit *u) {
        Scope *s = SCOPE(u);
        int r;

        assert(s);
        assert(s->state == SCOPE_DEAD);

        if (s->deserialized_state != s->state) {

                if ((s->deserialized_state == SCOPE_STOP_SIGKILL || s->deserialized_state == SCOPE_STOP_SIGTERM)
                    && s->timeout_stop_usec > 0) {
                        r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_stop_usec, &s->timer_watch);
                        if (r < 0)

                                return r;
                }

                scope_set_state(s, s->deserialized_state);
        }

        return 0;
}

static void scope_dump(Unit *u, FILE *f, const char *prefix) {
        Scope *s = SCOPE(u);

        assert(s);
        assert(f);

        fprintf(f,
                "%sScope State: %s\n"
                "%sResult: %s\n",
                prefix, scope_state_to_string(s->state),
                prefix, scope_result_to_string(s->result));

        cgroup_context_dump(&s->cgroup_context, f, prefix);
        kill_context_dump(&s->kill_context, f, prefix);
}

static void scope_enter_dead(Scope *s, ScopeResult f) {
        assert(s);

        if (f != SCOPE_SUCCESS)
                s->result = f;

        scope_set_state(s, s->result != SCOPE_SUCCESS ? SCOPE_FAILED : SCOPE_DEAD);
}

static void scope_enter_signal(Scope *s, ScopeState state, ScopeResult f) {
        int r;

        assert(s);

        if (f != SCOPE_SUCCESS)
                s->result = f;

        r = unit_kill_context(
                        UNIT(s),
                        &s->kill_context,
                        state != SCOPE_STOP_SIGTERM,
                        -1, -1, false);
        if (r < 0)
                goto fail;

        if (r > 0) {
                if (s->timeout_stop_usec > 0) {
                        r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_stop_usec, &s->timer_watch);
                        if (r < 0)
                                goto fail;
                }

                scope_set_state(s, state);
        } else
                scope_enter_dead(s, SCOPE_SUCCESS);

        return;

fail:
        log_warning_unit(UNIT(s)->id,
                         "%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));

        scope_enter_dead(s, SCOPE_FAILURE_RESOURCES);
}

static int scope_start(Unit *u) {
        Scope *s = SCOPE(u);
        int r;

        assert(s);

        if (s->state == SCOPE_FAILED)
                return -EPERM;

        if (s->state == SCOPE_STOP_SIGTERM ||
            s->state == SCOPE_STOP_SIGKILL)
                return -EAGAIN;

        assert(s->state == SCOPE_DEAD);

        if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
                return -ENOENT;

        r = unit_realize_cgroup(u);
        if (r < 0) {
                log_error("Failed to realize cgroup: %s", strerror(-r));
                return r;
        }

        r = cg_attach_many_everywhere(u->manager->cgroup_supported, u->cgroup_path, s->pids);
        if (r < 0)
                return r;

        set_free(s->pids);
        s->pids = NULL;

        s->result = SCOPE_SUCCESS;

        scope_set_state(s, SCOPE_RUNNING);
        return 0;
}

static int scope_stop(Unit *u) {
        Scope *s = SCOPE(u);

        assert(s);
        assert(s->state == SCOPE_RUNNING);

        if (s->state == SCOPE_STOP_SIGTERM ||
            s->state == SCOPE_STOP_SIGKILL)
                return 0;

        assert(s->state == SCOPE_RUNNING);

        scope_enter_signal(s, SCOPE_STOP_SIGTERM, SCOPE_SUCCESS);
        return 0;
}

static void scope_reset_failed(Unit *u) {
        Scope *s = SCOPE(u);

        assert(s);

        if (s->state == SCOPE_FAILED)
                scope_set_state(s, SCOPE_DEAD);

        s->result = SCOPE_SUCCESS;
}

static int scope_kill(Unit *u, KillWho who, int signo, DBusError *error) {
        return unit_kill_common(u, who, signo, -1, -1, error);
}

static int scope_serialize(Unit *u, FILE *f, FDSet *fds) {
        Scope *s = SCOPE(u);

        assert(s);
        assert(f);
        assert(fds);

        unit_serialize_item(u, f, "state", scope_state_to_string(s->state));
        return 0;
}

static int scope_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
        Scope *s = SCOPE(u);

        assert(u);
        assert(key);
        assert(value);
        assert(fds);

        if (streq(key, "state")) {
                ScopeState state;

                state = scope_state_from_string(value);
                if (state < 0)
                        log_debug("Failed to parse state value %s", value);
                else
                        s->deserialized_state = state;

        } else
                log_debug("Unknown serialization key '%s'", key);

        return 0;
}

static bool scope_check_gc(Unit *u) {
        Scope *s = SCOPE(u);
        int r;

        assert(s);

        /* Never clean up scopes that still have a process around,
         * even if the scope is formally dead. */

        if (UNIT(s)->cgroup_path) {
                r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
                if (r <= 0)
                        return true;
        }

        return false;
}

static void scope_timer_event(Unit *u, uint64_t elapsed, Watch*w) {
        Scope *s = SCOPE(u);

        assert(s);
        assert(elapsed == 1);
        assert(w == &s->timer_watch);

        switch (s->state) {

        case SCOPE_STOP_SIGTERM:
                if (s->kill_context.send_sigkill) {
                        log_warning_unit(u->id, "%s stopping timed out. Killing.", u->id);
                        scope_enter_signal(s, SCOPE_STOP_SIGKILL, SCOPE_FAILURE_TIMEOUT);
                } else {
                        log_warning_unit(u->id, "%s stopping timed out. Skipping SIGKILL.", u->id);
                        scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
                }

                break;

        case SCOPE_STOP_SIGKILL:
                log_warning_unit(u->id, "%s still around after SIGKILL. Ignoring.", u->id);
                scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
                break;

        default:
                assert_not_reached("Timeout at wrong time.");
        }
}

static void scope_notify_cgroup_empty_event(Unit *u) {
        Scope *s = SCOPE(u);
        assert(u);

        log_debug_unit(u->id, "%s: cgroup is empty", u->id);

        switch (s->state) {

        case SCOPE_RUNNING:
        case SCOPE_STOP_SIGTERM:
        case SCOPE_STOP_SIGKILL:
                scope_enter_dead(s, SCOPE_SUCCESS);

                break;

        default:
                ;
        }
}

_pure_ static UnitActiveState scope_active_state(Unit *u) {
        assert(u);

        return state_translation_table[SCOPE(u)->state];
}

_pure_ static const char *scope_sub_state_to_string(Unit *u) {
        assert(u);

        return scope_state_to_string(SCOPE(u)->state);
}

static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
        [SCOPE_DEAD] = "dead",
        [SCOPE_RUNNING] = "running",
        [SCOPE_STOP_SIGTERM] = "stop-sigterm",
        [SCOPE_STOP_SIGKILL] = "stop-sigkill",
        [SCOPE_FAILED] = "failed",
};

DEFINE_STRING_TABLE_LOOKUP(scope_state, ScopeState);

static const char* const scope_result_table[_SCOPE_RESULT_MAX] = {
        [SCOPE_SUCCESS] = "success",
        [SCOPE_FAILURE_RESOURCES] = "resources",
        [SCOPE_FAILURE_TIMEOUT] = "timeout",
};

DEFINE_STRING_TABLE_LOOKUP(scope_result, ScopeResult);

const UnitVTable scope_vtable = {
        .object_size = sizeof(Scope),
        .sections =
                "Unit\0"
                "Scope\0"
                "Install\0",

        .private_section = "Scope",
        .cgroup_context_offset = offsetof(Scope, cgroup_context),

        .no_alias = true,
        .no_instances = true,

        .init = scope_init,
        .load = scope_load,
        .done = scope_done,

        .coldplug = scope_coldplug,

        .dump = scope_dump,

        .start = scope_start,
        .stop = scope_stop,

        .kill = scope_kill,

        .serialize = scope_serialize,
        .deserialize_item = scope_deserialize_item,

        .active_state = scope_active_state,
        .sub_state_to_string = scope_sub_state_to_string,

        .check_gc = scope_check_gc,

        .timer_event = scope_timer_event,

        .reset_failed = scope_reset_failed,

        .notify_cgroup_empty = scope_notify_cgroup_empty_event,

        .bus_interface = "org.freedesktop.systemd1.Scope",
        .bus_message_handler = bus_scope_message_handler,
        .bus_set_property = bus_scope_set_property,
        .bus_commit_properties = bus_scope_commit_properties,

        .can_transient = true
};
Commit	Line	Data
6c12b52e LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2013 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 <signal.h>
	24	#include <unistd.h>
	25
	26	#include "unit.h"
	27	#include "scope.h"
	28	#include "load-fragment.h"
	29	#include "log.h"
	30	#include "dbus-scope.h"
	31	#include "special.h"
	32	#include "unit-name.h"
	33	#include "load-dropin.h"
	34
	35	static const UnitActiveState state_translation_table[_SCOPE_STATE_MAX] = {
	36	[SCOPE_DEAD] = UNIT_INACTIVE,
	37	[SCOPE_RUNNING] = UNIT_ACTIVE,
	38	[SCOPE_STOP_SIGTERM] = UNIT_DEACTIVATING,
	39	[SCOPE_STOP_SIGKILL] = UNIT_DEACTIVATING,
	40	[SCOPE_FAILED] = UNIT_FAILED
	41	};
	42
	43	static void scope_init(Unit *u) {
	44	Scope *s = SCOPE(u);
	45
	46	assert(u);
	47	assert(u->load_state == UNIT_STUB);
	48
1f19a534	49	s->timeout_stop_usec = u->manager->default_timeout_stop_usec;
6c12b52e LP	50
	51	watch_init(&s->timer_watch);
	52
	53	cgroup_context_init(&s->cgroup_context);
	54	kill_context_init(&s->kill_context);
	55
	56	UNIT(s)->ignore_on_isolate = true;
	57	UNIT(s)->ignore_on_snapshot = true;
	58	}
	59
	60	static void scope_done(Unit *u) {
	61	Scope *s = SCOPE(u);
	62
	63	assert(u);
	64
	65	cgroup_context_done(&s->cgroup_context);
	66
	67	set_free(s->pids);
	68	s->pids = NULL;
	69
	70	unit_unwatch_timer(u, &s->timer_watch);
	71	}
	72
	73	static void scope_set_state(Scope *s, ScopeState state) {
	74	ScopeState old_state;
	75	assert(s);
	76
	77	old_state = s->state;
	78	s->state = state;
	79
	80	if (state != SCOPE_STOP_SIGTERM &&
	81	state != SCOPE_STOP_SIGKILL)
	82	unit_unwatch_timer(UNIT(s), &s->timer_watch);
	83
	84	if (state != old_state)
	85	log_debug("%s changed %s -> %s",
	86	UNIT(s)->id,
	87	scope_state_to_string(old_state),
	88	scope_state_to_string(state));
	89
	90	unit_notify(UNIT(s), state_translation_table[old_state], state_translation_table[state], true);
	91	}
	92
	93	static int scope_add_default_dependencies(Scope *s) {
	94	int r;
	95
	96	assert(s);
	97
	98	/* Make sure scopes are unloaded on shutdown */
	99	r = unit_add_two_dependencies_by_name(
	100	UNIT(s),
	101	UNIT_BEFORE, UNIT_CONFLICTS,
	102	SPECIAL_SHUTDOWN_TARGET, NULL, true);
	103	if (r < 0)
	104	return r;
	105
	106	return 0;
	107	}
	108
	109	static int scope_verify(Scope *s) {
	110	assert(s);
	111
	112	if (UNIT(s)->load_state != UNIT_LOADED)
	113	return 0;
114
0c5778a2	115	if (set_size(s->pids) <= 0 && UNIT(s)->manager->n_reloading <= 0) {
6c12b52e LP	116	log_error_unit(UNIT(s)->id, "Scope %s has no PIDs. Refusing.", UNIT(s)->id);
	117	return -EINVAL;
	118	}
	119
	120	return 0;
	121	}
	122
	123	static int scope_load(Unit *u) {
	124	Scope *s = SCOPE(u);
	125	int r;
	126
	127	assert(s);
	128	assert(u->load_state == UNIT_STUB);
	129
	130	if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
	131	return -ENOENT;
	132
	133	u->load_state = UNIT_LOADED;
	134
	135	r = unit_load_dropin(u);
	136	if (r < 0)
	137	return r;
	138
	139	r = unit_add_default_slice(u);
	140	if (r < 0)
	141	return r;
	142
	143	if (u->default_dependencies) {
	144	r = scope_add_default_dependencies(s);
	145	if (r < 0)
	146	return r;
	147	}
	148
	149	return scope_verify(s);
	150	}
	151
	152	static int scope_coldplug(Unit *u) {
	153	Scope *s = SCOPE(u);
	154	int r;
	155
	156	assert(s);
	157	assert(s->state == SCOPE_DEAD);
	158
	159	if (s->deserialized_state != s->state) {
	160
	161	if ((s->deserialized_state == SCOPE_STOP_SIGKILL \|\| s->deserialized_state == SCOPE_STOP_SIGTERM)
	162	&& s->timeout_stop_usec > 0) {
	163	r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_stop_usec, &s->timer_watch);
	164	if (r < 0)
	165
	166	return r;
	167	}
	168
	169	scope_set_state(s, s->deserialized_state);
	170	}
	171
	172	return 0;
	173	}
	174
	175	static void scope_dump(Unit u, FILE f, const char *prefix) {
	176	Scope *s = SCOPE(u);
	177
	178	assert(s);
	179	assert(f);
180
181	fprintf(f,
182	"%sScope State: %s\n"
183	"%sResult: %s\n",
184	prefix, scope_state_to_string(s->state),
185	prefix, scope_result_to_string(s->result));
186
187	cgroup_context_dump(&s->cgroup_context, f, prefix);
188	kill_context_dump(&s->kill_context, f, prefix);
189	}
190
191	static void scope_enter_dead(Scope *s, ScopeResult f) {
192	assert(s);
193
194	if (f != SCOPE_SUCCESS)
195	s->result = f;
196
197	scope_set_state(s, s->result != SCOPE_SUCCESS ? SCOPE_FAILED : SCOPE_DEAD);
198	}
199
200	static void scope_enter_signal(Scope *s, ScopeState state, ScopeResult f) {
201	int r;
202
203	assert(s);
204
205	if (f != SCOPE_SUCCESS)
206	s->result = f;
207
208	r = unit_kill_context(
209	UNIT(s),
210	&s->kill_context,
211	state != SCOPE_STOP_SIGTERM,
212	-1, -1, false);
213	if (r < 0)
214	goto fail;
215
216	if (r > 0) {
217	if (s->timeout_stop_usec > 0) {
218	r = unit_watch_timer(UNIT(s), CLOCK_MONOTONIC, true, s->timeout_stop_usec, &s->timer_watch);
219	if (r < 0)
220	goto fail;
221	}
222
223	scope_set_state(s, state);
224	} else
225	scope_enter_dead(s, SCOPE_SUCCESS);
226
227	return;
228
229	fail:
230	log_warning_unit(UNIT(s)->id,
231	"%s failed to kill processes: %s", UNIT(s)->id, strerror(-r));
232
233	scope_enter_dead(s, SCOPE_FAILURE_RESOURCES);
234	}
235
236	static int scope_start(Unit *u) {
237	Scope *s = SCOPE(u);
238	int r;
239
240	assert(s);
241
7b617155 LP	242	if (s->state == SCOPE_FAILED)
	243	return -EPERM;
	244
6c12b52e LP	245	if (s->state == SCOPE_STOP_SIGTERM \|\|
	246	s->state == SCOPE_STOP_SIGKILL)
	247	return -EAGAIN;
	248
	249	assert(s->state == SCOPE_DEAD);
	250
	251	if (!u->transient && UNIT(s)->manager->n_reloading <= 0)
	252	return -ENOENT;
	253
	254	r = unit_realize_cgroup(u);
	255	if (r < 0) {
	256	log_error("Failed to realize cgroup: %s", strerror(-r));
	257	return r;
	258	}
	259
13b84ec7	260	r = cg_attach_many_everywhere(u->manager->cgroup_supported, u->cgroup_path, s->pids);
6c12b52e LP	261	if (r < 0)
	262	return r;
	263
	264	set_free(s->pids);
	265	s->pids = NULL;
	266
	267	s->result = SCOPE_SUCCESS;
	268
	269	scope_set_state(s, SCOPE_RUNNING);
	270	return 0;
	271	}
	272
	273	static int scope_stop(Unit *u) {
	274	Scope *s = SCOPE(u);
	275
	276	assert(s);
	277	assert(s->state == SCOPE_RUNNING);
	278
	279	if (s->state == SCOPE_STOP_SIGTERM \|\|
	280	s->state == SCOPE_STOP_SIGKILL)
	281	return 0;
	282
	283	assert(s->state == SCOPE_RUNNING);
	284
	285	scope_enter_signal(s, SCOPE_STOP_SIGTERM, SCOPE_SUCCESS);
	286	return 0;
	287	}
	288
8bcca7e2 LP	289	static void scope_reset_failed(Unit *u) {
	290	Scope *s = SCOPE(u);
	291
	292	assert(s);
	293
	294	if (s->state == SCOPE_FAILED)
	295	scope_set_state(s, SCOPE_DEAD);
	296
	297	s->result = SCOPE_SUCCESS;
	298	}
	299
6c12b52e LP	300	static int scope_kill(Unit u, KillWho who, int signo, DBusError error) {
	301	return unit_kill_common(u, who, signo, -1, -1, error);
	302	}
	303
	304	static int scope_serialize(Unit u, FILE f, FDSet *fds) {
	305	Scope *s = SCOPE(u);
	306
	307	assert(s);
	308	assert(f);
	309	assert(fds);
	310
	311	unit_serialize_item(u, f, "state", scope_state_to_string(s->state));
	312	return 0;
	313	}
	314
	315	static int scope_deserialize_item(Unit u, const char key, const char value, FDSet fds) {
	316	Scope *s = SCOPE(u);
	317
	318	assert(u);
	319	assert(key);
	320	assert(value);
	321	assert(fds);
	322
	323	if (streq(key, "state")) {
	324	ScopeState state;
	325
	326	state = scope_state_from_string(value);
	327	if (state < 0)
	328	log_debug("Failed to parse state value %s", value);
	329	else
	330	s->deserialized_state = state;
	331
	332	} else
	333	log_debug("Unknown serialization key '%s'", key);
	334
	335	return 0;
	336	}
	337
	338	static bool scope_check_gc(Unit *u) {
	339	Scope *s = SCOPE(u);
	340	int r;
	341
	342	assert(s);
	343
	344	/* Never clean up scopes that still have a process around,
	345	* even if the scope is formally dead. */
	346
	347	if (UNIT(s)->cgroup_path) {
	348	r = cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, UNIT(s)->cgroup_path, true);
	349	if (r <= 0)
	350	return true;
	351	}
	352
	353	return false;
	354	}
	355
	356	static void scope_timer_event(Unit u, uint64_t elapsed, Watchw) {
	357	Scope *s = SCOPE(u);
	358
	359	assert(s);
	360	assert(elapsed == 1);
	361	assert(w == &s->timer_watch);
	362
	363	switch (s->state) {
364
365	case SCOPE_STOP_SIGTERM:
366	if (s->kill_context.send_sigkill) {
367	log_warning_unit(u->id, "%s stopping timed out. Killing.", u->id);
368	scope_enter_signal(s, SCOPE_STOP_SIGKILL, SCOPE_FAILURE_TIMEOUT);
369	} else {
370	log_warning_unit(u->id, "%s stopping timed out. Skipping SIGKILL.", u->id);
371	scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
372	}
373
374	break;
375
376	case SCOPE_STOP_SIGKILL:
377	log_warning_unit(u->id, "%s still around after SIGKILL. Ignoring.", u->id);
378	scope_enter_dead(s, SCOPE_FAILURE_TIMEOUT);
379	break;
380
381	default:
382	assert_not_reached("Timeout at wrong time.");
383	}
384	}
385
386	static void scope_notify_cgroup_empty_event(Unit *u) {
387	Scope *s = SCOPE(u);
388	assert(u);
389
390	log_debug_unit(u->id, "%s: cgroup is empty", u->id);
391
392	switch (s->state) {
393
394	case SCOPE_RUNNING:
395	case SCOPE_STOP_SIGTERM:
396	case SCOPE_STOP_SIGKILL:
397	scope_enter_dead(s, SCOPE_SUCCESS);
398
399	break;
400
401	default:
402	;
403	}
404	}
405
406	_pure_ static UnitActiveState scope_active_state(Unit *u) {
407	assert(u);
408
409	return state_translation_table[SCOPE(u)->state];
410	}
411
412	_pure_ static const char scope_sub_state_to_string(Unit u) {
413	assert(u);
414
415	return scope_state_to_string(SCOPE(u)->state);
416	}
417
418	static const char* const scope_state_table[_SCOPE_STATE_MAX] = {
419	[SCOPE_DEAD] = "dead",
358712f3	420	[SCOPE_RUNNING] = "running",
6c12b52e LP	421	[SCOPE_STOP_SIGTERM] = "stop-sigterm",
	422	[SCOPE_STOP_SIGKILL] = "stop-sigkill",
	423	[SCOPE_FAILED] = "failed",
	424	};
	425
	426	DEFINE_STRING_TABLE_LOOKUP(scope_state, ScopeState);
	427
	428	static const char* const scope_result_table[_SCOPE_RESULT_MAX] = {
	429	[SCOPE_SUCCESS] = "success",
	430	[SCOPE_FAILURE_RESOURCES] = "resources",
	431	[SCOPE_FAILURE_TIMEOUT] = "timeout",
	432	};
	433
	434	DEFINE_STRING_TABLE_LOOKUP(scope_result, ScopeResult);
	435
	436	const UnitVTable scope_vtable = {
	437	.object_size = sizeof(Scope),
	438	.sections =
	439	"Unit\0"
	440	"Scope\0"
	441	"Install\0",
	442
	443	.private_section = "Scope",
	444	.cgroup_context_offset = offsetof(Scope, cgroup_context),
	445
	446	.no_alias = true,
	447	.no_instances = true,
	448
	449	.init = scope_init,
	450	.load = scope_load,
	451	.done = scope_done,
	452
	453	.coldplug = scope_coldplug,
	454
	455	.dump = scope_dump,
	456
	457	.start = scope_start,
	458	.stop = scope_stop,
	459
	460	.kill = scope_kill,
	461
	462	.serialize = scope_serialize,
	463	.deserialize_item = scope_deserialize_item,
	464
	465	.active_state = scope_active_state,
	466	.sub_state_to_string = scope_sub_state_to_string,
	467
	468	.check_gc = scope_check_gc,
	469
	470	.timer_event = scope_timer_event,
	471
8bcca7e2 LP	472	.reset_failed = scope_reset_failed,
8bcca7e2 LP	473
6c12b52e LP	474	.notify_cgroup_empty = scope_notify_cgroup_empty_event,
	475
	476	.bus_interface = "org.freedesktop.systemd1.Scope",
	477	.bus_message_handler = bus_scope_message_handler,
	478	.bus_set_property = bus_scope_set_property,
	479	.bus_commit_properties = bus_scope_commit_properties,
	480
	481	.can_transient = true
	482	};