[linux.git] / mm / cma_debug.c

// SPDX-License-Identifier: GPL-2.0
/*
 * CMA DebugFS Interface
 *
 * Copyright (c) 2015 Sasha Levin <[email protected]>
 */


#include <linux/debugfs.h>
#include <linux/cma.h>
#include <linux/list.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm_types.h>

#include "cma.h"

struct cma_mem {
	struct hlist_node node;
	struct page *p;
	unsigned long n;
};

static struct dentry *cma_debugfs_root;

static int cma_debugfs_get(void *data, u64 *val)
{
	unsigned long *p = data;

	*val = *p;

	return 0;
}
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;

	mutex_lock(&cma->lock);
	/* pages counter is smaller than sizeof(int) */
	used = bitmap_weight(cma->bitmap, (int)cma_bitmap_maxno(cma));
	mutex_unlock(&cma->lock);
	*val = (u64)used << cma->order_per_bit;

	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;
	unsigned long maxchunk = 0;
	unsigned long start, end = 0;
	unsigned long bitmap_maxno = cma_bitmap_maxno(cma);

	mutex_lock(&cma->lock);
	for (;;) {
		start = find_next_zero_bit(cma->bitmap, bitmap_maxno, end);
		if (start >= cma->count)
			break;
		end = find_next_bit(cma->bitmap, bitmap_maxno, start);
		maxchunk = max(end - start, maxchunk);
	}
	mutex_unlock(&cma->lock);
	*val = (u64)maxchunk << cma->order_per_bit;

	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);
	hlist_add_head(&mem->node, &cma->mem_head);
	spin_unlock(&cma->mem_head_lock);
}

static struct cma_mem *cma_get_entry_from_list(struct cma *cma)
{
	struct cma_mem *mem = NULL;

	spin_lock(&cma->mem_head_lock);
	if (!hlist_empty(&cma->mem_head)) {
		mem = hlist_entry(cma->mem_head.first, struct cma_mem, node);
		hlist_del_init(&mem->node);
	}
	spin_unlock(&cma->mem_head_lock);

	return mem;
}

static int cma_free_mem(struct cma *cma, int count)
{
	struct cma_mem *mem = NULL;

	while (count) {
		mem = cma_get_entry_from_list(cma);
		if (mem == NULL)
			return 0;

		if (mem->n <= count) {
			cma_release(cma, mem->p, mem->n);
			count -= mem->n;
			kfree(mem);
		} else if (cma->order_per_bit == 0) {
			cma_release(cma, mem->p, count);
			mem->p += count;
			mem->n -= count;
			count = 0;
			cma_add_to_cma_mem_list(cma, mem);
		} else {
			pr_debug("cma: cannot release partial block when order_per_bit != 0\n");
			cma_add_to_cma_mem_list(cma, mem);
			break;
		}
	}

	return 0;

}

static int cma_free_write(void *data, u64 val)
{
	int pages = val;
	struct cma *cma = data;

	return cma_free_mem(cma, pages);
}
DEFINE_SIMPLE_ATTRIBUTE(cma_free_fops, NULL, cma_free_write, "%llu\n");

static int cma_alloc_mem(struct cma *cma, int count)
{
	struct cma_mem *mem;
	struct page *p;

	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
	if (!mem)
		return -ENOMEM;

	p = cma_alloc(cma, count, 0, GFP_KERNEL);
	if (!p) {
		kfree(mem);
		return -ENOMEM;
	}

	mem->p = p;
	mem->n = count;

	cma_add_to_cma_mem_list(cma, mem);

	return 0;
}

static int cma_alloc_write(void *data, u64 val)
{
	int pages = val;
	struct cma *cma = data;

	return cma_alloc_mem(cma, pages);
}
DEFINE_SIMPLE_ATTRIBUTE(cma_alloc_fops, NULL, cma_alloc_write, "%llu\n");

static void cma_debugfs_add_one(struct cma *cma, int idx)
{
	struct dentry *tmp;
	char name[16];
	int u32s;

	scnprintf(name, sizeof(name), "cma-%s", cma->name);

	tmp = debugfs_create_dir(name, cma_debugfs_root);

	debugfs_create_file("alloc", S_IWUSR, tmp, cma,
				&cma_alloc_fops);

	debugfs_create_file("free", S_IWUSR, tmp, cma,
				&cma_free_fops);

	debugfs_create_file("base_pfn", S_IRUGO, tmp,
				&cma->base_pfn, &cma_debugfs_fops);
	debugfs_create_file("count", S_IRUGO, tmp,
				&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);
}

static int __init cma_debugfs_init(void)
{
	int i;

	cma_debugfs_root = debugfs_create_dir("cma", NULL);
	if (!cma_debugfs_root)
		return -ENOMEM;

	for (i = 0; i < cma_area_count; i++)
		cma_debugfs_add_one(&cma_areas[i], i);

	return 0;
}
late_initcall(cma_debugfs_init);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
28b24c1f SL	2	/*
	3	* CMA DebugFS Interface
	4	*
	5	* Copyright (c) 2015 Sasha Levin <[email protected]>
	6	*/
	7
	8
	9	#include <linux/debugfs.h>
	10	#include <linux/cma.h>
26b02a1f SL	11	#include <linux/list.h>
	12	#include <linux/kernel.h>
	13	#include <linux/slab.h>
8325330b	14	#include <linux/mm_types.h>
28b24c1f SL	15
	16	#include "cma.h"
	17
26b02a1f SL	18	struct cma_mem {
	19	struct hlist_node node;
	20	struct page *p;
	21	unsigned long n;
	22	};
	23
28b24c1f SL	24	static struct dentry *cma_debugfs_root;
	25
	26	static int cma_debugfs_get(void data, u64 val)
	27	{
	28	unsigned long *p = data;
	29
	30	val = p;
	31
	32	return 0;
	33	}
28b24c1f SL	34	DEFINE_SIMPLE_ATTRIBUTE(cma_debugfs_fops, cma_debugfs_get, NULL, "%llu\n");
28b24c1f SL	35
2e32b947 DS	36	static int cma_used_get(void data, u64 val)
	37	{
	38	struct cma *cma = data;
	39	unsigned long used;
	40
	41	mutex_lock(&cma->lock);
	42	/* pages counter is smaller than sizeof(int) */
d56e84b4	43	used = bitmap_weight(cma->bitmap, (int)cma_bitmap_maxno(cma));
2e32b947 DS	44	mutex_unlock(&cma->lock);
	45	*val = (u64)used << cma->order_per_bit;
	46
	47	return 0;
	48	}
2e32b947 DS	49	DEFINE_SIMPLE_ATTRIBUTE(cma_used_fops, cma_used_get, NULL, "%llu\n");
	50
	51	static int cma_maxchunk_get(void data, u64 val)
	52	{
	53	struct cma *cma = data;
	54	unsigned long maxchunk = 0;
	55	unsigned long start, end = 0;
d56e84b4	56	unsigned long bitmap_maxno = cma_bitmap_maxno(cma);
2e32b947 DS	57
	58	mutex_lock(&cma->lock);
	59	for (;;) {
d56e84b4	60	start = find_next_zero_bit(cma->bitmap, bitmap_maxno, end);
2e32b947 DS	61	if (start >= cma->count)
2e32b947 DS	62	break;
d56e84b4	63	end = find_next_bit(cma->bitmap, bitmap_maxno, start);
2e32b947 DS	64	maxchunk = max(end - start, maxchunk);
	65	}
	66	mutex_unlock(&cma->lock);
	67	*val = (u64)maxchunk << cma->order_per_bit;
	68
	69	return 0;
	70	}
2e32b947 DS	71	DEFINE_SIMPLE_ATTRIBUTE(cma_maxchunk_fops, cma_maxchunk_get, NULL, "%llu\n");
2e32b947 DS	72
26b02a1f SL	73	static void cma_add_to_cma_mem_list(struct cma cma, struct cma_mem mem)
	74	{
	75	spin_lock(&cma->mem_head_lock);
	76	hlist_add_head(&mem->node, &cma->mem_head);
	77	spin_unlock(&cma->mem_head_lock);
	78	}
	79
8325330b SL	80	static struct cma_mem cma_get_entry_from_list(struct cma cma)
	81	{
	82	struct cma_mem *mem = NULL;
	83
	84	spin_lock(&cma->mem_head_lock);
	85	if (!hlist_empty(&cma->mem_head)) {
	86	mem = hlist_entry(cma->mem_head.first, struct cma_mem, node);
	87	hlist_del_init(&mem->node);
	88	}
	89	spin_unlock(&cma->mem_head_lock);
	90
	91	return mem;
	92	}
	93
	94	static int cma_free_mem(struct cma *cma, int count)
	95	{
	96	struct cma_mem *mem = NULL;
	97
	98	while (count) {
	99	mem = cma_get_entry_from_list(cma);
	100	if (mem == NULL)
	101	return 0;
	102
	103	if (mem->n <= count) {
	104	cma_release(cma, mem->p, mem->n);
	105	count -= mem->n;
	106	kfree(mem);
	107	} else if (cma->order_per_bit == 0) {
	108	cma_release(cma, mem->p, count);
	109	mem->p += count;
	110	mem->n -= count;
	111	count = 0;
	112	cma_add_to_cma_mem_list(cma, mem);
	113	} else {
	114	pr_debug("cma: cannot release partial block when order_per_bit != 0\n");
	115	cma_add_to_cma_mem_list(cma, mem);
	116	break;
	117	}
	118	}
	119
	120	return 0;
	121
	122	}
	123
	124	static int cma_free_write(void *data, u64 val)
	125	{
	126	int pages = val;
	127	struct cma *cma = data;
	128
	129	return cma_free_mem(cma, pages);
	130	}
8325330b SL	131	DEFINE_SIMPLE_ATTRIBUTE(cma_free_fops, NULL, cma_free_write, "%llu\n");
8325330b SL	132
26b02a1f SL	133	static int cma_alloc_mem(struct cma *cma, int count)
	134	{
	135	struct cma_mem *mem;
	136	struct page *p;
	137
	138	mem = kzalloc(sizeof(*mem), GFP_KERNEL);
	139	if (!mem)
	140	return -ENOMEM;
	141
e2f466e3	142	p = cma_alloc(cma, count, 0, GFP_KERNEL);
26b02a1f SL	143	if (!p) {
	144	kfree(mem);
	145	return -ENOMEM;
	146	}
	147
	148	mem->p = p;
	149	mem->n = count;
	150
	151	cma_add_to_cma_mem_list(cma, mem);
	152
	153	return 0;
	154	}
	155
	156	static int cma_alloc_write(void *data, u64 val)
	157	{
	158	int pages = val;
	159	struct cma *cma = data;
	160
	161	return cma_alloc_mem(cma, pages);
	162	}
26b02a1f SL	163	DEFINE_SIMPLE_ATTRIBUTE(cma_alloc_fops, NULL, cma_alloc_write, "%llu\n");
26b02a1f SL	164
28b24c1f SL	165	static void cma_debugfs_add_one(struct cma *cma, int idx)
	166	{
	167	struct dentry *tmp;
	168	char name[16];
	169	int u32s;
	170
da094e42	171	scnprintf(name, sizeof(name), "cma-%s", cma->name);
28b24c1f SL	172
	173	tmp = debugfs_create_dir(name, cma_debugfs_root);
	174
2292c0b1	175	debugfs_create_file("alloc", S_IWUSR, tmp, cma,
26b02a1f SL	176	&cma_alloc_fops);
26b02a1f SL	177
2292c0b1	178	debugfs_create_file("free", S_IWUSR, tmp, cma,
8325330b SL	179	&cma_free_fops);
8325330b SL	180
28b24c1f SL	181	debugfs_create_file("base_pfn", S_IRUGO, tmp,
	182	&cma->base_pfn, &cma_debugfs_fops);
	183	debugfs_create_file("count", S_IRUGO, tmp,
	184	&cma->count, &cma_debugfs_fops);
	185	debugfs_create_file("order_per_bit", S_IRUGO, tmp,
26b02a1f	186	&cma->order_per_bit, &cma_debugfs_fops);
2e32b947 DS	187	debugfs_create_file("used", S_IRUGO, tmp, cma, &cma_used_fops);
2e32b947 DS	188	debugfs_create_file("maxchunk", S_IRUGO, tmp, cma, &cma_maxchunk_fops);
28b24c1f SL	189
	190	u32s = DIV_ROUND_UP(cma_bitmap_maxno(cma), BITS_PER_BYTE * sizeof(u32));
	191	debugfs_create_u32_array("bitmap", S_IRUGO, tmp, (u32*)cma->bitmap, u32s);
	192	}
	193
	194	static int __init cma_debugfs_init(void)
	195	{
	196	int i;
	197
	198	cma_debugfs_root = debugfs_create_dir("cma", NULL);
	199	if (!cma_debugfs_root)
	200	return -ENOMEM;
	201
	202	for (i = 0; i < cma_area_count; i++)
	203	cma_debugfs_add_one(&cma_areas[i], i);
	204
	205	return 0;
	206	}
	207	late_initcall(cma_debugfs_init);