[systemd-devel] [PATCH] core: add startup resource control option
WaLyong Cho
walyong.cho at samsung.com
Mon Mar 17 08:56:26 PDT 2014
Similar to CPUShares= and BlockIOWeight= respectively. However only
assign the specified weight during startup state. 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.
---
src/core/cgroup.c | 44 +++++++++++++----
src/core/cgroup.h | 8 +++-
src/core/dbus-cgroup.c | 40 ++++++++++++++++
src/core/load-fragment-gperf.gperf.m4 | 2 +
src/core/load-fragment.c | 83 +++++++++++++++++++++++++++++++++
src/core/load-fragment.h | 2 +
src/core/manager.c | 11 +++++
src/core/manager.h | 3 ++
8 files changed, 183 insertions(+), 10 deletions(-)
diff --git a/src/core/cgroup.c b/src/core/cgroup.c
index 18de888..8112207 100644
--- a/src/core/cgroup.c
+++ b/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;
}
void cgroup_context_free_device_allow(CGroupContext *c, CGroupDeviceAllow *a) {
@@ -93,14 +97,18 @@ void cgroup_context_dump(CGroupContext *c, FILE* f, const char *prefix) {
"%sBlockIOAccounting=%s\n"
"%sMemoryAccounting=%s\n"
"%sCPUShares=%lu\n"
+ "%sStartupCPUShares=%lu\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, c->blockio_weight,
+ prefix, c->startup_blockio_weight,
prefix, c->memory_limit,
prefix, cgroup_device_policy_to_string(c->device_policy));
@@ -269,7 +277,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;
@@ -286,7 +294,9 @@ void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, const cha
if ((mask & CGROUP_CPU) && !is_root) {
char buf[DECIMAL_STR_MAX(unsigned long) + 1];
- 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));
@@ -300,7 +310,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));
@@ -404,16 +416,19 @@ 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)
+ if (c->cpu_accounting ||
+ (manager_state(m) == MANAGER_STARTING && c->startup_cpu_shares != 1024) ||
+ (manager_state(m) != MANAGER_STARTING && c->cpu_shares != 1024))
mask |= CGROUP_CPUACCT | CGROUP_CPU;
if (c->blockio_accounting ||
- c->blockio_weight != 1000 ||
+ (manager_state(m) == MANAGER_STARTING && c->startup_blockio_weight != 1000) ||
+ (manager_state(m) != MANAGER_STARTING && c->blockio_weight != 1000) ||
c->blockio_device_weights ||
c->blockio_device_bandwidths)
mask |= CGROUP_BLKIO;
@@ -435,7 +450,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) {
@@ -611,6 +626,7 @@ static bool unit_has_mask_realized(Unit *u, CGroupControllerMask mask) {
*
* Returns 0 on success and < 0 on failure. */
static int unit_realize_cgroup_now(Unit *u) {
+ CGroupContext *c;
CGroupControllerMask mask;
int r;
@@ -638,8 +654,20 @@ static int unit_realize_cgroup_now(Unit *u) {
if (r < 0)
return r;
+ c = unit_get_cgroup_context(u);
+ if (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 < 0) {
+ if (r == -EEXIST)
+ r = 0;
+ else
+ return r;
+ }
+ }
+
/* Finally, apply the necessary attributes. */
- cgroup_context_apply(unit_get_cgroup_context(u), mask, u->cgroup_path);
+ cgroup_context_apply(u->manager, c, mask, u->cgroup_path);
return 0;
}
diff --git a/src/core/cgroup.h b/src/core/cgroup.h
index be717ad..72ea979 100644
--- a/src/core/cgroup.h
+++ b/src/core/cgroup.h
@@ -71,8 +71,12 @@ struct CGroupContext {
bool memory_accounting;
unsigned long cpu_shares;
+ unsigned long startup_cpu_shares;
+ bool startup_cpu_shares_set:1;
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);
@@ -89,9 +93,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);
diff --git a/src/core/dbus-cgroup.c b/src/core/dbus-cgroup.c
index 775825b..fdd7cb3 100644
--- a/src/core/dbus-cgroup.c
+++ b/src/core/dbus-cgroup.c
@@ -137,8 +137,10 @@ 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("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),
@@ -197,6 +199,25 @@ 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;
+ unit_write_drop_in_private_format(u, mode, name, "StartupCPUShares=%lu", ul);
+ }
+
+ return 1;
+
} else if (streq(name, "BlockIOAccounting")) {
int b;
@@ -230,6 +251,25 @@ 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;
+ 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;
diff --git a/src/core/load-fragment-gperf.gperf.m4 b/src/core/load-fragment-gperf.gperf.m4
index f85d868..e2e2601 100644
--- a/src/core/load-fragment-gperf.gperf.m4
+++ b/src/core/load-fragment-gperf.gperf.m4
@@ -109,12 +109,14 @@ 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.MemoryAccounting, config_parse_bool, 0, offsetof($1, cgroup_context.memory_accounting)
$1.MemoryLimit, config_parse_memory_limit, 0, offsetof($1, cgroup_context)
$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.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)'
diff --git a/src/core/load-fragment.c b/src/core/load-fragment.c
index 06e3031..87d7089 100644
--- a/src/core/load-fragment.c
+++ b/src/core/load-fragment.c
@@ -2460,6 +2460,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;
}
@@ -2589,6 +2630,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;
}
@@ -3406,11 +3487,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" },
diff --git a/src/core/load-fragment.h b/src/core/load-fragment.h
index 3513851..d8d4b2d 100644
--- a/src/core/load-fragment.h
+++ b/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);
diff --git a/src/core/manager.c b/src/core/manager.c
index ce5888e..9aa8071 100644
--- a/src/core/manager.c
+++ b/src/core/manager.c
@@ -453,6 +453,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;
@@ -784,6 +788,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);
@@ -2447,6 +2452,7 @@ 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;
assert(m);
@@ -2534,6 +2540,11 @@ void manager_check_finished(Manager *m) {
NULL);
}
+ while (!set_isempty(m->startup_units)) {
+ u = set_steal_first(m->startup_units);
+ 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,
diff --git a/src/core/manager.h b/src/core/manager.h
index 38f1c89..0000e29 100644
--- a/src/core/manager.h
+++ b/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;
--
1.7.9.5
More information about the systemd-devel
mailing list