mm: cma: add some debug information for CMA

/sys/kernel/debug/cma/cma-<N>/buffers contains a list of currently allocated CMA buffers for CMA region N when CONFIG_CMA_DEBUGFS is enabled.

Format is:

<base_phys_addr> - <end_phys_addr> (<size> kB), allocated by <PID> (<comm>)
<stack backtrace when the buffer had been allocated>

Signed-off-by Stefan Strogin <[email protected]>

---
 include/linux/cma.h |   9 ++++
 mm/cma.c            |   9 ++++
 mm/cma.h            |  16 ++++++
 mm/cma_debug.c      | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 178 insertions(+), 1 deletion(-)

include/linux/cma.h +0 -0

index 9384ba6..4c2c83c 100644
@@ -28,4 +28,13 @@ extern int cma_init_reserved_mem(phys_addr_t base,
 					struct cma **res_cma);
 extern struct page *cma_alloc(struct cma *cma, int count, unsigned int align);

include/linux/cma.h +0 -0

 #endif

mm/cma.c +9 -0

index 2609e20..ed269b0 100644
@@ -34,6 +34,9 @@
 #include <linux/cma.h>
 #include <linux/highmem.h>
 #include <linux/io.h>
+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#include <linux/time.h>
 
 #include "cma.h"
 

@@ -125,6 +128,8 @@ static int __init cma_activate_area(struct cma *cma)
 #ifdef CONFIG_CMA_DEBUGFS
 	INIT_HLIST_HEAD(&cma->mem_head);
 	spin_lock_init(&cma->mem_head_lock);
+	INIT_LIST_HEAD(&cma->buffers_list);
+	mutex_init(&cma->list_lock);
 #endif
 
 	return 0;

@@ -408,6 +413,9 @@ struct page *cma_alloc(struct cma *cma, int count, unsigned int align)
 		start = bitmap_no + mask + 1;
 	}
 
+	if (page)
+		cma_buffer_list_add(cma, pfn, count);
+
 	pr_debug("%s(): returned %p\n", __func__, page);
 	return page;
 }

@@ -440,6 +448,7 @@ bool cma_release(struct cma *cma, struct page *pages, int count)
 
 	free_contig_range(pfn, count);
 	cma_clear_bitmap(cma, pfn, count);
+	cma_buffer_list_del(cma, pfn, count);
 
 	return true;
 }

mm/cma.h +16 -0

index 1132d73..98e5f79 100644
@@ -1,6 +1,8 @@
 #ifndef __MM_CMA_H__
 #define __MM_CMA_H__
 
+#include <linux/sched.h>
+
 struct cma {
 	unsigned long   base_pfn;
 	unsigned long   count;

@@ -10,9 +12,23 @@ struct cma {
 #ifdef CONFIG_CMA_DEBUGFS
 	struct hlist_head mem_head;
 	spinlock_t mem_head_lock;
+	struct list_head buffers_list;
+	struct mutex	list_lock;
 #endif
 };
 
+#ifdef CONFIG_CMA_DEBUGFS
+struct cma_buffer {
+	unsigned long pfn;
+	unsigned long count;
+	pid_t pid;
+	char comm[TASK_COMM_LEN];
+	unsigned long trace_entries[16];
+	unsigned int nr_entries;
+	struct list_head list;
+};
+#endif
+
 extern struct cma cma_areas[MAX_CMA_AREAS];
 extern unsigned cma_area_count;
 

mm/cma_debug.c +79 -0

index 7e1d325..5acd937 100644
@@ -2,6 +2,7 @@
  * CMA DebugFS Interface
  *
  * Copyright (c) 2015 Sasha Levin <[email protected]>
+ * Copyright (c) 2015 Stefan Strogin <[email protected]>
  */
 
 

@@ -10,6 +11,8 @@
 #include <linux/list.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/mm_types.h>
+#include <linux/stacktrace.h>
 
 #include "cma.h"
 

@@ -21,6 +24,99 @@ struct cma_mem {
 
 static struct dentry *cma_debugfs_root;
 
+/* Must be called under cma->list_lock */
+static int __cma_buffer_list_add(struct cma *cma, unsigned long pfn, int count)
+{
+	struct cma_buffer *cmabuf;
+	struct stack_trace trace;
+
+	cmabuf = kmalloc(sizeof(*cmabuf), GFP_KERNEL);
+	if (!cmabuf) {
+		pr_warn("%s(page %p, count %d): failed to allocate buffer list entry\n",
+			__func__, pfn_to_page(pfn), count);
+		return -ENOMEM;
+	}
+
+	trace.nr_entries = 0;
+	trace.max_entries = ARRAY_SIZE(cmabuf->trace_entries);
+	trace.entries = &cmabuf->trace_entries[0];
+	trace.skip = 2;
+	save_stack_trace(&trace);
+
+	cmabuf->pfn = pfn;
+	cmabuf->count = count;
+	cmabuf->pid = task_pid_nr(current);
+	cmabuf->nr_entries = trace.nr_entries;
+	get_task_comm(cmabuf->comm, current);
+
+	list_add_tail(&cmabuf->list, &cma->buffers_list);
+
+	return 0;
+}
+
+/**
+ * cma_buffer_list_add() - add a new entry to a list of allocated buffers
+ * @cma:     Contiguous memory region for which the allocation is performed.
+ * @pfn:     Base PFN of the allocated buffer.
+ * @count:   Number of allocated pages.
+ *
+ * This function adds a new entry to the list of allocated contiguous memory
+ * buffers in a CMA area. It uses the CMA area specificated by the device
+ * if available or the default global one otherwise.
+ */
+int cma_buffer_list_add(struct cma *cma, unsigned long pfn, int count)
+{
+	int ret;
+
+	mutex_lock(&cma->list_lock);
+	ret = __cma_buffer_list_add(cma, pfn, count);
+	mutex_unlock(&cma->list_lock);
+
+	return ret;
+}
+
+/**
+ * cma_buffer_list_del() - delete an entry from a list of allocated buffers
+ * @cma:   Contiguous memory region for which the allocation was performed.
+ * @pfn:   Base PFN of the released buffer.
+ * @count: Number of pages.
+ *
+ * This function deletes a list entry added by cma_buffer_list_add().
+ */
+void cma_buffer_list_del(struct cma *cma, unsigned long pfn, int count)
+{
+	struct cma_buffer *cmabuf, *tmp;
+	int found = 0;
+	unsigned long buf_end_pfn, free_end_pfn = pfn + count;
+
+	mutex_lock(&cma->list_lock);
+	list_for_each_entry_safe(cmabuf, tmp, &cma->buffers_list, list) {
+
+		buf_end_pfn = cmabuf->pfn + cmabuf->count;
+		if (pfn <= cmabuf->pfn && free_end_pfn >= buf_end_pfn) {
+			list_del(&cmabuf->list);
+			kfree(cmabuf);
+			found = 1;
+		} else if (pfn <= cmabuf->pfn && free_end_pfn < buf_end_pfn) {
+			cmabuf->count -= free_end_pfn - cmabuf->pfn;
+			cmabuf->pfn = free_end_pfn;

On Fri, Feb 13, 2015 at 01:15:41AM +0300, Stefan Strogin wrote:

This linear searching make cma_release() slow if we have many allocated cma buffers. It wouldn't cause any problem?

Thanks.

Quoted 7 lines

include/linux/cma.h +3 -0

@@ -28,4 +28,13 @@ extern int cma_init_reserved_mem(phys_addr_t base,
 					struct cma **res_cma);
 extern struct page *cma_alloc(struct cma *cma, int count, unsigned int align);
 extern bool cma_release(struct cma *cma, struct page *pages, int count);
+
+#ifdef CONFIG_CMA_DEBUGFS
+extern int cma_buffer_list_add(struct cma *cma, unsigned long pfn, int count);

include/linux/cma.h extern int cma_init_reserved_mem(phys_addr_t base, · line 39

Quoted 6 lines

include/linux/cma.h +6 -0

+extern void cma_buffer_list_del(struct cma *cma, unsigned long pfn, int count);
+#else
+#define cma_buffer_list_add(cma, pfn, count) { }
+#define cma_buffer_list_del(cma, pfn, count) { }
+#endif
+

These could be in mm/cma.h rather than include/linux/cma.h.

static int cma_debugfs_get(void *data, u64 *val)
{

mm/cma_debug.c +5 -0

 	unsigned long *p = data;

@@ -125,6 +221,52 @@ static int cma_alloc_write(void *data, u64 val)
 
 DEFINE_SIMPLE_ATTRIBUTE(cma_alloc_fops, NULL, cma_alloc_write, "%llu\n");
 
+static int cma_buffers_read(struct file *file, char __user *userbuf,
+				size_t count, loff_t *ppos)
+{
+	struct cma *cma = file->private_data;
+	struct cma_buffer *cmabuf;

Quoted 12 lines · Stefan Strogin

static int cma_debugfs_get(void *data, u64 *val)
{

mm/cma_debug.c +5 -0

 	unsigned long *p = data;

@@ -125,6 +221,52 @@ static int cma_alloc_write(void *data, u64 val)
 
 DEFINE_SIMPLE_ATTRIBUTE(cma_alloc_fops, NULL, cma_alloc_write, "%llu\n");
 
+static int cma_buffers_read(struct file *file, char __user *userbuf,
+				size_t count, loff_t *ppos)
+{
+	struct cma *cma = file->private_data;
+	struct cma_buffer *cmabuf;

mm/cma_debug.c static int cma_alloc_write(void *data, u64 val) · line 238

Quoted 10 lines

mm/cma_debug.c +10 -0

+	struct stack_trace trace;
+	char *buf;
+	int ret, n = 0;
+
+	if (*ppos < 0 || !count)
+		return -EINVAL;
+
+	buf = kmalloc(count, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;

Is count limited within proper size boundary for kmalloc()? If it can exceed page size, using vmalloc() is better than this.

Thanks.

/sys/kernel/debug/cma/cma-<N>/buffers contains a list of currently allocated CMA buffers for CMA region N when CONFIG_CMA_DEBUGFS is enabled.

Format is:

<base_phys_addr> - <end_phys_addr> (<size> kB), allocated by <PID> (<comm>) <stack backtrace when the buffer had been allocated>

Signed-off-by Stefan Strogin <[email protected]>

---

include/linux/cma.h |   9 ++++
mm/cma.c            |   9 ++++
mm/cma.h            |  16 ++++++
mm/cma_debug.c      | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++-
4 files changed, 178 insertions(+), 1 deletion(-)

include/linux/cma.h +9 -0

index 9384ba6..4c2c83c 100644
@@ -28,4 +28,13 @@ extern int cma_init_reserved_mem(phys_addr_t base,
 					struct cma **res_cma);
 extern struct page *cma_alloc(struct cma *cma, int count, unsigned int align);
 extern bool cma_release(struct cma *cma, struct page *pages, int count);
+
+#ifdef CONFIG_CMA_DEBUGFS
+extern int cma_buffer_list_add(struct cma *cma, unsigned long pfn, int count);
+extern void cma_buffer_list_del(struct cma *cma, unsigned long pfn, int count);
+#else
+#define cma_buffer_list_add(cma, pfn, count) { }
+#define cma_buffer_list_del(cma, pfn, count) { }
+#endif
+
 #endif

mm/cma.c +0 -0

index 2609e20..ed269b0 100644

mm/cma.c +6 -0

 #include "cma.h"
 

@@ -125,6 +128,8 @@ static int __init cma_activate_area(struct cma *cma)
 #ifdef CONFIG_CMA_DEBUGFS
 	INIT_HLIST_HEAD(&cma->mem_head);
 	spin_lock_init(&cma->mem_head_lock);
+	INIT_LIST_HEAD(&cma->buffers_list);
+	mutex_init(&cma->list_lock);
 #endif
 
 	return 0;

@@ -408,6 +413,9 @@ struct page *cma_alloc(struct cma *cma, int count, unsigned int align)
 		start = bitmap_no + mask + 1;
 	}
 
+	if (page)
+		cma_buffer_list_add(cma, pfn, count);
+
 	pr_debug("%s(): returned %p\n", __func__, page);
 	return page;
 }

@@ -440,6 +448,7 @@ bool cma_release(struct cma *cma, struct page *pages, int count)
 
 	free_contig_range(pfn, count);
 	cma_clear_bitmap(cma, pfn, count);
+	cma_buffer_list_del(cma, pfn, count);
 
 	return true;
 }

mm/cma.h +16 -0

index 1132d73..98e5f79 100644
@@ -1,6 +1,8 @@
 #ifndef __MM_CMA_H__
 #define __MM_CMA_H__
 
+#include <linux/sched.h>
+
 struct cma {
 	unsigned long   base_pfn;
 	unsigned long   count;

@@ -10,9 +12,23 @@ struct cma {
 #ifdef CONFIG_CMA_DEBUGFS
 	struct hlist_head mem_head;
 	spinlock_t mem_head_lock;
+	struct list_head buffers_list;
+	struct mutex	list_lock;
 #endif
 };
 
+#ifdef CONFIG_CMA_DEBUGFS
+struct cma_buffer {
+	unsigned long pfn;
+	unsigned long count;
+	pid_t pid;
+	char comm[TASK_COMM_LEN];
+	unsigned long trace_entries[16];
+	unsigned int nr_entries;
+	struct list_head list;
+};
+#endif
+
 extern struct cma cma_areas[MAX_CMA_AREAS];
 extern unsigned cma_area_count;
 

mm/cma_debug.c +3 -0

index 7e1d325..5acd937 100644
@@ -2,6 +2,7 @@
 * CMA DebugFS Interface
 *
 * Copyright (c) 2015 Sasha Levin <[email protected]>
+ * Copyright (c) 2015 Stefan Strogin <[email protected]>
 */
 
 

@@ -10,6 +11,8 @@
 #include <linux/list.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
+#include <linux/mm_types.h>
+#include <linux/stacktrace.h>
 
 #include "cma.h"
 

@@ -21,6 +24,99 @@ struct cma_mem {
 
 static struct dentry *cma_debugfs_root;
 

mm/cma_debug.c +131 -1

+		return -ENOMEM;
+	}
+
+	trace.nr_entries = 0;
+	trace.max_entries = ARRAY_SIZE(cmabuf->trace_entries);
+	trace.entries = &cmabuf->trace_entries[0];
+	trace.skip = 2;
+	save_stack_trace(&trace);
+
+	cmabuf->pfn = pfn;
+	cmabuf->count = count;
+	cmabuf->pid = task_pid_nr(current);
+	cmabuf->nr_entries = trace.nr_entries;
+	get_task_comm(cmabuf->comm, current);
+
+	list_add_tail(&cmabuf->list, &cma->buffers_list);
+
+	return 0;
+}
+
+/**
+ * cma_buffer_list_add() - add a new entry to a list of allocated buffers
+ * @cma:     Contiguous memory region for which the allocation is performed.
+ * @pfn:     Base PFN of the allocated buffer.
+ * @count:   Number of allocated pages.
+ *
+ * This function adds a new entry to the list of allocated contiguous memory
+ * buffers in a CMA area. It uses the CMA area specificated by the device
+ * if available or the default global one otherwise.
+ */
+int cma_buffer_list_add(struct cma *cma, unsigned long pfn, int count)
+{
+	int ret;
+
+	mutex_lock(&cma->list_lock);
+	ret = __cma_buffer_list_add(cma, pfn, count);
+	mutex_unlock(&cma->list_lock);
+
+	return ret;
+}
+
+/**
+ * cma_buffer_list_del() - delete an entry from a list of allocated buffers
+ * @cma:   Contiguous memory region for which the allocation was performed.
+ * @pfn:   Base PFN of the released buffer.
+ * @count: Number of pages.
+ *
+ * This function deletes a list entry added by cma_buffer_list_add().
+ */
+void cma_buffer_list_del(struct cma *cma, unsigned long pfn, int count)
+{
+	struct cma_buffer *cmabuf, *tmp;
+	int found = 0;
+	unsigned long buf_end_pfn, free_end_pfn = pfn + count;
+
+	mutex_lock(&cma->list_lock);
+	list_for_each_entry_safe(cmabuf, tmp, &cma->buffers_list, list) {
+
+		buf_end_pfn = cmabuf->pfn + cmabuf->count;
+		if (pfn <= cmabuf->pfn && free_end_pfn >= buf_end_pfn) {
+			list_del(&cmabuf->list);
+			kfree(cmabuf);
+			found = 1;
+		} else if (pfn <= cmabuf->pfn && free_end_pfn < buf_end_pfn) {
+			cmabuf->count -= free_end_pfn - cmabuf->pfn;
+			cmabuf->pfn = free_end_pfn;
+			found = 1;
+		} else if (pfn > cmabuf->pfn && pfn < buf_end_pfn) {
+			if (free_end_pfn < buf_end_pfn)
+				__cma_buffer_list_add(cma, free_end_pfn,
+						buf_end_pfn - free_end_pfn);
+			cmabuf->count = pfn - cmabuf->pfn;
+			found = 1;
+		}
+	}
+	mutex_unlock(&cma->list_lock);
+
+	if (!found)
+		pr_err("%s(page %p, count %d): couldn't find buffer list entry\n",
+		       __func__, pfn_to_page(pfn), count);
+
+}
+
 static int cma_debugfs_get(void *data, u64 *val)
 {
 	unsigned long *p = data;

@@ -125,6 +221,52 @@ static int cma_alloc_write(void *data, u64 val)
 
 DEFINE_SIMPLE_ATTRIBUTE(cma_alloc_fops, NULL, cma_alloc_write, "%llu\n");
 
+static int cma_buffers_read(struct file *file, char __user *userbuf,
+				size_t count, loff_t *ppos)
+{
+	struct cma *cma = file->private_data;
+	struct cma_buffer *cmabuf;
+	struct stack_trace trace;
+	char *buf;
+	int ret, n = 0;
+
+	if (*ppos < 0 || !count)
+		return -EINVAL;
+
+	buf = kmalloc(count, GFP_KERNEL);
+	if (!buf)
+		return -ENOMEM;
+
+	mutex_lock(&cma->list_lock);
+	list_for_each_entry(cmabuf, &cma->buffers_list, list) {
+		n += snprintf(buf + n, count - n,
+			      "0x%llx - 0x%llx (%lu kB), allocated by pid %u (%s)\n",
+			      (unsigned long long)PFN_PHYS(cmabuf->pfn),
+			      (unsigned long long)PFN_PHYS(cmabuf->pfn +
+				      cmabuf->count),
+			      (cmabuf->count * PAGE_SIZE) >> 10, cmabuf->pid,
+			      cmabuf->comm);
+
+		trace.nr_entries = cmabuf->nr_entries;
+		trace.entries = &cmabuf->trace_entries[0];
+
+		n += snprint_stack_trace(buf + n, count - n, &trace, 0);
+		n += snprintf(buf + n, count - n, "\n");
+	}
+	mutex_unlock(&cma->list_lock);
+
+	ret = simple_read_from_buffer(userbuf, count, ppos, buf, n);
+	kfree(buf);
+
+	return ret;
+}
+
+static const struct file_operations cma_buffers_fops = {
+	.open = simple_open,
+	.read = cma_buffers_read,
+	.llseek = default_llseek,
+};
+
 static void cma_debugfs_add_one(struct cma *cma, int idx)
 {
 	struct dentry *tmp;

@@ -148,6 +290,8 @@ static void cma_debugfs_add_one(struct cma *cma, int idx)
 	debugfs_create_file("order_per_bit", S_IRUGO, tmp,
 				&cma->order_per_bit, &cma_debugfs_fops);
 
+	debugfs_create_file("buffers", S_IRUGO, tmp, cma, &cma_buffers_fops);
+
 	u32s = DIV_ROUND_UP(cma_bitmap_maxno(cma), BITS_PER_BYTE * sizeof(u32));
 	debugfs_create_u32_array("bitmap", S_IRUGO, tmp, (u32*)cma->bitmap, u32s);
 }

@@ -166,4 +310,3 @@ static int __init cma_debugfs_init(void)
 	return 0;
 }
 late_initcall(cma_debugfs_init);
-

Signature · 1 line

2.1.0

Hello, Stefan.

mm/cma.c line 39

Quoted 4 lines · Stefan Strogin

#include <linux/io.h>

mm/cma.c +3 -0

+#include <linux/list.h>
+#include <linux/proc_fs.h>
+#include <linux/time.h>

Looks like proc_fs.h and time.h are not necessary.

Quoted 3 lines

+ pr_warn("%s(page %p, count %d): failed to allocate buffer
list entry\n",
+ __func__, pfn_to_page(pfn), count);

pfn_to_page() would cause build failure on x86_64. Why don't you include appropriate header file?

From: Dmitry Safonov <[email protected]>

Here are two functions that provide interface to compute/get used size and size of biggest free chunk in cma region.
Add that information to debugfs.

Signed-off-by Dmitry Safonov <[email protected]>

Signed-off-by Stefan Strogin <[email protected]>

---
 include/linux/cma.h |  2 ++
 mm/cma.c            | 30 ++++++++++++++++++++++++++++++
 mm/cma_debug.c      | 24 ++++++++++++++++++++++++
 3 files changed, 56 insertions(+)

include/linux/cma.h +2 -0

index 4c2c83c..54a2c4d 100644
@@ -18,6 +18,8 @@ struct cma;
 extern unsigned long totalcma_pages;
 extern phys_addr_t cma_get_base(struct cma *cma);
 extern unsigned long cma_get_size(struct cma *cma);
+extern unsigned long cma_get_used(struct cma *cma);
+extern unsigned long cma_get_maxchunk(struct cma *cma);
 
 extern int __init cma_declare_contiguous(phys_addr_t base,
 			phys_addr_t size, phys_addr_t limit,

mm/cma.c +1 -0

index ed269b0..95e8121 100644
@@ -54,6 +54,36 @@ unsigned long cma_get_size(struct cma *cma)
 	return cma->count << PAGE_SHIFT;
 }
 
+unsigned long cma_get_used(struct cma *cma)

mm/cma.c +9 -0

+
+unsigned long cma_get_maxchunk(struct cma *cma)
+{
+	unsigned long maxchunk = 0;
+	unsigned long start, end = 0;
+
+	mutex_lock(&cma->lock);
+	for (;;) {
+		start = find_next_zero_bit(cma->bitmap, cma->count, end);

From: Dmitry Safonov <[email protected]>

Here are two functions that provide interface to compute/get used size and size of biggest free chunk in cma region.

2015-02-13 오전 7:15에 Stefan Strogin 이(가) 쓴 글:

Quoted 4 lines

From: Dmitry Safonov <[email protected]>

Here are two functions that provide interface to compute/get used size and size of biggest free chunk in cma region.

I usually just try to allocate memory, not check free size before try, becuase free size can be changed after I check it.

Could you tell me why biggest free chunk size is necessary?

Hi all.

Sorry for the long delay. Here is the second attempt to add some facility for debugging CMA (the first one was "mm: cma: add /proc/cmainfo" [1]).

This patch set is based on v3.19 and Sasha Levin's patch set "mm: cma: debugfs access to CMA" [2].
It is also available on git:
git://github.com/stefanstrogin/cmainfo -b cmainfo-v2

We want an interface to see a list of currently allocated CMA buffers and some useful information about them (like /proc/vmallocinfo but for physically contiguous buffers allocated with CMA).

Here is an example use case when we need it. We want a big (megabytes) CMA buffer to be allocated in runtime in default CMA region. If someone already uses CMA then the big allocation can fail. If it happens then with such an interface we could find who used CMA at the moment of failure, who caused fragmentation (possibly ftrace also would be helpful here) and so on.

These patches add some files to debugfs when CONFIG_CMA_DEBUGFS is enabled.

/sys/kernel/debug/cma/cma-<N>/buffers contains a list of currently allocated CMA buffers for each CMA region. Stacktrace saved at the moment of allocation is used to see who and whence allocated each buffer [3].

cma/cma-<N>/used and cma/cma-<N>/maxchunk are added to show used size and the biggest free chunk in each CMA region.

Also added trace events for cma_alloc() and cma_release().

Changes from "mm: cma: add /proc/cmainfo" [1]:
- Rebased on v3.19 and Sasha Levin's patch set [2].
- Moved debug code from cma.c to cma_debug.c.
- Moved cmainfo to debugfs and splited it by CMA region.
- Splited 'cmainfo' into 'buffers', 'used' and 'maxchunk'.
- Used CONFIG_CMA_DEBUGFS instead of CONFIG_CMA_DEBUG.
- Added trace events for cma_alloc() and cma_release().
- Don't use seq_files.
- A small change of debug output in cma_release().
- cma_buffer_list_del() now supports releasing chunks which ranges don't match allocations. E.g. we have buffer1: [0x0, 0x1], buffer2: [0x2, 0x3], then cma_buffer_list_del(cma, 0x1 /*or 0x0*/, 1 /*(or 2 or 3)*/) should work.
- Various small changes.

[1] https://lkml.org/lkml/2014/12/26/95

[2] https://lkml.org/lkml/2015/1/28/755

[3] E.g.

root@debian:/sys/kernel/debug/cma# cat cma-0/buffers
0x2f400000 - 0x2f417000 (92 kB), allocated by pid 1 (swapper/0)
 [<c1142c4b>] cma_alloc+0x1bb/0x200
 [<c143d28a>] dma_alloc_from_contiguous+0x3a/0x40
 [<c10079d9>] dma_generic_alloc_coherent+0x89/0x160
 [<c14456ce>] dmam_alloc_coherent+0xbe/0x100
 [<c1487312>] ahci_port_start+0xe2/0x210
 [<c146e0e0>] ata_host_start.part.28+0xc0/0x1a0
 [<c1473650>] ata_host_activate+0xd0/0x110
 [<c14881bf>] ahci_host_activate+0x3f/0x170
 [<c14854e4>] ahci_init_one+0x764/0xab0
 [<c12e415f>] pci_device_probe+0x6f/0xd0
 [<c14378a8>] driver_probe_device+0x68/0x210
 [<c1437b09>] __driver_attach+0x79/0x80
 [<c1435eef>] bus_for_each_dev+0x4f/0x80
 [<c143749e>] driver_attach+0x1e/0x20
 [<c1437197>] bus_add_driver+0x157/0x200
 [<c14381bd>] driver_register+0x5d/0xf0
<...> 
0x2f41b000 - 0x2f41c000 (4 kB), allocated by pid 1264 (NetworkManager)
 [<c1142c4b>] cma_alloc+0x1bb/0x200
 [<c143d28a>] dma_alloc_from_contiguous+0x3a/0x40
 [<c10079d9>] dma_generic_alloc_coherent+0x89/0x160
 [<c14c5d13>] e1000_setup_all_tx_resources+0x93/0x540
 [<c14c8021>] e1000_open+0x31/0x120
 [<c16264cf>] __dev_open+0x9f/0x130
 [<c16267ce>] __dev_change_flags+0x8e/0x150
 [<c16268b8>] dev_change_flags+0x28/0x60
 [<c1633ee0>] do_setlink+0x2a0/0x760
 [<c1634acb>] rtnl_newlink+0x60b/0x7b0
 [<c16314f4>] rtnetlink_rcv_msg+0x84/0x1f0
 [<c164b58e>] netlink_rcv_skb+0x8e/0xb0
 [<c1631461>] rtnetlink_rcv+0x21/0x30
 [<c164af7a>] netlink_unicast+0x13a/0x1d0
 [<c164b250>] netlink_sendmsg+0x240/0x3e0
 [<c160cbfd>] do_sock_sendmsg+0xbd/0xe0
<...>

Dmitry Safonov (1):
mm: cma: add functions to get region pages counters

Stefan Strogin (3):
mm: cma: add currently allocated CMA buffers list to debugfs
mm: cma: add number of pages to debug message in cma_release()
mm: cma: add trace events to debug physically-contiguous memory
allocations

 include/linux/cma.h        |  11 +++
 include/trace/events/cma.h |  57 +++++++++++++++
 mm/cma.c                   |  46 +++++++++++-
 mm/cma.h                   |  16 +++++
 mm/cma_debug.c             | 169 ++++++++++++++++++++++++++++++++++++++++++++-
 5 files changed, 297 insertions(+), 2 deletions(-)
 create mode 100644 include/trace/events/cma.h

Signature · 7 lines

2.1.0

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

Quoted 14 lines

Hi all.

Sorry for the long delay. Here is the second attempt to add some facility for debugging CMA (the first one was "mm: cma: add /proc/cmainfo" [1]).

This patch set is based on v3.19 and Sasha Levin's patch set "mm: cma: debugfs access to CMA" [2].
It is also available on git:
git://github.com/stefanstrogin/cmainfo -b cmainfo-v2

We want an interface to see a list of currently allocated CMA buffers and some useful information about them (like /proc/vmallocinfo but for physically contiguous buffers allocated with CMA).

Quoted 5 lines

Here is an example use case when we need it. We want a big (megabytes) CMA buffer to be allocated in runtime in default CMA region. If someone already uses CMA then the big allocation can fail. If it happens then with such an interface we could find who used CMA at the moment of failure, who caused fragmentation (possibly ftrace also would be helpful here) and so on.

Hello,

So, I'm not sure that information about allocated CMA buffer is really needed to solve your problem. You just want to know who uses default CMA region and you can know it by adding tracepoint in your 4/4 patch. We really need this custom allocation tracer? What can we do more with this custom tracer to solve your problem? Could you more specific about your problem and how to solve it by using this custom tracer?

Quoted 1 line

Quoted 1 line

These patches add some files to debugfs when CONFIG_CMA_DEBUGFS is enabled.

If this tracer is justifiable, I think that making it conditional is better than just enabling always on CONFIG_CMA_DEBUGFS. Some users don't want to this feature although they enable CONFIG_CMA_DEBUGFS.

Thanks.

Quoted 7 lines

If this tracer is justifiable, I think that making it conditional is better than just enabling always on CONFIG_CMA_DEBUGFS. Some users don't want to this feature although they enable CONFIG_CMA_DEBUGFS.

Thanks.

Hello,

Thanks for your work. It must be helpful to me.

What about add another option to activate stack-trace?
In my platform I know all devices using cma area, so I usually don't need stack-trace.

Hello Gioh,

Thank you for your answer.

Quoted 12 lines · Gioh Kim

Quoted 7 lines

If this tracer is justifiable, I think that making it conditional is better than just enabling always on CONFIG_CMA_DEBUGFS. Some users don't want to this feature although they enable CONFIG_CMA_DEBUGFS.

Thanks.

Hello,

Thanks for your work. It must be helpful to me.

Quoted 4 lines

What about add another option to activate stack-trace?
In my platform I know all devices using cma area, so I usually don't need stack-trace.

So Joonsoo suggests to add an option for buffer list, and you suggest to add another in addition to the first one (and also add CONFIG_STACKTRACE to dependences) right?

Quoted 6 lines · Stefan Strogin

Here is an example use case when we need it. We want a big (megabytes) CMA buffer to be allocated in runtime in default CMA region. If someone already uses CMA then the big allocation can fail. If it happens then with such an interface we could find who used CMA at the moment of failure, who caused fragmentation (possibly ftrace also would be helpful here) and so on.

Hello,

So, I'm not sure that information about allocated CMA buffer is really needed to solve your problem. You just want to know who uses default CMA region and you can know it by adding tracepoint in your 4/4 patch. We really need this custom allocation tracer? What can we do more with this custom tracer to solve your problem? Could you more specific about your problem and how to solve it by using this custom tracer?

Quoted 2 lines

These patches add some files to debugfs when CONFIG_CMA_DEBUGFS is enabled.

If this tracer is justifiable, I think that making it conditional is better than just enabling always on CONFIG_CMA_DEBUGFS. Some users don't want to this feature although they enable CONFIG_CMA_DEBUGFS.

Thanks.