fs/resctrl: Update bit_usage to reflect io_alloc

The "shareable_bits" and "bit_usage" resctrl files associated with cache
resources give insight into how instances of a cache is used.

Update the annotated capacity bitmasks displayed by "bit_usage" to include the
cache portions allocated for I/O via the "io_alloc" feature. "shareable_bits"
is a global bitmask of shareable cache with I/O and can thus not present the
per-domain I/O allocations possible with the "io_alloc" feature. Revise the
"shareable_bits" documentation to direct users to "bit_usage" for accurate
cache usage information.

Signed-off-by: Babu Moger <babu.moger@amd.com>
Signed-off-by: Borislav Petkov (AMD) <bp@alien8.de>
Reviewed-by: Reinette Chatre <reinette.chatre@intel.com>
Link: https://patch.msgid.link/e02a0d424129fd7f3e45822a559b1c614ae4652a.1762995456.git.babu.moger@amd.com

diff --git a/Documentation/filesystems/resctrl.rst b/Documentation/filesystems/resctrl.rst
index bbc4b6cbb71dce4036095409448476bb5005a947..8c8ce678148a524b1a30e4c5f51b5df342a5d149 100644 (file)
--- a/Documentation/filesystems/resctrl.rst
+++ b/Documentation/filesystems/resctrl.rst
@@ -96,12 +96,19 @@ related to allocation:
                must be set when writing a mask.
 
 "shareable_bits":
-               Bitmask of shareable resource with other executing
-               entities (e.g. I/O). User can use this when
-               setting up exclusive cache partitions. Note that
-               some platforms support devices that have their
-               own settings for cache use which can over-ride
-               these bits.
+               Bitmask of shareable resource with other executing entities
+               (e.g. I/O). Applies to all instances of this resource. User
+               can use this when setting up exclusive cache partitions.
+               Note that some platforms support devices that have their
+               own settings for cache use which can over-ride these bits.
+
+               When "io_alloc" is enabled, a portion of each cache instance can
+               be configured for shared use between hardware and software.
+               "bit_usage" should be used to see which portions of each cache
+               instance is configured for hardware use via "io_alloc" feature
+               because every cache instance can have its "io_alloc" bitmask
+               configured independently via "io_alloc_cbm".
+
 "bit_usage":
                Annotated capacity bitmasks showing how all
                instances of the resource are used. The legend is:
@@ -115,16 +122,16 @@ related to allocation:
                        "H":
                              Corresponding region is used by hardware only
                              but available for software use. If a resource
-                             has bits set in "shareable_bits" but not all
-                             of these bits appear in the resource groups'
-                             schematas then the bits appearing in
-                             "shareable_bits" but no resource group will
-                             be marked as "H".
+                             has bits set in "shareable_bits" or "io_alloc_cbm"
+                             but not all of these bits appear in the resource
+                             groups' schemata then the bits appearing in
+                             "shareable_bits" or "io_alloc_cbm" but no
+                             resource group will be marked as "H".
                        "X":
                              Corresponding region is available for sharing and
-                             used by hardware and software. These are the
-                             bits that appear in "shareable_bits" as
-                             well as a resource group's allocation.
+                             used by hardware and software. These are the bits
+                             that appear in "shareable_bits" or "io_alloc_cbm"
+                             as well as a resource group's allocation.
                        "S":
                              Corresponding region is used by software
                              and available for sharing.

diff --git a/fs/resctrl/ctrlmondata.c b/fs/resctrl/ctrlmondata.c
index 332918fc961a3d7475d2c5225d4a688d8b128cc9..b2d178d3556ecb4bcf99a86f8c0bcd96aef278bb 100644 (file)
--- a/fs/resctrl/ctrlmondata.c
+++ b/fs/resctrl/ctrlmondata.c
@@ -750,7 +750,7 @@ out:
  * resource. Note that if Code Data Prioritization (CDP) is enabled, the number
  * of available CLOSIDs is reduced by half.
  */
-static u32 resctrl_io_alloc_closid(struct rdt_resource *r)
+u32 resctrl_io_alloc_closid(struct rdt_resource *r)
 {
        if (resctrl_arch_get_cdp_enabled(r->rid))
                return resctrl_arch_get_num_closid(r) / 2  - 1;

diff --git a/fs/resctrl/internal.h b/fs/resctrl/internal.h
index e1eda74881a9a5343866a3505afa8f582dc49162..bff4a54ae3330c7343dfccbe0ac6c13bec8ce634 100644 (file)
--- a/fs/resctrl/internal.h
+++ b/fs/resctrl/internal.h
@@ -442,6 +442,7 @@ int resctrl_io_alloc_cbm_show(struct kernfs_open_file *of, struct seq_file *seq,
                              void *v);
 ssize_t resctrl_io_alloc_cbm_write(struct kernfs_open_file *of, char *buf,
                                   size_t nbytes, loff_t off);
+u32 resctrl_io_alloc_closid(struct rdt_resource *r);
 
 #ifdef CONFIG_RESCTRL_FS_PSEUDO_LOCK
 int rdtgroup_locksetup_enter(struct rdtgroup *rdtgrp);

diff --git a/fs/resctrl/rdtgroup.c b/fs/resctrl/rdtgroup.c
index 361497489d875cd6b544dc6c1e3c710e5f3324aa..8e39dfda56bc6e274f48e86b8404fd24ea47771d 100644 (file)
--- a/fs/resctrl/rdtgroup.c
+++ b/fs/resctrl/rdtgroup.c
@@ -1062,15 +1062,17 @@ static int rdt_bit_usage_show(struct kernfs_open_file *of,
 
        cpus_read_lock();
        mutex_lock(&rdtgroup_mutex);
-       hw_shareable = r->cache.shareable_bits;
        list_for_each_entry(dom, &r->ctrl_domains, hdr.list) {
                if (sep)
                        seq_putc(seq, ';');
+               hw_shareable = r->cache.shareable_bits;
                sw_shareable = 0;
                exclusive = 0;
                seq_printf(seq, "%d=", dom->hdr.id);
                for (i = 0; i < closids_supported(); i++) {
-                       if (!closid_allocated(i))
+                       if (!closid_allocated(i) ||
+                           (resctrl_arch_get_io_alloc_enabled(r) &&
+                            i == resctrl_io_alloc_closid(r)))
                                continue;
                        ctrl_val = resctrl_arch_get_config(r, dom, i,
                                                           s->conf_type);
@@ -1098,6 +1100,21 @@ static int rdt_bit_usage_show(struct kernfs_open_file *of,
                                break;
                        }
                }
+
+               /*
+                * When the "io_alloc" feature is enabled, a portion of the cache
+                * is configured for shared use between hardware and software.
+                * Also, when CDP is enabled the CBMs of CDP_CODE and CDP_DATA
+                * resources are kept in sync. So, the CBMs for "io_alloc" can
+                * be accessed through either resource.
+                */
+               if (resctrl_arch_get_io_alloc_enabled(r)) {
+                       ctrl_val = resctrl_arch_get_config(r, dom,
+                                                          resctrl_io_alloc_closid(r),
+                                                          s->conf_type);
+                       hw_shareable |= ctrl_val;
+               }
+
                for (i = r->cache.cbm_len - 1; i >= 0; i--) {
                        pseudo_locked = dom->plr ? dom->plr->cbm : 0;
                        hwb = test_bit(i, &hw_shareable);