From d8e5a9338278d6602a0c552f01f298771a384798 Mon Sep 17 00:00:00 2001
From: Alan Jenkins <alan.christopher.jenkins@gmail.com>
Date: Sun, 4 Feb 2018 20:46:27 +0000
Subject: [PATCH] slice: system.slice should be perpetual like -.mount

`-.mount` is placed in `system.slice`, and hence depends on it.
`-.mount` is always active and can never be stopped.  Therefore the same
should be true of `system.slice`.

Synthesize it as perpetual (unless systemd is running as a user manager).
Notice we also drop `Before=slices.target` as unnecessary.

AFAICS the justification for `perpetual` is to provide extra protection
against unintentionally stopping every single service.  So adding
system.slice to the perpetual units is perfectly consistent.

I don't expect this will (or can) fix any other problem.  And the
`perpetual` protection probably isn't formal enough to spend much time
thinking about.  I've just noticed this a couple of times, as something
that looks strange.

Might be a bit surprising that we have user.slice on-disk but not
system.slice, but I think it's ok. `systemctl status system.slice` will
still point you towards `man systemd.special`.  The only detail is that the
system slice disables `DefaultDependencies`.  If you're worrying about how
system shutdown works when you read `man systemd.slice`, I think it is not
too hard to guess that system.slice might do this:

> Only slice units involved with early boot
> or late system shutdown should disable this option

(Docs are great. I really appreciate the systemd ones).
---
 src/core/slice.c   | 44 ++++++++++++++++++++++++++++++++++++++++----
 units/meson.build  |  1 -
 units/system.slice | 14 --------------
 3 files changed, 40 insertions(+), 19 deletions(-)
 delete mode 100644 units/system.slice

diff --git a/src/core/slice.c b/src/core/slice.c
index 0bbc0aedc5..ef2177279a 100644
--- a/src/core/slice.c
+++ b/src/core/slice.c
@@ -146,6 +146,29 @@ static int slice_load_root_slice(Unit *u) {
         return 1;
 }
 
+static int slice_load_system_slice(Unit *u) {
+        assert(u);
+
+        if (!MANAGER_IS_SYSTEM(u->manager))
+                return 0;
+        if (!unit_has_name(u, SPECIAL_SYSTEM_SLICE))
+                return 0;
+
+        u->perpetual = true;
+
+        /* The system slice is a bit special. For example it is always running and cannot be terminated. Because of its
+         * special semantics we synthesize it here, instead of relying on the unit file on disk. */
+
+        u->default_dependencies = false;
+
+        if (!u->description)
+                u->description = strdup("System Slice");
+        if (!u->documentation)
+                u->documentation = strv_new("man:systemd.special(7)", NULL);
+
+        return 1;
+}
+
 static int slice_load(Unit *u) {
         Slice *s = SLICE(u);
         int r;
@@ -156,6 +179,10 @@ static int slice_load(Unit *u) {
         r = slice_load_root_slice(u);
         if (r < 0)
                 return r;
+        r = slice_load_system_slice(u);
+        if (r < 0)
+                return r;
+
         r = unit_load_fragment_and_dropin_optional(u);
         if (r < 0)
                 return r;
@@ -286,17 +313,17 @@ _pure_ static const char *slice_sub_state_to_string(Unit *u) {
         return slice_state_to_string(SLICE(u)->state);
 }
 
-static void slice_enumerate(Manager *m) {
+static void slice_enumerate_perpetual(Manager *m, const char *name) {
         Unit *u;
         int r;
 
         assert(m);
 
-        u = manager_get_unit(m, SPECIAL_ROOT_SLICE);
+        u = manager_get_unit(m, name);
         if (!u) {
-                r = unit_new_for_name(m, sizeof(Slice), SPECIAL_ROOT_SLICE, &u);
+                r = unit_new_for_name(m, sizeof(Slice), name, &u);
                 if (r < 0) {
-                        log_error_errno(r, "Failed to allocate the special " SPECIAL_ROOT_SLICE " unit: %m");
+                        log_error_errno(r, "Failed to allocate the special %s unit: %m", name);
                         return;
                 }
         }
@@ -308,6 +335,15 @@ static void slice_enumerate(Manager *m) {
         unit_add_to_dbus_queue(u);
 }
 
+static void slice_enumerate(Manager *m) {
+        assert(m);
+
+        slice_enumerate_perpetual(m, SPECIAL_ROOT_SLICE);
+
+        if (MANAGER_IS_SYSTEM(m))
+                slice_enumerate_perpetual(m, SPECIAL_SYSTEM_SLICE);
+}
+
 const UnitVTable slice_vtable = {
         .object_size = sizeof(Slice),
         .cgroup_context_offset = offsetof(Slice, cgroup_context),
diff --git a/units/meson.build b/units/meson.build
index 814ee7885b..7f40464190 100644
--- a/units/meson.build
+++ b/units/meson.build
@@ -91,7 +91,6 @@ units = [
         ['sysinit.target',                      ''],
         ['syslog.socket',                       ''],
         ['system-update.target',                ''],
-        ['system.slice',                        ''],
         ['systemd-ask-password-console.path',   '',
          'sysinit.target.wants/'],
         ['systemd-ask-password-wall.path',      '',
diff --git a/units/system.slice b/units/system.slice
deleted file mode 100644
index a4d5edfae8..0000000000
--- a/units/system.slice
+++ /dev/null
@@ -1,14 +0,0 @@
-#  SPDX-License-Identifier: LGPL-2.1+
-#
-#  This file is part of systemd.
-#
-#  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.
-
-[Unit]
-Description=System Slice
-Documentation=man:systemd.special(7)
-DefaultDependencies=no
-Before=slices.target