hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ The Narrow PARTID feature allows the MPAM driver to statically or dynamically allocate request PARTIDs (reqPARTIDs) to internal PARTIDs (intPARTIDs). This enables expanding the number of monitoring groups beyond the hardware PMG limit. For systems with mixed MSCs (Memory System Components), MSCs that do not support narrow PARTID use PARTIDs exceeding the minimum number of intPARTIDs as reqPARTIDs to expand monitoring groups. Expand RMID to include reqPARTID information: rmid = (reqPARTID << shift | PMG). To maintain compatibility with the existing resctrl layer, reqPARTIDs are allocated statically with a linear mapping to intPARTIDs via req2intpartid(). Mapping relationships (n = intPARTID count, m = reqPARTIDs per intPARTID): P - Partition group M - Monitoring group Group closid rmid.reqPARTID MSCs w/ narrow-PARTID MSCs w/o narrow-PARTID P1 0 intPARTID_1 PARTID_1 M1_1 0 0 ├── reqPARTID_1_1 ├── PARTID_1 M1_2 0 0+n ├── reqPARTID_1_2 ├── PARTID_1_2 M1_3 0 0+n*2 ├── reqPARTID_1_3 ├── PARTID_1_3 ... ├── ... ├── ... M1_m 0 0+n*(m-1) └── reqPARTID_1_m └── PARTID_1_m P2 1 intPARTID_2 PARTID_2 M2_1 1 1 ├── reqPARTID_2_1 ├── PARTID_2 M2_2 1 1+n ├── reqPARTID_2_2 ├── PARTID_2_2 M2_3 1 1+n*2 ├── reqPARTID_2_3 ├── PARTID_2_3 ... ├── ... ├── ... M2_m 1 1+n*(m-1) └── reqPARTID_2_m └── PARTID_2_m Pn n-1 intPARTID_n PARTID_n Mn_1 n-1 n-1 ├── reqPARTID_n_1 ├── PARTID_n Mn_2 n-1 n-1+n ├── reqPARTID_n_2 ├── PARTID_n_2 Mn_3 n-1 n-1+n*2 ├── reqPARTID_n_3 ├── PARTID_n_3 ... ├── ... ├── ... Mn_m n-1 n*m-1 └── reqPARTID_n_m └── PARTID_n_m Refactor the glue layer between resctrl abstractions (rmid) and MPAM hardware registers (reqPARTID/PMG) to support narrow PARTID. The resctrl layer uses rmid2reqpartid() and rmid2pmg() to extract components from rmid. The closid-to-intPARTID translation remains unchanged via resctrl_get_config_index(). Since narrow PARTID is a monitoring enhancement, reqPARTID is only used in monitoring paths while configuration paths maintain original semantics of closid. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- arch/arm64/include/asm/mpam.h | 17 +-- drivers/platform/mpam/mpam_resctrl.c | 160 ++++++++++++++++----------- include/linux/arm_mpam.h | 2 +- 3 files changed, 105 insertions(+), 74 deletions(-) diff --git a/arch/arm64/include/asm/mpam.h b/arch/arm64/include/asm/mpam.h index 5f1ac30ea4702..4d0a66013e3ff 100644 --- a/arch/arm64/include/asm/mpam.h +++ b/arch/arm64/include/asm/mpam.h @@ -129,18 +129,13 @@ static inline u64 mpam_get_regval(struct task_struct *tsk) #endif } -static inline void resctrl_arch_set_rmid(struct task_struct *tsk, u32 rmid) -{ -#ifdef CONFIG_ARM64_MPAM - u64 regval = mpam_get_regval(tsk); +u32 req2intpartid(u32 reqpartid); - regval &= ~MPAM_SYSREG_PMG_D; - regval &= ~MPAM_SYSREG_PMG_I; - regval |= FIELD_PREP(MPAM_SYSREG_PMG_D, rmid); - regval |= FIELD_PREP(MPAM_SYSREG_PMG_I, rmid); +static inline u32 mpam_get_regval_partid(u64 regval) +{ + u32 reqpartid = (regval & MPAM_SYSREG_PARTID_D) >> 16; - WRITE_ONCE(task_thread_info(tsk)->mpam_partid_pmg, regval); -#endif + return req2intpartid(reqpartid); } static inline void mpam_thread_switch(struct task_struct *tsk) @@ -153,7 +148,7 @@ static inline void mpam_thread_switch(struct task_struct *tsk) !static_branch_likely(&mpam_enabled)) return; - if (!regval) + if (!regval || !mpam_get_regval_partid(regval)) regval = READ_ONCE(per_cpu(arm64_mpam_default, cpu)); oldregval = READ_ONCE(per_cpu(arm64_mpam_current, cpu)); diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index 6d6f328a7f716..a2b0267502ef9 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -164,24 +164,73 @@ u32 resctrl_arch_system_num_rmid_idx(void) return num_reqpartid << closid_shift; } +static u32 rmid2reqpartid(u32 rmid) +{ + u8 pmg_shift = fls(mpam_pmg_max); + u32 reqpartid; + + WARN_ON_ONCE(pmg_shift > 8); + + rmid >>= pmg_shift; + + if (cdp_enabled) + reqpartid = resctrl_get_config_index(rmid, CDP_DATA); + else + reqpartid = resctrl_get_config_index(rmid, CDP_NONE); + + return reqpartid; +} + +static u8 rmid2pmg(u32 rmid) +{ + u8 pmg_shift = fls(mpam_pmg_max); + u32 pmg_mask = ~(~0 << pmg_shift); + + return rmid & pmg_mask; +} + +u32 req2intpartid(u32 reqpartid) +{ + u8 intpartid_shift = fls(mpam_intpartid_max); + u32 intpartid_mask = ~(~0 << intpartid_shift); + + return reqpartid & intpartid_mask; +} + +/* + * To avoid the reuse of rmid across multiple control groups, check + * the incoming closid to prevent rmid from being reallocated by + * resctrl_find_free_rmid(). + * + * If the closid and rmid do not match upon inspection, immediately + * returns an invalid rmid. A valid rmid must not exceed 24 bits. + */ u32 resctrl_arch_rmid_idx_encode(u32 closid, u32 rmid) { - u8 closid_shift = fls(mpam_pmg_max); + u32 reqpartid = rmid2reqpartid(rmid); + u32 intpartid = req2intpartid(reqpartid); + + if (cdp_enabled) + intpartid >>= 1; - BUG_ON(closid_shift > 8); + if (closid != intpartid) + return U32_MAX; - return (closid << closid_shift) | rmid; + return rmid; } void resctrl_arch_rmid_idx_decode(u32 idx, u32 *closid, u32 *rmid) { - u8 closid_shift = fls(mpam_pmg_max); - u32 pmg_mask = ~(~0 << closid_shift); - - BUG_ON(closid_shift > 8); + u32 reqpartid = rmid2reqpartid(idx); + u32 intpartid = req2intpartid(reqpartid); - *closid = idx >> closid_shift; - *rmid = idx & pmg_mask; + if (rmid) + *rmid = idx; + if (closid) { + if (cdp_enabled) + intpartid >>= 1; + *closid = intpartid; + } } void resctrl_sched_in(struct task_struct *tsk) @@ -191,23 +240,22 @@ void resctrl_sched_in(struct task_struct *tsk) mpam_thread_switch(tsk); } -void resctrl_arch_set_cpu_default_closid_rmid(int cpu, u32 closid, u32 pmg) +void resctrl_arch_set_cpu_default_closid_rmid(int cpu, u32 closid, u32 rmid) { - BUG_ON(closid > U16_MAX); - BUG_ON(pmg > U8_MAX); + u32 reqpartid = rmid2reqpartid(rmid); + u8 pmg = rmid2pmg(rmid); - if (!cdp_enabled) { - mpam_set_cpu_defaults(cpu, closid, closid, pmg, pmg); - } else { + WARN_ON_ONCE(reqpartid > U16_MAX); + WARN_ON_ONCE(pmg > U8_MAX); + + if (!cdp_enabled) + mpam_set_cpu_defaults(cpu, reqpartid, reqpartid, pmg, pmg); + else /* * When CDP is enabled, resctrl halves the closid range and we * use odd/even partid for one closid. */ - u32 partid_d = resctrl_get_config_index(closid, CDP_DATA); - u32 partid_i = resctrl_get_config_index(closid, CDP_CODE); - - mpam_set_cpu_defaults(cpu, partid_d, partid_i, pmg, pmg); - } + mpam_set_cpu_defaults(cpu, reqpartid, reqpartid + 1, pmg, pmg); } void resctrl_arch_sync_cpu_defaults(void *info) @@ -226,43 +274,40 @@ void resctrl_arch_sync_cpu_defaults(void *info) void resctrl_arch_set_closid_rmid(struct task_struct *tsk, u32 closid, u32 rmid) { + u32 reqpartid = rmid2reqpartid(rmid); + u8 pmg = rmid2pmg(rmid); + WARN_ON_ONCE(reqpartid > U16_MAX); + WARN_ON_ONCE(pmg > U8_MAX); - BUG_ON(closid > U16_MAX); - BUG_ON(rmid > U8_MAX); - - if (!cdp_enabled) { - mpam_set_task_partid_pmg(tsk, closid, closid, rmid, rmid); - } else { - u32 partid_d = resctrl_get_config_index(closid, CDP_DATA); - u32 partid_i = resctrl_get_config_index(closid, CDP_CODE); - - mpam_set_task_partid_pmg(tsk, partid_d, partid_i, rmid, rmid); - } + if (!cdp_enabled) + mpam_set_task_partid_pmg(tsk, reqpartid, reqpartid, pmg, pmg); + else + mpam_set_task_partid_pmg(tsk, reqpartid, reqpartid + 1, pmg, pmg); } bool resctrl_arch_match_closid(struct task_struct *tsk, u32 closid) { u64 regval = mpam_get_regval(tsk); - u32 tsk_closid = FIELD_GET(MPAM_SYSREG_PARTID_D, regval); + u32 tsk_partid = FIELD_GET(MPAM1_EL1_PARTID_D, regval); + + tsk_partid = req2intpartid(tsk_partid); if (cdp_enabled) - tsk_closid >>= 1; + tsk_partid >>= 1; - return tsk_closid == closid; + return tsk_partid == closid; } /* The task's pmg is not unique, the partid must be considered too */ bool resctrl_arch_match_rmid(struct task_struct *tsk, u32 closid, u32 rmid) { u64 regval = mpam_get_regval(tsk); - u32 tsk_closid = FIELD_GET(MPAM_SYSREG_PARTID_D, regval); - u32 tsk_rmid = FIELD_GET(MPAM_SYSREG_PMG_D, regval); - - if (cdp_enabled) - tsk_closid >>= 1; + u32 tsk_partid = FIELD_GET(MPAM1_EL1_PARTID_D, regval); + u32 tsk_pmg = FIELD_GET(MPAM1_EL1_PMG_D, regval); - return (tsk_closid == closid) && (tsk_rmid == rmid); + return (tsk_partid == rmid2reqpartid(rmid)) && + (tsk_pmg == rmid2pmg(rmid)); } #ifdef CONFIG_RESCTRL_IOMMU @@ -389,29 +434,24 @@ int resctrl_arch_rmid_read(struct rdt_resource *r, struct rdt_domain *d, num_mon = res->class->props.num_csu_mon; cfg.match_pmg = true; - cfg.pmg = rmid; + cfg.pmg = rmid2pmg(rmid); cfg.opts = resctrl_evt_config_to_mpam(dom->mbm_local_evt_cfg); + cfg.partid = rmid2reqpartid(rmid); - if (cdp_enabled) { - cfg.partid = resctrl_get_config_index(closid, CDP_DATA); - cfg.mon = cfg.partid % num_mon; - err = mpam_msmon_read(dom->comp, &cfg, type, val); - if (err) - return err; + cfg.mon = cfg.partid % num_mon; + err = mpam_msmon_read(dom->comp, &cfg, type, val); + if (err) + return err; - cfg.partid = resctrl_get_config_index(closid, CDP_CODE); + if (cdp_enabled) { + cfg.partid += 1; cfg.mon = cfg.partid % num_mon; err = mpam_msmon_read(dom->comp, &cfg, type, &cdp_val); if (!err) { - pr_debug("read monitor rmid %u %s:%u CODE/DATA: %lld/%lld\n", - resctrl_arch_rmid_idx_encode(closid, rmid), - r->name, dom->comp->comp_id, cdp_val, *val); + pr_debug("read monitor closid %u rmid %u %s:%u CODE/DATA: %lld/%lld\n", + closid, rmid, r->name, dom->comp->comp_id, cdp_val, *val); *val += cdp_val; } - } else { - cfg.partid = closid; - cfg.mon = cfg.partid % num_mon; - err = mpam_msmon_read(dom->comp, &cfg, type, val); } return err; @@ -433,19 +473,15 @@ void resctrl_arch_reset_rmid(struct rdt_resource *r, struct rdt_domain *d, num_mbwu_mon = res->class->props.num_mbwu_mon; cfg.mon = resctrl_arch_rmid_idx_encode(closid, rmid) % num_mbwu_mon; cfg.match_pmg = true; - cfg.pmg = rmid; + cfg.pmg = rmid2pmg(rmid); + cfg.partid = rmid2reqpartid(rmid); dom = container_of(d, struct mpam_resctrl_dom, resctrl_dom); + mpam_msmon_reset_mbwu(dom->comp, &cfg); if (cdp_enabled) { - cfg.partid = closid << 1; - mpam_msmon_reset_mbwu(dom->comp, &cfg); - cfg.partid += 1; mpam_msmon_reset_mbwu(dom->comp, &cfg); - } else { - cfg.partid = closid; - mpam_msmon_reset_mbwu(dom->comp, &cfg); } } diff --git a/include/linux/arm_mpam.h b/include/linux/arm_mpam.h index 5d60e1c6ca6c5..541c2f1bf6f4c 100644 --- a/include/linux/arm_mpam.h +++ b/include/linux/arm_mpam.h @@ -79,7 +79,7 @@ bool resctrl_arch_match_closid(struct task_struct *tsk, u32 closid); bool resctrl_arch_match_rmid(struct task_struct *tsk, u32 closid, u32 rmid); void resctrl_arch_set_cpu_default_closid(int cpu, u32 closid); void resctrl_arch_set_closid_rmid(struct task_struct *tsk, u32 closid, u32 rmid); -void resctrl_arch_set_cpu_default_closid_rmid(int cpu, u32 closid, u32 pmg); +void resctrl_arch_set_cpu_default_closid_rmid(int cpu, u32 closid, u32 rmid); void resctrl_sched_in(struct task_struct *tsk); u32 resctrl_arch_rmid_idx_encode(u32 closid, u32 rmid); void resctrl_arch_rmid_idx_decode(u32 idx, u32 *closid, u32 *rmid); -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ With the narrow PARTID feature, each control group is assigned multiple (req)PARTIDs to expand monitoring capacity. When a control group's configuration is updated, all associated sub-monitoring groups (each identified by a unique reqPARTID) should be synchronized. In __write_config(), iterate over all reqPARTIDs belonging to the control group and propagate the configuration to each sub-monitoring group: 1. For MSCs supporting narrow PARTID, establish the reqPARTID to intPARTID mapping. 2. For MSCs without narrow PARTID support, synchronize the configuration to new PARTIDs directly. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 29 ++++++++++++++++++++++++--- drivers/platform/mpam/mpam_internal.h | 2 ++ drivers/platform/mpam/mpam_resctrl.c | 5 +++++ 3 files changed, 33 insertions(+), 3 deletions(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index a190be18fff8f..7ebb9e5ebf578 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -1371,6 +1371,7 @@ static void mpam_reprogram_ris_partid(struct mpam_msc_ris *ris, u16 partid, u16 cmax = MPAMCFG_CMAX_CMAX; struct mpam_msc *msc = ris->msc; u16 bwa_fract = MPAMCFG_MBW_MAX_MAX; + u16 intpartid = req2intpartid(partid); struct mpam_props *rprops = &ris->props; spin_lock(&msc->part_sel_lock); @@ -1378,8 +1379,17 @@ static void mpam_reprogram_ris_partid(struct mpam_msc_ris *ris, u16 partid, if (mpam_has_feature(mpam_feat_partid_nrw, rprops)) { mpam_write_partsel_reg(msc, INTPARTID, - (MPAMCFG_PART_SEL_INTERNAL | partid)); - __mpam_intpart_sel(ris->ris_idx, partid, msc); + MPAMCFG_INTPARTID_INTERNAL | + intpartid); + + /* + * Mapping from reqpartid to intpartid already established. + * Sub-monitoring groups share the parent's configuration. + */ + if (partid != intpartid) + goto out; + + __mpam_intpart_sel(ris->ris_idx, intpartid, msc); } if (mpam_has_feature(mpam_feat_cpor_part, rprops)) { @@ -1463,6 +1473,7 @@ static void mpam_reprogram_ris_partid(struct mpam_msc_ris *ris, u16 partid, mpam_has_feature(mpam_feat_dspri_part, rprops)) mpam_write_partsel_reg(msc, PRI, pri_val); +out: spin_unlock(&msc->part_sel_lock); } @@ -2570,9 +2581,21 @@ struct mpam_write_config_arg { static int __write_config(void *arg) { + int closid_num = resctrl_arch_get_num_closid(NULL); struct mpam_write_config_arg *c = arg; + u32 reqpartid, req_idx; - mpam_reprogram_ris_partid(c->ris, c->partid, &c->comp->cfg[c->partid]); + /* c->partid should be within the range of intPARTIDs */ + WARN_ON_ONCE(c->partid >= closid_num); + + /* Synchronize the configuration to each sub-monitoring group. */ + for (req_idx = 0; req_idx < get_num_reqpartid_per_closid(); + req_idx++) { + reqpartid = req_idx * closid_num + c->partid; + + mpam_reprogram_ris_partid(c->ris, reqpartid, + &c->comp->cfg[c->partid]); + } return 0; } diff --git a/drivers/platform/mpam/mpam_internal.h b/drivers/platform/mpam/mpam_internal.h index e4809f2242ec0..adef0aae7cff0 100644 --- a/drivers/platform/mpam/mpam_internal.h +++ b/drivers/platform/mpam/mpam_internal.h @@ -594,4 +594,6 @@ bool mpam_cpbm_hisi_check_invalid(struct rdt_resource *r, unsigned long val); int mpam_resctrl_prepare_offline(void); +u32 get_num_reqpartid_per_closid(void); + #endif /* MPAM_INTERNAL_H */ diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index a2b0267502ef9..7786dc1c087af 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -156,6 +156,11 @@ static u32 get_num_reqpartid(void) return mpam_partid_max + 1; } +u32 get_num_reqpartid_per_closid(void) +{ + return get_num_reqpartid() / resctrl_arch_get_num_closid(NULL); +} + u32 resctrl_arch_system_num_rmid_idx(void) { u8 closid_shift = fls(mpam_pmg_max); -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Replace static reqPARTID allocation with dynamic binding to maximize monitoring group utilization. Static allocation wastes resources when control groups create fewer sub-groups than the pre-allocated limit. Add a lookup table (reqpartid_map) to dynamically bind reqPARTIDs to control groups needing extended monitoring capacity: - resctrl_arch_rmid_expand(): Find and bind a free reqPARTID to the specified closid when creating monitoring groups. - resctrl_arch_rmid_reclaim(): Unbind reqPARTID when all monitoring groups associated with pmg are freed, making it available for reuse. Update conversion helpers for dynamic mapping: - req2intpartid(): Use lookup table for dynamic entries - Add partid2closid() and req_pmg2rmid() helpers Refactor __write_config() to iterate over all reqPARTIDs that match by intPARTID, removing fixed per-closid slot assumption. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 16 ++- drivers/platform/mpam/mpam_internal.h | 2 +- drivers/platform/mpam/mpam_resctrl.c | 177 +++++++++++++++++++++----- 3 files changed, 154 insertions(+), 41 deletions(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 7ebb9e5ebf578..6ded9769ae5d2 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -2583,18 +2583,20 @@ static int __write_config(void *arg) { int closid_num = resctrl_arch_get_num_closid(NULL); struct mpam_write_config_arg *c = arg; - u32 reqpartid, req_idx; + u32 reqpartid; /* c->partid should be within the range of intPARTIDs */ WARN_ON_ONCE(c->partid >= closid_num); - /* Synchronize the configuration to each sub-monitoring group. */ - for (req_idx = 0; req_idx < get_num_reqpartid_per_closid(); - req_idx++) { - reqpartid = req_idx * closid_num + c->partid; + mpam_reprogram_ris_partid(c->ris, c->partid, + &c->comp->cfg[c->partid]); - mpam_reprogram_ris_partid(c->ris, reqpartid, - &c->comp->cfg[c->partid]); + /* Synchronize the configuration to each sub-monitoring group. */ + for (reqpartid = closid_num; + reqpartid < get_num_reqpartid(); reqpartid++) { + if (req2intpartid(reqpartid) == c->partid) + mpam_reprogram_ris_partid(c->ris, reqpartid, + &c->comp->cfg[c->partid]); } return 0; diff --git a/drivers/platform/mpam/mpam_internal.h b/drivers/platform/mpam/mpam_internal.h index adef0aae7cff0..74abba9497ceb 100644 --- a/drivers/platform/mpam/mpam_internal.h +++ b/drivers/platform/mpam/mpam_internal.h @@ -594,6 +594,6 @@ bool mpam_cpbm_hisi_check_invalid(struct rdt_resource *r, unsigned long val); int mpam_resctrl_prepare_offline(void); -u32 get_num_reqpartid_per_closid(void); +u32 get_num_reqpartid(void); #endif /* MPAM_INTERNAL_H */ diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index 7786dc1c087af..8ccf5a84f954d 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -151,16 +151,11 @@ u32 resctrl_arch_get_num_closid(struct rdt_resource *ignored) return mpam_intpartid_max + 1; } -static u32 get_num_reqpartid(void) +u32 get_num_reqpartid(void) { return mpam_partid_max + 1; } -u32 get_num_reqpartid_per_closid(void) -{ - return get_num_reqpartid() / resctrl_arch_get_num_closid(NULL); -} - u32 resctrl_arch_system_num_rmid_idx(void) { u8 closid_shift = fls(mpam_pmg_max); @@ -194,12 +189,37 @@ static u8 rmid2pmg(u32 rmid) return rmid & pmg_mask; } +static u32 req_pmg2rmid(u32 reqpartid, u8 pmg) +{ + u8 pmg_shift = fls(mpam_pmg_max); + u32 pmg_mask = ~(~0 << pmg_shift); + + if (cdp_enabled) + reqpartid >>= 1; + + return (reqpartid << pmg_shift) | (pmg & pmg_mask); +} + +static u32 *reqpartid_map; + u32 req2intpartid(u32 reqpartid) { - u8 intpartid_shift = fls(mpam_intpartid_max); - u32 intpartid_mask = ~(~0 << intpartid_shift); + /* + * Directly return intPartid in case that mpam_reset_ris() access + * NULL pointer. + */ + if (reqpartid < resctrl_arch_get_num_closid(NULL)) + return reqpartid; + + return reqpartid_map[reqpartid]; +} + +static u32 partid2closid(u32 partid) +{ + if (cdp_enabled) + partid >>= 1; - return reqpartid & intpartid_mask; + return partid; } /* @@ -213,12 +233,12 @@ u32 req2intpartid(u32 reqpartid) u32 resctrl_arch_rmid_idx_encode(u32 closid, u32 rmid) { u32 reqpartid = rmid2reqpartid(rmid); - u32 intpartid = req2intpartid(reqpartid); - if (cdp_enabled) - intpartid >>= 1; + /* When enable CDP mode, needs to filter invalid rmid entry out */ + if (reqpartid >= get_num_reqpartid()) + return U32_MAX; - if (closid != intpartid) + if (closid != partid2closid(req2intpartid(reqpartid))) return U32_MAX; return rmid; @@ -231,11 +251,9 @@ void resctrl_arch_rmid_idx_decode(u32 idx, u32 *closid, u32 *rmid) if (rmid) *rmid = idx; - if (closid) { - if (cdp_enabled) - intpartid >>= 1; - *closid = intpartid; - } + + if (closid) + *closid = partid2closid(intpartid); } void resctrl_sched_in(struct task_struct *tsk) @@ -1191,6 +1209,87 @@ static int mpam_resctrl_resource_init(struct mpam_resctrl_res *res) return 0; } +static int reqpartid_init(void) +{ + int req_num, idx; + + req_num = get_num_reqpartid(); + reqpartid_map = kcalloc(req_num, sizeof(u32), GFP_KERNEL); + if (!reqpartid_map) + return -ENOMEM; + + for (idx = 0; idx < req_num; idx++) + reqpartid_map[idx] = idx; + + return 0; +} + +void reqpartid_exit(void) +{ + kfree(reqpartid_map); +} + +void update_rmid_entries_for_reqpartid(u32 reqpartid) +{ + int pmg; + u32 intpartid = reqpartid_map[reqpartid]; + u32 closid = partid2closid(intpartid); + + for (pmg = 0; pmg <= mpam_pmg_max; pmg++) + rmid_entry_reassign_closid(closid, req_pmg2rmid(reqpartid, pmg)); +} + +int resctrl_arch_rmid_expand(u32 closid) +{ + int i; + + for (i = resctrl_arch_get_num_closid(NULL); + i < get_num_reqpartid(); i++) { + if (reqpartid_map[i] >= resctrl_arch_get_num_closid(NULL)) { + if (cdp_enabled) { + reqpartid_map[i] = resctrl_get_config_index(closid, CDP_DATA); + reqpartid_map[i + 1] = resctrl_get_config_index(closid, CDP_CODE); + } else { + reqpartid_map[i] = resctrl_get_config_index(closid, CDP_NONE); + } + update_rmid_entries_for_reqpartid(i); + return i; + } + } + + return -ENOSPC; +} + +void resctrl_arch_rmid_reclaim(u32 closid, u32 rmid) +{ + int pmg; + u32 intpartid; + int reqpartid = rmid2reqpartid(rmid); + + if (reqpartid < resctrl_arch_get_num_closid(NULL)) + return; + + if (cdp_enabled) + intpartid = resctrl_get_config_index(closid, CDP_DATA); + else + intpartid = resctrl_get_config_index(closid, CDP_NONE); + + WARN_ON_ONCE(intpartid != req2intpartid(reqpartid)); + + for (pmg = 0; pmg <= mpam_pmg_max; pmg++) { + if (rmid_is_occupied(closid, req_pmg2rmid(reqpartid, pmg))) + break; + } + + if (pmg > mpam_pmg_max) { + reqpartid_map[reqpartid] = reqpartid; + if (cdp_enabled) + reqpartid_map[reqpartid + 1] = reqpartid + 1; + + update_rmid_entries_for_reqpartid(reqpartid); + } +} + int mpam_resctrl_setup(void) { int err = 0; @@ -1222,24 +1321,35 @@ int mpam_resctrl_setup(void) } cpus_read_unlock(); - if (!err && !exposed_alloc_capable && !exposed_mon_capable) - err = -EOPNOTSUPP; - - if (!err) { - if (!is_power_of_2(mpam_pmg_max + 1)) { - /* - * If not all the partid*pmg values are valid indexes, - * resctrl may allocate pmg that don't exist. This - * should cause an error interrupt. - */ - pr_warn("Number of PMG is not a power of 2! resctrl may misbehave"); - } + if (err) + return err; + + if (!exposed_alloc_capable && !exposed_mon_capable) + return -EOPNOTSUPP; - err = resctrl_init(); - if (!err) - WRITE_ONCE(resctrl_enabled, true); + err = reqpartid_init(); + if (err) + return err; + + if (!is_power_of_2(mpam_pmg_max + 1)) { + /* + * If not all the partid*pmg values are valid indexes, + * resctrl may allocate pmg that don't exist. This + * should cause an error interrupt. + */ + pr_warn("Number of PMG is not a power of 2! resctrl may misbehave"); } + err = resctrl_init(); + if (err) + goto out; + + WRITE_ONCE(resctrl_enabled, true); + + return 0; + +out: + reqpartid_exit(); return err; } @@ -1250,6 +1360,7 @@ void mpam_resctrl_exit(void) WRITE_ONCE(resctrl_enabled, false); resctrl_exit(); + reqpartid_exit(); } u32 resctrl_arch_get_config(struct rdt_resource *r, struct rdt_domain *d, -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Add mpam_sync_config() to synchronize configuration when dynamically expanding rmid resources. When binding a new reqpartid to a control group, the driver maps the reqpartid to the corresponding intpartid or applies the control group's existing configuration to new partid if without Narrow partid feature. Extend mpam_apply_config() with a sync mode: - Sync mode: mpam_sync_config() calls this to apply existing configuration without updating config. - Non-sync mode: resctrl_arch_update_one() calls this to compare, update, and apply configuration. This mode retains the original behavior. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 25 +++++++++++++++++++---- drivers/platform/mpam/mpam_internal.h | 2 +- drivers/platform/mpam/mpam_resctrl.c | 29 ++++++++++++++++++++++++--- 3 files changed, 48 insertions(+), 8 deletions(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 6ded9769ae5d2..62b7ae418a882 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -2577,6 +2577,7 @@ struct mpam_write_config_arg { struct mpam_msc_ris *ris; struct mpam_component *comp; u16 partid; + bool sync; }; static int __write_config(void *arg) @@ -2585,6 +2586,15 @@ static int __write_config(void *arg) struct mpam_write_config_arg *c = arg; u32 reqpartid; + if (c->sync) { + /* c->partid should be within the range of reqPARTIDs */ + WARN_ON_ONCE(c->partid < closid_num); + + mpam_reprogram_ris_partid(c->ris, c->partid, + &c->comp->cfg[req2intpartid(c->partid)]); + return 0; + } + /* c->partid should be within the range of intPARTIDs */ WARN_ON_ONCE(c->partid >= closid_num); @@ -2605,7 +2615,7 @@ static int __write_config(void *arg) /* TODO: split into write_config/sync_config */ /* TODO: add config_dirty bitmap to drive sync_config */ int mpam_apply_config(struct mpam_component *comp, u16 partid, - struct mpam_config *cfg) + struct mpam_config *cfg, bool sync) { struct mpam_write_config_arg arg; struct mpam_msc_ris *ris; @@ -2613,12 +2623,19 @@ int mpam_apply_config(struct mpam_component *comp, u16 partid, lockdep_assert_cpus_held(); - if (!memcmp(&comp->cfg[partid], cfg, sizeof(*cfg))) - return 0; + if (!sync) { + /* The partid is within the range of intPARTIDs */ + WARN_ON_ONCE(partid >= resctrl_arch_get_num_closid(NULL)); + + if (!memcmp(&comp->cfg[partid], cfg, sizeof(*cfg))) + return 0; + + comp->cfg[partid] = *cfg; + } - comp->cfg[partid] = *cfg; arg.comp = comp; arg.partid = partid; + arg.sync = sync; idx = srcu_read_lock(&mpam_srcu); list_for_each_entry_rcu(ris, &comp->ris, comp_list) { diff --git a/drivers/platform/mpam/mpam_internal.h b/drivers/platform/mpam/mpam_internal.h index 74abba9497ceb..ebb6d7357a980 100644 --- a/drivers/platform/mpam/mpam_internal.h +++ b/drivers/platform/mpam/mpam_internal.h @@ -314,7 +314,7 @@ void mpam_disable(struct work_struct *work); void mpam_reset_class(struct mpam_class *class); int mpam_apply_config(struct mpam_component *comp, u16 partid, - struct mpam_config *cfg); + struct mpam_config *cfg, bool sync); int mpam_msmon_read(struct mpam_component *comp, struct mon_cfg *ctx, enum mpam_device_features, u64 *val); diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index 8ccf5a84f954d..ad8ed64af4153 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -1239,6 +1239,23 @@ void update_rmid_entries_for_reqpartid(u32 reqpartid) rmid_entry_reassign_closid(closid, req_pmg2rmid(reqpartid, pmg)); } +static int mpam_sync_config(u32 reqpartid) +{ + struct mpam_component *comp; + struct mpam_class *class; + int err; + + list_for_each_entry(class, &mpam_classes, classes_list) { + list_for_each_entry(comp, &class->components, class_list) { + err = mpam_apply_config(comp, reqpartid, NULL, true); + if (err) + return err; + } + } + + return 0; +} + int resctrl_arch_rmid_expand(u32 closid) { int i; @@ -1248,10 +1265,16 @@ int resctrl_arch_rmid_expand(u32 closid) if (reqpartid_map[i] >= resctrl_arch_get_num_closid(NULL)) { if (cdp_enabled) { reqpartid_map[i] = resctrl_get_config_index(closid, CDP_DATA); + mpam_sync_config(i); + reqpartid_map[i + 1] = resctrl_get_config_index(closid, CDP_CODE); + mpam_sync_config(i + 1); + } else { reqpartid_map[i] = resctrl_get_config_index(closid, CDP_NONE); + mpam_sync_config(i); } + update_rmid_entries_for_reqpartid(i); return i; } @@ -1544,15 +1567,15 @@ int resctrl_arch_update_one(struct rdt_resource *r, struct rdt_domain *d, */ if (mpam_resctrl_hide_cdp(r->rid)) { partid = resctrl_get_config_index(closid, CDP_CODE); - err = mpam_apply_config(dom->comp, partid, &cfg); + err = mpam_apply_config(dom->comp, partid, &cfg, false); if (err) return err; partid = resctrl_get_config_index(closid, CDP_DATA); - return mpam_apply_config(dom->comp, partid, &cfg); + return mpam_apply_config(dom->comp, partid, &cfg, false); } else { - return mpam_apply_config(dom->comp, partid, &cfg); + return mpam_apply_config(dom->comp, partid, &cfg, false); } } -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ MPAM supports heterogeneous systems where some type of MSCs may implement Narrow-PARTID while others do not. However, when an MSC uses percentage-based throttling (non-bitmap partition control) and lacks Narrow-PARTID support, resctrl cannot correctly apply control group configurations across multiple PARTIDs. To enable free assignment of multiple reqPARTIDs to resource control groups, all MSCs used by resctrl must either: Implement Narrow-PARTID, allowing explicit PARTID remapping, or only have stateless resource controls (non-percentage-based), such that splitting a control group across multiple PARTIDs does not affect behavior. The detection occurs at initialization time on the first call to get_num_reqpartid() from update_rmid_limits(). This call is guaranteed to occur after mpam_resctrl_pick_{mba,caches}() have set up the resource classes, ensuring the necessary properties are available for the Narrow-PARTID capability check. When an MSC with percentage-based control lacks Narrow-PARTID support, get_num_reqpartid() falls back to returning the number of intPARTIDs, effectively disabling the reqPARTID expansion for monitoring groups. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_resctrl.c | 75 +++++++++++++++++++++------- 1 file changed, 56 insertions(+), 19 deletions(-) diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index ad8ed64af4153..e3fd8361c22d9 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -151,17 +151,46 @@ u32 resctrl_arch_get_num_closid(struct rdt_resource *ignored) return mpam_intpartid_max + 1; } +/* + * Determine the effective number of PARTIDs available for resctrl. + * + * This function performs a one-time check to determine if Narrow-PARTID + * can be used. It must be called after mpam_resctrl_pick_{mba,caches}() + * have initialized the resource classes, as class properties are used + * to detect Narrow-PARTID support. + * + * The first call occurs in update_rmid_limits(), ensuring the + * prerequisite initialization is complete. + */ u32 get_num_reqpartid(void) { + struct mpam_props *cprops; + struct mpam_class *class; + static bool first = true; + + if (first) { + list_for_each_entry_rcu(class, &mpam_classes, classes_list) { + cprops = &class->props; + if (mpam_has_feature(mpam_feat_partid_nrw, cprops)) + continue; + + if (mpam_has_feature(mpam_feat_mbw_max, cprops) || + mpam_has_feature(mpam_feat_mbw_min, cprops) || + mpam_has_feature(mpam_feat_ccap_part, cprops) || + mpam_has_feature(mpam_feat_cmin, cprops)) { + mpam_partid_max = mpam_intpartid_max; + break; + } + } + } + + first = false; return mpam_partid_max + 1; } u32 resctrl_arch_system_num_rmid_idx(void) { - u8 closid_shift = fls(mpam_pmg_max); - u32 num_reqpartid = get_num_reqpartid(); - - return num_reqpartid << closid_shift; + return (mpam_pmg_max + 1) * get_num_reqpartid(); } static u32 rmid2reqpartid(u32 rmid) @@ -512,9 +541,13 @@ void resctrl_arch_reset_rmid(struct rdt_resource *r, struct rdt_domain *d, * The rmid realloc threshold should be for the smallest cache exposed to * resctrl. */ -static void update_rmid_limits(unsigned int size) +static void update_rmid_limits(struct mpam_class *class) { u32 num_unique_pmg = resctrl_arch_system_num_rmid_idx(); + unsigned int size; + + /* Assume cache levels are the same size for all CPUs... */ + size = get_cpu_cacheinfo_size(smp_processor_id(), class->level); if (WARN_ON_ONCE(!size)) return; @@ -773,7 +806,6 @@ static u16 ca_max_to_percent(u16 ca_max, u8 wd) static void mpam_resctrl_pick_caches(void) { int idx; - unsigned int cache_size; struct mpam_class *class; struct mpam_resctrl_res *res; bool has_cpor, has_cmax, has_cmin, has_intpri; @@ -813,18 +845,6 @@ static void mpam_resctrl_pick_caches(void) continue; } - /* Assume cache levels are the same size for all CPUs... */ - cache_size = get_cpu_cacheinfo_size(smp_processor_id(), class->level); - if (!cache_size) { - pr_debug("pick_caches: Could not read cache size\n"); - continue; - } - - if (mpam_has_feature(mpam_feat_msmon_csu, cprops)) { - if (class->level == 3) - update_rmid_limits(cache_size); - } - if (has_cpor) { if (class->level == 2) { res = &mpam_resctrl_exports[RDT_RESOURCE_L2]; @@ -923,6 +943,23 @@ static void mpam_resctrl_pick_mba(void) srcu_read_unlock(&mpam_srcu, idx); } +static void mpam_resctrl_pick_counters(void) +{ + struct mpam_class *class; + int idx; + + idx = srcu_read_lock(&mpam_srcu); + + list_for_each_entry_rcu(class, &mpam_classes, classes_list) { + if (mpam_has_feature(mpam_feat_msmon_csu, &class->props)) { + if (class->level == 3) + update_rmid_limits(class); + } + } + + srcu_read_unlock(&mpam_srcu, idx); +} + bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt) { struct mpam_props *cprops; @@ -1331,7 +1368,7 @@ int mpam_resctrl_setup(void) mpam_resctrl_pick_caches(); mpam_resctrl_pick_mba(); - /* TODO: mpam_resctrl_pick_counters(); */ + mpam_resctrl_pick_counters(); for (i = 0; i < RDT_NUM_RESOURCES; i++) { res = &mpam_resctrl_exports[i]; -- 2.43.0

hulk inclusion category: bugfix bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ When reparenting a monitor group (RDTMON_GROUP) to a new control group (RDTCTRL_GROUP), mongrp_reparent() updates rdtgrp->closid to the new parent's closid before calling rdt_move_group_tasks(). However, rdt_move_group_tasks() expects the first argument to be the *original* group (to identify tasks by their current closid) and the second argument to be the *destination* group (to update tasks to the new closid). By passing rdtgrp for both arguments after modifying its closid, the function fails to find any tasks to migrate because it searches for the new closid instead of the old one. Fix this by saving a copy of the original rdtgrp state before modifying it, then passing the copy as the source and the updated rdtgrp as the destination to rdt_move_group_tasks(). Fixes: 43132396266d ("fs/resctrl: Re-allocate rmid for the monitor when migrating across control groups") Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- fs/resctrl/rdtgroup.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c index 428e6538072e0..16c4f9311111d 100644 --- a/fs/resctrl/rdtgroup.c +++ b/fs/resctrl/rdtgroup.c @@ -3852,6 +3852,7 @@ static void mongrp_reparent(struct rdtgroup *rdtgrp, cpumask_var_t cpus) { struct rdtgroup *prdtgrp = rdtgrp->mon.parent; + struct rdtgroup old_rdtgrp = *rdtgrp; WARN_ON(rdtgrp->type != RDTMON_GROUP); WARN_ON(new_prdtgrp->type != RDTCTRL_GROUP); @@ -3870,7 +3871,7 @@ static void mongrp_reparent(struct rdtgroup *rdtgrp, rdtgrp->closid = new_prdtgrp->closid; /* Propagate updated closid to all tasks in this group. */ - rdt_move_group_tasks(rdtgrp, rdtgrp, cpus); + rdt_move_group_tasks(&old_rdtgrp, rdtgrp, cpus); update_closid_rmid(cpus, NULL); } -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Add support for the Hisilicon HIP13 processor by extending the existing HIP12-specific quirks to cover HIP13 as well. HIP13 inherits the following quirks from HIP12: * PMG_MAX workaround: Force PMG_MAX to 0 * CSU retrigger: Re-trigger cache monitoring reads for accurate values * CSU halved: Halve cache utilization values to match actual capacity Create a unified hisi_cpus[] list containing both HIP12 and HIP13 to simplify the quirk checks. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 3e875f29bd03b..60ab22fed7fde 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -97,6 +97,12 @@ static const struct midr_range hip12_cpus[] = { { /* sentinel */ } }; +static const struct midr_range hisi_cpus[] = { + MIDR_ALL_VERSIONS(MIDR_HISI_HIP12), + MIDR_ALL_VERSIONS(MIDR_HISI_HIP13), + { /* sentinel */ } +}; + static u32 __mpam_read_reg(struct mpam_msc *msc, u16 reg) { WARN_ON_ONCE(reg + sizeof(u32) > msc->mapped_hwpage_sz); @@ -776,7 +782,7 @@ static void mpam_ris_hw_probe(struct mpam_msc_ris *ris) static int mpam_pmg_max_workaround(u64 idr) { - if (is_midr_in_range_list(hip12_cpus)) + if (is_midr_in_range_list(hisi_cpus)) return 0; return FIELD_GET(MPAMF_IDR_PMG_MAX, idr); @@ -957,7 +963,7 @@ static bool mpam_csu_hisi_need_retrigger(struct mpam_msc_ris *ris, ris->comp->class->level != 3) return false; - if (!is_midr_in_range_list(hip12_cpus)) + if (!is_midr_in_range_list(hisi_cpus)) return false; if (read_again) @@ -1025,7 +1031,7 @@ static bool mpam_ris_has_nrdy_bit(struct mpam_msc_ris *ris) static u64 mpam_csu_hisi_need_halved(struct mpam_msc_ris *ris, u64 now) { - if (!is_midr_in_range_list(hip12_cpus)) + if (!is_midr_in_range_list(hisi_cpus)) return now; if (ris->comp->class->type != MPAM_CLASS_CACHE || -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Introduce resctrl_arch_setup_res_mbm_over() and resctrl_arch_setup_res_mbm_over_exclude_cpu() to abstract MBM overflow handling setup for different architectures. This abstraction is required because: * x86 only supports MBM on L3 cache, requiring single-resource setup. * ARM MPAM supports MBM on multiple resources (L2, L3, MBA), requiring iteration over all enabled resources. Add generic helper: * resctrl_setup_dom_overflow(): Set up overflow handlers for all domains in a resource * resctrl_setup_dom_overflow_exclude_cpu(): Re-setup handlers excluding a specific CPU (used during CPU hotplug) Refactor rdt_get_tree() and resctrl_offline_cpu() to use these helpers, eliminating hardcoded L3 dependencies. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_resctrl.c | 34 ++++++++++++++++++++++ fs/resctrl/rdtgroup.c | 42 ++++++++++++++++++++-------- include/linux/resctrl.h | 7 +++++ 3 files changed, 71 insertions(+), 12 deletions(-) diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index 9c1d98791e225..ad9e6b1ac7167 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -99,6 +99,40 @@ bool resctrl_arch_is_mbm_enabled(enum resctrl_res_level rid) } } +void resctrl_arch_setup_res_mbm_over(void) +{ + struct mpam_resctrl_res *res; + int i; + + for (i = 0; i < RDT_NUM_RESOURCES; i++) { + res = &mpam_resctrl_exports[i]; + + if (!res->class) + continue; + + resctrl_setup_dom_overflow(&res->resctrl_res); + } +} + +void resctrl_arch_setup_res_mbm_over_exclude_cpu(unsigned int exclude_cpu) +{ + struct mpam_resctrl_res *res; + struct rdt_domain *d; + int i; + + for (i = 0; i < RDT_NUM_RESOURCES; i++) { + res = &mpam_resctrl_exports[i]; + + if (!res->class) + continue; + + d = resctrl_get_domain_from_cpu(exclude_cpu, &res->resctrl_res); + if (d) + resctrl_setup_dom_overflow_exclude_cpu(&res->resctrl_res, + d, exclude_cpu); + } +} + bool resctrl_arch_get_cdp_enabled(enum resctrl_res_level rid) { switch (rid) { diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c index 139ea6bc446cd..b719eded4839b 100644 --- a/fs/resctrl/rdtgroup.c +++ b/fs/resctrl/rdtgroup.c @@ -2679,12 +2679,22 @@ static void schemata_list_destroy(void) } } +void resctrl_setup_dom_overflow(struct rdt_resource *r) +{ + struct rdt_domain *d; + + if (resctrl_arch_is_mbm_enabled(r->rid) && + resctrl_arch_would_mbm_overflow()) { + list_for_each_entry(d, &r->domains, list) + mbm_setup_overflow_handler(d, MBM_OVERFLOW_INTERVAL, + RESCTRL_PICK_ANY_CPU); + } +} + static int rdt_get_tree(struct fs_context *fc) { - struct rdt_resource *l3 = resctrl_arch_get_resource(RDT_RESOURCE_L3); struct rdt_fs_context *ctx = rdt_fc2context(fc); unsigned long flags = RFTYPE_CTRL_BASE; - struct rdt_domain *dom; int ret; cpus_read_lock(); @@ -2758,11 +2768,7 @@ static int rdt_get_tree(struct fs_context *fc) if (resctrl_arch_alloc_capable() || resctrl_arch_mon_capable()) resctrl_mounted = true; - if (resctrl_arch_is_mbm_enabled(l3->rid) && resctrl_arch_would_mbm_overflow()) { - list_for_each_entry(dom, &l3->domains, list) - mbm_setup_overflow_handler(dom, MBM_OVERFLOW_INTERVAL, - RESCTRL_PICK_ANY_CPU); - } + resctrl_arch_setup_res_mbm_over(); goto out; @@ -4188,6 +4194,21 @@ static void clear_childcpus(struct rdtgroup *r, unsigned int cpu) } } +void resctrl_setup_dom_overflow_exclude_cpu(struct rdt_resource *r, + struct rdt_domain *d, + unsigned int exclude_cpu) +{ + if (!d) + return; + + if (resctrl_arch_is_mbm_enabled(r->rid) && + exclude_cpu == d->mbm_work_cpu && + resctrl_arch_would_mbm_overflow()) { + cancel_delayed_work(&d->mbm_over); + mbm_setup_overflow_handler(d, 0, exclude_cpu); + } +} + void resctrl_offline_cpu(unsigned int cpu) { struct rdt_resource *l3 = resctrl_arch_get_resource(RDT_RESOURCE_L3); @@ -4207,11 +4228,6 @@ void resctrl_offline_cpu(unsigned int cpu) d = resctrl_get_domain_from_cpu(cpu, l3); if (d) { - if (resctrl_arch_is_mbm_enabled(l3->rid) && cpu == d->mbm_work_cpu && - resctrl_arch_would_mbm_overflow()) { - cancel_delayed_work(&d->mbm_over); - mbm_setup_overflow_handler(d, 0, cpu); - } if (resctrl_arch_is_llc_occupancy_enabled() && cpu == d->cqm_work_cpu && has_busy_rmid(d)) { cancel_delayed_work(&d->cqm_limbo); @@ -4219,6 +4235,8 @@ void resctrl_offline_cpu(unsigned int cpu) } } + resctrl_arch_setup_res_mbm_over_exclude_cpu(cpu); + out_unlock: mutex_unlock(&rdtgroup_mutex); } diff --git a/include/linux/resctrl.h b/include/linux/resctrl.h index dd3c2b660b393..6fb5e7ca29a26 100644 --- a/include/linux/resctrl.h +++ b/include/linux/resctrl.h @@ -473,6 +473,13 @@ void resctrl_exit(void); int resctrl_arch_mon_resource_init(void); void mbm_config_rftype_init(const char *config); +void resctrl_setup_dom_overflow(struct rdt_resource *r); +void resctrl_setup_dom_overflow_exclude_cpu(struct rdt_resource *r, + struct rdt_domain *d, + unsigned int exclude_cpu); +void resctrl_arch_setup_res_mbm_over(void); +void resctrl_arch_setup_res_mbm_over_exclude_cpu(unsigned int exclude_cpu); + /* When supported, the architecture must implement these */ #ifdef CONFIG_RESCTRL_IOMMU int resctrl_arch_set_iommu_closid_rmid(struct iommu_group *group, u32 closid, -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ The current resctrl_arch_would_mbm_overflow() assumes all HiSilicon CPUs do not require MBM overflow handling, returning false for any ARM_CPU_IMP_HISI implementor. However, HIP13 follows the ARM spec and requires proper overflow detection. This leads to incorrect memory bandwidth measurements on HIP13 systems when the MBM counter wraps around. Fix this by explicitly checking for HIP13 in the HiSilicon branch and returning true to enable overflow handling. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index d6e29f4fd710d..7180b253cf978 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -97,6 +97,11 @@ static const struct midr_range hip12_cpus[] = { { /* sentinel */ } }; +static const struct midr_range hip13_cpus[] = { + MIDR_ALL_VERSIONS(MIDR_HISI_HIP13), + { /* sentinel */ } +}; + static const struct midr_range hisi_cpus[] = { MIDR_ALL_VERSIONS(MIDR_HISI_HIP12), MIDR_ALL_VERSIONS(MIDR_HISI_HIP13), @@ -1018,7 +1023,12 @@ static u64 mpam_msmon_overflow_val(struct mpam_msc_ris *ris) bool resctrl_arch_would_mbm_overflow(void) { - return read_cpuid_implementor() != ARM_CPU_IMP_HISI; + /* Non-HiSilicon CPUs and HIP13 need overflow handling */ + if (read_cpuid_implementor() != ARM_CPU_IMP_HISI) + return true; + + /* HIP13 is the exception among HiSilicon CPUs */ + return is_midr_in_range_list(hip13_cpus); } static bool mpam_ris_has_nrdy_bit(struct mpam_msc_ris *ris) -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Update the SMMU IOMMU group QoS parameter functions to use the Narrow PARTID abstraction helpers instead of manual partid calculations: This enables SMMU devices to participate in the Narrow PARTID scheme where multiple reqPARTIDs can be mapped to a single internal PARTID, expanding the number of available monitoring contexts for IOMMU groups. This patch builds on the Narrow PARTID feature introduced in earlier commits, extending support to SMMU/IOMMU devices. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_resctrl.c | 27 +++++++++------------------ 1 file changed, 9 insertions(+), 18 deletions(-) diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index ce5a894b962ba..569a5254d65e0 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -414,44 +414,35 @@ bool resctrl_arch_match_rmid(struct task_struct *tsk, u32 closid, u32 rmid) int resctrl_arch_set_iommu_closid_rmid(struct iommu_group *group, u32 closid, u32 rmid) { - u16 partid; - - if (cdp_enabled) - partid = closid << 1; - else - partid = closid; - - return iommu_group_set_qos_params(group, partid, rmid); + return iommu_group_set_qos_params(group, rmid2reqpartid(rmid), + rmid2pmg(rmid)); } bool resctrl_arch_match_iommu_closid(struct iommu_group *group, u32 closid) { - u16 partid; - int err = iommu_group_get_qos_params(group, &partid, NULL); + u16 reqpartid; + int err = iommu_group_get_qos_params(group, &reqpartid, NULL); if (err) return false; if (cdp_enabled) - partid >>= 1; + closid <<= 1; - return (partid == closid); + return req2intpartid(reqpartid) == closid; } bool resctrl_arch_match_iommu_closid_rmid(struct iommu_group *group, u32 closid, u32 rmid) { u8 pmg; - u16 partid; - int err = iommu_group_get_qos_params(group, &partid, &pmg); + u16 reqpartid; + int err = iommu_group_get_qos_params(group, &reqpartid, &pmg); if (err) return false; - if (cdp_enabled) - partid >>= 1; - - return (partid == closid) && (rmid == pmg); + return req_pmg2rmid(reqpartid, pmg) == rmid; } #endif -- 2.43.0

hulk inclusion category: bugfix bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Remove the mbm_core field and its associated allocation from struct rdt_domain, as it is no referenced anywhere in the codebase. This is a code cleanup with no functional change. Fixes: 556688623b2b ("fs/resctrl: Create l2 cache monitors") Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- fs/resctrl/rdtgroup.c | 10 ---------- include/linux/resctrl.h | 1 - 2 files changed, 11 deletions(-) diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c index b719eded4839b..601c74e18315b 100644 --- a/fs/resctrl/rdtgroup.c +++ b/fs/resctrl/rdtgroup.c @@ -4119,16 +4119,6 @@ static int domain_setup_mon_state(struct rdt_resource *r, struct rdt_domain *d) return -ENOMEM; } } - if (resctrl_arch_is_mbm_core_enabled()) { - tsize = sizeof(*d->mbm_core); - d->mbm_core = kcalloc(idx_limit, tsize, GFP_KERNEL); - if (!d->mbm_core) { - bitmap_free(d->rmid_busy_llc); - kfree(d->mbm_total); - kfree(d->mbm_local); - return -ENOMEM; - } - } return 0; } diff --git a/include/linux/resctrl.h b/include/linux/resctrl.h index 6fb5e7ca29a26..a9ef4cfce2a62 100644 --- a/include/linux/resctrl.h +++ b/include/linux/resctrl.h @@ -119,7 +119,6 @@ struct rdt_domain { unsigned long *rmid_busy_llc; struct mbm_state *mbm_total; struct mbm_state *mbm_local; - struct mbm_state *mbm_core; struct delayed_work mbm_over; struct delayed_work cqm_limbo; int mbm_work_cpu; -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Add support for checking whether the MBM (Memory Bandwidth Monitoring) total bandwidth event is configurable on MPAM-enabled platforms. This mirrors the existing handling for the MBM local bandwidth event by checking the msmon_mbwu_rwbw feature flag on the mbm_total_class's properties. The QOS_L3_MBM_TOTAL_EVENT_ID case was missing from resctrl_arch_is_evt_configurable(), causing the total bandwidth monitoring event to be incorrectly reported as non-configurable even when the underlying hardware supports it. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_resctrl.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/drivers/platform/mpam/mpam_resctrl.c b/drivers/platform/mpam/mpam_resctrl.c index c279ba142ca3d..5f470d07d1f04 100644 --- a/drivers/platform/mpam/mpam_resctrl.c +++ b/drivers/platform/mpam/mpam_resctrl.c @@ -1086,6 +1086,12 @@ bool resctrl_arch_is_evt_configurable(enum resctrl_event_id evt) return false; cprops = &mbm_local_class->props; + return mpam_has_feature(mpam_feat_msmon_mbwu_rwbw, cprops); + case QOS_L3_MBM_TOTAL_EVENT_ID: + if (!mbm_total_class) + return false; + + cprops = &mbm_total_class->props; return mpam_has_feature(mpam_feat_msmon_mbwu_rwbw, cprops); default: return false; -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ Not all of MPAM is visible through the resctrl user-space interface. To make it easy to debug why certain devices were not exposed through resctrl, allow the properties of the devices to be read through debugfs. This adds an mpam directory to debugfs, and exposes the devices as well as the hierarchy that was built. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 117 ++++++++++++++++++++++++-- drivers/platform/mpam/mpam_internal.h | 11 +++ 2 files changed, 122 insertions(+), 6 deletions(-) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 3c93dc6b2b1ca..418a341f3821a 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -394,6 +394,9 @@ static void mpam_msc_destroy(struct mpam_msc *msc) list_for_each_entry_safe(ris, tmp, &msc->ris, msc_list) mpam_ris_destroy(ris); + + debugfs_remove_recursive(msc->debugfs); + msc->debugfs = NULL; } /* @@ -625,6 +628,7 @@ u16 mpam_cpbm_wd_hisi_workaround(u16 cpbm_wd, enum mpam_device_features feat, return cpbm_wd; } +static struct dentry *mpam_debugfs; static void mpam_ris_hw_probe(struct mpam_msc_ris *ris) { int err; @@ -637,25 +641,25 @@ static void mpam_ris_hw_probe(struct mpam_msc_ris *ris) /* Cache Capacity Partitioning */ if (FIELD_GET(MPAMF_IDR_HAS_CCAP_PART, ris->idr)) { - u32 ccap_features = mpam_read_partsel_reg(msc, CCAP_IDR); + ris->ccap_idr = mpam_read_partsel_reg(msc, CCAP_IDR); - props->cmax_wd = FIELD_GET(MPAMF_CCAP_IDR_CMAX_WD, ccap_features); + props->cmax_wd = FIELD_GET(MPAMF_CCAP_IDR_CMAX_WD, ris->ccap_idr); if (props->cmax_wd) { - if (!FIELD_GET(MPAMF_CCAP_IDR_NO_CMAX, ccap_features)) + if (!FIELD_GET(MPAMF_CCAP_IDR_NO_CMAX, ris->ccap_idr)) mpam_set_feature(mpam_feat_ccap_part, props); - if (FIELD_GET(MPAMF_CCAP_IDR_HAS_CMIN, ccap_features)) + if (FIELD_GET(MPAMF_CCAP_IDR_HAS_CMIN, ris->ccap_idr)) mpam_set_feature(mpam_feat_cmin, props); } } /* Cache Portion partitioning */ if (FIELD_GET(MPAMF_IDR_HAS_CPOR_PART, ris->idr)) { - u32 cpor_features = mpam_read_partsel_reg(msc, CPOR_IDR); + ris->cpor_idr = mpam_read_partsel_reg(msc, CPOR_IDR); props->cpbm_wd = mpam_cpbm_wd_hisi_workaround( - FIELD_GET(MPAMF_CPOR_IDR_CPBM_WD, cpor_features), + FIELD_GET(MPAMF_CPOR_IDR_CPBM_WD, ris->cpor_idr), mpam_feat_cpor_part, class->level); if (props->cpbm_wd) mpam_set_feature(mpam_feat_cpor_part, props); @@ -1992,6 +1996,7 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) { int err; pgprot_t prot; + char name[20]; void * __iomem io; struct mpam_msc *msc; struct resource *msc_res; @@ -2090,6 +2095,11 @@ static int mpam_msc_drv_probe(struct platform_device *pdev) list_add_rcu(&msc->glbl_list, &mpam_all_msc); platform_set_drvdata(pdev, msc); + + snprintf(name, sizeof(name), "msc.%u", msc->id); + msc->debugfs = debugfs_create_dir(name, mpam_debugfs); + debugfs_create_x32("max_nrdy_usec", 0400, msc->debugfs, &msc->nrdy_usec); + } while (0); mutex_unlock(&mpam_list_lock); @@ -2448,6 +2458,97 @@ static int mpam_allocate_config(void) return 0; } +static void mpam_debugfs_setup_ris(struct mpam_msc_ris *ris) +{ + char name[40]; + struct dentry *d; + struct mpam_props *rprops = &ris->props; + + snprintf(name, sizeof(name), "ris.%u", ris->ris_idx); + d = debugfs_create_dir(name, ris->msc->debugfs); + debugfs_create_x64("mpamf_idr", 0400, d, &ris->idr); + debugfs_create_x32("mpamf_cpor_idr", 0400, d, &ris->cpor_idr); + debugfs_create_x32("mpamf_ccap_idr", 0400, d, &ris->ccap_idr); + debugfs_create_x32("features", 0400, d, &rprops->features); + debugfs_create_x16("cpbm_wd", 0400, d, &rprops->cpbm_wd); + debugfs_create_x16("cmax_wd", 0400, d, &rprops->cmax_wd); + debugfs_create_x16("mbw_pbm_bits", 0400, d, &rprops->mbw_pbm_bits); + debugfs_create_x16("intpri_wd", 0400, d, &rprops->intpri_wd); + debugfs_create_x8("bwa_wd", 0400, d, &rprops->bwa_wd); + debugfs_create_x8("mbwu_scale", 0400, d, &rprops->mbwu_scale); + debugfs_create_x16("num_csu_mon", 0400, d, &rprops->num_csu_mon); + debugfs_create_x16("num_mbwu_mon", 0400, d, &rprops->num_mbwu_mon); + debugfs_create_cpumask("affinity", 0400, d, &ris->affinity); + ris->debugfs = d; +} + +static void mpam_debugfs_setup_comp_ris(struct mpam_component *comp, + struct mpam_msc_ris *ris) +{ + char name[40]; + char path[40]; + u8 ris_idx = ris->ris_idx; + int msc_id = ris->msc->id; + struct dentry *d = comp->debugfs; + + snprintf(name, sizeof(name), "msc.%u_ris.%u", + msc_id, ris_idx); + snprintf(path, sizeof(path), "../../msc.%u/ris.%u", + msc_id, ris_idx); + debugfs_create_symlink(name, d, path); +} + +static void mpam_debugfs_setup_comp(struct mpam_class *class, + struct mpam_component *comp) +{ + char name[40]; + struct dentry *d; + struct mpam_msc_ris *ris; + + snprintf(name, sizeof(name), "comp.%u", comp->comp_id); + d = debugfs_create_dir(name, class->debugfs); + comp->debugfs = d; + + list_for_each_entry_rcu(ris, &comp->ris, comp_list) + mpam_debugfs_setup_comp_ris(comp, ris); +} + +static void mpam_debugfs_setup(void) +{ + char name[40]; + struct dentry *d; + struct mpam_msc *msc; + struct mpam_class *class; + struct mpam_msc_ris *ris; + struct mpam_component *comp; + + lockdep_assert_held(&mpam_list_lock); + + list_for_each_entry(msc, &mpam_all_msc, glbl_list) { + d = msc->debugfs; + debugfs_create_u32("fw_id", 0400, d, &msc->pdev->id); + debugfs_create_x32("iface", 0400, d, &msc->iface); + debugfs_create_u16("partid_max", 0400, d, &msc->partid_max); + debugfs_create_u16("intpartid_max", 0400, d, &msc->intpartid_max); + debugfs_create_u8("pmg_max", 0400, d, &msc->pmg_max); + list_for_each_entry(ris, &msc->ris, msc_list) + mpam_debugfs_setup_ris(ris); + } + + list_for_each_entry_rcu(class, &mpam_classes, classes_list) { + snprintf(name, sizeof(name), "class.%u", class->level); + d = debugfs_create_dir(name, mpam_debugfs); + debugfs_create_x32("features", 0400, d, &class->props.features); + debugfs_create_x32("nrdy_usec", 0400, d, &class->nrdy_usec); + debugfs_create_x8("level", 0400, d, &class->level); + debugfs_create_cpumask("affinity", 0400, d, &class->affinity); + class->debugfs = d; + + list_for_each_entry_rcu(comp, &class->components, class_list) + mpam_debugfs_setup_comp(class, comp); + } +} + static void mpam_enable_once(void) { int err; @@ -2473,6 +2574,8 @@ static void mpam_enable_once(void) pr_warn("Failed to register irqs: %d\n", err); break; } + + mpam_debugfs_setup(); } while (0); mutex_unlock(&mpam_list_lock); cpus_read_unlock(); @@ -2757,6 +2860,8 @@ static int __init mpam_msc_driver_init(void) if (acpi_disabled) mpam_dt_create_foundling_msc(); + mpam_debugfs = debugfs_create_dir("mpam", NULL); + return platform_driver_register(&mpam_msc_driver); } /* Must occur after arm64_mpam_register_cpus() from arch_initcall() */ diff --git a/drivers/platform/mpam/mpam_internal.h b/drivers/platform/mpam/mpam_internal.h index ce5af77e3d300..c7087ca35e200 100644 --- a/drivers/platform/mpam/mpam_internal.h +++ b/drivers/platform/mpam/mpam_internal.h @@ -7,6 +7,7 @@ #include <linux/arm_mpam.h> #include <linux/atomic.h> #include <linux/cpumask.h> +#include <linux/debugfs.h> #include <linux/io.h> #include <linux/jump_label.h> #include <linux/mailbox_client.h> @@ -75,6 +76,8 @@ struct mpam_msc spinlock_t mon_sel_lock; void __iomem * mapped_hwpage; size_t mapped_hwpage_sz; + + struct dentry *debugfs; }; /* @@ -158,6 +161,8 @@ struct mpam_class struct ida ida_csu_mon; struct ida ida_mbwu_mon; + + struct dentry *debugfs; }; struct mpam_config { @@ -200,6 +205,8 @@ struct mpam_component /* parent: */ struct mpam_class *class; + + struct dentry *debugfs; }; /* The values for MSMON_CFG_MBWU_FLT.RWBW */ @@ -237,6 +244,8 @@ struct msmon_mbwu_state { struct mpam_msc_ris { u8 ris_idx; u64 idr; + u32 cpor_idr; + u32 ccap_idr; struct mpam_props props; bool in_reset_state; @@ -254,6 +263,8 @@ struct mpam_msc_ris { /* msmon mbwu configuration is preserved over reset */ struct msmon_mbwu_state *mbwu_state; + + struct dentry *debugfs; }; struct mpam_resctrl_dom { -- 2.43.0

hulk inclusion category: feature bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ This reverts commit 43132396266db21803149f07afff112bc56f19a6. The rdtgroup_rename() operation for monitor group migration involves RMID free and reallocation under MPAM, which alters the RDT operational flow. Additionally, on kernfs_rename() failure, resctrl_find_free_rmid() is not properly rolled back. Since upstream MPAM does not yet fully support this functionality, the conditions for monitor group 'mv' operations are not currently met. Return -EPERM directly to disallow the operation. Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- fs/resctrl/internal.h | 1 - fs/resctrl/monitor.c | 2 +- fs/resctrl/rdtgroup.c | 20 +++----------------- 3 files changed, 4 insertions(+), 19 deletions(-) diff --git a/fs/resctrl/internal.h b/fs/resctrl/internal.h index 4c5ddd03ce08a..a5f35e72ebc69 100644 --- a/fs/resctrl/internal.h +++ b/fs/resctrl/internal.h @@ -299,6 +299,5 @@ bool has_busy_rmid(struct rdt_domain *d); void __check_limbo(struct rdt_domain *d, bool force_free); void rdt_staged_configs_clear(void); int resctrl_find_cleanest_closid(void); -struct rmid_entry *resctrl_find_free_rmid(u32 closid); #endif /* _FS_RESCTRL_INTERNAL_H */ diff --git a/fs/resctrl/monitor.c b/fs/resctrl/monitor.c index b3eb1a02ac607..e152c646f35b2 100644 --- a/fs/resctrl/monitor.c +++ b/fs/resctrl/monitor.c @@ -211,7 +211,7 @@ static struct rmid_entry *__resctrl_find_free_rmid(u32 closid) return ERR_PTR(-ENOSPC); } -struct rmid_entry *resctrl_find_free_rmid(u32 closid) +static struct rmid_entry *resctrl_find_free_rmid(u32 closid) { struct rmid_entry *err; int ret; diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c index 601c74e18315b..2fab48af47000 100644 --- a/fs/resctrl/rdtgroup.c +++ b/fs/resctrl/rdtgroup.c @@ -3864,8 +3864,6 @@ static void mongrp_reparent(struct rdtgroup *rdtgrp, list_move_tail(&rdtgrp->mon.crdtgrp_list, &new_prdtgrp->mon.crdtgrp_list); - free_rmid(rdtgrp->closid, rdtgrp->mon.rmid); - rdtgrp->mon.rmid = alloc_rmid(new_prdtgrp->closid); rdtgrp->mon.parent = new_prdtgrp; rdtgrp->closid = new_prdtgrp->closid; @@ -3880,11 +3878,13 @@ static int rdtgroup_rename(struct kernfs_node *kn, { struct kernfs_node *kn_parent; struct rdtgroup *new_prdtgrp; - struct rmid_entry *entry; struct rdtgroup *rdtgrp; cpumask_var_t tmpmask; int ret; + if (IS_ENABLED(CONFIG_ARM64_MPAM)) + return -EPERM; + rdtgrp = kernfs_to_rdtgroup(kn); new_prdtgrp = kernfs_to_rdtgroup(new_parent); if (!rdtgrp || !new_prdtgrp) @@ -3940,20 +3940,6 @@ static int rdtgroup_rename(struct kernfs_node *kn, goto out; } - /* - * Unlike RDT, the rmid and closid in MPAM have a hierarchical - * relationship. Therefore, first check whether there are still - * free rmids available under the target closid. - */ - if (IS_ENABLED(CONFIG_ARM64_MPAM)) { - entry = resctrl_find_free_rmid(new_prdtgrp->closid); - if (IS_ERR(entry)) { - rdt_last_cmd_puts("Destination has been out of RMIDs\n"); - ret = PTR_ERR(entry); - goto out; - } - } - /* * Allocate the cpumask for use in mongrp_reparent() to avoid the * possibility of failing to allocate it after kernfs_rename() has -- 2.43.0

hulk inclusion category: bugfix bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ In __destroy_component_cfg() comp->cfg is freed with kfree() but not set to NULL, leaving a dangling pointer. If the function is subsequently called again (e.g. from the error path of __allocate_component_cfg()), the check "if (comp->cfg)" in __allocate_component_cfg() would see the stale non-NULL pointer and skip re-allocation, leading to a use-after-free when comp->cfg[partid] is later accessed. NULL the pointer after freeing to avoid the dangling reference. Fixes: 21ac9fc8f275 ("arm_mpam: Track bandwidth counter state for overflow and power management") Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 418a341f3821a..73f105072ff43 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -2392,6 +2392,7 @@ static void __destroy_component_cfg(struct mpam_component *comp) struct msmon_mbwu_state *mbwu_state; kfree(comp->cfg); + comp->cfg = NULL; list_for_each_entry(ris, &comp->ris, comp_list) { mutex_lock(&ris->msc->lock); spin_lock_irqsave(&ris->msc->mon_sel_lock, flags); -- 2.43.0

hulk inclusion category: bugfix bugzilla: https://atomgit.com/openeuler/kernel/issues/9840 ------------------ error_dev_id is allocated with alloc_percpu_gfp() in __setup_ppi(). Since it is a plain percpu allocation (not devm-managed like msc), devm_kfree() in the mpam_msc_setup() does not release it. When a PPI sharing conflict is detected and the function returns -EBUSY, error_dev_id is left allocated, leaking percpu memory. Free it before returning the error. Fixes: 79a4fc6c372c ("arm_mpam: Register and enable IRQs") Signed-off-by: Zeng Heng <zengheng4@huawei.com> --- drivers/platform/mpam/mpam_devices.c | 1 + 1 file changed, 1 insertion(+) diff --git a/drivers/platform/mpam/mpam_devices.c b/drivers/platform/mpam/mpam_devices.c index 2f44e1cfbd1a8..f8b6fea70784c 100644 --- a/drivers/platform/mpam/mpam_devices.c +++ b/drivers/platform/mpam/mpam_devices.c @@ -1835,6 +1835,7 @@ static int __setup_ppi(struct mpam_msc *msc) pr_err_once("%s shares PPI with %s!\n", dev_name(&msc->pdev->dev), dev_name(&empty->pdev->dev)); + free_percpu(msc->error_dev_id); return -EBUSY; } *per_cpu_ptr(msc->error_dev_id, cpu) = msc; -- 2.43.0