From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

To make MPAM feature perfectly compatiable with resctrl sysfs provided by Intel-RDT, we are ready to carry out a large-scale refactoring.

We move mpam.c, mpam_ctrlmon.c and mpam_mon.c to the mpam/ subdirectory under arch/arm64/kernel directory, and rename mpam.c to mpam_resctrl.c, of which function is expected to fully take up the internal resctrl jobs including many new supports such as cdp(Code Data Prioritization) and new interaction style.

Original operations on resctrl sysfs toward resctrl resource will be remapped to operations with new structures.

Before we formally declare that we have accomplished entire refactoring jobs, MPAM driver under our implementation is incomplete.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/Makefile | 2 +- arch/arm64/kernel/mpam/Makefile | 3 ++ arch/arm64/kernel/{ => mpam}/mpam_ctrlmon.c | 6 +--- arch/arm64/kernel/{ => mpam}/mpam_mon.c | 0 .../kernel/{mpam.c => mpam/mpam_resctrl.c} | 31 +++---------------- 5 files changed, 9 insertions(+), 33 deletions(-) create mode 100644 arch/arm64/kernel/mpam/Makefile rename arch/arm64/kernel/{ => mpam}/mpam_ctrlmon.c (98%) rename arch/arm64/kernel/{ => mpam}/mpam_mon.c (100%) rename arch/arm64/kernel/{mpam.c => mpam/mpam_resctrl.c} (97%)

diff --git a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile index 8a15d44fff67..396613f5c485 100644 --- a/arch/arm64/kernel/Makefile +++ b/arch/arm64/kernel/Makefile @@ -62,7 +62,7 @@ arm64-obj-$(CONFIG_CRASH_CORE) += crash_core.o arm64-obj-$(CONFIG_ARM_SDE_INTERFACE) += sdei.o arm64-obj-$(CONFIG_ARM64_SSBD) += ssbd.o arm64-obj-$(CONFIG_SDEI_WATCHDOG) += watchdog_sdei.o -arm64-obj-$(CONFIG_MPAM) += mpam.o mpam_ctrlmon.o mpam_mon.o +arm64-obj-$(CONFIG_MPAM) += mpam/ arm64-obj-$(CONFIG_ARM64_PTR_AUTH) += pointer_auth.o

obj-y += $(arm64-obj-y) vdso/ probes/ diff --git a/arch/arm64/kernel/mpam/Makefile b/arch/arm64/kernel/mpam/Makefile new file mode 100644 index 000000000000..3492ff0a9d0f --- /dev/null +++ b/arch/arm64/kernel/mpam/Makefile @@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_MPAM) += mpam_resctrl.o mpam_mon.o \ + mpam_ctrlmon.o diff --git a/arch/arm64/kernel/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c similarity index 98% rename from arch/arm64/kernel/mpam_ctrlmon.c rename to arch/arm64/kernel/mpam/mpam_ctrlmon.c index 850c52fb4cc8..9518c1fb6abf 100644 --- a/arch/arm64/kernel/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -171,9 +171,6 @@ static int parse_line(char *line, struct resctrl_resource *r) goto next; } } - - rdt_last_cmd_printf("unknown domain (%lu)\n", dom_id); - return -EINVAL; }

@@ -227,7 +224,6 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, rdtgrp = resctrl_group_kn_lock_live(of->kn); if (!rdtgrp) { resctrl_group_kn_unlock(of->kn); - rdt_last_cmd_puts("directory was removed\n"); return -ENOENT; } rdt_last_cmd_clear(); @@ -436,7 +432,7 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, return ret; }

- /* [FIXME] Could we remove the MATCH_* param ? */ + /* Could we remove the MATCH_* param ? */ rr->mon_write(d, prgrp, true);

return ret; diff --git a/arch/arm64/kernel/mpam_mon.c b/arch/arm64/kernel/mpam/mpam_mon.c similarity index 100% rename from arch/arm64/kernel/mpam_mon.c rename to arch/arm64/kernel/mpam/mpam_mon.c diff --git a/arch/arm64/kernel/mpam.c b/arch/arm64/kernel/mpam/mpam_resctrl.c similarity index 97% rename from arch/arm64/kernel/mpam.c rename to arch/arm64/kernel/mpam/mpam_resctrl.c index 3f89cec8e2fb..bd39af1d4854 100644 --- a/arch/arm64/kernel/mpam.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -86,9 +86,6 @@ static inline void mpam_node_assign_val(struct mpam_node *n, n->addr = hwpage_address; n->component_id = component_id; n->cpus_list = "0"; - - if (n->type == MPAM_RESOURCE_MC) - n->default_ctrl = MBA_MAX_WD; }

#define MPAM_NODE_NAME_SIZE (10) @@ -308,7 +305,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { [MPAM_RESOURCE_MC] = { .msr_update = bw_wrmsr, .msr_read = bw_rdmsr, - .parse_ctrlval = parse_bw, /* [FIXME] add parse_bw() helper */ + .parse_ctrlval = parse_bw, /* add parse_bw() helper */ .format_str = "%d=%0*d", .mon_read = mbwu_read, .mon_write = mbwu_write, @@ -368,7 +365,6 @@ u64 bw_rdmsr(struct rdt_domain *d, int partid) }

/* - * [FIXME] * use pmg as monitor id * just use match_pardid only. */ @@ -505,7 +501,7 @@ static int mpam_online_cpu(unsigned int cpu) return 0; }

-/* [FIXME] remove related resource when cpu offline */ +/* remove related resource when cpu offline */ static int mpam_offline_cpu(unsigned int cpu) { return 0; @@ -547,20 +543,6 @@ void post_resctrl_mount(void)

static int reset_all_ctrls(struct resctrl_resource *r) { - struct raw_resctrl_resource *rr; - struct rdt_domain *d; - int partid; - - rr = (struct raw_resctrl_resource *)r->res; - for (partid = 0; partid < rr->num_partid; partid++) { - list_for_each_entry(d, &r->domains, list) { - d->new_ctrl = rr->default_ctrl; - d->ctrl_val[partid] = rr->default_ctrl; - d->have_new_ctrl = true; - rr->msr_update(d, partid); - } - } - return 0; }

@@ -858,7 +840,7 @@ static int resctrl_num_mon_show(struct kernfs_open_file *of, int cpus_mon_write(struct rdtgroup *rdtgrp, cpumask_var_t newmask, cpumask_var_t tmpmask) { - rdt_last_cmd_puts("temporarily unsupported write cpus on mon_groups\n"); + pr_info("unsupported on mon_groups, please use ctrlmon groups\n"); return -EINVAL; }

@@ -1143,12 +1125,11 @@ static ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of,

if (!rdtgrp) { ret = -ENOENT; - rdt_last_cmd_puts("directory was removed\n"); goto unlock; }

if ((rdtgrp->flags & RDT_CTRLMON) && !ctrlmon) { - /* [FIXME] disable & remove mon_data dir */ + /* disable & remove mon_data dir */ rdtgrp->flags &= ~RDT_CTRLMON; resctrl_ctrlmon_disable(rdtgrp->mon.mon_data_kn, rdtgrp); } else if (!(rdtgrp->flags & RDT_CTRLMON) && ctrlmon) { @@ -1157,10 +1138,6 @@ static ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, if (!ret) rdtgrp->flags |= RDT_CTRLMON; } else { - if (ctrlmon) - rdt_last_cmd_printf("ctrlmon has been enabled\n"); - else - rdt_last_cmd_printf("ctrlmon has been disabled\n"); ret = -ENOENT; }

From: James Morse james.morse@arm.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

To provide a reasonable threshold for a measure of cache-usage, MPAM would like to keep track of the largest cache it has seen.

Provide a helper that takes a cpu and a cache-level, and returns the corresponding leaf. This only works for unified caches.

Callers must hold the cpus_read_lock() to prevent the leaf being free()d.

Conflicts: include/linux/cacheinfo.h [Wang ShaoBo: fix a little conflicts and validate info_list]

Signed-off-by: James Morse james.morse@arm.com Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=c9972f21aa19762dc6acf1... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- include/linux/cacheinfo.h | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+)

diff --git a/include/linux/cacheinfo.h b/include/linux/cacheinfo.h index 46b92cd61d0c..6db3f7f8a7d6 100644 --- a/include/linux/cacheinfo.h +++ b/include/linux/cacheinfo.h @@ -119,4 +119,39 @@ int acpi_find_last_cache_level(unsigned int cpu);

const struct attribute_group *cache_get_priv_group(struct cacheinfo *this_leaf);

+/* Get the id of a particular cache on @cpu. cpuhp lock must held. */ +static inline struct cacheinfo *get_cpu_cache_leaf(int cpu, int level) +{ + int i; + struct cpu_cacheinfo *ci = get_cpu_cacheinfo(cpu); + + for (i = 0; i < ci->num_leaves; i++) { + /* + * info_list of this cacheinfo instance + * may not be initialized because sometimes + * free_cache_attributes() may free this + * info_list but not set num_leaves to zero, + * for example when PPTT is not supported. + */ + if (!ci->info_list) + continue; + + if ((ci->info_list[i].type == CACHE_TYPE_UNIFIED) && + (ci->info_list[i].level == level)) { + return &ci->info_list[i]; + } + } + + return NULL; +} + +static inline int get_cpu_cacheinfo_id(int cpu, int level) +{ + struct cacheinfo *leaf = get_cpu_cache_leaf(cpu, level); + + if (leaf && leaf->attributes & CACHE_ID) + return leaf->id; + return -1; +} + #endif /* _LINUX_CACHEINFO_H */

From: James Morse james.morse@arm.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Memory Partitioning and Monitoring (MPAM) has memory mapped devices (MSCs) with an identity/configuration page.

Supplement the definitions for these registers as offset within the page(s).

[Wang ShaoBo: replace tab with space and useful definitions are added]

Signed-off-by: James Morse james.morse@arm.com http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=a9102d227c371ec3cf3913... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 254 +++++++++++++++++-------- 1 file changed, 177 insertions(+), 77 deletions(-)

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index 1a6904c22b9c..caa0b822d8ff 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -4,91 +4,191 @@

#include <linux/bitops.h>

-#define MPAMF_IDR 0x0000 -#define MPAMF_SIDR 0x0008 -#define MPAMF_MSMON_IDR 0x0080 -#define MPAMF_IMPL_IDR 0x0028 -#define MPAMF_CPOR_IDR 0x0030 -#define MPAMF_CCAP_IDR 0x0038 -#define MPAMF_MBW_IDR 0x0040 -#define MPAMF_PRI_IDR 0x0048 -#define MPAMF_CSUMON_IDR 0x0088 -#define MPAMF_MBWUMON_IDR 0x0090 -#define MPAMF_PARTID_NRW_IDR 0x0050 -#define MPAMF_IIDR 0x0018 -#define MPAMF_AIDR 0x0020 -#define MPAMCFG_PART_SEL 0x0100 -#define MPAMCFG_CPBM 0x1000 -#define MPAMCFG_CMAX 0x0108 -#define MPAMCFG_MBW_MIN 0x0200 -#define MPAMCFG_MBW_MAX 0x0208 -#define MPAMCFG_MBW_WINWD 0x0220 -#define MPAMCFG_MBW_PBM 0x2000 -#define MPAMCFG_PRI 0x0400 -#define MPAMCFG_MBW_PROP 0x0500 -#define MPAMCFG_INTPARTID 0x0600 -#define MSMON_CFG_MON_SEL 0x0800 -#define MSMON_CFG_CSU_FLT 0x0810 -#define MSMON_CFG_CSU_CTL 0x0818 -#define MSMON_CFG_MBWU_FLT 0x0820 -#define MSMON_CFG_MBWU_CTL 0x0828 -#define MSMON_CSU 0x0840 -#define MSMON_CSU_CAPTURE 0x0848 -#define MSMON_MBWU 0x0860 -#define MSMON_MBWU_CAPTURE 0x0868 -#define MSMON_CAPT_EVNT 0x0808 -#define MPAMF_ESR 0x00F8 -#define MPAMF_ECR 0x00F0 - -#define HAS_CCAP_PART BIT(24) -#define HAS_CPOR_PART BIT(25) -#define HAS_MBW_PART BIT(26) -#define HAS_PRI_PART BIT(27) -#define HAS_IMPL_IDR BIT(29) -#define HAS_MSMON BIT(30) +#define MPAMF_IDR 0x0000 +#define MPAMF_SIDR 0x0008 +#define MPAMF_MSMON_IDR 0x0080 +#define MPAMF_IMPL_IDR 0x0028 +#define MPAMF_CPOR_IDR 0x0030 +#define MPAMF_CCAP_IDR 0x0038 +#define MPAMF_MBW_IDR 0x0040 +#define MPAMF_PRI_IDR 0x0048 +#define MPAMF_CSUMON_IDR 0x0088 +#define MPAMF_MBWUMON_IDR 0x0090 +#define MPAMF_PARTID_NRW_IDR 0x0050 +#define MPAMF_IIDR 0x0018 +#define MPAMF_AIDR 0x0020 +#define MPAMCFG_PART_SEL 0x0100 +#define MPAMCFG_CPBM 0x1000 +#define MPAMCFG_CMAX 0x0108 +#define MPAMCFG_MBW_MIN 0x0200 +#define MPAMCFG_MBW_MAX 0x0208 +#define MPAMCFG_MBW_WINWD 0x0220 +#define MPAMCFG_MBW_PBM 0x2000 +#define MPAMCFG_PRI 0x0400 +#define MPAMCFG_MBW_PROP 0x0500 +#define MPAMCFG_INTPARTID 0x0600 +#define MSMON_CFG_MON_SEL 0x0800 +#define MSMON_CFG_CSU_FLT 0x0810 +#define MSMON_CFG_CSU_CTL 0x0818 +#define MSMON_CFG_MBWU_FLT 0x0820 +#define MSMON_CFG_MBWU_CTL 0x0828 +#define MSMON_CSU 0x0840 +#define MSMON_CSU_CAPTURE 0x0848 +#define MSMON_MBWU 0x0860 +#define MSMON_MBWU_CAPTURE 0x0868 +#define MSMON_CAPT_EVNT 0x0808 +#define MPAMF_ESR 0x00F8 +#define MPAMF_ECR 0x00F0 + +#define HAS_CCAP_PART BIT(24) +#define HAS_CPOR_PART BIT(25) +#define HAS_MBW_PART BIT(26) +#define HAS_PRI_PART BIT(27) +#define HAS_IMPL_IDR BIT(29) +#define HAS_MSMON BIT(30) +#define HAS_PARTID_NRW BIT(31)

/* MPAMF_IDR */ -#define MPAMF_IDR_PMG_MAX_MASK ((BIT(8) - 1) << 16) -#define MPAMF_IDR_PARTID_MAX_MASK (BIT(16) - 1) -#define MPAMF_IDR_PMG_MAX_GET(v) ((v & MPAMF_IDR_PMG_MAX_MASK) >> 16) -#define MPAMF_IDR_PARTID_MAX_GET(v) (v & MPAMF_IDR_PARTID_MAX_MASK) +#define MPAMF_IDR_PMG_MAX_MASK ((BIT(8) - 1) << 16) +#define MPAMF_IDR_PMG_MAX_SHIFT 16 +#define MPAMF_IDR_PARTID_MAX_MASK (BIT(16) - 1) +#define MPAMF_IDR_PMG_MAX_GET(v) ((v & MPAMF_IDR_PMG_MAX_MASK) >> 16) +#define MPAMF_IDR_PARTID_MAX_GET(v) (v & MPAMF_IDR_PARTID_MAX_MASK) + +#define MPAMF_IDR_HAS_CCAP_PART(v) ((v) & HAS_CCAP_PART) +#define MPAMF_IDR_HAS_CPOR_PART(v) ((v) & HAS_CPOR_PART) +#define MPAMF_IDR_HAS_MBW_PART(v) ((v) & HAS_MBW_PART) +#define MPAMF_IDR_HAS_MSMON(v) ((v) & HAS_MSMON) +#define MPAMF_IDR_PARTID_MASK GENMASK(15, 0) +#define MPAMF_IDR_PMG_MASK GENMASK(23, 16) +#define MPAMF_IDR_PMG_SHIFT 16 +#define MPAMF_IDR_HAS_PARTID_NRW(v) ((v) & HAS_PARTID_NRW) +#define NUM_MON_MASK (BIT(16) - 1) +#define MPAMF_IDR_NUM_MON(v) ((v) & NUM_MON_MASK) + +#define CPBM_WD_MASK 0xFFFF +#define CPBM_MASK 0x7FFF + +#define BWA_WD 6 /* hard code for P680 */ +#define MBW_MAX_MASK 0xFC00 +#define MBW_MAX_HARDLIM BIT(31) +#define MBW_MAX_SET(v) (MBW_MAX_HARDLIM|((v) << (16 - BWA_WD))) +#define MBW_MAX_GET(v) (((v) & MBW_MAX_MASK) >> (16 - BWA_WD)) + +#define MSMON_MATCH_PMG BIT(17) +#define MSMON_MATCH_PARTID BIT(16) +#define MSMON_CFG_CTL_EN BIT(31) +#define MSMON_CFG_FLT_SET(r, p) ((r) << 16|(p)) +#define MBWU_SUBTYPE_DEFAULT (3 << 20) +#define MSMON_CFG_MBWU_CTL_SET(m) (BIT(31)|MBWU_SUBTYPE_DEFAULT|(m)) +#define MSMON_CFG_CSU_CTL_SET(m) (BIT(31)|(m)) +#define MSMON_CFG_CSU_TYPE 0x43 +#define MSMON_CFG_MBWU_TYPE 0x42

-#define MPAMF_IDR_HAS_CCAP_PART(v) ((v) & HAS_CCAP_PART) -#define MPAMF_IDR_HAS_CPOR_PART(v) ((v) & HAS_CPOR_PART) -#define MPAMF_IDR_HAS_MBW_PART(v) ((v) & HAS_MBW_PART) -#define MPAMF_IDR_HAS_MSMON(v) ((v) & HAS_MSMON) - -/* MPAMF_x_IDR */ -#define NUM_MON_MASK (BIT(16) - 1) -#define MPAMF_IDR_NUM_MON(v) ((v) & NUM_MON_MASK) - -/* TODO */ - -#define CPBM_WD_MASK 0xFFFF -#define CPBM_MASK 0x7FFF - -#define BWA_WD 6 /* hard code for P680 */ -#define MBW_MAX_MASK 0xFC00 -#define MBW_MAX_HARDLIM BIT(31) - -#define MSMON_MATCH_PMG BIT(17) -#define MSMON_MATCH_PARTID BIT(16) - -#define MSMON_CFG_CTL_EN BIT(31) - -#define MSMON_CFG_FLT_SET(r, p) ((r) << 16|(p)) +/* + * Size of the memory mapped registers: 4K of feature page then 2 x 4K + * bitmap registers + */ +#define SZ_MPAM_DEVICE (3 * SZ_4K)

-#define MBWU_SUBTYPE_DEFAULT (3 << 20) -#define MSMON_CFG_MBWU_CTL_SET(m) (BIT(31)|MBWU_SUBTYPE_DEFAULT|(m)) +/* + * MSMON_CSU - Memory system performance monitor cache storage usage monitor + * register + * MSMON_CSU_CAPTURE - Memory system performance monitor cache storage usage + * capture register + * MSMON_MBWU - Memory system performance monitor memory bandwidth usage + * monitor register + * MSMON_MBWU_CAPTURE - Memory system performance monitor memory bandwidth usage + * capture register + */ +#define MSMON___VALUE GENMASK(30, 0) +#define MSMON___NRDY BIT(31)

-#define MSMON_CFG_CSU_CTL_SET(m) (BIT(31)|(m)) +/* + * MSMON_CAPT_EVNT - Memory system performance monitoring capture event + * generation register + */ +#define MSMON_CAPT_EVNT_NOW BIT(0) +/* + * MPAMCFG_MBW_MAX SET - temp Hard code + */ +#define MPAMCFG_PRI_DSPRI_SHIFT 16 + +/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ +#define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) +#define MPAMF_PRI_IDR_INTPRI_0_IS_LOW BIT(1) +#define MPAMF_PRI_IDR_INTPRI_WD_SHIFT 4 +#define MPAMF_PRI_IDR_INTPRI_WD GENMASK(9, 4) +#define MPAMF_PRI_IDR_HAS_DSPRI BIT(16) +#define MPAMF_PRI_IDR_DSPRI_0_IS_LOW BIT(17) +#define MPAMF_PRI_IDR_DSPRI_WD_SHIFT 20 +#define MPAMF_PRI_IDR_DSPRI_WD GENMASK(25, 20) + +/* MPAMF_CSUMON_IDR - MPAM cache storage usage monitor ID register */ +#define MPAMF_CSUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_CSUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_MBWUMON_IDR - MPAM memory bandwidth usage monitor ID register */ +#define MPAMF_MBWUMON_IDR_NUM_MON GENMASK(15, 0) +#define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31) + +/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */ +#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0) + +/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */ +#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0) + +/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */ +#define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) +#define MPAMF_MBW_IDR_HAS_MIN BIT(10) +#define MPAMF_MBW_IDR_HAS_MAX BIT(11) +#define MPAMF_MBW_IDR_HAS_PBM BIT(12) + +#define MPAMF_MBW_IDR_HAS_PROP BIT(13) +#define MPAMF_MBW_IDR_WINDWR BIT(14) +#define MPAMF_MBW_IDR_BWPBM_WD GENMASK(28, 16) +#define MPAMF_MBW_IDR_BWPBM_WD_SHIFT 16 + +/* MPAMF_PARTID_NRW_IDR - MPAM features partid narrow ID register */ +#define MPAMF_PARTID_NRW_IDR_MASK (BIT(16) - 1) + +#define MSMON_CFG_CTL_TYPE GENMASK(7, 0) +#define MSMON_CFG_CTL_MATCH_PARTID BIT(16) +#define MSMON_CFG_CTL_MATCH_PMG BIT(17) +#define MSMON_CFG_CTL_SUBTYPE GENMASK(23, 20) +#define MSMON_CFG_CTL_SUBTYPE_SHIFT 20 +#define MSMON_CFG_CTL_OFLOW_FRZ BIT(24) +#define MSMON_CFG_CTL_OFLOW_INTR BIT(25) +#define MSMON_CFG_CTL_OFLOW_STATUS BIT(26) +#define MSMON_CFG_CTL_CAPT_RESET BIT(27) +#define MSMON_CFG_CTL_CAPT_EVNT GENMASK(30, 28) +#define MSMON_CFG_CTL_CAPT_EVNT_SHIFT 28 +#define MSMON_CFG_CTL_EN BIT(31) + +#define MPAMF_IDR_HAS_PRI_PART(v) (v & BIT(27)) + +/* MPAMF_MSMON_IDR - MPAM performance monitoring ID register */ +#define MPAMF_MSMON_IDR_MSMON_CSU BIT(16) +#define MPAMF_MSMON_IDR_MSMON_MBWU BIT(17) +#define MPAMF_MSMON_IDR_HAS_LOCAL_CAPT_EVNT BIT(31)

-#define MSMON_CFG_CSU_TYPE 0x43 +/* + * MSMON_CFG_MBWU_FLT - Memory system performance monitor configure memory + * bandwidth usage monitor filter register + */ +#define MSMON_CFG_MBWU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_MBWU_FLT_PMG_SHIFT 16 +#define MSMON_CFG_MBWU_FLT_PMG GENMASK(23, 16) #define MSMON_CFG_MBWU_TYPE 0x42

-/* [FIXME] hard code for hardlim */ -#define MBW_MAX_SET(v) (MBW_MAX_HARDLIM|((v) << (16 - BWA_WD))) -#define MBW_MAX_GET(v) (((v) & MBW_MAX_MASK) >> (16 - BWA_WD)) +/* + * MSMON_CFG_CSU_FLT - Memory system performance monitor configure cache storage + * usage monitor filter register + */ +#define MSMON_CFG_CSU_FLT_PARTID GENMASK(15, 0) +#define MSMON_CFG_CSU_FLT_PMG GENMASK(23, 16) +#define MSMON_CFG_CSU_FLT_PMG_SHIFT 16 +#define MSMON_CFG_CSU_TYPE 0x43

/* hard code for mbw_max max-percentage's cresponding masks */ #define MBA_MAX_WD 63u

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Now mpam sysprops have been probed, maximum support of partid and pmg should be exported to resctrl.

For MPAM, Processing elements (PEs) issue memory-system requests, PEs must implement the MPAMn_ELx registers and their behaviors to generate the PARTID and PMG fields of memory-system requests.

For resctrl, partid and pmg should be used to combined into a unique rmid for labeling each group, and partid for determining the maximum number of ctrl groups.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_device.c | 12 ++++++++++++ arch/arm64/kernel/mpam/mpam_internal.h | 3 +++ 2 files changed, 15 insertions(+)

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index e14d8edbafd6..a72d5f0251a9 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -676,3 +676,15 @@ void __init mpam_discovery_failed(void) } mutex_unlock(&mpam_devices_lock); } + +u16 mpam_sysprops_num_partid(void) +{ + /* At least one partid for system width */ + return mpam_sysprops.max_partid + 1; +} + +u16 mpam_sysprops_num_pmg(void) +{ + /* At least one pmg for system width */ + return mpam_sysprops.max_pmg + 1; +} diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 24b26dc0e3d0..2579d111d7df 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -48,4 +48,7 @@ static inline void mpam_clear_feature(enum mpam_device_features feat,

#define MPAM_ARCHITECTURE_V1 0x10

+u16 mpam_sysprops_num_partid(void); +u16 mpam_sysprops_num_pmg(void); + #endif

From: James Morse james.morse@arm.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

To make a decision about whether to expose an mpam class as a resctrl resource we need to know its overall supported features and properties.

Once we've probed all the devices, we can walk the tree and produced overall values. If bitmap properties are mismatched within a component we cannot support that bitmap.

[Wang ShaoBo: few version adaption changes]

Signed-off-by: James Morse james.morse@arm.com Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=96d7c0b933c0334abf9c45... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_device.c | 110 +++++++++++++++++++++++++++ arch/arm64/kernel/mpam/mpam_device.h | 15 ++++ 2 files changed, 125 insertions(+)

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 47b1c0b25d23..bb0864120c71 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -252,6 +252,112 @@ static int mpam_device_probe(struct mpam_device *dev) return 0; }

+/* + * If device doesn't match class feature/configuration, do the right thing. + * For 'num' properties we can just take the minimum. + * For properties where the mismatched unused bits would make a difference, we + * nobble the class feature, as we can't configure all the devices. + * e.g. The L3 cache is composed of two devices with 13 and 17 portion + * bitmaps respectively. + */ +static void __device_class_feature_mismatch(struct mpam_device *dev, + struct mpam_class *class) +{ + lockdep_assert_held(&mpam_devices_lock); /* we modify class */ + + if (class->cpbm_wd != dev->cpbm_wd) + mpam_clear_feature(mpam_feat_cpor_part, &class->features); + if (class->mbw_pbm_bits != dev->mbw_pbm_bits) + mpam_clear_feature(mpam_feat_mbw_part, &class->features); + + /* For num properties, take the minimum */ + if (class->num_partid != dev->num_partid) + class->num_partid = min(class->num_partid, dev->num_partid); + if (class->num_intpartid != dev->num_intpartid) + class->num_intpartid = min(class->num_intpartid, dev->num_intpartid); + if (class->num_pmg != dev->num_pmg) + class->num_pmg = min(class->num_pmg, dev->num_pmg); + if (class->num_csu_mon != dev->num_csu_mon) + class->num_csu_mon = min(class->num_csu_mon, dev->num_csu_mon); + if (class->num_mbwu_mon != dev->num_mbwu_mon) + class->num_mbwu_mon = min(class->num_mbwu_mon, + dev->num_mbwu_mon); + + /* bwa_wd is a count of bits, fewer bits means less precision */ + if (class->bwa_wd != dev->bwa_wd) + class->bwa_wd = min(class->bwa_wd, dev->bwa_wd); + + if (class->intpri_wd != dev->intpri_wd) + class->intpri_wd = min(class->intpri_wd, dev->intpri_wd); + if (class->dspri_wd != dev->dspri_wd) + class->dspri_wd = min(class->dspri_wd, dev->dspri_wd); + + /* {int,ds}pri may not have differing 0-low behaviour */ + if (mpam_has_feature(mpam_feat_intpri_part_0_low, class->features) != + mpam_has_feature(mpam_feat_intpri_part_0_low, dev->features)) + mpam_clear_feature(mpam_feat_intpri_part, &class->features); + if (mpam_has_feature(mpam_feat_dspri_part_0_low, class->features) != + mpam_has_feature(mpam_feat_dspri_part_0_low, dev->features)) + mpam_clear_feature(mpam_feat_dspri_part, &class->features); +} + +/* + * Squash common class=>component=>device->features down to the + * class->features + */ +static void mpam_enable_squash_features(void) +{ + unsigned long flags; + struct mpam_device *dev; + struct mpam_class *class; + struct mpam_component *comp; + + lockdep_assert_held(&mpam_devices_lock); + + list_for_each_entry(class, &mpam_classes, classes_list) { + /* + * Copy the first component's first device's properties and + * features to the class. __device_class_feature_mismatch() + * will fix them as appropriate. + * It is not possible to have a component with no devices. + */ + if (!list_empty(&class->components)) { + comp = list_first_entry_or_null(&class->components, + struct mpam_component, class_list); + if (WARN_ON(!comp)) + break; + + dev = list_first_entry_or_null(&comp->devices, + struct mpam_device, comp_list); + if (WARN_ON(!dev)) + break; + + spin_lock_irqsave(&dev->lock, flags); + class->features = dev->features; + class->cpbm_wd = dev->cpbm_wd; + class->mbw_pbm_bits = dev->mbw_pbm_bits; + class->bwa_wd = dev->bwa_wd; + class->intpri_wd = dev->intpri_wd; + class->dspri_wd = dev->dspri_wd; + class->num_partid = dev->num_partid; + class->num_intpartid = dev->num_intpartid; + class->num_pmg = dev->num_pmg; + class->num_csu_mon = dev->num_csu_mon; + class->num_mbwu_mon = dev->num_mbwu_mon; + spin_unlock_irqrestore(&dev->lock, flags); + } + + list_for_each_entry(comp, &class->components, class_list) { + list_for_each_entry(dev, &comp->devices, comp_list) { + spin_lock_irqsave(&dev->lock, flags); + __device_class_feature_mismatch(dev, class); + class->features &= dev->features; + spin_unlock_irqrestore(&dev->lock, flags); + } + } + } +} + /* * Enable mpam once all devices have been probed. * Scheduled by mpam_discovery_complete() once all devices have been created. @@ -278,6 +384,10 @@ static void __init mpam_enable(struct work_struct *work)

if (!all_devices_probed) return; + + mutex_lock(&mpam_devices_lock); + mpam_enable_squash_features(); + mutex_unlock(&mpam_devices_lock); }

static void mpam_failed(struct work_struct *work) diff --git a/arch/arm64/kernel/mpam/mpam_device.h b/arch/arm64/kernel/mpam/mpam_device.h index d49f5be41443..05f8431c71fc 100644 --- a/arch/arm64/kernel/mpam/mpam_device.h +++ b/arch/arm64/kernel/mpam/mpam_device.h @@ -98,10 +98,25 @@ struct mpam_class { u8 level; enum mpam_class_types type;

+ /* Once enabled, the common features */ + u32 features; + struct mutex lock;

/* member of mpam_classes */ struct list_head classes_list; + + u16 cmax_wd; + u16 cpbm_wd; + u16 mbw_pbm_bits; + u16 bwa_wd; + u16 intpri_wd; + u16 dspri_wd; + u16 num_partid; + u16 num_intpartid; + u16 num_pmg; + u16 num_csu_mon; + u16 num_mbwu_mon; };

/* System wide properties */

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Pick available classes and exported as well-known caches and MBA():

1) System with MPAM support may have a variety of control types at any point of their system layout. We can only expose certain types of control, and only if they exist at particular locations.

Start with the well-know caches. These have to be depth 2 or 3 and support MPAM's cache portion bitmap controls, with a number of portions fewer that resctrl's limit.

2) Picking which MPAM component we can expose via resctrl as MBA (Memory Bandwidth Allocation) is tricky. The ABI is a percentage of available bandwidth.

We can either do this with the memory bandwidth portion bitmaps, or the memory bandwidth maximum control. If both are implemented we prefer the bitmap.

We require and candidate for this resource type to support bandwidth monitoring too.

For 'MBA's position in the toplogy, we want it to be at, or after, the last level cache that is being exposed via resctrl. If there are multiple candidates, we prefer the one closer to the outermost exposed cache.

Signed-off-by: James Morse james.morse@arm.com Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=b6870246e25f8f6f9c7b27... Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=676d9aee8c2b27a17dd9cb... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/resctrl.h | 19 +++ arch/arm64/kernel/mpam/Makefile | 2 +- arch/arm64/kernel/mpam/mpam_device.c | 25 +++ arch/arm64/kernel/mpam/mpam_internal.h | 38 +++++ arch/arm64/kernel/mpam/mpam_mon.c | 3 +- arch/arm64/kernel/mpam/mpam_resctrl.c | 2 + arch/arm64/kernel/mpam/mpam_setup.c | 223 +++++++++++++++++++++++++ include/linux/resctrlfs.h | 2 + 8 files changed, 312 insertions(+), 2 deletions(-) create mode 100644 arch/arm64/kernel/mpam/mpam_setup.c

diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index fb5fa6c13843..258baefc2360 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -8,6 +8,25 @@ #define resctrl_alloc_capable rdt_alloc_capable #define resctrl_mon_capable rdt_mon_capable

+enum resctrl_resource_level { + RDT_RESOURCE_SMMU, + RDT_RESOURCE_L3, + RDT_RESOURCE_L2, + RDT_RESOURCE_MC, + + /* Must be the last */ + RDT_NUM_RESOURCES, +}; + +enum rdt_event_id { + QOS_L3_OCCUP_EVENT_ID = 0x01, + QOS_L3_MBM_TOTAL_EVENT_ID = 0x02, + QOS_L3_MBM_LOCAL_EVENT_ID = 0x03, + + /* Must be the last */ + RESCTRL_NUM_EVENT_IDS, +}; + static inline int alloc_mon_id(void) {

diff --git a/arch/arm64/kernel/mpam/Makefile b/arch/arm64/kernel/mpam/Makefile index f69a7018d42b..23fe2d5095fb 100644 --- a/arch/arm64/kernel/mpam/Makefile +++ b/arch/arm64/kernel/mpam/Makefile @@ -1,3 +1,3 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_MPAM) += mpam_resctrl.o mpam_mon.o \ - mpam_ctrlmon.o mpam_device.o + mpam_ctrlmon.o mpam_device.o mpam_setup.o diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index a4d0a92b9e46..b5362c08e2e3 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -33,6 +33,7 @@ #include <linux/cacheinfo.h> #include <asm/mpam.h> #include <asm/mpam_resource.h> +#include <asm/mpam.h>

#include "mpam_device.h"

@@ -71,6 +72,11 @@ static struct work_struct mpam_enable_work; static int mpam_broken; static struct work_struct mpam_failed_work;

+void mpam_class_list_lock_held(void) +{ + lockdep_assert_held(&mpam_devices_lock); +} + static inline u32 mpam_read_reg(struct mpam_device *dev, u16 reg) { WARN_ON_ONCE(reg > SZ_MPAM_DEVICE); @@ -411,6 +417,25 @@ static void __init mpam_enable(struct work_struct *work) if (err) return; mutex_unlock(&mpam_devices_lock); + + /* + * mpam_enable() runs in parallel with cpuhp callbacks bringing other + * CPUs online, as we eagerly schedule the work. To give resctrl a + * clean start, we make all cpus look offline, set resctrl_registered, + * and then bring them back. + */ + mutex_lock(&mpam_cpuhp_lock); + if (!mpam_cpuhp_state) { + /* We raced with mpam_failed(). */ + mutex_unlock(&mpam_cpuhp_lock); + return; + } + cpuhp_remove_state(mpam_cpuhp_state); + mutex_unlock(&mpam_cpuhp_lock); + + mutex_lock(&mpam_devices_lock); + err = mpam_resctrl_setup(); + mutex_unlock(&mpam_devices_lock); }

static void mpam_failed(struct work_struct *work) diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 53df10e84554..3115f934917d 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -2,8 +2,42 @@ #ifndef _ASM_ARM64_MPAM_INTERNAL_H #define _ASM_ARM64_MPAM_INTERNAL_H

+#include <linux/resctrlfs.h> + typedef u32 mpam_features_t;

+struct mpam_component; +struct rdt_domain; +struct mpam_class; + +extern bool rdt_alloc_capable; +extern bool rdt_mon_capable; + +extern struct list_head mpam_classes; + +struct mpam_resctrl_dom { + struct mpam_component *comp; + + struct rdt_domain resctrl_dom; +}; + +struct mpam_resctrl_res { + struct mpam_class *class; + + bool resctrl_mba_uses_mbw_part; + + struct resctrl_resource resctrl_res; +}; + +#define for_each_resctrl_exports(r) \ + for (r = &mpam_resctrl_exports[0]; \ + r < &mpam_resctrl_exports[0] + \ + ARRAY_SIZE(mpam_resctrl_exports); r++) + +#define for_each_supported_resctrl_exports(r) \ + for_each_resctrl_exports(r) \ + if (r->class) + /* * MPAM component config Structure */ @@ -82,4 +116,8 @@ static inline void mpam_clear_feature(enum mpam_device_features feat, u16 mpam_sysprops_num_partid(void); u16 mpam_sysprops_num_pmg(void);

+void mpam_class_list_lock_held(void); + +int mpam_resctrl_setup(void); + #endif diff --git a/arch/arm64/kernel/mpam/mpam_mon.c b/arch/arm64/kernel/mpam/mpam_mon.c index 18fa99df511f..cffafc8d7dde 100644 --- a/arch/arm64/kernel/mpam/mpam_mon.c +++ b/arch/arm64/kernel/mpam/mpam_mon.c @@ -26,9 +26,10 @@ #include <linux/module.h> #include <linux/slab.h> #include <linux/resctrlfs.h> - #include <asm/resctrl.h>

+#include "mpam_internal.h" + /* * Global boolean for rdt_monitor which is true if any * resource monitoring is enabled. diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index bd39af1d4854..65b532dab004 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -39,6 +39,8 @@ #include <asm/resctrl.h> #include <asm/io.h>

+#include "mpam_internal.h" + /* Mutex to protect rdtgroup access. */ DEFINE_MUTEX(resctrl_group_mutex);

diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c new file mode 100644 index 000000000000..3bd660ebf35e --- /dev/null +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -0,0 +1,223 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Common code for ARM v8 MPAM + * + * Copyright (C) 2020-2021 Huawei Technologies Co., Ltd + * + * Author: Wang Shaobo bobo.shaobowang@huawei.com + * + * Code was partially borrowed from http://www.linux-arm.org/ + * git?p=linux-jm.git;a=shortlog;h=refs/heads/mpam/snapshot/may. + * + * This program is free software; you can redistribute it and/or modify it + * under the terms and conditions of the GNU General Public License, + * version 2, as published by the Free Software Foundation. + * + * This program is distributed in the hope it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * More information about MPAM be found in the Arm Architecture Reference + * Manual. + * + * https://static.docs.arm.com/ddi0598/a/DDI0598_MPAM_supp_armv8a.pdf + */ + +#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt + +#include <linux/slab.h> +#include <linux/err.h> +#include <linux/resctrlfs.h> +#include <asm/resctrl.h> + +#include "mpam_device.h" +#include "mpam_internal.h" + +/* + * The classes we've picked to map to resctrl resources. + * Class pointer may be NULL. + */ +struct mpam_resctrl_res mpam_resctrl_exports[RDT_NUM_RESOURCES]; +struct mpam_resctrl_res mpam_resctrl_events[RESCTRL_NUM_EVENT_IDS]; + +/* Test whether we can export MPAM_CLASS_CACHE:{2,3}? */ +static void mpam_resctrl_pick_caches(void) +{ + struct mpam_class *class; + struct mpam_resctrl_res *res; + + mpam_class_list_lock_held(); + + list_for_each_entry(class, &mpam_classes, classes_list) { + if (class->type != MPAM_CLASS_CACHE) + continue; + + if (class->level != 2 && class->level != 3) + continue; + + if (!mpam_has_feature(mpam_feat_cpor_part, class->features) && + !mpam_has_feature(mpam_feat_msmon_csu, class->features)) + continue; + + if (!mpam_has_feature(mpam_feat_msmon_csu, class->features) && + mpam_sysprops_num_partid() <= 1) + continue; + + if (class->cpbm_wd > RESCTRL_MAX_CBM) + continue; + + if (class->level == 2) { + res = &mpam_resctrl_exports[RDT_RESOURCE_L2]; + res->resctrl_res.name = "L2"; + } else { + res = &mpam_resctrl_exports[RDT_RESOURCE_L3]; + res->resctrl_res.name = "L3"; + } + res->class = class; + } +} + +/* Find what we can can export as MBA */ +static void mpam_resctrl_pick_mba(void) +{ + u8 resctrl_llc; + struct mpam_class *class; + struct mpam_class *candidate = NULL; + + mpam_class_list_lock_held(); + + /* At least two partitions ... */ + if (mpam_sysprops_num_partid() <= 1) + return; + + if (mpam_resctrl_exports[RDT_RESOURCE_L3].class) + resctrl_llc = 3; + else if (mpam_resctrl_exports[RDT_RESOURCE_L2].class) + resctrl_llc = 2; + else + resctrl_llc = 0; + + list_for_each_entry(class, &mpam_classes, classes_list) { + if (class->type == MPAM_CLASS_UNKNOWN) + continue; + + if (class->level < resctrl_llc) + continue; + + /* + * Once we support MBM counters, we should require the MBA + * class to be at the same point in the hierarchy. Practically, + * this means the MBA class must support MBWU. Until then + * having something is better than nothing, but this may cause + * the MBA resource to disappear over a kernel update on a + * system that could support both, but not at the same time. + */ + + /* + * There are two ways we can generate delays for MBA, either + * with the mbw portion bitmap, or the mbw max control. + */ + if (!mpam_has_feature(mpam_feat_mbw_part, class->features) && + !mpam_has_feature(mpam_feat_mbw_max, class->features)) { + continue; + } + + /* pick the class 'closest' to resctrl_llc */ + if (!candidate || (class->level < candidate->level)) + candidate = class; + } + + if (candidate) + mpam_resctrl_exports[RDT_RESOURCE_MC].class = candidate; +} + +static void mpam_resctrl_pick_event_l3_occup(void) +{ + /* + * as the name suggests, resctrl can only use this if your cache is + * called 'l3'. + */ + struct mpam_resctrl_res *res = &mpam_resctrl_exports[RDT_RESOURCE_L3]; + + if (!res->class) + return; + + if (!mpam_has_feature(mpam_feat_msmon_csu, res->class->features)) + return; + + mpam_resctrl_events[QOS_L3_OCCUP_EVENT_ID] = *res; + + rdt_mon_capable = true; + res->resctrl_res.mon_capable = true; + res->resctrl_res.mon_capable = true; +} + +static void mpam_resctrl_pick_event_mbm_total(void) +{ + u64 num_counters; + struct mpam_resctrl_res *res; + + /* We prefer to measure mbm_total on whatever we used as MBA... */ + res = &mpam_resctrl_exports[RDT_RESOURCE_MC]; + if (!res->class) { + /* ... but if there isn't one, the L3 cache works */ + res = &mpam_resctrl_exports[RDT_RESOURCE_L3]; + if (!res->class) + return; + } + + /* + * to measure bandwidth in a resctrl like way, we need to leave a + * counter running all the time. As these are PMU-like, it is really + * unlikely we have enough... To be useful, we'd need at least one per + * closid. + */ + num_counters = mpam_sysprops_num_partid(); + + if (mpam_has_feature(mpam_feat_msmon_mbwu, res->class->features)) { + if (res->class->num_mbwu_mon >= num_counters) { + /* + * We don't support this use of monitors, let the + * world know this platform could make use of them + * if we did! + */ + } + } +} + +static void mpam_resctrl_pick_event_mbm_local(void) +{ + struct mpam_resctrl_res *res; + + res = &mpam_resctrl_exports[RDT_RESOURCE_MC]; + if (!res->class) + return; + + if (mpam_has_feature(mpam_feat_msmon_mbwu, res->class->features)) { + res->resctrl_res.mon_capable = true; + mpam_resctrl_events[QOS_L3_MBM_LOCAL_EVENT_ID] = *res; + } +} + +/* Called with the mpam classes lock held */ +int mpam_resctrl_setup(void) +{ + struct mpam_resctrl_res *res; + enum resctrl_resource_level level = 0; + + for_each_resctrl_exports(res) { + INIT_LIST_HEAD(&res->resctrl_res.domains); + res->resctrl_res.rid = level; + level++; + } + + mpam_resctrl_pick_caches(); + mpam_resctrl_pick_mba(); + + mpam_resctrl_pick_event_l3_occup(); + mpam_resctrl_pick_event_mbm_total(); + mpam_resctrl_pick_event_mbm_local(); + + return 0; +} diff --git a/include/linux/resctrlfs.h b/include/linux/resctrlfs.h index e192fd55c316..7271703431e2 100644 --- a/include/linux/resctrlfs.h +++ b/include/linux/resctrlfs.h @@ -94,4 +94,6 @@ void resctrl_group_kn_unlock(struct kernfs_node *kn);

void post_resctrl_mount (void);

+#define RESCTRL_MAX_CBM 32 + #endif /* _RESCTRLFS_H */

From: James Morse james.morse@arm.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

So far we probe devices as they become accessible. Each time we probe a new device, we eagerly schedule mpam_enable(). Once all the devices have been probed mpam_enable() will poke resctrl.

At this point, resctrl has an inconcistent view of which CPUs are online, as we only update the the classes that we picked, and we only did that after there were enough CPUs online to have probed all the devices.

Instead of having some complicated re-sync logic, unregister the cpuhp callbacks, register resctrl, then re-register them. As we know all the devices have been probed, no-one can find a new one to cause mpam_enable() to be re-scheduled.

[Wang ShaoBo: many version adaptation changes]

Signed-off-by: James Morse james.morse@arm.com Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=e81ea2f3ca64d8e46a0519... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_device.c | 22 +++++++++++++++++++++- arch/arm64/kernel/mpam/mpam_internal.h | 6 ++++++ arch/arm64/kernel/mpam/mpam_resctrl.c | 22 ++++++++++++++-------- arch/arm64/kernel/mpam/mpam_setup.c | 10 ++++++++++ 4 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index b5362c08e2e3..285f69244da3 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -53,6 +53,7 @@ LIST_HEAD(mpam_classes); static DEFINE_MUTEX(mpam_cpuhp_lock); static int mpam_cpuhp_state;

+static bool resctrl_registered;

static inline int mpam_cpu_online(unsigned int cpu); static inline int mpam_cpu_offline(unsigned int cpu); @@ -431,11 +432,24 @@ static void __init mpam_enable(struct work_struct *work) return; } cpuhp_remove_state(mpam_cpuhp_state); - mutex_unlock(&mpam_cpuhp_lock);

mutex_lock(&mpam_devices_lock); err = mpam_resctrl_setup(); + if (!err) { + err = mpam_resctrl_init(); + if (!err) + resctrl_registered = true; + } + if (err) + pr_err("Failed to setup/init resctrl\n"); mutex_unlock(&mpam_devices_lock); + + mpam_cpuhp_state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, + "mpam:online", mpam_cpu_online, + mpam_cpu_offline); + if (mpam_cpuhp_state <= 0) + pr_err("Failed to re-register 'dyn' cpuhp callbacks"); + mutex_unlock(&mpam_cpuhp_lock); }

static void mpam_failed(struct work_struct *work) @@ -878,6 +892,9 @@ static int mpam_cpu_online(unsigned int cpu) return err; }

+ if (resctrl_registered) + mpam_resctrl_cpu_online(cpu); + return 0; }

@@ -891,6 +908,9 @@ static int mpam_cpu_offline(unsigned int cpu)

mutex_unlock(&mpam_devices_lock);

+ if (resctrl_registered) + mpam_resctrl_cpu_offline(cpu); + return 0; }

diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index be4109c19de9..106a67ef687a 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -121,9 +121,15 @@ u16 mpam_sysprops_num_pmg(void);

void mpam_class_list_lock_held(void);

+int mpam_resctrl_cpu_online(unsigned int cpu); + +int mpam_resctrl_cpu_offline(unsigned int cpu); + int mpam_resctrl_setup(void);

struct raw_resctrl_resource * mpam_get_raw_resctrl_resource(u32 level);

+int __init mpam_resctrl_init(void); + #endif diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index e63c8409a65b..d15b6b827118 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -1399,8 +1399,6 @@ static int __init mpam_init(void) rdt_alloc_capable = 1; rdt_mon_capable = 1;

- mpam_init_padding(); - ret = mpam_nodes_init(); if (ret) { pr_err("internal error: bad cpu list\n"); @@ -1418,12 +1416,7 @@ static int __init mpam_init(void) goto out; }

- register_resctrl_specific_files(res_specific_files, ARRAY_SIZE(res_specific_files)); - - seq_buf_init(&last_cmd_status, last_cmd_status_buf, - sizeof(last_cmd_status_buf)); - - ret = resctrl_group_init(); + ret = mpam_resctrl_init(); if (ret) { cpuhp_remove_state(state); goto out; @@ -1444,6 +1437,19 @@ static int __init mpam_init(void) return ret; }

+int __init mpam_resctrl_init(void) +{ + mpam_init_padding(); + + register_resctrl_specific_files(res_specific_files, + ARRAY_SIZE(res_specific_files)); + + seq_buf_init(&last_cmd_status, last_cmd_status_buf, + sizeof(last_cmd_status_buf)); + + return resctrl_group_init(); +} + /* * __intel_rdt_sched_in() - Writes the task's CLOSid/RMID to IA32_PQR_MSR * diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index d84fd7f3aabd..94abcf46806f 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -41,6 +41,16 @@ struct mpam_resctrl_res mpam_resctrl_exports[RDT_NUM_RESOURCES]; struct mpam_resctrl_res mpam_resctrl_events[RESCTRL_NUM_EVENT_IDS];

+int mpam_resctrl_cpu_online(unsigned int cpu) +{ + return 0; +} + +int mpam_resctrl_cpu_offline(unsigned int cpu) +{ + return 0; +} + /* Test whether we can export MPAM_CLASS_CACHE:{2,3}? */ static void mpam_resctrl_pick_caches(void) {

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

So far we have accomplished resctrl resource initialization works, we need the way to get resource(like Cache/Memory) monitor data and apply corresponding configuration from resctrl input to MSCs.

Sometimes before applying configurations there should some necessary operations to be pre-operated, for instance intpartid narrowing, of which implementation is left for continuous jobs.

For monitoring, This add support to read MSMON_MBWU (QOS_L3_MBM_LOCAL _EVENT_ID supported only) and MSMON_CSU register.

Code related to applying configuration is borrowed from http:// www.linux-arm.org/git?p=linux-jm.git;a=shortlog;h=refs/heads/mpam/ snapshot/jun, besides, monitoring related code is borrowed from Shameer's (5cba077c "arm/mpam: Add MBWU monitor support"), please refer to link.

Link: https://github.com/hisilicon/kernel-dev/commit/5cba077c9c75efecff37017019a5d... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 9 + arch/arm64/kernel/mpam/mpam_device.c | 373 +++++++++++++++++++++++++ arch/arm64/kernel/mpam/mpam_internal.h | 46 +++ 3 files changed, 428 insertions(+)

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index 57ec024c2c50..10d727512d61 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -75,6 +75,11 @@ #define MBW_MAX_BWA_FRACT(w) GENMASK(w - 1, 0) #define MBW_MAX_SET(v) (MBW_MAX_HARDLIM|((v) << (16 - BWA_WD))) #define MBW_MAX_GET(v) (((v) & MBW_MAX_MASK) >> (16 - BWA_WD)) +#define MBW_MAX_SET_HDL(r) (r | MBW_MAX_HARDLIM) +/* MPAMCFG_MBW_PROP */ +#define MBW_PROP_HARDLIM BIT(31) +#define MBW_PROP_SET_HDL(r) (r | MBW_PROP_HARDLIM) +/* MPAMCFG_MBW_MAX */

#define MSMON_MATCH_PMG BIT(17) #define MSMON_MATCH_PARTID BIT(16) @@ -90,6 +95,10 @@ * Set MPAMCFG_PART_SEL internal bit */ #define PART_SEL_SET_INTERNAL(r) (r | BIT(16)) + +/* MPAM_ESR */ +#define MPAMF_ESR_ERRCODE_MASK ((BIT(4) - 1) << 24) + /* * Size of the memory mapped registers: 4K of feature page then 2 x 4K * bitmap registers diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 285f69244da3..6162b919d1f9 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -742,6 +742,7 @@ static void mpam_reset_device_config(struct mpam_component *comp, dev->mbw_pbm_bits); if (mpam_has_feature(mpam_feat_mbw_max, dev->features)) { mbw_max = MBW_MAX_SET(MBW_MAX_BWA_FRACT(dev->bwa_wd)); + mbw_max = MBW_MAX_SET_HDL(mbw_max); mpam_write_reg(dev, MPAMCFG_MBW_MAX, mbw_max); } if (mpam_has_feature(mpam_feat_mbw_min, dev->features)) { @@ -955,3 +956,375 @@ u16 mpam_sysprops_num_pmg(void) /* At least one pmg for system width */ return mpam_sysprops.max_pmg + 1; } + +static u32 mpam_device_read_csu_mon(struct mpam_device *dev, + struct sync_args *args) +{ + u16 mon; + u32 clt, flt, cur_clt, cur_flt; + + mon = args->mon; + + mpam_write_reg(dev, MSMON_CFG_MON_SEL, mon); + wmb(); /* subsequent writes must be applied to this mon */ + + /* + * We don't bother with capture as we don't expose a way of measuring + * multiple partid:pmg with a single capture. + */ + clt = MSMON_CFG_CTL_MATCH_PARTID | MSMON_CFG_CSU_TYPE; + if (args->match_pmg) + clt |= MSMON_CFG_CTL_MATCH_PMG; + flt = args->partid | + (args->pmg << MSMON_CFG_CSU_FLT_PMG_SHIFT); + + /* + * We read the existing configuration to avoid re-writing the same + * values. + */ + cur_flt = mpam_read_reg(dev, MSMON_CFG_CSU_FLT); + cur_clt = mpam_read_reg(dev, MSMON_CFG_CSU_CTL); + + if (cur_flt != flt || cur_clt != (clt | MSMON_CFG_CTL_EN)) { + mpam_write_reg(dev, MSMON_CFG_CSU_FLT, flt); + + /* + * Write the ctl with the enable bit cleared, reset the + * counter, then enable counter. + */ + mpam_write_reg(dev, MSMON_CFG_CSU_CTL, clt); + wmb(); + + mpam_write_reg(dev, MSMON_CSU, 0); + wmb(); + + clt |= MSMON_CFG_CTL_EN; + mpam_write_reg(dev, MSMON_CFG_CSU_CTL, clt); + wmb(); + } + + return mpam_read_reg(dev, MSMON_CSU); +} + +static u32 mpam_device_read_mbwu_mon(struct mpam_device *dev, + struct sync_args *args) +{ + u16 mon; + u32 clt, flt, cur_clt, cur_flt; + + mon = args->mon; + + mpam_write_reg(dev, MSMON_CFG_MON_SEL, mon); + wmb(); /* subsequent writes must be applied to this mon */ + + /* + * We don't bother with capture as we don't expose a way of measuring + * multiple partid:pmg with a single capture. + */ + clt = MSMON_CFG_CTL_MATCH_PARTID | MSMON_CFG_MBWU_TYPE; + if (args->match_pmg) + clt |= MSMON_CFG_CTL_MATCH_PMG; + flt = args->partid | + (args->pmg << MSMON_CFG_MBWU_FLT_PMG_SHIFT); + + /* + * We read the existing configuration to avoid re-writing the same + * values. + */ + cur_flt = mpam_read_reg(dev, MSMON_CFG_MBWU_FLT); + cur_clt = mpam_read_reg(dev, MSMON_CFG_MBWU_CTL); + + if (cur_flt != flt || cur_clt != (clt | MSMON_CFG_CTL_EN)) { + mpam_write_reg(dev, MSMON_CFG_MBWU_FLT, flt); + + /* + * Write the ctl with the enable bit cleared, reset the + * counter, then enable counter. + */ + mpam_write_reg(dev, MSMON_CFG_MBWU_CTL, clt); + wmb(); + + mpam_write_reg(dev, MSMON_MBWU, 0); + wmb(); + + clt |= MSMON_CFG_CTL_EN; + mpam_write_reg(dev, MSMON_CFG_MBWU_CTL, clt); + wmb(); + } + + return mpam_read_reg(dev, MSMON_MBWU); +} + +static int mpam_device_frob_mon(struct mpam_device *dev, + struct mpam_device_sync *ctx) +{ + struct sync_args *args = ctx->args; + u32 val; + + lockdep_assert_held(&dev->lock); + + if (mpam_broken) + return -EIO; + + if (!args) + return -EINVAL; + + if (args->eventid == QOS_L3_OCCUP_EVENT_ID && + mpam_has_feature(mpam_feat_msmon_csu, dev->features)) + val = mpam_device_read_csu_mon(dev, args); + else if (args->eventid == QOS_L3_MBM_LOCAL_EVENT_ID && + mpam_has_feature(mpam_feat_msmon_mbwu, dev->features)) + val = mpam_device_read_mbwu_mon(dev, args); + else + return -EOPNOTSUPP; + + if (val & MSMON___NRDY) + return -EBUSY; + + val = val & MSMON___VALUE; + atomic64_add(val, &ctx->mon_value); + return 0; +} + +static int mpam_device_narrow_map(struct mpam_device *dev, u32 partid, + u32 intpartid) +{ + return 0; +} + +static int mpam_device_config(struct mpam_device *dev, u32 partid, + struct mpam_config *cfg) +{ + int ret; + u16 cmax = GENMASK(dev->cmax_wd, 0); + u32 pri_val = 0; + u16 intpri, dspri, max_intpri, max_dspri; + u32 mbw_pbm, mbw_max; + + lockdep_assert_held(&dev->lock); + + if (!mpam_has_part_sel(dev->features)) + return -EINVAL; + + /* + * intpartid should be narrowed the first time, + * upstream(resctrl) keep this order + */ + if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) { + if (cfg && mpam_has_feature(mpam_feat_part_nrw, cfg->valid)) { + ret = mpam_device_narrow_map(dev, partid, + cfg->intpartid); + if (ret) + goto out; + partid = PART_SEL_SET_INTERNAL(cfg->intpartid); + } else { + partid = PART_SEL_SET_INTERNAL(cfg->intpartid); + } + } + + mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); + wmb(); /* subsequent writes must be applied to our new partid */ + + if (mpam_has_feature(mpam_feat_ccap_part, dev->features)) + mpam_write_reg(dev, MPAMCFG_CMAX, cmax); + + if (mpam_has_feature(mpam_feat_cpor_part, dev->features)) { + if (cfg && mpam_has_feature(mpam_feat_cpor_part, cfg->valid)) { + /* + * cpor_part being valid implies the bitmap fits in a + * single write. + */ + mpam_write_reg(dev, MPAMCFG_CPBM, cfg->cpbm); + } + } + + if (mpam_has_feature(mpam_feat_mbw_part, dev->features)) { + mbw_pbm = cfg->mbw_pbm; + if (cfg && mpam_has_feature(mpam_feat_mbw_part, cfg->valid)) { + if (!mpam_has_feature(mpam_feat_part_hdl, cfg->valid) || + (mpam_has_feature(mpam_feat_part_hdl, cfg->valid) && cfg->hdl)) + mbw_pbm = MBW_PROP_SET_HDL(cfg->mbw_pbm); + mpam_write_reg(dev, MPAMCFG_MBW_PBM, mbw_pbm); + } + } + + if (mpam_has_feature(mpam_feat_mbw_max, dev->features)) { + if (cfg && mpam_has_feature(mpam_feat_mbw_max, cfg->valid)) { + mbw_max = MBW_MAX_SET(cfg->mbw_max); + if (!mpam_has_feature(mpam_feat_part_hdl, cfg->valid) || + (mpam_has_feature(mpam_feat_part_hdl, cfg->valid) && cfg->hdl)) + mbw_max = MBW_MAX_SET_HDL(mbw_max); + mpam_write_reg(dev, MPAMCFG_MBW_MAX, mbw_max); + } + } + + if (mpam_has_feature(mpam_feat_intpri_part, dev->features) || + mpam_has_feature(mpam_feat_dspri_part, dev->features)) { + if (mpam_has_feature(mpam_feat_intpri_part, cfg->valid) && + mpam_has_feature(mpam_feat_intpri_part, dev->features)) { + max_intpri = GENMASK(dev->intpri_wd - 1, 0); + /* + * Each priority portion only occupys a bit, not only that + * we leave lowest priority, which may be not suitable when + * owning large dspri_wd or intpri_wd. + * dspri and intpri are from same input, so if one + * exceeds it's max width, set it to max priority. + */ + intpri = (cfg->intpri > max_intpri) ? max_intpri : cfg->intpri; + if (!mpam_has_feature(mpam_feat_intpri_part_0_low, + dev->features)) + intpri = GENMASK(dev->intpri_wd - 1, 0) & ~intpri; + pri_val |= intpri; + } + if (mpam_has_feature(mpam_feat_dspri_part, cfg->valid) && + mpam_has_feature(mpam_feat_dspri_part, dev->features)) { + max_dspri = GENMASK(dev->dspri_wd - 1, 0); + dspri = (cfg->dspri > max_dspri) ? max_dspri : cfg->dspri; + if (!mpam_has_feature(mpam_feat_dspri_part_0_low, + dev->features)) + dspri = GENMASK(dev->dspri_wd - 1, 0) & ~dspri; + pri_val |= (dspri << MPAMCFG_PRI_DSPRI_SHIFT); + } + + mpam_write_reg(dev, MPAMCFG_PRI, pri_val); + } + + /* + * complete the configuration before the cpu can + * use this partid + */ + mb(); + +out: + return ret; +} + +static void mpam_component_device_sync(void *__ctx) +{ + int err = 0; + u32 partid; + unsigned long flags; + struct mpam_device *dev; + struct mpam_device_sync *ctx = (struct mpam_device_sync *)__ctx; + struct mpam_component *comp = ctx->comp; + struct sync_args *args = ctx->args; + + list_for_each_entry(dev, &comp->devices, comp_list) { + if (cpumask_intersects(&dev->online_affinity, + &ctx->updated_on)) + continue; + + /* This device needs updating, can I reach it? */ + if (!cpumask_test_cpu(smp_processor_id(), + &dev->online_affinity)) + continue; + + /* Apply new configuration to this device */ + err = 0; + spin_lock_irqsave(&dev->lock, flags); + if (args) { + partid = args->partid; + if (ctx->config_mon) + err = mpam_device_frob_mon(dev, ctx); + else + err = mpam_device_config(dev, partid, + &comp->cfg[partid]); + } else { + mpam_reset_device(comp, dev); + } + spin_unlock_irqrestore(&dev->lock, flags); + if (err) + cmpxchg(&ctx->error, 0, err); + } + + cpumask_set_cpu(smp_processor_id(), &ctx->updated_on); +} + +/** + * in some cases/platforms the MSC register access is only possible with + * the associated CPUs. And need to check if those CPUS are online before + * accessing it. So we use those CPUs dev->online_affinity to apply config. + */ +static int do_device_sync(struct mpam_component *comp, + struct mpam_device_sync *sync_ctx) +{ + int cpu; + struct mpam_device *dev; + + lockdep_assert_cpus_held(); + + cpu = get_cpu(); + if (cpumask_test_cpu(cpu, &comp->fw_affinity)) + mpam_component_device_sync(sync_ctx); + put_cpu(); + + /* + * Find the set of other CPUs we need to run on to update + * this component + */ + list_for_each_entry(dev, &comp->devices, comp_list) { + if (sync_ctx->error) + break; + + if (cpumask_intersects(&dev->online_affinity, + &sync_ctx->updated_on)) + continue; + + /* + * This device needs the config applying, and hasn't been + * reachable by any cpu so far. + */ + cpu = cpumask_any(&dev->online_affinity); + smp_call_function_single(cpu, mpam_component_device_sync, + sync_ctx, 1); + } + + return sync_ctx->error; +} + +static inline void +mpam_device_sync_config_prepare(struct mpam_component *comp, + struct mpam_device_sync *sync_ctx, struct sync_args *args) +{ + sync_ctx->comp = comp; + sync_ctx->args = args; + sync_ctx->config_mon = false; + sync_ctx->error = 0; + cpumask_clear(&sync_ctx->updated_on); +} + +int mpam_component_config(struct mpam_component *comp, struct sync_args *args) +{ + struct mpam_device_sync sync_ctx; + + mpam_device_sync_config_prepare(comp, &sync_ctx, args); + + return do_device_sync(comp, &sync_ctx); +} + +static inline void +mpam_device_sync_mon_prepare(struct mpam_component *comp, + struct mpam_device_sync *sync_ctx, struct sync_args *args) +{ + sync_ctx->comp = comp; + sync_ctx->args = args; + sync_ctx->error = 0; + sync_ctx->config_mon = true; + cpumask_clear(&sync_ctx->updated_on); + atomic64_set(&sync_ctx->mon_value, 0); +} + +int mpam_component_mon(struct mpam_component *comp, + struct sync_args *args, u64 *result) +{ + int ret; + struct mpam_device_sync sync_ctx; + + mpam_device_sync_mon_prepare(comp, &sync_ctx, args); + + ret = do_device_sync(comp, &sync_ctx); + if (!ret && result) + *result = atomic64_read(&sync_ctx.mon_value); + + return ret; +} diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index ed411d7b0031..9f6af1e11777 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -3,6 +3,7 @@ #define _ASM_ARM64_MPAM_INTERNAL_H

#include <linux/resctrlfs.h> +#include <asm/resctrl.h>

typedef u32 mpam_features_t;

@@ -32,6 +33,31 @@ struct mpam_resctrl_res { struct resctrl_resource resctrl_res; };

+struct sync_args { + u8 domid; + u8 pmg; + u32 partid; + u32 mon; + bool match_pmg; + enum rdt_event_id eventid; + /*for reading msr*/ + u16 reg; +}; + +struct mpam_device_sync { + struct mpam_component *comp; + + struct sync_args *args; + + bool config_mon; + atomic64_t mon_value; + + struct cpumask updated_on; + + atomic64_t cfg_value; + int error; +}; + #define for_each_resctrl_exports(r) \ for (r = &mpam_resctrl_exports[0]; \ r < &mpam_resctrl_exports[0] + \ @@ -116,6 +142,26 @@ static inline void mpam_clear_feature(enum mpam_device_features feat,

#define MPAM_ARCHITECTURE_V1 0x10

+static inline bool mpam_has_part_sel(mpam_features_t supported) +{ + mpam_features_t mask = (1<<mpam_feat_ccap_part) | + (1<<mpam_feat_cpor_part) | (1<<mpam_feat_mbw_part) | + (1<<mpam_feat_mbw_max) | (1<<mpam_feat_intpri_part) | + (1<<mpam_feat_dspri_part); + /* or HAS_PARTID_NRW or HAS_IMPL_IDR */ + + return supported & mask; +} + +/** + * Reset component devices if args is NULL + */ +int mpam_component_config(struct mpam_component *comp, + struct sync_args *args); + +int mpam_component_mon(struct mpam_component *comp, + struct sync_args *args, u64 *result); + u16 mpam_sysprops_num_partid(void); u16 mpam_sysprops_num_pmg(void);

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

We used to make use of mpam_node structure to initialize MSCs and directly use resctrl_resource structure to store the MSCs' probing information before, it's a good choice until we support multiple MSC's node per domain, so far this new framework mpam_device->mpam_component->mpam_class has been constructed, we should make MPAM setup process compatible with this new framework firstly.

At present, we only parsed the base address to create the mpam devices, but did not deal with the interruption registration issue, which will be dealt with later.

We will continue to update discovery process from MPAM ACPI tlb according to latest MPAM ACPI spec.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 33 --- arch/arm64/include/asm/mpam_sched.h | 8 - arch/arm64/kernel/mpam/mpam_device.c | 2 +- arch/arm64/kernel/mpam/mpam_device.h | 8 +- arch/arm64/kernel/mpam/mpam_resctrl.c | 360 +------------------------ drivers/acpi/arm64/mpam.c | 48 +++- include/linux/arm_mpam.h | 67 +++++ 7 files changed, 106 insertions(+), 420 deletions(-) create mode 100644 include/linux/arm_mpam.h

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index 10d727512d61..aa5bbe390c19 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -207,37 +207,4 @@ /* hard code for mbw_max max-percentage's cresponding masks */ #define MBA_MAX_WD 63u

-/* - * emulate the mpam nodes - * These should be reported by ACPI MPAM Table. - */ - -struct mpam_node { - /* for label mpam_node instance*/ - u32 component_id; - /* MPAM node header */ - u8 type; /* MPAM_SMMU, MPAM_CACHE, MPAM_MC */ - u64 addr; - void __iomem *base; - struct cpumask cpu_mask; - u64 default_ctrl; - - /* for debug */ - char *cpus_list; - char *name; - struct list_head list; -}; - -int __init mpam_force_init(void); - -int __init mpam_nodes_discovery_start(void); - -void __init mpam_nodes_discovery_failed(void); - -int __init mpam_nodes_discovery_complete(void); - -int mpam_create_cache_node(u32 component_id, phys_addr_t hwpage_address); - -int mpam_create_memory_node(u32 component_id, phys_addr_t hwpage_address); - #endif /* _ASM_ARM64_MPAM_RESOURCE_H */ diff --git a/arch/arm64/include/asm/mpam_sched.h b/arch/arm64/include/asm/mpam_sched.h index 350296157087..08ed349b6efa 100644 --- a/arch/arm64/include/asm/mpam_sched.h +++ b/arch/arm64/include/asm/mpam_sched.h @@ -40,14 +40,6 @@ static inline void mpam_sched_in(void) __mpam_sched_in(); }

-enum mpam_enable_type { - enable_denied = 0, - enable_default, - enable_acpi, -}; - -extern enum mpam_enable_type __read_mostly mpam_enabled; - #else

static inline void mpam_sched_in(void) {} diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 6162b919d1f9..cb29d28d42be 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -31,7 +31,7 @@ #include <linux/types.h> #include <linux/cpu.h> #include <linux/cacheinfo.h> -#include <asm/mpam.h> +#include <linux/arm_mpam.h> #include <asm/mpam_resource.h> #include <asm/mpam.h>

diff --git a/arch/arm64/kernel/mpam/mpam_device.h b/arch/arm64/kernel/mpam/mpam_device.h index a98c34742374..3165d6b1a270 100644 --- a/arch/arm64/kernel/mpam/mpam_device.h +++ b/arch/arm64/kernel/mpam/mpam_device.h @@ -5,6 +5,7 @@ #include <linux/err.h> #include <linux/cpumask.h> #include <linux/types.h> +#include <linux/arm_mpam.h> #include "mpam_internal.h"

struct mpam_config; @@ -15,13 +16,6 @@ struct mpam_config; */ #define SZ_MPAM_DEVICE (3 * SZ_4K)

-enum mpam_class_types { - MPAM_CLASS_SMMU, - MPAM_CLASS_CACHE, /* Well known caches, e.g. L2 */ - MPAM_CLASS_MEMORY, /* Main memory */ - MPAM_CLASS_UNKNOWN, /* Everything else, e.g. TLBs etc */ -}; - /* * An mpam_device corresponds to an MSC, an interface to a component's cache * or bandwidth controls. It is associated with a set of CPUs, and a component. diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 298eb8332676..48b24c390413 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -33,6 +33,7 @@ #include <linux/sched/signal.h> #include <linux/sched/task.h> #include <linux/resctrlfs.h> +#include <linux/arm_mpam.h>

#include <asm/mpam_sched.h> #include <asm/mpam_resource.h> @@ -90,208 +91,6 @@ void mpam_resctrl_clear_default_cpu(unsigned int cpu) cpumask_clear_cpu(cpu, &resctrl_group_default.cpu_mask); }

-static inline void mpam_node_assign_val(struct mpam_node *n, - char *name, - u8 type, - phys_addr_t hwpage_address, - u32 component_id) -{ - n->name = name; - n->type = type; - n->addr = hwpage_address; - n->component_id = component_id; - n->cpus_list = "0"; -} - -#define MPAM_NODE_NAME_SIZE (10) - -struct mpam_node *mpam_nodes_ptr; - -static int __init mpam_init(void); - -static void mpam_nodes_unmap(void) -{ - struct mpam_node *n; - - list_for_each_entry(n, &mpam_nodes_ptr->list, list) { - if (n->base) { - iounmap(n->base); - n->base = NULL; - } - } -} - -static int mpam_nodes_init(void) -{ - int ret = 0; - struct mpam_node *n; - - list_for_each_entry(n, &mpam_nodes_ptr->list, list) { - ret |= cpulist_parse(n->cpus_list, &n->cpu_mask); - n->base = ioremap(n->addr, 0x10000); - if (!n->base) { - mpam_nodes_unmap(); - return -ENOMEM; - } - } - - return ret; -} - -static void mpam_nodes_destroy(void) -{ - struct mpam_node *n, *tmp; - - if (!mpam_nodes_ptr) - return; - - list_for_each_entry_safe(n, tmp, &mpam_nodes_ptr->list, list) { - kfree(n->name); - list_del(&n->list); - kfree(n); - } - - list_del(&mpam_nodes_ptr->list); - kfree(mpam_nodes_ptr); - mpam_nodes_ptr = NULL; -} - -int __init mpam_nodes_discovery_start(void) -{ - if (!mpam_enabled) - return -EINVAL; - - mpam_nodes_ptr = kzalloc(sizeof(struct mpam_node), GFP_KERNEL); - if (!mpam_nodes_ptr) - return -ENOMEM; - - INIT_LIST_HEAD(&mpam_nodes_ptr->list); - - return 0; -} - -void __init mpam_nodes_discovery_failed(void) -{ - mpam_nodes_destroy(); -} - -int __init mpam_nodes_discovery_complete(void) -{ - return mpam_init(); -} - -static inline int validate_mpam_node(int type, - int component_id) -{ - int ret = 0; - struct mpam_node *n; - - list_for_each_entry(n, &mpam_nodes_ptr->list, list) { - if (n->component_id == component_id && - n->type == type) { - ret = -EINVAL; - break; - } - } - - return ret; -} - -int mpam_create_cache_node(u32 component_id, - phys_addr_t hwpage_address) -{ - struct mpam_node *new; - char *name; - - if (validate_mpam_node(RDT_RESOURCE_L3, component_id)) - goto skip; - - new = kzalloc(sizeof(struct mpam_node), GFP_KERNEL); - if (!new) - return -ENOMEM; - - name = kzalloc(MPAM_NODE_NAME_SIZE, GFP_KERNEL); - if (!name) { - kfree(new); - return -ENOMEM; - } - snprintf(name, MPAM_NODE_NAME_SIZE, "%s%d", "L3TALL", component_id); - - mpam_node_assign_val(new, - name, - RDT_RESOURCE_L3, - hwpage_address, - component_id); - list_add_tail(&new->list, &mpam_nodes_ptr->list); - -skip: - return 0; -} - -int mpam_create_memory_node(u32 component_id, - phys_addr_t hwpage_address) -{ - struct mpam_node *new; - char *name; - - if (validate_mpam_node(RDT_RESOURCE_MC, component_id)) - goto skip; - - new = kzalloc(sizeof(struct mpam_node), GFP_KERNEL); - if (!new) - return -ENOMEM; - - name = kzalloc(MPAM_NODE_NAME_SIZE, GFP_KERNEL); - if (!name) { - kfree(new); - return -ENOMEM; - } - snprintf(name, MPAM_NODE_NAME_SIZE, "%s%d", "HHAALL", component_id); - - mpam_node_assign_val(new, - name, - RDT_RESOURCE_MC, - hwpage_address, - component_id); - list_add_tail(&new->list, &mpam_nodes_ptr->list); - -skip: - return 0; - -} - -int __init mpam_force_init(void) -{ - int ret; - - if (mpam_enabled != enable_default) - return 0; - - ret = mpam_nodes_discovery_start(); - if (ret) - return ret; - - ret |= mpam_create_cache_node(0, 0x000098b90000ULL); - ret |= mpam_create_cache_node(1, 0x000090b90000ULL); - ret |= mpam_create_cache_node(2, 0x200098b90000ULL); - ret |= mpam_create_cache_node(3, 0x200090b90000ULL); - ret |= mpam_create_memory_node(0, 0x000098c10000ULL); - ret |= mpam_create_memory_node(1, 0x000090c10000ULL); - ret |= mpam_create_memory_node(2, 0x200098c10000ULL); - ret |= mpam_create_memory_node(3, 0x200090c10000ULL); - if (ret) { - mpam_nodes_discovery_failed(); - pr_err("Failed to force create mpam node\n"); - return -EINVAL; - } - - ret = mpam_nodes_discovery_complete(); - if (!ret) - pr_info("Successfully init mpam by hardcode.\n"); - - return 1; -} - static void cat_wrmsr(struct rdt_domain *d, int partid); static void @@ -535,19 +334,6 @@ void closid_free(int closid) closid_free_map |= 1 << closid; }

-static int mpam_online_cpu(unsigned int cpu) -{ - return mpam_resctrl_set_default_cpu(cpu); -} - -/* remove related resource when cpu offline */ -static int mpam_offline_cpu(unsigned int cpu) -{ - mpam_resctrl_clear_default_cpu(cpu); - - return 0; -} - /* * Choose a width for the resource name and resource data based on the * resource that has widest name and cbm. @@ -1301,156 +1087,16 @@ struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, return NULL; }

-static void mpam_domains_destroy(struct resctrl_resource *r) -{ - struct list_head *pos, *q; - struct rdt_domain *d; - - list_for_each_safe(pos, q, &r->domains) { - d = list_entry(pos, struct rdt_domain, list); - list_del(pos); - if (d) { - kfree(d->ctrl_val); - kfree(d); - } - } -} - -static void mpam_domains_init(struct resctrl_resource *r) -{ - int id = 0; - struct mpam_node *n; - struct list_head *add_pos = NULL; - struct rdt_domain *d; - struct raw_resctrl_resource *rr = (struct raw_resctrl_resource *)r->res; - u32 val; - - list_for_each_entry(n, &mpam_nodes_ptr->list, list) { - if (r->rid != n->type) - continue; - - d = mpam_find_domain(r, id, &add_pos); - if (IS_ERR(d)) { - mpam_domains_destroy(r); - pr_warn("Could't find cache id %d\n", id); - return; - } - - if (!d) - d = kzalloc(sizeof(*d), GFP_KERNEL); - else - continue; - - if (!d) { - mpam_domains_destroy(r); - return; - } - - d->id = id; - d->base = n->base; - cpumask_copy(&d->cpu_mask, &n->cpu_mask); - rr->default_ctrl = n->default_ctrl; - - val = mpam_readl(d->base + MPAMF_IDR); - rr->num_partid = MPAMF_IDR_PARTID_MAX_GET(val) + 1; - rr->num_pmg = MPAMF_IDR_PMG_MAX_GET(val) + 1; - - r->mon_capable = MPAMF_IDR_HAS_MSMON(val); - r->mon_enabled = MPAMF_IDR_HAS_MSMON(val); - - if (r->rid == RDT_RESOURCE_L3) { - r->alloc_capable = MPAMF_IDR_HAS_CPOR_PART(val); - r->alloc_enabled = MPAMF_IDR_HAS_CPOR_PART(val); - - val = mpam_readl(d->base + MPAMF_CSUMON_IDR); - rr->num_mon = MPAMF_IDR_NUM_MON(val); - } else if (r->rid == RDT_RESOURCE_MC) { - r->alloc_capable = MPAMF_IDR_HAS_MBW_PART(val); - r->alloc_enabled = MPAMF_IDR_HAS_MBW_PART(val); - - val = mpam_readl(d->base + MPAMF_MBWUMON_IDR); - rr->num_mon = MPAMF_IDR_NUM_MON(val); - } - - r->alloc_capable = 1; - r->alloc_enabled = 1; - r->mon_capable = 1; - r->mon_enabled = 1; - - d->cpus_list = n->cpus_list; - - d->ctrl_val = kmalloc_array(rr->num_partid, sizeof(*d->ctrl_val), GFP_KERNEL); - if (!d->ctrl_val) { - kfree(d); - mpam_domains_destroy(r); - - return; - } - - if (add_pos) - list_add_tail(&d->list, add_pos); - - id++; - } -} - enum mpam_enable_type __read_mostly mpam_enabled; static int __init mpam_setup(char *str) { if (!strcmp(str, "=acpi")) - mpam_enabled = enable_acpi; - else - mpam_enabled = enable_default; + mpam_enabled = MPAM_ENABLE_ACPI; + return 1; } __setup("mpam", mpam_setup);

-static int __init mpam_init(void) -{ - struct resctrl_resource *r; - int state, ret; - - rdt_alloc_capable = 1; - rdt_mon_capable = 1; - - ret = mpam_nodes_init(); - if (ret) { - pr_err("internal error: bad cpu list\n"); - goto out; - } - - mpam_domains_init(&resctrl_resources_all[RDT_RESOURCE_L3]); - mpam_domains_init(&resctrl_resources_all[RDT_RESOURCE_MC]); - - state = cpuhp_setup_state(CPUHP_AP_ONLINE_DYN, - "arm64/mpam:online:", - mpam_online_cpu, mpam_offline_cpu); - if (state < 0) { - ret = state; - goto out; - } - - ret = mpam_resctrl_init(); - if (ret) { - cpuhp_remove_state(state); - goto out; - } - - for_each_resctrl_resource(r) { - if (r->alloc_capable) - pr_info("MPAM %s allocation detected\n", r->name); - } - - for_each_resctrl_resource(r) { - if (r->mon_capable) - pr_info("MPAM %s monitoring detected\n", r->name); - } - -out: - mpam_nodes_destroy(); - return ret; -} - int __init mpam_resctrl_init(void) { mpam_init_padding(); diff --git a/drivers/acpi/arm64/mpam.c b/drivers/acpi/arm64/mpam.c index 1f82dce33e07..10e4769d5227 100644 --- a/drivers/acpi/arm64/mpam.c +++ b/drivers/acpi/arm64/mpam.c @@ -30,7 +30,7 @@ #include <linux/cacheinfo.h> #include <linux/string.h> #include <linux/nodemask.h> -#include <asm/mpam_resource.h> +#include <linux/arm_mpam.h>

/** * acpi_mpam_label_cache_component_id() - Recursivly find @min_physid @@ -95,6 +95,7 @@ static int __init acpi_mpam_parse_memory(struct acpi_mpam_header *h) { int ret = 0; u32 component_id; + struct mpam_device *dev; struct acpi_mpam_node_memory *node = (struct acpi_mpam_node_memory *)h;

ret = acpi_mpam_label_memory_component_id(node->proximity_domain, @@ -104,9 +105,9 @@ static int __init acpi_mpam_parse_memory(struct acpi_mpam_header *h) return -EINVAL; }

- ret = mpam_create_memory_node(component_id, + dev = mpam_device_create_memory(component_id, node->header.base_address); - if (ret) { + if (IS_ERR(dev)) { pr_err("Failed to create memory node\n"); return -EINVAL; } @@ -118,7 +119,10 @@ static int __init acpi_mpam_parse_cache(struct acpi_mpam_header *h, struct acpi_table_header *pptt) { int ret = 0; + int level; u32 component_id; + struct mpam_device *dev; + struct cacheinfo *ci; struct acpi_pptt_cache *pptt_cache; struct acpi_pptt_processor *pptt_cpu_node; struct acpi_mpam_node_cache *node = (struct acpi_mpam_node_cache *)h; @@ -148,9 +152,28 @@ static int __init acpi_mpam_parse_cache(struct acpi_mpam_header *h, return -EINVAL; }

- ret = mpam_create_cache_node(component_id, - node->header.base_address); - if (ret) { + cpus_read_lock(); + ci = cacheinfo_shared_cpu_map_search(pptt_cpu_node); + if (!ci) { + pr_err_once("No CPU has cache with PPTT reference 0x%x", + node->PPTT_ref); + pr_err_once("All CPUs must be online to probe mpam.\n"); + cpus_read_unlock(); + return -ENODEV; + } + + level = ci->level; + ci = NULL; + cpus_read_unlock(); + + /* + * Possible we can get cpu-affinity in next MPAM ACPI version, + * now we have to set it to NULL and use default possible_aff- + * inity. + */ + dev = mpam_device_create_cache(level, component_id, NULL, + node->header.base_address); + if (IS_ERR(dev)) { pr_err("Failed to create cache node\n"); return -EINVAL; } @@ -166,7 +189,8 @@ static int __init acpi_mpam_parse_table(struct acpi_table_header *table, struct acpi_mpam_header *node_hdr; int ret = 0;

- ret = mpam_nodes_discovery_start(); + ret = mpam_discovery_start(); + if (ret) return ret;

@@ -200,9 +224,9 @@ static int __init acpi_mpam_parse_table(struct acpi_table_header *table,

if (ret) { pr_err("discovery failed: %d\n", ret); - mpam_nodes_discovery_failed(); + mpam_discovery_failed(); } else { - ret = mpam_nodes_discovery_complete(); + ret = mpam_discovery_complete(); if (!ret) pr_info("Successfully init mpam by ACPI.\n"); } @@ -219,11 +243,7 @@ int __init acpi_mpam_parse(void) if (!cpus_have_const_cap(ARM64_HAS_MPAM)) return 0;

- ret = mpam_force_init(); - if (ret) - return 0; - - if (acpi_disabled) + if (acpi_disabled || mpam_enabled != MPAM_ENABLE_ACPI) return 0;

status = acpi_get_table(ACPI_SIG_MPAM, 0, &mpam); diff --git a/include/linux/arm_mpam.h b/include/linux/arm_mpam.h new file mode 100644 index 000000000000..9a00c7984d91 --- /dev/null +++ b/include/linux/arm_mpam.h @@ -0,0 +1,67 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef __LINUX_ARM_MPAM_H +#define __LINUX_ARM_MPAM_H + +#include <linux/err.h> +#include <linux/cpumask.h> +#include <linux/types.h> + +struct mpam_device; + +enum mpam_class_types { + MPAM_CLASS_SMMU, + MPAM_CLASS_CACHE, /* Well known caches, e.g. L2 */ + MPAM_CLASS_MEMORY, /* Main memory */ + MPAM_CLASS_UNKNOWN, /* Everything else, e.g. TLBs etc */ +}; + +struct mpam_device * __init +__mpam_device_create(u8 level_idx, enum mpam_class_types type, + int component_id, const struct cpumask *fw_affinity, + phys_addr_t hwpage_address); + +/* + * Create a device for a well known cache, e.g. L2. + * @level_idx and @cache_id will be used to match the cache via cacheinfo + * to learn the component affinity and export domain/resources via resctrl. + * If the device can only be accessed from a smaller set of CPUs, provide + * this as @device_affinity, which can otherwise be NULL. + * + * Returns the new device, or an ERR_PTR(). + */ +static inline struct mpam_device * +mpam_device_create_cache(u8 level_idx, int cache_id, + const struct cpumask *device_affinity, + phys_addr_t hwpage_address) +{ + return __mpam_device_create(level_idx, MPAM_CLASS_CACHE, cache_id, + device_affinity, hwpage_address); +} +/* + * Create a device for a main memory. + * For NUMA systems @nid allows multiple components to be created, + * which will be exported as resctrl domains. MSCs for memory must + * be accessible from any cpu. + */ +static inline struct mpam_device * +mpam_device_create_memory(int nid, phys_addr_t hwpage_address) +{ + struct cpumask dev_affinity; + + cpumask_copy(&dev_affinity, cpumask_of_node(nid)); + + return __mpam_device_create(~0, MPAM_CLASS_MEMORY, nid, + &dev_affinity, hwpage_address); +} +int __init mpam_discovery_start(void); +int __init mpam_discovery_complete(void); +void __init mpam_discovery_failed(void); + +enum mpam_enable_type { + MPAM_ENABLE_DENIED = 0, + MPAM_ENABLE_ACPI, +}; + +extern enum mpam_enable_type mpam_enabled; + +#endif

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

So far partid and pmg has been probed by mpam classes, so do feature capabilities of each resources, for resctrl intermediate processing layer, those information placed in classes should be restored in internal resctrl resource structure.

For simplicity, capabilities related are unifiedly controlled by integer input, also should its' width probed from mpam classes. currently we only give priority width and hardlimit width fields in resctrl resource structure, in order to adapt more features, part of this would be re-covered.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 11 +++++++---- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 4 +--- arch/arm64/kernel/mpam/mpam_resctrl.c | 2 +- arch/arm64/kernel/mpam/mpam_setup.c | 19 ++++++++++++++++--- 4 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 97e259703933..a70133fff450 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -263,7 +263,6 @@ struct msr_param { * @name: Name to use in "schemata" file * @num_closid: Number of CLOSIDs available * @cache_level: Which cache level defines scope of this resource - * @default_ctrl: Specifies default cache cbm or memory B/W percent. * @msr_base: Base MSR address for CBMs * @msr_update: Function pointer to update QOS MSRs * @data_width: Character width of data when displaying @@ -278,15 +277,19 @@ struct msr_param { */

struct raw_resctrl_resource { - int num_partid; - u32 default_ctrl; + u16 num_partid; + u16 num_intpartid; + u16 num_pmg; + + u16 pri_wd; + u16 hdl_wd; + void (*msr_update) (struct rdt_domain *d, int partid); u64 (*msr_read) (struct rdt_domain *d, int partid); int data_width; const char *format_str; int (*parse_ctrlval) (char *buf, struct raw_resctrl_resource *r, struct rdt_domain *d); - int num_pmg; int num_mon; u64 (*mon_read) (struct rdt_domain *d, struct rdtgroup *g); int (*mon_write) (struct rdt_domain *d, struct rdtgroup *g, bool enable); diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 7de890c3932b..cf524e186c36 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -590,7 +590,6 @@ int resctrl_mkdir_ctrlmon_mondata(struct kernfs_node *parent_kn, int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) { struct resctrl_resource *r; - struct raw_resctrl_resource *rr; struct rdt_domain *d; int ret;

@@ -598,9 +597,8 @@ int rdtgroup_init_alloc(struct rdtgroup *rdtgrp) if (!r->alloc_enabled) continue;

- rr = (struct raw_resctrl_resource *)r->res; list_for_each_entry(d, &r->domains, list) { - d->new_ctrl = rr->default_ctrl; + d->new_ctrl = r->default_ctrl; d->have_new_ctrl = true; }

diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 48b24c390413..97129c4017cc 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -308,7 +308,7 @@ void closid_init(void) for_each_resctrl_resource(r) { if (r->alloc_enabled) { rr = r->res; - num_closid = min(num_closid, rr->num_partid); + num_closid = min(num_closid, (int)rr->num_partid); } } closid_free_map = BIT_MASK(num_closid) - 1; diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index 45639a1fecb9..265e700cd7c0 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -331,6 +331,7 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) { struct mpam_class *class = res->class; struct resctrl_resource *r = &res->resctrl_res; + struct raw_resctrl_resource *rr = NULL;

if (class == mpam_resctrl_exports[RDT_RESOURCE_SMMU].class) { return 0; @@ -339,7 +340,8 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->name = "MB"; r->fflags = RFTYPE_RES_MC; r->mbw.delay_linear = true; - r->res = mpam_get_raw_resctrl_resource(RDT_RESOURCE_MC); + rr = mpam_get_raw_resctrl_resource(RDT_RESOURCE_MC); + r->res = rr;

if (mpam_has_feature(mpam_feat_mbw_part, class->features)) { res->resctrl_mba_uses_mbw_part = true; @@ -382,7 +384,8 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mon_enabled = true; } else if (class == mpam_resctrl_exports[RDT_RESOURCE_L3].class) { r->rid = RDT_RESOURCE_L3; - r->res = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L3); + rr = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L3); + r->res = rr; r->fflags = RFTYPE_RES_CACHE; r->name = "L3";

@@ -413,7 +416,8 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res)

} else if (class == mpam_resctrl_exports[RDT_RESOURCE_L2].class) { r->rid = RDT_RESOURCE_L2; - r->res = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L2); + rr = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L2); + r->res = rr; r->fflags = RFTYPE_RES_CACHE; r->name = "L2";

@@ -442,6 +446,15 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mon_capable = false; }

+ if (rr && class) { + rr->num_partid = class->num_partid; + rr->num_intpartid = class->num_intpartid; + rr->num_pmg = class->num_pmg; + + rr->pri_wd = max(class->intpri_wd, class->dspri_wd); + rr->hdl_wd = 2; + } + return 0; }

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

CDP (Code and Data Prioritization) should also be supported, because separate code and data caches is an illusion resctrl creates using CDP, as James said, The L2 cache is controlled from one place regardless. Arm doesn't specify a cache topology. Platforms may have separate L2 code and data caches, with independent controls. On such a system we would need a unified L2 cache to be an illusion. To support Arm's MPAM, we need CDP to not be implicit between the architecture code and the file-system code. this add a series definitions independent of resctrl resources.

To do this we make the code/data/both 'type' a property of the configuration that comes from the schema. This lets us combined the illusionary cache. Eventually we separate the architecture code and file-system code's idea of closid, the architecture code can then provide helpers to map one to the other.

Part of this code is borrowed to James's, See links.

Link: http://www.linux-arm.org/git?p=linux-jm.git;a=commit;h=57a6f6204f72e2afc1167... Link: http://www.linux-arm.org/git?p=linux-jm.git;a=commit;h=1385052cce87a8aed5dc0... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 91 +++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 5aef534fb3df..3082ee4f68d4 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -120,6 +120,97 @@ extern bool rdt_mon_capable;

extern int max_name_width, max_data_width;

+enum resctrl_conf_type { + CDP_BOTH = 0, + CDP_CODE, + CDP_DATA, + CDP_NUM_CONF_TYPE, +}; + +static inline int conf_name_to_conf_type(char *name) +{ + enum resctrl_conf_type t; + + if (!strcmp(name, "L3CODE") || !strcmp(name, "L2CODE")) + t = CDP_CODE; + else if (!strcmp(name, "L3DATA") || !strcmp(name, "L2DATA")) + t = CDP_DATA; + else + t = CDP_BOTH; + return t; +} + +#define for_each_conf_type(t) \ + for (t = CDP_BOTH; t < CDP_NUM_CONF_TYPE; t++) + +typedef struct { u16 val; } hw_mpamid_t; + +#define hw_closid_t hw_mpamid_t +#define hw_monid_t hw_mpamid_t +#define hw_closid_val(__x) (__x.val) +#define hw_monid_val(__x) (__x.val) + +#define as_hw_t(__name, __x) \ + ((hw_##__name##id_t){(__x)}) +#define hw_val(__name, __x) \ + hw_##__name##id_val(__x) + +/** + * When cdp enabled, give (closid + 1) to Cache LxDATA. + */ +#define resctrl_cdp_map(__name, __closid, __type, __result) \ +do { \ + if (__type == CDP_CODE) \ + __result = as_hw_t(__name, __closid); \ + else if (__type == CDP_DATA) \ + __result = as_hw_t(__name, __closid + 1); \ + else \ + __result = as_hw_t(__name, __closid); \ +} while (0) + +static inline bool is_resctrl_cdp_enabled(void) +{ + return 0; +} + +#define hw_alloc_times_validate(__name, __times, __flag) \ +do { \ + __flag = is_resctrl_cdp_enabled(); \ + __times = flag ? 2 : 1; \ +} while (0) + + +/** + * struct resctrl_staged_config - parsed configuration to be applied + * @hw_closid: raw closid for this configuration, regardless of CDP + * @new_ctrl: new ctrl value to be loaded + * @have_new_ctrl: did user provide new_ctrl for this domain + * @new_ctrl_type: CDP property of the new ctrl + */ +struct resctrl_staged_config { + hw_closid_t hw_closid; + u32 new_ctrl; + bool have_new_ctrl; + enum resctrl_conf_type new_ctrl_type; +}; + +/* later move to resctrl common directory */ +#define RESCTRL_NAME_LEN 7 + +/** + * @list: Member of resctrl's schema list + * @name: Name visible in the schemata file + * @conf_type: Type of configuration, e.g. code/data/both + * @res: The rdt_resource for this entry + */ +struct resctrl_schema { + struct list_head list; + char name[RESCTRL_NAME_LEN]; + enum resctrl_conf_type conf_type; + struct resctrl_resource *res; +}; + + /* rdtgroup.flags */ #define RDT_DELETED BIT(0) #define RDT_CTRLMON BIT(1)

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Initialize schemata list when mount resctrl sysfs and destroy it when umount, each list node contains the value updated by schemata (in resctrl sysfs) row.

Partial code is borrowed from 250656171d95 ("x86/resctrl: Stop using Lx CODE/DATA resources"), as it illustrates:

Now that CDP enable/disable is global, and the closid offset correction is based on the configuration being applied, we are using different hw_closid slots in the ctrl array for CODE/DATA schema. This lets us merge them using the same Lx resource twice for CDP's CODE/DATA schema. This keeps the illusion of separate caches in the resctrl code.

When CDP is enabled for a cache, create two schema generating the names and setting the configuration type.

We can now remove the initialisation of of the illusionary hw_resources: 'cdp_capable' just requires setting a flag, resctrl knows what to do from there.

Link: http://www.linux-arm.org/git?p=linux-jm.git;a=commit;h=250656171d95dea079cc6... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/resctrl.h | 4 ++ arch/arm64/kernel/mpam/mpam_ctrlmon.c | 78 +++++++++++++++++++++++++++ fs/resctrlfs.c | 11 +++- 3 files changed, 92 insertions(+), 1 deletion(-)

diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index 2119204fa090..58cff955fbda 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -75,6 +75,10 @@ struct rdtgroup { struct mongroup mon; };

+int schemata_list_init(void); + +void schemata_list_destroy(void); + static inline int alloc_mon_id(void) {

diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index e0407dbc5152..914294476ff9 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -36,6 +36,84 @@ #include <asm/resctrl.h> #include "mpam_internal.h"

+/* schemata content list */ +LIST_HEAD(resctrl_all_schema); + +/* Init schemata content */ +static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) +{ + char *suffix = ""; + struct resctrl_schema *s; + + s = kzalloc(sizeof(*s), GFP_KERNEL); + if (!s) + return -ENOMEM; + + s->res = r; + s->conf_type = t; + + switch (t) { + case CDP_CODE: + suffix = "CODE"; + break; + case CDP_DATA: + suffix = "DATA"; + break; + case CDP_BOTH: + suffix = ""; + break; + default: + return -EINVAL; + } + + WARN_ON_ONCE(strlen(r->name) + strlen(suffix) + 1 > RESCTRL_NAME_LEN); + snprintf(s->name, sizeof(s->name), "%s%s", r->name, suffix); + + INIT_LIST_HEAD(&s->list); + list_add_tail(&s->list, &resctrl_all_schema); + + return 0; +} + +int schemata_list_init(void) +{ + int ret; + struct mpam_resctrl_res *res; + struct resctrl_resource *r; + + for_each_supported_resctrl_exports(res) { + r = &res->resctrl_res; + if (!r || !r->alloc_capable) + continue; + + if (r->cdp_enable) { + ret = add_schema(CDP_CODE, r); + ret |= add_schema(CDP_DATA, r); + } else { + ret = add_schema(CDP_BOTH, r); + } + if (ret) + break; + } + + return ret; +} + +/* + * During resctrl_kill_sb(), the mba_sc state is reset before + * schemata_list_destroy() is called: unconditionally try to free the + * array. + */ +void schemata_list_destroy(void) +{ + struct resctrl_schema *s, *tmp; + + list_for_each_entry_safe(s, tmp, &resctrl_all_schema, list) { + list_del(&s->list); + kfree(s); + } +} + /* * Check whether a cache bit mask is valid. The SDM says: * Please note that all (and only) contiguous '1' combinations diff --git a/fs/resctrlfs.c b/fs/resctrlfs.c index 345234b1eb93..650dc1709c32 100644 --- a/fs/resctrlfs.c +++ b/fs/resctrlfs.c @@ -332,7 +332,13 @@ static struct dentry *resctrl_mount(struct file_system_type *fs_type, dentry = ERR_PTR(ret); goto out_options; } - +#ifdef CONFIG_ARM64 + ret = schemata_list_init(); + if (ret) { + dentry = ERR_PTR(ret); + goto out_options; + } +#endif resctrl_id_init();

ret = resctrl_group_create_info_dir(resctrl_group_default.kn); @@ -502,6 +508,9 @@ static void resctrl_kill_sb(struct super_block *sb) mutex_lock(&resctrl_group_mutex);

resctrl_resource_reset(); +#ifdef CONFIG_ARM64 + schemata_list_destroy(); +#endif

rmdir_all_sub(); static_branch_disable_cpuslocked(&resctrl_alloc_enable_key);

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

schemata labels each row with hw_closid, which can be parsed into closid according to fixed rules (LxCODE and MBA are given closid, LxDATA is given to closid + 1), so the maximum number of rdtgroup can be created is also restricted by half if cdp enabled.

The length of Lx Cache domains displayed in schemata is compressed, this is because for specified hardware platform, domains of each resource may be too many to be easily operated for user interaction.

This patch also move parse_cbm() and parse_bw() to mpam_resctrl.c for clarity.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 7 +- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 237 +++++++++----------------- arch/arm64/kernel/mpam/mpam_resctrl.c | 118 ++++++++++++- 3 files changed, 202 insertions(+), 160 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 6a90cc9661a2..b0bab6153db8 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -251,6 +251,8 @@ struct rdt_domain { struct resctrl_staged_config staged_cfg[CDP_NUM_CONF_TYPE]; };

+#define RESCTRL_SHOW_DOM_MAX_NUM 8 + extern struct mutex resctrl_group_mutex;

extern struct resctrl_resource resctrl_resources_all[]; @@ -336,16 +338,13 @@ struct raw_resctrl_resource { int data_width; const char *format_str; int (*parse_ctrlval)(char *buf, struct raw_resctrl_resource *r, - struct rdt_domain *d); + struct resctrl_staged_config *cfg, hw_closid_t closid);

u16 num_mon; u64 (*mon_read)(struct rdt_domain *d, struct rdtgroup *g); int (*mon_write)(struct rdt_domain *d, struct rdtgroup *g, bool enable); };

-int parse_cbm(char *buf, struct raw_resctrl_resource *r, struct rdt_domain *d); -int parse_bw(char *buf, struct raw_resctrl_resource *r, struct rdt_domain *d); - union mon_data_bits { void *priv; struct { diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index e6c0b71b5da9..db627e4c270a 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -145,124 +145,21 @@ static int resctrl_group_update_domains(struct rdtgroup *rdtgrp, return 0; }

-/* - * Check whether a cache bit mask is valid. The SDM says: - * Please note that all (and only) contiguous '1' combinations - * are allowed (e.g. FFFFH, 0FF0H, 003CH, etc.). - * Additionally Haswell requires at least two bits set. - */ -static bool cbm_validate(char *buf, unsigned long *data, struct raw_resctrl_resource *r) -{ - u64 val; - int ret; - - ret = kstrtou64(buf, 16, &val); - if (ret) { - rdt_last_cmd_printf("non-hex character in mask %s\n", buf); - return false; - } - - *data = val; - return true; -} - -/* - * Read one cache bit mask (hex). Check that it is valid for the current - * resource type. - */ -int parse_cbm(char *buf, struct raw_resctrl_resource *r, struct rdt_domain *d) -{ - unsigned long data; - - if (d->have_new_ctrl) { - rdt_last_cmd_printf("duplicate domain %d\n", d->id); - return -EINVAL; - } - - if (!cbm_validate(buf, &data, r)) - return -EINVAL; - - d->new_ctrl = data; - d->have_new_ctrl = true; - - return 0; -} - -/* define bw_min as 5 percentage, that are 5% ~ 100% which cresponding masks: */ -static u32 bw_max_mask[20] = { - 3, /* 3/64: 5% */ - 6, /* 6/64: 10% */ - 10, /* 10/64: 15% */ - 13, /* 13/64: 20% */ - 16, /* 16/64: 25% */ - 19, /* ... */ - 22, - 26, - 29, - 32, - 35, - 38, - 42, - 45, - 48, - 51, - 54, - 58, - 61, - 63 /* 100% */ -}; - -static bool bw_validate(char *buf, unsigned long *data, struct raw_resctrl_resource *r) -{ - unsigned long bw; - int ret, idx; - - ret = kstrtoul(buf, 10, &bw); - if (ret) { - rdt_last_cmd_printf("non-hex character in mask %s\n", buf); - return false; - } - - bw = bw < 5 ? 5 : bw; - bw = bw > 100 ? 100 : bw; - - idx = roundup(bw, 5) / 5 - 1; - - *data = bw_max_mask[idx]; - return true; -} - -int parse_bw(char *buf, struct raw_resctrl_resource *r, struct rdt_domain *d) -{ - unsigned long data; - - if (d->have_new_ctrl) { - rdt_last_cmd_printf("duplicate domain %d\n", d->id); - return -EINVAL; - } - - if (!bw_validate(buf, &data, r)) - return -EINVAL; - - d->new_ctrl = data; - d->have_new_ctrl = true; - - return 0; -} - /* * For each domain in this resource we expect to find a series of: * id=mask * separated by ";". The "id" is in decimal, and must match one of * the "id"s for this resource. */ -static int parse_line(char *line, struct resctrl_resource *r) +static int parse_line(char *line, struct resctrl_resource *r, + enum resctrl_conf_type t, u32 closid) { - struct raw_resctrl_resource *rr = (struct raw_resctrl_resource *)r->res; - char *dom = NULL, *id; + struct raw_resctrl_resource *rr = r->res; + char *dom = NULL; + char *id; struct rdt_domain *d; unsigned long dom_id; - + hw_closid_t hw_closid;

next: if (!line || line[0] == '\0') @@ -276,7 +173,8 @@ static int parse_line(char *line, struct resctrl_resource *r) dom = strim(dom); list_for_each_entry(d, &r->domains, list) { if (d->id == dom_id) { - if (rr->parse_ctrlval(dom, (struct raw_resctrl_resource *)&r->res, d)) + resctrl_cdp_map(clos, closid, t, hw_closid); + if (rr->parse_ctrlval(dom, rr, &d->staged_cfg[t], hw_closid)) return -EINVAL; goto next; } @@ -284,40 +182,29 @@ static int parse_line(char *line, struct resctrl_resource *r) return -EINVAL; }

-static int update_domains(struct resctrl_resource *r, struct rdtgroup *g) +static int +resctrl_group_parse_schema_resource(char *resname, char *tok, u32 closid) { - struct raw_resctrl_resource *rr; - struct rdt_domain *d; - int partid = g->closid; - - rr = (struct raw_resctrl_resource *)r->res; - list_for_each_entry(d, &r->domains, list) { - if (d->have_new_ctrl && d->new_ctrl != d->ctrl_val[partid]) { - d->ctrl_val[partid] = d->new_ctrl; - rr->msr_update(r, d, NULL, partid); - } - } - - return 0; -} - -static int resctrl_group_parse_resource(char *resname, char *tok, int closid) -{ - struct mpam_resctrl_res *res; struct resctrl_resource *r; - struct raw_resctrl_resource *rr; + struct resctrl_schema *s; + enum resctrl_conf_type t;

- for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; + list_for_each_entry(s, &resctrl_all_schema, list) { + r = s->res; + + if (!r) + continue;

if (r->alloc_enabled) { - rr = (struct raw_resctrl_resource *)r->res; - if (!strcmp(resname, r->name) && closid < - mpam_sysprops_num_partid()) - return parse_line(tok, r); + if (!strcmp(resname, s->name) && + closid < mpam_sysprops_num_partid()) { + t = conf_name_to_conf_type(s->name); + return parse_line(tok, r, t, closid); + } } } rdt_last_cmd_printf("unknown/unsupported resource name '%s'\n", resname); + return -EINVAL; }

@@ -326,10 +213,13 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, { struct rdtgroup *rdtgrp; struct rdt_domain *dom; - struct mpam_resctrl_res *res; struct resctrl_resource *r; + struct mpam_resctrl_res *res; + enum resctrl_conf_type conf_type; + struct resctrl_staged_config *cfg; char *tok, *resname; - int closid, ret = 0; + u32 closid; + int ret = 0;

/* Valid input requires a trailing newline */ if (nbytes == 0 || buf[nbytes - 1] != '\n') @@ -341,6 +231,7 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, resctrl_group_kn_unlock(of->kn); return -ENOENT; } + rdt_last_cmd_clear();

closid = rdtgrp->closid; @@ -349,8 +240,13 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, r = &res->resctrl_res;

if (r->alloc_enabled) { - list_for_each_entry(dom, &r->domains, list) + list_for_each_entry(dom, &r->domains, list) { dom->have_new_ctrl = false; + for_each_conf_type(conf_type) { + cfg = &dom->staged_cfg[conf_type]; + cfg->have_new_ctrl = false; + } + } } }

@@ -366,16 +262,15 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, ret = -EINVAL; goto out; } - ret = resctrl_group_parse_resource(resname, tok, closid); + ret = resctrl_group_parse_schema_resource(resname, tok, closid); if (ret) goto out; }

for_each_supported_resctrl_exports(res) { r = &res->resctrl_res; - if (r->alloc_enabled) { - ret = update_domains(r, rdtgrp); + ret = resctrl_group_update_domains(rdtgrp, r); if (ret) goto out; } @@ -386,42 +281,73 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, return ret ?: nbytes; }

-static void show_doms(struct seq_file *s, struct resctrl_resource *r, int partid) +/** + * MPAM resources such as L2 may have too many domains for arm64, + * at this time we should rearrange this display for brevity and + * harmonious interaction. + * + * Before rearrangement: L2:0=ff;1=ff;2=fc;3=ff;4=f;....;255=ff + * After rearrangement: L2:S;2=fc;S;4=f;S + * Those continuous fully sharable domains will be combined into + * a single "S" simply. + */ +static void show_doms(struct seq_file *s, struct resctrl_resource *r, + char *schema_name, int partid) { - struct raw_resctrl_resource *rr = (struct raw_resctrl_resource *)r->res; + struct raw_resctrl_resource *rr = r->res; struct rdt_domain *dom; bool sep = false; + bool rg = false; + bool prev_auto_fill = false; + u32 reg_val; + + if (r->dom_num > RESCTRL_SHOW_DOM_MAX_NUM) + rg = true;

- seq_printf(s, "%*s:", max_name_width, r->name); + seq_printf(s, "%*s:", max_name_width, schema_name); list_for_each_entry(dom, &r->domains, list) { + reg_val = rr->msr_read(dom, partid); + + if (rg && reg_val == r->default_ctrl && + prev_auto_fill == true) + continue; + if (sep) seq_puts(s, ";"); - seq_printf(s, rr->format_str, dom->id, max_data_width, - rr->msr_read(dom, partid)); + if (rg && reg_val == r->default_ctrl) { + prev_auto_fill = true; + seq_puts(s, "S"); + } else { + seq_printf(s, rr->format_str, dom->id, + max_data_width, reg_val); + } sep = true; } seq_puts(s, "\n"); }

int resctrl_group_schemata_show(struct kernfs_open_file *of, - struct seq_file *s, void *v) + struct seq_file *s, void *v) { struct rdtgroup *rdtgrp; - struct mpam_resctrl_res *res; struct resctrl_resource *r; - struct raw_resctrl_resource *rr; + struct resctrl_schema *rs; int ret = 0; + hw_closid_t hw_closid; u32 partid;

rdtgrp = resctrl_group_kn_lock_live(of->kn); if (rdtgrp) { - partid = rdtgrp->closid; - for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; + list_for_each_entry(rs, &resctrl_all_schema, list) { + r = rs->res; + if (!r) + continue; if (r->alloc_enabled) { - rr = (struct raw_resctrl_resource *)r->res; + resctrl_cdp_map(clos, rdtgrp->closid, + rs->conf_type, hw_closid); + partid = hw_closid_val(hw_closid); if (partid < mpam_sysprops_num_partid()) - show_doms(s, r, partid); + show_doms(s, r, rs->name, partid); } } } else { @@ -707,6 +633,7 @@ int resctrl_mkdir_ctrlmon_mondata(struct kernfs_node *parent_kn, rdt_last_cmd_puts("kernfs subdir error\n"); free_mon(ret); } + return ret; }

diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 5e3f7c17a418..7461132aedfa 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -128,6 +128,11 @@ static inline bool is_mon_dyn(u32 mon) return (mon == mpam_resctrl_max_mon_num()) ? true : false; }

+static int parse_cbm(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, hw_closid_t hw_closid); +static int parse_bw(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, hw_closid_t hw_closid); + struct raw_resctrl_resource raw_resctrl_resources_all[] = { [RDT_RESOURCE_L3] = { .msr_update = common_wrmsr, @@ -164,6 +169,116 @@ mpam_get_raw_resctrl_resource(enum resctrl_resource_level level) return &raw_resctrl_resources_all[level]; }

+/* + * Check whether a cache bit mask is valid. for arm64 MPAM, + * it seems that there are no restrictions according to MPAM + * spec expect for requiring at least one bit. + */ +static bool cbm_validate(char *buf, unsigned long *data, + struct raw_resctrl_resource *r) +{ + u64 val; + int ret; + + ret = kstrtou64(buf, 16, &val); + if (ret) { + rdt_last_cmd_printf("non-hex character in mask %s\n", buf); + return false; + } + + *data = val; + return true; +} + +/* + * Read one cache bit mask (hex). Check that it is valid for the current + * resource type. + */ +static int +parse_cbm(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, hw_closid_t hw_closid) +{ + unsigned long data; + + if (cfg->have_new_ctrl) { + rdt_last_cmd_printf("duplicate domain\n"); + return -EINVAL; + } + + if (!cbm_validate(buf, &data, r)) + return -EINVAL; + + cfg->new_ctrl = data; + cfg->have_new_ctrl = true; + cfg->hw_closid = hw_closid; + + return 0; +} + +/* define bw_min as 5 percentage, that are 5% ~ 100% which cresponding masks: */ +static u32 bw_max_mask[20] = { + 3, /* 3/64: 5% */ + 6, /* 6/64: 10% */ + 10, /* 10/64: 15% */ + 13, /* 13/64: 20% */ + 16, /* 16/64: 25% */ + 19, /* ... */ + 22, + 26, + 29, + 32, + 35, + 38, + 42, + 45, + 48, + 51, + 54, + 58, + 61, + 63 /* 100% */ +}; + +static bool bw_validate(char *buf, unsigned long *data, + struct raw_resctrl_resource *r) +{ + unsigned long bw; + int ret; + + ret = kstrtoul(buf, 10, &bw); + if (ret) { + rdt_last_cmd_printf("non-hex character in mask %s\n", buf); + return false; + } + + bw = bw < 5 ? 5 : bw; + bw = bw > 100 ? 100 : bw; + *data = roundup(bw, 5); + + return true; +} + +static int +parse_bw(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, hw_closid_t hw_closid) +{ + unsigned long data; + + if (cfg->have_new_ctrl) { + rdt_last_cmd_printf("duplicate domain\n"); + return -EINVAL; + } + + if (!bw_validate(buf, &data, r)) + return -EINVAL; + + cfg->new_ctrl = data; + cfg->have_new_ctrl = true; + cfg->hw_closid = hw_closid; + + return 0; +} + static void common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, struct list_head *opt_list, int partid) @@ -1302,7 +1417,8 @@ mpam_update_from_resctrl_cfg(struct mpam_resctrl_res *res, mpam_set_feature(mpam_feat_mbw_part, &mpam_cfg->valid); } else { /* .. the number of fractions we can represent */ - mpam_cfg->mbw_max = resctrl_cfg; + mpam_cfg->mbw_max = bw_max_mask[(resctrl_cfg / 5 - 1) % + ARRAY_SIZE(bw_max_mask)];

mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); }

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

resctrl_resource_reset() would be excuted if resctrl sysfs umount, this help to reset all settings stored in related structures (such as mpam_cfg) and put MSCs back to default state.

This is similar to 6ab0b81f2c18 ("arm64/mpam: Fix unreset resources when mkdir ctrl group or umount resctrl") but using helpers from mpam devices module.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_device.c | 16 +++++++ arch/arm64/kernel/mpam/mpam_internal.h | 2 + arch/arm64/kernel/mpam/mpam_resctrl.c | 58 +++++++++++++++++--------- 3 files changed, 57 insertions(+), 19 deletions(-)

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 11cd7a5a6785..62ca0952cadc 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -1302,6 +1302,22 @@ int mpam_component_config(struct mpam_component *comp, struct sync_args *args) return do_device_sync(comp, &sync_ctx); }

+/* + * Reset every component, configuring every partid unrestricted. + */ +void mpam_reset_devices(void) +{ + struct mpam_class *class; + struct mpam_component *comp; + + mutex_lock(&mpam_devices_lock); + list_for_each_entry(class, &mpam_classes, classes_list) { + list_for_each_entry(comp, &class->components, class_list) + mpam_component_config(comp, NULL); + } + mutex_unlock(&mpam_devices_lock); +} + static inline void mpam_device_sync_mon_prepare(struct mpam_component *comp, struct mpam_device_sync *sync_ctx, struct sync_args *args) diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 8ab019fd8938..1a31d563bc41 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -159,6 +159,8 @@ static inline bool mpam_has_part_sel(mpam_features_t supported) int mpam_component_config(struct mpam_component *comp, struct sync_args *args);

+void mpam_reset_devices(void); + int mpam_component_mon(struct mpam_component *comp, struct sync_args *args, u64 *result);

diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 26e9b1cd3d6f..053656c2fcaf 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -526,25 +526,6 @@ void post_resctrl_mount(void) static_branch_enable_cpuslocked(&resctrl_enable_key); }

-static int reset_all_ctrls(struct resctrl_resource *r) -{ - return 0; -} - -void resctrl_resource_reset(void) -{ - struct mpam_resctrl_res *res; - struct resctrl_resource *r; - - /*Put everything back to default values. */ - for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; - - if (r->alloc_enabled) - reset_all_ctrls(r); - } -} - void release_rdtgroupfs_options(void) { } @@ -1498,6 +1479,45 @@ mpam_resctrl_update_component_cfg(struct resctrl_resource *r, mpam_update_from_resctrl_cfg(res, resctrl_cfg, mpam_cfg); }

+static void mpam_reset_cfg(struct mpam_resctrl_res *res, + struct mpam_resctrl_dom *dom, struct rdt_domain *d) + +{ + int i; + struct resctrl_resource *r = &res->resctrl_res; + + for (i = 0; i != mpam_sysprops_num_partid(); i++) { + mpam_update_from_resctrl_cfg(res, r->default_ctrl, + &dom->comp->cfg[i]); + d->ctrl_val[i] = r->default_ctrl; + } +} + +void resctrl_resource_reset(void) +{ + struct mpam_resctrl_res *res; + struct mpam_resctrl_dom *dom; + struct rdt_domain *d; + + for_each_supported_resctrl_exports(res) { + if (!res->resctrl_res.alloc_capable) + continue; + + list_for_each_entry(d, &res->resctrl_res.domains, list) { + dom = container_of(d, struct mpam_resctrl_dom, + resctrl_dom); + mpam_reset_cfg(res, dom, d); + } + } + + mpam_reset_devices(); + + /* + * reset CDP configuration used in recreating schema list nodes. + */ + resctrl_cdp_enabled = false; +} + u16 mpam_resctrl_max_mon_num(void) { struct mpam_resctrl_res *res;

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Resctrl ctrlmon write/read functions should be moved to mpam_ctrlmon.c to make code clear.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 6 ++ arch/arm64/kernel/mpam/mpam_ctrlmon.c | 109 +++++++++++++++++++++++++ arch/arm64/kernel/mpam/mpam_resctrl.c | 110 -------------------------- 3 files changed, 115 insertions(+), 110 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index d4cb6672f7b9..b81aec481784 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -355,6 +355,12 @@ union mon_data_bits { struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, struct list_head **pos);

+ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off); + +int resctrl_group_ctrlmon_show(struct kernfs_open_file *of, + struct seq_file *s, void *v); + int resctrl_group_alloc_mon(struct rdtgroup *grp);

void mon_init(void); diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index db627e4c270a..7915c252fe66 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -485,6 +485,115 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, return ret; }

+int resctrl_ctrlmon_enable(struct kernfs_node *parent_kn, + struct resctrl_group *prgrp, + struct kernfs_node **dest_kn) +{ + int ret; + + /* only for RDTCTRL_GROUP */ + if (prgrp->type == RDTMON_GROUP) + return 0; + + ret = alloc_mon(); + if (ret < 0) { + rdt_last_cmd_puts("out of monitors\n"); + pr_info("out of monitors: ret %d\n", ret); + return ret; + } + prgrp->mon.mon = ret; + prgrp->mon.rmid = 0; + + ret = mkdir_mondata_all(parent_kn, prgrp, dest_kn); + if (ret) { + rdt_last_cmd_puts("kernfs subdir error\n"); + free_mon(ret); + } + + return ret; +} + +void resctrl_ctrlmon_disable(struct kernfs_node *kn_mondata, + struct resctrl_group *prgrp) +{ + struct mpam_resctrl_res *r; + struct resctrl_resource *resctrl_res; + struct raw_resctrl_resource *rr; + struct rdt_domain *dom; + int mon = prgrp->mon.mon; + + /* only for RDTCTRL_GROUP */ + if (prgrp->type == RDTMON_GROUP) + return; + + for_each_resctrl_exports(r) { + resctrl_res = &r->resctrl_res; + + if (resctrl_res->mon_enabled) { + rr = (struct raw_resctrl_resource *)resctrl_res->res; + + list_for_each_entry(dom, &resctrl_res->domains, list) { + rr->mon_write(dom, prgrp, false); + } + } + } + + free_mon(mon); + kernfs_remove(kn_mondata); +} + +ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off) +{ + struct rdtgroup *rdtgrp; + int ret = 0; + int ctrlmon; + + if (kstrtoint(strstrip(buf), 0, &ctrlmon) || ctrlmon < 0) + return -EINVAL; + rdtgrp = resctrl_group_kn_lock_live(of->kn); + rdt_last_cmd_clear(); + + if (!rdtgrp) { + ret = -ENOENT; + goto unlock; + } + + if ((rdtgrp->flags & RDT_CTRLMON) && !ctrlmon) { + /* disable & remove mon_data dir */ + rdtgrp->flags &= ~RDT_CTRLMON; + resctrl_ctrlmon_disable(rdtgrp->mon.mon_data_kn, rdtgrp); + } else if (!(rdtgrp->flags & RDT_CTRLMON) && ctrlmon) { + ret = resctrl_ctrlmon_enable(rdtgrp->kn, rdtgrp, + &rdtgrp->mon.mon_data_kn); + if (!ret) + rdtgrp->flags |= RDT_CTRLMON; + } else { + ret = -ENOENT; + } + +unlock: + resctrl_group_kn_unlock(of->kn); + return ret ?: nbytes; +} + +int resctrl_group_ctrlmon_show(struct kernfs_open_file *of, + struct seq_file *s, void *v) +{ + struct rdtgroup *rdtgrp; + int ret = 0; + + rdtgrp = resctrl_group_kn_lock_live(of->kn); + if (rdtgrp) + seq_printf(s, "%d", !!(rdtgrp->flags & RDT_CTRLMON)); + else + ret = -ENOENT; + resctrl_group_kn_unlock(of->kn); + + return ret; +} + + static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, struct resctrl_resource *r, struct resctrl_group *prgrp) diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index d316c605b4b8..8c74d69c6826 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -1133,116 +1133,6 @@ static int resctrl_group_tasks_show(struct kernfs_open_file *of, return ret; }

-int resctrl_ctrlmon_enable(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp, - struct kernfs_node **dest_kn) -{ - int ret; - - /* only for RDTCTRL_GROUP */ - if (prgrp->type == RDTMON_GROUP) - return 0; - - ret = alloc_mon(); - if (ret < 0) { - rdt_last_cmd_puts("out of monitors\n"); - pr_info("out of monitors: ret %d\n", ret); - return ret; - } - prgrp->mon.mon = ret; - prgrp->mon.rmid = 0; - - ret = mkdir_mondata_all(parent_kn, prgrp, dest_kn); - if (ret) { - rdt_last_cmd_puts("kernfs subdir error\n"); - free_mon(ret); - } - - return ret; -} - -void resctrl_ctrlmon_disable(struct kernfs_node *kn_mondata, - struct resctrl_group *prgrp) -{ - struct mpam_resctrl_res *r; - struct resctrl_resource *resctrl_res; - struct raw_resctrl_resource *rr; - struct rdt_domain *dom; - int mon = prgrp->mon.mon; - - /* only for RDTCTRL_GROUP */ - if (prgrp->type == RDTMON_GROUP) - return; - - for_each_supported_resctrl_exports(r) { - resctrl_res = &r->resctrl_res; - - if (resctrl_res->mon_enabled) { - rr = (struct raw_resctrl_resource *)resctrl_res->res; - - list_for_each_entry(dom, &resctrl_res->domains, list) { - rr->mon_write(dom, prgrp, false); - } - } - } - - free_mon(mon); - kernfs_remove(kn_mondata); - - return; -} - -static ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, - char *buf, size_t nbytes, loff_t off) -{ - struct rdtgroup *rdtgrp; - int ret = 0; - int ctrlmon; - - if (kstrtoint(strstrip(buf), 0, &ctrlmon) || ctrlmon < 0) - return -EINVAL; - rdtgrp = resctrl_group_kn_lock_live(of->kn); - rdt_last_cmd_clear(); - - if (!rdtgrp) { - ret = -ENOENT; - goto unlock; - } - - if ((rdtgrp->flags & RDT_CTRLMON) && !ctrlmon) { - /* disable & remove mon_data dir */ - rdtgrp->flags &= ~RDT_CTRLMON; - resctrl_ctrlmon_disable(rdtgrp->mon.mon_data_kn, rdtgrp); - } else if (!(rdtgrp->flags & RDT_CTRLMON) && ctrlmon) { - ret = resctrl_ctrlmon_enable(rdtgrp->kn, rdtgrp, - &rdtgrp->mon.mon_data_kn); - if (!ret) - rdtgrp->flags |= RDT_CTRLMON; - } else { - ret = -ENOENT; - } - -unlock: - resctrl_group_kn_unlock(of->kn); - return ret ?: nbytes; -} - -static int resctrl_group_ctrlmon_show(struct kernfs_open_file *of, - struct seq_file *s, void *v) -{ - struct rdtgroup *rdtgrp; - int ret = 0; - - rdtgrp = resctrl_group_kn_lock_live(of->kn); - if (rdtgrp) - seq_printf(s, "%d", !!(rdtgrp->flags & RDT_CTRLMON)); - else - ret = -ENOENT; - resctrl_group_kn_unlock(of->kn); - - return ret; -} - /* rdtgroup information files for one cache resource. */ static struct rftype res_specific_files[] = { {

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

commit 43be0de7be8f ("arm64/mpam: Support cdp on allocating monitors") allows us to allocate two monitor once, we apply this two monitors to different monitor sysfile under mon_data directory according to its' closid, as following illustrates.

-- resctrl/ +-- schemata L3CODE:0=xx # closid L3DATA:1=xx # closid+1 MB:0=xx # closid +-- mon_data/ +-- mon_L3CODE_00 # monitor +-- mon_L3DATA_00 # monitor+1 +-- mon_MB_00 # monitor

When monitoring happens, we read the private data of each monitor sysfile which contains closid, monitor and pmg, this is used for obtaining monitor data.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 6 ++-- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 47 ++++++++++++++++++--------- arch/arm64/kernel/mpam/mpam_resctrl.c | 45 ++++++++++++++++--------- 3 files changed, 65 insertions(+), 33 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index b81aec481784..82b9887270a1 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -338,10 +338,11 @@ struct raw_resctrl_resource { struct resctrl_staged_config *cfg, hw_closid_t closid);

u16 num_mon; - u64 (*mon_read)(struct rdt_domain *d, struct rdtgroup *g); - int (*mon_write)(struct rdt_domain *d, struct rdtgroup *g, bool enable); + u64 (*mon_read)(struct rdt_domain *d, void *md_priv); + int (*mon_write)(struct rdt_domain *d, void *md_priv, bool enable); };

+/* 64bit arm64 specified */ union mon_data_bits { void *priv; struct { @@ -349,6 +350,7 @@ union mon_data_bits { u8 domid; u8 partid; u8 pmg; + u8 mon; } u; };

diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 7915c252fe66..c4c801d47e98 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -421,7 +421,7 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) goto out; }

- usage = rr->mon_read(d, rdtgrp); + usage = rr->mon_read(d, md.priv); seq_printf(m, "%llu\n", usage);

out: @@ -450,22 +450,31 @@ static int resctrl_group_kn_set_ugid(struct kernfs_node *kn) }

static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, - struct rdt_domain *d, - struct resctrl_resource *r, struct resctrl_group *prgrp) + struct rdt_domain *d, struct resctrl_schema *s, + struct resctrl_group *prgrp) + { - struct raw_resctrl_resource *rr = (struct raw_resctrl_resource *)r->res; + struct resctrl_resource *r; + struct raw_resctrl_resource *rr; + hw_closid_t hw_closid; + hw_monid_t hw_monid; union mon_data_bits md; struct kernfs_node *kn; char name[32]; int ret = 0;

+ r = s->res; + rr = r->res;

md.u.rid = r->rid; md.u.domid = d->id; - md.u.partid = prgrp->closid; + resctrl_cdp_map(clos, prgrp->closid, s->conf_type, hw_closid); + md.u.partid = hw_closid_val(hw_closid); + resctrl_cdp_map(mon, prgrp->mon.mon, s->conf_type, hw_monid); + md.u.mon = hw_monid_val(hw_monid); md.u.pmg = prgrp->mon.rmid;

- snprintf(name, sizeof(name), "mon_%s_%02d", r->name, d->id); + snprintf(name, sizeof(name), "mon_%s_%02d", s->name, d->id); kn = __kernfs_create_file(parent_kn, name, 0444, GLOBAL_ROOT_UID, GLOBAL_ROOT_GID, 0, &kf_mondata_ops, md.priv, NULL, NULL); @@ -480,7 +489,7 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, }

/* Could we remove the MATCH_* param ? */ - rr->mon_write(d, prgrp, true); + rr->mon_write(d, md.priv, true);

return ret; } @@ -595,14 +604,15 @@ int resctrl_group_ctrlmon_show(struct kernfs_open_file *of,

static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, - struct resctrl_resource *r, - struct resctrl_group *prgrp) + struct resctrl_schema *s, struct resctrl_group *prgrp) { + struct resctrl_resource *r; struct rdt_domain *dom; int ret;

+ r = s->res; list_for_each_entry(dom, &r->domains, list) { - ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp); + ret = mkdir_mondata_subdir(parent_kn, dom, s, prgrp); if (ret) return ret; } @@ -668,7 +678,7 @@ int mkdir_mondata_all(struct kernfs_node *parent_kn, struct resctrl_group *prgrp, struct kernfs_node **dest_kn) { - struct mpam_resctrl_res *res; + struct resctrl_schema *s; struct resctrl_resource *r; struct kernfs_node *kn; int ret; @@ -687,16 +697,23 @@ int mkdir_mondata_all(struct kernfs_node *parent_kn, * Create the subdirectories for each domain. Note that all events * in a domain like L3 are grouped into a resource whose domain is L3 */ - for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; + list_for_each_entry(s, &resctrl_all_schema, list) { + r = s->res;

if (r->mon_enabled) { /* HHA does not support monitor by pmg */ + struct raw_resctrl_resource *rr; + + rr = r->res; + /* + * num pmg of different resources varies, we just + * skip creating those unqualified ones. + */ if ((prgrp->type == RDTMON_GROUP) && - (r->rid == RDT_RESOURCE_MC)) + (prgrp->mon.rmid >= rr->num_pmg)) continue;

- ret = mkdir_mondata_subdir_alldom(kn, r, prgrp); + ret = mkdir_mondata_subdir_alldom(kn, s, prgrp); if (ret) goto out_destroy; } diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 8c74d69c6826..4b5c16adf15a 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -118,11 +118,10 @@ common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, static u64 cache_rdmsr(struct rdt_domain *d, int partid); static u64 mbw_rdmsr(struct rdt_domain *d, int partid);

-static u64 cache_rdmon(struct rdt_domain *d, struct rdtgroup *g); -static u64 mbw_rdmon(struct rdt_domain *d, struct rdtgroup *g); +static u64 cache_rdmon(struct rdt_domain *d, void *md_priv); +static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv);

-static int common_wrmon(struct rdt_domain *d, struct rdtgroup *g, - bool enable); +static int common_wrmon(struct rdt_domain *d, void *md_priv, bool enable);

static inline bool is_mon_dyn(u32 mon) { @@ -337,22 +336,27 @@ static u64 mbw_rdmsr(struct rdt_domain *d, int partid) * use pmg as monitor id * just use match_pardid only. */ -static u64 cache_rdmon(struct rdt_domain *d, struct rdtgroup *g) +static u64 cache_rdmon(struct rdt_domain *d, void *md_priv) { int err; u64 result; + union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom; - u32 mon = g->mon.mon; + u32 mon; unsigned long timeout;

+ md.priv = md_priv; + + mon = md.u.mon; + /* Indicates whether allocating a monitor dynamically*/ if (is_mon_dyn(mon)) mon = alloc_mon();

- args.partid = g->closid; + args.partid = md.u.partid; args.mon = mon; - args.pmg = g->mon.rmid; + args.pmg = md.u.pmg; args.match_pmg = true; args.eventid = QOS_L3_OCCUP_EVENT_ID;

@@ -382,21 +386,26 @@ static u64 cache_rdmon(struct rdt_domain *d, struct rdtgroup *g) * use pmg as monitor id * just use match_pardid only. */ -static u64 mbw_rdmon(struct rdt_domain *d, struct rdtgroup *g) +static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv) { int err; u64 result; + union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom; - u32 mon = g->mon.mon; + u32 mon; unsigned long timeout;

+ md.priv = md_priv; + + mon = md.u.mon; + if (is_mon_dyn(mon)) mon = alloc_mon();

- args.partid = g->closid; + args.partid = md.u.partid; args.mon = mon; - args.pmg = g->mon.rmid; + args.pmg = md.u.pmg; args.match_pmg = true; args.eventid = QOS_L3_MBM_LOCAL_EVENT_ID;

@@ -422,18 +431,22 @@ static u64 mbw_rdmon(struct rdt_domain *d, struct rdtgroup *g) return result; }

-static int common_wrmon(struct rdt_domain *d, struct rdtgroup *g, bool enable) +static int +common_wrmon(struct rdt_domain *d, void *md_priv, bool enable) { u64 result; + union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom;

if (!enable) return -EINVAL;

- args.partid = g->closid; - args.mon = g->mon.mon; - args.pmg = g->mon.rmid; + md.priv = md_priv; + args.partid = md.u.partid; + args.mon = md.u.mon; + args.pmg = md.u.pmg; + args.match_pmg = true;

dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom);

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

We redesign monitoring process for user, as following illustrates:

e.g. before rewriting: mount /sys/fs/resctrl && cd /sys/fs/resctrl mkdir p1 && cd p1 echo 1 > ctrlmon # this allocates a monitor resource for this group ... # associating task/cpu with this group grep . mon_data/* # get monitor data from mon_data directory e.g. after rewriting: mount /sys/fs/resctrl && cd /sys/fs/resctrl mkdir p1 && cd p1 # automically allocating a monitoring resource ... # associate task/cpu with this group grep . mon_data/* # directly get monitor data

ctrlmon is used for manually allocating a monitor resource for monitoring a specified group (labeled by partid and pmg), we delete ctrlmon because this action is redundant.

User should know which group has been allocated a available monitor resource and only this monitor resource is released then this monitor resource can be reallocated to a new group after, this action is redundant and unnecessary, as monitor resource is used only when monitoring process happens, so a relax monitor resource can be allocated to multiple groups and take effect when monitoring process happened.

But should some restrictions be known, a monitor resource for monitoring Cache-occupancy might be kept for a long time until it doesn't need to be use anymore, or below a threshold as like intel-RDT limbo list works, otherwise you may see that the monitoring result is very small beyond exception when you force switch one mon resource from one group to another.

We deliver a simple LRU mon resource allocation mechanism, but so far it just assign a monitor according to the order in which groups was created, this is incomplete and needs subsequent improvement.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 13 +- arch/arm64/include/asm/resctrl.h | 63 +------ arch/arm64/kernel/mpam/mpam_ctrlmon.c | 240 +------------------------- arch/arm64/kernel/mpam/mpam_mon.c | 75 ++++---- arch/arm64/kernel/mpam/mpam_resctrl.c | 79 ++++----- fs/resctrlfs.c | 198 ++++++++++++++++----- 6 files changed, 250 insertions(+), 418 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 52a334cce91a..ec2fc0f2eadb 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -167,7 +167,7 @@ do { \

bool is_resctrl_cdp_enabled(void);

-#define hw_alloc_times_validate(__name, __times, __flag) \ +#define hw_alloc_times_validate(__times, __flag) \ do { \ __flag = is_resctrl_cdp_enabled(); \ __times = flag ? 2 : 1; \ @@ -309,7 +309,7 @@ struct raw_resctrl_resource {

u16 num_mon; u64 (*mon_read)(struct rdt_domain *d, void *md_priv); - int (*mon_write)(struct rdt_domain *d, void *md_priv, bool enable); + int (*mon_write)(struct rdt_domain *d, void *md_priv); };

/* 64bit arm64 specified */ @@ -333,14 +333,11 @@ int resctrl_group_schemata_show(struct kernfs_open_file *of, struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, struct list_head **pos);

-ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, - char *buf, size_t nbytes, loff_t off); - -int resctrl_group_ctrlmon_show(struct kernfs_open_file *of, - struct seq_file *s, void *v); - int resctrl_group_alloc_mon(struct rdtgroup *grp);

u16 mpam_resctrl_max_mon_num(void);

+void pmg_init(void); +void mon_init(void); + #endif /* _ASM_ARM64_MPAM_H */ diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index 90b7683dd4dd..68e515ea8779 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -78,48 +78,14 @@ int schemata_list_init(void);

void schemata_list_destroy(void);

-int alloc_rmid(void); -void free_rmid(u32 rmid); +int resctrl_lru_request_mon(void);

-static inline int alloc_mon_id(void) -{ - - return alloc_rmid(); -} - -static inline void free_mon_id(u32 id) -{ - free_rmid(id); -} +int alloc_mon_id(void); +void free_mon_id(u32 id);

-int closid_init(void); -int closid_alloc(void); -void closid_free(int closid); -void pmg_init(void); - -static inline int resctrl_id_init(void) -{ - int ret; - - ret = closid_init(); - if (ret) - goto out; - - pmg_init(); - -out: - return ret; -} - -static inline int resctrl_id_alloc(void) -{ - return closid_alloc(); -} - -static inline void resctrl_id_free(int id) -{ - closid_free(id); -} +int resctrl_id_init(void); +int resctrl_id_alloc(void); +void resctrl_id_free(int id);

void update_cpu_closid_rmid(void *info); void update_closid_rmid(const struct cpumask *cpu_mask, struct resctrl_group *r); @@ -131,7 +97,6 @@ extern bool rdt_mon_capable;

/* rdtgroup.flags */ #define RDT_DELETED BIT(0) -#define RDT_CTRLMON BIT(1)

void rdt_last_cmd_clear(void); void rdt_last_cmd_puts(const char *s); @@ -142,9 +107,6 @@ extern struct mutex resctrl_group_mutex; void release_rdtgroupfs_options(void); int parse_rdtgroupfs_options(char *data);

-int alloc_mon(void); -void free_mon(u32 mon); - void resctrl_resource_reset(void);

#define release_resctrl_group_fs_options release_rdtgroupfs_options @@ -152,14 +114,6 @@ void resctrl_resource_reset(void);

int mpam_get_mon_config(struct resctrl_resource *r);

-int mkdir_mondata_all(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp, - struct kernfs_node **dest_kn); - -int -mongroup_create_dir(struct kernfs_node *parent_kn, struct resctrl_group *prgrp, - char *name, struct kernfs_node **dest_kn); - int resctrl_group_init_alloc(struct rdtgroup *rdtgrp);

static inline int __resctrl_group_show_options(struct seq_file *seq) @@ -167,9 +121,8 @@ static inline int __resctrl_group_show_options(struct seq_file *seq) return 0; }

-int resctrl_mkdir_ctrlmon_mondata(struct kernfs_node *parent_kn, - struct rdtgroup *prgrp, - struct kernfs_node **dest_kn); +int resctrl_mkdir_mondata_all_subdir(struct kernfs_node *parent_kn, + struct resctrl_group *prgrp);

struct resctrl_resource * mpam_resctrl_get_resource(enum resctrl_resource_level level); diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index b29800f83bb7..3547f3cdc26e 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -446,7 +446,7 @@ static int resctrl_group_kn_set_ugid(struct kernfs_node *kn) return kernfs_setattr(kn, &iattr); }

-static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, +static int resctrl_mkdir_mondata_dom(struct kernfs_node *parent_kn, struct rdt_domain *d, struct resctrl_schema *s, struct resctrl_group *prgrp)

@@ -486,121 +486,12 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn, }

/* Could we remove the MATCH_* param ? */ - rr->mon_write(d, md.priv, true); + rr->mon_write(d, md.priv);

return ret; }

-int resctrl_ctrlmon_enable(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp, - struct kernfs_node **dest_kn) -{ - int ret; - - /* only for RDTCTRL_GROUP */ - if (prgrp->type == RDTMON_GROUP) - return 0; - - ret = alloc_mon(); - if (ret < 0) { - rdt_last_cmd_puts("out of monitors\n"); - pr_info("out of monitors: ret %d\n", ret); - return ret; - } - prgrp->mon.mon = ret; - prgrp->mon.rmid = 0; - - ret = mkdir_mondata_all(parent_kn, prgrp, dest_kn); - if (ret) { - rdt_last_cmd_puts("kernfs subdir error\n"); - free_mon(ret); - } - - return ret; -} - -void resctrl_ctrlmon_disable(struct kernfs_node *kn_mondata, - struct resctrl_group *prgrp) -{ - struct mpam_resctrl_res *r; - struct resctrl_resource *resctrl_res; - struct raw_resctrl_resource *rr; - struct rdt_domain *dom; - int mon = prgrp->mon.mon; - - /* only for RDTCTRL_GROUP */ - if (prgrp->type == RDTMON_GROUP) - return; - - for_each_resctrl_exports(r) { - resctrl_res = &r->resctrl_res; - - if (resctrl_res->mon_enabled) { - rr = (struct raw_resctrl_resource *)resctrl_res->res; - - list_for_each_entry(dom, &resctrl_res->domains, list) { - rr->mon_write(dom, prgrp, false); - } - } - } - - free_mon(mon); - kernfs_remove(kn_mondata); -} - -ssize_t resctrl_group_ctrlmon_write(struct kernfs_open_file *of, - char *buf, size_t nbytes, loff_t off) -{ - struct rdtgroup *rdtgrp; - int ret = 0; - int ctrlmon; - - if (kstrtoint(strstrip(buf), 0, &ctrlmon) || ctrlmon < 0) - return -EINVAL; - rdtgrp = resctrl_group_kn_lock_live(of->kn); - rdt_last_cmd_clear(); - - if (!rdtgrp) { - ret = -ENOENT; - goto unlock; - } - - if ((rdtgrp->flags & RDT_CTRLMON) && !ctrlmon) { - /* disable & remove mon_data dir */ - rdtgrp->flags &= ~RDT_CTRLMON; - resctrl_ctrlmon_disable(rdtgrp->mon.mon_data_kn, rdtgrp); - } else if (!(rdtgrp->flags & RDT_CTRLMON) && ctrlmon) { - ret = resctrl_ctrlmon_enable(rdtgrp->kn, rdtgrp, - &rdtgrp->mon.mon_data_kn); - if (!ret) - rdtgrp->flags |= RDT_CTRLMON; - } else { - ret = -ENOENT; - } - -unlock: - resctrl_group_kn_unlock(of->kn); - return ret ?: nbytes; -} - -int resctrl_group_ctrlmon_show(struct kernfs_open_file *of, - struct seq_file *s, void *v) -{ - struct rdtgroup *rdtgrp; - int ret = 0; - - rdtgrp = resctrl_group_kn_lock_live(of->kn); - if (rdtgrp) - seq_printf(s, "%d", !!(rdtgrp->flags & RDT_CTRLMON)); - else - ret = -ENOENT; - resctrl_group_kn_unlock(of->kn); - - return ret; -} - - -static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, +static int resctrl_mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, struct resctrl_schema *s, struct resctrl_group *prgrp) { struct resctrl_resource *r; @@ -609,7 +500,7 @@ static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn,

r = s->res; list_for_each_entry(dom, &r->domains, list) { - ret = mkdir_mondata_subdir(parent_kn, dom, s, prgrp); + ret = resctrl_mkdir_mondata_dom(parent_kn, dom, s, prgrp); if (ret) return ret; } @@ -617,79 +508,13 @@ static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn, return 0; }

-int -mongroup_create_dir(struct kernfs_node *parent_kn, struct resctrl_group *prgrp, - char *name, struct kernfs_node **dest_kn) -{ - struct kernfs_node *kn; - int ret; - - /* create the directory */ - kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); - if (IS_ERR(kn)) { - pr_info("%s: create dir %s, error\n", __func__, name); - return PTR_ERR(kn); - } - - if (dest_kn) - *dest_kn = kn; - - /* - * This extra ref will be put in kernfs_remove() and guarantees - * that @rdtgrp->kn is always accessible. - */ - kernfs_get(kn); - - ret = resctrl_group_kn_set_ugid(kn); - if (ret) - goto out_destroy; - - kernfs_activate(kn); - - return 0; - -out_destroy: - kernfs_remove(kn); - return ret; -} - - -/* - * This creates a directory mon_data which contains the monitored data. - * - * mon_data has one directory for each domain whic are named - * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data - * with L3 domain looks as below: - * ./mon_data: - * mon_L3_00 - * mon_L3_01 - * mon_L3_02 - * ... - * - * Each domain directory has one file per event: - * ./mon_L3_00/: - * llc_occupancy - * - */ -int mkdir_mondata_all(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp, - struct kernfs_node **dest_kn) +int resctrl_mkdir_mondata_all_subdir(struct kernfs_node *parent_kn, + struct resctrl_group *prgrp) { struct resctrl_schema *s; struct resctrl_resource *r; - struct kernfs_node *kn; int ret;

- /* - * Create the mon_data directory first. - */ - ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); - if (ret) - return ret; - - if (dest_kn) - *dest_kn = kn; - /* * Create the subdirectories for each domain. Note that all events * in a domain like L3 are grouped into a resource whose domain is L3 @@ -701,61 +526,14 @@ int mkdir_mondata_all(struct kernfs_node *parent_kn, struct raw_resctrl_resource *rr;

rr = r->res; - /* - * num pmg of different resources varies, we just - * skip creating those unqualified ones. - */ - if ((prgrp->type == RDTMON_GROUP) && - (prgrp->mon.rmid >= rr->num_pmg)) - continue;

- ret = mkdir_mondata_subdir_alldom(kn, s, prgrp); + ret = resctrl_mkdir_mondata_subdir_alldom(parent_kn, + s, prgrp); if (ret) - goto out_destroy; + break; } }

- kernfs_activate(kn); - - return 0; - -out_destroy: - kernfs_remove(kn); - return ret; -} - -int resctrl_mkdir_ctrlmon_mondata(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp, - struct kernfs_node **dest_kn) -{ - int ret; - - /* disalbe monitor by default for mpam. */ - if (prgrp->type == RDTCTRL_GROUP) - return 0; - - ret = alloc_mon(); - if (ret < 0) { - rdt_last_cmd_puts("out of monitors\n"); - return ret; - } - prgrp->mon.mon = ret; - - ret = alloc_mon_id(); - if (ret < 0) { - rdt_last_cmd_puts("out of PMGs\n"); - free_mon(prgrp->mon.mon); - return ret; - } - - prgrp->mon.rmid = ret; - - ret = mkdir_mondata_all(parent_kn, prgrp, dest_kn); - if (ret) { - rdt_last_cmd_puts("kernfs subdir error\n"); - free_mon(ret); - } - return ret; }

diff --git a/arch/arm64/kernel/mpam/mpam_mon.c b/arch/arm64/kernel/mpam/mpam_mon.c index d1e2ea3c1be1..fbf92bb79ad2 100644 --- a/arch/arm64/kernel/mpam/mpam_mon.c +++ b/arch/arm64/kernel/mpam/mpam_mon.c @@ -35,7 +35,6 @@ bool rdt_mon_capable;

static int pmg_free_map; -void mon_init(void); void pmg_init(void) { u16 num_pmg = USHRT_MAX; @@ -50,15 +49,13 @@ void pmg_init(void) num_pmg = min(num_pmg, rr->num_pmg); }

- mon_init(); - pmg_free_map = BIT_MASK(num_pmg) - 1;

/* pmg 0 is always reserved for the default group */ pmg_free_map &= ~1; }

-int alloc_pmg(void) +static int alloc_pmg(void) { u32 pmg = ffs(pmg_free_map);

@@ -71,58 +68,66 @@ int alloc_pmg(void) return pmg; }

-void free_pmg(u32 pmg) +static void free_pmg(u32 pmg) { pmg_free_map |= 1 << pmg; }

-static int mon_free_map; +int alloc_mon_id(void) +{ + return alloc_pmg(); +} + +void free_mon_id(u32 id) +{ + free_pmg(id); +} + +/* + * A simple LRU monitor allocation machanism, each + * monitor free map occupies two section, one for + * allocation and another for recording. + */ +static int mon_free_map[2]; +static u8 alloc_idx, record_idx; + void mon_init(void) { int num_mon; + u32 times, flag;

num_mon = mpam_resctrl_max_mon_num();

- mon_free_map = BIT_MASK(num_mon) - 1; + hw_alloc_times_validate(times, flag); + /* for cdp on or off */ + num_mon = rounddown(num_mon, times); + + mon_free_map[0] = BIT_MASK(num_mon) - 1; + mon_free_map[1] = 0; + + alloc_idx = 0; + record_idx = 1; }

-int alloc_mon(void) +int resctrl_lru_request_mon(void) { u32 mon = 0; u32 times, flag;

- hw_alloc_times_validate(mon, times, flag); + hw_alloc_times_validate(times, flag);

- mon = ffs(mon_free_map); + mon = ffs(mon_free_map[alloc_idx]); if (mon == 0) return -ENOSPC;

mon--; - mon_free_map &= ~(GENMASK(mon, mon + times - 1)); + mon_free_map[alloc_idx] &= ~(GENMASK(mon + times - 1, mon)); + mon_free_map[record_idx] |= GENMASK(mon + times - 1, mon);

- return mon; -} - -void free_mon(u32 mon) -{ - u32 times, flag; - - hw_alloc_times_validate(mon, times, flag); - - mon_free_map |= GENMASK(mon, mon + times - 1); -} - -/* - * As of now the RMIDs allocation is global. - * However we keep track of which packages the RMIDs - * are used to optimize the limbo list management. - */ -int alloc_rmid(void) -{ - return alloc_pmg(); -} + if (!mon_free_map[alloc_idx]) { + alloc_idx = record_idx; + record_idx ^= 0x1; + }

-void free_rmid(u32 pmg) -{ - free_pmg(pmg); + return mon; } diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index e24ea70ff846..bd6bc36c8079 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -119,16 +119,7 @@ static u64 mbw_rdmsr(struct rdt_domain *d, int partid); static u64 cache_rdmon(struct rdt_domain *d, void *md_priv); static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv);

-static int common_wrmon(struct rdt_domain *d, void *md_priv, bool enable); - -static inline bool is_mon_dyn(u32 mon) -{ - /* - * if rdtgrp->mon.mon has been tagged with value (max_mon_num), - * allocating a monitor in dynamic when getting monitor data. - */ - return (mon == mpam_resctrl_max_mon_num()) ? true : false; -} +static int common_wrmon(struct rdt_domain *d, void *md_priv);

static int parse_cbm(char *buf, struct raw_resctrl_resource *r, struct resctrl_staged_config *cfg, hw_closid_t hw_closid); @@ -341,19 +332,12 @@ static u64 cache_rdmon(struct rdt_domain *d, void *md_priv) union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom; - u32 mon; unsigned long timeout;

md.priv = md_priv;

- mon = md.u.mon; - - /* Indicates whether allocating a monitor dynamically*/ - if (is_mon_dyn(mon)) - mon = alloc_mon(); - args.partid = md.u.partid; - args.mon = mon; + args.mon = md.u.mon; args.pmg = md.u.pmg; args.match_pmg = true; args.eventid = QOS_L3_OCCUP_EVENT_ID; @@ -375,9 +359,6 @@ static u64 cache_rdmon(struct rdt_domain *d, void *md_priv) WARN_ON(err && (err != -EBUSY)); } while (err == -EBUSY);

- if (is_mon_dyn(mon)) - free_mon(mon); - return result; } /* @@ -391,18 +372,12 @@ static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv) union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom; - u32 mon; unsigned long timeout;

md.priv = md_priv;

- mon = md.u.mon; - - if (is_mon_dyn(mon)) - mon = alloc_mon(); - args.partid = md.u.partid; - args.mon = mon; + args.mon = md.u.mon; args.pmg = md.u.pmg; args.match_pmg = true; args.eventid = QOS_L3_MBM_LOCAL_EVENT_ID; @@ -424,22 +399,17 @@ static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv) WARN_ON(err && (err != -EBUSY)); } while (err == -EBUSY);

- if (is_mon_dyn(mon)) - free_mon(mon); return result; }

static int -common_wrmon(struct rdt_domain *d, void *md_priv, bool enable) +common_wrmon(struct rdt_domain *d, void *md_priv) { u64 result; union mon_data_bits md; struct sync_args args; struct mpam_resctrl_dom *dom;

- if (!enable) - return -EINVAL; - md.priv = md_priv; args.partid = md.u.partid; args.mon = md.u.mon; @@ -488,7 +458,7 @@ int closid_init(void) num_closid = mpam_sysprops_num_partid(); num_closid = min(num_closid, RESCTRL_MAX_CLOSID);

- hw_alloc_times_validate(clos, times, flag); + hw_alloc_times_validate(times, flag);

if (flag) num_closid = rounddown(num_closid, 2); @@ -514,7 +484,7 @@ int closid_alloc(void) int pos; u32 times, flag;

- hw_alloc_times_validate(clos, times, flag); + hw_alloc_times_validate(times, flag);

pos = find_first_bit(closid_free_map, num_closid); if (pos == num_closid) @@ -529,7 +499,7 @@ void closid_free(int closid) { u32 times, flag;

- hw_alloc_times_validate(clos, times, flag); + hw_alloc_times_validate(times, flag); bitmap_set(closid_free_map, closid, times); }

@@ -1206,15 +1176,7 @@ static struct rftype res_specific_files[] = { .write = resctrl_group_schemata_write, .seq_show = resctrl_group_schemata_show, .fflags = RF_CTRL_BASE, - }, - { - .name = "ctrlmon", - .mode = 0644, - .kf_ops = &resctrl_group_kf_single_ops, - .write = resctrl_group_ctrlmon_write, - .seq_show = resctrl_group_ctrlmon_show, - .fflags = RF_CTRL_BASE, - }, + } };

struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, @@ -1474,3 +1436,28 @@ u16 mpam_resctrl_max_mon_num(void)

return mon_num; } + +int resctrl_id_init(void) +{ + int ret; + + ret = closid_init(); + if (ret) + goto out; + + pmg_init(); + mon_init(); + +out: + return ret; +} + +int resctrl_id_alloc(void) +{ + return closid_alloc(); +} + +void resctrl_id_free(int id) +{ + closid_free(id); +} diff --git a/fs/resctrlfs.c b/fs/resctrlfs.c index d2307b22281d..ed48a9f2a957 100644 --- a/fs/resctrlfs.c +++ b/fs/resctrlfs.c @@ -310,6 +310,138 @@ void resctrl_group_kn_unlock(struct kernfs_node *kn) } }

+static int +mongroup_create_dir(struct kernfs_node *parent_kn, struct resctrl_group *prgrp, + char *name, struct kernfs_node **dest_kn) +{ + struct kernfs_node *kn; + int ret; + + /* create the directory */ + kn = kernfs_create_dir(parent_kn, name, parent_kn->mode, prgrp); + if (IS_ERR(kn)) { + pr_info("%s: create dir %s, error\n", __func__, name); + return PTR_ERR(kn); + } + + if (dest_kn) + *dest_kn = kn; + + /* + * This extra ref will be put in kernfs_remove() and guarantees + * that @rdtgrp->kn is always accessible. + */ + kernfs_get(kn); + + ret = resctrl_group_kn_set_ugid(kn); + if (ret) + goto out_destroy; + + kernfs_activate(kn); + + return 0; + +out_destroy: + kernfs_remove(kn); + return ret; +} + +static void mkdir_mondata_all_prepare_clean(struct resctrl_group *prgrp) +{ + if (prgrp->type == RDTCTRL_GROUP) + return; + + if (prgrp->closid) + resctrl_id_free(prgrp->closid); + if (prgrp->mon.rmid) + free_mon_id(prgrp->mon.rmid); +} + +static int mkdir_mondata_all_prepare(struct resctrl_group *rdtgrp) +{ + int ret = 0; + int mon, mon_id, closid; + + mon = resctrl_lru_request_mon(); + if (mon < 0) { + rdt_last_cmd_puts("out of monitors\n"); + ret = -EINVAL; + goto out; + } + rdtgrp->mon.mon = mon; + + if (rdtgrp->type == RDTMON_GROUP) { + mon_id = alloc_mon_id(); + if (mon_id < 0) { + closid = resctrl_id_alloc(); + if (closid < 0) { + rdt_last_cmd_puts("out of closID\n"); + free_mon_id(mon_id); + ret = -EINVAL; + goto out; + } + rdtgrp->closid = closid; + rdtgrp->mon.rmid = 0; + } else { + struct resctrl_group *prgrp; + + prgrp = rdtgrp->mon.parent; + rdtgrp->closid = prgrp->closid; + rdtgrp->mon.rmid = mon_id; + } + } + +out: + return ret; +} + +/* + * This creates a directory mon_data which contains the monitored data. + * + * mon_data has one directory for each domain whic are named + * in the format mon_<domain_name>_<domain_id>. For ex: A mon_data + * with L3 domain looks as below: + * ./mon_data: + * mon_L3_00 + * mon_L3_01 + * mon_L3_02 + * ... + * + * Each domain directory has one file per event: + * ./mon_L3_00/: + * llc_occupancy + * + */ +static int mkdir_mondata_all(struct kernfs_node *parent_kn, + struct resctrl_group *prgrp, + struct kernfs_node **dest_kn) +{ + struct kernfs_node *kn; + int ret; + + /* + * Create the mon_data directory first. + */ + ret = mongroup_create_dir(parent_kn, prgrp, "mon_data", &kn); + if (ret) + return ret; + + if (dest_kn) + *dest_kn = kn; + + ret = resctrl_mkdir_mondata_all_subdir(kn, prgrp); + if (ret) + goto out_destroy; + + kernfs_activate(kn); + + return 0; + +out_destroy: + kernfs_remove(kn); + return ret; +} + static struct dentry *resctrl_mount(struct file_system_type *fs_type, int flags, const char *unused_dev_name, void *data) @@ -362,6 +494,11 @@ static struct dentry *resctrl_mount(struct file_system_type *fs_type, kernfs_get(kn_mongrp);

#ifndef CONFIG_ARM64 /* [FIXME] arch specific code */ + ret = mkdir_mondata_all_prepare(&resctrl_group_default); + if (ret < 0) { + dentry = ERR_PTR(ret); + goto out_mongrp; + } ret = mkdir_mondata_all(resctrl_group_default.kn, &resctrl_group_default, &kn_mondata); if (ret) { @@ -559,6 +696,17 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, *r = rdtgrp; rdtgrp->mon.parent = prdtgrp; rdtgrp->type = rtype; + + if (rdtgrp->type == RDTCTRL_GROUP) { + ret = resctrl_id_alloc(); + if (ret < 0) { + rdt_last_cmd_puts("out of CLOSIDs\n"); + goto out_unlock; + } + rdtgrp->closid = ret; + ret = 0; + } + INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list);

/* kernfs creates the directory for rdtgrp */ @@ -592,27 +740,16 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, }

if (resctrl_mon_capable) { -#ifdef CONFIG_ARM64 - ret = resctrl_mkdir_ctrlmon_mondata(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); - if (ret < 0) { - rdt_last_cmd_puts("out of monitors or PMGs\n"); - goto out_destroy; - } - -#else - ret = alloc_mon_id(); + ret = mkdir_mondata_all_prepare(rdtgrp); if (ret < 0) { - rdt_last_cmd_puts("out of RMIDs\n"); goto out_destroy; } - rdtgrp->mon.rmid = ret;

ret = mkdir_mondata_all(kn, rdtgrp, &rdtgrp->mon.mon_data_kn); if (ret) { rdt_last_cmd_puts("kernfs subdir error\n"); - goto out_idfree; + goto out_prepare_clean; } -#endif } kernfs_activate(kn);

@@ -621,10 +758,8 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, */ return 0;

-#ifndef CONFIG_ARM64 -out_idfree: - free_mon_id(rdtgrp->mon.rmid); -#endif +out_prepare_clean: + mkdir_mondata_all_prepare_clean(rdtgrp); out_destroy: kernfs_remove(rdtgrp->kn); out_free_rgrp: @@ -637,7 +772,6 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, static void mkdir_resctrl_prepare_clean(struct resctrl_group *rgrp) { kernfs_remove(rgrp->kn); - free_mon_id(rgrp->mon.rmid); kfree(rgrp); }

@@ -660,8 +794,6 @@ static int resctrl_group_mkdir_mon(struct kernfs_node *parent_kn, return ret;

prgrp = rdtgrp->mon.parent; - rdtgrp->closid = prgrp->closid; - /* * Add the rdtgrp to the list of rdtgrps the parent * ctrl_mon group has to track. @@ -682,7 +814,6 @@ static int resctrl_group_mkdir_ctrl_mon(struct kernfs_node *parent_kn, { struct resctrl_group *rdtgrp; struct kernfs_node *kn; - u32 closid; int ret;

ret = mkdir_resctrl_prepare(parent_kn, prgrp_kn, name, mode, RDTCTRL_GROUP, @@ -691,19 +822,10 @@ static int resctrl_group_mkdir_ctrl_mon(struct kernfs_node *parent_kn, return ret;

kn = rdtgrp->kn; - ret = resctrl_id_alloc(); - if (ret < 0) { - rdt_last_cmd_puts("out of CLOSIDs\n"); - goto out_common_fail; - } - closid = ret; - ret = 0; - - rdtgrp->closid = closid;

ret = resctrl_group_init_alloc(rdtgrp); if (ret < 0) - goto out_id_free; + goto out_common_fail;

list_add(&rdtgrp->resctrl_group_list, &resctrl_all_groups);

@@ -715,14 +837,13 @@ static int resctrl_group_mkdir_ctrl_mon(struct kernfs_node *parent_kn, ret = mongroup_create_dir(kn, NULL, "mon_groups", NULL); if (ret) { rdt_last_cmd_puts("kernfs subdir error\n"); - goto out_id_free; + goto out_list_del; } }

goto out_unlock;

-out_id_free: - resctrl_id_free(closid); +out_list_del: list_del(&rdtgrp->resctrl_group_list); out_common_fail: mkdir_resctrl_prepare_clean(rdtgrp); @@ -778,10 +899,6 @@ static void resctrl_group_rm_mon(struct resctrl_group *rdtgrp, struct resctrl_group *prdtgrp = rdtgrp->mon.parent; int cpu;

-#ifdef CONFIG_ARM64 /* [FIXME] arch specific code */ - free_mon(rdtgrp->mon.mon); -#endif - /* Give any tasks back to the parent group */ resctrl_move_group_tasks(rdtgrp, prdtgrp, tmpmask);

@@ -859,11 +976,6 @@ static void resctrl_group_rm_ctrl(struct resctrl_group *rdtgrp, cpumask_var_t tm static int resctrl_group_rmdir_ctrl(struct kernfs_node *kn, struct resctrl_group *rdtgrp, cpumask_var_t tmpmask) { -#ifdef CONFIG_ARM64 /* [FIXME] arch specific code */ - if (rdtgrp->flags & RDT_CTRLMON) - return -EPERM; -#endif - resctrl_group_rm_ctrl(rdtgrp, tmpmask);

/*

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

According to Arm MPAM spec definition, register MPAMCFG_PART_SEL's high 16 bit should be set to 0 and MPAMCFG_INTPARTID's high 16 bit should be set to 1 when establishing intpartid association, and we should use intpartid in MPAMCFG_PART_SEL instead of reqpartid as long as intpartid narrowing is implemented.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 4 +++ arch/arm64/kernel/mpam/mpam_device.c | 35 +++++++++++++++----------- 2 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index aa5bbe390c19..4c042eb2da20 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -91,6 +91,10 @@ #define MSMON_CFG_CSU_TYPE 0x43 #define MSMON_CFG_MBWU_TYPE 0x42

+/* + * Set MPAMCFG_INTPARTID internal bit + */ +#define MPAMCFG_INTPARTID_INTERNAL BIT(16) /* * Set MPAMCFG_PART_SEL internal bit */ diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 356362ecdc79..327540e1f2eb 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -1086,16 +1086,29 @@ static int mpam_device_frob_mon(struct mpam_device *dev, return 0; }

-static int mpam_device_narrow_map(struct mpam_device *dev, u32 partid, +static void mpam_device_narrow_map(struct mpam_device *dev, u32 partid, u32 intpartid) { - return 0; + int cur_intpartid; + + lockdep_assert_held(&dev->lock); + + mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); + wmb(); /* subsequent writes must be applied to our new partid */ + + cur_intpartid = mpam_read_reg(dev, MPAMCFG_INTPARTID); + /* write association, this need set 16 bit to 1 */ + intpartid = intpartid | MPAMCFG_INTPARTID_INTERNAL; + /* reqpartid has already been associated to this intpartid */ + if (cur_intpartid == intpartid) + return; + + mpam_write_reg(dev, MPAMCFG_INTPARTID, intpartid); }

static int mpam_device_config(struct mpam_device *dev, u32 partid, struct mpam_config *cfg) { - int ret; u16 cmax = GENMASK(dev->cmax_wd, 0); u32 pri_val = 0; u16 intpri, dspri, max_intpri, max_dspri; @@ -1111,15 +1124,10 @@ static int mpam_device_config(struct mpam_device *dev, u32 partid, * upstream(resctrl) keep this order */ if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) { - if (cfg && mpam_has_feature(mpam_feat_part_nrw, cfg->valid)) { - ret = mpam_device_narrow_map(dev, partid, - cfg->intpartid); - if (ret) - goto out; - partid = PART_SEL_SET_INTERNAL(cfg->intpartid); - } else { - partid = PART_SEL_SET_INTERNAL(cfg->intpartid); - } + if (cfg && mpam_has_feature(mpam_feat_part_nrw, cfg->valid)) + mpam_device_narrow_map(dev, partid, cfg->intpartid); + /* intpartid success, set 16 bit to 1*/ + partid = PART_SEL_SET_INTERNAL(cfg->intpartid); }

mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); @@ -1195,8 +1203,7 @@ static int mpam_device_config(struct mpam_device *dev, u32 partid, */ mb();

-out: - return ret; + return 0; }

static void mpam_component_device_sync(void *__ctx)

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

For each ctrl group, it's monitoring data should include all it's child mon groups' monitoring data, these code is borrowed from Intel-RDT for facilitating users to configure different monitoring strategies.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)

diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index b906e5b85698..47ebb64ccbe1 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -449,6 +449,33 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) }

usage = rr->mon_read(d, md.priv); + /* + * if this rdtgroup is ctrlmon group, also collect it's + * mon groups' monitor data. + */ + if (rdtgrp->type == RDTCTRL_GROUP) { + struct list_head *head; + struct rdtgroup *entry; + hw_closid_t hw_closid; + enum resctrl_conf_type type = CDP_CODE; + + resctrl_cdp_map(clos, rdtgrp->closid.reqpartid, + CDP_CODE, hw_closid); + /* CDP_CODE share the same closid with CDP_BOTH */ + if (md.u.partid != hw_closid_val(hw_closid)) + type = CDP_DATA; + + head = &rdtgrp->mon.crdtgrp_list; + list_for_each_entry(entry, head, mon.crdtgrp_list) { + resctrl_cdp_map(clos, entry->closid.reqpartid, + type, hw_closid); + md.u.partid = hw_closid_val(hw_closid); + md.u.pmg = entry->mon.rmid; + md.u.mon = entry->mon.mon; + usage += rr->mon_read(d, md.priv); + } + } + seq_printf(m, "%llu\n", usage);

out:

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Currently configuration control type is devided into three classes: COMMON, PRIORITY and HARDLIMIT, capacities' features for mount options is stored in ctrl_extend_bits field live in resctrl resource structure to figure out which configuration type is allowed to apply, when writing schemata sysfile, all related configurations' content from corresponding configuration array will be updated and applied once time.

we can set configuration like this: e.g. > mount -t resctrl resctrl /sys/fs/resctrl && cd /sys/fs/resctrl -o hardlimit > cat schemata L3:0=7fff;1=7fff;2=7fff;3=7fff MB:0=100;1=100;2=100;3=100 MBHDL:0=1;1=1;2=1;3=1 > echo 'MB:0=10' > schemata && echo 'MBHDL:0=0' > schemata # no hardlimit

This also deletes opt_list no longer needed that used as organizing different control types, now we can check supports from ctrl_extend_bits and do extended control-type works by schema list.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 37 ++- arch/arm64/include/asm/mpam_resource.h | 2 + arch/arm64/kernel/mpam/mpam_ctrlmon.c | 206 +++++++++++----- arch/arm64/kernel/mpam/mpam_resctrl.c | 312 +++++++++++++++++++------ arch/arm64/kernel/mpam/mpam_setup.c | 37 ++- include/linux/resctrlfs.h | 6 +- 6 files changed, 455 insertions(+), 145 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 5a76fb5d0fc6..6641180b4c3a 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -117,6 +117,21 @@ DECLARE_STATIC_KEY_FALSE(resctrl_mon_enable_key);

extern int max_name_width, max_data_width;

+enum resctrl_ctrl_type { + SCHEMA_COMM = 0, + SCHEMA_PRI, + SCHEMA_HDL, + SCHEMA_NUM_CTRL_TYPE +}; + +#define for_each_ctrl_type(t) \ + for (t = SCHEMA_COMM; t != SCHEMA_NUM_CTRL_TYPE; t++) + +#define for_each_extend_ctrl_type(t) \ + for (t = SCHEMA_PRI; t != SCHEMA_NUM_CTRL_TYPE; t++) + +bool resctrl_ctrl_extend_bits_match(u32 bitmap, enum resctrl_ctrl_type type); + enum resctrl_conf_type { CDP_BOTH = 0, CDP_CODE, @@ -183,25 +198,34 @@ do { \ */ struct resctrl_staged_config { hw_closid_t hw_closid; - u32 new_ctrl; + u32 new_ctrl[SCHEMA_NUM_CTRL_TYPE]; bool have_new_ctrl; enum resctrl_conf_type conf_type; + enum resctrl_ctrl_type ctrl_type; };

/* later move to resctrl common directory */ -#define RESCTRL_NAME_LEN 7 +#define RESCTRL_NAME_LEN 15 + +struct resctrl_schema_ctrl { + struct list_head list; + char name[RESCTRL_NAME_LEN]; + enum resctrl_ctrl_type ctrl_type; +};

/** * @list: Member of resctrl's schema list * @name: Name visible in the schemata file * @conf_type: Type of configuration, e.g. code/data/both * @res: The rdt_resource for this entry + * @schemata_ctrl_list: Type of ctrl configuration. e.g. priority/hardlimit */ struct resctrl_schema { struct list_head list; char name[RESCTRL_NAME_LEN]; enum resctrl_conf_type conf_type; struct resctrl_resource *res; + struct list_head schema_ctrl_list; };

/** @@ -230,8 +254,7 @@ struct rdt_domain { void __iomem *base;

/* arch specific fields */ - u32 *ctrl_val; - u32 new_ctrl; + u32 *ctrl_val[SCHEMA_NUM_CTRL_TYPE]; bool have_new_ctrl;

/* for debug */ @@ -260,6 +283,7 @@ void post_resctrl_mount(void); struct sd_closid;

struct msr_param { + enum resctrl_ctrl_type type; struct sd_closid *closid; };

@@ -295,13 +319,14 @@ struct raw_resctrl_resource { u16 hdl_wd;

void (*msr_update)(struct resctrl_resource *r, struct rdt_domain *d, - struct list_head *opt_list, struct msr_param *para); + struct msr_param *para); u64 (*msr_read)(struct rdt_domain *d, struct msr_param *para);

int data_width; const char *format_str; int (*parse_ctrlval)(char *buf, struct raw_resctrl_resource *r, - struct resctrl_staged_config *cfg); + struct resctrl_staged_config *cfg, + enum resctrl_ctrl_type ctrl_type);

u16 num_mon; u64 (*mon_read)(struct rdt_domain *d, void *md_priv); diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index cc863183e1be..8868da13411b 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -76,6 +76,7 @@ #define MBW_MAX_SET(v) (MBW_MAX_HARDLIM|((v) << (16 - BWA_WD))) #define MBW_MAX_GET(v) (((v) & MBW_MAX_MASK) >> (16 - BWA_WD)) #define MBW_MAX_SET_HDL(r) (r | MBW_MAX_HARDLIM) +#define MBW_MAX_GET_HDL(r) (r & MBW_MAX_HARDLIM) /* MPAMCFG_MBW_PROP */ #define MBW_PROP_HARDLIM BIT(31) #define MBW_PROP_SET_HDL(r) (r | MBW_PROP_HARDLIM) @@ -133,6 +134,7 @@ * MPAMCFG_MBW_MAX SET - temp Hard code */ #define MPAMCFG_PRI_DSPRI_SHIFT 16 +#define MPAMCFG_PRI_GET(r) ((r & GENMASK(15, 0)) | (r & GENMASK(16, 31)) >> 16)

/* MPAMF_PRI_IDR - MPAM features priority partitioning ID register */ #define MPAMF_PRI_IDR_HAS_INTPRI BIT(0) diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 47ebb64ccbe1..b7dc8226a008 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -39,8 +39,15 @@ LIST_HEAD(resctrl_all_schema); /* Init schemata content */ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) { + int ret = 0; char *suffix = ""; + char *ctrl_suffix = ""; struct resctrl_schema *s; + struct raw_resctrl_resource *rr; + struct resctrl_schema_ctrl *sc, *sc_tmp; + struct resctrl_schema_ctrl *sc_pri = NULL; + struct resctrl_schema_ctrl *sc_hdl = NULL; + enum resctrl_ctrl_type type;

s = kzalloc(sizeof(*s), GFP_KERNEL); if (!s) @@ -69,7 +76,50 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) INIT_LIST_HEAD(&s->list); list_add_tail(&s->list, &resctrl_all_schema);

+ /* + * Initialize extension ctrl type with MPAM capabilities, + * e.g. priority/hardlimit. + */ + rr = r->res; + INIT_LIST_HEAD(&s->schema_ctrl_list); + for_each_extend_ctrl_type(type) { + if ((type == SCHEMA_PRI && !rr->pri_wd) || + (type == SCHEMA_HDL && !rr->hdl_wd) || + !resctrl_ctrl_extend_bits_match(r->ctrl_extend_bits, + type)) + continue; + + sc = kzalloc(sizeof(*sc), GFP_KERNEL); + if (!sc) { + ret = -ENOMEM; + goto err; + } + sc->ctrl_type = type; + if (type == SCHEMA_PRI) { + sc_pri = sc; + ctrl_suffix = "PRI"; + } else if (type == SCHEMA_HDL) { + sc_hdl = sc; + ctrl_suffix = "HDL"; + } + + WARN_ON_ONCE(strlen(r->name) + strlen(suffix) + + strlen(ctrl_suffix) + 1 > RESCTRL_NAME_LEN); + snprintf(sc->name, sizeof(sc->name), "%s%s%s", + r->name, suffix, ctrl_suffix); + list_add_tail(&sc->list, &s->schema_ctrl_list); + } + return 0; + +err: + list_for_each_entry_safe(sc, sc_tmp, &s->schema_ctrl_list, list) { + list_del(&sc->list); + kfree(sc); + } + list_del(&s->list); + kfree(s); + return ret; }

int schemata_list_init(void) @@ -104,69 +154,88 @@ int schemata_list_init(void) void schemata_list_destroy(void) { struct resctrl_schema *s, *tmp; + struct resctrl_schema_ctrl *sc, *sc_tmp;

list_for_each_entry_safe(s, tmp, &resctrl_all_schema, list) { + list_for_each_entry_safe(sc, sc_tmp, &s->schema_ctrl_list, list) { + list_del(&sc->list); + kfree(sc); + } list_del(&s->list); kfree(s); } }

-static int resctrl_group_update_domains(struct rdtgroup *rdtgrp, - struct resctrl_resource *r) +static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, + struct resctrl_resource *r, struct rdt_domain *dom) { int i; - struct rdt_domain *d; - struct raw_resctrl_resource *rr; struct resctrl_staged_config *cfg; + enum resctrl_ctrl_type type; hw_closid_t hw_closid; + struct raw_resctrl_resource *rr; struct sd_closid closid; struct list_head *head; struct rdtgroup *entry; struct msr_param para;

- para.closid = &closid; + bool update_on;

rr = r->res; - list_for_each_entry(d, &r->domains, list) { - cfg = d->staged_cfg; - for (i = 0; i < ARRAY_SIZE(d->staged_cfg); i++) { - if (!cfg[i].have_new_ctrl) - continue;

- /* - * for ctrl group configuration, hw_closid of cfg[i] - * equals to rdtgrp->closid.intpartid. - */ - closid.intpartid = hw_closid_val(cfg[i].hw_closid); + cfg = dom->staged_cfg; + para.closid = &closid;

+ for (i = 0; i < ARRAY_SIZE(dom->staged_cfg); i++) { + if (!cfg[i].have_new_ctrl) + continue; + update_on = false; + /* + * for ctrl group configuration, hw_closid of cfg[i] equals + * to rdtgrp->closid.intpartid. + */ + closid.intpartid = hw_closid_val(cfg[i].hw_closid); + for_each_ctrl_type(type) { /* if ctrl group's config has changed, refresh it first. */ - if (d->ctrl_val[closid.intpartid] != cfg[i].new_ctrl) { + if (dom->ctrl_val[closid.intpartid] != cfg[i].new_ctrl) { /* * duplicate ctrl group's configuration indexed * by intpartid from domain ctrl_val array. */ resctrl_cdp_map(clos, rdtgrp->closid.reqpartid, - cfg[i].conf_type, hw_closid); - closid.reqpartid = hw_closid_val(hw_closid); - - d->ctrl_val[closid.intpartid] = cfg[i].new_ctrl; - d->have_new_ctrl = true; - rr->msr_update(r, d, NULL, &para); - } - /* - * we should synchronize all child mon groups' - * configuration from this ctrl rdtgrp - */ - head = &rdtgrp->mon.crdtgrp_list; - list_for_each_entry(entry, head, mon.crdtgrp_list) { - resctrl_cdp_map(clos, entry->closid.reqpartid, cfg[i].conf_type, hw_closid); closid.reqpartid = hw_closid_val(hw_closid);

- rr->msr_update(r, d, NULL, &para); + dom->ctrl_val[type][closid.intpartid] = + cfg[i].new_ctrl[type]; + dom->have_new_ctrl = true; + update_on = true; } } + if (update_on) + rr->msr_update(r, dom, &para); + + /* + * we should synchronize all child mon groups' + * configuration from this ctrl rdtgrp + */ + head = &rdtgrp->mon.crdtgrp_list; + list_for_each_entry(entry, head, mon.crdtgrp_list) { + resctrl_cdp_map(clos, entry->closid.reqpartid, + cfg[i].conf_type, hw_closid); + closid.reqpartid = hw_closid_val(hw_closid); + rr->msr_update(r, dom, &para); + } } +} + +static int resctrl_group_update_domains(struct rdtgroup *rdtgrp, + struct resctrl_resource *r) +{ + struct rdt_domain *d; + + list_for_each_entry(d, &r->domains, list) + resctrl_group_update_domain_ctrls(rdtgrp, r, d);

return 0; } @@ -177,8 +246,10 @@ static int resctrl_group_update_domains(struct rdtgroup *rdtgrp, * separated by ";". The "id" is in decimal, and must match one of * the "id"s for this resource. */ -static int parse_line(char *line, struct resctrl_resource *r, - enum resctrl_conf_type t, u32 closid) +static int +parse_line(char *line, struct resctrl_resource *r, + enum resctrl_conf_type conf_type, + enum resctrl_ctrl_type ctrl_type, u32 closid) { struct raw_resctrl_resource *rr = r->res; char *dom = NULL; @@ -199,11 +270,13 @@ static int parse_line(char *line, struct resctrl_resource *r, dom = strim(dom); list_for_each_entry(d, &r->domains, list) { if (d->id == dom_id) { - resctrl_cdp_map(clos, closid, t, hw_closid); - if (rr->parse_ctrlval(dom, rr, &d->staged_cfg[t])) + resctrl_cdp_map(clos, closid, conf_type, hw_closid); + if (rr->parse_ctrlval(dom, rr, + &d->staged_cfg[conf_type], ctrl_type)) return -EINVAL; - d->staged_cfg[t].hw_closid = hw_closid; - d->staged_cfg[t].conf_type = t; + d->staged_cfg[conf_type].hw_closid = hw_closid; + d->staged_cfg[conf_type].conf_type = conf_type; + d->staged_cfg[conf_type].ctrl_type = ctrl_type; goto next; } } @@ -216,6 +289,7 @@ resctrl_group_parse_schema_resource(char *resname, char *tok, u32 closid) struct resctrl_resource *r; struct resctrl_schema *s; enum resctrl_conf_type t; + struct resctrl_schema_ctrl *sc;

list_for_each_entry(s, &resctrl_all_schema, list) { r = s->res; @@ -224,10 +298,18 @@ resctrl_group_parse_schema_resource(char *resname, char *tok, u32 closid) continue;

if (r->alloc_enabled) { - if (!strcmp(resname, s->name) && - closid < mpam_sysprops_num_partid()) { - t = conf_name_to_conf_type(s->name); - return parse_line(tok, r, t, closid); + if (closid >= mpam_sysprops_num_partid()) + continue; + t = conf_name_to_conf_type(s->name); + if (!strcmp(resname, s->name)) + return parse_line(tok, r, t, + SCHEMA_COMM, closid); + + list_for_each_entry(sc, &s->schema_ctrl_list, list) { + if (!strcmp(resname, sc->name)) + return parse_line(tok, r, t, + sc->ctrl_type, + closid); } } } @@ -312,7 +394,8 @@ ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, * a single "S" simply. */ static void show_doms(struct seq_file *s, struct resctrl_resource *r, - char *schema_name, struct sd_closid *closid) + char *schema_name, enum resctrl_ctrl_type type, + struct sd_closid *closid) { struct raw_resctrl_resource *rr = r->res; struct rdt_domain *dom; @@ -323,6 +406,7 @@ static void show_doms(struct seq_file *s, struct resctrl_resource *r, u32 reg_val;

para.closid = closid; + para.type = type;

if (r->dom_num > RESCTRL_SHOW_DOM_MAX_NUM) rg = true; @@ -331,13 +415,13 @@ static void show_doms(struct seq_file *s, struct resctrl_resource *r, list_for_each_entry(dom, &r->domains, list) { reg_val = rr->msr_read(dom, &para);

- if (rg && reg_val == r->default_ctrl && + if (rg && reg_val == r->default_ctrl[SCHEMA_COMM] && prev_auto_fill == true) continue;

if (sep) seq_puts(s, ";"); - if (rg && reg_val == r->default_ctrl) { + if (rg && reg_val == r->default_ctrl[SCHEMA_COMM]) { prev_auto_fill = true; seq_puts(s, "S"); } else { @@ -358,6 +442,7 @@ int resctrl_group_schemata_show(struct kernfs_open_file *of, int ret = 0; hw_closid_t hw_closid; struct sd_closid closid; + struct resctrl_schema_ctrl *sc;

rdtgrp = resctrl_group_kn_lock_live(of->kn); if (rdtgrp) { @@ -374,7 +459,10 @@ int resctrl_group_schemata_show(struct kernfs_open_file *of, rs->conf_type, hw_closid); closid.reqpartid = hw_closid_val(hw_closid);

- show_doms(s, r, rs->name, &closid); + show_doms(s, r, rs->name, SCHEMA_COMM, &closid); + list_for_each_entry(sc, &rs->schema_ctrl_list, list) { + show_doms(s, r, sc->name, sc->ctrl_type, &closid); + } } } } else { @@ -600,12 +688,17 @@ static void rdtgroup_init_mba(struct resctrl_resource *r, u32 closid) { struct resctrl_staged_config *cfg; struct rdt_domain *d; + enum resctrl_ctrl_type t;

list_for_each_entry(d, &r->domains, list) { cfg = &d->staged_cfg[CDP_BOTH]; - cfg->new_ctrl = r->default_ctrl; + cfg->new_ctrl[SCHEMA_COMM] = r->default_ctrl[SCHEMA_COMM]; resctrl_cdp_map(clos, closid, CDP_BOTH, cfg->hw_closid); cfg->have_new_ctrl = true; + /* Set extension ctrl default value, e.g. priority/hardlimit */ + for_each_extend_ctrl_type(t) { + cfg->new_ctrl[t] = r->default_ctrl[t]; + } } }

@@ -622,7 +715,8 @@ static void rdtgroup_init_mba(struct resctrl_resource *r, u32 closid) static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) { struct resctrl_staged_config *cfg; - enum resctrl_conf_type t = s->conf_type; + enum resctrl_conf_type conf_type = s->conf_type; + enum resctrl_ctrl_type ctrl_type; struct rdt_domain *d; struct resctrl_resource *r; u32 used_b = 0; @@ -634,17 +728,17 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) return -EINVAL;

list_for_each_entry(d, &s->res->domains, list) { - cfg = &d->staged_cfg[t]; + cfg = &d->staged_cfg[conf_type]; cfg->have_new_ctrl = false; - cfg->new_ctrl = r->cache.shareable_bits; + cfg->new_ctrl[SCHEMA_COMM] = r->cache.shareable_bits; used_b = r->cache.shareable_bits;

unused_b = used_b ^ (BIT_MASK(r->cache.cbm_len) - 1); unused_b &= BIT_MASK(r->cache.cbm_len) - 1; - cfg->new_ctrl |= unused_b; + cfg->new_ctrl[SCHEMA_COMM] |= unused_b;

/* Ensure cbm does not access out-of-bound */ - tmp_cbm = cfg->new_ctrl; + tmp_cbm = cfg->new_ctrl[SCHEMA_COMM]; if (bitmap_weight(&tmp_cbm, r->cache.cbm_len) < r->cache.min_cbm_bits) { rdt_last_cmd_printf("No space on %s:%d\n", @@ -652,8 +746,16 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) return -ENOSPC; }

- resctrl_cdp_map(clos, closid, t, cfg->hw_closid); + resctrl_cdp_map(clos, closid, conf_type, cfg->hw_closid); cfg->have_new_ctrl = true; + + /* + * Set extension ctrl default value, e.g. priority/hardlimit + * with MPAM capabilities. + */ + for_each_extend_ctrl_type(ctrl_type) { + cfg->new_ctrl[ctrl_type] = r->default_ctrl[ctrl_type]; + } }

return 0; diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 6abd682f1fa5..7b986b9c74c4 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -105,14 +105,29 @@ bool is_resctrl_cdp_enabled(void) return !!resctrl_cdp_enabled; }

+static void +resctrl_ctrl_extend_bits_set(u32 *bitmap, enum resctrl_ctrl_type type) +{ + *bitmap |= BIT(type); +} + +static void resctrl_ctrl_extend_bits_clear(u32 *bitmap) +{ + *bitmap = 0; +} + +bool resctrl_ctrl_extend_bits_match(u32 bitmap, enum resctrl_ctrl_type type) +{ + return bitmap & BIT(type); +} + static void mpam_resctrl_update_component_cfg(struct resctrl_resource *r, - struct rdt_domain *d, struct list_head *opt_list, - struct sd_closid *closid); + struct rdt_domain *d, struct sd_closid *closid);

static void common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, - struct list_head *opt_list, struct msr_param *para); + struct msr_param *para);

static u64 cache_rdmsr(struct rdt_domain *d, struct msr_param *para); static u64 mbw_rdmsr(struct rdt_domain *d, struct msr_param *para); @@ -122,16 +137,16 @@ static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv);

static int common_wrmon(struct rdt_domain *d, void *md_priv);

-static int parse_cbm(char *buf, struct raw_resctrl_resource *r, - struct resctrl_staged_config *cfg); +static int parse_cache(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, enum resctrl_ctrl_type ctrl_type); static int parse_bw(char *buf, struct raw_resctrl_resource *r, - struct resctrl_staged_config *cfg); + struct resctrl_staged_config *cfg, enum resctrl_ctrl_type ctrl_type);

struct raw_resctrl_resource raw_resctrl_resources_all[] = { [RDT_RESOURCE_L3] = { .msr_update = common_wrmsr, .msr_read = cache_rdmsr, - .parse_ctrlval = parse_cbm, + .parse_ctrlval = parse_cache, .format_str = "%d=%0*x", .mon_read = cache_rdmon, .mon_write = common_wrmon, @@ -139,7 +154,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { [RDT_RESOURCE_L2] = { .msr_update = common_wrmsr, .msr_read = cache_rdmsr, - .parse_ctrlval = parse_cbm, + .parse_ctrlval = parse_cache, .format_str = "%d=%0*x", .mon_read = cache_rdmon, .mon_write = common_wrmon, @@ -164,33 +179,13 @@ mpam_get_raw_resctrl_resource(enum resctrl_resource_level level) }

/* - * Check whether a cache bit mask is valid. for arm64 MPAM, - * it seems that there are no restrictions according to MPAM - * spec expect for requiring at least one bit. - */ -static bool cbm_validate(char *buf, unsigned long *data, - struct raw_resctrl_resource *r) -{ - u64 val; - int ret; - - ret = kstrtou64(buf, 16, &val); - if (ret) { - rdt_last_cmd_printf("non-hex character in mask %s\n", buf); - return false; - } - - *data = val; - return true; -} - -/* - * Read one cache bit mask (hex). Check that it is valid for the current + * Read one cache schema row. Check that it is valid for the current * resource type. */ static int -parse_cbm(char *buf, struct raw_resctrl_resource *r, - struct resctrl_staged_config *cfg) +parse_cache(char *buf, struct raw_resctrl_resource *r, + struct resctrl_staged_config *cfg, + enum resctrl_ctrl_type type) { unsigned long data;

@@ -199,10 +194,24 @@ parse_cbm(char *buf, struct raw_resctrl_resource *r, return -EINVAL; }

- if (!cbm_validate(buf, &data, r)) + switch (type) { + case SCHEMA_COMM: + if (kstrtoul(buf, 16, &data)) + return -EINVAL; + break; + case SCHEMA_PRI: + if (kstrtoul(buf, 10, &data)) + return -EINVAL; + break; + case SCHEMA_HDL: + if (kstrtoul(buf, 10, &data)) + return -EINVAL; + break; + default: return -EINVAL; + }

- cfg->new_ctrl = data; + cfg->new_ctrl[type] = data; cfg->have_new_ctrl = true;

return 0; @@ -253,7 +262,8 @@ static bool bw_validate(char *buf, unsigned long *data,

static int parse_bw(char *buf, struct raw_resctrl_resource *r, - struct resctrl_staged_config *cfg) + struct resctrl_staged_config *cfg, + enum resctrl_ctrl_type type) { unsigned long data;

@@ -262,10 +272,24 @@ parse_bw(char *buf, struct raw_resctrl_resource *r, return -EINVAL; }

- if (!bw_validate(buf, &data, r)) + switch (type) { + case SCHEMA_COMM: + if (!bw_validate(buf, &data, r)) + return -EINVAL; + break; + case SCHEMA_PRI: + if (kstrtoul(buf, 10, &data)) + return -EINVAL; + break; + case SCHEMA_HDL: + if (kstrtoul(buf, 10, &data)) + return -EINVAL; + break; + default: return -EINVAL; + }

- cfg->new_ctrl = data; + cfg->new_ctrl[type] = data; cfg->have_new_ctrl = true;

return 0; @@ -273,14 +297,14 @@ parse_bw(char *buf, struct raw_resctrl_resource *r,

static void common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, - struct list_head *opt_list, struct msr_param *para) + struct msr_param *para) { struct sync_args args; struct mpam_resctrl_dom *dom;

dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom);

- mpam_resctrl_update_component_cfg(r, d, opt_list, para->closid); + mpam_resctrl_update_component_cfg(r, d, para->closid);

/* * so far we have accomplished configuration replication, @@ -297,31 +321,75 @@ static u64 cache_rdmsr(struct rdt_domain *d, struct msr_param *para) struct mpam_resctrl_dom *dom;

args.closid = *para->closid; - args.reg = MPAMCFG_CPBM;

- dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom); + switch (para->type) { + case SCHEMA_COMM: + args.reg = MPAMCFG_CPBM; + break; + case SCHEMA_PRI: + args.reg = MPAMCFG_PRI; + default: + return 0; + }

+ dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom); mpam_component_get_config(dom->comp, &args, &result);

+ switch (para->type) { + case SCHEMA_PRI: + result = MPAMCFG_PRI_GET(result); + break; + default: + break; + } + return result; }

static u64 mbw_rdmsr(struct rdt_domain *d, struct msr_param *para) { - u64 max; u32 result; struct sync_args args; struct mpam_resctrl_dom *dom;

args.closid = *para->closid; - args.reg = MPAMCFG_MBW_MAX;

- dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom); + /* + * software default set memory bandwidth by + * MPAMCFG_MBW_MAX but not MPAMCFG_MBW_PBM. + */ + switch (para->type) { + case SCHEMA_COMM: + args.reg = MPAMCFG_MBW_MAX; + break; + case SCHEMA_HDL: + args.reg = MPAMCFG_MBW_MAX; + break; + case SCHEMA_PRI: + args.reg = MPAMCFG_PRI; + break; + default: + return 0; + }

+ dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom); mpam_component_get_config(dom->comp, &args, &result);

- max = MBW_MAX_GET(result); - return roundup((max * 100) / 64, 5); + switch (para->type) { + case SCHEMA_COMM: + result = roundup((MBW_MAX_GET(result) * 100) / 64, 5); + break; + case SCHEMA_PRI: + result = MPAMCFG_PRI_GET(result); + break; + case SCHEMA_HDL: + result = MBW_MAX_GET_HDL(result); + break; + default: + break; + } + + return result; }

/* @@ -644,6 +712,52 @@ static int cdpl2_enable(void) return try_to_enable_cdp(RDT_RESOURCE_L2); }

+static void basic_ctrl_enable(void) +{ + struct mpam_resctrl_res *res; + struct resctrl_resource *r; + + for_each_supported_resctrl_exports(res) { + r = &res->resctrl_res; + /* At least SCHEMA_COMM is supported */ + resctrl_ctrl_extend_bits_set(&r->ctrl_extend_bits, SCHEMA_COMM); + } +} + +static int extend_ctrl_enable(enum resctrl_ctrl_type type) +{ + bool match = false; + struct resctrl_resource *r; + struct raw_resctrl_resource *rr; + struct mpam_resctrl_res *res; + + for_each_supported_resctrl_exports(res) { + r = &res->resctrl_res; + rr = r->res; + if ((type == SCHEMA_PRI && rr->pri_wd) || + (type == SCHEMA_HDL && rr->hdl_wd)) { + resctrl_ctrl_extend_bits_set(&r->ctrl_extend_bits, type); + match = true; + } + } + + if (!match) + return -EINVAL; + + return 0; +} + +static void extend_ctrl_disable(void) +{ + struct resctrl_resource *r; + struct mpam_resctrl_res *res; + + for_each_supported_resctrl_exports(res) { + r = &res->resctrl_res; + resctrl_ctrl_extend_bits_clear(&r->ctrl_extend_bits); + } +} + int parse_rdtgroupfs_options(char *data) { char *token; @@ -651,6 +765,7 @@ int parse_rdtgroupfs_options(char *data) int ret = 0;

disable_cdp(); + extend_ctrl_disable();

while ((token = strsep(&o, ",")) != NULL) { if (!*token) { @@ -666,12 +781,22 @@ int parse_rdtgroupfs_options(char *data) ret = cdpl2_enable(); if (ret) goto out; + } else if (!strcmp(token, "priority")) { + ret = extend_ctrl_enable(SCHEMA_PRI); + if (ret) + goto out; + } else if (!strcmp(token, "hardlimit")) { + ret = extend_ctrl_enable(SCHEMA_HDL); + if (ret) + goto out; } else { ret = -EINVAL; goto out; } }

+ basic_ctrl_enable(); + return 0;

out: @@ -1422,45 +1547,70 @@ void __mpam_sched_in(void)

static void mpam_update_from_resctrl_cfg(struct mpam_resctrl_res *res, - u32 resctrl_cfg, struct mpam_config *mpam_cfg) + u32 resctrl_cfg, enum resctrl_ctrl_type ctrl_type, + struct mpam_config *mpam_cfg) { - if (res == &mpam_resctrl_exports[RDT_RESOURCE_MC]) { - u64 range; + switch (ctrl_type) { + case SCHEMA_COMM: + if (res == &mpam_resctrl_exports[RDT_RESOURCE_MC]) { + u64 range; + + /* For MBA cfg is a percentage of .. */ + if (res->resctrl_mba_uses_mbw_part) { + /* .. the number of bits we can set */ + range = res->class->mbw_pbm_bits; + mpam_cfg->mbw_pbm = + (resctrl_cfg * range) / MAX_MBA_BW; + mpam_set_feature(mpam_feat_mbw_part, &mpam_cfg->valid); + } else { + /* .. the number of fractions we can represent */ + mpam_cfg->mbw_max = + bw_max_mask[(resctrl_cfg / 5 - 1) % + ARRAY_SIZE(bw_max_mask)];

- /* For MBA cfg is a percentage of .. */ - if (res->resctrl_mba_uses_mbw_part) { - /* .. the number of bits we can set */ - range = res->class->mbw_pbm_bits; - mpam_cfg->mbw_pbm = (resctrl_cfg * range) / MAX_MBA_BW; - mpam_set_feature(mpam_feat_mbw_part, &mpam_cfg->valid); + mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); + } } else { - /* .. the number of fractions we can represent */ - mpam_cfg->mbw_max = bw_max_mask[(resctrl_cfg / 5 - 1) % - ARRAY_SIZE(bw_max_mask)]; - - mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); + /* + * Nothing clever here as mpam_resctrl_pick_caches() + * capped the size at RESCTRL_MAX_CBM. + */ + mpam_cfg->cpbm = resctrl_cfg; + mpam_set_feature(mpam_feat_cpor_part, &mpam_cfg->valid); } - } else { - /* - * Nothing clever here as mpam_resctrl_pick_caches() - * capped the size at RESCTRL_MAX_CBM. - */ - mpam_cfg->cpbm = resctrl_cfg; - mpam_set_feature(mpam_feat_cpor_part, &mpam_cfg->valid); + break; + case SCHEMA_PRI: + mpam_cfg->dspri = resctrl_cfg; + mpam_cfg->intpri = resctrl_cfg; + mpam_set_feature(mpam_feat_dspri_part, &mpam_cfg->valid); + mpam_set_feature(mpam_feat_intpri_part, &mpam_cfg->valid); + break; + case SCHEMA_HDL: + mpam_cfg->hdl = resctrl_cfg; + mpam_set_feature(mpam_feat_part_hdl, &mpam_cfg->valid); + break; + default: + break; } }

+/* + * copy all ctrl type at once looks more efficient, as it + * only needs refresh devices' state once time through + * mpam_component_config, this feature will be checked + * again when appling configuration. + */ static void mpam_resctrl_update_component_cfg(struct resctrl_resource *r, - struct rdt_domain *d, struct list_head *opt_list, - struct sd_closid *closid) + struct rdt_domain *d, struct sd_closid *closid) { struct mpam_resctrl_dom *dom; struct mpam_resctrl_res *res; struct mpam_config *slave_mpam_cfg; + enum resctrl_ctrl_type type; u32 intpartid = closid->intpartid; u32 reqpartid = closid->reqpartid; - u32 resctrl_cfg = d->ctrl_val[intpartid]; + u32 resctrl_cfg;

lockdep_assert_held(&resctrl_group_mutex);

@@ -1481,9 +1631,18 @@ mpam_resctrl_update_component_cfg(struct resctrl_resource *r, slave_mpam_cfg = &dom->comp->cfg[reqpartid]; if (WARN_ON_ONCE(!slave_mpam_cfg)) return; - slave_mpam_cfg->valid = 0; - mpam_update_from_resctrl_cfg(res, resctrl_cfg, slave_mpam_cfg); + + for_each_ctrl_type(type) { + /* + * we don't need check if we have enabled this ctrl type, because + * this ctrls also should be applied an default configuration and + * this feature type would be rechecked when configuring mpam devices. + */ + resctrl_cfg = d->ctrl_val[type][intpartid]; + mpam_update_from_resctrl_cfg(res, resctrl_cfg, + type, slave_mpam_cfg); + } }

static void mpam_reset_cfg(struct mpam_resctrl_res *res, @@ -1492,11 +1651,14 @@ static void mpam_reset_cfg(struct mpam_resctrl_res *res, { int i; struct resctrl_resource *r = &res->resctrl_res; + enum resctrl_ctrl_type type;

for (i = 0; i != mpam_sysprops_num_partid(); i++) { - mpam_update_from_resctrl_cfg(res, r->default_ctrl, - &dom->comp->cfg[i]); - d->ctrl_val[i] = r->default_ctrl; + for_each_ctrl_type(type) { + mpam_update_from_resctrl_cfg(res, r->default_ctrl[type], + type, &dom->comp->cfg[i]); + d->ctrl_val[type][i] = r->default_ctrl[type]; + } } }

diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index b01716392a65..a06bd19be485 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -64,6 +64,7 @@ static int mpam_resctrl_setup_domain(unsigned int cpu, struct mpam_component *comp_iter, *comp; u32 num_partid; u32 **ctrlval_ptr; + enum resctrl_ctrl_type type;

num_partid = mpam_sysprops_num_partid();

@@ -88,12 +89,14 @@ static int mpam_resctrl_setup_domain(unsigned int cpu, dom->resctrl_dom.id = comp->comp_id; cpumask_set_cpu(cpu, &dom->resctrl_dom.cpu_mask);

- ctrlval_ptr = &dom->resctrl_dom.ctrl_val; - *ctrlval_ptr = kmalloc_array(num_partid, + for_each_ctrl_type(type) { + ctrlval_ptr = &dom->resctrl_dom.ctrl_val[type]; + *ctrlval_ptr = kmalloc_array(num_partid, sizeof(**ctrlval_ptr), GFP_KERNEL); - if (!*ctrlval_ptr) { - kfree(dom); - return -ENOMEM; + if (!*ctrlval_ptr) { + kfree(dom); + return -ENOMEM; + } }

/* TODO: this list should be sorted */ @@ -331,6 +334,13 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) struct resctrl_resource *r = &res->resctrl_res; struct raw_resctrl_resource *rr = NULL;

+ if (class && !r->default_ctrl) { + r->default_ctrl = kmalloc_array(SCHEMA_NUM_CTRL_TYPE, + sizeof(*r->default_ctrl), GFP_KERNEL); + if (!r->default_ctrl) + return -ENOMEM; + } + if (class == mpam_resctrl_exports[RDT_RESOURCE_SMMU].class) { return 0; } else if (class == mpam_resctrl_exports[RDT_RESOURCE_MC].class) { @@ -363,7 +373,7 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mbw.min_bw = MAX_MBA_BW / ((1ULL << class->bwa_wd) - 1); /* the largest mbw_max is 100 */ - r->default_ctrl = 100; + r->default_ctrl[SCHEMA_COMM] = 100; } /* Just in case we have an excessive number of bits */ if (!r->mbw.min_bw) @@ -381,6 +391,9 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) rdt_alloc_capable = true; r->mon_capable = true; r->mon_enabled = true; + /* Export memory bandwidth hardlimit, default active hardlimit */ + rr->hdl_wd = 2; + r->default_ctrl[SCHEMA_HDL] = rr->hdl_wd - 1; } else if (class == mpam_resctrl_exports[RDT_RESOURCE_L3].class) { r->rid = RDT_RESOURCE_L3; rr = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L3); @@ -390,14 +403,14 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->name = "L3";

r->cache.cbm_len = class->cpbm_wd; - r->default_ctrl = GENMASK(class->cpbm_wd - 1, 0); + r->default_ctrl[SCHEMA_COMM] = GENMASK(class->cpbm_wd - 1, 0); /* * Which bits are shared with other ...things... * Unknown devices use partid-0 which uses all the bitmap * fields. Until we configured the SMMU and GIC not to do this * 'all the bits' is the correct answer here. */ - r->cache.shareable_bits = r->default_ctrl; + r->cache.shareable_bits = r->default_ctrl[SCHEMA_COMM]; r->cache.min_cbm_bits = 1;

if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { @@ -423,14 +436,14 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->name = "L2";

r->cache.cbm_len = class->cpbm_wd; - r->default_ctrl = GENMASK(class->cpbm_wd - 1, 0); + r->default_ctrl[SCHEMA_COMM] = GENMASK(class->cpbm_wd - 1, 0); /* * Which bits are shared with other ...things... * Unknown devices use partid-0 which uses all the bitmap * fields. Until we configured the SMMU and GIC not to do this * 'all the bits' is the correct answer here. */ - r->cache.shareable_bits = r->default_ctrl; + r->cache.shareable_bits = r->default_ctrl[SCHEMA_COMM];

if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { r->alloc_capable = true; @@ -452,8 +465,10 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) rr->num_intpartid = class->num_intpartid; rr->num_pmg = class->num_pmg;

+ /* Export priority setting, default highest priority */ rr->pri_wd = max(class->intpri_wd, class->dspri_wd); - rr->hdl_wd = 2; + r->default_ctrl[SCHEMA_PRI] = (rr->pri_wd > 0) ? + rr->pri_wd - 1 : 0; }

return 0; diff --git a/include/linux/resctrlfs.h b/include/linux/resctrlfs.h index 684bcdba51de..7f1ff6e816f5 100644 --- a/include/linux/resctrlfs.h +++ b/include/linux/resctrlfs.h @@ -32,6 +32,8 @@ struct resctrl_cache { * @min_bw: Minimum memory bandwidth percentage user can request * @bw_gran: Granularity at which the memory bandwidth is allocated * @delay_linear: True if memory B/W delay is in linear scale + * @ctrl_extend_bits: Indicates if there are extra ctrl capabilities supported. + * e.g. priority/hardlimit. */ struct resctrl_membw { u32 min_bw; @@ -56,7 +58,9 @@ struct resctrl_resource {

bool cdp_capable; bool cdp_enable; - u32 default_ctrl; + u32 *default_ctrl; + + u32 ctrl_extend_bits;

void *res; };

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Store default priority in mpam class structure from reading devices' intpri_wd and dspri_wd.

intpri_wd and dspri_wd represent the number of implemented bits in the internal/downstream priority field in MPAMCFG_PRI, when INTPRI_0_IS_LOW /DSPRI_0_IS_LOW is not set, we need to rotate input priority(higher value higher priority) from user space to target priority (higher value lower priority) and this is restricted by implemented bits.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/kernel/mpam/mpam_device.c | 13 +++++++++++-- arch/arm64/kernel/mpam/mpam_device.h | 4 ++++ arch/arm64/kernel/mpam/mpam_setup.c | 10 +++++++--- 3 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index b8686e6c6669..0413eac0ba5e 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -362,6 +362,8 @@ static void mpam_enable_squash_features(void) class->num_pmg = dev->num_pmg; class->num_csu_mon = dev->num_csu_mon; class->num_mbwu_mon = dev->num_mbwu_mon; + class->hwdef_intpri = dev->hwdef_intpri; + class->hwdef_dspri = dev->hwdef_dspri; spin_unlock_irqrestore(&dev->lock, flags); }

@@ -764,10 +766,17 @@ static void mpam_reset_device_config(struct mpam_component *comp, intpri = dev->hwdef_intpri; dspri = dev->hwdef_dspri;

- if (mpam_has_feature(mpam_feat_intpri_part, dev->features)) + if (mpam_has_feature(mpam_feat_intpri_part, dev->features)) { + if (!mpam_has_feature(mpam_feat_intpri_part_0_low, dev->features)) + intpri = GENMASK(dev->intpri_wd - 1, 0) & ~intpri; pri_val |= intpri; - if (mpam_has_feature(mpam_feat_dspri_part, dev->features)) + } + + if (mpam_has_feature(mpam_feat_dspri_part, dev->features)) { + if (!mpam_has_feature(mpam_feat_dspri_part_0_low, dev->features)) + dspri = GENMASK(dev->dspri_wd - 1, 0) & ~dspri; pri_val |= (dspri << MPAMCFG_PRI_DSPRI_SHIFT); + }

mpam_write_reg(dev, MPAMCFG_PRI, pri_val); } diff --git a/arch/arm64/kernel/mpam/mpam_device.h b/arch/arm64/kernel/mpam/mpam_device.h index b1f852e65d83..fc5f7c292b6f 100644 --- a/arch/arm64/kernel/mpam/mpam_device.h +++ b/arch/arm64/kernel/mpam/mpam_device.h @@ -118,6 +118,10 @@ struct mpam_class { u16 num_pmg; u16 num_csu_mon; u16 num_mbwu_mon; + + /* for reset class MPAMCFG_PRI */ + u16 hwdef_intpri; + u16 hwdef_dspri; };

/* System wide properties */ diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index a06bd19be485..dc7490890349 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -465,10 +465,14 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) rr->num_intpartid = class->num_intpartid; rr->num_pmg = class->num_pmg;

- /* Export priority setting, default highest priority */ + /* + * Export priority setting, default priority from hardware, + * no clever here, we don't need to define another default + * value. + */ rr->pri_wd = max(class->intpri_wd, class->dspri_wd); - r->default_ctrl[SCHEMA_PRI] = (rr->pri_wd > 0) ? - rr->pri_wd - 1 : 0; + r->default_ctrl[SCHEMA_PRI] = max(class->hwdef_intpri, + class->hwdef_dspri); }

return 0;

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

MPAMCFG_INTPARTID.INTERNAL must be set when narrowing reqpartid to intpartid according to MPAM spec definitions, and this action must be done before writing MPAMCFG_PART_SEL if narrowing implemented. So we plan this work that do narrowing unifiedly when narrowing is supported.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 2 +- arch/arm64/kernel/mpam/mpam_device.c | 47 +++++++++++++++----------- 2 files changed, 28 insertions(+), 21 deletions(-)

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index 270ae49f306e..d7d9549be668 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -101,7 +101,7 @@ /* * Set MPAMCFG_PART_SEL internal bit */ -#define PART_SEL_SET_INTERNAL(r) (r | BIT(16)) +#define MPAMCFG_PART_SEL_INTERNAL BIT(16)

/* MPAM_ESR */ #define MPAMF_ESR_ERRCODE_MASK ((BIT(4) - 1) << 24) diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 0413eac0ba5e..6cc939e173f9 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -743,7 +743,7 @@ static void mpam_reset_device_config(struct mpam_component *comp, lockdep_assert_held(&dev->lock);

if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) - partid = PART_SEL_SET_INTERNAL(partid); + partid = partid | MPAMCFG_PART_SEL_INTERNAL; mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); wmb(); /* subsequent writes must be applied to our new partid */

@@ -1120,6 +1120,25 @@ static void mpam_device_narrow_map(struct mpam_device *dev, u32 partid, mpam_write_reg(dev, MPAMCFG_INTPARTID, intpartid); }

+/* + * partid should be narrowed to intpartid if this feature implemented, + * before writing to register MPAMCFG_PART_SEL should we check this. + */ +static int try_to_narrow_device_intpartid(struct mpam_device *dev, + u32 *partid, u32 intpartid) +{ + if (!mpam_has_part_sel(dev->features)) + return -EINVAL; + + if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) { + mpam_device_narrow_map(dev, *partid, intpartid); + /* narrowing intpartid success, then set 16 bit to 1*/ + *partid = intpartid | MPAMCFG_PART_SEL_INTERNAL; + } + + return 0; +} + static int mpam_device_config(struct mpam_device *dev, struct sd_closid *closid, struct mpam_config *cfg) @@ -1137,20 +1156,9 @@ mpam_device_config(struct mpam_device *dev, struct sd_closid *closid,

lockdep_assert_held(&dev->lock);

- if (!mpam_has_part_sel(dev->features)) + if (try_to_narrow_device_intpartid(dev, &partid, intpartid)) return -EINVAL;

- /* - * intpartid should be narrowed the first time, - * upstream(resctrl) keep this order - */ - if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) { - if (cfg && mpam_has_feature(mpam_feat_part_nrw, cfg->valid)) - mpam_device_narrow_map(dev, partid, intpartid); - /* intpartid success, set 16 bit to 1*/ - partid = PART_SEL_SET_INTERNAL(intpartid); - } - mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); wmb(); /* subsequent writes must be applied to our new partid */

@@ -1386,7 +1394,7 @@ static void mpam_component_read_mpamcfg(void *_ctx) struct sync_args *args = ctx->args; u64 val; u16 reg; - u32 partid; + u32 partid, intpartid;

if (!args) return; @@ -1394,6 +1402,7 @@ static void mpam_component_read_mpamcfg(void *_ctx) reg = args->reg;

partid = args->closid.reqpartid; + intpartid = args->closid.intpartid;

list_for_each_entry(dev, &comp->devices, comp_list) { if (!cpumask_test_cpu(smp_processor_id(), @@ -1401,13 +1410,11 @@ static void mpam_component_read_mpamcfg(void *_ctx) continue;

spin_lock_irqsave(&dev->lock, flags); - if (mpam_has_feature(mpam_feat_part_nrw, dev->features)) { - /* - * partid is possible reqpartid or intpartid, - * if narrow enabled, it should be intpartid. - */ - partid = PART_SEL_SET_INTERNAL(args->closid.intpartid); + if (try_to_narrow_device_intpartid(dev, &partid, intpartid)) { + spin_unlock_irqrestore(&dev->lock, flags); + return; } + mpam_write_reg(dev, MPAMCFG_PART_SEL, partid); wmb(); val = mpam_read_reg(dev, reg);

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

If cdp enabled, LxCODE and LxDATA are assigned two different partid each occupies a monitor, but because not all features use cdp mode, for instance MB(Memory Bandwidth), we should make sure this two partid/ monitor be operated simultaneously for display.

e.g.

+- code stream (partid = 0, monitor = 0) ----+---> L3CODE cpu-+ + +- data stream (partid = 1, monitor = 1) ----+---> L3DATA | +---> MB

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 5 ++ arch/arm64/kernel/mpam/mpam_ctrlmon.c | 81 ++++++++++++++++++++++----- 2 files changed, 72 insertions(+), 14 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 7dd34caa8a86..5fac0fb3c807 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -195,6 +195,7 @@ do { \ * @new_ctrl: new ctrl value to be loaded * @have_new_ctrl: did user provide new_ctrl for this domain * @new_ctrl_type: CDP property of the new ctrl + * @cdp_both_ctrl: did cdp both control if cdp enabled */ struct resctrl_staged_config { hw_closid_t hw_closid; @@ -202,6 +203,7 @@ struct resctrl_staged_config { bool have_new_ctrl; enum resctrl_conf_type conf_type; enum resctrl_ctrl_type ctrl_type; + bool cdp_both_ctrl; };

/* later move to resctrl common directory */ @@ -219,6 +221,7 @@ struct resctrl_schema_ctrl { * @conf_type: Type of configuration, e.g. code/data/both * @res: The rdt_resource for this entry * @schemata_ctrl_list: Type of ctrl configuration. e.g. priority/hardlimit + * @cdp_mc_both: did cdp both mon/ctrl if cdp enabled */ struct resctrl_schema { struct list_head list; @@ -226,6 +229,7 @@ struct resctrl_schema { enum resctrl_conf_type conf_type; struct resctrl_resource *res; struct list_head schema_ctrl_list; + bool cdp_mc_both; };

/** @@ -341,6 +345,7 @@ union mon_data_bits { u8 partid; u8 pmg; u8 mon; + u8 cdp_both_mon; } u; };

diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 8e1e9b1a21d1..fa4d4ee3af5b 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -56,6 +56,15 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) s->res = r; s->conf_type = t;

+ /* + * code and data is separated for resources LxCache but + * not for MB(Memory Bandwidth), it's necessary to set + * cdp_mc_both to let resctrl know operating the two closid/ + * monitor simultaneously when configuring/monitoring. + */ + if (is_resctrl_cdp_enabled()) + s->cdp_mc_both = !r->cdp_enable; + switch (t) { case CDP_CODE: suffix = "CODE"; @@ -164,6 +173,24 @@ void schemata_list_destroy(void) } }

+static void +resctrl_dom_ctrl_config(bool cdp_both_ctrl, struct resctrl_resource *r, + struct rdt_domain *dom, struct msr_param *para) +{ + struct raw_resctrl_resource *rr; + + rr = r->res; + rr->msr_update(r, dom, para); + + if (cdp_both_ctrl) { + hw_closid_t hw_closid; + + resctrl_cdp_map(clos, para->closid->reqpartid, CDP_DATA, hw_closid); + para->closid->reqpartid = hw_closid_val(hw_closid); + rr->msr_update(r, dom, para); + } +} + static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, struct resctrl_resource *r, struct rdt_domain *dom) { @@ -171,15 +198,11 @@ static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, struct resctrl_staged_config *cfg; enum resctrl_ctrl_type type; hw_closid_t hw_closid; - struct raw_resctrl_resource *rr; struct sd_closid closid; struct list_head *head; struct rdtgroup *entry; struct msr_param para; - - bool update_on; - - rr = r->res; + bool update_on, cdp_both_ctrl;

cfg = dom->staged_cfg; para.closid = &closid; @@ -188,6 +211,7 @@ static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, if (!cfg[i].have_new_ctrl) continue; update_on = false; + cdp_both_ctrl = cfg[i].cdp_both_ctrl; /* * for ctrl group configuration, hw_closid of cfg[i] equals * to rdtgrp->closid.intpartid. @@ -211,7 +235,7 @@ static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, } } if (update_on) - rr->msr_update(r, dom, &para); + resctrl_dom_ctrl_config(cdp_both_ctrl, r, dom, &para);

/* * we should synchronize all child mon groups' @@ -221,8 +245,9 @@ static void resctrl_group_update_domain_ctrls(struct rdtgroup *rdtgrp, list_for_each_entry(entry, head, mon.crdtgrp_list) { resctrl_cdp_map(clos, entry->closid.reqpartid, cfg[i].conf_type, hw_closid); + closid.reqpartid = hw_closid_val(hw_closid); - rr->msr_update(r, dom, &para); + resctrl_dom_ctrl_config(cdp_both_ctrl, r, dom, &para); } } } @@ -500,13 +525,33 @@ static inline char *get_resource_name(char *name) return res; }

+static u64 resctrl_dom_mon_data(struct resctrl_resource *r, + struct rdt_domain *d, void *md_priv) +{ + u64 ret; + union mon_data_bits md; + struct raw_resctrl_resource *rr; + + md.priv = md_priv; + rr = r->res; + ret = rr->mon_read(d, md.priv); + if (md.u.cdp_both_mon) { + hw_closid_t hw_closid; + + resctrl_cdp_map(clos, md.u.partid, CDP_DATA, hw_closid); + md.u.partid = hw_closid_val(hw_closid); + ret += rr->mon_read(d, md.priv); + } + + return ret; +} + int resctrl_group_mondata_show(struct seq_file *m, void *arg) { struct kernfs_open_file *of = m->private; struct rdtgroup *rdtgrp; struct rdt_domain *d; struct resctrl_resource *r; - struct raw_resctrl_resource *rr; union mon_data_bits md; int ret = 0; char *resname = get_resource_name(kernfs_node_name(of)); @@ -524,7 +569,6 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) md.priv = of->kn->priv;

r = mpam_resctrl_get_resource(md.u.rid); - rr = r->res;

/* show monitor data */ d = mpam_find_domain(r, md.u.domid, NULL); @@ -534,7 +578,8 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) goto out; }

- usage = rr->mon_read(d, md.priv); + usage = resctrl_dom_mon_data(r, d, md.priv); + /* * if this rdtgroup is ctrlmon group, also collect it's * mon groups' monitor data. @@ -558,7 +603,7 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) md.u.partid = hw_closid_val(hw_closid); md.u.pmg = entry->mon.rmid; md.u.mon = entry->mon.mon; - usage += rr->mon_read(d, md.priv); + usage += resctrl_dom_mon_data(r, d, md.priv); } }

@@ -614,6 +659,7 @@ static int resctrl_mkdir_mondata_dom(struct kernfs_node *parent_kn, resctrl_cdp_map(mon, prgrp->mon.mon, s->conf_type, hw_monid); md.u.mon = hw_monid_val(hw_monid); md.u.pmg = prgrp->mon.rmid; + md.u.cdp_both_mon = s->cdp_mc_both;

snprintf(name, sizeof(name), "mon_%s_%02d", s->name, d->id); kn = __kernfs_create_file(parent_kn, name, 0444, @@ -682,14 +728,20 @@ int resctrl_mkdir_mondata_all_subdir(struct kernfs_node *parent_kn, }

/* Initialize MBA resource with default values. */ -static void rdtgroup_init_mba(struct resctrl_resource *r, u32 closid) +static void rdtgroup_init_mba(struct resctrl_schema *s, u32 closid) { struct resctrl_staged_config *cfg; + struct resctrl_resource *r; struct rdt_domain *d; enum resctrl_ctrl_type t;

- list_for_each_entry(d, &r->domains, list) { + r = s->res; + if (WARN_ON(!r)) + return; + + list_for_each_entry(d, &s->res->domains, list) { cfg = &d->staged_cfg[CDP_BOTH]; + cfg->cdp_both_ctrl = s->cdp_mc_both; cfg->new_ctrl[SCHEMA_COMM] = r->default_ctrl[SCHEMA_COMM]; resctrl_cdp_map(clos, closid, CDP_BOTH, cfg->hw_closid); cfg->have_new_ctrl = true; @@ -727,6 +779,7 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid)

list_for_each_entry(d, &s->res->domains, list) { cfg = &d->staged_cfg[conf_type]; + cfg->cdp_both_ctrl = s->cdp_mc_both; cfg->have_new_ctrl = false; cfg->new_ctrl[SCHEMA_COMM] = r->cache.shareable_bits; used_b = r->cache.shareable_bits; @@ -769,7 +822,7 @@ int resctrl_group_init_alloc(struct rdtgroup *rdtgrp) list_for_each_entry(s, &resctrl_all_schema, list) { r = s->res; if (r->rid == RDT_RESOURCE_MC) { - rdtgroup_init_mba(r, rdtgrp->closid.intpartid); + rdtgroup_init_mba(s, rdtgrp->closid.intpartid); } else { ret = rdtgroup_init_cat(s, rdtgrp->closid.intpartid); if (ret < 0)

From: James Morse james.morse@arm.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

The MPAM MSC error interrupt tells us how we misconfigured the MSC. We don't expect to to this. If the interrupt fires, print a summary, and mark MPAM as broken. Eventually we will try and cleanly teardown when we see this.

Now we can register from a helper mpam_register_device_irq() to register overflow and error interrupt from mpam device, When devices come and go we want to make sure the error irq is enabled. We disable the error irq when cpus are taken offline in case the component remains online even when the associated CPUs are offline.

Code of this patch are borrowed from james james.morse@arm.com.

[Wang ShaoBo: few version adaptation changes]

Signed-off-by: James Morse james.morse@arm.com Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=6d1ceca3eb5953fc16a524... Link: http://www.linux-arm.org/git?p=linux-jm.git;a=patch;h=81d178c198165fd557431d... Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam_resource.h | 10 +- arch/arm64/kernel/mpam/mpam_device.c | 164 ++++++++++++++++++++++++- arch/arm64/kernel/mpam/mpam_device.h | 6 + arch/arm64/kernel/mpam/mpam_internal.h | 10 ++ drivers/acpi/arm64/mpam.c | 10 +- include/linux/arm_mpam.h | 51 ++++++++ 6 files changed, 246 insertions(+), 5 deletions(-)

diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/include/asm/mpam_resource.h index 72cc9029946f..412faca90e0b 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/include/asm/mpam_resource.h @@ -102,9 +102,17 @@ */ #define MPAMCFG_PART_SEL_INTERNAL BIT(16)

-/* MPAM_ESR */ +/* MPAMF_ESR - MPAM Error Status Register */ +#define MPAMF_ESR_PARTID_OR_MON GENMASK(15, 0) +#define MPAMF_ESR_PMG GENMASK(23, 16) +#define MPAMF_ESR_ERRCODE GENMASK(27, 24) +#define MPAMF_ESR_ERRCODE_SHIFT 24 +#define MPAMF_ESR_OVRWR BIT(31) #define MPAMF_ESR_ERRCODE_MASK ((BIT(4) - 1) << 24)

+/* MPAMF_ECR - MPAM Error Control Register */ +#define MPAMF_ECR_INTEN BIT(0) + /* * Size of the memory mapped registers: 4K of feature page then 2 x 4K * bitmap registers diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 70f27e0e12c9..c1a41b39e328 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -406,6 +406,129 @@ static int mpam_allocate_config(void) return 0; }

+static const char *mpam_msc_err_str[_MPAM_NUM_ERRCODE] = { + [MPAM_ERRCODE_NONE] = "No Error", + [MPAM_ERRCODE_PARTID_SEL_RANGE] = "Out of range PARTID selected", + [MPAM_ERRCODE_REQ_PARTID_RANGE] = "Out of range PARTID requested", + [MPAM_ERRCODE_REQ_PMG_RANGE] = "Out of range PMG requested", + [MPAM_ERRCODE_MONITOR_RANGE] = "Out of range Monitor selected", + [MPAM_ERRCODE_MSMONCFG_ID_RANGE] = "Out of range Monitor:PARTID or PMG written", + + /* These two are about PARTID narrowing, which we don't support */ + [MPAM_ERRCODE_INTPARTID_RANGE] = "Out or range Internal-PARTID written", + [MPAM_ERRCODE_UNEXPECTED_INTERNAL] = "Internal-PARTID set but not expected", +}; + + +static irqreturn_t mpam_handle_error_irq(int irq, void *data) +{ + u32 device_esr; + u16 device_errcode; + struct mpam_device *dev = data; + + spin_lock(&dev->lock); + device_esr = mpam_read_reg(dev, MPAMF_ESR); + spin_unlock(&dev->lock); + + device_errcode = (device_esr & MPAMF_ESR_ERRCODE) >> MPAMF_ESR_ERRCODE_SHIFT; + if (device_errcode == MPAM_ERRCODE_NONE) + return IRQ_NONE; + + /* No-one expects MPAM errors! */ + if (device_errcode <= _MPAM_NUM_ERRCODE) + pr_err_ratelimited("unexpected error '%s' [esr:%x]\n", + mpam_msc_err_str[device_errcode], + device_esr); + else + pr_err_ratelimited("unexpected error %d [esr:%x]\n", + device_errcode, device_esr); + + if (!cmpxchg(&mpam_broken, -EINTR, 0)) + schedule_work(&mpam_failed_work); + + /* A write of 0 to MPAMF_ESR.ERRCODE clears level interrupts */ + spin_lock(&dev->lock); + mpam_write_reg(dev, MPAMF_ESR, 0); + spin_unlock(&dev->lock); + + return IRQ_HANDLED; +} +/* register and enable all device error interrupts */ +static void mpam_enable_irqs(void) +{ + struct mpam_device *dev; + int rc, irq, request_flags; + unsigned long irq_save_flags; + + list_for_each_entry(dev, &mpam_all_devices, glbl_list) { + spin_lock_irqsave(&dev->lock, irq_save_flags); + irq = dev->error_irq; + request_flags = dev->error_irq_flags; + spin_unlock_irqrestore(&dev->lock, irq_save_flags); + + if (request_flags & MPAM_IRQ_MODE_LEVEL) { + struct cpumask tmp; + bool inaccessible_cpus; + + request_flags = IRQF_TRIGGER_LOW | IRQF_SHARED; + + /* + * If the MSC is not accessible from any CPU the IRQ + * may be migrated to, we won't be able to clear it. + * ~dev->fw_affinity is all the CPUs that can't access + * the MSC. 'and' cpu_possible_mask tells us whether we + * care. + */ + spin_lock_irqsave(&dev->lock, irq_save_flags); + inaccessible_cpus = cpumask_andnot(&tmp, + cpu_possible_mask, + &dev->fw_affinity); + spin_unlock_irqrestore(&dev->lock, irq_save_flags); + + if (inaccessible_cpus) { + pr_err_once("NOT registering MPAM error level-irq that isn't globally reachable"); + continue; + } + } else { + request_flags = IRQF_TRIGGER_RISING | IRQF_SHARED; + } + + rc = request_irq(irq, mpam_handle_error_irq, request_flags, + "MPAM ERR IRQ", dev); + if (rc) { + pr_err_ratelimited("Failed to register irq %u\n", irq); + continue; + } + + /* + * temporary: the interrupt will only be enabled when cpus + * subsequently come online after mpam_enable(). + */ + spin_lock_irqsave(&dev->lock, irq_save_flags); + dev->enable_error_irq = true; + spin_unlock_irqrestore(&dev->lock, irq_save_flags); + } +} + +static void mpam_disable_irqs(void) +{ + int irq; + bool do_unregister; + struct mpam_device *dev; + unsigned long irq_save_flags; + + list_for_each_entry(dev, &mpam_all_devices, glbl_list) { + spin_lock_irqsave(&dev->lock, irq_save_flags); + irq = dev->error_irq; + do_unregister = dev->enable_error_irq; + dev->enable_error_irq = false; + spin_unlock_irqrestore(&dev->lock, irq_save_flags); + + if (do_unregister) + free_irq(irq, dev); + } +} + /* * Enable mpam once all devices have been probed. * Scheduled by mpam_discovery_complete() once all devices have been created. @@ -441,6 +564,8 @@ static void __init mpam_enable(struct work_struct *work) return; mutex_unlock(&mpam_devices_lock);

+ mpam_enable_irqs(); + /* * mpam_enable() runs in parallel with cpuhp callbacks bringing other * CPUs online, as we eagerly schedule the work. To give resctrl a @@ -484,6 +609,8 @@ static void mpam_failed(struct work_struct *work) if (mpam_cpuhp_state) { cpuhp_remove_state(mpam_cpuhp_state); mpam_cpuhp_state = 0; + + mpam_disable_irqs(); } mutex_unlock(&mpam_cpuhp_lock); } @@ -679,6 +806,28 @@ __mpam_device_create(u8 level_idx, enum mpam_class_types type, return dev; }

+void __init mpam_device_set_error_irq(struct mpam_device *dev, u32 irq, + u32 flags) +{ + unsigned long irq_save_flags; + + spin_lock_irqsave(&dev->lock, irq_save_flags); + dev->error_irq = irq; + dev->error_irq_flags = flags & MPAM_IRQ_FLAGS_MASK; + spin_unlock_irqrestore(&dev->lock, irq_save_flags); +} + +void __init mpam_device_set_overflow_irq(struct mpam_device *dev, u32 irq, + u32 flags) +{ + unsigned long irq_save_flags; + + spin_lock_irqsave(&dev->lock, irq_save_flags); + dev->overflow_irq = irq; + dev->overflow_irq_flags = flags & MPAM_IRQ_FLAGS_MASK; + spin_unlock_irqrestore(&dev->lock, irq_save_flags); +} + static int mpam_cpus_have_feature(void) { if (!cpus_have_const_cap(ARM64_HAS_MPAM)) @@ -803,6 +952,9 @@ static void mpam_reset_device(struct mpam_component *comp,

lockdep_assert_held(&dev->lock);

+ if (dev->enable_error_irq) + mpam_write_reg(dev, MPAMF_ECR, MPAMF_ECR_INTEN); + if (!mpam_has_feature(mpam_feat_part_nrw, dev->features)) { for (partid = 0; partid < dev->num_partid; partid++) mpam_reset_device_config(comp, dev, partid); @@ -924,12 +1076,22 @@ static int mpam_cpu_online(unsigned int cpu)

static int mpam_cpu_offline(unsigned int cpu) { + unsigned long flags; struct mpam_device *dev;

mutex_lock(&mpam_devices_lock); - list_for_each_entry(dev, &mpam_all_devices, glbl_list) + list_for_each_entry(dev, &mpam_all_devices, glbl_list) { + if (!cpumask_test_cpu(cpu, &dev->online_affinity)) + continue; cpumask_clear_cpu(cpu, &dev->online_affinity);

+ if (cpumask_empty(&dev->online_affinity)) { + spin_lock_irqsave(&dev->lock, flags); + mpam_write_reg(dev, MPAMF_ECR, 0); + spin_unlock_irqrestore(&dev->lock, flags); + } + } + mutex_unlock(&mpam_devices_lock);

if (resctrl_registered) diff --git a/arch/arm64/kernel/mpam/mpam_device.h b/arch/arm64/kernel/mpam/mpam_device.h index fc5f7c292b6f..f3ebd3f8b23d 100644 --- a/arch/arm64/kernel/mpam/mpam_device.h +++ b/arch/arm64/kernel/mpam/mpam_device.h @@ -58,6 +58,12 @@ struct mpam_device { /* for reset device MPAMCFG_PRI */ u16 hwdef_intpri; u16 hwdef_dspri; + + bool enable_error_irq; + u32 error_irq; + u32 error_irq_flags; + u32 overflow_irq; + u32 overflow_irq_flags; };

/* diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 0ca58712a8ca..974a0b0784fa 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -20,6 +20,16 @@ extern struct list_head mpam_classes;

#define MAX_MBA_BW 100u

+#define MPAM_ERRCODE_NONE 0 +#define MPAM_ERRCODE_PARTID_SEL_RANGE 1 +#define MPAM_ERRCODE_REQ_PARTID_RANGE 2 +#define MPAM_ERRCODE_MSMONCFG_ID_RANGE 3 +#define MPAM_ERRCODE_REQ_PMG_RANGE 4 +#define MPAM_ERRCODE_MONITOR_RANGE 5 +#define MPAM_ERRCODE_INTPARTID_RANGE 6 +#define MPAM_ERRCODE_UNEXPECTED_INTERNAL 7 +#define _MPAM_NUM_ERRCODE 8 + struct mpam_resctrl_dom { struct mpam_component *comp;

diff --git a/drivers/acpi/arm64/mpam.c b/drivers/acpi/arm64/mpam.c index 10e4769d5227..6c238f5a5c5a 100644 --- a/drivers/acpi/arm64/mpam.c +++ b/drivers/acpi/arm64/mpam.c @@ -93,7 +93,7 @@ static int acpi_mpam_label_memory_component_id(u8 proximity_domain,

static int __init acpi_mpam_parse_memory(struct acpi_mpam_header *h) { - int ret = 0; + int ret; u32 component_id; struct mpam_device *dev; struct acpi_mpam_node_memory *node = (struct acpi_mpam_node_memory *)h; @@ -112,7 +112,9 @@ static int __init acpi_mpam_parse_memory(struct acpi_mpam_header *h) return -EINVAL; }

- return ret; + return mpam_register_device_irq(dev, + node->header.overflow_interrupt, node->header.overflow_flags, + node->header.error_interrupt, node->header.error_interrupt_flags); }

static int __init acpi_mpam_parse_cache(struct acpi_mpam_header *h, @@ -178,7 +180,9 @@ static int __init acpi_mpam_parse_cache(struct acpi_mpam_header *h, return -EINVAL; }

- return ret; + return mpam_register_device_irq(dev, + node->header.overflow_interrupt, node->header.overflow_flags, + node->header.error_interrupt, node->header.error_interrupt_flags); }

static int __init acpi_mpam_parse_table(struct acpi_table_header *table, diff --git a/include/linux/arm_mpam.h b/include/linux/arm_mpam.h index 9a00c7984d91..44d0690ae8c4 100644 --- a/include/linux/arm_mpam.h +++ b/include/linux/arm_mpam.h @@ -2,6 +2,7 @@ #ifndef __LINUX_ARM_MPAM_H #define __LINUX_ARM_MPAM_H

+#include <linux/acpi.h> #include <linux/err.h> #include <linux/cpumask.h> #include <linux/types.h> @@ -64,4 +65,54 @@ enum mpam_enable_type {

extern enum mpam_enable_type mpam_enabled;

+#define MPAM_IRQ_MODE_LEVEL 0x1 +#define MPAM_IRQ_FLAGS_MASK 0x7f + +#define mpam_irq_flags_to_acpi(x) ((x & MPAM_IRQ_MODE_LEVEL) ? \ + ACPI_LEVEL_SENSITIVE : ACPI_EDGE_SENSITIVE) + +void __init mpam_device_set_error_irq(struct mpam_device *dev, u32 irq, + u32 flags); +void __init mpam_device_set_overflow_irq(struct mpam_device *dev, u32 irq, + u32 flags); + +static inline int __init mpam_register_device_irq(struct mpam_device *dev, + u32 overflow_interrupt, u32 overflow_flags, + u32 error_interrupt, u32 error_flags) +{ + int irq, trigger; + int ret = 0; + u8 irq_flags; + + if (overflow_interrupt) { + irq_flags = overflow_flags & MPAM_IRQ_FLAGS_MASK; + trigger = mpam_irq_flags_to_acpi(irq_flags); + + irq = acpi_register_gsi(NULL, overflow_interrupt, trigger, + ACPI_ACTIVE_HIGH); + if (irq < 0) { + pr_err_once("Failed to register overflow interrupt with ACPI\n"); + return ret; + } + + mpam_device_set_overflow_irq(dev, irq, irq_flags); + } + + if (error_interrupt) { + irq_flags = error_flags & MPAM_IRQ_FLAGS_MASK; + trigger = mpam_irq_flags_to_acpi(irq_flags); + + irq = acpi_register_gsi(NULL, error_interrupt, trigger, + ACPI_ACTIVE_HIGH); + if (irq < 0) { + pr_err_once("Failed to register error interrupt with ACPI\n"); + return ret; + } + + mpam_device_set_error_irq(dev, irq, irq_flags); + } + + return ret; +} + #endif

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

So far we use sd_closid, including {reqpartid, intpartid}, to label each resctrl group including ctrlgroup and mongroup, This can perfectly handle this case where number of reqpartid exceeds intpartid, this always happen when intpartid narrowing supported, otherwise their two are of same number. So we use excessive reqpartid to indicate (1)- how configurations can be synchronized from the configuration indexed by intpartid, not only that, (2)- take part of monitor role.

But reqpartid in (2) with pmg still be scattered, So far we have not yet a right way to explain how can we use their two properly. In order to ensure their resources can be fully utilized, and given this idea from Intel-RDT's design which uses rmid for monitoring, a rmid remap matrix is delivered for transforming partid and pmg to rmid, this matrix is organized like this:

[bitmap entry indexed by partid] [col pos is partid]

[0] [1] [2] [3] [4] [5] occ->bitmap[:0] 1 0 0 1 1 1 bitmap[:1] 1 0 0 1 1 1 bitmap[:2] 1 1 1 1 1 1 bitmap[:3] 1 1 1 1 1 1 [row pos-1 is pmg]

Calculate rmid = partid + NR_partid * pmg

occ represents if this bitmap has been used by a partid, it is because a certain partid should not be accompany with a duplicated pmg for monitoring, this design easily saves a lot of space, and can also decrease time complexity of allocating and free rmid process from O(NR_partid)* O(NR_pmg) to O(NR_partid) + O(log(NR_pmg)) compared with using list.

By this way, we get a continuous rmid set with upper bound(NR_pmg * NR_partid - 1), given an rmid we can assume that if it's a valid rmid by judging whether it falls within this range or not.

rmid implicts the reqpartid info, so we can use relevant helpers to get this reqpartid for sd_closid@reqpartid and perfectly accomplish this configuration sync mission, this also makes closid simpler which can be consists of intpartid index only, also each resctrl group is happy to own consecutive rmid.

This also has some profound influences, for instance for MPAM there also support SMMU io using partid and pmg, we can use a single helper mpam_rmid_to_partid_pmg() in SMMU driver to complete this remap process for rmid input from outside user space.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 3 +- arch/arm64/include/asm/resctrl.h | 55 +-- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 17 +- arch/arm64/kernel/mpam/mpam_mon.c | 49 --- arch/arm64/kernel/mpam/mpam_resctrl.c | 506 +++++++++++++++++++++----- fs/resctrlfs.c | 138 +++---- 6 files changed, 529 insertions(+), 239 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 5fac0fb3c807..014d5728f607 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -362,7 +362,8 @@ int resctrl_group_alloc_mon(struct rdtgroup *grp);

u16 mpam_resctrl_max_mon_num(void);

-void pmg_init(void); void mon_init(void);

+extern int mpam_rmid_to_partid_pmg(int rmid, int *partid, int *pmg); + #endif /* _ASM_ARM64_MPAM_H */ diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index 1cd24441d2e6..40f97b1ddb83 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -2,6 +2,7 @@ #define _ASM_ARM64_RESCTRL_H

#include <asm/mpam_sched.h> +#include <asm/mpam.h>

#define resctrl_group rdtgroup #define resctrl_alloc_capable rdt_alloc_capable @@ -95,17 +96,12 @@ void schemata_list_destroy(void);

int resctrl_lru_request_mon(void);

-int alloc_rmid(void); -void free_rmid(u32 id); +int rmid_alloc(int entry_idx); +void rmid_free(int rmid);

-enum closid_type { - CLOSID_INT = 0x1, - CLOSID_REQ = 0x2, - CLOSID_NUM_TYPES, -}; int resctrl_id_init(void); -int resctrl_id_alloc(enum closid_type); -void resctrl_id_free(enum closid_type, int id); +int closid_alloc(void); +void closid_free(int closid);

void update_cpu_closid_rmid(void *info); void update_closid_rmid(const struct cpumask *cpu_mask, struct resctrl_group *r); @@ -152,20 +148,35 @@ int resctrl_update_groups_config(struct rdtgroup *rdtgrp); #define RESCTRL_MAX_CLOSID 32

/* - * left 16 bits of closid store parent(master)'s - * closid, the reset store current group's closid, - * this used for judging if tasks are allowed to move - * another ctrlmon/mon group, it is because when - * a mon group is permited to allocated another - * closid different from it's parent, only closid - * is not sufficient to do that. + * This is only for avoiding unnecessary cost in mpam_sched_in() + * called by __switch_to() if using mpam_rmid_to_partid_pmg() + * to get partid and pmg, we just simply shift and get their + * two easily when we want. */ -#define TASK_CLOSID_SET(prclosid, closid) \ - ((prclosid << 16) | closid) +static inline void resctrl_navie_rmid_partid_pmg(u32 rmid, int *partid, int *pmg) +{ + *partid = rmid >> 16; + *pmg = (rmid << 16) >> 16; +} + +static inline u32 resctrl_navie_rmid(u32 rmid) +{ + int ret, partid, pmg; + + ret = mpam_rmid_to_partid_pmg(rmid, (int *)&partid, (int *)&pmg); + if (ret) + return 0;

-#define TASK_CLOSID_CUR_GET(closid) \ - (closid & GENMASK(15, 0)) -#define TASK_CLOSID_PR_GET(closid) \ - ((closid & GENMASK(31, 16)) >> 16) + return (partid << 16) | pmg; +} + +/* + * closid.reqpartid is used as part of mapping to rmid, now + * we only need to map intpartid to closid. + */ +static inline u32 resctrl_navie_closid(struct sd_closid closid) +{ + return closid.intpartid; +}

#endif /* _ASM_ARM64_RESCTRL_H */ diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index fa4d4ee3af5b..ddb5f099a1b4 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -556,6 +556,7 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) int ret = 0; char *resname = get_resource_name(kernfs_node_name(of)); u64 usage; + int pmg;

if (!resname) return -ENOMEM; @@ -601,7 +602,13 @@ int resctrl_group_mondata_show(struct seq_file *m, void *arg) resctrl_cdp_map(clos, entry->closid.reqpartid, type, hw_closid); md.u.partid = hw_closid_val(hw_closid); - md.u.pmg = entry->mon.rmid; + + ret = mpam_rmid_to_partid_pmg(entry->mon.rmid, + NULL, &pmg); + if (ret) + return ret; + + md.u.pmg = pmg; md.u.mon = entry->mon.mon; usage += resctrl_dom_mon_data(r, d, md.priv); } @@ -647,6 +654,7 @@ static int resctrl_mkdir_mondata_dom(struct kernfs_node *parent_kn, struct kernfs_node *kn; char name[32]; int ret = 0; + int pmg;

r = s->res; rr = r->res; @@ -658,7 +666,12 @@ static int resctrl_mkdir_mondata_dom(struct kernfs_node *parent_kn, md.u.partid = hw_closid_val(hw_closid); resctrl_cdp_map(mon, prgrp->mon.mon, s->conf_type, hw_monid); md.u.mon = hw_monid_val(hw_monid); - md.u.pmg = prgrp->mon.rmid; + + ret = mpam_rmid_to_partid_pmg(prgrp->mon.rmid, NULL, &pmg); + if (ret) + return ret; + md.u.pmg = pmg; + md.u.cdp_both_mon = s->cdp_mc_both;

snprintf(name, sizeof(name), "mon_%s_%02d", s->name, d->id); diff --git a/arch/arm64/kernel/mpam/mpam_mon.c b/arch/arm64/kernel/mpam/mpam_mon.c index 8dfdba6a5ba2..0f1b2663399d 100644 --- a/arch/arm64/kernel/mpam/mpam_mon.c +++ b/arch/arm64/kernel/mpam/mpam_mon.c @@ -34,55 +34,6 @@ */ bool rdt_mon_capable;

-static int pmg_free_map; -void pmg_init(void) -{ - u16 num_pmg = USHRT_MAX; - struct mpam_resctrl_res *res; - struct resctrl_resource *r; - struct raw_resctrl_resource *rr; - - /* Use the max num_pmg among all resources */ - for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; - rr = r->res; - num_pmg = min(num_pmg, rr->num_pmg); - } - - pmg_free_map = BIT_MASK(num_pmg) - 1; - - /* pmg 0 is always reserved for the default group */ - pmg_free_map &= ~1; -} - -static int alloc_pmg(void) -{ - u32 pmg = ffs(pmg_free_map); - - if (pmg == 0) - return -ENOSPC; - - pmg--; - pmg_free_map &= ~(1 << pmg); - - return pmg; -} - -static void free_pmg(u32 pmg) -{ - pmg_free_map |= 1 << pmg; -} - -int alloc_rmid(void) -{ - return alloc_pmg(); -} - -void free_rmid(u32 id) -{ - free_pmg(id); -} - /* * A simple LRU monitor allocation machanism, each * monitor free map occupies two section, one for diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index f23bd231cc33..5550887d366a 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -476,8 +476,8 @@ common_wrmon(struct rdt_domain *d, void *md_priv) * limited as the number of resources grows. */

-static unsigned long *intpartid_free_map, *reqpartid_free_map; static int num_intpartid, num_reqpartid; +static unsigned long *intpartid_free_map;

static void mpam_resctrl_closid_collect(void) { @@ -513,83 +513,435 @@ static void mpam_resctrl_closid_collect(void) } }

-static inline int local_closid_bitmap_init(int bits_num, unsigned long **ptr) +int closid_bitmap_init(void) { int pos; u32 times, flag; + u32 bits_num;

+ mpam_resctrl_closid_collect(); + bits_num = num_intpartid; hw_alloc_times_validate(times, flag); + bits_num = rounddown(bits_num, times); + if (!bits_num) + return -EINVAL;

- if (flag) - bits_num = rounddown(bits_num, 2); + if (intpartid_free_map) + kfree(intpartid_free_map);

- if (!*ptr) { - *ptr = bitmap_zalloc(bits_num, GFP_KERNEL); - if (!*ptr) - return -ENOMEM; - } + intpartid_free_map = bitmap_zalloc(bits_num, GFP_KERNEL); + if (!intpartid_free_map) + return -ENOMEM;

- bitmap_set(*ptr, 0, bits_num); + bitmap_set(intpartid_free_map, 0, bits_num);

/* CLOSID 0 is always reserved for the default group */ - pos = find_first_bit(*ptr, bits_num); - bitmap_clear(*ptr, pos, times); + pos = find_first_bit(intpartid_free_map, bits_num); + bitmap_clear(intpartid_free_map, pos, times);

return 0; }

-int closid_bitmap_init(void) +/** + * struct rmid_transform - Matrix for transforming rmid to partid and pmg + * @rows: Number of bits for remap_body[:] bitmap + * @clos: Number of bitmaps + * @nr_usage: Number rmid we have + * @stride: Step stride from transforming rmid to partid and pmg + * @remap_body: Storing bitmaps' entry and itself + * @remap_enabled: Does remap_body init done + */ +struct rmid_transform { + u32 rows; + u32 cols; + u32 nr_usage; + int stride; + unsigned long **remap_body; + bool remap_enabled; +}; +static struct rmid_transform rmid_remap_matrix; + +/* + * a rmid remap matrix is delivered for transforming partid pmg to rmid, + * this matrix is organized like this: + * + * [bitmap entry indexed by partid] + * + * [0] [1] [2] [3] [4] [5] + * occ 1 0 0 1 1 1 + * bitmap[:0] 1 0 0 1 1 1 + * bitmap[:1] 1 1 1 1 1 1 + * bitmap[:2] 1 1 1 1 1 1 + * [pos is pmg] + * + * Calculate rmid = partid + NR_partid * pmg + * + * occ represents if this bitmap has been used by a partid, it is because + * a certain partid should not be accompany with a duplicated pmg for + * monitoring, this design easily saves a lot of space, and can also decrease + * time complexity of allocating and free rmid process from O(NR_partid)* + * O(NR_pmg) to O(NR_partid) + O(log(NR_pmg)) compared with using list. + */ +static int set_rmid_remap_matrix(u32 rows, u32 cols) { - int ret; + u32 times, flag; + int ret, col;

- mpam_resctrl_closid_collect(); - if (!num_intpartid || !num_reqpartid) + /* + * cols stands for partid, so if cdp enabled we must + * keep at least two partid for LxCODE and LxDATA + * respectively once time. + */ + hw_alloc_times_validate(times, flag); + rmid_remap_matrix.cols = rounddown(cols, times); + rmid_remap_matrix.stride = times; + if (times > rmid_remap_matrix.cols) return -EINVAL;

- if (intpartid_free_map) - kfree(intpartid_free_map); - if (reqpartid_free_map) - kfree(reqpartid_free_map); + /* + * first row of rmid remap matrix is used for indicating + * if remap bitmap is occupied by a col index. + */ + rmid_remap_matrix.rows = rows + 1; + + if (rows == 0 || cols == 0) + return -EINVAL; + + rmid_remap_matrix.nr_usage = rows * cols; + + /* free history pointer for matrix recreation */ + if (rmid_remap_matrix.remap_body) { + for (col = 0; col < cols; col++) { + if (!rmid_remap_matrix.remap_body[col]) + continue; + kfree(rmid_remap_matrix.remap_body[col]); + } + kfree(rmid_remap_matrix.remap_body); + } + + rmid_remap_matrix.remap_body = kcalloc(rmid_remap_matrix.cols, + sizeof(*rmid_remap_matrix.remap_body), GFP_KERNEL); + if (!rmid_remap_matrix.remap_body) + return -ENOMEM; + + for (col = 0; col < cols; col++) { + if (rmid_remap_matrix.remap_body[col]) + kfree(rmid_remap_matrix.remap_body[col]); + + rmid_remap_matrix.remap_body[col] = + bitmap_zalloc(rmid_remap_matrix.rows, + GFP_KERNEL); + if (!rmid_remap_matrix.remap_body[col]) { + ret = -ENOMEM; + goto clean; + } + + bitmap_set(rmid_remap_matrix.remap_body[col], + 0, rmid_remap_matrix.rows); + } + + rmid_remap_matrix.remap_enabled = 1; + + return 0; +clean: + for (col = 0; col < cols; col++) { + if (!rmid_remap_matrix.remap_body[col]) + continue; + kfree(rmid_remap_matrix.remap_body[col]); + rmid_remap_matrix.remap_body[col] = NULL; + } + if (rmid_remap_matrix.remap_body) { + kfree(rmid_remap_matrix.remap_body); + rmid_remap_matrix.remap_body = NULL; + } + + return ret; +} + +static u32 probe_rmid_remap_matrix_cols(void) +{ + return (u32)num_reqpartid; +} + +static u32 probe_rmid_remap_matrix_rows(void) +{ + return (u32)mpam_sysprops_num_pmg(); +} + +static inline unsigned long **__rmid_remap_bmp(int col) +{ + if (!rmid_remap_matrix.remap_enabled) + return NULL; + + if ((u32)col >= rmid_remap_matrix.cols) + return NULL; + + return rmid_remap_matrix.remap_body + col; +} + +#define for_each_rmid_remap_bmp(bmp) \ + for (bmp = __rmid_remap_bmp(0); \ + bmp <= __rmid_remap_bmp(rmid_remap_matrix.cols - 1); \ + bmp++) + +#define for_each_valid_rmid_remap_bmp(bmp) \ + for_each_rmid_remap_bmp(bmp) \ + if (bmp && *bmp) + +#define STRIDE_CHK(stride) \ + (stride == rmid_remap_matrix.stride) + +#define STRIDE_INC_CHK(stride) \ + (++stride == rmid_remap_matrix.stride) + +#define STRIDE_CHK_AND_WARN(stride) \ +do { \ + if (!STRIDE_CHK(stride)) \ + WARN_ON_ONCE("Unexpected stride\n"); \ +} while (0) + +static void set_rmid_remap_bmp_occ(unsigned long *bmp) +{ + clear_bit(0, bmp); +} + +static void unset_rmid_remap_bmp_occ(unsigned long *bmp) +{ + set_bit(0, bmp); +} + +static void rmid_remap_bmp_bdr_set(unsigned long *bmp, int b) +{ + set_bit(b + 1, bmp); +}

- ret = local_closid_bitmap_init(num_intpartid, &intpartid_free_map); +static void rmid_remap_bmp_bdr_clear(unsigned long *bmp, int b) +{ + clear_bit(b + 1, bmp); +} + +static int is_rmid_remap_bmp_occ(unsigned long *bmp) +{ + return (find_first_bit(bmp, rmid_remap_matrix.rows) == 0) ? 0 : 1; +} + +static int is_rmid_remap_bmp_full(unsigned long *bmp) +{ + return ((is_rmid_remap_bmp_occ(bmp) && + bitmap_weight(bmp, rmid_remap_matrix.rows) == + (rmid_remap_matrix.rows-1)) || + bitmap_full(bmp, rmid_remap_matrix.rows)); +} + +static int rmid_remap_bmp_alloc_pmg(unsigned long *bmp) +{ + int pos; + + pos = find_first_bit(bmp, rmid_remap_matrix.rows); + if (pos == rmid_remap_matrix.rows) + return -ENOSPC; + + clear_bit(pos, bmp); + return pos - 1; +} + +static int rmid_remap_matrix_init(void) +{ + int stride = 0; + int ret; + u32 cols, rows; + unsigned long **bmp; + + cols = probe_rmid_remap_matrix_cols(); + rows = probe_rmid_remap_matrix_rows(); + + ret = set_rmid_remap_matrix(rows, cols); if (ret) goto out;

- ret = local_closid_bitmap_init(num_reqpartid, &reqpartid_free_map); + /* + * if CDP disabled, drop partid = 0, pmg = 0 + * from bitmap for root resctrl group reserving + * default rmid, otherwise drop partid = 0 and + * partid = 1 for LxCACHE, LxDATA reservation. + */ + for_each_valid_rmid_remap_bmp(bmp) { + set_rmid_remap_bmp_occ(*bmp); + rmid_remap_bmp_bdr_clear(*bmp, 0); + if (STRIDE_INC_CHK(stride)) + break; + } + + STRIDE_CHK_AND_WARN(stride); + + return 0; + +out: + return ret; +} + +int resctrl_id_init(void) +{ + int ret; + + ret = closid_bitmap_init(); if (ret) - goto out; + return ret; + + ret = rmid_remap_matrix_init(); + if (ret) + return ret; + + mon_init();

return 0; +} + +static int is_rmid_valid(int rmid) +{ + return ((u32)rmid >= rmid_remap_matrix.nr_usage) ? 0 : 1; +} + +static int to_rmid(int partid, int pmg) +{ + return (partid + (rmid_remap_matrix.cols * pmg)); +} + +static int rmid_to_partid_pmg(int rmid, int *partid, int *pmg) +{ + if (!is_rmid_valid(rmid)) + return -EINVAL; + + if (pmg) + *pmg = rmid / rmid_remap_matrix.cols; + if (partid) + *partid = rmid % rmid_remap_matrix.cols; + return 0; +} + +static int __rmid_alloc(int partid) +{ + int stride = 0; + int partid_sel = 0; + int ret, pmg; + int rmid[2] = {-1, -1}; + unsigned long **cmp, **bmp; + + if (partid >= 0) { + cmp = __rmid_remap_bmp(partid); + if (!cmp) { + ret = -EINVAL; + goto out; + } + for_each_valid_rmid_remap_bmp(bmp) { + if (bmp < cmp) + continue; + set_rmid_remap_bmp_occ(*bmp); + + ret = rmid_remap_bmp_alloc_pmg(*bmp); + if (ret < 0) + goto out; + pmg = ret; + rmid[stride] = to_rmid(partid + stride, pmg); + if (STRIDE_INC_CHK(stride)) + break; + } + } else { + for_each_valid_rmid_remap_bmp(bmp) { + partid_sel++; + + if (is_rmid_remap_bmp_occ(*bmp)) + continue; + set_rmid_remap_bmp_occ(*bmp); + + ret = rmid_remap_bmp_alloc_pmg(*bmp); + if (ret < 0) + goto out; + pmg = ret; + rmid[stride] = to_rmid(partid_sel - 1, pmg); + if (STRIDE_INC_CHK(stride)) + break; + } + } + + if (!STRIDE_CHK(stride)) { + ret = -ENOSPC; + goto out; + } + + return rmid[0]; + out: + rmid_free(rmid[0]); return ret; }

+int rmid_alloc(int partid) +{ + return __rmid_alloc(partid); +} + +void rmid_free(int rmid) +{ + int stride = 0; + int partid, pmg; + unsigned long **bmp, **cmp; + + if (rmid_to_partid_pmg(rmid, &partid, &pmg)) + return; + + cmp = __rmid_remap_bmp(partid); + if (!cmp) + return; + + for_each_valid_rmid_remap_bmp(bmp) { + if (bmp < cmp) + continue; + + rmid_remap_bmp_bdr_set(*bmp, pmg); + + if (is_rmid_remap_bmp_full(*bmp)) + unset_rmid_remap_bmp_occ(*bmp); + + if (STRIDE_INC_CHK(stride)) + break; + } + + STRIDE_CHK_AND_WARN(stride); +} + +int mpam_rmid_to_partid_pmg(int rmid, int *partid, int *pmg) +{ + return rmid_to_partid_pmg(rmid, partid, pmg); +} +EXPORT_SYMBOL(mpam_rmid_to_partid_pmg); + /* * If cdp enabled, allocate two closid once time, then return first * allocated id. */ -static int closid_bitmap_alloc(int bits_num, unsigned long *ptr) +int closid_alloc(void) { int pos; u32 times, flag;

hw_alloc_times_validate(times, flag);

- pos = find_first_bit(ptr, bits_num); - if (pos == bits_num) + pos = find_first_bit(intpartid_free_map, num_intpartid); + if (pos == num_intpartid) return -ENOSPC;

- bitmap_clear(ptr, pos, times); + bitmap_clear(intpartid_free_map, pos, times);

return pos; }

-static void closid_bitmap_free(int pos, unsigned long *ptr) +void closid_free(int closid) { u32 times, flag;

hw_alloc_times_validate(times, flag); - bitmap_set(ptr, pos, times); + bitmap_set(intpartid_free_map, closid, times); }

/* @@ -773,8 +1125,8 @@ void update_cpu_closid_rmid(void *info) struct rdtgroup *r = info;

if (r) { - this_cpu_write(pqr_state.default_closid, r->closid.reqpartid); - this_cpu_write(pqr_state.default_rmid, r->mon.rmid); + this_cpu_write(pqr_state.default_closid, resctrl_navie_closid(r->closid)); + this_cpu_write(pqr_state.default_rmid, resctrl_navie_rmid(r->mon.rmid)); }

/* @@ -868,15 +1220,12 @@ int __resctrl_group_move_task(struct task_struct *tsk, * their parent CTRL group. */ if (rdtgrp->type == RDTCTRL_GROUP) { - tsk->closid = TASK_CLOSID_SET(rdtgrp->closid.intpartid, - rdtgrp->closid.reqpartid); - tsk->rmid = rdtgrp->mon.rmid; + tsk->closid = resctrl_navie_closid(rdtgrp->closid); + tsk->rmid = resctrl_navie_rmid(rdtgrp->mon.rmid); } else if (rdtgrp->type == RDTMON_GROUP) { - if (rdtgrp->mon.parent->closid.intpartid == - TASK_CLOSID_PR_GET(tsk->closid)) { - tsk->closid = TASK_CLOSID_SET(rdtgrp->closid.intpartid, - rdtgrp->closid.reqpartid); - tsk->rmid = rdtgrp->mon.rmid; + if (rdtgrp->mon.parent->closid.intpartid == tsk->closid) { + tsk->closid = resctrl_navie_closid(rdtgrp->closid); + tsk->rmid = resctrl_navie_rmid(rdtgrp->mon.rmid); } else { rdt_last_cmd_puts("Can't move task to different control group\n"); ret = -EINVAL; @@ -1274,13 +1623,10 @@ static void show_resctrl_tasks(struct rdtgroup *r, struct seq_file *s) rcu_read_lock(); for_each_process_thread(p, t) { if ((r->type == RDTMON_GROUP && - TASK_CLOSID_CUR_GET(t->closid) == r->closid.reqpartid && - t->rmid == r->mon.rmid) || + t->rmid == resctrl_navie_rmid(r->mon.rmid)) || (r->type == RDTCTRL_GROUP && - TASK_CLOSID_PR_GET(t->closid) == r->closid.intpartid)) - seq_printf(s, "group:(gid:%d mon:%d) task:(pid:%d gid:%d rmid:%d)\n", - r->closid.reqpartid, r->mon.mon, t->pid, - (int)TASK_CLOSID_CUR_GET(t->closid), t->rmid); + t->closid == resctrl_navie_closid(r->closid))) + seq_printf(s, "%d\n", t->pid); } rcu_read_unlock(); } @@ -1431,9 +1777,11 @@ int __init mpam_resctrl_init(void) void __mpam_sched_in(void) { struct intel_pqr_state *state = this_cpu_ptr(&pqr_state); - u64 closid = state->default_closid; u64 partid_d, partid_i; - u64 pmg = state->default_rmid; + u64 rmid = state->default_rmid; + u64 closid = state->default_closid; + u64 reqpartid = 0; + u64 pmg = 0;

/* * If this task has a closid/rmid assigned, use it. @@ -1441,35 +1789,28 @@ void __mpam_sched_in(void) */ if (static_branch_likely(&resctrl_alloc_enable_key)) { if (current->closid) - closid = TASK_CLOSID_CUR_GET(current->closid); + closid = current->closid; }

if (static_branch_likely(&resctrl_mon_enable_key)) { if (current->rmid) - pmg = current->rmid; + rmid = current->rmid; }

- if (closid != state->cur_closid || pmg != state->cur_rmid) { + if (closid != state->cur_closid || rmid != state->cur_rmid) { u64 reg;

+ resctrl_navie_rmid_partid_pmg(rmid, (int *)&reqpartid, (int *)&pmg); + if (resctrl_cdp_enabled) { hw_closid_t hw_closid;

- resctrl_cdp_map(clos, closid, CDP_DATA, hw_closid); + resctrl_cdp_map(clos, reqpartid, CDP_DATA, hw_closid); partid_d = hw_closid_val(hw_closid);

- resctrl_cdp_map(clos, closid, CDP_CODE, hw_closid); + resctrl_cdp_map(clos, reqpartid, CDP_CODE, hw_closid); partid_i = hw_closid_val(hw_closid);

- /* - * when cdp enabled, we use partid_i to label cur_closid - * of cpu state instead of partid_d, because each task/ - * rdtgrp's closid is labeled by CDP_BOTH/CDP_CODE but not - * CDP_DATA. - */ - state->cur_closid = partid_i; - state->cur_rmid = pmg; - /* set in EL0 */ reg = mpam_read_sysreg_s(SYS_MPAM0_EL1, "SYS_MPAM0_EL1"); reg = PARTID_D_SET(reg, partid_d); @@ -1484,21 +1825,21 @@ void __mpam_sched_in(void) reg = PMG_SET(reg, pmg); mpam_write_sysreg_s(reg, SYS_MPAM1_EL1, "SYS_MPAM1_EL1"); } else { - state->cur_closid = closid; - state->cur_rmid = pmg; - /* set in EL0 */ reg = mpam_read_sysreg_s(SYS_MPAM0_EL1, "SYS_MPAM0_EL1"); - reg = PARTID_SET(reg, closid); + reg = PARTID_SET(reg, reqpartid); reg = PMG_SET(reg, pmg); mpam_write_sysreg_s(reg, SYS_MPAM0_EL1, "SYS_MPAM0_EL1");

/* set in EL1 */ reg = mpam_read_sysreg_s(SYS_MPAM1_EL1, "SYS_MPAM1_EL1"); - reg = PARTID_SET(reg, closid); + reg = PARTID_SET(reg, reqpartid); reg = PMG_SET(reg, pmg); mpam_write_sysreg_s(reg, SYS_MPAM1_EL1, "SYS_MPAM1_EL1"); } + + state->cur_rmid = rmid; + state->cur_closid = closid; } }

@@ -1665,36 +2006,3 @@ u16 mpam_resctrl_max_mon_num(void)

return mon_num; } - -int resctrl_id_init(void) -{ - int ret; - - ret = closid_bitmap_init(); - if (ret) - goto out; - - pmg_init(); - mon_init(); - -out: - return ret; -} - -int resctrl_id_alloc(enum closid_type type) -{ - if (type == CLOSID_INT) - return closid_bitmap_alloc(num_intpartid, intpartid_free_map); - else if (type == CLOSID_REQ) - return closid_bitmap_alloc(num_reqpartid, reqpartid_free_map); - - return -ENOSPC; -} - -void resctrl_id_free(enum closid_type type, int id) -{ - if (type == CLOSID_INT) - return closid_bitmap_free(id, intpartid_free_map); - else if (type == CLOSID_REQ) - return closid_bitmap_free(id, reqpartid_free_map); -} diff --git a/fs/resctrlfs.c b/fs/resctrlfs.c index b1b114937272..2d4f239f4291 100644 --- a/fs/resctrlfs.c +++ b/fs/resctrlfs.c @@ -38,6 +38,7 @@

#include <uapi/linux/magic.h>

+#include <asm/mpam.h> #include <asm/resctrl.h>

DEFINE_STATIC_KEY_FALSE(resctrl_enable_key); @@ -336,25 +337,17 @@ mongroup_create_dir(struct kernfs_node *parent_kn, struct resctrl_group *prgrp, return ret; }

-static inline void free_mon_id(struct resctrl_group *rdtgrp) -{ - if (rdtgrp->mon.rmid) - free_rmid(rdtgrp->mon.rmid); - else if (rdtgrp->closid.reqpartid) - resctrl_id_free(CLOSID_REQ, rdtgrp->closid.reqpartid); -} - static void mkdir_mondata_all_prepare_clean(struct resctrl_group *prgrp) { if (prgrp->type == RDTCTRL_GROUP && prgrp->closid.intpartid) - resctrl_id_free(CLOSID_INT, prgrp->closid.intpartid); - free_mon_id(prgrp); + closid_free(prgrp->closid.intpartid); + rmid_free(prgrp->mon.rmid); }

static int mkdir_mondata_all_prepare(struct resctrl_group *rdtgrp) { int ret = 0; - int mon, rmid, reqpartid; + int mon; struct resctrl_group *prgrp;

mon = resctrl_lru_request_mon(); @@ -365,39 +358,8 @@ static int mkdir_mondata_all_prepare(struct resctrl_group *rdtgrp) } rdtgrp->mon.mon = mon;

- prgrp = rdtgrp->mon.parent; - if (rdtgrp->type == RDTMON_GROUP) { - /* - * this for mon id allocation, for mpam, rmid - * (pmg) is just reserved for creating monitoring - * group, it has the same effect with reqpartid - * (reqpartid) except for config allocation, but - * for some fuzzy reasons, we keep it until spec - * changes. We also allocate rmid first if it's - * available. - */ - rmid = alloc_rmid(); - if (rmid < 0) { - reqpartid = resctrl_id_alloc(CLOSID_REQ); - if (reqpartid < 0) { - rdt_last_cmd_puts("out of closID\n"); - ret = -EINVAL; - goto out; - } - rdtgrp->closid.reqpartid = reqpartid; - rdtgrp->mon.rmid = 0; - } else { - /* - * this time copy reqpartid from father group, - * as rmid is sufficient to monitoring. - */ - rdtgrp->closid.reqpartid = prgrp->closid.reqpartid; - rdtgrp->mon.rmid = rmid; - } - /* - * establish relationship from ctrl to mon group. - */ + prgrp = rdtgrp->mon.parent; rdtgrp->closid.intpartid = prgrp->closid.intpartid; }

@@ -546,7 +508,7 @@ static struct dentry *resctrl_mount(struct file_system_type *fs_type, static inline bool is_task_match_resctrl_group(struct task_struct *t, struct resctrl_group *r) { - return (TASK_CLOSID_PR_GET(t->closid) == r->closid.intpartid); + return (t->closid == r->closid.intpartid); }

/* @@ -565,9 +527,8 @@ static void resctrl_move_group_tasks(struct resctrl_group *from, struct resctrl_ read_lock(&tasklist_lock); for_each_process_thread(p, t) { if (!from || is_task_match_resctrl_group(t, from)) { - t->closid = TASK_CLOSID_SET(to->closid.intpartid, - to->closid.reqpartid); - t->rmid = to->mon.rmid; + t->closid = resctrl_navie_closid(to->closid); + t->rmid = resctrl_navie_rmid(to->mon.rmid);

#ifdef CONFIG_SMP /* @@ -595,7 +556,7 @@ static void free_all_child_rdtgrp(struct resctrl_group *rdtgrp) head = &rdtgrp->mon.crdtgrp_list; list_for_each_entry_safe(sentry, stmp, head, mon.crdtgrp_list) { /* rmid may not be used */ - free_mon_id(sentry); + rmid_free(sentry->mon.rmid); list_del(&sentry->mon.crdtgrp_list); kfree(sentry); } @@ -627,7 +588,7 @@ static void rmdir_all_sub(void) cpumask_or(&resctrl_group_default.cpu_mask, &resctrl_group_default.cpu_mask, &rdtgrp->cpu_mask);

- free_mon_id(rdtgrp); + rmid_free(rdtgrp->mon.rmid);

kernfs_remove(rdtgrp->kn); list_del(&rdtgrp->resctrl_group_list); @@ -666,6 +627,46 @@ static struct file_system_type resctrl_fs_type = { .kill_sb = resctrl_kill_sb, };

+static int find_rdtgrp_allocable_rmid(struct resctrl_group *rdtgrp) +{ + int ret, rmid, reqpartid; + struct resctrl_group *prgrp, *entry; + struct list_head *head; + + prgrp = rdtgrp->mon.parent; + if (prgrp == &resctrl_group_default) { + rmid = rmid_alloc(-1); + if (rmid < 0) + return rmid; + } else { + do { + rmid = rmid_alloc(prgrp->closid.reqpartid); + if (rmid >= 0) + break; + + head = &prgrp->mon.crdtgrp_list; + list_for_each_entry(entry, head, mon.crdtgrp_list) { + if (entry == rdtgrp) + continue; + rmid = rmid_alloc(entry->closid.reqpartid); + if (rmid >= 0) + break; + } + } while (0); + } + + if (rmid < 0) + rmid = rmid_alloc(-1); + + ret = mpam_rmid_to_partid_pmg(rmid, &reqpartid, NULL); + if (ret) + return ret; + rdtgrp->mon.rmid = rmid; + rdtgrp->closid.reqpartid = reqpartid; + + return rmid; +} + static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, struct kernfs_node *prgrp_kn, const char *name, umode_t mode, @@ -702,21 +703,21 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, * getting monitoring for child mon groups. */ if (rdtgrp->type == RDTCTRL_GROUP) { - ret = resctrl_id_alloc(CLOSID_INT); + ret = closid_alloc(); if (ret < 0) { rdt_last_cmd_puts("out of CLOSIDs\n"); goto out_unlock; } rdtgrp->closid.intpartid = ret; - ret = resctrl_id_alloc(CLOSID_REQ); - if (ret < 0) { - rdt_last_cmd_puts("out of SLAVE CLOSIDs\n"); - goto out_unlock; - } - rdtgrp->closid.reqpartid = ret; - ret = 0; }

+ ret = find_rdtgrp_allocable_rmid(rdtgrp); + if (ret < 0) { + rdt_last_cmd_puts("out of RMIDs\n"); + goto out_free_closid; + } + rdtgrp->mon.rmid = ret; + INIT_LIST_HEAD(&rdtgrp->mon.crdtgrp_list);

/* kernfs creates the directory for rdtgrp */ @@ -724,7 +725,7 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, if (IS_ERR(kn)) { ret = PTR_ERR(kn); rdt_last_cmd_puts("kernfs create error\n"); - goto out_free_rgrp; + goto out_free_rmid; } rdtgrp->kn = kn;

@@ -773,8 +774,12 @@ static int mkdir_resctrl_prepare(struct kernfs_node *parent_kn, mkdir_mondata_all_prepare_clean(rdtgrp); out_destroy: kernfs_remove(rdtgrp->kn); -out_free_rgrp: +out_free_rmid: + rmid_free(rdtgrp->mon.rmid); kfree(rdtgrp); +out_free_closid: + if (rdtgrp->type == RDTCTRL_GROUP) + closid_free(rdtgrp->closid.intpartid); out_unlock: resctrl_group_kn_unlock(prgrp_kn); return ret; @@ -921,9 +926,10 @@ static void resctrl_group_rm_mon(struct resctrl_group *rdtgrp,

/* Update per cpu closid and rmid of the moved CPUs first */ for_each_cpu(cpu, &rdtgrp->cpu_mask) { - per_cpu(pqr_state.default_closid, cpu) = prdtgrp->closid.reqpartid; - per_cpu(pqr_state.default_rmid, cpu) = prdtgrp->mon.rmid; + per_cpu(pqr_state.default_closid, cpu) = resctrl_navie_closid(prdtgrp->closid); + per_cpu(pqr_state.default_rmid, cpu) = resctrl_navie_rmid(prdtgrp->mon.rmid); } + /* * Update the MSR on moved CPUs and CPUs which have moved * task running on them. @@ -933,7 +939,7 @@ static void resctrl_group_rm_mon(struct resctrl_group *rdtgrp,

rdtgrp->flags |= RDT_DELETED;

- free_mon_id(rdtgrp); + rmid_free(rdtgrp->mon.rmid);

/* * Remove the rdtgrp from the parent ctrl_mon group's list @@ -971,9 +977,9 @@ static void resctrl_group_rm_ctrl(struct resctrl_group *rdtgrp, cpumask_var_t tm /* Update per cpu closid and rmid of the moved CPUs first */ for_each_cpu(cpu, &rdtgrp->cpu_mask) { per_cpu(pqr_state.default_closid, cpu) = - resctrl_group_default.closid.reqpartid; + resctrl_navie_closid(resctrl_group_default.closid); per_cpu(pqr_state.default_rmid, cpu) = - resctrl_group_default.mon.rmid; + resctrl_navie_rmid(resctrl_group_default.mon.rmid); }

/* @@ -984,8 +990,8 @@ static void resctrl_group_rm_ctrl(struct resctrl_group *rdtgrp, cpumask_var_t tm update_closid_rmid(tmpmask, NULL);

rdtgrp->flags |= RDT_DELETED; - resctrl_id_free(CLOSID_INT, rdtgrp->closid.intpartid); - resctrl_id_free(CLOSID_REQ, rdtgrp->closid.reqpartid); + closid_free(rdtgrp->closid.intpartid); + rmid_free(rdtgrp->mon.rmid);

/* * Free all the child monitor group rmids.

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Structure resctrl_ctrl_feature taken by resources is introduced to manage ctrl features, of which characteristic like max width from outer input and the base we parse from.

Now it is more practical for declaring a new ctrl feature, such as SCHEMA_PRI feature, only associated with internal priority setting exported by mpam devices, where informations is collected from mpam_resctrl_resource_init(), and next be chosen open or close by user options.

ctrl_ctrl_feature structure contains a flags field to avoid duplicated control type, for instance, SCHEMA_COMM feature selectes cpbm (Cache portion bitmap) as resource Cache default control type, so we should not enable this feature no longer if user manually selectes cpbm control type through mount options.

This field evt in ctrl_ctrl_feature structure is enum rdt_event_id type variable which works like eee4ad2a36e6 ("arm64/mpam: Add hook-events id for ctrl features") illustrates.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 25 ++- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 29 ++- arch/arm64/kernel/mpam/mpam_internal.h | 1 + arch/arm64/kernel/mpam/mpam_resctrl.c | 287 ++++++++++++------------- arch/arm64/kernel/mpam/mpam_setup.c | 136 +++++++----- include/linux/resctrlfs.h | 3 - 6 files changed, 260 insertions(+), 221 deletions(-)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 0414fdc5cb0e..e6fd2b7c72b0 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -124,14 +124,28 @@ enum resctrl_ctrl_type { SCHEMA_NUM_CTRL_TYPE };

+struct resctrl_ctrl_feature { + enum resctrl_ctrl_type type; + int flags; + const char *name; + + u32 max_wd; + + int base; + int evt; + + int default_ctrl; + + bool capable; + bool enabled; +}; + #define for_each_ctrl_type(t) \ for (t = SCHEMA_COMM; t != SCHEMA_NUM_CTRL_TYPE; t++)

#define for_each_extend_ctrl_type(t) \ for (t = SCHEMA_PRI; t != SCHEMA_NUM_CTRL_TYPE; t++)

-bool resctrl_ctrl_extend_bits_match(u32 bitmap, enum resctrl_ctrl_type type); - enum resctrl_conf_type { CDP_BOTH = 0, CDP_CODE, @@ -319,11 +333,10 @@ struct raw_resctrl_resource { u16 num_intpartid; u16 num_pmg;

- u16 extend_ctrls_wd[SCHEMA_NUM_CTRL_TYPE]; - void (*msr_update)(struct resctrl_resource *r, struct rdt_domain *d, struct msr_param *para); - u64 (*msr_read)(struct rdt_domain *d, struct msr_param *para); + u64 (*msr_read)(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para);

int data_width; const char *format_str; @@ -334,6 +347,8 @@ struct raw_resctrl_resource { u16 num_mon; u64 (*mon_read)(struct rdt_domain *d, void *md_priv); int (*mon_write)(struct rdt_domain *d, void *md_priv); + + struct resctrl_ctrl_feature ctrl_features[SCHEMA_NUM_CTRL_TYPE]; };

/* 64bit arm64 specified */ diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index eda30c5c9730..5f0481356d32 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -92,8 +92,8 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) rr = r->res; INIT_LIST_HEAD(&s->schema_ctrl_list); for_each_extend_ctrl_type(type) { - if (!resctrl_ctrl_extend_bits_match(r->ctrl_extend_bits, type) || - !rr->extend_ctrls_wd[type]) + if (!rr->ctrl_features[type].enabled || + !rr->ctrl_features[type].max_wd) continue;

sc = kzalloc(sizeof(*sc), GFP_KERNEL); @@ -281,6 +281,9 @@ parse_line(char *line, struct resctrl_resource *r, unsigned long dom_id; hw_closid_t hw_closid;

+ if (!rr->ctrl_features[ctrl_type].enabled) + return -EINVAL; + next: if (!line || line[0] == '\0') return 0; @@ -428,6 +431,9 @@ static void show_doms(struct seq_file *s, struct resctrl_resource *r, bool prev_auto_fill = false; u32 reg_val;

+ if (!rr->ctrl_features[type].enabled) + return; + para.closid = closid; para.type = type;

@@ -436,15 +442,15 @@ static void show_doms(struct seq_file *s, struct resctrl_resource *r,

seq_printf(s, "%*s:", max_name_width, schema_name); list_for_each_entry(dom, &r->domains, list) { - reg_val = rr->msr_read(dom, &para); + reg_val = rr->msr_read(r, dom, &para);

- if (rg && reg_val == r->default_ctrl[SCHEMA_COMM] && - prev_auto_fill == true) + if (reg_val == rr->ctrl_features[SCHEMA_COMM].default_ctrl && + rg && prev_auto_fill == true) continue;

if (sep) seq_puts(s, ";"); - if (rg && reg_val == r->default_ctrl[SCHEMA_COMM]) { + if (rg && reg_val == rr->ctrl_features[SCHEMA_COMM].default_ctrl) { prev_auto_fill = true; seq_puts(s, "S"); } else { @@ -750,22 +756,24 @@ static void rdtgroup_init_mba(struct resctrl_schema *s, u32 closid) { struct resctrl_staged_config *cfg; struct resctrl_resource *r; + struct raw_resctrl_resource *rr; struct rdt_domain *d; enum resctrl_ctrl_type t;

r = s->res; if (WARN_ON(!r)) return; + rr = r->res;

list_for_each_entry(d, &s->res->domains, list) { cfg = &d->staged_cfg[CDP_BOTH]; cfg->cdp_both_ctrl = s->cdp_mc_both; - cfg->new_ctrl[SCHEMA_COMM] = r->default_ctrl[SCHEMA_COMM]; + cfg->new_ctrl[SCHEMA_COMM] = rr->ctrl_features[SCHEMA_COMM].default_ctrl; resctrl_cdp_map(clos, closid, CDP_BOTH, cfg->hw_closid); cfg->have_new_ctrl = true; /* Set extension ctrl default value, e.g. priority/hardlimit */ for_each_extend_ctrl_type(t) { - cfg->new_ctrl[t] = r->default_ctrl[t]; + cfg->new_ctrl[t] = rr->ctrl_features[t].default_ctrl; } } } @@ -787,6 +795,7 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) enum resctrl_ctrl_type ctrl_type; struct rdt_domain *d; struct resctrl_resource *r; + struct raw_resctrl_resource *rr; u32 used_b = 0; u32 unused_b = 0; unsigned long tmp_cbm; @@ -794,6 +803,7 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) r = s->res; if (WARN_ON(!r)) return -EINVAL; + rr = r->res;

list_for_each_entry(d, &s->res->domains, list) { cfg = &d->staged_cfg[conf_type]; @@ -823,7 +833,8 @@ static int rdtgroup_init_cat(struct resctrl_schema *s, u32 closid) * with MPAM capabilities. */ for_each_extend_ctrl_type(ctrl_type) { - cfg->new_ctrl[ctrl_type] = r->default_ctrl[ctrl_type]; + cfg->new_ctrl[ctrl_type] = + rr->ctrl_features[ctrl_type].default_ctrl; } }

diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 690ed3f875e8..d74989e03993 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -19,6 +19,7 @@ extern bool rdt_mon_capable; extern struct list_head mpam_classes;

#define MAX_MBA_BW 100u +#define GRAN_MBA_BW 2u

#define MPAM_ERRCODE_NONE 0 #define MPAM_ERRCODE_PARTID_SEL_RANGE 1 diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 029a1538c00b..fe13f3442eac 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -100,22 +100,6 @@ bool is_resctrl_cdp_enabled(void) return !!resctrl_cdp_enabled; }

-static void -resctrl_ctrl_extend_bits_set(u32 *bitmap, enum resctrl_ctrl_type type) -{ - *bitmap |= BIT(type); -} - -static void resctrl_ctrl_extend_bits_clear(u32 *bitmap) -{ - *bitmap = 0; -} - -bool resctrl_ctrl_extend_bits_match(u32 bitmap, enum resctrl_ctrl_type type) -{ - return bitmap & BIT(type); -} - static void mpam_resctrl_update_component_cfg(struct resctrl_resource *r, struct rdt_domain *d, struct sd_closid *closid); @@ -124,8 +108,10 @@ static void common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, struct msr_param *para);

-static u64 cache_rdmsr(struct rdt_domain *d, struct msr_param *para); -static u64 mbw_rdmsr(struct rdt_domain *d, struct msr_param *para); +static u64 cache_rdmsr(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para); +static u64 mbw_rdmsr(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para);

static u64 cache_rdmon(struct rdt_domain *d, void *md_priv); static u64 mbw_rdmon(struct rdt_domain *d, void *md_priv); @@ -145,6 +131,23 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .format_str = "%d=%0*x", .mon_read = cache_rdmon, .mon_write = common_wrmon, + .ctrl_features = { + [SCHEMA_COMM] = { + .type = SCHEMA_COMM, + .flags = SCHEMA_COMM, + .name = "comm", + .base = 16, + .evt = QOS_CAT_CPBM_EVENT_ID, + .capable = 1, + }, + [SCHEMA_PRI] = { + .type = SCHEMA_PRI, + .flags = SCHEMA_PRI, + .name = "caPrio", + .base = 10, + .evt = QOS_CAT_INTPRI_EVENT_ID, + }, + }, }, [RDT_RESOURCE_L2] = { .msr_update = common_wrmsr, @@ -153,6 +156,23 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .format_str = "%d=%0*x", .mon_read = cache_rdmon, .mon_write = common_wrmon, + .ctrl_features = { + [SCHEMA_COMM] = { + .type = SCHEMA_COMM, + .flags = SCHEMA_COMM, + .name = "comm", + .base = 16, + .evt = QOS_CAT_CPBM_EVENT_ID, + .capable = 1, + }, + [SCHEMA_PRI] = { + .type = SCHEMA_PRI, + .flags = SCHEMA_PRI, + .name = "caPrio", + .base = 10, + .evt = QOS_CAT_INTPRI_EVENT_ID, + }, + }, }, [RDT_RESOURCE_MC] = { .msr_update = common_wrmsr, @@ -161,6 +181,30 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .format_str = "%d=%0*d", .mon_read = mbw_rdmon, .mon_write = common_wrmon, + .ctrl_features = { + [SCHEMA_COMM] = { + .type = SCHEMA_COMM, + .flags = SCHEMA_COMM, + .name = "comm", + .base = 10, + .evt = QOS_MBA_MAX_EVENT_ID, + .capable = 1, + }, + [SCHEMA_PRI] = { + .type = SCHEMA_PRI, + .flags = SCHEMA_PRI, + .name = "mbPrio", + .base = 10, + .evt = QOS_MBA_INTPRI_EVENT_ID, + }, + [SCHEMA_HDL] = { + .type = SCHEMA_HDL, + .flags = SCHEMA_HDL, + .name = "mbHdl", + .base = 10, + .evt = QOS_MBA_HDL_EVENT_ID, + }, + }, }, };

@@ -183,28 +227,18 @@ parse_cache(char *buf, struct resctrl_resource *r, enum resctrl_ctrl_type type) { unsigned long data; + struct raw_resctrl_resource *rr = r->res;

if (cfg->have_new_ctrl) { rdt_last_cmd_printf("duplicate domain\n"); return -EINVAL; }

- switch (type) { - case SCHEMA_COMM: - if (kstrtoul(buf, 16, &data)) - return -EINVAL; - break; - case SCHEMA_PRI: - if (kstrtoul(buf, 10, &data)) - return -EINVAL; - break; - case SCHEMA_HDL: - if (kstrtoul(buf, 10, &data)) - return -EINVAL; - break; - default: + if (kstrtoul(buf, rr->ctrl_features[type].base, &data)) + return -EINVAL; + + if (data >= rr->ctrl_features[type].max_wd) return -EINVAL; - }

cfg->new_ctrl[type] = data; cfg->have_new_ctrl = true; @@ -212,54 +246,35 @@ parse_cache(char *buf, struct resctrl_resource *r, return 0; }

-static bool bw_validate(char *buf, unsigned long *data, - struct resctrl_resource *r) -{ - unsigned long bw; - int ret; - - ret = kstrtoul(buf, 10, &bw); - if (ret) { - rdt_last_cmd_printf("non-hex character in mask %s\n", buf); - return false; - } - - bw = bw > MAX_MBA_BW ? MAX_MBA_BW : bw; - bw = bw < r->mbw.min_bw ? r->mbw.min_bw : bw; - *data = roundup(bw, r->mbw.bw_gran); - - return true; -} - static int parse_bw(char *buf, struct resctrl_resource *r, struct resctrl_staged_config *cfg, enum resctrl_ctrl_type type) { unsigned long data; + struct raw_resctrl_resource *rr = r->res;

if (cfg->have_new_ctrl) { rdt_last_cmd_printf("duplicate domain\n"); return -EINVAL; }

- switch (type) { - case SCHEMA_COMM: - if (!bw_validate(buf, &data, r)) + switch (rr->ctrl_features[type].evt) { + case QOS_MBA_MAX_EVENT_ID: + if (kstrtoul(buf, rr->ctrl_features[type].base, &data)) return -EINVAL; + data = (data < r->mbw.min_bw) ? r->mbw.min_bw : data; + data = roundup(data, r->mbw.bw_gran); break; - case SCHEMA_PRI: - if (kstrtoul(buf, 10, &data)) - return -EINVAL; - break; - case SCHEMA_HDL: - if (kstrtoul(buf, 10, &data)) + default: + if (kstrtoul(buf, rr->ctrl_features[type].base, &data)) return -EINVAL; break; - default: - return -EINVAL; }

+ if (data >= rr->ctrl_features[type].max_wd) + return -EINVAL; + cfg->new_ctrl[type] = data; cfg->have_new_ctrl = true;

@@ -285,61 +300,43 @@ common_wrmsr(struct resctrl_resource *r, struct rdt_domain *d, mpam_component_config(dom->comp, &args); }

-static u64 cache_rdmsr(struct rdt_domain *d, struct msr_param *para) +static u64 cache_rdmsr(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para) { - u32 result, intpri, dspri; + u32 result; struct sync_args args; struct mpam_resctrl_dom *dom; + struct raw_resctrl_resource *rr = r->res;

args.closid = *para->closid; dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom);

- switch (para->type) { - case SCHEMA_COMM: - args.eventid = QOS_CAT_CPBM_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &result); - break; - case SCHEMA_PRI: - args.eventid = QOS_CAT_INTPRI_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &intpri); - args.eventid = QOS_MBA_DSPRI_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &dspri); - result = (intpri > dspri) ? intpri : dspri; - break; - default: - return 0; - } + args.eventid = rr->ctrl_features[para->type].evt; + mpam_component_get_config(dom->comp, &args, &result);

return result; }

-static u64 mbw_rdmsr(struct rdt_domain *d, struct msr_param *para) +static u64 mbw_rdmsr(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para) { - u32 result, intpri, dspri; + u32 result; struct sync_args args; struct mpam_resctrl_dom *dom; + struct raw_resctrl_resource *rr = r->res;

args.closid = *para->closid; dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom);

- switch (para->type) { - case SCHEMA_COMM: - args.eventid = QOS_MBA_MAX_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &result); - break; - case SCHEMA_PRI: - args.eventid = QOS_MBA_INTPRI_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &intpri); - args.eventid = QOS_MBA_DSPRI_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &dspri); - result = (intpri > dspri) ? intpri : dspri; - break; - case SCHEMA_HDL: - args.eventid = QOS_MBA_HDL_EVENT_ID; - mpam_component_get_config(dom->comp, &args, &result); + args.eventid = rr->ctrl_features[para->type].evt; + mpam_component_get_config(dom->comp, &args, &result); + + switch (rr->ctrl_features[para->type].evt) { + case QOS_MBA_MAX_EVENT_ID: + result = roundup(result, r->mbw.bw_gran); break; default: - return 0; + break; }

return result; @@ -1023,27 +1020,25 @@ static int cdpl2_enable(void) static void basic_ctrl_enable(void) { struct mpam_resctrl_res *res; - struct resctrl_resource *r; + struct raw_resctrl_resource *rr;

for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; + rr = res->resctrl_res.res; /* At least SCHEMA_COMM is supported */ - resctrl_ctrl_extend_bits_set(&r->ctrl_extend_bits, SCHEMA_COMM); + rr->ctrl_features[SCHEMA_COMM].enabled = true; } }

static int extend_ctrl_enable(enum resctrl_ctrl_type type) { bool match = false; - struct resctrl_resource *r; struct raw_resctrl_resource *rr; struct mpam_resctrl_res *res;

for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; - rr = r->res; - if (rr->extend_ctrls_wd[type]) { - resctrl_ctrl_extend_bits_set(&r->ctrl_extend_bits, type); + rr = res->resctrl_res.res; + if (rr->ctrl_features[type].capable) { + rr->ctrl_features[type].enabled = true; match = true; } } @@ -1056,12 +1051,13 @@ static int extend_ctrl_enable(enum resctrl_ctrl_type type)

static void extend_ctrl_disable(void) { - struct resctrl_resource *r; + struct raw_resctrl_resource *rr; struct mpam_resctrl_res *res;

for_each_supported_resctrl_exports(res) { - r = &res->resctrl_res; - resctrl_ctrl_extend_bits_clear(&r->ctrl_extend_bits); + rr = res->resctrl_res.res; + rr->ctrl_features[SCHEMA_PRI].enabled = false; + rr->ctrl_features[SCHEMA_HDL].enabled = false; } }

@@ -1843,48 +1839,32 @@ void __mpam_sched_in(void)

static void mpam_update_from_resctrl_cfg(struct mpam_resctrl_res *res, - u32 resctrl_cfg, enum resctrl_ctrl_type ctrl_type, + u32 resctrl_cfg, enum rdt_event_id evt, struct mpam_config *mpam_cfg) { - switch (ctrl_type) { - case SCHEMA_COMM: - if (res == &mpam_resctrl_exports[RDT_RESOURCE_MC]) { - u64 range; - - /* For MBA cfg is a percentage of .. */ - if (res->resctrl_mba_uses_mbw_part) { - /* .. the number of bits we can set */ - range = res->class->mbw_pbm_bits; - mpam_cfg->mbw_pbm = - (resctrl_cfg * range) / MAX_MBA_BW; - mpam_set_feature(mpam_feat_mbw_part, &mpam_cfg->valid); - } else { - /* .. the number of fractions we can represent */ - range = MBW_MAX_BWA_FRACT(res->class->bwa_wd); - mpam_cfg->mbw_max = (resctrl_cfg * range) / (MAX_MBA_BW - 1); - mpam_cfg->mbw_max = - (mpam_cfg->mbw_max > range) ? range : mpam_cfg->mbw_max; - mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); - } - } else { - /* - * Nothing clever here as mpam_resctrl_pick_caches() - * capped the size at RESCTRL_MAX_CBM. - */ - mpam_cfg->cpbm = resctrl_cfg; - mpam_set_feature(mpam_feat_cpor_part, &mpam_cfg->valid); - } - break; - case SCHEMA_PRI: - mpam_cfg->dspri = resctrl_cfg; - mpam_cfg->intpri = resctrl_cfg; - mpam_set_feature(mpam_feat_dspri_part, &mpam_cfg->valid); - mpam_set_feature(mpam_feat_intpri_part, &mpam_cfg->valid); + u64 range; + + switch (evt) { + case QOS_MBA_MAX_EVENT_ID: + /* .. the number of fractions we can represent */ + range = MBW_MAX_BWA_FRACT(res->class->bwa_wd); + mpam_cfg->mbw_max = (resctrl_cfg * range) / (MAX_MBA_BW - 1); + mpam_cfg->mbw_max = + (mpam_cfg->mbw_max > range) ? range : mpam_cfg->mbw_max; + mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); break; - case SCHEMA_HDL: + case QOS_MBA_HDL_EVENT_ID: mpam_cfg->hdl = resctrl_cfg; mpam_set_feature(mpam_feat_part_hdl, &mpam_cfg->valid); break; + case QOS_CAT_CPBM_EVENT_ID: + mpam_cfg->cpbm = resctrl_cfg; + mpam_set_feature(mpam_feat_cpor_part, &mpam_cfg->valid); + break; + case QOS_CAT_INTPRI_EVENT_ID: + mpam_cfg->intpri = resctrl_cfg; + mpam_set_feature(mpam_feat_intpri_part, &mpam_cfg->valid); + break; default: break; } @@ -1903,6 +1883,7 @@ mpam_resctrl_update_component_cfg(struct resctrl_resource *r, struct mpam_resctrl_dom *dom; struct mpam_resctrl_res *res; struct mpam_config *slave_mpam_cfg; + struct raw_resctrl_resource *rr = r->res; enum resctrl_ctrl_type type; u32 intpartid = closid->intpartid; u32 reqpartid = closid->reqpartid; @@ -1930,11 +1911,9 @@ mpam_resctrl_update_component_cfg(struct resctrl_resource *r, slave_mpam_cfg->valid = 0;

for_each_ctrl_type(type) { - /* - * we don't need check if we have enabled this ctrl type, because - * this ctrls also should be applied an default configuration and - * this feature type would be rechecked when configuring mpam devices. - */ + if (!rr->ctrl_features[type].enabled) + continue; + resctrl_cfg = d->ctrl_val[type][intpartid]; mpam_update_from_resctrl_cfg(res, resctrl_cfg, type, slave_mpam_cfg); @@ -1947,13 +1926,15 @@ static void mpam_reset_cfg(struct mpam_resctrl_res *res, { int i; struct resctrl_resource *r = &res->resctrl_res; + struct raw_resctrl_resource *rr = r->res; enum resctrl_ctrl_type type;

for (i = 0; i != mpam_sysprops_num_partid(); i++) { for_each_ctrl_type(type) { - mpam_update_from_resctrl_cfg(res, r->default_ctrl[type], - type, &dom->comp->cfg[i]); - d->ctrl_val[type][i] = r->default_ctrl[type]; + mpam_update_from_resctrl_cfg(res, + rr->ctrl_features[type].default_ctrl, + rr->ctrl_features[type].evt, &dom->comp->cfg[i]); + d->ctrl_val[type][i] = rr->ctrl_features[type].default_ctrl; } } } diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index ef922a796ff8..18b1e5db5c0a 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -334,13 +334,6 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) struct resctrl_resource *r = &res->resctrl_res; struct raw_resctrl_resource *rr = NULL;

- if (class && !r->default_ctrl) { - r->default_ctrl = kmalloc_array(SCHEMA_NUM_CTRL_TYPE, - sizeof(*r->default_ctrl), GFP_KERNEL); - if (!r->default_ctrl) - return -ENOMEM; - } - if (class == mpam_resctrl_exports[RDT_RESOURCE_SMMU].class) { return 0; } else if (class == mpam_resctrl_exports[RDT_RESOURCE_MC].class) { @@ -373,17 +366,32 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mbw.min_bw = MAX_MBA_BW / ((1ULL << class->bwa_wd) - 1); /* the largest mbw_max is 100 */ - r->default_ctrl[SCHEMA_COMM] = 100; + rr->ctrl_features[SCHEMA_COMM].default_ctrl = MAX_MBA_BW; + rr->ctrl_features[SCHEMA_COMM].max_wd = MAX_MBA_BW + 1; + rr->ctrl_features[SCHEMA_COMM].capable = true; + } + + if (mpam_has_feature(mpam_feat_intpri_part, class->features)) { + /* + * Export internal priority setting, which represents the + * max level of control we can export to resctrl. this default + * priority is from hardware, no clever here. + */ + rr->ctrl_features[SCHEMA_PRI].max_wd = 1 << class->intpri_wd; + rr->ctrl_features[SCHEMA_PRI].default_ctrl = class->hwdef_intpri; + rr->ctrl_features[SCHEMA_PRI].capable = true; } + /* Just in case we have an excessive number of bits */ if (!r->mbw.min_bw) r->mbw.min_bw = 1;

/* - * because its linear with no offset, the granule is the same - * as the smallest value + * james said because its linear with no offset, the granule is the same + * as the smallest value. It is a little fuzzy here because a granularity + * of 1 would appear too fine to make percentage conversions. */ - r->mbw.bw_gran = r->mbw.min_bw; + r->mbw.bw_gran = GRAN_MBA_BW;

/* We will only pick a class that can monitor and control */ r->alloc_capable = true; @@ -392,8 +400,9 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mon_capable = true; r->mon_enabled = true; /* Export memory bandwidth hardlimit, default active hardlimit */ - rr->extend_ctrls_wd[SCHEMA_HDL] = 2; - r->default_ctrl[SCHEMA_HDL] = 1; + rr->ctrl_features[SCHEMA_HDL].default_ctrl = 1; + rr->ctrl_features[SCHEMA_HDL].max_wd = 2; + rr->ctrl_features[SCHEMA_HDL].capable = true; } else if (class == mpam_resctrl_exports[RDT_RESOURCE_L3].class) { r->rid = RDT_RESOURCE_L3; rr = mpam_get_raw_resctrl_resource(RDT_RESOURCE_L3); @@ -402,22 +411,40 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->fflags = RFTYPE_RES_CACHE; r->name = "L3";

- r->cache.cbm_len = class->cpbm_wd; - r->default_ctrl[SCHEMA_COMM] = GENMASK(class->cpbm_wd - 1, 0); - /* - * Which bits are shared with other ...things... - * Unknown devices use partid-0 which uses all the bitmap - * fields. Until we configured the SMMU and GIC not to do this - * 'all the bits' is the correct answer here. - */ - r->cache.shareable_bits = r->default_ctrl[SCHEMA_COMM]; - r->cache.min_cbm_bits = 1; - if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { - r->alloc_capable = true; - r->alloc_enabled = true; - rdt_alloc_capable = true; + r->cache.cbm_len = class->cpbm_wd; + rr->ctrl_features[SCHEMA_COMM].default_ctrl = GENMASK(class->cpbm_wd - 1, 0); + rr->ctrl_features[SCHEMA_COMM].max_wd = + rr->ctrl_features[SCHEMA_COMM].default_ctrl + 1; + rr->ctrl_features[SCHEMA_COMM].capable = true; + /* + * Which bits are shared with other ...things... + * Unknown devices use partid-0 which uses all the bitmap + * fields. Until we configured the SMMU and GIC not to do this + * 'all the bits' is the correct answer here. + */ + r->cache.shareable_bits = rr->ctrl_features[SCHEMA_COMM].default_ctrl; + r->cache.min_cbm_bits = 1; + } + + if (mpam_has_feature(mpam_feat_intpri_part, class->features)) { + /* + * Export internal priority setting, which represents the + * max level of control we can export to resctrl. this default + * priority is from hardware, no clever here. + */ + rr->ctrl_features[SCHEMA_PRI].max_wd = 1 << class->intpri_wd; + rr->ctrl_features[SCHEMA_PRI].default_ctrl = class->hwdef_intpri; + rr->ctrl_features[SCHEMA_PRI].capable = true; } + /* + * Only this resource is allocable can it be picked from + * mpam_resctrl_pick_caches(). So directly set following + * fields to true. + */ + r->alloc_capable = true; + r->alloc_enabled = true; + rdt_alloc_capable = true; /* * While this is a CPU-interface feature of MPAM, we only tell * resctrl about it for caches, as that seems to be how x86 @@ -435,22 +462,40 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->fflags = RFTYPE_RES_CACHE; r->name = "L2";

- r->cache.cbm_len = class->cpbm_wd; - r->default_ctrl[SCHEMA_COMM] = GENMASK(class->cpbm_wd - 1, 0); - /* - * Which bits are shared with other ...things... - * Unknown devices use partid-0 which uses all the bitmap - * fields. Until we configured the SMMU and GIC not to do this - * 'all the bits' is the correct answer here. - */ - r->cache.shareable_bits = r->default_ctrl[SCHEMA_COMM]; - if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { - r->alloc_capable = true; - r->alloc_enabled = true; - rdt_alloc_capable = true; + r->cache.cbm_len = class->cpbm_wd; + rr->ctrl_features[SCHEMA_COMM].default_ctrl = GENMASK(class->cpbm_wd - 1, 0); + rr->ctrl_features[SCHEMA_COMM].max_wd = + rr->ctrl_features[SCHEMA_COMM].default_ctrl + 1; + rr->ctrl_features[SCHEMA_COMM].capable = true; + /* + * Which bits are shared with other ...things... + * Unknown devices use partid-0 which uses all the bitmap + * fields. Until we configured the SMMU and GIC not to do this + * 'all the bits' is the correct answer here. + */ + r->cache.shareable_bits = rr->ctrl_features[SCHEMA_COMM].default_ctrl; }

+ if (mpam_has_feature(mpam_feat_intpri_part, class->features)) { + /* + * Export internal priority setting, which represents the + * max level of control we can export to resctrl. this default + * priority is from hardware, no clever here. + */ + rr->ctrl_features[SCHEMA_PRI].max_wd = 1 << class->intpri_wd; + rr->ctrl_features[SCHEMA_PRI].default_ctrl = class->hwdef_intpri; + rr->ctrl_features[SCHEMA_PRI].capable = true; + } + /* + * Only this resource is allocable can it be picked from + * mpam_resctrl_pick_caches(). So directly set following + * fields to true. + */ + r->alloc_capable = true; + r->alloc_enabled = true; + rdt_alloc_capable = true; + /* * While this is a CPU-interface feature of MPAM, we only tell * resctrl about it for caches, as that seems to be how x86 @@ -464,17 +509,6 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) rr->num_partid = class->num_partid; rr->num_intpartid = class->num_intpartid; rr->num_pmg = class->num_pmg; - - /* - * Export priority setting, extend_ctrls_wd represents the - * max level of control we can export. this default priority - * is just from hardware, no need to define another default - * value. - */ - rr->extend_ctrls_wd[SCHEMA_PRI] = 1 << max(class->intpri_wd, - class->dspri_wd); - r->default_ctrl[SCHEMA_PRI] = max(class->hwdef_intpri, - class->hwdef_dspri); }

return 0; diff --git a/include/linux/resctrlfs.h b/include/linux/resctrlfs.h index 7f1ff6e816f5..287be52e2385 100644 --- a/include/linux/resctrlfs.h +++ b/include/linux/resctrlfs.h @@ -58,9 +58,6 @@ struct resctrl_resource {

bool cdp_capable; bool cdp_enable; - u32 *default_ctrl; - - u32 ctrl_extend_bits;

void *res; };

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

So far there are some declarations shared by resctrlfs.c and mpam core module files under kernel/mpam directory scattered in mpam.h and resctrl.h, this is organized like this:

-- asm/ +-- resctrl.h + +-- mpam.h | + +-- mpam_resource.h | | + | | | -- fs/ | | +-> mpam/ +-- resctrlfs.c <----+----+------> +-- mpam_resctrl.c ...

We move this declarations shared by resctrlfs.c and mpam/ to resctrl.h and split another declarations into mpam_internal.h, also including moving mpam_resource.h to mpam/ directory, currently this is organized like this:

-- asm/ +-- mpam.h +----> export to other modules(e.g. SMMU master io) +-- resctrl.h + | -- mpam/ | +-- mpam_internal.h | + +-- mpam_resource.h | | + | | | -- fs/ | +----+-> mpam/ +-- resctrlfs.c <----+-----------> +-- mpam_resctrl.c ...

In this way can we build a clearer framework for MPAM usage.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/mpam.h | 377 +----------------- arch/arm64/include/asm/resctrl.h | 322 ++++++++++++++- arch/arm64/kernel/mpam/mpam_ctrlmon.c | 96 ++++- arch/arm64/kernel/mpam/mpam_device.c | 2 +- arch/arm64/kernel/mpam/mpam_internal.h | 142 ++++++- arch/arm64/kernel/mpam/mpam_resctrl.c | 3 +- .../asm => kernel/mpam}/mpam_resource.h | 4 +- fs/resctrlfs.c | 94 +---- include/linux/resctrlfs.h | 71 ---- 9 files changed, 551 insertions(+), 560 deletions(-) rename arch/arm64/{include/asm => kernel/mpam}/mpam_resource.h (98%)

diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 930658a775d6..6338eab817e7 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -2,381 +2,8 @@ #ifndef _ASM_ARM64_MPAM_H #define _ASM_ARM64_MPAM_H

-#include <linux/sched.h> -#include <linux/kernfs.h> -#include <linux/jump_label.h> - -#include <linux/seq_buf.h> -#include <linux/seq_file.h> -#include <linux/resctrlfs.h> - -/* MPAM register */ -#define SYS_MPAM0_EL1 sys_reg(3, 0, 10, 5, 1) -#define SYS_MPAM1_EL1 sys_reg(3, 0, 10, 5, 0) -#define SYS_MPAM2_EL2 sys_reg(3, 4, 10, 5, 0) -#define SYS_MPAM3_EL3 sys_reg(3, 6, 10, 5, 0) -#define SYS_MPAM1_EL12 sys_reg(3, 5, 10, 5, 0) -#define SYS_MPAMHCR_EL2 sys_reg(3, 4, 10, 4, 0) -#define SYS_MPAMVPMV_EL2 sys_reg(3, 4, 10, 4, 1) -#define SYS_MPAMVPMn_EL2(n) sys_reg(3, 4, 10, 6, n) -#define SYS_MPAMIDR_EL1 sys_reg(3, 0, 10, 4, 4) - -#define MPAM_MASK(n) ((1UL << n) - 1) -/* plan to use GENMASK(n, 0) instead */ - -/* - * MPAMx_ELn: - * 15:0 PARTID_I - * 31:16 PARTID_D - * 39:32 PMG_I - * 47:40 PMG_D - * 48 TRAPMPAM1EL1 - * 49 TRAPMPAM0EL1 - * 61:49 Reserved - * 62 TRAPLOWER - * 63 MPAMEN - */ -#define PARTID_BITS (16) -#define PMG_BITS (8) -#define PARTID_MASK MPAM_MASK(PARTID_BITS) -#define PMG_MASK MPAM_MASK(PMG_BITS) - -#define PARTID_I_SHIFT (0) -#define PARTID_D_SHIFT (PARTID_I_SHIFT + PARTID_BITS) -#define PMG_I_SHIFT (PARTID_D_SHIFT + PARTID_BITS) -#define PMG_D_SHIFT (PMG_I_SHIFT + PMG_BITS) - -#define PARTID_I_MASK (PARTID_MASK << PARTID_I_SHIFT) -#define PARTID_D_MASK (PARTID_MASK << PARTID_D_SHIFT) -#define PARTID_I_CLR(r) ((r) & ~PARTID_I_MASK) -#define PARTID_D_CLR(r) ((r) & ~PARTID_D_MASK) -#define PARTID_CLR(r) (PARTID_I_CLR(r) & PARTID_D_CLR(r)) - -#define PARTID_I_SET(r, id) (PARTID_I_CLR(r) | ((id) << PARTID_I_SHIFT)) -#define PARTID_D_SET(r, id) (PARTID_D_CLR(r) | ((id) << PARTID_D_SHIFT)) -#define PARTID_SET(r, id) (PARTID_CLR(r) | ((id) << PARTID_I_SHIFT) | ((id) << PARTID_D_SHIFT)) - -#define PMG_I_MASK (PMG_MASK << PMG_I_SHIFT) -#define PMG_D_MASK (PMG_MASK << PMG_D_SHIFT) -#define PMG_I_CLR(r) ((r) & ~PMG_I_MASK) -#define PMG_D_CLR(r) ((r) & ~PMG_D_MASK) -#define PMG_CLR(r) (PMG_I_CLR(r) & PMG_D_CLR(r)) - -#define PMG_I_SET(r, id) (PMG_I_CLR(r) | ((id) << PMG_I_SHIFT)) -#define PMG_D_SET(r, id) (PMG_D_CLR(r) | ((id) << PMG_D_SHIFT)) -#define PMG_SET(r, id) (PMG_CLR(r) | ((id) << PMG_I_SHIFT) | ((id) << PMG_D_SHIFT)) - -#define TRAPMPAM1EL1_SHIFT (PMG_D_SHIFT + PMG_BITS) -#define TRAPMPAM0EL1_SHIFT (TRAPMPAM1EL1_SHIFT + 1) -#define TRAPLOWER_SHIFT (TRAPMPAM0EL1_SHIFT + 13) -#define MPAMEN_SHIFT (TRAPLOWER_SHIFT + 1) - -/* - * MPAMHCR_EL2: - * 0 EL0_VPMEN - * 1 EL1_VPMEN - * 7:2 Reserved - * 8 GSTAPP_PLK - * 30:9 Reserved - * 31 TRAP_MPAMIDR_EL1 - * 63:32 Reserved - */ -#define EL0_VPMEN_SHIFT (0) -#define EL1_VPMEN_SHIFT (EL0_VPMEN_SHIFT + 1) -#define GSTAPP_PLK_SHIFT (8) -#define TRAP_MPAMIDR_EL1_SHIFT (31) - -/* - * MPAMIDR_EL1: - * 15:0 PARTID_MAX - * 16 Reserved - * 17 HAS_HCR - * 20:18 VPMR_MAX - * 31:21 Reserved - * 39:32 PMG_MAX - * 63:40 Reserved - */ -#define VPMR_MAX_BITS (3) -#define PARTID_MAX_SHIFT (0) -#define PARTID_MAX_MASK (MPAM_MASK(PARTID_BITS) << PARTID_MAX_SHIFT) -#define HAS_HCR_SHIFT (PARTID_MAX_SHIFT + PARTID_BITS + 1) -#define VPMR_MAX_SHIFT (HAS_HCR_SHIFT + 1) -#define PMG_MAX_SHIFT (VPMR_MAX_SHIFT + VPMR_MAX_BITS + 11) -#define PMG_MAX_MASK (MPAM_MASK(PMG_BITS) << PMG_MAX_SHIFT) -#define VPMR_MASK MPAM_MASK(VPMR_MAX_BITS) - -/* - * MPAMVPMV_EL2: - * 31:0 VPM_V - * 63:32 Reserved - */ -#define VPM_V_BITS 32 - -DECLARE_STATIC_KEY_FALSE(resctrl_enable_key); -DECLARE_STATIC_KEY_FALSE(resctrl_mon_enable_key); - -extern int max_name_width, max_data_width; - -enum resctrl_ctrl_type { - SCHEMA_COMM = 0, - SCHEMA_PRI, - SCHEMA_HDL, - SCHEMA_NUM_CTRL_TYPE -}; - -struct resctrl_ctrl_feature { - enum resctrl_ctrl_type type; - int flags; - const char *name; - - u32 max_wd; - - int base; - int evt; - - int default_ctrl; - - bool capable; - bool enabled; -}; - -#define for_each_ctrl_type(t) \ - for (t = SCHEMA_COMM; t != SCHEMA_NUM_CTRL_TYPE; t++) - -#define for_each_extend_ctrl_type(t) \ - for (t = SCHEMA_PRI; t != SCHEMA_NUM_CTRL_TYPE; t++) - -enum resctrl_conf_type { - CDP_BOTH = 0, - CDP_CODE, - CDP_DATA, - CDP_NUM_CONF_TYPE, -}; - -static inline int conf_name_to_conf_type(char *name) -{ - enum resctrl_conf_type t; - - if (!strcmp(name, "L3CODE") || !strcmp(name, "L2CODE")) - t = CDP_CODE; - else if (!strcmp(name, "L3DATA") || !strcmp(name, "L2DATA")) - t = CDP_DATA; - else - t = CDP_BOTH; - return t; -} - -#define for_each_conf_type(t) \ - for (t = CDP_BOTH; t < CDP_NUM_CONF_TYPE; t++) - -typedef struct { u16 val; } hw_mpamid_t; - -#define hw_closid_t hw_mpamid_t -#define hw_monid_t hw_mpamid_t -#define hw_closid_val(__x) (__x.val) -#define hw_monid_val(__x) (__x.val) - -#define as_hw_t(__name, __x) \ - ((hw_##__name##id_t){(__x)}) -#define hw_val(__name, __x) \ - hw_##__name##id_val(__x) - -/** - * When cdp enabled, give (closid + 1) to Cache LxDATA. - */ -#define resctrl_cdp_map(__name, __closid, __type, __result) \ -do { \ - if (__type == CDP_CODE) \ - __result = as_hw_t(__name, __closid); \ - else if (__type == CDP_DATA) \ - __result = as_hw_t(__name, __closid + 1); \ - else \ - __result = as_hw_t(__name, __closid); \ -} while (0) - -bool is_resctrl_cdp_enabled(void); - -#define hw_alloc_times_validate(__times, __flag) \ -do { \ - __flag = is_resctrl_cdp_enabled(); \ - __times = flag ? 2 : 1; \ -} while (0) - - -/** - * struct resctrl_staged_config - parsed configuration to be applied - * @hw_closid: raw closid for this configuration, regardless of CDP - * @new_ctrl: new ctrl value to be loaded - * @have_new_ctrl: did user provide new_ctrl for this domain - * @new_ctrl_type: CDP property of the new ctrl - * @cdp_both_ctrl: did cdp both control if cdp enabled - */ -struct resctrl_staged_config { - hw_closid_t hw_closid; - u32 new_ctrl[SCHEMA_NUM_CTRL_TYPE]; - bool have_new_ctrl; - enum resctrl_conf_type conf_type; - enum resctrl_ctrl_type ctrl_type; - bool cdp_both_ctrl; -}; - -/* later move to resctrl common directory */ -#define RESCTRL_NAME_LEN 15 - -struct resctrl_schema_ctrl { - struct list_head list; - char name[RESCTRL_NAME_LEN]; - enum resctrl_ctrl_type ctrl_type; -}; - -/** - * @list: Member of resctrl's schema list - * @name: Name visible in the schemata file - * @conf_type: Type of configuration, e.g. code/data/both - * @res: The rdt_resource for this entry - * @schemata_ctrl_list: Type of ctrl configuration. e.g. priority/hardlimit - * @cdp_mc_both: did cdp both mon/ctrl if cdp enabled - */ -struct resctrl_schema { - struct list_head list; - char name[RESCTRL_NAME_LEN]; - enum resctrl_conf_type conf_type; - struct resctrl_resource *res; - struct list_head schema_ctrl_list; - bool cdp_mc_both; -}; - -extern struct list_head resctrl_all_schema; - -/** - * struct rdt_domain - group of cpus sharing an RDT resource - * @list: all instances of this resource - * @id: unique id for this instance - * @cpu_mask: which cpus share this resource - * @rmid_busy_llc: - * bitmap of which limbo RMIDs are above threshold - * @mbm_total: saved state for MBM total bandwidth - * @mbm_local: saved state for MBM local bandwidth - * @mbm_over: worker to periodically read MBM h/w counters - * @cqm_limbo: worker to periodically read CQM h/w counters - * @mbm_work_cpu: - * worker cpu for MBM h/w counters - * @cqm_work_cpu: - * worker cpu for CQM h/w counters - * @ctrl_val: array of cache or mem ctrl values (indexed by CLOSID) - * @new_ctrl: new ctrl value to be loaded - * @have_new_ctrl: did user provide new_ctrl for this domain - */ -struct rdt_domain { - struct list_head list; - int id; - struct cpumask cpu_mask; - void __iomem *base; - - /* arch specific fields */ - u32 *ctrl_val[SCHEMA_NUM_CTRL_TYPE]; - bool have_new_ctrl; - - /* for debug */ - char *cpus_list; - - struct resctrl_staged_config staged_cfg[CDP_NUM_CONF_TYPE]; -}; - -#define RESCTRL_SHOW_DOM_MAX_NUM 8 - -int __init resctrl_group_init(void); - -int resctrl_group_mondata_show(struct seq_file *m, void *arg); -void rmdir_mondata_subdir_allrdtgrp(struct resctrl_resource *r, - unsigned int dom_id); - -int cdp_enable(int level, int data_type, int code_type); - -void post_resctrl_mount(void); - -#define mpam_read_sysreg_s(reg, name) read_sysreg_s(reg) -#define mpam_write_sysreg_s(v, r, n) write_sysreg_s(v, r) -#define mpam_readl(addr) readl(addr) -#define mpam_writel(v, addr) writel(v, addr) - -struct sd_closid; - -struct msr_param { - enum resctrl_ctrl_type type; - struct sd_closid *closid; -}; - -/** - * struct resctrl_resource - attributes of an RDT resource - * @rid: The index of the resource - * @alloc_enabled: Is allocation enabled on this machine - * @mon_enabled: Is monitoring enabled for this feature - * @alloc_capable: Is allocation available on this machine - * @mon_capable: Is monitor feature available on this machine - * @name: Name to use in "schemata" file - * @num_closid: Number of CLOSIDs available - * @cache_level: Which cache level defines scope of this resource - * @msr_base: Base MSR address for CBMs - * @msr_update: Function pointer to update QOS MSRs - * @data_width: Character width of data when displaying - * @domains: All domains for this resource - * @cache: Cache allocation related data - * @format_str: Per resource format string to show domain value - * @parse_ctrlval: Per resource function pointer to parse control values - * @evt_list: List of monitoring events - * @num_rmid: Number of RMIDs available - * @mon_scale: cqm counter * mon_scale = occupancy in bytes - * @fflags: flags to choose base and info files - */ - -struct raw_resctrl_resource { - u16 num_partid; - u16 num_intpartid; - u16 num_pmg; - - void (*msr_update)(struct resctrl_resource *r, struct rdt_domain *d, - struct msr_param *para); - u64 (*msr_read)(struct resctrl_resource *r, struct rdt_domain *d, - struct msr_param *para); - - int data_width; - const char *format_str; - int (*parse_ctrlval)(char *buf, struct resctrl_resource *r, - struct resctrl_staged_config *cfg, - enum resctrl_ctrl_type ctrl_type); - - u16 num_mon; - u64 (*mon_read)(struct rdt_domain *d, void *md_priv); - int (*mon_write)(struct rdt_domain *d, void *md_priv); - - struct resctrl_ctrl_feature ctrl_features[SCHEMA_NUM_CTRL_TYPE]; - - unsigned long fflags; -}; - -/* 64bit arm64 specified */ -union mon_data_bits { - void *priv; - struct { - u8 rid; - u8 domid; - u8 partid; - u8 pmg; - u8 mon; - u8 cdp_both_mon; - } u; -}; - -ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, - char *buf, size_t nbytes, loff_t off); - -int resctrl_group_schemata_show(struct kernfs_open_file *of, - struct seq_file *s, void *v); - -struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, - struct list_head **pos); - +#ifdef CONFIG_MPAM extern int mpam_rmid_to_partid_pmg(int rmid, int *partid, int *pmg); +#endif

#endif /* _ASM_ARM64_MPAM_H */ diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index 44a5bcfa5b92..af2388a43990 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -1,9 +1,12 @@ #ifndef _ASM_ARM64_RESCTRL_H #define _ASM_ARM64_RESCTRL_H

+#include <linux/resctrlfs.h> #include <asm/mpam_sched.h> #include <asm/mpam.h>

+#if defined(CONFIG_RESCTRL) && defined(CONFIG_MPAM) + #define resctrl_group rdtgroup #define resctrl_alloc_capable rdt_alloc_capable #define resctrl_mon_capable rdt_mon_capable @@ -40,13 +43,81 @@ enum rdt_group_type { RDT_NUM_GROUP, };

+/** + * struct resctrl_cache - Cache allocation related data + * @cbm_len: Length of the cache bit mask + * @min_cbm_bits: Minimum number of consecutive bits to be set + * @shareable_bits: Bitmask of shareable resource with other + * executing entities + */ +struct resctrl_cache { + u32 cbm_len; + u32 shareable_bits; + u32 min_cbm_bits; +}; + +/** + * struct resctrl_membw - Memory bandwidth allocation related data + * @min_bw: Minimum memory bandwidth percentage user can request + * @bw_gran: Granularity at which the memory bandwidth is allocated + * @delay_linear: True if memory B/W delay is in linear scale + * @ctrl_extend_bits: Indicates if there are extra ctrl capabilities supported. + * e.g. priority/hardlimit. + */ +struct resctrl_membw { + u32 min_bw; + u32 bw_gran; + u32 delay_linear; +}; + +/** + * struct resctrl_resource - attributes of an RDT resource + * @rid: The index of the resource + * @alloc_enabled: Is allocation enabled on this machine + * @mon_enabled: Is monitoring enabled for this feature + * @alloc_capable: Is allocation available on this machine + * @mon_capable: Is monitor feature available on this machine + * @name: Name to use in "schemata" file + * @domains: All domains for this resource + * @cache: Cache allocation related data + * @mbw: Memory Bandwidth allocation related data + * @evt_list: List of monitoring events + * @fflags: flags to choose base and info files + */ +struct resctrl_resource { + int rid; + bool alloc_enabled; + bool mon_enabled; + bool alloc_capable; + bool mon_capable; + char *name; + struct list_head domains; + u32 dom_num; + struct list_head evt_list; + unsigned long fflags; + + struct resctrl_cache cache; + struct resctrl_membw mbw; + + bool cdp_capable; + bool cdp_enable; + u32 *default_ctrl; + + u32 ctrl_extend_bits; + + void *res; +}; + +/* List of all resource groups */ +extern struct list_head resctrl_all_groups; + /** * struct mongroup - store mon group's data in resctrl fs. * @mon_data_kn kernlfs node for the mon_data directory * @parent: parent rdtgrp * @crdtgrp_list: child rdtgroup node list * @rmid: rmid for this rdtgroup - * @mon: monnitor id + * @init: init flag */ struct mongroup { struct kernfs_node *mon_data_kn; @@ -59,7 +130,7 @@ struct mongroup { /** * struct sd_closid - software defined closid * @intpartid: closid for this rdtgroup only for allocation - * @weak_closid: closid for synchronizing configuration and monitoring + * @reqpartid: closid for synchronizing configuration and monitoring */ struct sd_closid { u32 intpartid; @@ -70,6 +141,7 @@ struct sd_closid { * struct rdtgroup - store rdtgroup's data in resctrl file system. * @kn: kernfs node * @resctrl_group_list: linked list for all rdtgroups + * @closid: software defined closid * @cpu_mask: CPUs assigned to this rdtgroup * @flags: status bits * @waitcount: how many cpus expect to find this @@ -89,11 +161,214 @@ struct rdtgroup { struct mongroup mon; };

+enum resctrl_ctrl_type { + SCHEMA_COMM = 0, + SCHEMA_PRI, + SCHEMA_HDL, + SCHEMA_NUM_CTRL_TYPE +}; + +#define for_each_ctrl_type(t) \ + for (t = SCHEMA_COMM; t != SCHEMA_NUM_CTRL_TYPE; t++) + +#define for_each_extend_ctrl_type(t) \ + for (t = SCHEMA_PRI; t != SCHEMA_NUM_CTRL_TYPE; t++) + +/** + * struct resctrl_ctrl_feature - ctrl feature member live in schema list + * @flags: Does what ctrl types can this feature server for + * @name: Name of this ctrl feature + * @max_wd: Max width of this feature can be input from outter space + * @base: Base of integer from outter space + * @evt: rdt_event_id event owned for applying configuration + * @capable: Does this feature support + * @enabled: Enabled or not. + * @default_ctrl: Default ctrl value of this feature + */ +struct resctrl_ctrl_feature { + enum resctrl_ctrl_type type; + int flags; + const char *name; + u32 max_wd; + int base; + enum rdt_event_id evt; + int default_ctrl; + bool capable; + bool enabled; +}; + +struct msr_param { + enum resctrl_ctrl_type type; + struct sd_closid *closid; +}; + +enum resctrl_conf_type { + CDP_BOTH = 0, + CDP_CODE, + CDP_DATA, + CDP_NUM_CONF_TYPE, +}; + +static inline int conf_name_to_conf_type(char *name) +{ + enum resctrl_conf_type t; + + if (!strcmp(name, "L3CODE") || !strcmp(name, "L2CODE")) + t = CDP_CODE; + else if (!strcmp(name, "L3DATA") || !strcmp(name, "L2DATA")) + t = CDP_DATA; + else + t = CDP_BOTH; + return t; +} + +#define for_each_conf_type(t) \ + for (t = CDP_BOTH; t < CDP_NUM_CONF_TYPE; t++) + +typedef struct { u16 val; } hw_def_t; + +#define hw_closid_t hw_def_t +#define hw_monid_t hw_def_t +#define hw_closid_val(__x) (__x.val) +#define hw_monid_val(__x) (__x.val) + +#define as_hw_t(__name, __x) \ + ((hw_##__name##id_t){(__x)}) +#define hw_val(__name, __x) \ + hw_##__name##id_val(__x) + +/** + * When cdp enabled, give (closid + 1) to Cache LxDATA. + */ +#define resctrl_cdp_map(__name, __closid, __type, __result) \ +do { \ + if (__type == CDP_CODE) \ + __result = as_hw_t(__name, __closid); \ + else if (__type == CDP_DATA) \ + __result = as_hw_t(__name, __closid + 1); \ + else \ + __result = as_hw_t(__name, __closid); \ +} while (0) + +bool is_resctrl_cdp_enabled(void); + +#define hw_alloc_validate(__flag) \ +do { \ + if (is_resctrl_cdp_enabled()) \ + __flag = true; \ + else \ + __flag = false; \ +} while (0) + +#define hw_alloc_times_validate(__times, __flag) \ +do { \ + hw_alloc_validate(__flag); \ + if (__flag) \ + __times = 2; \ + else \ + __times = 1; \ +} while (0) + +/** + * struct resctrl_staged_config - parsed configuration to be applied + * @hw_closid: raw closid for this configuration, regardless of CDP + * @new_ctrl: new ctrl value to be loaded + * @have_new_ctrl: did user provide new_ctrl for this domain + * @new_ctrl_type: CDP property of the new ctrl + * @cdp_both_ctrl: did cdp both control if cdp enabled + */ +struct resctrl_staged_config { + hw_closid_t hw_closid; + u32 new_ctrl[SCHEMA_NUM_CTRL_TYPE]; + bool have_new_ctrl; + enum resctrl_conf_type conf_type; + enum resctrl_ctrl_type ctrl_type; + bool cdp_both_ctrl; +}; + +/* later move to resctrl common directory */ +#define RESCTRL_NAME_LEN 15 + +struct resctrl_schema_ctrl { + struct list_head list; + char name[RESCTRL_NAME_LEN]; + enum resctrl_ctrl_type ctrl_type; +}; + +/** + * @list: Member of resctrl's schema list + * @name: Name visible in the schemata file + * @conf_type: Type of configuration, e.g. code/data/both + * @res: The rdt_resource for this entry + * @schemata_ctrl_list: Type of ctrl configuration. e.g. priority/hardlimit + * @cdp_mc_both: did cdp both mon/ctrl if cdp enabled + */ +struct resctrl_schema { + struct list_head list; + char name[RESCTRL_NAME_LEN]; + enum resctrl_conf_type conf_type; + struct resctrl_resource *res; + struct list_head schema_ctrl_list; + bool cdp_mc_both; +}; + int schemata_list_init(void);

void schemata_list_destroy(void);

-int resctrl_lru_request_mon(void); +/** + * struct rdt_domain - group of cpus sharing an RDT resource + * @list: all instances of this resource + * @id: unique id for this instance + * @cpu_mask: which cpus share this resource + * @base MMIO base address + * @ctrl_val: array of cache or mem ctrl values (indexed by CLOSID) + * @have_new_ctrl: did user provide new_ctrl for this domain + */ +struct rdt_domain { + struct list_head list; + int id; + struct cpumask cpu_mask; + void __iomem *base; + + /* arch specific fields */ + u32 *ctrl_val[SCHEMA_NUM_CTRL_TYPE]; + bool have_new_ctrl; + + /* for debug */ + char *cpus_list; + + struct resctrl_staged_config staged_cfg[CDP_NUM_CONF_TYPE]; +}; + +/* + * Internal struct of resctrl_resource structure, + * for static initialization. + */ +struct raw_resctrl_resource { + u16 num_partid; + u16 num_intpartid; + u16 num_pmg; + + u16 extend_ctrls_wd[SCHEMA_NUM_CTRL_TYPE]; + + void (*msr_update)(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para); + u64 (*msr_read)(struct resctrl_resource *r, struct rdt_domain *d, + struct msr_param *para); + + int data_width; + const char *format_str; + int (*parse_ctrlval)(char *buf, struct resctrl_resource *r, + struct resctrl_staged_config *cfg, enum resctrl_ctrl_type ctrl_type); + + u16 num_mon; + u64 (*mon_read)(struct rdt_domain *d, void *md_priv); + int (*mon_write)(struct rdt_domain *d, void *md_priv); + unsigned long fflags; + + struct resctrl_ctrl_feature ctrl_features[SCHEMA_NUM_CTRL_TYPE]; +};

int rmid_alloc(int entry_idx); void rmid_free(int rmid); @@ -103,7 +378,8 @@ int closid_alloc(void); void closid_free(int closid);

void update_cpu_closid_rmid(void *info); -void update_closid_rmid(const struct cpumask *cpu_mask, struct resctrl_group *r); +void update_closid_rmid(const struct cpumask *cpu_mask, + struct resctrl_group *r); int __resctrl_group_move_task(struct task_struct *tsk, struct resctrl_group *rdtgrp);

@@ -117,18 +393,11 @@ void rdt_last_cmd_clear(void); void rdt_last_cmd_puts(const char *s); void rdt_last_cmd_printf(const char *fmt, ...);

-extern struct mutex resctrl_group_mutex; - -void release_rdtgroupfs_options(void); -int parse_rdtgroupfs_options(char *data); - void resctrl_resource_reset(void);

#define release_resctrl_group_fs_options release_rdtgroupfs_options #define parse_resctrl_group_fs_options parse_rdtgroupfs_options

-int mpam_get_mon_config(struct resctrl_resource *r); - int resctrl_group_init_alloc(struct rdtgroup *rdtgrp);

static inline int __resctrl_group_show_options(struct seq_file *seq) @@ -136,15 +405,35 @@ static inline int __resctrl_group_show_options(struct seq_file *seq) return 0; }

+int resctrl_update_groups_config(struct rdtgroup *rdtgrp); + +#define RESCTRL_MAX_CLOSID 32 + +int __init resctrl_group_init(void); + +void post_resctrl_mount(void); + +extern struct mutex resctrl_group_mutex; +DECLARE_STATIC_KEY_FALSE(resctrl_alloc_enable_key); +extern struct rdtgroup resctrl_group_default; int resctrl_mkdir_mondata_all_subdir(struct kernfs_node *parent_kn, - struct resctrl_group *prgrp); + struct resctrl_group *prgrp);

-struct resctrl_resource * -mpam_resctrl_get_resource(enum resctrl_resource_level level); +int resctrl_group_create_info_dir(struct kernfs_node *parent_kn, + struct kernfs_node **kn_info);

-int resctrl_update_groups_config(struct rdtgroup *rdtgrp); +int register_resctrl_specific_files(struct rftype *files, size_t len); +extern struct kernfs_ops resctrl_group_kf_single_ops;

-#define RESCTRL_MAX_CLOSID 32 +extern struct rdtgroup *resctrl_group_kn_lock_live(struct kernfs_node *kn); +void resctrl_group_kn_unlock(struct kernfs_node *kn); + +void release_rdtgroupfs_options(void); +int parse_rdtgroupfs_options(char *data); + +int resctrl_group_add_files(struct kernfs_node *kn, unsigned long fflags); + +#define RESCTRL_MAX_CBM 32

/* * This is only for avoiding unnecessary cost in mpam_sched_in() @@ -178,4 +467,5 @@ static inline u32 resctrl_navie_closid(struct sd_closid closid) return closid.intpartid; }

+#endif #endif /* _ASM_ARM64_RESCTRL_H */ diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 5f0481356d32..4b5b7bd5877b 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -29,8 +29,9 @@ #include <linux/kernfs.h> #include <linux/seq_file.h> #include <linux/slab.h> +#include <asm/mpam.h>

-#include <asm/mpam_resource.h> +#include "mpam_resource.h" #include "mpam_internal.h"

/* schemata content list */ @@ -751,6 +752,99 @@ int resctrl_mkdir_mondata_all_subdir(struct kernfs_node *parent_kn, return ret; }

+static int resctrl_group_mkdir_info_resdir(struct resctrl_resource *r, + char *name,unsigned long fflags, struct kernfs_node *kn_info) +{ + struct kernfs_node *kn_subdir; + int ret; + + kn_subdir = kernfs_create_dir(kn_info, name, + kn_info->mode, r); + if (IS_ERR(kn_subdir)) + return PTR_ERR(kn_subdir); + + kernfs_get(kn_subdir); + ret = resctrl_group_kn_set_ugid(kn_subdir); + if (ret) + return ret; + + ret = resctrl_group_add_files(kn_subdir, fflags); + if (!ret) + kernfs_activate(kn_subdir); + + return ret; +} + +int resctrl_group_create_info_dir(struct kernfs_node *parent_kn, + struct kernfs_node **kn_info) +{ + struct resctrl_schema *s; + struct resctrl_resource *r; + struct raw_resctrl_resource *rr; + unsigned long fflags; + char name[32]; + int ret; + + /* create the directory */ + *kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); + if (IS_ERR(*kn_info)) + return PTR_ERR(*kn_info); + kernfs_get(*kn_info); + + ret = resctrl_group_add_files(*kn_info, RF_TOP_INFO); + if (ret) + goto out_destroy; + + list_for_each_entry(s, &resctrl_all_schema, list) { + r = s->res; + if (!r) + continue; + rr = r->res; + if (r->alloc_enabled) { + fflags = rr->fflags | RF_CTRL_INFO; + ret = resctrl_group_mkdir_info_resdir(r, s->name, + fflags, *kn_info); + if (ret) + goto out_destroy; + } + } + + list_for_each_entry(s, &resctrl_all_schema, list) { + r = s->res; + if (!r) + continue; + rr = r->res; + if (r->mon_enabled) { + fflags = rr->fflags | RF_MON_INFO; + snprintf(name, sizeof(name), "%s_MON", s->name); + ret = resctrl_group_mkdir_info_resdir(r, name, + fflags, *kn_info); + if (ret) + goto out_destroy; + } + } + + /* + m This extra ref will be put in kernfs_remove() and guarantees + * that @rdtgrp->kn is always accessible. + */ + kernfs_get(*kn_info); + + ret = resctrl_group_kn_set_ugid(*kn_info); + if (ret) + goto out_destroy; + + kernfs_activate(*kn_info); + + return 0; + +out_destroy: + kernfs_remove(*kn_info); + return ret; +} + + + /* Initialize MBA resource with default values. */ static void rdtgroup_init_mba(struct resctrl_schema *s, u32 closid) { diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 3e4509e289dd..3fd5fc66b204 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -32,8 +32,8 @@ #include <linux/cpu.h> #include <linux/cacheinfo.h> #include <linux/arm_mpam.h> -#include <asm/mpam_resource.h>

+#include "mpam_resource.h" #include "mpam_device.h" #include "mpam_internal.h"

diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index d74989e03993..40dcc02f4e57 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -2,8 +2,6 @@ #ifndef _ASM_ARM64_MPAM_INTERNAL_H #define _ASM_ARM64_MPAM_INTERNAL_H

-#include <linux/resctrlfs.h> -#include <asm/mpam.h> #include <asm/resctrl.h>

typedef u32 mpam_features_t; @@ -12,6 +10,142 @@ struct mpam_component; struct rdt_domain; struct mpam_class; struct raw_resctrl_resource; +struct resctrl_resource; +/* MPAM register */ +#define SYS_MPAM0_EL1 sys_reg(3, 0, 10, 5, 1) +#define SYS_MPAM1_EL1 sys_reg(3, 0, 10, 5, 0) +#define SYS_MPAM2_EL2 sys_reg(3, 4, 10, 5, 0) +#define SYS_MPAM3_EL3 sys_reg(3, 6, 10, 5, 0) +#define SYS_MPAM1_EL12 sys_reg(3, 5, 10, 5, 0) +#define SYS_MPAMHCR_EL2 sys_reg(3, 4, 10, 4, 0) +#define SYS_MPAMVPMV_EL2 sys_reg(3, 4, 10, 4, 1) +#define SYS_MPAMVPMn_EL2(n) sys_reg(3, 4, 10, 6, n) +#define SYS_MPAMIDR_EL1 sys_reg(3, 0, 10, 4, 4) + +#define MPAM_MASK(n) ((1UL << n) - 1) +/* plan to use GENMASK(n, 0) instead */ + +/* + * MPAMx_ELn: + * 15:0 PARTID_I + * 31:16 PARTID_D + * 39:32 PMG_I + * 47:40 PMG_D + * 48 TRAPMPAM1EL1 + * 49 TRAPMPAM0EL1 + * 61:49 Reserved + * 62 TRAPLOWER + * 63 MPAMEN + */ +#define PARTID_BITS (16) +#define PMG_BITS (8) +#define PARTID_MASK MPAM_MASK(PARTID_BITS) +#define PMG_MASK MPAM_MASK(PMG_BITS) + +#define PARTID_I_SHIFT (0) +#define PARTID_D_SHIFT (PARTID_I_SHIFT + PARTID_BITS) +#define PMG_I_SHIFT (PARTID_D_SHIFT + PARTID_BITS) +#define PMG_D_SHIFT (PMG_I_SHIFT + PMG_BITS) + +#define PARTID_I_MASK (PARTID_MASK << PARTID_I_SHIFT) +#define PARTID_D_MASK (PARTID_MASK << PARTID_D_SHIFT) +#define PARTID_I_CLR(r) ((r) & ~PARTID_I_MASK) +#define PARTID_D_CLR(r) ((r) & ~PARTID_D_MASK) +#define PARTID_CLR(r) (PARTID_I_CLR(r) & PARTID_D_CLR(r)) + +#define PARTID_I_SET(r, id) (PARTID_I_CLR(r) | ((id) << PARTID_I_SHIFT)) +#define PARTID_D_SET(r, id) (PARTID_D_CLR(r) | ((id) << PARTID_D_SHIFT)) +#define PARTID_SET(r, id) (PARTID_CLR(r) | ((id) << PARTID_I_SHIFT) | ((id) << PARTID_D_SHIFT)) + +#define PMG_I_MASK (PMG_MASK << PMG_I_SHIFT) +#define PMG_D_MASK (PMG_MASK << PMG_D_SHIFT) +#define PMG_I_CLR(r) ((r) & ~PMG_I_MASK) +#define PMG_D_CLR(r) ((r) & ~PMG_D_MASK) +#define PMG_CLR(r) (PMG_I_CLR(r) & PMG_D_CLR(r)) + +#define PMG_I_SET(r, id) (PMG_I_CLR(r) | ((id) << PMG_I_SHIFT)) +#define PMG_D_SET(r, id) (PMG_D_CLR(r) | ((id) << PMG_D_SHIFT)) +#define PMG_SET(r, id) (PMG_CLR(r) | ((id) << PMG_I_SHIFT) | ((id) << PMG_D_SHIFT)) + +#define TRAPMPAM1EL1_SHIFT (PMG_D_SHIFT + PMG_BITS) +#define TRAPMPAM0EL1_SHIFT (TRAPMPAM1EL1_SHIFT + 1) +#define TRAPLOWER_SHIFT (TRAPMPAM0EL1_SHIFT + 13) +#define MPAMEN_SHIFT (TRAPLOWER_SHIFT + 1) + +/* + * MPAMHCR_EL2: + * 0 EL0_VPMEN + * 1 EL1_VPMEN + * 7:2 Reserved + * 8 GSTAPP_PLK + * 30:9 Reserved + * 31 TRAP_MPAMIDR_EL1 + * 63:32 Reserved + */ +#define EL0_VPMEN_SHIFT (0) +#define EL1_VPMEN_SHIFT (EL0_VPMEN_SHIFT + 1) +#define GSTAPP_PLK_SHIFT (8) +#define TRAP_MPAMIDR_EL1_SHIFT (31) + +/* + * MPAMIDR_EL1: + * 15:0 PARTID_MAX + * 16 Reserved + * 17 HAS_HCR + * 20:18 VPMR_MAX + * 31:21 Reserved + * 39:32 PMG_MAX + * 63:40 Reserved + */ +#define VPMR_MAX_BITS (3) +#define PARTID_MAX_SHIFT (0) +#define PARTID_MAX_MASK (MPAM_MASK(PARTID_BITS) << PARTID_MAX_SHIFT) +#define HAS_HCR_SHIFT (PARTID_MAX_SHIFT + PARTID_BITS + 1) +#define VPMR_MAX_SHIFT (HAS_HCR_SHIFT + 1) +#define PMG_MAX_SHIFT (VPMR_MAX_SHIFT + VPMR_MAX_BITS + 11) +#define PMG_MAX_MASK (MPAM_MASK(PMG_BITS) << PMG_MAX_SHIFT) +#define VPMR_MASK MPAM_MASK(VPMR_MAX_BITS) + +/* + * MPAMVPMV_EL2: + * 31:0 VPM_V + * 63:32 Reserved + */ +#define VPM_V_BITS 32 + +DECLARE_STATIC_KEY_FALSE(resctrl_enable_key); +DECLARE_STATIC_KEY_FALSE(resctrl_mon_enable_key); + +extern int max_name_width, max_data_width; + +#define RESCTRL_SHOW_DOM_MAX_NUM 8 + +#define mpam_read_sysreg_s(reg, name) read_sysreg_s(reg) +#define mpam_write_sysreg_s(v, r, n) write_sysreg_s(v, r) +#define mpam_readl(addr) readl(addr) +#define mpam_writel(v, addr) writel(v, addr) + +/* 64bit arm64 specified */ +union mon_data_bits { + void *priv; + struct { + u8 rid; + u8 domid; + u8 partid; + u8 pmg; + u8 mon; + u8 cdp_both_mon; + } u; +}; + +ssize_t resctrl_group_schemata_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off); + +int resctrl_group_schemata_show(struct kernfs_open_file *of, + struct seq_file *s, void *v); + +struct rdt_domain *mpam_find_domain(struct resctrl_resource *r, int id, + struct list_head **pos);

extern bool rdt_alloc_capable; extern bool rdt_mon_capable; @@ -201,4 +335,8 @@ int assoc_rmid_with_mon(u32 rmid); void deassoc_rmid_with_mon(u32 rmid); u32 get_rmid_mon(u32 rmid, enum resctrl_resource_level rid); int rmid_mon_ptrs_init(u32 nr_rmids); + +struct resctrl_resource * +mpam_resctrl_get_resource(enum resctrl_resource_level level); + #endif diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index e7c51845dbf3..2dc81aa5c3a7 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -35,10 +35,11 @@ #include <linux/arm_mpam.h>

#include <asm/mpam_sched.h> -#include <asm/mpam_resource.h> +#include <asm/mpam.h> #include <asm/io.h>

#include "mpam_device.h" +#include "mpam_resource.h" #include "mpam_internal.h"

/* Mutex to protect rdtgroup access. */ diff --git a/arch/arm64/include/asm/mpam_resource.h b/arch/arm64/kernel/mpam/mpam_resource.h similarity index 98% rename from arch/arm64/include/asm/mpam_resource.h rename to arch/arm64/kernel/mpam/mpam_resource.h index 412faca90e0b..a9e8334e879e 100644 --- a/arch/arm64/include/asm/mpam_resource.h +++ b/arch/arm64/kernel/mpam/mpam_resource.h @@ -165,10 +165,10 @@ #define MPAMF_MBWUMON_IDR_HAS_CAPTURE BIT(31)

/* MPAMF_CPOR_IDR - MPAM features cache portion partitioning ID register */ -#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0) +#define MPAMF_CPOR_IDR_CPBM_WD GENMASK(15, 0)

/* MPAMF_CCAP_IDR - MPAM features cache capacity partitioning ID register */ -#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0) +#define MPAMF_CCAP_IDR_CMAX_WD GENMASK(5, 0)

/* MPAMF_MBW_IDR - MPAM features memory bandwidth partitioning ID register */ #define MPAMF_MBW_IDR_BWA_WD GENMASK(5, 0) diff --git a/fs/resctrlfs.c b/fs/resctrlfs.c index 081945234139..48661b51ed36 100644 --- a/fs/resctrlfs.c +++ b/fs/resctrlfs.c @@ -38,8 +38,8 @@

#include <uapi/linux/magic.h>

-#include <asm/mpam.h> #include <asm/resctrl.h> +#include <asm/mpam.h>

DEFINE_STATIC_KEY_FALSE(resctrl_enable_key); DEFINE_STATIC_KEY_FALSE(resctrl_mon_enable_key); @@ -141,7 +141,7 @@ static int __resctrl_group_add_files(struct kernfs_node *kn, unsigned long fflag return ret; }

-static int resctrl_group_add_files(struct kernfs_node *kn, unsigned long fflags) +int resctrl_group_add_files(struct kernfs_node *kn, unsigned long fflags) { int ret = 0;

@@ -152,94 +152,6 @@ static int resctrl_group_add_files(struct kernfs_node *kn, unsigned long fflags) return ret; }

-static int resctrl_group_mkdir_info_resdir(struct resctrl_resource *r, char *name, - unsigned long fflags) -{ - struct kernfs_node *kn_subdir; - int ret; - - kn_subdir = kernfs_create_dir(kn_info, name, - kn_info->mode, r); - if (IS_ERR(kn_subdir)) - return PTR_ERR(kn_subdir); - - kernfs_get(kn_subdir); - ret = resctrl_group_kn_set_ugid(kn_subdir); - if (ret) - return ret; - - ret = resctrl_group_add_files(kn_subdir, fflags); - if (!ret) - kernfs_activate(kn_subdir); - - return ret; -} - -static int resctrl_group_create_info_dir(struct kernfs_node *parent_kn) -{ - struct resctrl_schema *s; - struct resctrl_resource *r; - struct raw_resctrl_resource *rr; - unsigned long fflags; - char name[32]; - int ret; - - /* create the directory */ - kn_info = kernfs_create_dir(parent_kn, "info", parent_kn->mode, NULL); - if (IS_ERR(kn_info)) - return PTR_ERR(kn_info); - kernfs_get(kn_info); - - ret = resctrl_group_add_files(kn_info, RF_TOP_INFO); - if (ret) - goto out_destroy; - - list_for_each_entry(s, &resctrl_all_schema, list) { - r = s->res; - if (!r) - continue; - rr = r->res; - if (r->alloc_enabled) { - fflags = rr->fflags | RF_CTRL_INFO; - ret = resctrl_group_mkdir_info_resdir(r, s->name, fflags); - if (ret) - goto out_destroy; - } - } - - list_for_each_entry(s, &resctrl_all_schema, list) { - r = s->res; - if (!r) - continue; - rr = r->res; - if (r->mon_enabled) { - fflags = rr->fflags | RF_MON_INFO; - snprintf(name, sizeof(name), "%s_MON", s->name); - ret = resctrl_group_mkdir_info_resdir(r, name, fflags); - if (ret) - goto out_destroy; - } - } - - /* - m This extra ref will be put in kernfs_remove() and guarantees - * that @rdtgrp->kn is always accessible. - */ - kernfs_get(kn_info); - - ret = resctrl_group_kn_set_ugid(kn_info); - if (ret) - goto out_destroy; - - kernfs_activate(kn_info); - - return 0; - -out_destroy: - kernfs_remove(kn_info); - return ret; -} - /* * We don't allow resctrl_group directories to be created anywhere * except the root directory. Thus when looking for the resctrl_group @@ -438,7 +350,7 @@ static struct dentry *resctrl_mount(struct file_system_type *fs_type, goto out_options; }

- ret = resctrl_group_create_info_dir(resctrl_group_default.kn); + ret = resctrl_group_create_info_dir(resctrl_group_default.kn, &kn_info); if (ret) { dentry = ERR_PTR(ret); goto out_options; diff --git a/include/linux/resctrlfs.h b/include/linux/resctrlfs.h index 287be52e2385..bd739bdc72cb 100644 --- a/include/linux/resctrlfs.h +++ b/include/linux/resctrlfs.h @@ -9,59 +9,6 @@ #include <linux/seq_buf.h> #include <linux/seq_file.h>

-/** - * struct resctrl_cache - Cache allocation related data - * @cbm_len: Length of the cache bit mask - * @min_cbm_bits: Minimum number of consecutive bits to be set - * @cbm_idx_mult: Multiplier of CBM index - * @cbm_idx_offset: Offset of CBM index. CBM index is computed by: - * closid * cbm_idx_multi + cbm_idx_offset - * in a cache bit mask - * @shareable_bits: Bitmask of shareable resource with other - * executing entities - * @arch_has_sparse_bitmaps: True if a bitmap like f00f is valid. - */ -struct resctrl_cache { - u32 cbm_len; - u32 shareable_bits; - u32 min_cbm_bits; -}; - -/** - * struct resctrl_membw - Memory bandwidth allocation related data - * @min_bw: Minimum memory bandwidth percentage user can request - * @bw_gran: Granularity at which the memory bandwidth is allocated - * @delay_linear: True if memory B/W delay is in linear scale - * @ctrl_extend_bits: Indicates if there are extra ctrl capabilities supported. - * e.g. priority/hardlimit. - */ -struct resctrl_membw { - u32 min_bw; - u32 bw_gran; - u32 delay_linear; -}; - -struct resctrl_resource { - int rid; - bool alloc_enabled; - bool mon_enabled; - bool alloc_capable; - bool mon_capable; - char *name; - struct list_head domains; - u32 dom_num; - struct list_head evt_list; - unsigned long fflags; - - struct resctrl_cache cache; - struct resctrl_membw mbw; - - bool cdp_capable; - bool cdp_enable; - - void *res; -}; - DECLARE_STATIC_KEY_FALSE(resctrl_enable_key);

/* rftype.flags */ @@ -87,9 +34,6 @@ DECLARE_STATIC_KEY_FALSE(resctrl_enable_key); #define RF_TOP_INFO (RFTYPE_INFO | RFTYPE_TOP) #define RF_CTRL_BASE (RFTYPE_BASE | RFTYPE_CTRL)

-/* List of all resource groups */ -extern struct list_head resctrl_all_groups; - /** * struct rftype - describe each file in the resctrl file system * @name: File name @@ -120,19 +64,4 @@ struct rftype { char *buf, size_t nbytes, loff_t off); };

-DECLARE_STATIC_KEY_FALSE(resctrl_alloc_enable_key); -extern struct rdtgroup resctrl_group_default; - -int __init resctrl_group_init(void); - -int register_resctrl_specific_files(struct rftype *files, size_t len); -extern struct kernfs_ops resctrl_group_kf_single_ops; - -extern struct rdtgroup *resctrl_group_kn_lock_live(struct kernfs_node *kn); -void resctrl_group_kn_unlock(struct kernfs_node *kn); - -void post_resctrl_mount (void); - -#define RESCTRL_MAX_CBM 32 - #endif /* _RESCTRLFS_H */

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

ctrl_features array, introduced by 61fa56e1dd8a ("arm64/mpam: Add resctrl_ctrl_feature structure to manage ctrl features"), which lives in raw_resctrl_resource structure for listing ctrl features's type do we support in total for this resource, this filters illegal parameters outside from mount options and provides useful info for add_schema() for registering a new control type node in schema list.

This action helps us to add new ctrl feature easier later.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/resctrl.h | 2 ++ arch/arm64/kernel/mpam/mpam_ctrlmon.c | 24 ++++++++------------ arch/arm64/kernel/mpam/mpam_resctrl.c | 32 +++++++++++++++------------ 3 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index af2388a43990..15310ad1b287 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -195,6 +195,8 @@ struct resctrl_ctrl_feature { int default_ctrl; bool capable; bool enabled; + + const char *ctrl_suffix; };

struct msr_param { diff --git a/arch/arm64/kernel/mpam/mpam_ctrlmon.c b/arch/arm64/kernel/mpam/mpam_ctrlmon.c index 4b5b7bd5877b..26b558abf6eb 100644 --- a/arch/arm64/kernel/mpam/mpam_ctrlmon.c +++ b/arch/arm64/kernel/mpam/mpam_ctrlmon.c @@ -42,12 +42,9 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) { int ret = 0; char *suffix = ""; - char *ctrl_suffix = ""; struct resctrl_schema *s; struct raw_resctrl_resource *rr; - struct resctrl_schema_ctrl *sc, *sc_tmp; - struct resctrl_schema_ctrl *sc_pri = NULL; - struct resctrl_schema_ctrl *sc_hdl = NULL; + struct resctrl_schema_ctrl *sc, *tmp; enum resctrl_ctrl_type type;

s = kzalloc(sizeof(*s), GFP_KERNEL); @@ -93,6 +90,9 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) rr = r->res; INIT_LIST_HEAD(&s->schema_ctrl_list); for_each_extend_ctrl_type(type) { + struct resctrl_ctrl_feature *feature = + &rr->ctrl_features[type]; + if (!rr->ctrl_features[type].enabled || !rr->ctrl_features[type].max_wd) continue; @@ -103,25 +103,19 @@ static int add_schema(enum resctrl_conf_type t, struct resctrl_resource *r) goto err; } sc->ctrl_type = type; - if (type == SCHEMA_PRI) { - sc_pri = sc; - ctrl_suffix = "PRI"; - } else if (type == SCHEMA_HDL) { - sc_hdl = sc; - ctrl_suffix = "HDL"; - }

WARN_ON_ONCE(strlen(r->name) + strlen(suffix) + - strlen(ctrl_suffix) + 1 > RESCTRL_NAME_LEN); - snprintf(sc->name, sizeof(sc->name), "%s%s%s", - r->name, suffix, ctrl_suffix); + strlen(feature->ctrl_suffix) + 1 > RESCTRL_NAME_LEN); + snprintf(sc->name, sizeof(sc->name), "%s%s%s", r->name, + suffix, feature->ctrl_suffix); + list_add_tail(&sc->list, &s->schema_ctrl_list); }

return 0;

err: - list_for_each_entry_safe(sc, sc_tmp, &s->schema_ctrl_list, list) { + list_for_each_entry_safe(sc, tmp, &s->schema_ctrl_list, list) { list_del(&sc->list); kfree(sc); } diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index deae8e94aeb4..6439c926517d 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -1048,17 +1048,28 @@ static void basic_ctrl_enable(void) } }

-static int extend_ctrl_enable(enum resctrl_ctrl_type type) +static int extend_ctrl_enable(char *tok) { bool match = false; + struct resctrl_resource *r; struct raw_resctrl_resource *rr; struct mpam_resctrl_res *res; + struct resctrl_ctrl_feature *feature; + enum resctrl_ctrl_type type;

for_each_supported_resctrl_exports(res) { - rr = res->resctrl_res.res; - if (rr->ctrl_features[type].capable) { - rr->ctrl_features[type].enabled = true; - match = true; + r = &res->resctrl_res; + if (!r->alloc_capable) + continue; + rr = r->res; + for_each_ctrl_type(type) { + feature = &rr->ctrl_features[type]; + if (strcmp(feature->name, tok)) + continue; + if (rr->ctrl_features[type].capable) { + rr->ctrl_features[type].enabled = true; + match = true; + } } }

@@ -1103,17 +1114,10 @@ int parse_rdtgroupfs_options(char *data) ret = cdpl2_enable(); if (ret) goto out; - } else if (!strcmp(token, "priority")) { - ret = extend_ctrl_enable(SCHEMA_PRI); - if (ret) - goto out; - } else if (!strcmp(token, "hardlimit")) { - ret = extend_ctrl_enable(SCHEMA_HDL); + } else { + ret = extend_ctrl_enable(token); if (ret) goto out; - } else { - ret = -EINVAL; - goto out; } }

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Sometimes monitoring will have such anomalies:

e.g. > cd /sys/fs/resctrl/ && grep . mon_data/* mon_data/mon_L3CODE_00:14336 mon_data/mon_L3CODE_01:344064 mon_data/mon_L3CODE_02:2048 mon_data/mon_L3CODE_03:27648 mon_data/mon_L3DATA_00:0 #L3DATA's monitoring data always be 0 mon_data/mon_L3DATA_01:0 mon_data/mon_L3DATA_02:0 mon_data/mon_L3DATA_03:0 mon_data/mon_MB_00:392 mon_data/mon_MB_01:552 mon_data/mon_MB_02:160 mon_data/mon_MB_03:0

If cdp on, tasks in resctrl default group with closid=0 and rmid=0 don't know how to fill proper partid_i/pmg_i and partid_d/pmg_d into MPAMx_ELx sysregs by mpam_sched_in() called by __switch_to(), it's because current cpu's default closid and rmid are also equal to 0 and to make the operation modifying configuration passed.

Update per cpu default closid of none-zero value, call update_closid_rmid() to update each cpu's mpam proper MPAMx_ELx sysregs for setting partid and pmg when mounting resctrl sysfs, it looks like a practical method.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- fs/resctrlfs.c | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+)

diff --git a/fs/resctrlfs.c b/fs/resctrlfs.c index 48661b51ed36..4248dec9340a 100644 --- a/fs/resctrlfs.c +++ b/fs/resctrlfs.c @@ -317,6 +317,28 @@ static int mkdir_mondata_all(struct kernfs_node *parent_kn, return ret; }

+static void resctrl_cdp_update_cpus_state(struct resctrl_group *r) +{ + int cpu; + + /* + * If cdp on, tasks in resctrl default group with closid=0 + * and rmid=0 don't know how to fill proper partid_i/pmg_i + * and partid_d/pmg_d into MPAMx_ELx sysregs by mpam_sched_in() + * called by __switch_to(), it's because current cpu's default + * closid and rmid are also equal to 0 and to make the operation + * modifying configuration passed. Update per cpu default closid + * of none-zero value, call update_closid_rmid() to update each + * cpu's mpam proper MPAMx_ELx sysregs for setting partid and + * pmg when mounting resctrl sysfs, it looks like a practical + * method. + */ + for_each_cpu(cpu, &r->cpu_mask) + per_cpu(pqr_state.default_closid, cpu) = ~0; + + update_closid_rmid(&r->cpu_mask, NULL); +} + static struct dentry *resctrl_mount(struct file_system_type *fs_type, int flags, const char *unused_dev_name, void *data) @@ -386,6 +408,8 @@ static struct dentry *resctrl_mount(struct file_system_type *fs_type, if (IS_ERR(dentry)) goto out_mondata;

+ resctrl_cdp_update_cpus_state(&resctrl_group_default); + post_resctrl_mount();

goto out;

From: Wang ShaoBo bobo.shaobowang@huawei.com

hulk inclusion category: feature bugzilla: 34278 CVE: NA

-------------------------------------------------

Based on 61fa56e1dd8a ("arm64/mpam: Add resctrl_ctrl_feature structure to manage ctrl features"), we add several ctrl features and supply corresponding mount options, including mbPbm, mbMax, mbMin, mbPrio, caMax, caPrio, caPbm, if MPAM system supports relevant features, we can mount resctrl like this:

e.g.

mount -t resctrl resctrl /sys/fs/resctrl -o mbMax,mbMin,caPrio cd /sys/fs/resctrl && cat schemata

L3:0=0x7fff;1=0x7fff;2=0x7fff;3=0x7fff #default select cpbm as basic ctrl feature L3PRI:0=3;1=3;2=3;3=3 MBMAX:0=100;1=100;2=100;3=100 MBMIN:0=0;1=0;2=0;3=0

mount -t resctrl resctrl /sys/fs/resctrl cd /sys/fs/resctrl && cat schemata

L3:0=0x7fff;1=0x7fff;2=0x7fff;3=0x7fff #default select cpbm as basic ctrl feature MB:0=100;1=100;2=100;3=100 #default select mbw max as basic ctrl feature

mount -t resctrl resctrl /sys/fs/resctrl -o caMax cd /sys/fs/resctrl && cat schemata

L3:0=33554432;1=33554432;2=33554432;3=33554432 #use cmax ctrl feature MB:0=100;1=100;2=100;3=100 #default select mbw max as basic ctrl feature

For Cache MSCs, basic ctrl features include cmax(Cache Maximum Capacity) and cpbm(Cache protion bitmap) partition, if mount options are not specified, default cpbm will be selected.

For Memory MSCs, basic ctrl features include max(Memory Bandwidth Maximum) and pbm(Memory Bandwidth Portion Bitmap) partition, if mount options are not specified, default max will be selected.

Above mount options also can be used accompany with cdp options.

e.g.

mount -t resctrl resctrl /sys/fs/resctrl -o caMax,caPrio,cdpl3 cd /sys/fs/resctrl && cat schemata

L3CODE:0=33554432;1=33554432;2=33554432;3=33554432 #code use cmax ctrl feature L3DATA:0=33554432;1=33554432;2=33554432;3=33554432 #data use cmax ctrl feature L3CODEPRI:0=3;1=3;2=3;3=3 #code use intpriority ctrl feature L3DATAPRI:0=3;1=3;2=3;3=3 #data use intpriority ctrl feature MB:0=100;1=100;2=100;3=100 #default select mbw max as basic ctrl feature

By combining these mount parameters can we use MPAM more powerfully.

Signed-off-by: Wang ShaoBo bobo.shaobowang@huawei.com Reviewed-by: Xiongfeng Wang wangxiongfeng2@huawei.com Reviewed-by: Cheng Jian cj.chengjian@huawei.com Signed-off-by: Yang Yingliang yangyingliang@huawei.com --- arch/arm64/include/asm/resctrl.h | 18 ++-- arch/arm64/kernel/mpam/mpam_device.c | 33 ++++++- arch/arm64/kernel/mpam/mpam_internal.h | 3 + arch/arm64/kernel/mpam/mpam_resctrl.c | 120 ++++++++++++++++++++++--- arch/arm64/kernel/mpam/mpam_setup.c | 84 ++++++++++++----- 5 files changed, 218 insertions(+), 40 deletions(-)

diff --git a/arch/arm64/include/asm/resctrl.h b/arch/arm64/include/asm/resctrl.h index 45dde62e8586..95148e1bb232 100644 --- a/arch/arm64/include/asm/resctrl.h +++ b/arch/arm64/include/asm/resctrl.h @@ -27,12 +27,15 @@ enum rdt_event_id { QOS_L3_MBM_LOCAL_EVENT_ID = 0x03,

QOS_CAT_CPBM_EVENT_ID = 0x04, - QOS_CAT_INTPRI_EVENT_ID = 0x05, - QOS_CAT_DSPRI_EVENT_ID = 0x06, - QOS_MBA_MAX_EVENT_ID = 0x07, - QOS_MBA_INTPRI_EVENT_ID = 0x08, - QOS_MBA_DSPRI_EVENT_ID = 0x09, - QOS_MBA_HDL_EVENT_ID = 0x0a, + QOS_CAT_CMAX_EVENT_ID = 0x05, + QOS_CAT_INTPRI_EVENT_ID = 0x06, + QOS_CAT_DSPRI_EVENT_ID = 0x07, + QOS_MBA_MAX_EVENT_ID = 0x08, + QOS_MBA_MIN_EVENT_ID = 0x09, + QOS_MBA_PBM_EVENT_ID = 0x0a, + QOS_MBA_INTPRI_EVENT_ID = 0x0b, + QOS_MBA_DSPRI_EVENT_ID = 0x0c, + QOS_MBA_HDL_EVENT_ID = 0x0d, /* Must be the last */ RESCTRL_NUM_EVENT_IDS, }; @@ -165,6 +168,9 @@ enum resctrl_ctrl_type { SCHEMA_COMM = 0, SCHEMA_PRI, SCHEMA_HDL, + SCHEMA_PBM, + SCHEMA_MAX, + SCHEMA_MIN, SCHEMA_NUM_CTRL_TYPE };

diff --git a/arch/arm64/kernel/mpam/mpam_device.c b/arch/arm64/kernel/mpam/mpam_device.c index 3fd5fc66b204..fc7aa1ae0b82 100644 --- a/arch/arm64/kernel/mpam/mpam_device.c +++ b/arch/arm64/kernel/mpam/mpam_device.c @@ -1142,6 +1142,11 @@ u16 mpam_sysprops_num_pmg(void) return mpam_sysprops.max_pmg + 1; }

+u32 mpam_sysprops_llc_size(void) +{ + return mpam_sysprops.mpam_llc_size; +} + static u32 mpam_device_read_csu_mon(struct mpam_device *dev, struct sync_args *args) { @@ -1317,7 +1322,7 @@ mpam_device_config(struct mpam_device *dev, struct sd_closid *closid, u16 cmax = GENMASK(dev->cmax_wd, 0); u32 pri_val = 0; u16 intpri, dspri, max_intpri, max_dspri; - u32 mbw_pbm, mbw_max; + u32 mbw_pbm, mbw_max, mbw_min; /* * if dev supports narrowing, narrowing first and then apply this slave's * configuration. @@ -1366,6 +1371,13 @@ mpam_device_config(struct mpam_device *dev, struct sd_closid *closid, } }

+ if (mpam_has_feature(mpam_feat_mbw_min, dev->features)) { + if (cfg && mpam_has_feature(mpam_feat_mbw_min, cfg->valid)) { + mbw_min = MBW_MAX_SET(cfg->mbw_min, dev->bwa_wd); + mpam_write_reg(dev, MPAMCFG_MBW_MIN, mbw_min); + } + } + if (mpam_has_feature(mpam_feat_intpri_part, dev->features) || mpam_has_feature(mpam_feat_dspri_part, dev->features)) { if (mpam_has_feature(mpam_feat_intpri_part, cfg->valid) && @@ -1596,6 +1608,11 @@ static void mpam_component_read_mpamcfg(void *_ctx) break; val = mpam_read_reg(dev, MPAMCFG_CPBM); break; + case QOS_CAT_CMAX_EVENT_ID: + if (!mpam_has_feature(mpam_feat_ccap_part, dev->features)) + break; + val = mpam_read_reg(dev, MPAMCFG_CMAX); + break; case QOS_MBA_MAX_EVENT_ID: if (!mpam_has_feature(mpam_feat_mbw_max, dev->features)) break; @@ -1603,6 +1620,20 @@ static void mpam_component_read_mpamcfg(void *_ctx) range = MBW_MAX_BWA_FRACT(dev->bwa_wd); val = MBW_MAX_GET(val, dev->bwa_wd) * (MAX_MBA_BW - 1) / range; break; + case QOS_MBA_MIN_EVENT_ID: + if (!mpam_has_feature(mpam_feat_mbw_min, dev->features)) + break; + val = mpam_read_reg(dev, MPAMCFG_MBW_MIN); + range = MBW_MAX_BWA_FRACT(dev->bwa_wd); + val = MBW_MAX_GET(val, dev->bwa_wd) * (MAX_MBA_BW - 1) / range; + break; + case QOS_MBA_PBM_EVENT_ID: + if (!mpam_has_feature(mpam_feat_mbw_part, dev->features)) + break; + val = mpam_read_reg(dev, MPAMCFG_MBW_PBM); + range = dev->mbw_pbm_bits; + val = val * MAX_MBA_BW / range; + break; case QOS_MBA_HDL_EVENT_ID: if (!mpam_has_feature(mpam_feat_mbw_max, dev->features)) break; diff --git a/arch/arm64/kernel/mpam/mpam_internal.h b/arch/arm64/kernel/mpam/mpam_internal.h index 40dcc02f4e57..cfaef82428aa 100644 --- a/arch/arm64/kernel/mpam/mpam_internal.h +++ b/arch/arm64/kernel/mpam/mpam_internal.h @@ -225,8 +225,10 @@ struct mpam_config { mpam_features_t valid;

u32 cpbm; + u32 cmax; u32 mbw_pbm; u16 mbw_max; + u16 mbw_min;

/* * dspri is downstream priority, intpri is internal priority. @@ -311,6 +313,7 @@ void mpam_component_get_config(struct mpam_component *comp,

u16 mpam_sysprops_num_partid(void); u16 mpam_sysprops_num_pmg(void); +u32 mpam_sysprops_llc_size(void);

void mpam_class_list_lock_held(void);

diff --git a/arch/arm64/kernel/mpam/mpam_resctrl.c b/arch/arm64/kernel/mpam/mpam_resctrl.c index 9817d70b737a..3998305a08ef 100644 --- a/arch/arm64/kernel/mpam/mpam_resctrl.c +++ b/arch/arm64/kernel/mpam/mpam_resctrl.c @@ -141,6 +141,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .base = 16, .evt = QOS_CAT_CPBM_EVENT_ID, .capable = 1, + .ctrl_suffix = "", }, [SCHEMA_PRI] = { .type = SCHEMA_PRI, @@ -148,6 +149,23 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .name = "caPrio", .base = 10, .evt = QOS_CAT_INTPRI_EVENT_ID, + .ctrl_suffix = "PRI", + }, + [SCHEMA_PBM] = { + .type = SCHEMA_PBM, + .flags = SCHEMA_COMM, + .name = "caPbm", + .base = 16, + .evt = QOS_CAT_CPBM_EVENT_ID, + .ctrl_suffix = "PBM", + }, + [SCHEMA_MAX] = { + .type = SCHEMA_MAX, + .flags = SCHEMA_COMM, + .name = "caMax", + .base = 10, + .evt = QOS_CAT_CMAX_EVENT_ID, + .ctrl_suffix = "MAX", }, }, }, @@ -167,6 +185,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .base = 16, .evt = QOS_CAT_CPBM_EVENT_ID, .capable = 1, + .ctrl_suffix = "", }, [SCHEMA_PRI] = { .type = SCHEMA_PRI, @@ -174,6 +193,23 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .name = "caPrio", .base = 10, .evt = QOS_CAT_INTPRI_EVENT_ID, + .ctrl_suffix = "PRI", + }, + [SCHEMA_PBM] = { + .type = SCHEMA_PBM, + .flags = SCHEMA_COMM, + .name = "caPbm", + .base = 16, + .evt = QOS_CAT_CPBM_EVENT_ID, + .ctrl_suffix = "PBM", + }, + [SCHEMA_MAX] = { + .type = SCHEMA_MAX, + .flags = SCHEMA_COMM, + .name = "caMax", + .base = 10, + .evt = QOS_CAT_CMAX_EVENT_ID, + .ctrl_suffix = "MAX", }, }, }, @@ -193,6 +229,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .base = 10, .evt = QOS_MBA_MAX_EVENT_ID, .capable = 1, + .ctrl_suffix = "", }, [SCHEMA_PRI] = { .type = SCHEMA_PRI, @@ -200,6 +237,7 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .name = "mbPrio", .base = 10, .evt = QOS_MBA_INTPRI_EVENT_ID, + .ctrl_suffix = "PRI", }, [SCHEMA_HDL] = { .type = SCHEMA_HDL, @@ -207,6 +245,31 @@ struct raw_resctrl_resource raw_resctrl_resources_all[] = { .name = "mbHdl", .base = 10, .evt = QOS_MBA_HDL_EVENT_ID, + .ctrl_suffix = "HDL", + }, + [SCHEMA_PBM] = { + .type = SCHEMA_PBM, + .flags = SCHEMA_COMM, + .name = "mbPbm", + .base = 16, + .evt = QOS_MBA_PBM_EVENT_ID, + .ctrl_suffix = "PBM", + }, + [SCHEMA_MAX] = { + .type = SCHEMA_MAX, + .flags = SCHEMA_COMM, + .name = "mbMax", + .base = 10, + .evt = QOS_MBA_MAX_EVENT_ID, + .ctrl_suffix = "MAX", + }, + [SCHEMA_MIN] = { + .type = SCHEMA_MIN, + .flags = SCHEMA_COMM, + .name = "mbMin", + .base = 10, + .evt = QOS_MBA_MIN_EVENT_ID, + .ctrl_suffix = "MIN", }, }, }, @@ -265,6 +328,8 @@ parse_bw(char *buf, struct resctrl_resource *r,

switch (rr->ctrl_features[type].evt) { case QOS_MBA_MAX_EVENT_ID: + case QOS_MBA_MIN_EVENT_ID: + case QOS_MBA_PBM_EVENT_ID: if (kstrtoul(buf, rr->ctrl_features[type].base, &data)) return -EINVAL; data = (data < r->mbw.min_bw) ? r->mbw.min_bw : data; @@ -337,6 +402,8 @@ static u64 mbw_rdmsr(struct resctrl_resource *r, struct rdt_domain *d,

switch (rr->ctrl_features[para->type].evt) { case QOS_MBA_MAX_EVENT_ID: + case QOS_MBA_MIN_EVENT_ID: + case QOS_MBA_PBM_EVENT_ID: result = roundup(result, r->mbw.bw_gran); break; default: @@ -1062,14 +1129,21 @@ static int extend_ctrl_enable(char *tok) if (!r->alloc_capable) continue; rr = r->res; - for_each_ctrl_type(type) { + for_each_extend_ctrl_type(type) { feature = &rr->ctrl_features[type]; + if (!feature->capable || !feature->name) + continue; if (strcmp(feature->name, tok)) continue; - if (rr->ctrl_features[type].capable) { - rr->ctrl_features[type].enabled = true; - match = true; - } + + rr->ctrl_features[type].enabled = true; + /* + * If we chose to enable a feature also embraces + * SCHEMA_COMM, SCHEMA_COMM will not be selected. + */ + if (feature->flags == SCHEMA_COMM) + rr->ctrl_features[SCHEMA_COMM].enabled = false;; + match = true; } }

@@ -1083,11 +1157,15 @@ static void extend_ctrl_disable(void) { struct raw_resctrl_resource *rr; struct mpam_resctrl_res *res; + struct resctrl_ctrl_feature *feature; + enum resctrl_ctrl_type type;

for_each_supported_resctrl_exports(res) { rr = res->resctrl_res.res; - rr->ctrl_features[SCHEMA_PRI].enabled = false; - rr->ctrl_features[SCHEMA_HDL].enabled = false; + for_each_extend_ctrl_type(type) { + feature = &rr->ctrl_features[type]; + feature->enabled = false; + } } }

@@ -1099,6 +1177,7 @@ int parse_rdtgroupfs_options(char *data)

disable_cdp(); extend_ctrl_disable(); + basic_ctrl_enable();

while ((token = strsep(&o, ",")) != NULL) { if (!*token) { @@ -1121,8 +1200,6 @@ int parse_rdtgroupfs_options(char *data) } }

- basic_ctrl_enable(); - return 0;

out: @@ -2003,22 +2080,43 @@ mpam_update_from_resctrl_cfg(struct mpam_resctrl_res *res, u64 range;

switch (evt) { + case QOS_MBA_PBM_EVENT_ID: + /* .. the number of bits we can set */ + range = res->class->mbw_pbm_bits; + mpam_cfg->mbw_pbm = + (resctrl_cfg * range) / MAX_MBA_BW; + mpam_set_feature(mpam_feat_mbw_part, &mpam_cfg->valid); + break; case QOS_MBA_MAX_EVENT_ID: - /* .. the number of fractions we can represent */ range = MBW_MAX_BWA_FRACT(res->class->bwa_wd); mpam_cfg->mbw_max = (resctrl_cfg * range) / (MAX_MBA_BW - 1); mpam_cfg->mbw_max = (mpam_cfg->mbw_max > range) ? range : mpam_cfg->mbw_max; mpam_set_feature(mpam_feat_mbw_max, &mpam_cfg->valid); break; + case QOS_MBA_MIN_EVENT_ID: + range = MBW_MAX_BWA_FRACT(res->class->bwa_wd); + mpam_cfg->mbw_min = (resctrl_cfg * range) / (MAX_MBA_BW - 1); + mpam_cfg->mbw_min = + (mpam_cfg->mbw_min > range) ? range : mpam_cfg->mbw_min; + mpam_set_feature(mpam_feat_mbw_min, &mpam_cfg->valid); + break; case QOS_MBA_HDL_EVENT_ID: mpam_cfg->hdl = resctrl_cfg; mpam_set_feature(mpam_feat_part_hdl, &mpam_cfg->valid); break; + case QOS_MBA_INTPRI_EVENT_ID: + mpam_cfg->intpri = resctrl_cfg; + mpam_set_feature(mpam_feat_intpri_part, &mpam_cfg->valid); + break; case QOS_CAT_CPBM_EVENT_ID: mpam_cfg->cpbm = resctrl_cfg; mpam_set_feature(mpam_feat_cpor_part, &mpam_cfg->valid); break; + case QOS_CAT_CMAX_EVENT_ID: + mpam_cfg->cmax = resctrl_cfg; + mpam_set_feature(mpam_feat_ccap_part, &mpam_cfg->valid); + break; case QOS_CAT_INTPRI_EVENT_ID: mpam_cfg->intpri = resctrl_cfg; mpam_set_feature(mpam_feat_intpri_part, &mpam_cfg->valid); @@ -2074,7 +2172,7 @@ mpam_resctrl_update_component_cfg(struct resctrl_resource *r,

resctrl_cfg = d->ctrl_val[type][intpartid]; mpam_update_from_resctrl_cfg(res, resctrl_cfg, - type, slave_mpam_cfg); + rr->ctrl_features[type].evt, slave_mpam_cfg); } }

diff --git a/arch/arm64/kernel/mpam/mpam_setup.c b/arch/arm64/kernel/mpam/mpam_setup.c index 18b1e5db5c0a..51817091f119 100644 --- a/arch/arm64/kernel/mpam/mpam_setup.c +++ b/arch/arm64/kernel/mpam/mpam_setup.c @@ -346,18 +346,17 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->res = rr;

if (mpam_has_feature(mpam_feat_mbw_part, class->features)) { - res->resctrl_mba_uses_mbw_part = true; - /* * The maximum throttling is the number of bits we can * unset in the bitmap. We never clear all of them, * so the minimum is one bit, as a percentage. */ r->mbw.min_bw = MAX_MBA_BW / class->mbw_pbm_bits; - } else { - /* we're using mpam_feat_mbw_max's */ - res->resctrl_mba_uses_mbw_part = false; + rr->ctrl_features[SCHEMA_PBM].max_wd = MAX_MBA_BW + 1; + rr->ctrl_features[SCHEMA_PBM].capable = true; + }

+ if (mpam_has_feature(mpam_feat_mbw_max, class->features)) { /* * The maximum throttling is the number of fractions we * can represent with the implemented bits. We never @@ -366,22 +365,36 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) r->mbw.min_bw = MAX_MBA_BW / ((1ULL << class->bwa_wd) - 1); /* the largest mbw_max is 100 */ - rr->ctrl_features[SCHEMA_COMM].default_ctrl = MAX_MBA_BW; - rr->ctrl_features[SCHEMA_COMM].max_wd = MAX_MBA_BW + 1; - rr->ctrl_features[SCHEMA_COMM].capable = true; + rr->ctrl_features[SCHEMA_MAX].default_ctrl = MAX_MBA_BW; + rr->ctrl_features[SCHEMA_MAX].max_wd = MAX_MBA_BW + 1; + rr->ctrl_features[SCHEMA_MAX].capable = true; + + /* default set max stride MAX as COMMON ctrl feature */ + rr->ctrl_features[SCHEMA_COMM].default_ctrl = + rr->ctrl_features[SCHEMA_MAX].default_ctrl; + rr->ctrl_features[SCHEMA_COMM].max_wd = + rr->ctrl_features[SCHEMA_MAX].max_wd; + rr->ctrl_features[SCHEMA_COMM].capable = + rr->ctrl_features[SCHEMA_MAX].capable; + } + + if (mpam_has_feature(mpam_feat_mbw_min, class->features)) { + rr->ctrl_features[SCHEMA_MIN].max_wd = MAX_MBA_BW + 1; + rr->ctrl_features[SCHEMA_MIN].capable = true; }

+ /* + * Export priority setting, which represents the max level of + * control we can export. this default priority from hardware, + * no clever here, no need to define additional default value. + */ if (mpam_has_feature(mpam_feat_intpri_part, class->features)) { - /* - * Export internal priority setting, which represents the - * max level of control we can export to resctrl. this default - * priority is from hardware, no clever here. - */ rr->ctrl_features[SCHEMA_PRI].max_wd = 1 << class->intpri_wd; rr->ctrl_features[SCHEMA_PRI].default_ctrl = class->hwdef_intpri; rr->ctrl_features[SCHEMA_PRI].capable = true; }

+ /* Just in case we have an excessive number of bits */ if (!r->mbw.min_bw) r->mbw.min_bw = 1; @@ -413,18 +426,26 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res)

if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { r->cache.cbm_len = class->cpbm_wd; - rr->ctrl_features[SCHEMA_COMM].default_ctrl = GENMASK(class->cpbm_wd - 1, 0); - rr->ctrl_features[SCHEMA_COMM].max_wd = - rr->ctrl_features[SCHEMA_COMM].default_ctrl + 1; - rr->ctrl_features[SCHEMA_COMM].capable = true; + rr->ctrl_features[SCHEMA_PBM].default_ctrl = GENMASK(class->cpbm_wd - 1, 0); + rr->ctrl_features[SCHEMA_PBM].max_wd = + rr->ctrl_features[SCHEMA_PBM].default_ctrl + 1; + rr->ctrl_features[SCHEMA_PBM].capable = true; /* * Which bits are shared with other ...things... * Unknown devices use partid-0 which uses all the bitmap * fields. Until we configured the SMMU and GIC not to do this * 'all the bits' is the correct answer here. */ - r->cache.shareable_bits = rr->ctrl_features[SCHEMA_COMM].default_ctrl; + r->cache.shareable_bits = rr->ctrl_features[SCHEMA_PBM].default_ctrl; r->cache.min_cbm_bits = 1; + + /* default set CPBM as COMMON ctrl feature */ + rr->ctrl_features[SCHEMA_COMM].default_ctrl = + rr->ctrl_features[SCHEMA_PBM].default_ctrl; + rr->ctrl_features[SCHEMA_COMM].max_wd = + rr->ctrl_features[SCHEMA_PBM].max_wd; + rr->ctrl_features[SCHEMA_COMM].capable = + rr->ctrl_features[SCHEMA_PBM].capable; }

if (mpam_has_feature(mpam_feat_intpri_part, class->features)) { @@ -437,6 +458,12 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) rr->ctrl_features[SCHEMA_PRI].default_ctrl = class->hwdef_intpri; rr->ctrl_features[SCHEMA_PRI].capable = true; } + + if (mpam_has_feature(mpam_feat_ccap_part, class->features)) { + rr->ctrl_features[SCHEMA_MAX].max_wd = mpam_sysprops_llc_size() + 1; + rr->ctrl_features[SCHEMA_MAX].capable = true; + } + /* * Only this resource is allocable can it be picked from * mpam_resctrl_pick_caches(). So directly set following @@ -464,10 +491,11 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res)

if (mpam_has_feature(mpam_feat_cpor_part, class->features)) { r->cache.cbm_len = class->cpbm_wd; - rr->ctrl_features[SCHEMA_COMM].default_ctrl = GENMASK(class->cpbm_wd - 1, 0); - rr->ctrl_features[SCHEMA_COMM].max_wd = - rr->ctrl_features[SCHEMA_COMM].default_ctrl + 1; - rr->ctrl_features[SCHEMA_COMM].capable = true; + rr->ctrl_features[SCHEMA_PBM].default_ctrl = + GENMASK(class->cpbm_wd - 1, 0); + rr->ctrl_features[SCHEMA_PBM].max_wd = + rr->ctrl_features[SCHEMA_PBM].default_ctrl + 1; + rr->ctrl_features[SCHEMA_PBM].capable = true; /* * Which bits are shared with other ...things... * Unknown devices use partid-0 which uses all the bitmap @@ -475,6 +503,18 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) * 'all the bits' is the correct answer here. */ r->cache.shareable_bits = rr->ctrl_features[SCHEMA_COMM].default_ctrl; + /* default set max stride MAX as COMMON ctrl feature */ + rr->ctrl_features[SCHEMA_COMM].default_ctrl = + rr->ctrl_features[SCHEMA_PBM].default_ctrl; + rr->ctrl_features[SCHEMA_COMM].max_wd = + rr->ctrl_features[SCHEMA_PBM].max_wd; + rr->ctrl_features[SCHEMA_COMM].capable = + rr->ctrl_features[SCHEMA_PBM].capable; + } + + if (mpam_has_feature(mpam_feat_ccap_part, class->features)) { + rr->ctrl_features[SCHEMA_MAX].max_wd = ~0; + rr->ctrl_features[SCHEMA_MAX].capable = true; }

if (mpam_has_feature(mpam_feat_intpri_part, class->features)) {