shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2024-10-26 17:25:34 +03:00
Code

cgroup: rework startup logic

Browse Source 
Introduce a (unsigned long) -1 as "unset" state for cpu shares/block io
weights, and keep the startup unit set around all the time.
This commit is contained in:
Lennart Poettering 2014-05-22 07:06:16 +09:00
parent 95ae05c0e7
commit db785129c9
9 changed files with 137 additions and 216 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
man/systemd.resource-control.xml
View File

@ -115,6 +115,7 @@ along with systemd; If not, see <http://www.gnu.org/licenses/>.
<varlistentry>
<term><varname>CPUShares=<replaceable>weight</replaceable></varname></term>
<term><varname>StartupCPUShares=<replaceable>weight</replaceable></varname></term>
<listitem>
<para>Assign the specified CPU time share weight to the
@ -122,10 +123,17 @@ along with systemd; If not, see <http://www.gnu.org/licenses/>.
the <literal>cpu.shares</literal> control group attribute,
which defaults to 1024. For details about this control group
attribute, see <ulink
url="https://www.kernel.org/doc/Documentation/scheduler/sched-design-CFS.txt">sched-design-CFS.txt</ulink>
The available CPU time is split up among all units within a
url="https://www.kernel.org/doc/Documentation/scheduler/sched-design-CFS.txt">sched-design-CFS.txt</ulink>.
The available CPU time is split up among all units within one
slice relative to their CPU time share weight.</para>
<para>While <varname>StartupCPUShares=</varname> only
applies to the startup phase of the system,
<varname>CPUShares=</varname> applies to the later runtime
of the system, and if the former is not set also to the
startup phase. This allows priorizing specific services at
boot-up differently than during runtime.</para>
<para>Implies <literal>CPUAccounting=true</literal>.</para>
</listitem>
</varlistentry>
@ -170,18 +178,6 @@ 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>
@ -233,37 +229,30 @@ along with systemd; If not, see <http://www.gnu.org/licenses/>.
<varlistentry>
<term><varname>BlockIOWeight=<replaceable>weight</replaceable></varname></term>
<term><varname>StartupBlockIOWeight=<replaceable>weight</replaceable></varname></term>
<listitem><para>Set the default
overall block IO weight for the
executed processes. Takes a single
weight value (between 10 and 1000) to
set the default block IO weight. This
controls the
<literal>blkio.weight</literal>
control group attribute, which
defaults to 1000. For details about
this control group attribute, see
<ulink
url="https://www.kernel.org/doc/Documentation/cgroups/blkio-controller.txt">blkio-controller.txt</ulink>.</para>
<listitem><para>Set the default overall block IO weight for
the executed processes. Takes a single weight value (between
10 and 1000) to set the default block IO weight. This controls
the <literal>blkio.weight</literal> control group attribute,
which defaults to 1000. For details about this control group
attribute, see <ulink
url="https://www.kernel.org/doc/Documentation/cgroups/blkio-controller.txt">blkio-controller.txt</ulink>.
The available IO bandwidth is split up among all units within
one slice relative to their block IO weight.</para>
<para>While <varname>StartupBlockIOWeight=</varname> only
applies to the startup phase of the system,
<varname>BlockIOWeight=</varname> applies to the later runtime
of the system, and if the former is not set also to the
startup phase. This allows priorizing specific services at
boot-up differently than during runtime.</para>
<para>Implies
<literal>BlockIOAccounting=true</literal>.</para>
</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>

60
src/core/cgroup.c
View File

@ -33,13 +33,11 @@ void cgroup_context_init(CGroupContext *c) {
/* Initialize everything to the kernel defaults, assuming the
* structure is preinitialized to 0 */
c->cpu_shares = 1024;
c->startup_cpu_shares = 1024;
c->startup_cpu_shares_set = false;
c->cpu_shares = (unsigned long) -1;
c->startup_cpu_shares = (unsigned long) -1;
c->memory_limit = (uint64_t) -1;
c->blockio_weight = 1000;
c->startup_blockio_weight = 1000;
c->startup_blockio_weight_set = false;
c->blockio_weight = (unsigned long) -1;
c->startup_blockio_weight = (unsigned long) -1;
c->cpu_quota_per_sec_usec = (usec_t) -1;
c->cpu_quota_usec = (usec_t) -1;
@ -314,7 +312,7 @@ fail:
return -errno;
}
void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mask, const char *path) {
void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const char *path, ManagerState state) {
bool is_root;
int r;
@ -332,9 +330,9 @@ void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mas
char buf[MAX(DECIMAL_STR_MAX(unsigned long), DECIMAL_STR_MAX(usec_t)) + 1];
usec_t q;
sprintf(buf, "%lu\n", manager_state(m) == MANAGER_STARTING
? c->startup_cpu_shares
: c->cpu_shares);
sprintf(buf, "%lu\n",
state == MANAGER_STARTING && c->startup_cpu_shares != (unsigned long) -1 ? c->startup_cpu_shares :
c->cpu_shares != (unsigned long) -1 ? c->cpu_shares : 1024);
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));
@ -362,9 +360,8 @@ void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mas
CGroupBlockIODeviceBandwidth *b;
if (!is_root) {
sprintf(buf, "%lu\n", manager_state(m) == MANAGER_STARTING
? c->startup_blockio_weight
: c->blockio_weight);
sprintf(buf, "%lu\n", state == MANAGER_STARTING && c->startup_blockio_weight != (unsigned long) -1 ? c->startup_blockio_weight :
c->blockio_weight != (unsigned long) -1 ? c->blockio_weight : 1000);
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));
@ -474,30 +471,24 @@ void cgroup_context_apply(Manager *m, CGroupContext *c, CGroupControllerMask mas
}
}
CGroupControllerMask cgroup_context_get_mask(Manager *m, CGroupContext *c) {
CGroupControllerMask cgroup_context_get_mask(CGroupContext *c) {
CGroupControllerMask mask = 0;
/* Figure out which controllers we need */
if (c->cpu_accounting ||
(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_shares != (unsigned long) -1 ||
c->startup_cpu_shares != (unsigned long) -1 ||
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 ||
(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_weight != (unsigned long) -1 ||
c->startup_blockio_weight != (unsigned long) -1 ||
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)
@ -516,7 +507,7 @@ CGroupControllerMask unit_get_cgroup_mask(Unit *u) {
if (!c)
return 0;
return cgroup_context_get_mask(u->manager, c);
return cgroup_context_get_mask(c);
}
CGroupControllerMask unit_get_members_mask(Unit *u) {
@ -691,7 +682,7 @@ static bool unit_has_mask_realized(Unit *u, CGroupControllerMask mask) {
* If not, create paths, move processes over, and set attributes.
*
* Returns 0 on success and < 0 on failure. */
static int unit_realize_cgroup_now(Unit *u) {
static int unit_realize_cgroup_now(Unit *u, ManagerState state) {
CGroupControllerMask mask;
int r;
@ -709,7 +700,7 @@ static int unit_realize_cgroup_now(Unit *u) {
/* First, realize parents */
if (UNIT_ISSET(u->slice)) {
r = unit_realize_cgroup_now(UNIT_DEREF(u->slice));
r = unit_realize_cgroup_now(UNIT_DEREF(u->slice), state);
if (r < 0)
return r;
}
@ -720,7 +711,7 @@ static int unit_realize_cgroup_now(Unit *u) {
return r;
/* Finally, apply the necessary attributes. */
cgroup_context_apply(u->manager, unit_get_cgroup_context(u), mask, u->cgroup_path);
cgroup_context_apply(unit_get_cgroup_context(u), mask, u->cgroup_path, state);
return 0;
}
@ -735,14 +726,17 @@ static void unit_add_to_cgroup_queue(Unit *u) {
}
unsigned manager_dispatch_cgroup_queue(Manager *m) {
Unit *i;
ManagerState state;
unsigned n = 0;
Unit *i;
int r;
state = manager_state(m);
while ((i = m->cgroup_queue)) {
assert(i->in_cgroup_queue);
r = unit_realize_cgroup_now(i);
r = unit_realize_cgroup_now(i, state);
if (r < 0)
log_warning("Failed to realize cgroups for queued unit %s: %s", i->id, strerror(-r));
@ -814,7 +808,7 @@ int unit_realize_cgroup(Unit *u) {
unit_queue_siblings(u);
/* And realize this one now (and apply the values) */
return unit_realize_cgroup_now(u);
return unit_realize_cgroup_now(u, manager_state(u->manager));
}
void unit_destroy_cgroup(Unit *u) {

6
src/core/cgroup.h
View File

@ -72,14 +72,12 @@ struct CGroupContext {
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);
@ -96,9 +94,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(Manager *m, CGroupContext *c, CGroupControllerMask mask, const char *path);
void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const char *path, ManagerState state);
CGroupControllerMask cgroup_context_get_mask(Manager *m, CGroupContext *c);
CGroupControllerMask cgroup_context_get_mask(CGroupContext *c);
void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a);
void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBlockIODeviceWeight *w);

70
src/core/dbus-cgroup.c
View File

@ -169,17 +169,35 @@ static int property_get_cpu_quota_per_sec_usec(
return sd_bus_message_append(reply, "t", cgroup_context_get_cpu_quota_per_sec_usec(c));
}
static int property_get_ulong_as_u64(
sd_bus *bus,
const char *path,
const char *interface,
const char *property,
sd_bus_message *reply,
void *userdata,
sd_bus_error *error) {
unsigned long *ul = userdata;
assert(bus);
assert(reply);
assert(ul);
return sd_bus_message_append(reply, "t", *ul == (unsigned long) -1 ? (uint64_t) -1 : (uint64_t) *ul);
}
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("CPUShares", "t", property_get_ulong_as_u64, offsetof(CGroupContext, cpu_shares), 0),
SD_BUS_PROPERTY("StartupCPUShares", "t", property_get_ulong_as_u64, 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("BlockIOWeight", "t", property_get_ulong_as_u64, offsetof(CGroupContext, blockio_weight), 0),
SD_BUS_PROPERTY("StartupBlockIOWeight", "t", property_get_ulong_as_u64, 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),
@ -228,9 +246,13 @@ int bus_cgroup_set_property(
if (r < 0)
return r;
ul = (unsigned long) u64;
if (ul <= 0 || (uint64_t) ul != u64)
return sd_bus_error_set_errnof(error, EINVAL, "CPUShares value out of range");
if (u64 == (uint64_t) -1)
ul = (unsigned long) -1;
else {
ul = (unsigned long) u64;
if (ul <= 0 || (uint64_t) ul != u64)
return sd_bus_error_set_errnof(error, EINVAL, "CPUShares value out of range");
}
if (mode != UNIT_CHECK) {
c->cpu_shares = ul;
@ -248,13 +270,17 @@ int bus_cgroup_set_property(
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 (u64 == (uint64_t) -1)
ul = (unsigned long) -1;
else {
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;
u->cgroup_realized_mask &= ~CGROUP_CPU;
unit_write_drop_in_private_format(u, mode, name, "StartupCPUShares=%lu", ul);
}
@ -340,9 +366,13 @@ int bus_cgroup_set_property(
if (r < 0)
return r;
ul = (unsigned long) u64;
if (ul < 10 || ul > 1000)
return sd_bus_error_set_errnof(error, EINVAL, "BlockIOWeight value out of range");
if (u64 == (uint64_t) -1)
ul = (unsigned long) -1;
else {
ul = (unsigned long) u64;
if (ul < 10 || ul > 1000)
return sd_bus_error_set_errnof(error, EINVAL, "BlockIOWeight value out of range");
}
if (mode != UNIT_CHECK) {
c->blockio_weight = ul;
@ -360,13 +390,17 @@ int bus_cgroup_set_property(
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 (u64 == (uint64_t) -1)
ul = (unsigned long) -1;
else {
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;
u->cgroup_realized_mask &= ~CGROUP_BLKIO;
unit_write_drop_in_private_format(u, mode, name, "StartupBlockIOWeight=%lu", ul);
}

8
src/core/load-fragment-gperf.gperf.m4
View File

@ -105,8 +105,8 @@ $1.KillSignal, config_parse_kill_signal, 0,
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.CPUShares, config_parse_cpu_shares, 0, offsetof($1, cgroup_context.cpu_shares)
$1.StartupCPUShares, config_parse_cpu_shares, 0, offsetof($1, cgroup_context.startup_cpu_shares)
$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,8 +114,8 @@ $1.MemoryLimit, config_parse_memory_limit, 0,
$1.DeviceAllow, config_parse_device_allow, 0, offsetof($1, cgroup_context)
$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.BlockIOWeight, config_parse_blockio_weight, 0, offsetof($1, cgroup_context.blockio_weight)
$1.StartupBlockIOWeight, config_parse_blockio_weight, 0, offsetof($1, cgroup_context.startup_blockio_weight)
$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)'

114
src/core/load-fragment.c
View File

@ -2430,8 +2430,7 @@ int config_parse_cpu_shares(
void *data,
void *userdata) {
CGroupContext *c = data;
unsigned long lu;
unsigned long *shares = data, lu;
int r;
assert(filename);
@ -2439,59 +2438,17 @@ int config_parse_cpu_shares(
assert(rvalue);
if (isempty(rvalue)) {
c->cpu_shares = 1024;
*shares = (unsigned long) -1;
return 0;
}
r = safe_atolu(rvalue, &lu);
if (r < 0 || lu <= 0) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"CPU shares '%s' invalid. Ignoring.", rvalue);
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "CPU shares '%s' invalid. Ignoring.", rvalue);
return 0;
}
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;
*shares = lu;
return 0;
}
@ -2648,8 +2605,7 @@ int config_parse_blockio_weight(
void *data,
void *userdata) {
CGroupContext *c = data;
unsigned long lu;
unsigned long *weight = data, lu;
int r;
assert(filename);
@ -2657,59 +2613,17 @@ int config_parse_blockio_weight(
assert(rvalue);
if (isempty(rvalue)) {
c->blockio_weight = 1000;
*weight = (unsigned long) -1;
return 0;
}
r = safe_atolu(rvalue, &lu);
if (r < 0 || lu < 10 || lu > 1000) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"Block IO weight '%s' invalid. Ignoring.", rvalue);
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Block IO weight '%s' invalid. Ignoring.", rvalue);
return 0;
}
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;
*weight = lu;
return 0;
}
@ -2747,8 +2661,7 @@ int config_parse_blockio_device_weight(
n = strcspn(rvalue, WHITESPACE);
weight = rvalue + n;
if (!*weight) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"Expected block device and device weight. Ignoring.");
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Expected block device and device weight. Ignoring.");
return 0;
}
@ -2757,20 +2670,17 @@ int config_parse_blockio_device_weight(
return log_oom();
if (!path_startswith(path, "/dev")) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"Invalid device node path '%s'. Ignoring.", path);
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Invalid device node path '%s'. Ignoring.", path);
return 0;
}
weight += strspn(weight, WHITESPACE);
r = safe_atolu(weight, &lu);
if (r < 0 || lu < 10 || lu > 1000) {
log_syntax(unit, LOG_ERR, filename, line, EINVAL,
"Block IO weight '%s' invalid. Ignoring.", rvalue);
log_syntax(unit, LOG_ERR, filename, line, EINVAL, "Block IO weight '%s' invalid. Ignoring.", rvalue);
return 0;
}
w = new0(CGroupBlockIODeviceWeight, 1);
if (!w)
return log_oom();
@ -3526,13 +3436,11 @@ 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" },

2
src/core/load-fragment.h
View File

@ -80,12 +80,10 @@ 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);

10
src/core/manager.c
View File

@ -2452,7 +2452,6 @@ void manager_check_finished(Manager *m) {
usec_t firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec;
Unit *u = NULL;
Iterator i;
UnitActiveState state;
assert(m);
@ -2540,13 +2539,8 @@ 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);
}
SET_FOREACH(u, m->startup_units, i)
cgroup_context_apply(unit_get_cgroup_context(u), unit_get_cgroup_mask(u), u->cgroup_path, manager_state(m));
bus_manager_send_finished(m, firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec);

18
src/core/unit.c
View File

@ -509,6 +509,7 @@ void unit_free(Unit *u) {
}
set_remove(u->manager->failed_units, u);
set_remove(u->manager->startup_units, u);
free(u->description);
strv_free(u->documentation);
@ -1076,12 +1077,17 @@ static int unit_add_startup_units(Unit *u) {
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;
}
if (!c)
return 0;
if (c->startup_cpu_shares == (unsigned long) -1 &&
c->startup_blockio_weight == (unsigned long) -1)
return 0;
r = set_put(u->manager->startup_units, u);
if (r == -EEXIST)
return 0;
return r;
}