NUMA nodes based on their performance weight, thereby optimizing memory

bandwidth utilization. The weight values are configured through sysfs.

Previously, sysfs entries for weighted interleave were managed statically

at initialization. This led to several issues:

when initialization failed or when nodes were removed.

- Lack of Dynamic Updates: Sysfs attributes were created only during

initialization, preventing nodes added at runtime from being recognized.

- Handling of Unusable Nodes: Sysfs entries were generated for all

possible nodes (`N_POSSIBLE`), including memoryless or unavailable nodes,

### Patch Overview

- Ensures proper cleanup of `kobject` allocations.

These patches have been tested under CXL-based memory configurations,

including hotplug scenarios, to ensure proper behavior and stability.

--

2.34.1

Memory leaks occurred when removing sysfs attributes for weighted

interleave. Improper kobject deallocation led to unreleased memory

when initialization failed or when nodes were removed.

This patch resolves the issue by replacing unnecessary `kfree()`

Fixes: dce41f5ae253 ("mm/mempolicy: implement the sysfs-based weighted_interleave interface")

Signed-off-by: Rakie Kim <rakie.kim@sk.com>

---

diff --git a/mm/mempolicy.c b/mm/mempolicy.c

index XXXXXXX..XXXXXXX 100644

--- a/mm/mempolicy.c

+++ b/mm/mempolicy.c

            break;

        }

    }

-    if (err)

+    if (err) {

        kobject_put(wi_kobj);

+        goto err_out;

+    }

+

    return 0;

-        pr_err("mempolicy sysfs structure failed to initialize\n");

-        kobject_put(mempolicy_kobj);

-        return err;

-    }

+    if (err)

-    return err;

-node_out:

-    kfree(node_attrs);

-mempol_out:

-    kfree(mempolicy_kobj);

err_out:

-    pr_err("failed to add mempolicy kobject to the system\n");

+    kobject_put(mempolicy_kobj);

    return err;

}

--

2.34.1

Previously, the weighted interleave sysfs structure was statically

Signed-off-by: Rakie Kim <rakie.kim@sk.com>

---

diff --git a/mm/mempolicy.c b/mm/mempolicy.c

index XXXXXXX..XXXXXXX 100644

--- a/mm/mempolicy.c

+++ b/mm/mempolicy.c

+struct sysfs_wi_group {

+    struct kobject wi_kobj;

+    struct iw_node_attr *nattrs[];

+};

+

+

static ssize_t node_show(struct kobject *kobj, struct kobj_attribute *attr,

             char *buf)

{

@@ -XXX,XX +XXX,XX @@ static ssize_t node_store(struct kobject *kobj, struct kobj_attribute *attr,

-static struct iw_node_attr **node_attrs;

-

-static void sysfs_wi_node_release(struct iw_node_attr *node_attr,

-                 struct kobject *parent)

{

-    if (!node_attr)

        return;

-    sysfs_remove_file(parent, &node_attr->kobj_attr.attr);

-    kfree(node_attr->kobj_attr.attr.name);

-    kfree(node_attr);

+

}

static void sysfs_wi_release(struct kobject *wi_kobj)

{

-    int i;

+    int nid;

-    kfree(node_attrs);

-    kfree(wi_kobj);

+    for (nid = 0; nid < nr_node_ids; nid++)

}

static const struct kobj_type wi_ktype = {

@@ -XXX,XX +XXX,XX @@ static const struct kobj_type wi_ktype = {

    .release = sysfs_wi_release,

@@ -XXX,XX +XXX,XX @@ static int add_weight_node(int nid, struct kobject *wi_kobj)

    node_attr->kobj_attr.store = node_store;

    node_attr->nid = nid;

-    if (sysfs_create_file(wi_kobj, &node_attr->kobj_attr.attr)) {

        kfree(node_attr->kobj_attr.attr.name);

        kfree(node_attr);

        pr_err("failed to add attribute to weighted_interleave\n");

        return -ENOMEM;

    }

-    node_attrs[nid] = node_attr;

    return 0;

}

-static int add_weighted_interleave_group(struct kobject *root_kobj)

+static int add_weighted_interleave_group(struct kobject *mempolicy_kobj)

    int nid, err;

-    node_attrs = kcalloc(nr_node_ids, sizeof(struct iw_node_attr *),

-             GFP_KERNEL);

-    if (!node_attrs)

        return -ENOMEM;

-    wi_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);

-    if (!wi_kobj) {

-        err = -ENOMEM;

-        goto node_out;

-    }

-

-    err = kobject_init_and_add(wi_kobj, &wi_ktype, root_kobj,

                 "weighted_interleave");

-    if (err) {

-        kobject_put(wi_kobj);

+    if (err)

        goto err_out;

-        err = add_weight_node(nid, wi_kobj);

+        err = sysfs_wi_node_add(nid);

        if (err) {

            pr_err("failed to add sysfs [node%d]\n", nid);

-            break;

        }

    }

-    if (err) {

-        kobject_put(wi_kobj);

-        goto err_out;

-    }

    return 0;

-node_out:

-    kfree(node_attrs);

err_out:

    return err;

}

--

2.34.1

runtime, as some may remain memoryless or offline.

This led to sysfs entries being created for unusable nodes, causing

potential misconfiguration issues.

To address this issue, this patch modifies the sysfs creation logic to:

2) Support memory hotplug by dynamically adding and removing sysfs entries

based on whether a node transitions into or out of the N_MEMORY state.

Additionally, the patch ensures that sysfs attributes are properly managed

when nodes go offline, preventing stale or redundant entries from persisting

sysfs entries more efficiently, ensuring that only relevant nodes are

considered for interleaving, and dynamically adapting to memory hotplug

events.

Signed-off-by: Rakie Kim <rakie.kim@sk.com>

---

diff --git a/mm/mempolicy.c b/mm/mempolicy.c

index XXXXXXX..XXXXXXX 100644

--- a/mm/mempolicy.c

+++ b/mm/mempolicy.c

    struct iw_node_attr *nattrs[];

};

@@ -XXX,XX +XXX,XX @@ static ssize_t node_store(struct kobject *kobj, struct kobj_attribute *attr,

{

+    struct iw_node_attr *attr;

+

+    if (nid < 0 || nid >= nr_node_ids)

+        return;

+

+    if (!attr) {

        return;

+    }

+

+    kfree(attr->kobj_attr.attr.name);

+    kfree(attr);

}

static void sysfs_wi_release(struct kobject *wi_kobj)

{

-    struct iw_node_attr *node_attr;

+    int ret = 0;

    char *name;

+    struct iw_node_attr *new_attr = NULL;

+    if (nid < 0 || nid >= nr_node_ids) {

+        pr_err("Invalid node id: %d\n", nid);

+        return -EINVAL;

+    }

+    new_attr = kzalloc(sizeof(struct iw_node_attr), GFP_KERNEL);

+    if (!new_attr)

        return -ENOMEM;

    name = kasprintf(GFP_KERNEL, "node%d", nid);

-    node_attr->kobj_attr.attr.name = name;

-    node_attr->kobj_attr.attr.mode = 0644;

-    node_attr->kobj_attr.show = node_show;

-    node_attr->kobj_attr.store = node_store;

-    node_attr->nid = nid;

+        pr_info("Node [%d] already exists\n", nid);

+        kfree(new_attr);

+        kfree(name);

+        return 0;

+    }

-        kfree(node_attr->kobj_attr.attr.name);

-        kfree(node_attr);

-        pr_err("failed to add attribute to weighted_interleave\n");

-        return -ENOMEM;

+    if (ret) {

+        pr_err("Failed to add attribute to weighted_interleave: %d\n", ret);

    }

-    return 0;

+    return ret;

+}

+

+static int wi_node_notifier(struct notifier_block *nb,

+            pr_err("failed to add sysfs [node%d]\n", nid);

+            return NOTIFY_BAD;

+        }

+        break;

+    case MEM_OFFLINE:

+        break;

+    }

+

+notifier_end:

+    return NOTIFY_OK;

}

static int add_weighted_interleave_group(struct kobject *mempolicy_kobj)

@@ -XXX,XX +XXX,XX @@ static int add_weighted_interleave_group(struct kobject *mempolicy_kobj)

        return -ENOMEM;

                 "weighted_interleave");

    if (err)

        goto err_out;

-    for_each_node_state(nid, N_POSSIBLE) {

    }

+    hotplug_memory_notifier(wi_node_notifier, DEFAULT_CALLBACK_PRI);

    return 0;

--

2.34.1