[PATCH v10 11/12] x86/resctrl: Add the ERDT CMT scale

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

The limbo handler polls the LLC occupancy of limbo RMIDs and makes an RMID
available for reuse once its occupancy drops below
resctrl_rmid_realloc_threshold. User space sets this threshold in bytes by
writing to the "max_threshold_occupancy" file. The occupancy counter only has
the granularity of its scale, the number of bytes one counter unit represents,
so resctrl_arch_round_mon_val() rounds the written byte value down to a multiple
of that scale before it is stored in resctrl_rmid_realloc_threshold.

resctrl_arch_round_mon_val() uses the CPUID-provided scale. LLC occupancy read
via ERDT is instead scaled by the CMRC up_scale of each ERDT domain.
resctrl_rmid_realloc_threshold is a single global value, so one scale has to be
derived from the per-domain values.

Add erdt_cmt_scale to hold the largest CMRC up_scale among all ERDT domains. Use
the largest because rounding is a floor: a larger scale yields a slightly lower
threshold, i.e. an RMID has to drop to a slightly lower occupancy before it is
reused.

Suggested-by: Reinette Chatre <reinette.chatre@intel.com>
Signed-off-by: Chen Yu <yu.c.chen@intel.com>
Tested-by: Hongyu Ning <hongyu.ning@linux.intel.com>
---
Changes since v9:
- New patch, replacing v9 "x86/resctrl: Add a global ERDT monitor scale".
  Place it after the CMRC parsing and erdt_cpu_has() patches so that the
  scale is added in one coherent change instead of as a placeholder that
  stays 0 until the last patch. (Reinette Chatre)
- Rename erdt_scale/erdt_get_scale() to erdt_cmt_scale and
  erdt_get_cmt_scale() so that the names say this is the CMT scale and
  not a global monitor scale. Move the erdt_cpu_has() check from the
  last patch into erdt_get_cmt_scale(). (Reinette Chatre)
- Compute erdt_cmt_scale from the CMRC up_scale of each RMDD that is
  accepted (moved here from the last patch), and reset it in
  erdt_exit(). (Reinette Chatre)
- Squash in the fix for the stale "h/w works in units of
  boot_cpu_data.x86_cache_occ_scale" comment from the last patch.
  (Reinette Chatre)
- Changelog: say "limbo RMIDs" instead of "stale RMIDs", distinguish the
  "max_threshold_occupancy" file from the resctrl_rmid_realloc_threshold
  variable, and state that the threshold is in bytes. (Reinette Chatre)

 arch/x86/kernel/cpu/resctrl/erdt.c     | 23 +++++++++++++++++++++++
 arch/x86/kernel/cpu/resctrl/internal.h |  1 +
 arch/x86/kernel/cpu/resctrl/monitor.c  |  7 +++++--
 3 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/arch/x86/kernel/cpu/resctrl/erdt.c b/arch/x86/kernel/cpu/resctrl/erdt.c
index 107d599bf586..3d34e1050794 100644
--- a/arch/x86/kernel/cpu/resctrl/erdt.c
+++ b/arch/x86/kernel/cpu/resctrl/erdt.c
@@ -36,11 +36,30 @@ static u16 first_rmdd_domain_id;
 /* Largest RMID that is valid in every ERDT domain. */
 static unsigned int erdt_max_rmid;
 
+/*
+ * Used only to round the global resctrl_rmid_realloc_threshold for the limbo
+ * handler. resctrl_rmid_realloc_threshold is exposed to user space as a single
+ * global value, so ERDT uses one scale derived from the per-domain
+ * cmrc->up_scale values. Keep this single threshold conservative across
+ * domains because the rounding is a floor: a larger scale yields a slightly
+ * lower threshold, i.e. an RMID has to drop to a slightly lower occupancy
+ * before it is reused.
+ */
+static unsigned int erdt_cmt_scale;
+
 bool erdt_support(int flag)
 {
 	return false;
 }
 
+unsigned int erdt_get_cmt_scale(void)
+{
+	if (!erdt_cpu_has(X86_FEATURE_CQM_OCCUP_LLC))
+		return 0;
+
+	return erdt_cmt_scale;
+}
+
 static void __iomem *erdt_ioremap(resource_size_t base, u32 num_pages, const char *desc)
 {
 	void __iomem *addr;
@@ -256,6 +275,9 @@ static __init bool parse_rmdd_table(struct acpi_subtbl_hdr_16 *rmdd_hdr)
 	else
 		erdt_max_rmid = min(erdt_max_rmid, rmdd->max_rmid);
 
+	if (domain_info->cmrc)
+		erdt_cmt_scale = max(erdt_cmt_scale, domain_info->cmrc->up_scale);
+
 	list_add(&domain_info->entry, &domain_info_list);
 
 	return true;
@@ -400,6 +422,7 @@ void erdt_exit(void)
 	valid_subtbl_mask = 0;
 	first_rmdd_domain_id = 0;
 	erdt_max_rmid = 0;
+	erdt_cmt_scale = 0;
 }
 
 static __init int enumerate_erdt_table(struct acpi_table_header *table_hdr)
diff --git a/arch/x86/kernel/cpu/resctrl/internal.h b/arch/x86/kernel/cpu/resctrl/internal.h
index fe8a4c1dd46b..87494316becb 100644
--- a/arch/x86/kernel/cpu/resctrl/internal.h
+++ b/arch/x86/kernel/cpu/resctrl/internal.h
@@ -293,6 +293,7 @@ static inline bool intel_handle_aet_option(bool force_off, char *tok) { return f
 
 bool erdt_cpu_has(int flag);
 bool erdt_support(int flag);
+unsigned int erdt_get_cmt_scale(void);
 void erdt_init(void);
 void erdt_exit(void);
 bool erdt_try_bind_domain(int cpu);
diff --git a/arch/x86/kernel/cpu/resctrl/monitor.c b/arch/x86/kernel/cpu/resctrl/monitor.c
index 510e947d98e6..05f6d24d0fc6 100644
--- a/arch/x86/kernel/cpu/resctrl/monitor.c
+++ b/arch/x86/kernel/cpu/resctrl/monitor.c
@@ -426,9 +426,12 @@ __init int snc_get_config(void)
 
 unsigned int resctrl_arch_round_mon_val(unsigned int val)
 {
-	unsigned int scale = boot_cpu_data.x86_cache_occ_scale;
+	unsigned int scale = erdt_get_cmt_scale();
 
-	/* h/w works in units of "boot_cpu_data.x86_cache_occ_scale" */
+	if (!scale)
+		scale = boot_cpu_data.x86_cache_occ_scale;
+
+	/* h/w works in units of the occupancy scale */
 	val /= scale;
 	return val * scale;
 }
-- 
2.25.1