src/core/slice.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2013 Lennart Poettering
   5
   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.
  10
  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.
  15
  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/>.
  18 ***/
  19
  20 #include <errno.h>
  21
  22 #include "alloc-util.h"
  23 #include "dbus-slice.h"
  24 #include "log.h"
  25 #include "slice.h"
  26 #include "special.h"
  27 #include "string-util.h"
  28 #include "strv.h"
  29 #include "unit-name.h"
  30 #include "unit.h"
  31
  32 static const UnitActiveState state_translation_table[_SLICE_STATE_MAX] = {
  33         [SLICE_DEAD] = UNIT_INACTIVE,
  34         [SLICE_ACTIVE] = UNIT_ACTIVE
  35 };
  36
  37 static void slice_init(Unit *u) {
  38         assert(u);
  39         assert(u->load_state == UNIT_STUB);
  40
  41         u->ignore_on_isolate = true;
  42 }
  43
  44 static void slice_set_state(Slice *t, SliceState state) {
  45         SliceState old_state;
  46         assert(t);
  47
  48         old_state = t->state;
  49         t->state = state;
  50
  51         if (state != old_state)
  52                 log_debug("%s changed %s -> %s",
  53                           UNIT(t)->id,
  54                           slice_state_to_string(old_state),
  55                           slice_state_to_string(state));
  56
  57         unit_notify(UNIT(t), state_translation_table[old_state], state_translation_table[state], true);
  58 }
  59
  60 static int slice_add_parent_slice(Slice *s) {
  61         char *a, *dash;
  62         Unit *parent;
  63         int r;
  64
  65         assert(s);
  66
  67         if (UNIT_ISSET(UNIT(s)->slice))
  68                 return 0;
  69
  70         if (unit_has_name(UNIT(s), SPECIAL_ROOT_SLICE))
  71                 return 0;
  72
  73         a = strdupa(UNIT(s)->id);
  74         dash = strrchr(a, '-');
  75         if (dash)
  76                 strcpy(dash, ".slice");
  77         else
  78                 a = (char*) SPECIAL_ROOT_SLICE;
  79
  80         r = manager_load_unit(UNIT(s)->manager, a, NULL, NULL, &parent);
  81         if (r < 0)
  82                 return r;
  83
  84         unit_ref_set(&UNIT(s)->slice, parent);
  85         return 0;
  86 }
  87
  88 static int slice_add_default_dependencies(Slice *s) {
  89         int r;
  90
  91         assert(s);
  92
  93         if (!UNIT(s)->default_dependencies)
  94                 return 0;
  95
  96         /* Make sure slices are unloaded on shutdown */
  97         r = unit_add_two_dependencies_by_name(
  98                         UNIT(s),
  99                         UNIT_BEFORE, UNIT_CONFLICTS,
 100                         SPECIAL_SHUTDOWN_TARGET, NULL, true);
 101         if (r < 0)
 102                 return r;
 103
 104         return 0;
 105 }
 106
 107 static int slice_verify(Slice *s) {
 108         _cleanup_free_ char *parent = NULL;
 109         int r;
 110
 111         assert(s);
 112
 113         if (UNIT(s)->load_state != UNIT_LOADED)
 114                 return 0;
 115
 116         if (!slice_name_is_valid(UNIT(s)->id)) {
 117                 log_unit_error(UNIT(s), "Slice name %s is not valid. Refusing.", UNIT(s)->id);
 118                 return -EINVAL;
 119         }
 120
 121         r = slice_build_parent_slice(UNIT(s)->id, &parent);
 122         if (r < 0)
 123                 return log_unit_error_errno(UNIT(s), r, "Failed to determine parent slice: %m");
 124
 125         if (parent ? !unit_has_name(UNIT_DEREF(UNIT(s)->slice), parent) : UNIT_ISSET(UNIT(s)->slice)) {
 126                 log_unit_error(UNIT(s), "Located outside of parent slice. Refusing.");
 127                 return -EINVAL;
 128         }
 129
 130         return 0;
 131 }
 132
 133 static int slice_load_root_slice(Unit *u) {
 134         assert(u);
 135
 136         if (!unit_has_name(u, SPECIAL_ROOT_SLICE))
 137                 return 0;
 138
 139         u->perpetual = true;
 140
 141         /* The root slice is a bit special. For example it is always running and cannot be terminated. Because of its
 142          * special semantics we synthesize it here, instead of relying on the unit file on disk. */
 143
 144         u->default_dependencies = false;
 145         u->ignore_on_isolate = true;
 146
 147         if (!u->description)
 148                 u->description = strdup("Root Slice");
 149         if (!u->documentation)
 150                 u->documentation = strv_new("man:systemd.special(7)", NULL);
 151
 152         return 1;
 153 }
 154
 155 static int slice_load(Unit *u) {
 156         Slice *s = SLICE(u);
 157         int r;
 158
 159         assert(s);
 160         assert(u->load_state == UNIT_STUB);
 161
 162         r = slice_load_root_slice(u);
 163         if (r < 0)
 164                 return r;
 165         r = unit_load_fragment_and_dropin_optional(u);
 166         if (r < 0)
 167                 return r;
 168
 169         /* This is a new unit? Then let's add in some extras */
 170         if (u->load_state == UNIT_LOADED) {
 171
 172                 r = unit_patch_contexts(u);
 173                 if (r < 0)
 174                         return r;
 175
 176                 r = slice_add_parent_slice(s);
 177                 if (r < 0)
 178                         return r;
 179
 180                 r = slice_add_default_dependencies(s);
 181                 if (r < 0)
 182                         return r;
 183         }
 184
 185         return slice_verify(s);
 186 }
 187
 188 static int slice_coldplug(Unit *u) {
 189         Slice *t = SLICE(u);
 190
 191         assert(t);
 192         assert(t->state == SLICE_DEAD);
 193
 194         if (t->deserialized_state != t->state)
 195                 slice_set_state(t, t->deserialized_state);
 196
 197         return 0;
 198 }
 199
 200 static void slice_dump(Unit *u, FILE *f, const char *prefix) {
 201         Slice *t = SLICE(u);
 202
 203         assert(t);
 204         assert(f);
 205
 206         fprintf(f,
 207                 "%sSlice State: %s\n",
 208                 prefix, slice_state_to_string(t->state));
 209
 210         cgroup_context_dump(&t->cgroup_context, f, prefix);
 211 }
 212
 213 static int slice_start(Unit *u) {
 214         Slice *t = SLICE(u);
 215         int r;
 216
 217         assert(t);
 218         assert(t->state == SLICE_DEAD);
 219
 220         r = unit_acquire_invocation_id(u);
 221         if (r < 0)
 222                 return r;
 223
 224         (void) unit_realize_cgroup(u);
 225         (void) unit_reset_cpu_accounting(u);
 226         (void) unit_reset_ip_accounting(u);
 227
 228         slice_set_state(t, SLICE_ACTIVE);
 229         return 1;
 230 }
 231
 232 static int slice_stop(Unit *u) {
 233         Slice *t = SLICE(u);
 234
 235         assert(t);
 236         assert(t->state == SLICE_ACTIVE);
 237
 238         /* We do not need to destroy the cgroup explicitly,
 239          * unit_notify() will do that for us anyway. */
 240
 241         slice_set_state(t, SLICE_DEAD);
 242         return 1;
 243 }
 244
 245 static int slice_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 246         return unit_kill_common(u, who, signo, -1, -1, error);
 247 }
 248
 249 static int slice_serialize(Unit *u, FILE *f, FDSet *fds) {
 250         Slice *s = SLICE(u);
 251
 252         assert(s);
 253         assert(f);
 254         assert(fds);
 255
 256         unit_serialize_item(u, f, "state", slice_state_to_string(s->state));
 257         return 0;
 258 }
 259
 260 static int slice_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 261         Slice *s = SLICE(u);
 262
 263         assert(u);
 264         assert(key);
 265         assert(value);
 266         assert(fds);
 267
 268         if (streq(key, "state")) {
 269                 SliceState state;
 270
 271                 state = slice_state_from_string(value);
 272                 if (state < 0)
 273                         log_debug("Failed to parse state value %s", value);
 274                 else
 275                         s->deserialized_state = state;
 276
 277         } else
 278                 log_debug("Unknown serialization key '%s'", key);
 279
 280         return 0;
 281 }
 282
 283 _pure_ static UnitActiveState slice_active_state(Unit *u) {
 284         assert(u);
 285
 286         return state_translation_table[SLICE(u)->state];
 287 }
 288
 289 _pure_ static const char *slice_sub_state_to_string(Unit *u) {
 290         assert(u);
 291
 292         return slice_state_to_string(SLICE(u)->state);
 293 }
 294
 295 static void slice_enumerate(Manager *m) {
 296         Unit *u;
 297         int r;
 298
 299         assert(m);
 300
 301         u = manager_get_unit(m, SPECIAL_ROOT_SLICE);
 302         if (!u) {
 303                 r = unit_new_for_name(m, sizeof(Slice), SPECIAL_ROOT_SLICE, &u);
 304                 if (r < 0) {
 305                         log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_SLICE " unit: %m");
 306                         return;
 307                 }
 308         }
 309
 310         u->perpetual = true;
 311         SLICE(u)->deserialized_state = SLICE_ACTIVE;
 312
 313         unit_add_to_load_queue(u);
 314         unit_add_to_dbus_queue(u);
 315 }
 316
 317 const UnitVTable slice_vtable = {
 318         .object_size = sizeof(Slice),
 319         .cgroup_context_offset = offsetof(Slice, cgroup_context),
 320
 321         .sections =
 322                 "Unit\0"
 323                 "Slice\0"
 324                 "Install\0",
 325         .private_section = "Slice",
 326
 327         .can_transient = true,
 328
 329         .init = slice_init,
 330         .load = slice_load,
 331
 332         .coldplug = slice_coldplug,
 333
 334         .dump = slice_dump,
 335
 336         .start = slice_start,
 337         .stop = slice_stop,
 338
 339         .kill = slice_kill,
 340
 341         .serialize = slice_serialize,
 342         .deserialize_item = slice_deserialize_item,
 343
 344         .active_state = slice_active_state,
 345         .sub_state_to_string = slice_sub_state_to_string,
 346
 347         .bus_vtable = bus_slice_vtable,
 348         .bus_set_property = bus_slice_set_property,
 349         .bus_commit_properties = bus_slice_commit_properties,
 350
 351         .enumerate = slice_enumerate,
 352
 353         .status_message_formats = {
 354                 .finished_start_job = {
 355                         [JOB_DONE]       = "Created slice %s.",
 356                 },
 357                 .finished_stop_job = {
 358                         [JOB_DONE]       = "Removed slice %s.",
 359                 },
 360         },
 361 };