core: add startup resource control option

Similar to CPUShares= and BlockIOWeight= respectively. However only
assign the specified weight during startup. Each control group
attribute is re-assigned as weight by CPUShares=weight and
BlockIOWeight=weight after startup.  If not CPUShares= or
BlockIOWeight= be specified, then the attribute is re-assigned to each
default attribute value. (default cpu.shares=1024, blkio.weight=1000)
If only CPUShares=weight or BlockIOWeight=weight be specified, then
that implies StartupCPUShares=weight and StartupBlockIOWeight=weight.

man/systemd.resource-control.xml

@@ -170,6 +170,18 @@ along with systemd; If not, see <http://www.gnu.org/licenses/>.
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><varname>StartupCPUShares=<replaceable>weight</replaceable></varname></term>
+
+        <listitem>
+          <para>Similar to <varname>CPUShares=</varname>. However,
+          only be assigned on startup state. After finishing startup, will be
+          re-assigned by <varname>CPUShares=</varname>. If
+          <varname>CPUShares=</varname> is not specified, then it will be
+          assigned to default(1024).</para>
+        </listitem>
+      </varlistentry>
+
       <varlistentry>
         <term><varname>MemoryAccounting=</varname></term>
 
@@ -240,6 +252,18 @@ along with systemd; If not, see <http://www.gnu.org/licenses/>.
         </listitem>
       </varlistentry>
 
+      <varlistentry>
+        <term><varname>StartupBlockIOWeight=<replaceable>weight</replaceable></varname></term>
+
+        <listitem>
+          <para>Similar to <varname>BlockIOWeight=</varname>. However,
+          only be assigned on startup state. After finishing startup, will be
+          re-assigned by <varname>BlockIOWeight=</varname>. If
+          <varname>BlockIOWeight=</varname> is not specified, then it will be
+          assigned to default(1000).</para>
+        </listitem>
+      </varlistentry>
+
       <varlistentry>
         <term><varname>BlockIODeviceWeight=<replaceable>device</replaceable> <replaceable>weight</replaceable></varname></term>
 

src/core/cgroup.c

@@ -34,8 +34,12 @@ void cgroup_context_init(CGroupContext *c) {
          * structure is preinitialized to 0 */
 
         c->cpu_shares = 1024;
+        c->startup_cpu_shares = 1024;
+        c->startup_cpu_shares_set = false;
         c->memory_limit = (uint64_t) -1;
         c->blockio_weight = 1000;
+        c->startup_blockio_weight = 1000;
+        c->startup_blockio_weight_set = false;
 
         c->cpu_quota_per_sec_usec = (usec_t) -1;
         c->cpu_quota_usec = (usec_t) -1;
@@ -124,20 +128,24 @@ void cgroup_context_dump(CGroupContext *c, FILE* f, const char *prefix) {
                 "%sBlockIOAccounting=%s\n"
                 "%sMemoryAccounting=%s\n"
                 "%sCPUShares=%lu\n"
+                "%sStartupCPUShares=%lu\n"
                 "%sCPUQuota=%s\n"
                 "%sCPUQuotaPerSecSec=%s\n"
                 "%sCPUQuotaPeriodSec=%s\n"
                 "%sBlockIOWeight=%lu\n"
+                "%sStartupBlockIOWeight=%lu\n"
                 "%sMemoryLimit=%" PRIu64 "\n"
                 "%sDevicePolicy=%s\n",
                 prefix, yes_no(c->cpu_accounting),
                 prefix, yes_no(c->blockio_accounting),
                 prefix, yes_no(c->memory_accounting),
                 prefix, c->cpu_shares,
+                prefix, c->startup_cpu_shares,
                 prefix, strna(format_timespan(u, sizeof(u), cgroup_context_get_cpu_quota_usec(c), 1)),
                 prefix, strna(format_timespan(t, sizeof(t), cgroup_context_get_cpu_quota_per_sec_usec(c), 1)),
                 prefix, strna(format_timespan(s, sizeof(s), c->cpu_quota_period_usec, 1)),
                 prefix, c->blockio_weight,
+                prefix, c->startup_blockio_weight,
                 prefix, c->memory_limit,
                 prefix, cgroup_device_policy_to_string(c->device_policy));
 
@@ -306,7 +314,7 @@ fail:
         return -errno;
 }
 
-void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const char *path) {
+void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mask, const char *path) {
         bool is_root;
         int r;
 
@@ -324,7 +332,9 @@ void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const cha
                 char buf[MAX(DECIMAL_STR_MAX(unsigned long), DECIMAL_STR_MAX(usec_t)) + 1];
                 usec_t q;
 
-                sprintf(buf, "%lu\n", c->cpu_shares);
+                sprintf(buf, "%lu\n", manager_state(m) == MANAGER_STARTING
+                        ? c->startup_cpu_shares
+                        : c->cpu_shares);
                 r = cg_set_attribute("cpu", path, "cpu.shares", buf);
                 if (r < 0)
                         log_warning("Failed to set cpu.shares on %s: %s", path, strerror(-r));
@@ -352,7 +362,9 @@ void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const cha
                 CGroupBlockIODeviceBandwidth *b;
 
                 if (!is_root) {
-                        sprintf(buf, "%lu\n", c->blockio_weight);
+                        sprintf(buf, "%lu\n", manager_state(m) == MANAGER_STARTING
+                                ? c->startup_blockio_weight
+                                : c->blockio_weight);
                         r = cg_set_attribute("blkio", path, "blkio.weight", buf);
                         if (r < 0)
                                 log_warning("Failed to set blkio.weight on %s: %s", path, strerror(-r));
@@ -462,22 +474,30 @@ void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const cha
         }
 }
 
-CGroupControllerMask cgroup_context_get_mask(CGroupContext *c) {
+CGroupControllerMask cgroup_context_get_mask(Manager *m, CGroupContext *c) {
         CGroupControllerMask mask = 0;
 
         /* Figure out which controllers we need */
 
         if (c->cpu_accounting ||
-            c->cpu_shares != 1024 ||
+            (manager_state(m) == MANAGER_STARTING ? c->startup_cpu_shares : c->cpu_shares) != 1024 ||
+            (manager_state(m) != MANAGER_STARTING && c->startup_cpu_shares_set && c->startup_cpu_shares != c->cpu_shares) ||
             c->cpu_quota_usec != (usec_t) -1 ||
-            c->cpu_quota_per_sec_usec != (usec_t) -1)
+            c->cpu_quota_per_sec_usec != (usec_t) -1) {
                 mask |= CGROUP_CPUACCT | CGROUP_CPU;
+                if (manager_state(m) != MANAGER_STARTING)
+                        c->startup_cpu_shares_set = false;
+        }
 
         if (c->blockio_accounting ||
-            c->blockio_weight != 1000 ||
+            (manager_state(m) == MANAGER_STARTING ? c->startup_blockio_weight : c->blockio_weight) != 1000 ||
+            (manager_state(m) != MANAGER_STARTING && c->startup_blockio_weight_set && c->startup_blockio_weight != c->blockio_weight) ||
             c->blockio_device_weights ||
-            c->blockio_device_bandwidths)
+            c->blockio_device_bandwidths) {
                 mask |= CGROUP_BLKIO;
+                if (manager_state(m) != MANAGER_STARTING)
+                        c->startup_blockio_weight_set = false;
+        }
 
         if (c->memory_accounting ||
             c->memory_limit != (uint64_t) -1)
@@ -496,7 +516,7 @@ CGroupControllerMask unit_get_cgroup_mask(Unit *u) {
         if (!c)
                 return 0;
 
-        return cgroup_context_get_mask(c);
+        return cgroup_context_get_mask(u->manager, c);
 }
 
 CGroupControllerMask unit_get_members_mask(Unit *u) {
@@ -700,7 +720,7 @@ static int unit_realize_cgroup_now(Unit *u) {
                 return r;
 
         /* Finally, apply the necessary attributes. */
-        cgroup_context_apply(unit_get_cgroup_context(u), mask, u->cgroup_path);
+        cgroup_context_apply(u->manager, unit_get_cgroup_context(u), mask, u->cgroup_path);
 
         return 0;
 }

src/core/cgroup.h

@@ -71,11 +71,15 @@ struct CGroupContext {
         bool memory_accounting;
 
         unsigned long cpu_shares;
+        unsigned long startup_cpu_shares;
+        bool startup_cpu_shares_set:1;
         usec_t cpu_quota_per_sec_usec;
         usec_t cpu_quota_usec;
         usec_t cpu_quota_period_usec;
 
         unsigned long blockio_weight;
+        unsigned long startup_blockio_weight;
+        bool startup_blockio_weight_set:1;
         LIST_HEAD(CGroupBlockIODeviceWeight, blockio_device_weights);
         LIST_HEAD(CGroupBlockIODeviceBandwidth, blockio_device_bandwidths);
 
@@ -92,9 +96,9 @@ struct CGroupContext {
 void cgroup_context_init(CGroupContext *c);
 void cgroup_context_done(CGroupContext *c);
 void cgroup_context_dump(CGroupContext *c, FILE* f, const char *prefix);
-void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const char *path);
+void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mask, const char *path);
 
-CGroupControllerMask cgroup_context_get_mask(CGroupContext *c);
+CGroupControllerMask cgroup_context_get_mask(Manager *m, CGroupContext *c);
 
 void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a);
 void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBlockIODeviceWeight *w);

src/core/dbus-cgroup.c

@@ -173,11 +173,13 @@ const sd_bus_vtable bus_cgroup_vtable[] = {
         SD_BUS_VTABLE_START(0),
         SD_BUS_PROPERTY("CPUAccounting", "b", bus_property_get_bool, offsetof(CGroupContext, cpu_accounting), 0),
         SD_BUS_PROPERTY("CPUShares", "t", bus_property_get_ulong, offsetof(CGroupContext, cpu_shares), 0),
+        SD_BUS_PROPERTY("StartupCPUShares", "t", bus_property_get_ulong, offsetof(CGroupContext, startup_cpu_shares), 0),
         SD_BUS_PROPERTY("CPUQuotaPerSecUSec", "t", property_get_cpu_quota_per_sec_usec, 0, 0),
         SD_BUS_PROPERTY("CPUQuotaUSec", "t", property_get_cpu_quota_usec, 0, 0),
         SD_BUS_PROPERTY("CPUQuotaPeriodUSec", "t", bus_property_get_usec, offsetof(CGroupContext, cpu_quota_period_usec), 0),
         SD_BUS_PROPERTY("BlockIOAccounting", "b", bus_property_get_bool, offsetof(CGroupContext, blockio_accounting), 0),
         SD_BUS_PROPERTY("BlockIOWeight", "t", bus_property_get_ulong, offsetof(CGroupContext, blockio_weight), 0),
+        SD_BUS_PROPERTY("StartupBlockIOWeight", "t", bus_property_get_ulong, offsetof(CGroupContext, startup_blockio_weight), 0),
         SD_BUS_PROPERTY("BlockIODeviceWeight", "a(st)", property_get_blockio_device_weight, 0, 0),
         SD_BUS_PROPERTY("BlockIOReadBandwidth", "a(st)", property_get_blockio_device_bandwidths, 0, 0),
         SD_BUS_PROPERTY("BlockIOWriteBandwidth", "a(st)", property_get_blockio_device_bandwidths, 0, 0),
@@ -238,6 +240,26 @@ int bus_cgroup_set_property(
 
                 return 1;
 
+        } else if (streq(name, "StartupCPUShares")) {
+                uint64_t u64;
+                unsigned long ul;
+
+                r = sd_bus_message_read(message, "t", &u64);
+                if (r < 0)
+                        return r;
+
+                ul = (unsigned long) u64;
+                if (ul <= 0 || (uint64_t) ul != u64)
+                        return sd_bus_error_set_errnof(error, EINVAL, "StartupCPUShares value out of range");
+
+                if (mode != UNIT_CHECK) {
+                        c->startup_cpu_shares = ul;
+                        c->startup_cpu_shares_set = true;
+                        unit_write_drop_in_private_format(u, mode, name, "StartupCPUShares=%lu", ul);
+                }
+
+                return 1;
+
         } else if (streq(name, "CPUQuotaPerSecUSec")) {
                 uint64_t u64;
 
@@ -330,6 +352,26 @@ int bus_cgroup_set_property(
 
                 return 1;
 
+        } else if (streq(name, "StartupBlockIOWeight")) {
+                uint64_t u64;
+                unsigned long ul;
+
+                r = sd_bus_message_read(message, "t", &u64);
+                if (r < 0)
+                        return r;
+
+                ul = (unsigned long) u64;
+                if (ul < 10 || ul > 1000)
+                        return sd_bus_error_set_errnof(error, EINVAL, "StartupBlockIOWeight value out of range");
+
+                if (mode != UNIT_CHECK) {
+                        c->startup_blockio_weight = ul;
+                        c->startup_blockio_weight_set = true;
+                        unit_write_drop_in_private_format(u, mode, name, "StartupBlockIOWeight=%lu", ul);
+                }
+
+                return 1;
+
         } else if (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth")) {
                 const char *path;
                 bool read = true;

src/core/load-fragment-gperf.gperf.m4

@@ -106,6 +106,7 @@ m4_define(`CGROUP_CONTEXT_CONFIG_ITEMS',
 `$1.Slice,                       config_parse_unit_slice,            0,                             0
 $1.CPUAccounting,                config_parse_bool,                  0,                             offsetof($1, cgroup_context.cpu_accounting)
 $1.CPUShares,                    config_parse_cpu_shares,            0,                             offsetof($1, cgroup_context)
+$1.StartupCPUShares,             config_parse_startup_cpu_shares,    0,                             offsetof($1, cgroup_context)
 $1.CPUQuota,                     config_parse_cpu_quota,             0,                             offsetof($1, cgroup_context)
 $1.CPUQuotaPeriodSec,            config_parse_sec,                   0,                             offsetof($1, cgroup_context.cpu_quota_period_usec)
 $1.MemoryAccounting,             config_parse_bool,                  0,                             offsetof($1, cgroup_context.memory_accounting)
@@ -114,6 +115,7 @@ $1.DeviceAllow,                  config_parse_device_allow,          0,
 $1.DevicePolicy,                 config_parse_device_policy,         0,                             offsetof($1, cgroup_context.device_policy)
 $1.BlockIOAccounting,            config_parse_bool,                  0,                             offsetof($1, cgroup_context.blockio_accounting)
 $1.BlockIOWeight,                config_parse_blockio_weight,        0,                             offsetof($1, cgroup_context)
+$1.StartupBlockIOWeight,         config_parse_startup_blockio_weight, 0,                            offsetof($1, cgroup_context)
 $1.BlockIODeviceWeight,          config_parse_blockio_device_weight, 0,                             offsetof($1, cgroup_context)
 $1.BlockIOReadBandwidth,         config_parse_blockio_bandwidth,     0,                             offsetof($1, cgroup_context)
 $1.BlockIOWriteBandwidth,        config_parse_blockio_bandwidth,     0,                             offsetof($1, cgroup_context)'

src/core/load-fragment.c

@@ -2451,6 +2451,47 @@ int config_parse_cpu_shares(
         }
 
         c->cpu_shares = lu;
+        if (!c->startup_cpu_shares_set)
+                c->startup_cpu_shares = lu;
+
+        return 0;
+}
+
+int config_parse_startup_cpu_shares(
+                const char *unit,
+                const char *filename,
+                unsigned line,
+                const char *section,
+                unsigned section_line,
+                const char *lvalue,
+                int ltype,
+                const char *rvalue,
+                void *data,
+                void *userdata) {
+
+        CGroupContext *c = data;
+        unsigned long lu;
+        int r;
+
+        assert(filename);
+        assert(lvalue);
+        assert(rvalue);
+
+        if (isempty(rvalue)) {
+                c->startup_cpu_shares = 1024;
+                return 0;
+        }
+
+        r = safe_atolu(rvalue, &lu);
+        if (r < 0 || lu <= 0) {
+                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
+                           "Startup CPU shares '%s' invalid. Ignoring.", rvalue);
+                return 0;
+        }
+
+        c->startup_cpu_shares = lu;
+        c->startup_cpu_shares_set = true;
+
         return 0;
 }
 
@@ -2628,6 +2669,46 @@ int config_parse_blockio_weight(
         }
 
         c->blockio_weight = lu;
+        if (!c->startup_blockio_weight_set)
+                c->startup_blockio_weight = lu;
+
+        return 0;
+}
+
+int config_parse_startup_blockio_weight(
+                const char *unit,
+                const char *filename,
+                unsigned line,
+                const char *section,
+                unsigned section_line,
+                const char *lvalue,
+                int ltype,
+                const char *rvalue,
+                void *data,
+                void *userdata) {
+
+        CGroupContext *c = data;
+        unsigned long lu;
+        int r;
+
+        assert(filename);
+        assert(lvalue);
+        assert(rvalue);
+
+        if (isempty(rvalue)) {
+                c->startup_blockio_weight = 1000;
+                return 0;
+        }
+
+        r = safe_atolu(rvalue, &lu);
+        if (r < 0 || lu < 10 || lu > 1000) {
+                log_syntax(unit, LOG_ERR, filename, line, EINVAL,
+                           "Startup Block IO weight '%s' invalid. Ignoring.", rvalue);
+                return 0;
+        }
+
+        c->startup_blockio_weight = lu;
+        c->startup_blockio_weight_set = true;
 
         return 0;
 }
@@ -3445,11 +3526,13 @@ void unit_dump_config_items(FILE *f) {
                 { config_parse_address_families,      "FAMILIES" },
 #endif
                 { config_parse_cpu_shares,            "SHARES" },
+                { config_parse_startup_cpu_shares,    "STARTUPSHARES" },
                 { config_parse_memory_limit,          "LIMIT" },
                 { config_parse_device_allow,          "DEVICE" },
                 { config_parse_device_policy,         "POLICY" },
                 { config_parse_blockio_bandwidth,     "BANDWIDTH" },
                 { config_parse_blockio_weight,        "WEIGHT" },
+                { config_parse_startup_blockio_weight, "STARTUPWEIGHT" },
                 { config_parse_blockio_device_weight, "DEVICEWEIGHT" },
                 { config_parse_long,                  "LONG" },
                 { config_parse_socket_service,        "SERVICE" },

src/core/load-fragment.h

@@ -80,10 +80,12 @@ int config_parse_syscall_errno(const char *unit, const char *filename, unsigned
 int config_parse_environ(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_unit_slice(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_cpu_shares(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
+int config_parse_startup_cpu_shares(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_memory_limit(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_device_policy(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_device_allow(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_blockio_weight(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
+int config_parse_startup_blockio_weight(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_blockio_device_weight(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_blockio_bandwidth(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
 int config_parse_job_mode(const char *unit, const char *filename, unsigned line, const char *section, unsigned section_line, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);

src/core/manager.c

@@ -456,6 +456,10 @@ int manager_new(SystemdRunningAs running_as, Manager **_m) {
         if (r < 0)
                 goto fail;
 
+        r = set_ensure_allocated(&m->startup_units, trivial_hash_func, trivial_compare_func);
+        if (r < 0)
+                goto fail;
+
         r = set_ensure_allocated(&m->failed_units, trivial_hash_func, trivial_compare_func);
         if (r < 0)
                 goto fail;
@@ -794,6 +798,7 @@ void manager_free(Manager *m) {
         hashmap_free(m->watch_pids2);
         hashmap_free(m->watch_bus);
 
+        set_free(m->startup_units);
         set_free(m->failed_units);
 
         sd_event_source_unref(m->signal_event_source);
@@ -2445,6 +2450,9 @@ bool manager_unit_inactive_or_pending(Manager *m, const char *name) {
 void manager_check_finished(Manager *m) {
         char userspace[FORMAT_TIMESPAN_MAX], initrd[FORMAT_TIMESPAN_MAX], kernel[FORMAT_TIMESPAN_MAX], sum[FORMAT_TIMESPAN_MAX];
         usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
+        Unit *u = NULL;
+        Iterator i;
+        UnitActiveState state;
 
         assert(m);
 
@@ -2532,6 +2540,14 @@ void manager_check_finished(Manager *m) {
                                    NULL);
         }
 
+        SET_FOREACH(u, m->startup_units, i) {
+                u = set_steal_first(m->startup_units);
+                state = unit_active_state(u);
+                if (!UNIT_IS_ACTIVE_OR_ACTIVATING(state))
+                        continue;
+                cgroup_context_apply(m, unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path);
+        }
+
         bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);
 
         sd_notifyf(false,

src/core/manager.h

@@ -116,6 +116,9 @@ struct Manager {
         Hashmap *watch_pids1;  /* pid => Unit object n:1 */
         Hashmap *watch_pids2;  /* pid => Unit object n:1 */
 
+        /* A set contains all units which cgroup should be refreshed after startup */
+        Set *startup_units;
+
         /* A set which contains all currently failed units */
         Set *failed_units;
 

src/core/unit.c

@@ -1071,6 +1071,20 @@ static int unit_add_mount_dependencies(Unit *u) {
         return 0;
 }
 
+static int unit_add_startup_units(Unit *u) {
+        CGroupContext *c;
+        int r = 0;
+
+        c = unit_get_cgroup_context(u);
+        if (c != NULL && manager_state(u->manager) == MANAGER_STARTING &&
+            (c->startup_cpu_shares_set || c->startup_blockio_weight_set)) {
+                r = set_put(u->manager->startup_units, u);
+                if (r == -EEXIST)
+                        r = 0;
+        }
+        return r;
+}
+
 int unit_load(Unit *u) {
         int r;
 
@@ -1112,6 +1126,10 @@ int unit_load(Unit *u) {
                 if (r < 0)
                         goto fail;
 
+                r = unit_add_startup_units(u);
+                if (r < 0)
+                        goto fail;
+
                 if (u->on_failure_job_mode == JOB_ISOLATE && set_size(u->dependencies[UNIT_ON_FAILURE]) > 1) {
                         log_error_unit(u->id, "More than one OnFailure= dependencies specified for %s but OnFailureJobMode=isolate set. Refusing.", u->id);
                         r = -EINVAL;