mm/demotion: expose memory tier details via sysfs

Add /sys/devices/virtual/memory_tiering/ where all memory tier related
details can be found.  All allocated memory tiers will be listed there as
/sys/devices/virtual/memory_tiering/memory_tierN/

The nodes which are part of a specific memory tier can be listed via
/sys/devices/virtual/memory_tiering/memory_tierN/nodes

A directory hierarchy looks like
:/sys/devices/virtual/memory_tiering$ tree memory_tier4/
memory_tier4/
├── nodes
├── subsystem -> ../../../../bus/memory_tiering
└── uevent

:/sys/devices/virtual/memory_tiering$ cat memory_tier4/nodes
0,2

[aneesh.kumar@linux.ibm.com: drop toptier_nodes from sysfs]
Link: https://lkml.kernel.org/r/20220922102201.62168-1-aneesh.kumar@linux.ibm.com
Link: https://lkml.kernel.org/r/20220830081736.119281-1-aneesh.kumar@linux.ibm.com
Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.ibm.com>
Cc: Alistair Popple <apopple@nvidia.com>
Cc: Bharata B Rao <bharata@amd.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Dave Hansen <dave.hansen@intel.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Hesham Almatary <hesham.almatary@huawei.com>
Cc: "Huang, Ying" <ying.huang@intel.com>
Cc: Jagdish Gediya <jvgediya.oss@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Tim Chen <tim.c.chen@intel.com>
Cc: Wei Xu <weixugc@google.com>
Cc: Yang Shi <shy828301@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers b/Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers
new file mode 100644 (file)
index 0000000..45985e4
--- /dev/null
+++ b/Documentation/ABI/testing/sysfs-kernel-mm-memory-tiers
@@ -0,0 +1,25 @@
+What:          /sys/devices/virtual/memory_tiering/
+Date:          August 2022
+Contact:       Linux memory management mailing list <linux-mm@kvack.org>
+Description:   A collection of all the memory tiers allocated.
+
+               Individual memory tier details are contained in subdirectories
+               named by the abstract distance of the memory tier.
+
+               /sys/devices/virtual/memory_tiering/memory_tierN/
+
+
+What:          /sys/devices/virtual/memory_tiering/memory_tierN/
+               /sys/devices/virtual/memory_tiering/memory_tierN/nodes
+Date:          August 2022
+Contact:       Linux memory management mailing list <linux-mm@kvack.org>
+Description:   Directory with details of a specific memory tier
+
+               This is the directory containing information about a particular
+               memory tier, memtierN, where N is derived based on abstract distance.
+
+               A smaller value of N implies a higher (faster) memory tier in the
+               hierarchy.
+
+               nodes: NUMA nodes that are part of this memory tier.
+

diff --git a/mm/memory-tiers.c b/mm/memory-tiers.c
index c82eb0111383bbb1d869ad7397d156cf017b0eb3..f116b7b6333e50f1c3f6c2a7717afe30aa2b1629 100644 (file)
--- a/mm/memory-tiers.c
+++ b/mm/memory-tiers.c
@@ -19,6 +19,7 @@ struct memory_tier {
         * adistance_start .. adistance_start + MEMTIER_CHUNK_SIZE
         */
        int adistance_start;
+       struct device dev;
        /* All the nodes that are part of all the lower memory tiers. */
        nodemask_t lower_tier_mask;
 };
@@ -36,6 +37,12 @@ static DEFINE_MUTEX(memory_tier_lock);
 static LIST_HEAD(memory_tiers);
 static struct node_memory_type_map node_memory_types[MAX_NUMNODES];
 static struct memory_dev_type *default_dram_type;
+
+static struct bus_type memory_tier_subsys = {
+       .name = "memory_tiering",
+       .dev_name = "memory_tier",
+};
+
 #ifdef CONFIG_MIGRATION
 static int top_tier_adistance;
 /*
@@ -98,8 +105,63 @@ static int top_tier_adistance;
 static struct demotion_nodes *node_demotion __read_mostly;
 #endif /* CONFIG_MIGRATION */
 
+static inline struct memory_tier *to_memory_tier(struct device *device)
+{
+       return container_of(device, struct memory_tier, dev);
+}
+
+static __always_inline nodemask_t get_memtier_nodemask(struct memory_tier *memtier)
+{
+       nodemask_t nodes = NODE_MASK_NONE;
+       struct memory_dev_type *memtype;
+
+       list_for_each_entry(memtype, &memtier->memory_types, tier_sibiling)
+               nodes_or(nodes, nodes, memtype->nodes);
+
+       return nodes;
+}
+
+static void memory_tier_device_release(struct device *dev)
+{
+       struct memory_tier *tier = to_memory_tier(dev);
+       /*
+        * synchronize_rcu in clear_node_memory_tier makes sure
+        * we don't have rcu access to this memory tier.
+        */
+       kfree(tier);
+}
+
+static ssize_t nodes_show(struct device *dev,
+                         struct device_attribute *attr, char *buf)
+{
+       int ret;
+       nodemask_t nmask;
+
+       mutex_lock(&memory_tier_lock);
+       nmask = get_memtier_nodemask(to_memory_tier(dev));
+       ret = sysfs_emit(buf, "%*pbl\n", nodemask_pr_args(&nmask));
+       mutex_unlock(&memory_tier_lock);
+       return ret;
+}
+static DEVICE_ATTR_RO(nodes);
+
+static struct attribute *memtier_dev_attrs[] = {
+       &dev_attr_nodes.attr,
+       NULL
+};
+
+static const struct attribute_group memtier_dev_group = {
+       .attrs = memtier_dev_attrs,
+};
+
+static const struct attribute_group *memtier_dev_groups[] = {
+       &memtier_dev_group,
+       NULL
+};
+
 static struct memory_tier *find_create_memory_tier(struct memory_dev_type *memtype)
 {
+       int ret;
        bool found_slot = false;
        struct memory_tier *memtier, *new_memtier;
        int adistance = memtype->adistance;
@@ -123,15 +185,14 @@ static struct memory_tier *find_create_memory_tier(struct memory_dev_type *memty
 
        list_for_each_entry(memtier, &memory_tiers, list) {
                if (adistance == memtier->adistance_start) {
-                       list_add(&memtype->tier_sibiling, &memtier->memory_types);
-                       return memtier;
+                       goto link_memtype;
                } else if (adistance < memtier->adistance_start) {
                        found_slot = true;
                        break;
                }
        }
 
-       new_memtier = kmalloc(sizeof(struct memory_tier), GFP_KERNEL);
+       new_memtier = kzalloc(sizeof(struct memory_tier), GFP_KERNEL);
        if (!new_memtier)
                return ERR_PTR(-ENOMEM);
 
@@ -142,8 +203,23 @@ static struct memory_tier *find_create_memory_tier(struct memory_dev_type *memty
                list_add_tail(&new_memtier->list, &memtier->list);
        else
                list_add_tail(&new_memtier->list, &memory_tiers);
-       list_add(&memtype->tier_sibiling, &new_memtier->memory_types);
-       return new_memtier;
+
+       new_memtier->dev.id = adistance >> MEMTIER_CHUNK_BITS;
+       new_memtier->dev.bus = &memory_tier_subsys;
+       new_memtier->dev.release = memory_tier_device_release;
+       new_memtier->dev.groups = memtier_dev_groups;
+
+       ret = device_register(&new_memtier->dev);
+       if (ret) {
+               list_del(&memtier->list);
+               put_device(&memtier->dev);
+               return ERR_PTR(ret);
+       }
+       memtier = new_memtier;
+
+link_memtype:
+       list_add(&memtype->tier_sibiling, &memtier->memory_types);
+       return memtier;
 }
 
 static struct memory_tier *__node_get_memory_tier(int node)
@@ -275,17 +351,6 @@ static void disable_all_demotion_targets(void)
        synchronize_rcu();
 }
 
-static __always_inline nodemask_t get_memtier_nodemask(struct memory_tier *memtier)
-{
-       nodemask_t nodes = NODE_MASK_NONE;
-       struct memory_dev_type *memtype;
-
-       list_for_each_entry(memtype, &memtier->memory_types, tier_sibiling)
-               nodes_or(nodes, nodes, memtype->nodes);
-
-       return nodes;
-}
-
 /*
  * Find an automatic demotion target for all memory
  * nodes. Failing here is OK.  It might just indicate
@@ -433,11 +498,7 @@ static struct memory_tier *set_node_memory_tier(int node)
 static void destroy_memory_tier(struct memory_tier *memtier)
 {
        list_del(&memtier->list);
-       /*
-        * synchronize_rcu in clear_node_memory_tier makes sure
-        * we don't have rcu access to this memory tier.
-        */
-       kfree(memtier);
+       device_unregister(&memtier->dev);
 }
 
 static bool clear_node_memory_tier(int node)
@@ -566,9 +627,13 @@ static int __meminit memtier_hotplug_callback(struct notifier_block *self,
 
 static int __init memory_tier_init(void)
 {
-       int node;
+       int ret, node;
        struct memory_tier *memtier;
 
+       ret = subsys_virtual_register(&memory_tier_subsys, NULL);
+       if (ret)
+               panic("%s() failed to register memory tier subsystem\n", __func__);
+
 #ifdef CONFIG_MIGRATION
        node_demotion = kcalloc(nr_node_ids, sizeof(struct demotion_nodes),
                                GFP_KERNEL);