Skip to contentSkip to conversation

mm: cma: support sysfs

PATCH Superseded Minchan Kim 3 participants 12 messages Mar 24, 2021

Subsystems (3)

v6 of 8 Superseded Latest is v8 →

lore
Share & tools
lore
#0 lore raw

PATCH v6 1/1 mm: cma: support sysfs

Since CMA is getting used more widely, it's more important to keep monitoring CMA statistics for system health since it's directly related to user experience.

This patch introduces sysfs statistics for CMA, in order to provide some basic monitoring of the CMA allocator.

* the number of CMA page successful allocations
* the number of CMA page allocation failures

These two values allow the user to calculate the allocation failure rate for each CMA area.

e.g.)
/sys/kernel/mm/cma/WIFI/alloc_pages_[success|fail] /sys/kernel/mm/cma/SENSOR/alloc_pages_[success|fail] /sys/kernel/mm/cma/BLUETOOTH/alloc_pages_[success|fail]

The cma_stat was intentionally allocated by dynamic allocation to harmonize with kobject lifetime management.
https://lore.kernel.org/linux-mm/[email protected]/

---
From v5 - https://lore.kernel.org/linux-mm/[email protected]/
* refactoring and fix typo - digetx@

From v4 - https://lore.kernel.org/linux-mm/[email protected]/
* fix corruption - digetx@

From v3 - https://lore.kernel.org/linux-mm/[email protected]/
* fix ZERO_OR_NULL_PTR - kernel test robot
* remove prefix cma - david@
* resolve conflict with vmstat cma in mmotm - akpm@
* rename stat name with success|fail

From v2 - https://lore.kernel.org/linux-mm/[email protected]/
* sysfs doc and description modification - jhubbard

From v1 - https://lore.kernel.org/linux-mm/[email protected]/
* fix sysfs build and refactoring - willy

 Documentation/ABI/testing/sysfs-kernel-mm-cma |  25 ++++
 mm/Kconfig                                    |   7 ++
 mm/Makefile                                   |   1 +
 mm/cma.c                                      |   7 +-
 mm/cma.h                                      |  23 ++++
 mm/cma_sysfs.c                                | 107 ++++++++++++++++++
 6 files changed, 168 insertions(+), 2 deletions(-)
 create mode 100644 Documentation/ABI/testing/sysfs-kernel-mm-cma
 create mode 100644 mm/cma_sysfs.c
Documentation/ABI/testing/sysfs-kernel-mm-cma new file +25 -0
new file mode 100644
index 000000000000..02b2bb60c296
@@ -0,0 +1,25 @@
+What:		/sys/kernel/mm/cma/
+Date:		Feb 2021
+Contact:	Minchan Kim <[email protected]>
+Description:
+		/sys/kernel/mm/cma/ contains a subdirectory for each CMA
+		heap name (also sometimes called CMA areas).
+
+		Each CMA heap subdirectory (that is, each
+		/sys/kernel/mm/cma/<cma-heap-name> directory) contains the
+		following items:
+
+			alloc_pages_success
+			alloc_pages_fail
+
+What:		/sys/kernel/mm/cma/<cma-heap-name>/alloc_pages_success
+Date:		Feb 2021
+Contact:	Minchan Kim <[email protected]>
+Description:
+		the number of pages CMA API succeeded to allocate
+
+What:		/sys/kernel/mm/cma/<cma-heap-name>/alloc_pages_fail
+Date:		Feb 2021
+Contact:	Minchan Kim <[email protected]>
+Description:
+		the number of pages CMA API failed to allocate
mm/Kconfig +7 -0
index 24c045b24b95..febb7e8e24de 100644
@@ -513,6 +513,13 @@ config CMA_DEBUGFS
 	help
 	  Turns on the DebugFS interface for CMA.
 
+config CMA_SYSFS
+	bool "CMA information through sysfs interface"
+	depends on CMA && SYSFS
+	help
+	  This option exposes some sysfs attributes to get information
+	  from CMA.
+
 config CMA_AREAS
 	int "Maximum count of the CMA areas"
 	depends on CMA
mm/Makefile +1 -0
index 72227b24a616..56968b23ed7a 100644
@@ -109,6 +109,7 @@ obj-$(CONFIG_CMA)	+= cma.o
 obj-$(CONFIG_MEMORY_BALLOON) += balloon_compaction.o
 obj-$(CONFIG_PAGE_EXTENSION) += page_ext.o
 obj-$(CONFIG_CMA_DEBUGFS) += cma_debug.o
+obj-$(CONFIG_CMA_SYSFS) += cma_sysfs.o
 obj-$(CONFIG_USERFAULTFD) += userfaultfd.o
 obj-$(CONFIG_IDLE_PAGE_TRACKING) += page_idle.o
 obj-$(CONFIG_DEBUG_PAGE_REF) += debug_page_ref.o
mm/cma.c +5 -2
index 908f04775686..204e349a0c25 100644
@@ -507,10 +507,13 @@ struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align,
 
 	pr_debug("%s(): returned %p\n", __func__, page);
 out:
-	if (page)
+	if (page) {
 		count_vm_event(CMA_ALLOC_SUCCESS);
-	else
+		cma_sysfs_account_success_pages(cma, count);
+	} else {
 		count_vm_event(CMA_ALLOC_FAIL);
+		cma_sysfs_account_fail_pages(cma, count);
+	}
 
 	return page;
 }
mm/cma.h +23 -0
index 42ae082cb067..2298a2e736a6 100644
@@ -3,6 +3,12 @@
 #define __MM_CMA_H__
 
 #include <linux/debugfs.h>
+#include <linux/kobject.h>
+
+struct cma_kobject {
+	struct cma *cma;
+	struct kobject kobj;
+};
 
 struct cma {
 	unsigned long   base_pfn;
@@ -16,6 +22,14 @@ struct cma {
 	struct debugfs_u32_array dfs_bitmap;
 #endif
 	char name[CMA_MAX_NAME];
+#ifdef CONFIG_CMA_SYSFS
+	/* the number of CMA page successful allocations */
+	atomic64_t nr_pages_succeeded;
+	/* the number of CMA page allocation failures */
+	atomic64_t nr_pages_failed;
+	/* kobject requires dynamic object */
+	struct cma_kobject *kobj;
+#endif
 };
 
 extern struct cma cma_areas[MAX_CMA_AREAS];
@@ -26,4 +40,13 @@ static inline unsigned long cma_bitmap_maxno(struct cma *cma)
 	return cma->count >> cma->order_per_bit;
 }
 
+#ifdef CONFIG_CMA_SYSFS
+void cma_sysfs_account_success_pages(struct cma *cma, size_t count);
+void cma_sysfs_account_fail_pages(struct cma *cma, size_t count);
+#else
+static inline void cma_sysfs_account_success_pages(struct cma *cma,
+						   size_t count) {};
+static inline void cma_sysfs_account_fail_pages(struct cma *cma,
+						size_t count) {};
+#endif
 #endif
mm/cma_sysfs.c new file +107 -0

107 lines not on this page · raw message

Signature · 1 line
2.31.0.291.g576ba9dcdaf-goog
#1 lore raw

On 3/23/21 6:05 PM, Minchan Kim wrote:
...> diff --git a/mm/cma_sysfs.c b/mm/cma_sysfs.c

Quoted 22 lines

new file mode 100644
index 000000000000..c3791a032dc5

mm/cma_sysfs.c new file +17 -0
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * CMA SysFS Interface
+ *
+ * Copyright (c) 2021 Minchan Kim <[email protected]>
+ */
+
+#include <linux/cma.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+
+#include "cma.h"
+
+void cma_sysfs_account_success_pages(struct cma *cma, size_t count)
+{
+	atomic64_add(count, &cma->nr_pages_succeeded);
+}

mm/cma_sysfs.c line 27

Quoted 10 lines
mm/cma_sysfs.c new file +10 -0
+
+void cma_sysfs_account_fail_pages(struct cma *cma, size_t count)
+{
+	atomic64_add(count, &cma->nr_pages_failed);
+}
+
+#define CMA_ATTR_RO(_name) \
+	static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
+
+#define to_cma_kobject(x) container_of(x, struct cma_kobject, kobj)

I really don't think that helps. container_of() is so widely used and understood that it is not a good move make people read one more wrapper for it. Instead, see below...

mm/cma_sysfs.c line 33

Quoted 6 lines
mm/cma_sysfs.c new file +6 -0
+
+static ssize_t alloc_pages_success_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;

...if you're looking to get rid of the real code duplication, then you could put *both* of those lines into a wrapper function, instead, like this:

static inline struct cma* cma_from_kobj(struct kobject *kobj)

{
	struct cma_kobject *cma_kobj = container_of(kobj, struct cma_kobject,
						    kobj);
	struct cma *cma = cma_kobj->cma;

	return cma;
}

static ssize_t alloc_pages_success_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)

{
	struct cma *cma = cma_from_kobj(kobj);

	return sysfs_emit(buf, "%llu\n",
			  atomic64_read(&cma->nr_pages_succeeded));
}

CMA_ATTR_RO(alloc_pages_success);

static ssize_t alloc_pages_fail_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)

{
	struct cma *cma = cma_from_kobj(kobj);

	return sysfs_emit(buf, "%llu\n", atomic64_read(&cma->nr_pages_failed));
}

CMA_ATTR_RO(alloc_pages_fail);

static void cma_kobj_release(struct kobject *kobj)

{
	struct cma_kobject *cma_kobj = container_of(kobj, struct cma_kobject,
						    kobj);
	struct cma *cma = cma_kobj->cma;

	kfree(cma_kobj);
	cma->kobj = NULL;
}

...isn't that nicer? Saves a little code, gets rid of a macro.

Quoted 47 lines
mm/cma_sysfs.c new file +47 -0
+
+	return sysfs_emit(buf, "%llu\n",
+			  atomic64_read(&cma->nr_pages_succeeded));
+}
+CMA_ATTR_RO(alloc_pages_success);
+
+static ssize_t alloc_pages_fail_show(struct kobject *kobj,
+				     struct kobj_attribute *attr, char *buf)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;
+
+	return sysfs_emit(buf, "%llu\n", atomic64_read(&cma->nr_pages_failed));
+}
+CMA_ATTR_RO(alloc_pages_fail);
+
+static void cma_kobj_release(struct kobject *kobj)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;
+
+	kfree(cma_kobj);
+	cma->kobj = NULL;
+}
+
+static struct attribute *cma_attrs[] = {
+	&alloc_pages_success_attr.attr,
+	&alloc_pages_fail_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(cma);
+
+static struct kobject *cma_kobj_root;
+
+static struct kobj_type cma_ktype = {
+	.release = cma_kobj_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = cma_groups
+};
+
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

mm/cma_sysfs.c line 90

Quoted 10 lines
mm/cma_sysfs.c new file +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

What you might want here is a separate routine to clean up, because it has to loop through and free whatever was allocated on previous iterations of this loop here.

mm/cma_sysfs.c line 101

Quoted 11 lines
mm/cma_sysfs.c new file +11 -0
+		}
+
+		cma = &cma_areas[i];
+		cma->kobj = cma_kobj;
+		cma_kobj->cma = cma;
+		err = kobject_init_and_add(&cma_kobj->kobj, &cma_ktype,
+					   cma_kobj_root, "%s", cma->name);
+		if (err) {
+			kobject_put(&cma_kobj->kobj);
+			kobject_put(cma_kobj_root);
+			return err;

Hopefully this little bit of logic could also go into the cleanup routine.

mm/cma_sysfs.c line 107

Quoted 7 lines
mm/cma_sysfs.c new file +6 -0
+		}
+	}
+
+	return 0;
+}
+subsys_initcall(cma_sysfs_init);

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#2 lore raw
Quoted 87 lines · John Hubbard

On 3/23/21 6:05 PM, Minchan Kim wrote:
...> diff --git a/mm/cma_sysfs.c b/mm/cma_sysfs.c

Quoted 22 lines

new file mode 100644
index 000000000000..c3791a032dc5

mm/cma_sysfs.c new file +17 -0
@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * CMA SysFS Interface
+ *
+ * Copyright (c) 2021 Minchan Kim <[email protected]>
+ */
+
+#include <linux/cma.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+
+#include "cma.h"
+
+void cma_sysfs_account_success_pages(struct cma *cma, size_t count)
+{
+	atomic64_add(count, &cma->nr_pages_succeeded);
+}

mm/cma_sysfs.c line 27

Quoted 10 lines
mm/cma_sysfs.c new file +10 -0
+
+void cma_sysfs_account_fail_pages(struct cma *cma, size_t count)
+{
+	atomic64_add(count, &cma->nr_pages_failed);
+}
+
+#define CMA_ATTR_RO(_name) \
+	static struct kobj_attribute _name##_attr = __ATTR_RO(_name)
+
+#define to_cma_kobject(x) container_of(x, struct cma_kobject, kobj)

I really don't think that helps. container_of() is so widely used and understood that it is not a good move make people read one more wrapper for it. Instead, see below...

mm/cma_sysfs.c line 33

Quoted 6 lines
mm/cma_sysfs.c new file +6 -0
+
+static ssize_t alloc_pages_success_show(struct kobject *kobj,
+					struct kobj_attribute *attr, char *buf)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;

...if you're looking to get rid of the real code duplication, then you could put *both* of those lines into a wrapper function, instead, like this:

static inline struct cma* cma_from_kobj(struct kobject *kobj)

{
	struct cma_kobject *cma_kobj = container_of(kobj, struct cma_kobject,
						    kobj);
	struct cma *cma = cma_kobj->cma;

	return cma;
}

static ssize_t alloc_pages_success_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)

{
	struct cma *cma = cma_from_kobj(kobj);

	return sysfs_emit(buf, "%llu\n",
			  atomic64_read(&cma->nr_pages_succeeded));
}

CMA_ATTR_RO(alloc_pages_success);

static ssize_t alloc_pages_fail_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)

{
	struct cma *cma = cma_from_kobj(kobj);

	return sysfs_emit(buf, "%llu\n", atomic64_read(&cma->nr_pages_failed));
}

CMA_ATTR_RO(alloc_pages_fail);

static void cma_kobj_release(struct kobject *kobj)

{
	struct cma_kobject *cma_kobj = container_of(kobj, struct cma_kobject,
						    kobj);
	struct cma *cma = cma_kobj->cma;

	kfree(cma_kobj);
	cma->kobj = NULL;
}
Quoted 1 line

...isn't that nicer? Saves a little code, gets rid of a macro.

Yub.

Quoted 52 lines
Quoted 52 lines
mm/cma_sysfs.c new file +51 -0
+
+	return sysfs_emit(buf, "%llu\n",
+			  atomic64_read(&cma->nr_pages_succeeded));
+}
+CMA_ATTR_RO(alloc_pages_success);
+
+static ssize_t alloc_pages_fail_show(struct kobject *kobj,
+				     struct kobj_attribute *attr, char *buf)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;
+
+	return sysfs_emit(buf, "%llu\n", atomic64_read(&cma->nr_pages_failed));
+}
+CMA_ATTR_RO(alloc_pages_fail);
+
+static void cma_kobj_release(struct kobject *kobj)
+{
+	struct cma_kobject *cma_kobj = to_cma_kobject(kobj);
+	struct cma *cma = cma_kobj->cma;
+
+	kfree(cma_kobj);
+	cma->kobj = NULL;
+}
+
+static struct attribute *cma_attrs[] = {
+	&alloc_pages_success_attr.attr,
+	&alloc_pages_fail_attr.attr,
+	NULL,
+};
+ATTRIBUTE_GROUPS(cma);
+
+static struct kobject *cma_kobj_root;
+
+static struct kobj_type cma_ktype = {
+	.release = cma_kobj_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = cma_groups
+};
+
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
Quoted 8 lines

mm/cma_sysfs.c line 90

Quoted 6 lines
mm/cma_sysfs.c new file +6 -0
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

I thought kobject_put(cma_kobj_root) should deal with it. No?

Quoted 32 lines

What you might want here is a separate routine to clean up, because it has to loop through and free whatever was allocated on previous iterations of this loop here.

mm/cma_sysfs.c line 101

Quoted 11 lines
mm/cma_sysfs.c new file +11 -0
+		}
+
+		cma = &cma_areas[i];
+		cma->kobj = cma_kobj;
+		cma_kobj->cma = cma;
+		err = kobject_init_and_add(&cma_kobj->kobj, &cma_ktype,
+					   cma_kobj_root, "%s", cma->name);
+		if (err) {
+			kobject_put(&cma_kobj->kobj);
+			kobject_put(cma_kobj_root);
+			return err;

Hopefully this little bit of logic could also go into the cleanup routine.

mm/cma_sysfs.c line 107

Quoted 7 lines
mm/cma_sysfs.c new file +6 -0
+		}
+	}
+
+	return 0;
+}
+subsys_initcall(cma_sysfs_init);

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#3 lore raw

On 3/23/21 8:27 PM, Minchan Kim wrote:
...

Quoted 20 lines
Quoted 11 lines
Quoted 11 lines
mm/cma_sysfs.c new file +11 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
Quoted 8 lines

mm/cma_sysfs.c line 90

Quoted 6 lines
mm/cma_sysfs.c new file +6 -0
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#4 lore raw
Quoted 22 lines · John Hubbard

On 3/23/21 8:27 PM, Minchan Kim wrote:
...

Quoted 20 lines
Quoted 19 lines
Quoted 7 lines
(quoted diff) +7 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

Review

Quoted 10 lines
(quoted diff) +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 6 lines
Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

Oh, I misunderstood that destroying of root kobject will release children recursively. Seems not true. Go back to old version.

index 16c81c9cb9b7..418951a3f138 100644

mm/cma_sysfs.c +17 -8
@@ -80,20 +80,19 @@ static struct kobj_type cma_ktype = {
 static int __init cma_sysfs_init(void)
 {
        unsigned int i;
+       int err;
+       struct cma *cma;
+       struct cma_kobject *cma_kobj;
 
        cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
        if (!cma_kobj_root)
                return -ENOMEM;
 
        for (i = 0; i < cma_area_count; i++) {
-               int err;
-               struct cma *cma;
-               struct cma_kobject *cma_kobj;
-
                cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
                if (!cma_kobj) {
-                       kobject_put(cma_kobj_root);
-                       return -ENOMEM;
+                       err = -ENOMEM;
+                       goto out;
                }
 
                cma = &cma_areas[i];
@@ -103,11 +102,21 @@ static int __init cma_sysfs_init(void)
                                           cma_kobj_root, "%s", cma->name);
                if (err) {
                        kobject_put(&cma_kobj->kobj);
-                       kobject_put(cma_kobj_root);
-                       return err;
+                       goto out;
                }
        }
 
        return 0;
+out:
+       while (--i >= 0) {
+               cma = &cma_areas[i];
+
+               kobject_put(&cma->kobj->kobj);
+               kfree(cma->kobj);
+               cma->kobj = NULL;
+       }
+       kobject_put(cma_kobj_root);
+
+       return err;
 }
 subsys_initcall(cma_sysfs_init);
#5 lore raw
Quoted 69 lines · Minchan Kim
Quoted 22 lines · John Hubbard

On 3/23/21 8:27 PM, Minchan Kim wrote:
...

Quoted 20 lines
Quoted 19 lines
Quoted 7 lines
(quoted diff) +7 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

Review

Quoted 10 lines
(quoted diff) +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 6 lines
Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

Oh, I misunderstood that destroying of root kobject will release children recursively. Seems not true. Go back to old version.

index 16c81c9cb9b7..418951a3f138 100644

mm/cma_sysfs.c +5 -8
@@ -80,20 +80,19 @@ static struct kobj_type cma_ktype = {
  static int __init cma_sysfs_init(void)
  {
         unsigned int i;
+       int err;
+       struct cma *cma;
+       struct cma_kobject *cma_kobj;
 
         cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
         if (!cma_kobj_root)
                 return -ENOMEM;
 
         for (i = 0; i < cma_area_count; i++) {
-               int err;
-               struct cma *cma;
-               struct cma_kobject *cma_kobj;
-
                 cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
                 if (!cma_kobj) {
-                       kobject_put(cma_kobj_root);
-                       return -ENOMEM;
+                       err = -ENOMEM;
+                       goto out;
                 }
 
                 cma = &cma_areas[i];
@@ -103,11 +102,21 @@ static int __init cma_sysfs_init(void)
                                            cma_kobj_root, "%s", cma->name);
                 if (err) {
                         kobject_put(&cma_kobj->kobj);
-                       kobject_put(cma_kobj_root);
-                       return err;

mm/cma_sysfs.c static int __init cma_sysfs_init(void) · line 114

Quoted 10 lines
mm/cma_sysfs.c +6 -0
+                       goto out;
                 }
         }
 
         return 0;
+out:
+       while (--i >= 0) {
+               cma = &cma_areas[i];
+
+               kobject_put(&cma->kobj->kobj);

OK. As long as you are spinning a new version, let's fix up the naming to be a little better, too. In this case, with a mildly dizzying mix of cma's and kobjects, it actually makes a real difference. I wouldn't have asked, but the above cma->kobj->kobj chain really made it obvious for me just now.

So instead of this (in cma.h):

struct cma_kobject {
	struct cma *cma;
	struct kobject kobj;
};

struct cma {
...

	struct cma_kobject *kobj;
};

, how about approximately this:

struct cma_kobject_wrapper {
	struct cma *parent;
	struct kobject kobj;
};

struct cma {
...

	struct cma_kobject_wrapper *cma_kobj_wrapper;
};

...thus allowing readers of cma_sysfs.c to read that file more easily.

mm/cma_sysfs.c static int __init cma_sysfs_init(void) · line 122

Quoted 11 lines
mm/cma_sysfs.c +6 -0
+               kfree(cma->kobj);
+               cma->kobj = NULL;
+       }
+       kobject_put(cma_kobj_root);
+
+       return err;
  }
  subsys_initcall(cma_sysfs_init);

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#6 lore raw
Quoted 106 lines · John Hubbard
Quoted 69 lines · Minchan Kim
Quoted 22 lines · John Hubbard

On 3/23/21 8:27 PM, Minchan Kim wrote:
...

Quoted 20 lines
Quoted 19 lines
Quoted 7 lines
(quoted diff) +7 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

Review

Quoted 10 lines
(quoted diff) +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 6 lines
Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

Oh, I misunderstood that destroying of root kobject will release children recursively. Seems not true. Go back to old version.

index 16c81c9cb9b7..418951a3f138 100644

mm/cma_sysfs.c +5 -8
@@ -80,20 +80,19 @@ static struct kobj_type cma_ktype = {
  static int __init cma_sysfs_init(void)
  {
         unsigned int i;
+       int err;
+       struct cma *cma;
+       struct cma_kobject *cma_kobj;
 
         cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
         if (!cma_kobj_root)
                 return -ENOMEM;
 
         for (i = 0; i < cma_area_count; i++) {
-               int err;
-               struct cma *cma;
-               struct cma_kobject *cma_kobj;
-
                 cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
                 if (!cma_kobj) {
-                       kobject_put(cma_kobj_root);
-                       return -ENOMEM;
+                       err = -ENOMEM;
+                       goto out;
                 }
 
                 cma = &cma_areas[i];
@@ -103,11 +102,21 @@ static int __init cma_sysfs_init(void)
                                            cma_kobj_root, "%s", cma->name);
                 if (err) {
                         kobject_put(&cma_kobj->kobj);
-                       kobject_put(cma_kobj_root);
-                       return err;

mm/cma_sysfs.c static int __init cma_sysfs_init(void) · line 114

Quoted 10 lines
mm/cma_sysfs.c +6 -0
+                       goto out;
                 }
         }
 
         return 0;
+out:
+       while (--i >= 0) {
+               cma = &cma_areas[i];
+
+               kobject_put(&cma->kobj->kobj);

OK. As long as you are spinning a new version, let's fix up the naming to be a little better, too. In this case, with a mildly dizzying mix of cma's and kobjects, it actually makes a real difference. I wouldn't have asked, but the above cma->kobj->kobj chain really made it obvious for me just now.

So instead of this (in cma.h):

struct cma_kobject {
	struct cma *cma;
	struct kobject kobj;
};

struct cma {
...

	struct cma_kobject *kobj;
};

, how about approximately this:

struct cma_kobject_wrapper {
	struct cma *parent;
	struct kobject kobj;
};
Quoted 7 lines

struct cma {
...

	struct cma_kobject_wrapper *cma_kobj_wrapper;
};

...thus allowing readers of cma_sysfs.c to read that file more easily.

I agree cma->kobj->kobj is awkward but personally, I don't like the
naming: cma_kobject_wrapper parent pointer. cma_kobject is alredy wrapper so it sounds me redundant and it's not a parent in same hierarchy.

Since the kobj->kobj is just one line in the code(I don't imagine it could grow up in cma_sysfs in future), I don't think it would be a problem. If we really want to make it more clear, maybe?

cma->cma_kobj->kobj

It would be consistent with other variables in cma_sysfs_init.

#7 lore raw

On 3/23/21 11:57 PM, Minchan Kim wrote:
...

Quoted 20 lines
Quoted 7 lines

, how about approximately this:

struct cma_kobject_wrapper {
	struct cma *parent;
	struct kobject kobj;
};
Quoted 7 lines

struct cma {
...

	struct cma_kobject_wrapper *cma_kobj_wrapper;
};

...thus allowing readers of cma_sysfs.c to read that file more easily.

I agree cma->kobj->kobj is awkward but personally, I don't like the
naming: cma_kobject_wrapper parent pointer. cma_kobject is alredy wrapper so it sounds me redundant and it's not a parent in same hierarchy.

Quoted 8 lines

Since the kobj->kobj is just one line in the code(I don't imagine it could grow up in cma_sysfs in future), I don't think it would be a problem. If we really want to make it more clear, maybe?

    cma->cma_kobj->kobj

It would be consistent with other variables in cma_sysfs_init.

OK, that's at least better than it was.

thanks,

Signature · 2 lines
John Hubbard
NVIDIA
#8 lore raw
In reply to Minchan Kim

24.03.2021 08:44, Minchan Kim пишет:

Quoted 77 lines · John Hubbard
Quoted 22 lines · Minchan Kim

...

Quoted 20 lines
Quoted 19 lines
Quoted 7 lines
(quoted diff) +7 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

Review

Quoted 10 lines
(quoted diff) +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 6 lines
Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

Oh, I misunderstood that destroying of root kobject will release children recursively. Seems not true. Go back to old version.

index 16c81c9cb9b7..418951a3f138 100644

mm/cma_sysfs.c +9 -8
@@ -80,20 +80,19 @@ static struct kobj_type cma_ktype = {
 static int __init cma_sysfs_init(void)
 {
        unsigned int i;
+       int err;
+       struct cma *cma;
+       struct cma_kobject *cma_kobj;
 
        cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
        if (!cma_kobj_root)
                return -ENOMEM;
 
        for (i = 0; i < cma_area_count; i++) {
-               int err;
-               struct cma *cma;
-               struct cma_kobject *cma_kobj;
-
                cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
                if (!cma_kobj) {
-                       kobject_put(cma_kobj_root);
-                       return -ENOMEM;
+                       err = -ENOMEM;
+                       goto out;
                }
 
                cma = &cma_areas[i];
@@ -103,11 +102,21 @@ static int __init cma_sysfs_init(void)
                                           cma_kobj_root, "%s", cma->name);
                if (err) {
                        kobject_put(&cma_kobj->kobj);
-                       kobject_put(cma_kobj_root);
-                       return err;
+                       goto out;
                }
        }
 
        return 0;
+out:
+       while (--i >= 0) {
+               cma = &cma_areas[i];

mm/cma_sysfs.c static int __init cma_sysfs_init(void) · line 122

Quoted 10 lines
mm/cma_sysfs.c +8 -0
+
+               kobject_put(&cma->kobj->kobj);
+               kfree(cma->kobj);
+               cma->kobj = NULL;
+       }
+       kobject_put(cma_kobj_root);
+
+       return err;
 }
 subsys_initcall(cma_sysfs_init);

Since we don't care about the order in which kobjects are put, I'd write it in this way, which I think looks cleaner:

static void cma_sysfs_cleanup(struct kobject *cma_kobj_root)

{
	struct cma *cma = cma_areas;
	unsigned int i;

	for (i = 0; i < cma_area_count; i++, cma++) {
		if (!cma->kobj)
			break;

		kobject_put(&cma->kobj->kobj);
	}

	kobject_put(cma_kobj_root);
}

static int __init cma_sysfs_init(void)

{
	struct kobject *cma_kobj_root;
	unsigned int i;

	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
	if (!cma_kobj_root)
		return -ENOMEM;

	for (i = 0; i < cma_area_count; i++) {
		struct cma_kobject *cma_kobj;
		struct cma *cma;
		int err;

		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
		if (!cma_kobj) {
			cma_sysfs_cleanup(cma_kobj_root);
			return -ENOMEM;
		}

		cma = &cma_areas[i];
		cma->kobj = cma_kobj;
		cma_kobj->cma = cma;
		err = kobject_init_and_add(&cma_kobj->kobj, &cma_ktype,
					   cma_kobj_root, "%s", cma->name);
		if (err) {
			cma_sysfs_cleanup(cma_kobj_root);
			return err;
		}
	}

	return 0;
}

subsys_initcall(cma_sysfs_init);

#9 lore raw
Quoted 74 lines · Dmitry Osipenko

24.03.2021 08:44, Minchan Kim пишет:

Quoted 73 lines · John Hubbard
Quoted 22 lines · Minchan Kim

...

Quoted 20 lines
Quoted 19 lines
Quoted 7 lines
(quoted diff) +7 -0
+static int __init cma_sysfs_init(void)
+{
+	unsigned int i;
+
+	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
+	if (!cma_kobj_root)
+		return -ENOMEM;

Review

Quoted 10 lines
(quoted diff) +10 -0
+
+	for (i = 0; i < cma_area_count; i++) {
+		int err;
+		struct cma *cma;
+		struct cma_kobject *cma_kobj;
+
+		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
+		if (!cma_kobj) {
+			kobject_put(cma_kobj_root);
+			return -ENOMEM;

This leaks little cma_kobj's all over the floor. :)

Quoted 6 lines
Quoted 2 lines

I thought kobject_put(cma_kobj_root) should deal with it. No?

If this fails when i > 0, there will be cma_kobj instances that were stashed in the cma_areas[] array. But this code only deletes the most recently allocated cma_kobj, not anything allocated on previous iterations of the loop.

Oh, I misunderstood that destroying of root kobject will release children recursively. Seems not true. Go back to old version.

index 16c81c9cb9b7..418951a3f138 100644

mm/cma_sysfs.c +6 -8
@@ -80,20 +80,19 @@ static struct kobj_type cma_ktype = {
 static int __init cma_sysfs_init(void)
 {
        unsigned int i;
+       int err;
+       struct cma *cma;
+       struct cma_kobject *cma_kobj;
 
        cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
        if (!cma_kobj_root)
                return -ENOMEM;
 
        for (i = 0; i < cma_area_count; i++) {
-               int err;
-               struct cma *cma;
-               struct cma_kobject *cma_kobj;
-
                cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
                if (!cma_kobj) {
-                       kobject_put(cma_kobj_root);
-                       return -ENOMEM;
+                       err = -ENOMEM;
+                       goto out;
                }
 
                cma = &cma_areas[i];
@@ -103,11 +102,21 @@ static int __init cma_sysfs_init(void)
                                           cma_kobj_root, "%s", cma->name);
                if (err) {
                        kobject_put(&cma_kobj->kobj);
-                       kobject_put(cma_kobj_root);
-                       return err;
+                       goto out;
                }
        }
 
Quoted 17 lines
Quoted 4 lines
mm/cma_sysfs.c +3 -0
        return 0;
+out:
+       while (--i >= 0) {
+               cma = &cma_areas[i];

mm/cma_sysfs.c static int __init cma_sysfs_init(void) · line 122

Quoted 10 lines
mm/cma_sysfs.c +8 -0
+
+               kobject_put(&cma->kobj->kobj);
+               kfree(cma->kobj);
+               cma->kobj = NULL;
+       }
+       kobject_put(cma_kobj_root);
+
+       return err;
 }
 subsys_initcall(cma_sysfs_init);

Since we don't care about the order in which kobjects are put, I'd write it in this way, which I think looks cleaner:

Hmm, preference matter. That kinds of goto error handling for unwinding is familiar in kernel code and simple enough for me. I don't think readbility is bad enough to need another cleanup function at this moment.

Quoted 49 lines

static void cma_sysfs_cleanup(struct kobject *cma_kobj_root)

{
	struct cma *cma = cma_areas;
	unsigned int i;

	for (i = 0; i < cma_area_count; i++, cma++) {
		if (!cma->kobj)
			break;

		kobject_put(&cma->kobj->kobj);
	}

	kobject_put(cma_kobj_root);
}

static int __init cma_sysfs_init(void)

{
	struct kobject *cma_kobj_root;
	unsigned int i;

	cma_kobj_root = kobject_create_and_add("cma", mm_kobj);
	if (!cma_kobj_root)
		return -ENOMEM;

	for (i = 0; i < cma_area_count; i++) {
		struct cma_kobject *cma_kobj;
		struct cma *cma;
		int err;

		cma_kobj = kzalloc(sizeof(*cma_kobj), GFP_KERNEL);
		if (!cma_kobj) {
			cma_sysfs_cleanup(cma_kobj_root);
			return -ENOMEM;
		}

		cma = &cma_areas[i];
		cma->kobj = cma_kobj;
		cma_kobj->cma = cma;
		err = kobject_init_and_add(&cma_kobj->kobj, &cma_ktype,
					   cma_kobj_root, "%s", cma->name);
		if (err) {
			cma_sysfs_cleanup(cma_kobj_root);
			return err;
		}
	}

	return 0;
}

subsys_initcall(cma_sysfs_init);

#10 lore raw
In reply to Minchan Kim

24.03.2021 04:05, Minchan Kim пишет:

Quoted 1 line

+static struct kobject *cma_kobj_root;

This should be a local variable.

mm/cma_sysfs.c line 71

Quoted 4 lines
mm/cma_sysfs.c new file +4 -0
+static struct kobj_type cma_ktype = {
+	.release = cma_kobj_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = cma_groups

I'd add a comma to the end, for consistency.

Quoted 1 line

+};

#11 lore raw
Quoted 4 lines · Dmitry Osipenko

24.03.2021 04:05, Minchan Kim пишет:

Quoted 1 line

+static struct kobject *cma_kobj_root;

This should be a local variable.

Sure.

Quoted 7 lines

mm/cma_sysfs.c line 71

Quoted 5 lines
mm/cma_sysfs.c new file +4 -0
+static struct kobj_type cma_ktype = {
+	.release = cma_kobj_release,
+	.sysfs_ops = &kobj_sysfs_ops,
+	.default_groups = cma_groups

I'd add a comma to the end, for consistency.

Yub.