If the CPU supports Intel's Code and Data Prioritization (CDP), software
can specify a separate bitmap for code and data. This feature needs
enabling in a model-specific-register, and changes the properties of
the cache-controls: it halves the effective number of closids.
This changes how closids are allocated, and so applies to all
alloc_enabled caches. If a system has multiple levels of RDT-like
controls CDP should be enabled/disabled across them all.
Make the CDP enable/disable calls global.
Add CDP capable/enabled flags, and unify the enable/disable behind a
single resctrl_arch_set_cdp_enabled(true/false) call. Architectures
that have nothing to do here can just update the flags.
This subtly changes resctrl's '-o cdp' (l3) and '-o cdpl2' parameters
to mean enable globally if this level supports cdp. The difference
can't be seen on a system which only has one of the two.
Signed-off-by: James Morse <james.mo...@arm.com>
---
arch/x86/kernel/cpu/intel_rdt.c | 1 +
arch/x86/kernel/cpu/intel_rdt_rdtgroup.c | 72 ++++++++++++++++--------
include/linux/resctrl.h | 7 +++
3 files changed, 57 insertions(+), 23 deletions(-)
diff --git a/arch/x86/kernel/cpu/intel_rdt.c b/arch/x86/kernel/cpu/intel_rdt.c
index c4e6dcdd235b..0e651447956e 100644
--- a/arch/x86/kernel/cpu/intel_rdt.c
+++ b/arch/x86/kernel/cpu/intel_rdt.c
@@ -331,6 +331,7 @@ static void rdt_get_cdp_config(int level, int type)
* By default, CDP is disabled. CDP can be enabled by mount parameter
* "cdp" during resctrl file system mount time.
*/
+ r_l->cdp_capable = true;
r->alloc_enabled = false;
}
diff --git a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
index 3ed88d4fedd0..f4f76c193495 100644
--- a/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
+++ b/arch/x86/kernel/cpu/intel_rdt_rdtgroup.c
@@ -1081,7 +1081,7 @@ static int cdp_enable(int level, int data_type, int
code_type)
int ret;
if (!r_l->alloc_capable || !r_ldata->alloc_capable ||
- !r_lcode->alloc_capable)
+ !r_lcode->alloc_capable || !r_l->cdp_capable)
return -EINVAL;
ret = set_cache_qos_cfg(level, true);
@@ -1089,51 +1089,77 @@ static int cdp_enable(int level, int data_type, int
code_type)
r_l->alloc_enabled = false;
r_ldata->alloc_enabled = true;
r_lcode->alloc_enabled = true;
+
+ r_l->cdp_enabled = true;
+ r_ldata->cdp_enabled = true;
+ r_lcode->cdp_enabled = true;
}
return ret;
}
-static int cdpl3_enable(void)
-{
- return cdp_enable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA,
- RDT_RESOURCE_L3CODE);
-}
-
-static int cdpl2_enable(void)
-{
- return cdp_enable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA,
- RDT_RESOURCE_L2CODE);
-}
-
static void cdp_disable(int level, int data_type, int code_type)
{
struct rdt_resource *r = &rdt_resources_all[level].resctrl;
+ if (!r->cdp_enabled)
+ return;
+
r->alloc_enabled = r->alloc_capable;
if (rdt_resources_all[data_type].resctrl.alloc_enabled) {
rdt_resources_all[data_type].resctrl.alloc_enabled = false;
rdt_resources_all[code_type].resctrl.alloc_enabled = false;
set_cache_qos_cfg(level, false);
+
+ r->cdp_enabled = false;
+ rdt_resources_all[data_type].resctrl.cdp_enabled = false;
+ rdt_resources_all[code_type].resctrl.cdp_enabled = false;
}
}
-static void cdpl3_disable(void)
+int resctrl_arch_set_cdp_enabled(bool enable)
{
- cdp_disable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA, RDT_RESOURCE_L3CODE);
+ int ret = -EINVAL;
+ struct rdt_hw_resource *l3 = &rdt_resources_all[RDT_RESOURCE_L3];
+ struct rdt_hw_resource *l2 = &rdt_resources_all[RDT_RESOURCE_L2];
+
+ if (l3 && l3->resctrl.cdp_capable) {
+ if (!enable) {
+ cdp_disable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA,
+ RDT_RESOURCE_L3CODE);
+ ret = 0;
+ } else {
+ ret = cdp_enable(RDT_RESOURCE_L3, RDT_RESOURCE_L3DATA,
+ RDT_RESOURCE_L3CODE);
+ }
+ }
+ if (l2 && l2->resctrl.cdp_capable) {
+ if (!enable) {
+ cdp_disable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA,
+ RDT_RESOURCE_L2CODE);
+ ret = 0;
+ } else {
+ ret = cdp_enable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA,
+ RDT_RESOURCE_L2CODE);
+ }
+ }
+
+ return ret;
}
-static void cdpl2_disable(void)
+static int try_to_enable_cdp(int level)
{
- cdp_disable(RDT_RESOURCE_L2, RDT_RESOURCE_L2DATA, RDT_RESOURCE_L2CODE);
+ struct rdt_resource *r = &rdt_resources_all[level].resctrl;
+
+ if (!r->cdp_capable)
+ return -EINVAL;
+
+ return resctrl_arch_set_cdp_enabled(true);
}
static void cdp_disable_all(void)
{
- if (rdt_resources_all[RDT_RESOURCE_L3DATA].resctrl.alloc_enabled)
- cdpl3_disable();
- if (rdt_resources_all[RDT_RESOURCE_L2DATA].resctrl.alloc_enabled)
- cdpl2_disable();
+ resctrl_arch_set_cdp_enabled(false);
}
static int parse_rdtgroupfs_options(char *data)
@@ -1148,11 +1174,11 @@ static int parse_rdtgroupfs_options(char *data)
}
if (!strcmp(token, "cdp")) {
- ret = cdpl3_enable();
+ ret = try_to_enable_cdp(RDT_RESOURCE_L3);
if (ret)
goto out;
} else if (!strcmp(token, "cdpl2")) {
- ret = cdpl2_enable();
+ ret = try_to_enable_cdp(RDT_RESOURCE_L2);
if (ret)
goto out;
} else if (!strcmp(token, "mba_MBps")) {
diff --git a/include/linux/resctrl.h b/include/linux/resctrl.h
index 9fe7d7de53d7..8bf813071039 100644
--- a/include/linux/resctrl.h
+++ b/include/linux/resctrl.h
@@ -75,8 +75,10 @@ struct resctrl_membw {
/**
* @alloc_enabled: Is allocation enabled on this machine
* @mon_enabled: Is monitoring enabled for this feature
+ * @cdp_enabled Is CDP enabled for this resource
* @alloc_capable: Is allocation available on this machine
* @mon_capable: Is monitor feature available on this machine
+ * @cdp_capable: Is CDP feature available on this resource
*
* @cache_level: Which cache level defines scope of this resource.
*
@@ -100,8 +102,10 @@ struct resctrl_membw {
struct rdt_resource {
bool alloc_enabled;
bool mon_enabled;
+ bool cdp_enabled;
bool alloc_capable;
bool mon_capable;
+ bool cdp_capable;
int cache_level;
@@ -129,4 +133,7 @@ int resctrl_arch_update_domains(struct rdt_resource *r);
void resctrl_arch_get_config(struct rdt_resource *r, struct rdt_domain *d,
u32 closid, u32 *value);
+/* Enable/Disable CDP on all applicable resources */
+int resctrl_arch_set_cdp_enabled(bool enable);
+
#endif /* __LINUX_RESCTRL_H */
--
2.18.0
