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]>
Acked-by: Michal Nazarewicz <[email protected]>
---
Took out from the patch set "mm: cma: add some debug information for CMA" v4
(http://thread.gmane.org/gmane.linux.kernel.mm/129903) because of probable
uselessness of the most part of the set.
include/linux/cma.h | 2 ++
mm/cma.c | 30 ++++++++++++++++++++++++++++++
mm/cma_debug.c | 24 ++++++++++++++++++++++++
3 files changed, 56 insertions(+)
diff --git a/include/linux/cma.h b/include/linux/cma.h
index f7ef093..1231f50 100644
--- a/include/linux/cma.h
+++ b/include/linux/cma.h
@@ -18,6 +18,8 @@ struct cma;
extern unsigned long totalcma_pages;
extern phys_addr_t cma_get_base(const struct cma *cma);
extern unsigned long cma_get_size(const 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,
diff --git a/mm/cma.c b/mm/cma.c
index 3a7a67b..d839011 100644
--- a/mm/cma.c
+++ b/mm/cma.c
@@ -53,6 +53,36 @@ unsigned long cma_get_size(const struct cma *cma)
return cma->count << PAGE_SHIFT;
}
+unsigned long cma_get_used(struct cma *cma)
+{
+ unsigned long ret = 0;
+
+ mutex_lock(&cma->lock);
+ /* pages counter is smaller than sizeof(int) */
+ ret = bitmap_weight(cma->bitmap, (int)cma->count);
+ mutex_unlock(&cma->lock);
+
+ return ret << cma->order_per_bit;
+}
+
+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);
+ if (start >= cma->count)
+ break;
+ end = find_next_bit(cma->bitmap, cma->count, start);
+ maxchunk = max(end - start, maxchunk);
+ }
+ mutex_unlock(&cma->lock);
+
+ return maxchunk << cma->order_per_bit;
+}
+
static unsigned long cma_bitmap_aligned_mask(const struct cma *cma,
int align_order)
{
diff --git a/mm/cma_debug.c b/mm/cma_debug.c
index ec915e6..984cedd 100644
--- a/mm/cma_debug.c
+++ b/mm/cma_debug.c
@@ -33,6 +33,28 @@ static int cma_debugfs_get(void *data, u64 *val)
DEFINE_SIMPLE_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");
+static int cma_used_get(void *data, u64 *val)
+{
+ struct cma *cma = data;
+
+ *val = cma_get_used(cma);
+
+ return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(cma_used_fops, cma_used_get, NULL, "%llu\n");
+
+static int cma_maxchunk_get(void *data, u64 *val)
+{
+ struct cma *cma = data;
+
+ *val = cma_get_maxchunk(cma);
+
+ return 0;
+}
+
+DEFINE_SIMPLE_ATTRIBUTE(cma_maxchunk_fops, cma_maxchunk_get, NULL, "%llu\n");
+
static void cma_add_to_cma_mem_list(struct cma *cma, struct cma_mem *mem)
{
spin_lock(&cma->mem_head_lock);
@@ -149,6 +171,8 @@ static void cma_debugfs_add_one(struct cma *cma, int idx)
&cma->count, &cma_debugfs_fops);
debugfs_create_file("order_per_bit", S_IRUGO, tmp,
&cma->order_per_bit, &cma_debugfs_fops);
+ debugfs_create_file("used", S_IRUGO, tmp, cma, &cma_used_fops);
+ debugfs_create_file("maxchunk", S_IRUGO, tmp, cma, &cma_maxchunk_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);
--
2.1.0
On Fri, 03 Apr 2015 15:42:40 +0300 Stefan Strogin <[email protected]> wrote:
> 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.
>
> ...
>
> --- a/mm/cma.c
> +++ b/mm/cma.c
> @@ -53,6 +53,36 @@ unsigned long cma_get_size(const struct cma *cma)
> return cma->count << PAGE_SHIFT;
> }
>
> +unsigned long cma_get_used(struct cma *cma)
> +{
> + unsigned long ret = 0;
> +
> + mutex_lock(&cma->lock);
> + /* pages counter is smaller than sizeof(int) */
> + ret = bitmap_weight(cma->bitmap, (int)cma->count);
> + mutex_unlock(&cma->lock);
> +
> + return ret << cma->order_per_bit;
> +}
> +
> +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);
> + if (start >= cma->count)
> + break;
> + end = find_next_bit(cma->bitmap, cma->count, start);
> + maxchunk = max(end - start, maxchunk);
> + }
> + mutex_unlock(&cma->lock);
> +
> + return maxchunk << cma->order_per_bit;
> +}
This will cause unused code to be included in cma.o when
CONFIG_CMA_DEBUGFS=n. Please review the below patch which moves it all
into cma_debug.c
> --- a/mm/cma_debug.c
> +++ b/mm/cma_debug.c
> @@ -33,6 +33,28 @@ static int cma_debugfs_get(void *data, u64 *val)
>
> DEFINE_SIMPLE_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");
>
> +static int cma_used_get(void *data, u64 *val)
> +{
> + struct cma *cma = data;
> +
> + *val = cma_get_used(cma);
> +
> + return 0;
> +}
We have cma_used_get() and cma_get_used(). Confusing! Can we think of
better names for one or both of them?
From: Andrew Morton <[email protected]>
Subject: mm-cma-add-functions-to-get-region-pages-counters-fix
move debug code from cma.c into cma_debug.c so it doesn't get included in
CONFIG_CMA_DEBUGFS=n builds
Cc: Dmitry Safonov <[email protected]>
Cc: Michal Nazarewicz <[email protected]>
Cc: Stefan Strogin <[email protected]>
Cc: Marek Szyprowski <[email protected]>
Cc: Joonsoo Kim <[email protected]>
Cc: Pintu Kumar <[email protected]>
Cc: Weijie Yang <[email protected]>
Cc: Laurent Pinchart <[email protected]>
Cc: Vyacheslav Tyrtov <[email protected]>
Cc: Aleksei Mateosian <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
---
include/linux/cma.h | 2 --
mm/cma.c | 30 ------------------------------
mm/cma_debug.c | 31 +++++++++++++++++++++++++++++++
3 files changed, 31 insertions(+), 32 deletions(-)
diff -puN include/linux/cma.h~mm-cma-add-functions-to-get-region-pages-counters-fix include/linux/cma.h
--- a/include/linux/cma.h~mm-cma-add-functions-to-get-region-pages-counters-fix
+++ a/include/linux/cma.h
@@ -18,8 +18,6 @@ struct cma;
extern unsigned long totalcma_pages;
extern phys_addr_t cma_get_base(const struct cma *cma);
extern unsigned long cma_get_size(const 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,
diff -puN mm/cma.c~mm-cma-add-functions-to-get-region-pages-counters-fix mm/cma.c
--- a/mm/cma.c~mm-cma-add-functions-to-get-region-pages-counters-fix
+++ a/mm/cma.c
@@ -53,36 +53,6 @@ unsigned long cma_get_size(const struct
return cma->count << PAGE_SHIFT;
}
-unsigned long cma_get_used(struct cma *cma)
-{
- unsigned long ret = 0;
-
- mutex_lock(&cma->lock);
- /* pages counter is smaller than sizeof(int) */
- ret = bitmap_weight(cma->bitmap, (int)cma->count);
- mutex_unlock(&cma->lock);
-
- return ret << cma->order_per_bit;
-}
-
-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);
- if (start >= cma->count)
- break;
- end = find_next_bit(cma->bitmap, cma->count, start);
- maxchunk = max(end - start, maxchunk);
- }
- mutex_unlock(&cma->lock);
-
- return maxchunk << cma->order_per_bit;
-}
-
static unsigned long cma_bitmap_aligned_mask(const struct cma *cma,
int align_order)
{
diff -puN mm/cma_debug.c~mm-cma-add-functions-to-get-region-pages-counters-fix mm/cma_debug.c
--- a/mm/cma_debug.c~mm-cma-add-functions-to-get-region-pages-counters-fix
+++ a/mm/cma_debug.c
@@ -22,6 +22,37 @@ struct cma_mem {
static struct dentry *cma_debugfs_root;
+static unsigned long cma_get_used(struct cma *cma)
+{
+ unsigned long ret = 0;
+
+ mutex_lock(&cma->lock);
+ /* pages counter is smaller than sizeof(int) */
+ ret = bitmap_weight(cma->bitmap, (int)cma->count);
+ mutex_unlock(&cma->lock);
+
+ return ret << cma->order_per_bit;
+}
+
+static 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);
+ if (start >= cma->count)
+ break;
+ end = find_next_bit(cma->bitmap, cma->count, start);
+ maxchunk = max(end - start, maxchunk);
+ }
+ mutex_unlock(&cma->lock);
+
+ return maxchunk << cma->order_per_bit;
+}
+
+
static int cma_debugfs_get(void *data, u64 *val)
{
unsigned long *p = data;
_
Hello Andrew,
On 04/04/15 00:58, Andrew Morton wrote:
> On Fri, 03 Apr 2015 15:42:40 +0300 Stefan Strogin <[email protected]> wrote:
>
>> 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.
>>
>> ...
>>
>> --- a/mm/cma.c
>> +++ b/mm/cma.c
>> @@ -53,6 +53,36 @@ unsigned long cma_get_size(const struct cma *cma)
>> return cma->count << PAGE_SHIFT;
>> }
>>
>> +unsigned long cma_get_used(struct cma *cma)
>> +{
>> + unsigned long ret = 0;
>> +
>> + mutex_lock(&cma->lock);
>> + /* pages counter is smaller than sizeof(int) */
>> + ret = bitmap_weight(cma->bitmap, (int)cma->count);
>> + mutex_unlock(&cma->lock);
>> +
>> + return ret << cma->order_per_bit;
>> +}
>> +
>> +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);
>> + if (start >= cma->count)
>> + break;
>> + end = find_next_bit(cma->bitmap, cma->count, start);
>> + maxchunk = max(end - start, maxchunk);
>> + }
>> + mutex_unlock(&cma->lock);
>> +
>> + return maxchunk << cma->order_per_bit;
>> +}
>
> This will cause unused code to be included in cma.o when
> CONFIG_CMA_DEBUGFS=n. Please review the below patch which moves it all
> into cma_debug.c
>
Thank you very much for the reply and for the patches.
>> --- a/mm/cma_debug.c
>> +++ b/mm/cma_debug.c
>> @@ -33,6 +33,28 @@ static int cma_debugfs_get(void *data, u64 *val)
>>
>> DEFINE_SIMPLE_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");
>>
>> +static int cma_used_get(void *data, u64 *val)
>> +{
>> + struct cma *cma = data;
>> +
>> + *val = cma_get_used(cma);
>> +
>> + return 0;
>> +}
>
> We have cma_used_get() and cma_get_used(). Confusing! Can we think of
> better names for one or both of them?
>
Oh. Excuse me for the bad code.
Wouldn't it be better to merge cma_get_used() and cma_get_maxchunk()
into cma_*_get() as they aren't used anywhere else?
Please see the following patch.
Move the code from cma_get_used() and cma_get_maxchunk() to cma_used_get()
and cma_maxchunk_get(), because cma_get_*() aren't used anywhere else, and
because of their confusing similar names.
Signed-off-by: Stefan Strogin <[email protected]>
---
mm/cma_debug.c | 51 ++++++++++++++++++---------------------------------
1 file changed, 18 insertions(+), 33 deletions(-)
diff --git a/mm/cma_debug.c b/mm/cma_debug.c
index 56c4175..abb9d0b 100644
--- a/mm/cma_debug.c
+++ b/mm/cma_debug.c
@@ -22,37 +22,6 @@ struct cma_mem {
static struct dentry *cma_debugfs_root;
-static unsigned long cma_get_used(struct cma *cma)
-{
- unsigned long ret = 0;
-
- mutex_lock(&cma->lock);
- /* pages counter is smaller than sizeof(int) */
- ret = bitmap_weight(cma->bitmap, (int)cma->count);
- mutex_unlock(&cma->lock);
-
- return ret << cma->order_per_bit;
-}
-
-static 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);
- if (start >= cma->count)
- break;
- end = find_next_bit(cma->bitmap, cma->count, start);
- maxchunk = max(end - start, maxchunk);
- }
- mutex_unlock(&cma->lock);
-
- return maxchunk << cma->order_per_bit;
-}
-
-
static int cma_debugfs_get(void *data, u64 *val)
{
unsigned long *p = data;
@@ -66,8 +35,13 @@ DEFINE_SIMPLE_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");
static int cma_used_get(void *data, u64 *val)
{
struct cma *cma = data;
+ unsigned long used;
- *val = cma_get_used(cma);
+ mutex_lock(&cma->lock);
+ /* pages counter is smaller than sizeof(int) */
+ used = bitmap_weight(cma->bitmap, (int)cma->count);
+ mutex_unlock(&cma->lock);
+ *val = used << cma->order_per_bit;
return 0;
}
@@ -76,8 +50,19 @@ DEFINE_SIMPLE_ATTRIBUTE(cma_used_fops, cma_used_get, NULL, "%llu\n");
static int cma_maxchunk_get(void *data, u64 *val)
{
struct cma *cma = data;
+ unsigned long maxchunk = 0;
+ unsigned long start, end = 0;
- *val = cma_get_maxchunk(cma);
+ mutex_lock(&cma->lock);
+ for (;;) {
+ start = find_next_zero_bit(cma->bitmap, cma->count, end);
+ if (start >= cma->count)
+ break;
+ end = find_next_bit(cma->bitmap, cma->count, start);
+ maxchunk = max(end - start, maxchunk);
+ }
+ mutex_unlock(&cma->lock);
+ *val = maxchunk << cma->order_per_bit;
return 0;
}
--
2.1.0