chiark / gitweb /
manager: don't do plymouth in a container
[elogind.git] / src / core / slice.c
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 "slice.h"
28 #include "load-fragment.h"
29 #include "log.h"
30 #include "dbus-slice.h"
31 #include "special.h"
32 #include "unit-name.h"
33
34 static const UnitActiveState state_translation_table[_SLICE_STATE_MAX] = {
35         [SLICE_DEAD] = UNIT_INACTIVE,
36         [SLICE_ACTIVE] = UNIT_ACTIVE
37 };
38
39 static void slice_init(Unit *u) {
40         Slice *s = SLICE(u);
41
42         assert(u);
43         assert(u->load_state == UNIT_STUB);
44
45         cgroup_context_init(&s->cgroup_context);
46 }
47
48 static void slice_done(Unit *u) {
49         Slice *s = SLICE(u);
50
51         assert(u);
52
53         cgroup_context_done(&s->cgroup_context);
54 }
55
56 static void slice_set_state(Slice *t, SliceState state) {
57         SliceState old_state;
58         assert(t);
59
60         old_state = t->state;
61         t->state = state;
62
63         if (state != old_state)
64                 log_debug("%s changed %s -> %s",
65                           UNIT(t)->id,
66                           slice_state_to_string(old_state),
67                           slice_state_to_string(state));
68
69         unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
70 }
71
72 static int slice_add_parent_slice(Slice *s) {
73         char *a, *dash;
74         Unit *parent;
75         int r;
76
77         assert(s);
78
79         if (UNIT_ISSET(UNIT(s)->slice))
80                 return 0;
81
82         if (unit_has_name(UNIT(s), SPECIAL_ROOT_SLICE))
83                 return 0;
84
85         a = strdupa(UNIT(s)->id);
86         dash = strrchr(a, '-');
87         if (dash)
88                 strcpy(dash, ".slice");
89         else
90                 a = (char*) SPECIAL_ROOT_SLICE;
91
92         r = manager_load_unit(UNIT(s)->manager, a, NULL, NULL, &parent);
93         if (r < 0)
94                 return r;
95
96         unit_ref_set(&UNIT(s)->slice, parent);
97         return 0;
98 }
99
100 static int slice_add_default_dependencies(Slice *s) {
101         int r;
102
103         assert(s);
104
105         /* Make sure slices are unloaded on shutdown */
106         r = unit_add_two_dependencies_by_name(
107                         UNIT(s),
108                         UNIT_BEFORE, UNIT_CONFLICTS,
109                         SPECIAL_SHUTDOWN_TARGET, NULL, true);
110         if (r < 0)
111                 return r;
112
113         return 0;
114 }
115
116 static int slice_verify(Slice *s) {
117         assert(s);
118
119         if (UNIT(s)->load_state != UNIT_LOADED)
120                 return 0;
121
122         if (UNIT_DEREF(UNIT(s)->slice)) {
123                 char *a, *dash;
124
125                 a = strdupa(UNIT(s)->id);
126                 dash = strrchr(a, '-');
127                 if (dash)
128                         strcpy(dash, ".slice");
129                 else
130                         a = (char*) SPECIAL_ROOT_SLICE;
131
132                 if (!unit_has_name(UNIT_DEREF(UNIT(s)->slice), a)) {
133                         log_error_unit(UNIT(s)->id,
134                                        "%s located outside its parent slice. Refusing.", UNIT(s)->id);
135                         return -EINVAL;
136                 }
137         }
138
139         return 0;
140 }
141
142 static int slice_load(Unit *u) {
143         Slice *s = SLICE(u);
144         int r;
145
146         assert(s);
147
148         r = unit_load_fragment_and_dropin_optional(u);
149         if (r < 0)
150                 return r;
151
152         /* This is a new unit? Then let's add in some extras */
153         if (u->load_state == UNIT_LOADED) {
154
155                 r = slice_add_parent_slice(s);
156                 if (r < 0)
157                         return r;
158
159                 if (u->default_dependencies) {
160                         r = slice_add_default_dependencies(s);
161                         if (r < 0)
162                                 return r;
163                 }
164         }
165
166         return slice_verify(s);
167 }
168
169 static int slice_coldplug(Unit *u) {
170         Slice *t = SLICE(u);
171
172         assert(t);
173         assert(t->state == SLICE_DEAD);
174
175         if (t->deserialized_state != t->state)
176                 slice_set_state(t, t->deserialized_state);
177
178         return 0;
179 }
180
181 static void slice_dump(Unit *u, FILE *f, const char *prefix) {
182         Slice *t = SLICE(u);
183
184         assert(t);
185         assert(f);
186
187         fprintf(f,
188                 "%sSlice State: %s\n",
189                 prefix, slice_state_to_string(t->state));
190
191         cgroup_context_dump(&t->cgroup_context, f, prefix);
192 }
193
194 static int slice_start(Unit *u) {
195         Slice *t = SLICE(u);
196
197         assert(t);
198         assert(t->state == SLICE_DEAD);
199
200         unit_realize_cgroup(u);
201
202         slice_set_state(t, SLICE_ACTIVE);
203         return 0;
204 }
205
206 static int slice_stop(Unit *u) {
207         Slice *t = SLICE(u);
208
209         assert(t);
210         assert(t->state == SLICE_ACTIVE);
211
212         /* We do not need to destroy the cgroup explicitly,
213          * unit_notify() will do that for us anyway. */
214
215         slice_set_state(t, SLICE_DEAD);
216         return 0;
217 }
218
219 static int slice_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
220         return unit_kill_common(u, who, signo, -1, -1, error);
221 }
222
223 static int slice_serialize(Unit *u, FILE *f, FDSet *fds) {
224         Slice *s = SLICE(u);
225
226         assert(s);
227         assert(f);
228         assert(fds);
229
230         unit_serialize_item(u, f, "state", slice_state_to_string(s->state));
231         return 0;
232 }
233
234 static int slice_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
235         Slice *s = SLICE(u);
236
237         assert(u);
238         assert(key);
239         assert(value);
240         assert(fds);
241
242         if (streq(key, "state")) {
243                 SliceState state;
244
245                 state = slice_state_from_string(value);
246                 if (state < 0)
247                         log_debug("Failed to parse state value %s", value);
248                 else
249                         s->deserialized_state = state;
250
251         } else
252                 log_debug("Unknown serialization key '%s'", key);
253
254         return 0;
255 }
256
257 _pure_ static UnitActiveState slice_active_state(Unit *u) {
258         assert(u);
259
260         return state_translation_table[SLICE(u)->state];
261 }
262
263 _pure_ static const char *slice_sub_state_to_string(Unit *u) {
264         assert(u);
265
266         return slice_state_to_string(SLICE(u)->state);
267 }
268
269 static const char* const slice_state_table[_SLICE_STATE_MAX] = {
270         [SLICE_DEAD] = "dead",
271         [SLICE_ACTIVE] = "active"
272 };
273
274 DEFINE_STRING_TABLE_LOOKUP(slice_state, SliceState);
275
276 const UnitVTable slice_vtable = {
277         .object_size = sizeof(Slice),
278         .cgroup_context_offset = offsetof(Slice, cgroup_context),
279
280         .sections =
281                 "Unit\0"
282                 "Slice\0"
283                 "Install\0",
284         .private_section = "Slice",
285
286         .no_alias = true,
287         .no_instances = true,
288
289         .init = slice_init,
290         .load = slice_load,
291         .done = slice_done,
292
293         .coldplug = slice_coldplug,
294
295         .dump = slice_dump,
296
297         .start = slice_start,
298         .stop = slice_stop,
299
300         .kill = slice_kill,
301
302         .serialize = slice_serialize,
303         .deserialize_item = slice_deserialize_item,
304
305         .active_state = slice_active_state,
306         .sub_state_to_string = slice_sub_state_to_string,
307
308         .bus_interface = "org.freedesktop.systemd1.Slice",
309         .bus_vtable = bus_slice_vtable,
310         .bus_set_property = bus_slice_set_property,
311         .bus_commit_properties = bus_slice_commit_properties,
312
313         .status_message_formats = {
314                 .finished_start_job = {
315                         [JOB_DONE]       = "Created slice %s.",
316                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
317                 },
318                 .finished_stop_job = {
319                         [JOB_DONE]       = "Removed slice %s.",
320                 },
321         },
322 };