[RFC PATCH 11/31] x86/resctrl: Rename struct resctrl_membw to struct resctrl_ctrl_scalar

[Chen Yu <yu.c.chen@intel.com>]

Rename struct resctrl_membw to struct resctrl_ctrl_scalar to better
reflect its role as the property container for scalar-type controls.
Also rename the union member from 'membw' to 'scalar' for consistency.

This follows the design discussed in the generic schema RFC where
controls are classified by type (scalar vs bitmap) rather than by
the specific resource they manage (memory bandwidth).

Signed-off-by: Chen Yu <yu.c.chen@intel.com>
---
 arch/x86/kernel/cpu/resctrl/core.c | 30 +++++++++++++++---------------
 drivers/resctrl/mpam_resctrl.c     |  6 +++---
 fs/resctrl/ctrlmondata.c           |  6 +++---
 fs/resctrl/monitor.c               |  8 ++++----
 fs/resctrl/rdtgroup.c              | 20 ++++++++++----------
 include/linux/resctrl.h            | 16 ++++++++--------
 6 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/arch/x86/kernel/cpu/resctrl/core.c b/arch/x86/kernel/cpu/resctrl/core.c
index 1357f3e5ebd3..9566ee43f206 100644
--- a/arch/x86/kernel/cpu/resctrl/core.c
+++ b/arch/x86/kernel/cpu/resctrl/core.c
@@ -204,9 +204,9 @@ static __init bool __get_mem_config_intel(struct rdt_resource *r)
 	hw_ctrl->r_ctrl.name = RESCTRL_CTRL_NAME_DEF;
 	INIT_LIST_HEAD(&hw_ctrl->r_ctrl.domains);
 
-	hw_ctrl->r_ctrl.membw.max_bw = MAX_MBA_BW;
-	hw_ctrl->r_ctrl.membw.min_bw = MAX_MBA_BW - max_delay;
-	hw_ctrl->r_ctrl.membw.bw_gran = MAX_MBA_BW - max_delay;
+	hw_ctrl->r_ctrl.scalar.max_bw = MAX_MBA_BW;
+	hw_ctrl->r_ctrl.scalar.min_bw = MAX_MBA_BW - max_delay;
+	hw_ctrl->r_ctrl.scalar.bw_gran = MAX_MBA_BW - max_delay;
 
 	r->bw_delay_linear = true;
 	if (boot_cpu_has(X86_FEATURE_PER_THREAD_MBA))
@@ -214,10 +214,10 @@ static __init bool __get_mem_config_intel(struct rdt_resource *r)
 	else
 		r->bw_throttle_mode = THREAD_THROTTLE_MAX;
 
-	hw_ctrl->r_ctrl.membw.resolution = 100;
-	hw_ctrl->r_ctrl.membw.tolerance = 5;
-	hw_ctrl->r_ctrl.membw.scale = 1;
-	hw_ctrl->r_ctrl.membw.unit = RESCTRL_CTRL_UNIT_ALL;
+	hw_ctrl->r_ctrl.scalar.resolution = 100;
+	hw_ctrl->r_ctrl.scalar.tolerance = 5;
+	hw_ctrl->r_ctrl.scalar.scale = 1;
+	hw_ctrl->r_ctrl.scalar.unit = RESCTRL_CTRL_UNIT_ALL;
 
 	hw_ctrl->msr_base = MSR_IA32_MBA_THRTL_BASE;
 	hw_ctrl->msr_update = mba_wrmsr_intel;
@@ -246,7 +246,7 @@ static __init bool __rdt_get_mem_config_amd(struct rdt_resource *r)
 	if (!hw_ctrl)
 		return false;
 
-	if (BITS_PER_TYPE(hw_ctrl->r_ctrl.membw.max_bw) <= eax) {
+	if (BITS_PER_TYPE(hw_ctrl->r_ctrl.scalar.max_bw) <= eax) {
 		pr_warn("Unable to support hardware's maximum bandwidth\n");
 		kfree(hw_ctrl);
 		return false;
@@ -257,7 +257,7 @@ static __init bool __rdt_get_mem_config_amd(struct rdt_resource *r)
 	hw_ctrl->r_ctrl.name = RESCTRL_CTRL_NAME_DEF;
 	INIT_LIST_HEAD(&hw_ctrl->r_ctrl.domains);
 
-	hw_ctrl->r_ctrl.membw.max_bw = BIT(eax);
+	hw_ctrl->r_ctrl.scalar.max_bw = BIT(eax);
 
 	/* AMD does not use delay */
 	r->bw_delay_linear = false;
@@ -267,12 +267,12 @@ static __init bool __rdt_get_mem_config_amd(struct rdt_resource *r)
 	 * the allocation like Intel does.
 	 */
 	r->bw_throttle_mode = THREAD_THROTTLE_UNDEFINED;
-	hw_ctrl->r_ctrl.membw.min_bw = 0;
-	hw_ctrl->r_ctrl.membw.bw_gran = 1;
-	hw_ctrl->r_ctrl.membw.resolution = 8;
-	hw_ctrl->r_ctrl.membw.tolerance = 0;
-	hw_ctrl->r_ctrl.membw.scale = 1;
-	hw_ctrl->r_ctrl.membw.unit = RESCTRL_CTRL_UNIT_GBPS;
+	hw_ctrl->r_ctrl.scalar.min_bw = 0;
+	hw_ctrl->r_ctrl.scalar.bw_gran = 1;
+	hw_ctrl->r_ctrl.scalar.resolution = 8;
+	hw_ctrl->r_ctrl.scalar.tolerance = 0;
+	hw_ctrl->r_ctrl.scalar.scale = 1;
+	hw_ctrl->r_ctrl.scalar.unit = RESCTRL_CTRL_UNIT_GBPS;
 
 	if (r->rid == RDT_RESOURCE_MBA) {
 		hw_ctrl->msr_base = MSR_IA32_MBA_BW_BASE;
diff --git a/drivers/resctrl/mpam_resctrl.c b/drivers/resctrl/mpam_resctrl.c
index a9bfab03f0d5..b97c9b80d0ed 100644
--- a/drivers/resctrl/mpam_resctrl.c
+++ b/drivers/resctrl/mpam_resctrl.c
@@ -1043,9 +1043,9 @@ static int mpam_resctrl_control_init(struct mpam_resctrl_res *res)
 
 		r->bw_delay_linear = true;
 		r->bw_throttle_mode = THREAD_THROTTLE_UNDEFINED;
-		mpam_ctrl->r_ctrl.membw.min_bw = get_mba_min(cprops);
-		mpam_ctrl->r_ctrl.membw.max_bw = MAX_MBA_BW;
-		mpam_ctrl->r_ctrl.membw.bw_gran = get_mba_granularity(cprops);
+		mpam_ctrl->r_ctrl.scalar.min_bw = get_mba_min(cprops);
+		mpam_ctrl->r_ctrl.scalar.max_bw = MAX_MBA_BW;
+		mpam_ctrl->r_ctrl.scalar.bw_gran = get_mba_granularity(cprops);
 		list_add(&mpam_ctrl->r_ctrl.entry, &r->controls);
 
 		r->name = "MB";
diff --git a/fs/resctrl/ctrlmondata.c b/fs/resctrl/ctrlmondata.c
index d95ab8ad36e2..fd1a9203d6e5 100644
--- a/fs/resctrl/ctrlmondata.c
+++ b/fs/resctrl/ctrlmondata.c
@@ -86,13 +86,13 @@ static bool bw_validate(char *buf, u32 *data, struct rdt_resource *r,
 		return true;
 	}
 
-	if (bw < ctrl->membw.min_bw || bw > ctrl->membw.max_bw) {
+	if (bw < ctrl->scalar.min_bw || bw > ctrl->scalar.max_bw) {
 		rdt_last_cmd_printf("MB value %u out of range [%d,%d]\n",
-				    bw, ctrl->membw.min_bw, ctrl->membw.max_bw);
+				    bw, ctrl->scalar.min_bw, ctrl->scalar.max_bw);
 		return false;
 	}
 
-	*data = roundup(bw, (unsigned long)ctrl->membw.bw_gran);
+	*data = roundup(bw, (unsigned long)ctrl->scalar.bw_gran);
 	return true;
 }
 
diff --git a/fs/resctrl/monitor.c b/fs/resctrl/monitor.c
index 89baed73bcd6..63d48be41025 100644
--- a/fs/resctrl/monitor.c
+++ b/fs/resctrl/monitor.c
@@ -758,11 +758,11 @@ static void update_mba_bw(struct rdtgroup *rgrp, struct rdt_l3_mon_domain *dom_m
 	 * 40% would go past the limit by multiplying current bandwidth by
 	 * "(30 + 10) / 30".
 	 */
-	if (cur_msr_val > ctrl->membw.min_bw && user_bw < cur_bw) {
-		new_msr_val = cur_msr_val - ctrl->membw.bw_gran;
+	if (cur_msr_val > ctrl->scalar.min_bw && user_bw < cur_bw) {
+		new_msr_val = cur_msr_val - ctrl->scalar.bw_gran;
 	} else if (cur_msr_val < MAX_MBA_BW &&
-		   (user_bw > (cur_bw * (cur_msr_val + ctrl->membw.min_bw) / cur_msr_val))) {
-		new_msr_val = cur_msr_val + ctrl->membw.bw_gran;
+		   (user_bw > (cur_bw * (cur_msr_val + ctrl->scalar.min_bw) / cur_msr_val))) {
+		new_msr_val = cur_msr_val + ctrl->scalar.bw_gran;
 	} else {
 		return;
 	}
diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c
index 5ccd09b16e0f..4392242e63da 100644
--- a/fs/resctrl/rdtgroup.c
+++ b/fs/resctrl/rdtgroup.c
@@ -1179,7 +1179,7 @@ static int rdt_min_bw_show(struct kernfs_open_file *of,
 	if (!ctrl || ctrl->type != RESCTRL_CTRL_SCALAR)
 		return 0;
 
-	seq_printf(seq, "%u\n", ctrl->membw.min_bw);
+	seq_printf(seq, "%u\n", ctrl->scalar.min_bw);
 	return 0;
 }
 
@@ -1222,7 +1222,7 @@ static int rdt_bw_gran_show(struct kernfs_open_file *of,
 	if (!ctrl || ctrl->type != RESCTRL_CTRL_SCALAR)
 		return 0;
 
-	seq_printf(seq, "%u\n", ctrl->membw.bw_gran);
+	seq_printf(seq, "%u\n", ctrl->scalar.bw_gran);
 	return 0;
 }
 
@@ -1622,7 +1622,7 @@ bool is_mba_sc(struct rdt_resource *r, struct resctrl_ctrl *ctrl)
 			return false;
 	}
 
-	return ctrl->membw.mba_sc;
+	return ctrl->scalar.mba_sc;
 }
 
 /*
@@ -2256,7 +2256,7 @@ static int resctrl_ctrl_min_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	seq_printf(seq, "%u\n", ctrl->membw.min_bw);
+	seq_printf(seq, "%u\n", ctrl->scalar.min_bw);
 
 	return 0;
 }
@@ -2266,7 +2266,7 @@ static int resctrl_ctrl_max_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	seq_printf(seq, "%u\n", ctrl->membw.max_bw);
+	seq_printf(seq, "%u\n", ctrl->scalar.max_bw);
 
 	return 0;
 }
@@ -2276,7 +2276,7 @@ static int resctrl_ctrl_resolution_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	seq_printf(seq, "%u\n", ctrl->membw.resolution);
+	seq_printf(seq, "%u\n", ctrl->scalar.resolution);
 
 	return 0;
 }
@@ -2286,7 +2286,7 @@ static int resctrl_ctrl_tolerance_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	seq_printf(seq, "%d\n", ctrl->membw.tolerance);
+	seq_printf(seq, "%d\n", ctrl->scalar.tolerance);
 
 	return 0;
 }
@@ -2296,7 +2296,7 @@ static int resctrl_ctrl_scale_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	seq_printf(seq, "%u\n", ctrl->membw.scale);
+	seq_printf(seq, "%u\n", ctrl->scalar.scale);
 
 	return 0;
 }
@@ -2306,7 +2306,7 @@ static int resctrl_ctrl_unit_show(struct kernfs_open_file *of,
 {
 	struct resctrl_ctrl *ctrl = rdt_kn_parent_priv(of->kn);
 
-	switch (ctrl->membw.unit) {
+	switch (ctrl->scalar.unit) {
 	case RESCTRL_CTRL_UNIT_ALL:
 		seq_puts(seq, "all\n");
 		return 0;
@@ -2901,7 +2901,7 @@ static int set_mba_sc(bool mba_sc)
 	if (!supports_mba_mbps(ctrl) || mba_sc == is_mba_sc(r, ctrl))
 		return -EINVAL;
 
-	ctrl->membw.mba_sc = mba_sc;
+	ctrl->scalar.mba_sc = mba_sc;
 
 	rdtgroup_default.mba_mbps_event = mba_mbps_default_event;
 
diff --git a/include/linux/resctrl.h b/include/linux/resctrl.h
index 72fb7256270e..f54a889c6d99 100644
--- a/include/linux/resctrl.h
+++ b/include/linux/resctrl.h
@@ -258,10 +258,10 @@ enum resctrl_ctrl_unit {
 };
 
 /**
- * struct resctrl_membw - Memory bandwidth allocation related data
- * @min_bw:		Minimum memory bandwidth percentage user can request
- * @max_bw:		Maximum memory bandwidth value, used as the reset value
- * @bw_gran:		Granularity at which the memory bandwidth is allocated
+ * struct resctrl_ctrl_scalar - Scalar control type properties
+ * @min_bw:		Minimum scalar control value user can request
+ * @max_bw:		Maximum scalar control value, used as the reset value
+ * @bw_gran:		Granularity at which the scalar control is allocated
  * @resolution:		If the control is proportional (for example, a
  *			percentage) this is the number of divisions that
  *			resource can be divided into. Otherwise, since this
@@ -284,7 +284,7 @@ enum resctrl_ctrl_unit {
  * the amount of resource allocated by this control is:
  * 		C * scale / resolution * unit
  */
-struct resctrl_membw {
+struct resctrl_ctrl_scalar {
 	u32				min_bw;
 	u32				max_bw;
 	u32				bw_gran;
@@ -370,7 +370,7 @@ enum resctrl_ctrl_name {
  *		For example, with resource name "MB" and control name "MAX" the
  *		schema entry will be "MB_MAX".
  * @cache:	Cache allocation control properties.
- * @membw:	Bandwidth control properties.
+ * @scalar:	Scalar control properties.
  */
 struct resctrl_ctrl {
 	struct list_head	entry;
@@ -380,7 +380,7 @@ struct resctrl_ctrl {
 	enum resctrl_ctrl_name	name;
 	union {
 		struct resctrl_cache	cache;
-		struct resctrl_membw	membw;
+		struct resctrl_ctrl_scalar	scalar;
 	};
 };
 
@@ -483,7 +483,7 @@ static inline u32 resctrl_get_default_ctrlval(struct resctrl_ctrl *ctrl)
 	case RESCTRL_CTRL_BITMAP:
 		return BIT_MASK(ctrl->cache.cbm_len) - 1;
 	case RESCTRL_CTRL_SCALAR:
-		return ctrl->membw.max_bw;
+		return ctrl->scalar.max_bw;
 	}
 
 	return WARN_ON_ONCE(1);
-- 
2.43.0