1 files changed, 151 insertions, 0 deletions

diff --git a/drivers/base/node.c b/drivers/base/node.c
index 2de546a040a5..8598fcbd2a17 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -205,6 +205,155 @@ void node_set_perf_attrs(unsigned int nid, struct node_hmem_attrs *hmem_attrs,
                 }
         }
 }
+
+/**
+ * struct node_cache_info - Internal tracking for memory node caches
+ * @dev:        Device represeting the cache level
+ * @node:       List element for tracking in the node
+ * @cache_attrs:Attributes for this cache level
+ */
+struct node_cache_info {
+        struct device dev;
+        struct list_head node;
+        struct node_cache_attrs cache_attrs;
+};
+#define to_cache_info(device) container_of(device, struct node_cache_info, dev)
+
+#define CACHE_ATTR(name, fmt)                                           \
+static ssize_t name##_show(struct device *dev,                          \
+                           struct device_attribute *attr,               \
+                           char *buf)                                   \
+{                                                                       \
+        return sprintf(buf, fmt "\n", to_cache_info(dev)->cache_attrs.name);\
+}                                                                       \
+DEVICE_ATTR_RO(name);
+
+CACHE_ATTR(size, "%llu")
+CACHE_ATTR(line_size, "%u")
+CACHE_ATTR(indexing, "%u")
+CACHE_ATTR(write_policy, "%u")
+
+static struct attribute *cache_attrs[] = {
+        &dev_attr_indexing.attr,
+        &dev_attr_size.attr,
+        &dev_attr_line_size.attr,
+        &dev_attr_write_policy.attr,
+        NULL,
+};
+ATTRIBUTE_GROUPS(cache);
+
+static void node_cache_release(struct device *dev)
+{
+        kfree(dev);
+}
+
+static void node_cacheinfo_release(struct device *dev)
+{
+        struct node_cache_info *info = to_cache_info(dev);
+        kfree(info);
+}
+
+static void node_init_cache_dev(struct node *node)
+{
+        struct device *dev;
+
+        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+        if (!dev)
+                return;
+
+        dev->parent = &node->dev;
+        dev->release = node_cache_release;
+        if (dev_set_name(dev, "memory_side_cache"))
+                goto free_dev;
+
+        if (device_register(dev))
+                goto free_name;
+
+        pm_runtime_no_callbacks(dev);
+        node->cache_dev = dev;
+        return;
+free_name:
+        kfree_const(dev->kobj.name);
+free_dev:
+        kfree(dev);
+}
+
+/**
+ * node_add_cache() - add cache attribute to a memory node
+ * @nid: Node identifier that has new cache attributes
+ * @cache_attrs: Attributes for the cache being added
+ */
+void node_add_cache(unsigned int nid, struct node_cache_attrs *cache_attrs)
+{
+        struct node_cache_info *info;
+        struct device *dev;
+        struct node *node;
+
+        if (!node_online(nid) || !node_devices[nid])
+                return;
+
+        node = node_devices[nid];
+        list_for_each_entry(info, &node->cache_attrs, node) {
+                if (info->cache_attrs.level == cache_attrs->level) {
+                        dev_warn(&node->dev,
+                                "attempt to add duplicate cache level:%d\n",
+                                cache_attrs->level);
+                        return;
+                }
+        }
+
+        if (!node->cache_dev)
+                node_init_cache_dev(node);
+        if (!node->cache_dev)
+                return;
+
+        info = kzalloc(sizeof(*info), GFP_KERNEL);
+        if (!info)
+                return;
+
+        dev = &info->dev;
+        dev->parent = node->cache_dev;
+        dev->release = node_cacheinfo_release;
+        dev->groups = cache_groups;
+        if (dev_set_name(dev, "index%d", cache_attrs->level))
+                goto free_cache;
+
+        info->cache_attrs = *cache_attrs;
+        if (device_register(dev)) {
+                dev_warn(&node->dev, "failed to add cache level:%d\n",
+                         cache_attrs->level);
+                goto free_name;
+        }
+        pm_runtime_no_callbacks(dev);
+        list_add_tail(&info->node, &node->cache_attrs);
+        return;
+free_name:
+        kfree_const(dev->kobj.name);
+free_cache:
+        kfree(info);
+}
+
+static void node_remove_caches(struct node *node)
+{
+        struct node_cache_info *info, *next;
+
+        if (!node->cache_dev)
+                return;
+
+        list_for_each_entry_safe(info, next, &node->cache_attrs, node) {
+                list_del(&info->node);
+                device_unregister(&info->dev);
+        }
+        device_unregister(node->cache_dev);
+}
+
+static void node_init_caches(unsigned int nid)
+{
+        INIT_LIST_HEAD(&node_devices[nid]->cache_attrs);
+}
+#else
+static void node_init_caches(unsigned int nid) { }
+static void node_remove_caches(struct node *node) { }
 #endif
 
 #define K(x) ((x) << (PAGE_SHIFT - 10))
@@ -489,6 +638,7 @@ void unregister_node(struct node *node)
 {
         hugetlb_unregister_node(node);          /* no-op, if memoryless node */
         node_remove_accesses(node);
+        node_remove_caches(node);
         device_unregister(&node->dev);
 }
 
@@ -781,6 +931,7 @@ int __register_one_node(int nid)
         INIT_LIST_HEAD(&node_devices[nid]->access_list);
         /* initialize work queue for memory hot plug */
         init_node_hugetlb_work(nid);
+        node_init_caches(nid);
 
         return error;
 }