[PATCH 08/11] s390/sclp_mem: Allocate struct sclp_mem dynamically and add kobject release

[Ian Rogers <irogers@xxxxxxxxxx>]

sclp_init_mem() allocated a single array of struct sclp_mem with
kzalloc_objs() and registered each embedded kobject using a kobj_type
without a .release callback. Allocate each struct sclp_mem individually
with kzalloc_obj() instead and add sclp_mem_release() to free it.

Fixes: ff18dcb19aab ("s390/sclp: Add support for dynamic (de)configuration of 
memory")
Assisted-by: Antigravity:gemini-3.1-pro
Signed-off-by: Ian Rogers <irogers@xxxxxxxxxx>
---
 drivers/s390/char/sclp_mem.c | 73 +++++++++++++++++-------------------
 1 file changed, 34 insertions(+), 39 deletions(-)

diff --git a/drivers/s390/char/sclp_mem.c b/drivers/s390/char/sclp_mem.c
index 6df1926d4c62..f7c161e0d836 100644
--- a/drivers/s390/char/sclp_mem.c
+++ b/drivers/s390/char/sclp_mem.c
@@ -49,11 +49,6 @@ struct sclp_mem {
 #endif
 };
 
-struct sclp_mem_arg {
-       struct sclp_mem *sclp_mems;
-       struct kset *kset;
-};
-
 struct assign_storage_sccb {
        struct sccb_header header;
        u16 rn;
@@ -304,7 +299,15 @@ static ssize_t sclp_memmap_on_memory_store(struct kobject 
*kobj, struct kobj_att
        return rc ? rc : count;
 }
 
+static void sclp_mem_release(struct kobject *kobj)
+{
+       struct sclp_mem *sclp_mem = container_of(kobj, struct sclp_mem, kobj);
+
+       kfree(sclp_mem);
+}
+
 static const struct kobj_type ktype = {
+       .release = sclp_mem_release,
        .sysfs_ops = &kobj_sysfs_ops,
 };
 
@@ -321,36 +324,40 @@ static struct attribute_group sclp_mem_attr_group = {
        .attrs = sclp_mem_attrs,
 };
 
-static int sclp_create_mem(struct sclp_mem *sclp_mem, struct kset *kset,
-                          unsigned int id, bool config, bool memmap_on_memory)
+static int sclp_create_mem(struct kset *kset, unsigned int id, bool config,
+                          bool memmap_on_memory)
 {
+       struct sclp_mem *sclp_mem;
        int rc;
 
+       sclp_mem = kzalloc_obj(*sclp_mem);
+       if (!sclp_mem)
+               return -ENOMEM;
        sclp_mem->memmap_on_memory = memmap_on_memory;
        sclp_mem->config = config;
 #ifdef CONFIG_KASAN
        sclp_mem->early_shadow_mapped = config;
 #endif
        sclp_mem->id = id;
-       kobject_init(&sclp_mem->kobj, &ktype);
-       rc = kobject_add(&sclp_mem->kobj, &kset->kobj, "memory%d", id);
-       if (rc)
+       rc = kobject_init_and_add(&sclp_mem->kobj, &ktype, &kset->kobj,
+                                 "memory%d", id);
+       if (rc) {
+               kobject_put(&sclp_mem->kobj);
                return rc;
-       return sysfs_create_group(&sclp_mem->kobj, &sclp_mem_attr_group);
+       }
+       rc = sysfs_create_group(&sclp_mem->kobj, &sclp_mem_attr_group);
+       if (rc) {
+               kobject_put(&sclp_mem->kobj);
+               return rc;
+       }
+       return 0;
 }
 
 static int sclp_create_configured_mem(struct memory_block *mem, void *argument)
 {
-       struct sclp_mem *sclp_mems;
-       struct sclp_mem_arg *arg;
-       struct kset *kset;
-       unsigned int id;
+       struct kset *kset = argument;
 
-       id = mem->dev.id;
-       arg = (struct sclp_mem_arg *)argument;
-       sclp_mems = arg->sclp_mems;
-       kset = arg->kset;
-       return sclp_create_mem(&sclp_mems[id], kset, id, true, false);
+       return sclp_create_mem(kset, mem->dev.id, true, false);
 }
 
 static void __init align_to_block_size(unsigned long *start,
@@ -368,8 +375,7 @@ static void __init align_to_block_size(unsigned long *start,
        *size = size_align;
 }
 
-static int __init sclp_create_standby_mems_merged(struct sclp_mem *sclp_mems,
-                                                 struct kset *kset, u16 rn)
+static int __init sclp_create_standby_mems_merged(struct kset *kset, u16 rn)
 {
        unsigned long start, size, addr, block_size;
        static u16 first_rn, num;
@@ -394,7 +400,7 @@ static int __init sclp_create_standby_mems_merged(struct 
sclp_mem *sclp_mems,
                goto skip_add;
        for (addr = start; addr < start + size; addr += block_size) {
                id = addr / block_size;
-               rc = sclp_create_mem(&sclp_mems[id], kset, id, false,
+               rc = sclp_create_mem(kset, id, false,
                                     mhp_supports_memmap_on_memory());
                if (rc)
                        break;
@@ -405,45 +411,34 @@ static int __init sclp_create_standby_mems_merged(struct 
sclp_mem *sclp_mems,
        return rc;
 }
 
-static int __init sclp_create_standby_mems(struct sclp_mem *sclp_mems, struct 
kset *kset)
+static int __init sclp_create_standby_mems(struct kset *kset)
 {
        struct memory_increment *incr;
        int rc = 0;
 
        list_for_each_entry(incr, &sclp_mem_list, list) {
                if (incr->standby)
-                       rc = sclp_create_standby_mems_merged(sclp_mems, kset, 
incr->rn);
+                       rc = sclp_create_standby_mems_merged(kset, incr->rn);
                if (rc)
                        return rc;
        }
-       return sclp_create_standby_mems_merged(sclp_mems, kset, 0);
+       return sclp_create_standby_mems_merged(kset, 0);
 }
 
 static int __init sclp_init_mem(void)
 {
-       const unsigned long block_size = memory_block_size_bytes();
-       unsigned int max_sclp_mems;
-       struct sclp_mem *sclp_mems;
-       struct sclp_mem_arg arg;
        struct kset *kset;
        int rc;
 
-       max_sclp_mems = roundup(sclp.rnmax * sclp.rzm, block_size) / block_size;
-       /* Allocate memory for all blocks ahead of time. */
-       sclp_mems = kzalloc_objs(struct sclp_mem, max_sclp_mems);
-       if (!sclp_mems)
-               return -ENOMEM;
        kset = kset_create_and_add("memory", NULL, firmware_kobj);
        if (!kset)
                return -ENOMEM;
        /* Initial memory is in the "configured" state already. */
-       arg.sclp_mems = sclp_mems;
-       arg.kset = kset;
-       rc = for_each_memory_block(&arg, sclp_create_configured_mem);
+       rc = for_each_memory_block(kset, sclp_create_configured_mem);
        if (rc)
                return rc;
        /* Standby memory is "deconfigured". */
-       return sclp_create_standby_mems(sclp_mems, kset);
+       return sclp_create_standby_mems(kset);
 }
 
 static void __init insert_increment(u16 rn, int standby, int assigned)
-- 
2.56.0.385.gd3acb90ef8-goog