x86,fs/resctrl: Refactor domain create/remove using struct rdt_domain_hdr

Up until now, all monitoring events were associated with the L3 resource and it
made sense to use the L3 specific "struct rdt_mon_domain *" argument to functions
operating on domains.

Telemetry events will be tied to a new resource with its instances represented
by a new domain structure that, just like struct rdt_mon_domain, starts with
the generic struct rdt_domain_hdr.

Prepare to support domains belonging to different resources by changing the
calling convention of functions operating on domains.  Pass the generic header
and use that to find the domain specific structure where needed.

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/arch/x86/kernel/cpu/resctrl/core.c b/arch/x86/kernel/cpu/resctrl/core.c
index 64ed81cbf8bffe91a5efa22cc2927f410a74ef9e..1fab4c67d273f6488bd4f3154d88a24c868bb046 100644 (file)
--- a/arch/x86/kernel/cpu/resctrl/core.c
+++ b/arch/x86/kernel/cpu/resctrl/core.c
@@ -534,7 +534,7 @@ static void l3_mon_domain_setup(int cpu, int id, struct rdt_resource *r, struct
 
        list_add_tail_rcu(&d->hdr.list, add_pos);
 
-       err = resctrl_online_mon_domain(r, d);
+       err = resctrl_online_mon_domain(r, &d->hdr);
        if (err) {
                list_del_rcu(&d->hdr.list);
                synchronize_rcu();
@@ -661,7 +661,7 @@ static void domain_remove_cpu_mon(int cpu, struct rdt_resource *r)
 
                d = container_of(hdr, struct rdt_mon_domain, hdr);
                hw_dom = resctrl_to_arch_mon_dom(d);
-               resctrl_offline_mon_domain(r, d);
+               resctrl_offline_mon_domain(r, hdr);
                list_del_rcu(&hdr->list);
                synchronize_rcu();
                mon_domain_free(hw_dom);

diff --git a/fs/resctrl/ctrlmondata.c b/fs/resctrl/ctrlmondata.c
index 905c310de57327a63b5f0afecd138a05a53533be..3154cdc98a3180a237e9f95516855049dd15b2e6 100644 (file)
--- a/fs/resctrl/ctrlmondata.c
+++ b/fs/resctrl/ctrlmondata.c
@@ -551,14 +551,21 @@ struct rdt_domain_hdr *resctrl_find_domain(struct list_head *h, int id,
 }
 
 void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
-                   struct rdt_mon_domain *d, struct rdtgroup *rdtgrp,
+                   struct rdt_domain_hdr *hdr, struct rdtgroup *rdtgrp,
                    cpumask_t *cpumask, int evtid, int first)
 {
+       struct rdt_mon_domain *d = NULL;
        int cpu;
 
        /* When picking a CPU from cpu_mask, ensure it can't race with cpuhp */
        lockdep_assert_cpus_held();
 
+       if (hdr) {
+               if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+                       return;
+               d = container_of(hdr, struct rdt_mon_domain, hdr);
+       }
+
        /*
         * Setup the parameters to pass to mon_event_count() to read the data.
         */
@@ -653,12 +660,11 @@ int rdtgroup_mondata_show(struct seq_file *m, void *arg)
                 * the resource to find the domain with "domid".
                 */
                hdr = resctrl_find_domain(&r->mon_domains, domid, NULL);
-               if (!hdr || !domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, resid)) {
+               if (!hdr) {
                        ret = -ENOENT;
                        goto out;
                }
-               d = container_of(hdr, struct rdt_mon_domain, hdr);
-               mon_event_read(&rr, r, d, rdtgrp, &d->hdr.cpu_mask, evtid, false);
+               mon_event_read(&rr, r, hdr, rdtgrp, &hdr->cpu_mask, evtid, false);
        }
 
 checkresult:

diff --git a/fs/resctrl/internal.h b/fs/resctrl/internal.h
index bff4a54ae3330c7343dfccbe0ac6c13bec8ce634..5e52269b391e7be0cf127eedf32def74d1be1454 100644 (file)
--- a/fs/resctrl/internal.h
+++ b/fs/resctrl/internal.h
@@ -362,7 +362,7 @@ void mon_event_count(void *info);
 int rdtgroup_mondata_show(struct seq_file *m, void *arg);
 
 void mon_event_read(struct rmid_read *rr, struct rdt_resource *r,
-                   struct rdt_mon_domain *d, struct rdtgroup *rdtgrp,
+                   struct rdt_domain_hdr *hdr, struct rdtgroup *rdtgrp,
                    cpumask_t *cpumask, int evtid, int first);
 
 int resctrl_mon_resource_init(void);

diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c
index 8e39dfda56bc6e274f48e86b8404fd24ea47771d..89ffe54fb0fc3cfb16d00d497617a271c76a4ef9 100644 (file)
--- a/fs/resctrl/rdtgroup.c
+++ b/fs/resctrl/rdtgroup.c
@@ -3229,17 +3229,22 @@ static void mon_rmdir_one_subdir(struct kernfs_node *pkn, char *name, char *subn
  * when last domain being summed is removed.
  */
 static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
-                                          struct rdt_mon_domain *d)
+                                          struct rdt_domain_hdr *hdr)
 {
        struct rdtgroup *prgrp, *crgrp;
+       struct rdt_mon_domain *d;
        char subname[32];
        bool snc_mode;
        char name[32];
 
+       if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+               return;
+
+       d = container_of(hdr, struct rdt_mon_domain, hdr);
        snc_mode = r->mon_scope == RESCTRL_L3_NODE;
-       sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : d->hdr.id);
+       sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : hdr->id);
        if (snc_mode)
-               sprintf(subname, "mon_sub_%s_%02d", r->name, d->hdr.id);
+               sprintf(subname, "mon_sub_%s_%02d", r->name, hdr->id);
 
        list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
                mon_rmdir_one_subdir(prgrp->mon.mon_data_kn, name, subname);
@@ -3249,15 +3254,20 @@ static void rmdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
        }
 }
 
-static int mon_add_all_files(struct kernfs_node *kn, struct rdt_mon_domain *d,
+static int mon_add_all_files(struct kernfs_node *kn, struct rdt_domain_hdr *hdr,
                             struct rdt_resource *r, struct rdtgroup *prgrp,
                             bool do_sum)
 {
        struct rmid_read rr = {0};
+       struct rdt_mon_domain *d;
        struct mon_data *priv;
        struct mon_evt *mevt;
        int ret, domid;
 
+       if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+               return -EINVAL;
+
+       d = container_of(hdr, struct rdt_mon_domain, hdr);
        for_each_mon_event(mevt) {
                if (mevt->rid != r->rid || !mevt->enabled)
                        continue;
@@ -3271,23 +3281,28 @@ static int mon_add_all_files(struct kernfs_node *kn, struct rdt_mon_domain *d,
                        return ret;
 
                if (!do_sum && resctrl_is_mbm_event(mevt->evtid))
-                       mon_event_read(&rr, r, d, prgrp, &d->hdr.cpu_mask, mevt->evtid, true);
+                       mon_event_read(&rr, r, hdr, prgrp, &hdr->cpu_mask, mevt->evtid, true);
        }
 
        return 0;
 }
 
 static int mkdir_mondata_subdir(struct kernfs_node *parent_kn,
-                               struct rdt_mon_domain *d,
+                               struct rdt_domain_hdr *hdr,
                                struct rdt_resource *r, struct rdtgroup *prgrp)
 {
        struct kernfs_node *kn, *ckn;
+       struct rdt_mon_domain *d;
        char name[32];
        bool snc_mode;
        int ret = 0;
 
        lockdep_assert_held(&rdtgroup_mutex);
 
+       if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+               return -EINVAL;
+
+       d = container_of(hdr, struct rdt_mon_domain, hdr);
        snc_mode = r->mon_scope == RESCTRL_L3_NODE;
        sprintf(name, "mon_%s_%02d", r->name, snc_mode ? d->ci_id : d->hdr.id);
        kn = kernfs_find_and_get(parent_kn, name);
@@ -3305,13 +3320,13 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn,
                ret = rdtgroup_kn_set_ugid(kn);
                if (ret)
                        goto out_destroy;
-               ret = mon_add_all_files(kn, d, r, prgrp, snc_mode);
+               ret = mon_add_all_files(kn, hdr, r, prgrp, snc_mode);
                if (ret)
                        goto out_destroy;
        }
 
        if (snc_mode) {
-               sprintf(name, "mon_sub_%s_%02d", r->name, d->hdr.id);
+               sprintf(name, "mon_sub_%s_%02d", r->name, hdr->id);
                ckn = kernfs_create_dir(kn, name, parent_kn->mode, prgrp);
                if (IS_ERR(ckn)) {
                        ret = -EINVAL;
@@ -3322,7 +3337,7 @@ static int mkdir_mondata_subdir(struct kernfs_node *parent_kn,
                if (ret)
                        goto out_destroy;
 
-               ret = mon_add_all_files(ckn, d, r, prgrp, false);
+               ret = mon_add_all_files(ckn, hdr, r, prgrp, false);
                if (ret)
                        goto out_destroy;
        }
@@ -3340,7 +3355,7 @@ out_destroy:
  * and "monitor" groups with given domain id.
  */
 static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
-                                          struct rdt_mon_domain *d)
+                                          struct rdt_domain_hdr *hdr)
 {
        struct kernfs_node *parent_kn;
        struct rdtgroup *prgrp, *crgrp;
@@ -3348,12 +3363,12 @@ static void mkdir_mondata_subdir_allrdtgrp(struct rdt_resource *r,
 
        list_for_each_entry(prgrp, &rdt_all_groups, rdtgroup_list) {
                parent_kn = prgrp->mon.mon_data_kn;
-               mkdir_mondata_subdir(parent_kn, d, r, prgrp);
+               mkdir_mondata_subdir(parent_kn, hdr, r, prgrp);
 
                head = &prgrp->mon.crdtgrp_list;
                list_for_each_entry(crgrp, head, mon.crdtgrp_list) {
                        parent_kn = crgrp->mon.mon_data_kn;
-                       mkdir_mondata_subdir(parent_kn, d, r, crgrp);
+                       mkdir_mondata_subdir(parent_kn, hdr, r, crgrp);
                }
        }
 }
@@ -3362,14 +3377,14 @@ static int mkdir_mondata_subdir_alldom(struct kernfs_node *parent_kn,
                                       struct rdt_resource *r,
                                       struct rdtgroup *prgrp)
 {
-       struct rdt_mon_domain *dom;
+       struct rdt_domain_hdr *hdr;
        int ret;
 
        /* Walking r->domains, ensure it can't race with cpuhp */
        lockdep_assert_cpus_held();
 
-       list_for_each_entry(dom, &r->mon_domains, hdr.list) {
-               ret = mkdir_mondata_subdir(parent_kn, dom, r, prgrp);
+       list_for_each_entry(hdr, &r->mon_domains, list) {
+               ret = mkdir_mondata_subdir(parent_kn, hdr, r, prgrp);
                if (ret)
                        return ret;
        }
@@ -4253,16 +4268,23 @@ void resctrl_offline_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain
        mutex_unlock(&rdtgroup_mutex);
 }
 
-void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d)
+void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr)
 {
+       struct rdt_mon_domain *d;
+
        mutex_lock(&rdtgroup_mutex);
 
+       if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+               goto out_unlock;
+
+       d = container_of(hdr, struct rdt_mon_domain, hdr);
+
        /*
         * If resctrl is mounted, remove all the
         * per domain monitor data directories.
         */
        if (resctrl_mounted && resctrl_arch_mon_capable())
-               rmdir_mondata_subdir_allrdtgrp(r, d);
+               rmdir_mondata_subdir_allrdtgrp(r, hdr);
 
        if (resctrl_is_mbm_enabled())
                cancel_delayed_work(&d->mbm_over);
@@ -4280,7 +4302,7 @@ void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d
        }
 
        domain_destroy_mon_state(d);
-
+out_unlock:
        mutex_unlock(&rdtgroup_mutex);
 }
 
@@ -4353,12 +4375,17 @@ int resctrl_online_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d
        return err;
 }
 
-int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d)
+int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr)
 {
-       int err;
+       struct rdt_mon_domain *d;
+       int err = -EINVAL;
 
        mutex_lock(&rdtgroup_mutex);
 
+       if (!domain_header_is_valid(hdr, RESCTRL_MON_DOMAIN, RDT_RESOURCE_L3))
+               goto out_unlock;
+
+       d = container_of(hdr, struct rdt_mon_domain, hdr);
        err = domain_setup_mon_state(r, d);
        if (err)
                goto out_unlock;
@@ -4379,7 +4406,7 @@ int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d)
         * If resctrl is mounted, add per domain monitor data directories.
         */
        if (resctrl_mounted && resctrl_arch_mon_capable())
-               mkdir_mondata_subdir_allrdtgrp(r, d);
+               mkdir_mondata_subdir_allrdtgrp(r, hdr);
 
 out_unlock:
        mutex_unlock(&rdtgroup_mutex);

diff --git a/include/linux/resctrl.h b/include/linux/resctrl.h
index e7c218f8d4f77d7e06287c28972a784abb5ee7fd..5db37c7e89c5cafa9ccbec37cf31497092136ec4 100644 (file)
--- a/include/linux/resctrl.h
+++ b/include/linux/resctrl.h
@@ -507,9 +507,9 @@ int resctrl_arch_update_one(struct rdt_resource *r, struct rdt_ctrl_domain *d,
 u32 resctrl_arch_get_config(struct rdt_resource *r, struct rdt_ctrl_domain *d,
                            u32 closid, enum resctrl_conf_type type);
 int resctrl_online_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d);
-int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d);
+int resctrl_online_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr);
 void resctrl_offline_ctrl_domain(struct rdt_resource *r, struct rdt_ctrl_domain *d);
-void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_mon_domain *d);
+void resctrl_offline_mon_domain(struct rdt_resource *r, struct rdt_domain_hdr *hdr);
 void resctrl_online_cpu(unsigned int cpu);
 void resctrl_offline_cpu(unsigned int cpu);