fs/resctrl: Move RMID initialization to first mount

L3 monitor features are enumerated during resctrl initialization and
rmid_ptrs[] that tracks all RMIDs and depends on the number of supported
RMIDs is allocated during this time.

Telemetry monitor features are enumerated during first resctrl mount and
may support a different number of RMIDs compared to L3 monitor features.

Delay allocation and initialization of rmid_ptrs[] until first mount.
Since the number of RMIDs cannot change on later mounts, keep the same set of
rmid_ptrs[] until resctrl_exit(). This is required because the limbo handler
keeps running after resctrl is unmounted and needs to access rmid_ptrs[]
as it keeps tracking busy RMIDs after unmount.

Rename routines to match what they now do:
dom_data_init() -> setup_rmid_lru_list()
dom_data_exit() -> free_rmid_lru_list()

Signed-off-by: Tony Luck <tony.luck@intel.com>
Signed-off-by: Borislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: Reinette Chatre <reinette.chatre@intel.com>
Link: https://lore.kernel.org/20251217172121.12030-1-tony.luck@intel.com

diff --git a/fs/resctrl/internal.h b/fs/resctrl/internal.h
index 399f625be67d3ae02fa4d8424fdad44c72defe73..1a9b29119f88f8630aa61802033b53f56af98817 100644 (file)
--- a/fs/resctrl/internal.h
+++ b/fs/resctrl/internal.h
@@ -369,6 +369,10 @@ int closids_supported(void);
 
 void closid_free(int closid);
 
+int setup_rmid_lru_list(void);
+
+void free_rmid_lru_list(void);
+
 int alloc_rmid(u32 closid);
 
 void free_rmid(u32 closid, u32 rmid);

diff --git a/fs/resctrl/monitor.c b/fs/resctrl/monitor.c
index bbf8c9037887bc8160e60bced34bb28b14bcf33e..0cd5476a483a0aea731515c0fcd4d6c8d9e79365 100644 (file)
--- a/fs/resctrl/monitor.c
+++ b/fs/resctrl/monitor.c
@@ -903,20 +903,29 @@ void mbm_setup_overflow_handler(struct rdt_l3_mon_domain *dom, unsigned long del
                schedule_delayed_work_on(cpu, &dom->mbm_over, delay);
 }
 
-static int dom_data_init(struct rdt_resource *r)
+int setup_rmid_lru_list(void)
 {
-       u32 idx_limit = resctrl_arch_system_num_rmid_idx();
        struct rmid_entry *entry = NULL;
-       int err = 0, i;
+       u32 idx_limit;
        u32 idx;
+       int i;
 
-       mutex_lock(&rdtgroup_mutex);
+       if (!resctrl_arch_mon_capable())
+               return 0;
 
+       /*
+        * Called on every mount, but the number of RMIDs cannot change
+        * after the first mount, so keep using the same set of rmid_ptrs[]
+        * until resctrl_exit(). Note that the limbo handler continues to
+        * access rmid_ptrs[] after resctrl is unmounted.
+        */
+       if (rmid_ptrs)
+               return 0;
+
+       idx_limit = resctrl_arch_system_num_rmid_idx();
        rmid_ptrs = kcalloc(idx_limit, sizeof(struct rmid_entry), GFP_KERNEL);
-       if (!rmid_ptrs) {
-               err = -ENOMEM;
-               goto out_unlock;
-       }
+       if (!rmid_ptrs)
+               return -ENOMEM;
 
        for (i = 0; i < idx_limit; i++) {
                entry = &rmid_ptrs[i];
@@ -929,30 +938,24 @@ static int dom_data_init(struct rdt_resource *r)
        /*
         * RESCTRL_RESERVED_CLOSID and RESCTRL_RESERVED_RMID are special and
         * are always allocated. These are used for the rdtgroup_default
-        * control group, which will be setup later in resctrl_init().
+        * control group, which was setup earlier in rdtgroup_setup_default().
         */
        idx = resctrl_arch_rmid_idx_encode(RESCTRL_RESERVED_CLOSID,
                                           RESCTRL_RESERVED_RMID);
        entry = __rmid_entry(idx);
        list_del(&entry->list);
 
-out_unlock:
-       mutex_unlock(&rdtgroup_mutex);
-
-       return err;
+       return 0;
 }
 
-static void dom_data_exit(struct rdt_resource *r)
+void free_rmid_lru_list(void)
 {
-       mutex_lock(&rdtgroup_mutex);
-
-       if (!r->mon_capable)
-               goto out_unlock;
+       if (!resctrl_arch_mon_capable())
+               return;
 
+       mutex_lock(&rdtgroup_mutex);
        kfree(rmid_ptrs);
        rmid_ptrs = NULL;
-
-out_unlock:
        mutex_unlock(&rdtgroup_mutex);
 }
 
@@ -1830,7 +1833,8 @@ static void closid_num_dirty_rmid_free(void)
  * resctrl_l3_mon_resource_init() - Initialise global monitoring structures.
  *
  * Allocate and initialise global monitor resources that do not belong to a
- * specific domain. i.e. the rmid_ptrs[] used for the limbo and free lists.
+ * specific domain. i.e. the closid_num_dirty_rmid[] used to find the CLOSID
+ * with the cleanest set of RMIDs.
  * Called once during boot after the struct rdt_resource's have been configured
  * but before the filesystem is mounted.
  * Resctrl's cpuhp callbacks may be called before this point to bring a domain
@@ -1850,12 +1854,6 @@ int resctrl_l3_mon_resource_init(void)
        if (ret)
                return ret;
 
-       ret = dom_data_init(r);
-       if (ret) {
-               closid_num_dirty_rmid_free();
-               return ret;
-       }
-
        if (resctrl_arch_is_evt_configurable(QOS_L3_MBM_TOTAL_EVENT_ID)) {
                mon_event_all[QOS_L3_MBM_TOTAL_EVENT_ID].configurable = true;
                resctrl_file_fflags_init("mbm_total_bytes_config",
@@ -1902,6 +1900,4 @@ void resctrl_l3_mon_resource_exit(void)
                return;
 
        closid_num_dirty_rmid_free();
-
-       dom_data_exit(r);
 }

diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c
index 666cac7661cef5c33fae81930d1b08363c1b4199..ba8d503551cd11e43b1dbebfdbcd1f11d8a91a40 100644 (file)
--- a/fs/resctrl/rdtgroup.c
+++ b/fs/resctrl/rdtgroup.c
@@ -2800,6 +2800,10 @@ static int rdt_get_tree(struct fs_context *fc)
                goto out;
        }
 
+       ret = setup_rmid_lru_list();
+       if (ret)
+               goto out;
+
        ret = rdtgroup_setup_root(ctx);
        if (ret)
                goto out;
@@ -4655,4 +4659,5 @@ void resctrl_exit(void)
         */
 
        resctrl_l3_mon_resource_exit();
+       free_rmid_lru_list();
 }