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(Unit *u) {
 134         Slice *s = SLICE(u);
 135         int r;
 136
 137         assert(s);
 138
 139         r = unit_load_fragment_and_dropin_optional(u);
 140         if (r < 0)
 141                 return r;
 142
 143         /* This is a new unit? Then let's add in some extras */
 144         if (u->load_state == UNIT_LOADED) {
 145
 146                 r = unit_patch_contexts(u);
 147                 if (r < 0)
 148                         return r;
 149
 150                 r = slice_add_parent_slice(s);
 151                 if (r < 0)
 152                         return r;
 153
 154                 r = slice_add_default_dependencies(s);
 155                 if (r < 0)
 156                         return r;
 157         }
 158
 159         return slice_verify(s);
 160 }
 161
 162 static int slice_coldplug(Unit *u) {
 163         Slice *t = SLICE(u);
 164
 165         assert(t);
 166         assert(t->state == SLICE_DEAD);
 167
 168         if (t->deserialized_state != t->state)
 169                 slice_set_state(t, t->deserialized_state);
 170
 171         return 0;
 172 }
 173
 174 static void slice_dump(Unit *u, FILE *f, const char *prefix) {
 175         Slice *t = SLICE(u);
 176
 177         assert(t);
 178         assert(f);
 179
 180         fprintf(f,
 181                 "%sSlice State: %s\n",
 182                 prefix, slice_state_to_string(t->state));
 183
 184         cgroup_context_dump(&t->cgroup_context, f, prefix);
 185 }
 186
 187 static int slice_start(Unit *u) {
 188         Slice *t = SLICE(u);
 189
 190         assert(t);
 191         assert(t->state == SLICE_DEAD);
 192
 193         (void) unit_realize_cgroup(u);
 194         (void) unit_reset_cpu_usage(u);
 195
 196         slice_set_state(t, SLICE_ACTIVE);
 197         return 1;
 198 }
 199
 200 static int slice_stop(Unit *u) {
 201         Slice *t = SLICE(u);
 202
 203         assert(t);
 204         assert(t->state == SLICE_ACTIVE);
 205
 206         /* We do not need to destroy the cgroup explicitly,
 207          * unit_notify() will do that for us anyway. */
 208
 209         slice_set_state(t, SLICE_DEAD);
 210         return 1;
 211 }
 212
 213 static int slice_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 214         return unit_kill_common(u, who, signo, -1, -1, error);
 215 }
 216
 217 static int slice_serialize(Unit *u, FILE *f, FDSet *fds) {
 218         Slice *s = SLICE(u);
 219
 220         assert(s);
 221         assert(f);
 222         assert(fds);
 223
 224         unit_serialize_item(u, f, "state", slice_state_to_string(s->state));
 225         return 0;
 226 }
 227
 228 static int slice_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 229         Slice *s = SLICE(u);
 230
 231         assert(u);
 232         assert(key);
 233         assert(value);
 234         assert(fds);
 235
 236         if (streq(key, "state")) {
 237                 SliceState state;
 238
 239                 state = slice_state_from_string(value);
 240                 if (state < 0)
 241                         log_debug("Failed to parse state value %s", value);
 242                 else
 243                         s->deserialized_state = state;
 244
 245         } else
 246                 log_debug("Unknown serialization key '%s'", key);
 247
 248         return 0;
 249 }
 250
 251 _pure_ static UnitActiveState slice_active_state(Unit *u) {
 252         assert(u);
 253
 254         return state_translation_table[SLICE(u)->state];
 255 }
 256
 257 _pure_ static const char *slice_sub_state_to_string(Unit *u) {
 258         assert(u);
 259
 260         return slice_state_to_string(SLICE(u)->state);
 261 }
 262
 263 static void slice_enumerate(Manager *m) {
 264         Unit *u;
 265         int r;
 266
 267         assert(m);
 268
 269         u = manager_get_unit(m, SPECIAL_ROOT_SLICE);
 270         if (!u) {
 271                 u = unit_new(m, sizeof(Slice));
 272                 if (!u)  {
 273                         log_oom();
 274                         return;
 275                 }
 276
 277                 r = unit_add_name(u, SPECIAL_ROOT_SLICE);
 278                 if (r < 0) {
 279                         unit_free(u);
 280                         log_error_errno(r, "Failed to add -.slice name");
 281                         return;
 282                 }
 283         }
 284
 285         u->default_dependencies = false;
 286         u->no_gc = true;
 287         u->ignore_on_isolate = true;
 288         u->refuse_manual_start = true;
 289         u->refuse_manual_stop = true;
 290         SLICE(u)->deserialized_state = SLICE_ACTIVE;
 291
 292         if (!u->description)
 293                 u->description = strdup("Root Slice");
 294         if (!u->documentation)
 295                 (void) strv_extend(&u->documentation, "man:systemd.special(7)");
 296
 297         unit_add_to_load_queue(u);
 298         unit_add_to_dbus_queue(u);
 299 }
 300
 301 const UnitVTable slice_vtable = {
 302         .object_size = sizeof(Slice),
 303         .cgroup_context_offset = offsetof(Slice, cgroup_context),
 304
 305         .sections =
 306                 "Unit\0"
 307                 "Slice\0"
 308                 "Install\0",
 309         .private_section = "Slice",
 310
 311         .no_alias = true,
 312         .no_instances = true,
 313         .can_transient = true,
 314
 315         .init = slice_init,
 316         .load = slice_load,
 317
 318         .coldplug = slice_coldplug,
 319
 320         .dump = slice_dump,
 321
 322         .start = slice_start,
 323         .stop = slice_stop,
 324
 325         .kill = slice_kill,
 326
 327         .serialize = slice_serialize,
 328         .deserialize_item = slice_deserialize_item,
 329
 330         .active_state = slice_active_state,
 331         .sub_state_to_string = slice_sub_state_to_string,
 332
 333         .bus_vtable = bus_slice_vtable,
 334         .bus_set_property = bus_slice_set_property,
 335         .bus_commit_properties = bus_slice_commit_properties,
 336
 337         .enumerate = slice_enumerate,
 338
 339         .status_message_formats = {
 340                 .finished_start_job = {
 341                         [JOB_DONE]       = "Created slice %s.",
 342                 },
 343                 .finished_stop_job = {
 344                         [JOB_DONE]       = "Removed slice %s.",
 345                 },
 346         },
 347 };