kgsl_debugfs.c - kernel/msm-modules/graphics - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2002,2008-2021, The Linux Foundation. All rights reserved.
  * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
  */

 #include <linux/debugfs.h>
 #include <linux/io.h>

 #include "kgsl_debugfs.h"
 #include "kgsl_device.h"
 #include "kgsl_pool.h"
 #include "kgsl_sharedmem.h"

 struct dentry *kgsl_debugfs_dir, *mempools_debugfs;
 static struct dentry *proc_d_debugfs;

 static void kgsl_qdss_gfx_register_probe(struct kgsl_device *device)
 {
 	struct resource *res;

 	res = platform_get_resource_byname(device->pdev, IORESOURCE_MEM,
 							"qdss_gfx");

 	if (res == NULL)
 		return;

 	device->qdss_gfx_virt = devm_ioremap(&device->pdev->dev, res->start,
 							resource_size(res));

 	if (device->qdss_gfx_virt == NULL)
 		dev_warn(device->dev, "qdss_gfx ioremap failed\n");
 }

 static int _isdb_set(void *data, u64 val)
 {
 	struct kgsl_device *device = data;

 	if (device->qdss_gfx_virt == NULL)
 		kgsl_qdss_gfx_register_probe(device);

 	device->set_isdb_breakpoint = val ? true : false;
 	return 0;
 }

 static int _isdb_get(void *data, u64 *val)
 {
 	struct kgsl_device *device = data;

 	*val = device->set_isdb_breakpoint ? 1 : 0;
 	return 0;
 }

 DEFINE_DEBUGFS_ATTRIBUTE(_isdb_fops, _isdb_get, _isdb_set, "%llu\n");

 static int globals_show(struct seq_file *s, void *unused)
 {
 	struct kgsl_device *device = s->private;
 	struct kgsl_global_memdesc *md;

 	list_for_each_entry(md, &device->globals, node) {
 		struct kgsl_memdesc *memdesc = &md->memdesc;
 		char flags[6];

 		flags[0] = memdesc->priv & KGSL_MEMDESC_PRIVILEGED ?  'p' : '-';
 		flags[1] = !(memdesc->flags & KGSL_MEMFLAGS_GPUREADONLY) ? 'w' : '-';
 		flags[2] = kgsl_memdesc_is_secured(memdesc) ?  's' : '-';
 		flags[3] = memdesc->priv & KGSL_MEMDESC_RANDOM ?  'r' : '-';
 		flags[4] = memdesc->priv & KGSL_MEMDESC_UCODE ? 'u' : '-';
 		flags[5] = '\0';

 		seq_printf(s, "0x%pK-0x%pK %16llu %5s %s\n",
 			(u64 *)(uintptr_t) memdesc->gpuaddr,
 			(u64 *)(uintptr_t) (memdesc->gpuaddr +
 			memdesc->size - 1), memdesc->size, flags,
 			md->name);
 	}

 	return 0;
 }

 DEFINE_SHOW_ATTRIBUTE(globals);

 static int _pool_size_get(void *data, u64 *val)
 {
 	*val = (u64) kgsl_pool_size_total();
 	return 0;
 }

 DEFINE_DEBUGFS_ATTRIBUTE(_pool_size_fops, _pool_size_get, NULL, "%llu\n");

 DEFINE_DEBUGFS_ATTRIBUTE(_reserved_fops,
 					kgsl_pool_reserved_get, NULL, "%llu\n");
 DEFINE_DEBUGFS_ATTRIBUTE(_page_count_fops,
 					kgsl_pool_page_count_get, NULL, "%llu\n");

 void kgsl_pool_init_debugfs(struct dentry *pool_debugfs,
 					char *name, void *pool)
 {
 	struct dentry *dentry;

 	pool_debugfs = debugfs_create_dir(name, mempools_debugfs);

 	if (IS_ERR_OR_NULL(pool_debugfs)) {
 		WARN((pool_debugfs == NULL),
 			"Unable to create debugfs dir for %s\n", name);
 		pool_debugfs = NULL;
 		return;
 	}

 	dentry = debugfs_create_file("reserved", 0444,
 		pool_debugfs, pool, &_reserved_fops);

 	WARN((IS_ERR_OR_NULL(dentry)),
 		"Unable to create 'reserved' file for %s\n", name);

 	dentry = debugfs_create_file("count", 0444,
 		pool_debugfs, pool, &_page_count_fops);

 	WARN((IS_ERR_OR_NULL(dentry)),
 		"Unable to create 'count' file for %s\n", name);
 }

 void kgsl_device_debugfs_init(struct kgsl_device *device)
 {
 	struct dentry *snapshot_dir;

 	if (IS_ERR_OR_NULL(kgsl_debugfs_dir))
 		return;

 	device->d_debugfs = debugfs_create_dir(device->name,
 						       kgsl_debugfs_dir);

 	debugfs_create_file("globals", 0444, device->d_debugfs, device,
 		&globals_fops);

 	snapshot_dir = debugfs_create_dir("snapshot", kgsl_debugfs_dir);
 	debugfs_create_file("break_isdb", 0644, snapshot_dir, device,
 		&_isdb_fops);
 }

 void kgsl_device_debugfs_close(struct kgsl_device *device)
 {
 	debugfs_remove_recursive(device->d_debugfs);
 }

 static const char *memtype_str(int memtype)
 {
 	if (memtype == KGSL_MEM_ENTRY_KERNEL)
 		return "gpumem";
 	else if (memtype == KGSL_MEM_ENTRY_USER)
 		return "usermem";
 	else if (memtype == KGSL_MEM_ENTRY_ION)
 		return "ion";

 	return "unknown";
 }

 static char get_alignflag(const struct kgsl_memdesc *m)
 {
 	int align = kgsl_memdesc_get_align(m);

 	if (align >= ilog2(SZ_1M))
 		return 'L';
 	else if (align >= ilog2(SZ_64K))
 		return 'l';
 	return '-';
 }

 static char get_cacheflag(const struct kgsl_memdesc *m)
 {
 	static const char table[] = {
 		[KGSL_CACHEMODE_WRITECOMBINE] = '-',
 		[KGSL_CACHEMODE_UNCACHED] = 'u',
 		[KGSL_CACHEMODE_WRITEBACK] = 'b',
 		[KGSL_CACHEMODE_WRITETHROUGH] = 't',
 	};

 	return table[kgsl_memdesc_get_cachemode(m)];
 }


 static int print_mem_entry(void *data, void *ptr)
 {
 	struct seq_file *s = data;
 	struct kgsl_mem_entry *entry = ptr;
 	char flags[11];
 	char usage[16];
 	struct kgsl_memdesc *m = &entry->memdesc;
 	unsigned int usermem_type = kgsl_memdesc_usermem_type(m);
 	int egl_surface_count = 0, egl_image_count = 0;
 	unsigned long inode_number = 0;
 	u32 map_count = atomic_read(&entry->map_count);

 	flags[0] = kgsl_memdesc_is_global(m) ?  'g' : '-';
 	flags[1] = '-';
 	flags[2] = !(m->flags & KGSL_MEMFLAGS_GPUREADONLY) ? 'w' : '-';
 	flags[3] = get_alignflag(m);
 	flags[4] = get_cacheflag(m);
 	flags[5] = kgsl_memdesc_use_cpu_map(m) ? 'p' : '-';
 	/* Show Y if at least one vma has this entry mapped (could be multiple) */
 	flags[6] = map_count ? 'Y' : 'N';
 	flags[7] = kgsl_memdesc_is_secured(m) ?  's' : '-';
 	flags[8] = '-';
 	flags[9] = m->flags & KGSL_MEMFLAGS_VBO ? 'v' : '-';
 	flags[10] = '\0';

 	kgsl_get_memory_usage(usage, sizeof(usage), m->flags);

 	if (usermem_type == KGSL_MEM_ENTRY_ION) {
 		kgsl_get_egl_counts(entry, &egl_surface_count,
 						&egl_image_count);
 		inode_number = kgsl_get_dmabuf_inode_number(entry);
 	}

 	seq_printf(s, "%pK %pK %16llu %5d %10s %10s %16s %5d %10d %6d %6d %10lu",
 			(uint64_t *)(uintptr_t) m->gpuaddr,
 			/*
 			 * Show zero for the useraddr - we can't reliably track
 			 * that value for multiple vmas anyway
 			 */
 			NULL, m->size, entry->id, flags,
 			memtype_str(usermem_type),
 			usage, (m->sgt ? m->sgt->nents : 0), map_count,
 			egl_surface_count, egl_image_count, inode_number);

 	if (entry->metadata[0] != 0)
 		seq_printf(s, " %s", entry->metadata);

 	seq_putc(s, '\n');

 	return 0;
 }

 static struct kgsl_mem_entry *process_mem_seq_find(struct seq_file *s,
 						void *ptr, loff_t pos)
 {
 	struct kgsl_mem_entry *entry = ptr;
 	struct kgsl_process_private *private = s->private;
 	int id = 0;

 	loff_t temp_pos = 1;

 	if (entry != SEQ_START_TOKEN)
 		id = entry->id + 1;

 	spin_lock(&private->mem_lock);
 	for (entry = idr_get_next(&private->mem_idr, &id); entry;
 		id++, entry = idr_get_next(&private->mem_idr, &id),
 							temp_pos++) {
 		if (temp_pos == pos && kgsl_mem_entry_get(entry)) {
 			spin_unlock(&private->mem_lock);
 			goto found;
 		}
 	}
 	spin_unlock(&private->mem_lock);

 	entry = NULL;
 found:
 	if (ptr != SEQ_START_TOKEN)
 		kgsl_mem_entry_put(ptr);

 	return entry;
 }

 static void *process_mem_seq_start(struct seq_file *s, loff_t *pos)
 {
 	loff_t seq_file_offset = *pos;

 	if (seq_file_offset == 0)
 		return SEQ_START_TOKEN;
 	else
 		return process_mem_seq_find(s, SEQ_START_TOKEN,
 						seq_file_offset);
 }

 static void process_mem_seq_stop(struct seq_file *s, void *ptr)
 {
 	if (ptr && ptr != SEQ_START_TOKEN)
 		kgsl_mem_entry_put(ptr);
 }

 static void *process_mem_seq_next(struct seq_file *s, void *ptr,
 							loff_t *pos)
 {
 	++*pos;
 	return process_mem_seq_find(s, ptr, 1);
 }

 static int process_mem_seq_show(struct seq_file *s, void *ptr)
 {
 	if (ptr == SEQ_START_TOKEN) {
 		seq_printf(s, "%16s %16s %16s %5s %10s %10s %16s %5s %10s %6s %6s %10s\n",
 			"gpuaddr", "useraddr", "size", "id", "flags", "type",
 			"usage", "sglen", "mapcnt", "eglsrf", "eglimg", "inode");
 		return 0;
 	} else
 		return print_mem_entry(s, ptr);
 }

 static const struct seq_operations process_mem_seq_fops = {
 	.start = process_mem_seq_start,
 	.stop = process_mem_seq_stop,
 	.next = process_mem_seq_next,
 	.show = process_mem_seq_show,
 };

 static int process_mem_open(struct inode *inode, struct file *file)
 {
 	int ret;
 	pid_t pid = (pid_t) (unsigned long) inode->i_private;
 	struct seq_file *s = NULL;
 	struct kgsl_process_private *private = NULL;

 	private = kgsl_process_private_find(pid);

 	if (!private)
 		return -ENODEV;

 	ret = seq_open(file, &process_mem_seq_fops);
 	if (ret)
 		kgsl_process_private_put(private);
 	else {
 		s = file->private_data;
 		s->private = private;
 	}

 	return ret;
 }

 static int process_mem_release(struct inode *inode, struct file *file)
 {
 	struct kgsl_process_private *private =
 		((struct seq_file *)file->private_data)->private;

 	if (private)
 		kgsl_process_private_put(private);

 	return seq_release(inode, file);
 }

 static const struct file_operations process_mem_fops = {
 	.open = process_mem_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	.release = process_mem_release,
 };


 static int print_vbo_ranges(int id, void *ptr, void *data)
 {
 	kgsl_memdesc_print_vbo_ranges(ptr, data);
 	return 0;
 }

 static int vbo_print(struct seq_file *s, void *unused)
 {
 	struct kgsl_process_private *private = s->private;

 	seq_puts(s, "id    child range\n");

 	spin_lock(&private->mem_lock);
 	idr_for_each(&private->mem_idr, print_vbo_ranges, s);
 	spin_unlock(&private->mem_lock);

 	return 0;
 }

 static int vbo_open(struct inode *inode, struct file *file)
 {
 	pid_t pid = (pid_t) (unsigned long) inode->i_private;
 	struct kgsl_process_private *private;
 	int ret;

 	private = kgsl_process_private_find(pid);

 	if (!private)
 		return -ENODEV;

 	ret = single_open(file, vbo_print, private);
 	if (ret)
 		kgsl_process_private_put(private);

 	return ret;
 }

 static const struct file_operations vbo_fops = {
 	.open = vbo_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	/* Reuse the same release function */
 	.release = process_mem_release,
 };

 /**
  * kgsl_process_init_debugfs() - Initialize debugfs for a process
  * @private: Pointer to process private structure created for the process
  *
  * kgsl_process_init_debugfs() is called at the time of creating the
  * process struct when a process opens kgsl device for the first time.
  * This function is not fatal - all we do is print a warning message if
  * the files can't be created
  */
 void kgsl_process_init_debugfs(struct kgsl_process_private *private)
 {
 	unsigned char name[16];
 	struct dentry *dentry;

 	snprintf(name, sizeof(name), "%d", pid_nr(private->pid));

 	private->debug_root = debugfs_create_dir(name, proc_d_debugfs);

 	if (IS_ERR(private->debug_root)) {
 		WARN_ONCE("Unable to create debugfs dir for %s\n", name);
 		private->debug_root = NULL;
 		return;
 	}

 	dentry = debugfs_create_file("mem", 0444, private->debug_root,
 		(void *) ((unsigned long) pid_nr(private->pid)), &process_mem_fops);

 	if (IS_ERR(dentry))
 		WARN_ONCE("Unable to create 'mem' file for %s\n", name);

 	debugfs_create_file("vbos", 0444, private->debug_root,
 		(void *) ((unsigned long) pid_nr(private->pid)), &vbo_fops);
 }

 void kgsl_core_debugfs_init(void)
 {
 	struct dentry *debug_dir, *dentry;

 	kgsl_debugfs_dir = debugfs_create_dir("kgsl", NULL);
 	if (IS_ERR_OR_NULL(kgsl_debugfs_dir))
 		return;

 	debug_dir = debugfs_create_dir("debug", kgsl_debugfs_dir);

 	proc_d_debugfs = debugfs_create_dir("proc", kgsl_debugfs_dir);

 	debugfs_create_bool("strict_memory", 0644, debug_dir,
 		&kgsl_sharedmem_noretry_flag);

 	mempools_debugfs = debugfs_create_dir("mempools", kgsl_debugfs_dir);

 	if (IS_ERR_OR_NULL(mempools_debugfs))
 		return;

 	dentry = debugfs_create_file("pool_size", 0444,
 		mempools_debugfs, NULL, &_pool_size_fops);

 	WARN((IS_ERR_OR_NULL(dentry)),
 		"Unable to create 'pool_size' file for mempools\n");
 }

 void kgsl_core_debugfs_close(void)
 {
 	debugfs_remove_recursive(kgsl_debugfs_dir);
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright (c) 2002,2008-2021, The Linux Foundation. All rights reserved.
	* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
	*/

	#include <linux/debugfs.h>
	#include <linux/io.h>

	#include "kgsl_debugfs.h"
	#include "kgsl_device.h"
	#include "kgsl_pool.h"
	#include "kgsl_sharedmem.h"

	struct dentry kgsl_debugfs_dir, mempools_debugfs;
	static struct dentry *proc_d_debugfs;

	static void kgsl_qdss_gfx_register_probe(struct kgsl_device *device)
	{
	struct resource *res;

	res = platform_get_resource_byname(device->pdev, IORESOURCE_MEM,
	"qdss_gfx");

	if (res == NULL)
	return;

	device->qdss_gfx_virt = devm_ioremap(&device->pdev->dev, res->start,
	resource_size(res));

	if (device->qdss_gfx_virt == NULL)
	dev_warn(device->dev, "qdss_gfx ioremap failed\n");
	}

	static int _isdb_set(void *data, u64 val)
	{
	struct kgsl_device *device = data;

	if (device->qdss_gfx_virt == NULL)
	kgsl_qdss_gfx_register_probe(device);

	device->set_isdb_breakpoint = val ? true : false;
	return 0;
	}

	static int _isdb_get(void data, u64 val)
	{
	struct kgsl_device *device = data;

	*val = device->set_isdb_breakpoint ? 1 : 0;
	return 0;
	}

	DEFINE_DEBUGFS_ATTRIBUTE(_isdb_fops, _isdb_get, _isdb_set, "%llu\n");

	static int globals_show(struct seq_file s, void unused)
	{
	struct kgsl_device *device = s->private;
	struct kgsl_global_memdesc *md;

	list_for_each_entry(md, &device->globals, node) {
	struct kgsl_memdesc *memdesc = &md->memdesc;
	char flags[6];

	flags[0] = memdesc->priv & KGSL_MEMDESC_PRIVILEGED ? 'p' : '-';
	flags[1] = !(memdesc->flags & KGSL_MEMFLAGS_GPUREADONLY) ? 'w' : '-';
	flags[2] = kgsl_memdesc_is_secured(memdesc) ? 's' : '-';
	flags[3] = memdesc->priv & KGSL_MEMDESC_RANDOM ? 'r' : '-';
	flags[4] = memdesc->priv & KGSL_MEMDESC_UCODE ? 'u' : '-';
	flags[5] = '\0';

	seq_printf(s, "0x%pK-0x%pK %16llu %5s %s\n",
	(u64 *)(uintptr_t) memdesc->gpuaddr,
	(u64 *)(uintptr_t) (memdesc->gpuaddr +
	memdesc->size - 1), memdesc->size, flags,
	md->name);
	}

	return 0;
	}

	DEFINE_SHOW_ATTRIBUTE(globals);

	static int _pool_size_get(void data, u64 val)
	{
	*val = (u64) kgsl_pool_size_total();
	return 0;
	}

	DEFINE_DEBUGFS_ATTRIBUTE(_pool_size_fops, _pool_size_get, NULL, "%llu\n");

	DEFINE_DEBUGFS_ATTRIBUTE(_reserved_fops,
	kgsl_pool_reserved_get, NULL, "%llu\n");
	DEFINE_DEBUGFS_ATTRIBUTE(_page_count_fops,
	kgsl_pool_page_count_get, NULL, "%llu\n");

	void kgsl_pool_init_debugfs(struct dentry *pool_debugfs,
	char name, void pool)
	{
	struct dentry *dentry;

	pool_debugfs = debugfs_create_dir(name, mempools_debugfs);

	if (IS_ERR_OR_NULL(pool_debugfs)) {
	WARN((pool_debugfs == NULL),
	"Unable to create debugfs dir for %s\n", name);
	pool_debugfs = NULL;
	return;
	}

	dentry = debugfs_create_file("reserved", 0444,
	pool_debugfs, pool, &_reserved_fops);

	WARN((IS_ERR_OR_NULL(dentry)),
	"Unable to create 'reserved' file for %s\n", name);

	dentry = debugfs_create_file("count", 0444,
	pool_debugfs, pool, &_page_count_fops);

	WARN((IS_ERR_OR_NULL(dentry)),
	"Unable to create 'count' file for %s\n", name);
	}

	void kgsl_device_debugfs_init(struct kgsl_device *device)
	{
	struct dentry *snapshot_dir;

	if (IS_ERR_OR_NULL(kgsl_debugfs_dir))
	return;

	device->d_debugfs = debugfs_create_dir(device->name,
	kgsl_debugfs_dir);

	debugfs_create_file("globals", 0444, device->d_debugfs, device,
	&globals_fops);

	snapshot_dir = debugfs_create_dir("snapshot", kgsl_debugfs_dir);
	debugfs_create_file("break_isdb", 0644, snapshot_dir, device,
	&_isdb_fops);
	}

	void kgsl_device_debugfs_close(struct kgsl_device *device)
	{
	debugfs_remove_recursive(device->d_debugfs);
	}

	static const char *memtype_str(int memtype)
	{
	if (memtype == KGSL_MEM_ENTRY_KERNEL)
	return "gpumem";
	else if (memtype == KGSL_MEM_ENTRY_USER)
	return "usermem";
	else if (memtype == KGSL_MEM_ENTRY_ION)
	return "ion";

	return "unknown";
	}

	static char get_alignflag(const struct kgsl_memdesc *m)
	{
	int align = kgsl_memdesc_get_align(m);

	if (align >= ilog2(SZ_1M))
	return 'L';
	else if (align >= ilog2(SZ_64K))
	return 'l';
	return '-';
	}

	static char get_cacheflag(const struct kgsl_memdesc *m)
	{
	static const char table[] = {
	[KGSL_CACHEMODE_WRITECOMBINE] = '-',
	[KGSL_CACHEMODE_UNCACHED] = 'u',
	[KGSL_CACHEMODE_WRITEBACK] = 'b',
	[KGSL_CACHEMODE_WRITETHROUGH] = 't',
	};

	return table[kgsl_memdesc_get_cachemode(m)];
	}


	static int print_mem_entry(void data, void ptr)
	{
	struct seq_file *s = data;
	struct kgsl_mem_entry *entry = ptr;
	char flags[11];
	char usage[16];
	struct kgsl_memdesc *m = &entry->memdesc;
	unsigned int usermem_type = kgsl_memdesc_usermem_type(m);
	int egl_surface_count = 0, egl_image_count = 0;
	unsigned long inode_number = 0;
	u32 map_count = atomic_read(&entry->map_count);

	flags[0] = kgsl_memdesc_is_global(m) ? 'g' : '-';
	flags[1] = '-';
	flags[2] = !(m->flags & KGSL_MEMFLAGS_GPUREADONLY) ? 'w' : '-';
	flags[3] = get_alignflag(m);
	flags[4] = get_cacheflag(m);
	flags[5] = kgsl_memdesc_use_cpu_map(m) ? 'p' : '-';
	/* Show Y if at least one vma has this entry mapped (could be multiple) */
	flags[6] = map_count ? 'Y' : 'N';
	flags[7] = kgsl_memdesc_is_secured(m) ? 's' : '-';
	flags[8] = '-';
	flags[9] = m->flags & KGSL_MEMFLAGS_VBO ? 'v' : '-';
	flags[10] = '\0';

	kgsl_get_memory_usage(usage, sizeof(usage), m->flags);

	if (usermem_type == KGSL_MEM_ENTRY_ION) {
	kgsl_get_egl_counts(entry, &egl_surface_count,
	&egl_image_count);
	inode_number = kgsl_get_dmabuf_inode_number(entry);
	}

	seq_printf(s, "%pK %pK %16llu %5d %10s %10s %16s %5d %10d %6d %6d %10lu",
	(uint64_t *)(uintptr_t) m->gpuaddr,
	/*
	* Show zero for the useraddr - we can't reliably track
	* that value for multiple vmas anyway
	*/
	NULL, m->size, entry->id, flags,
	memtype_str(usermem_type),
	usage, (m->sgt ? m->sgt->nents : 0), map_count,
	egl_surface_count, egl_image_count, inode_number);

	if (entry->metadata[0] != 0)
	seq_printf(s, " %s", entry->metadata);

	seq_putc(s, '\n');

	return 0;
	}

	static struct kgsl_mem_entry process_mem_seq_find(struct seq_file s,
	void *ptr, loff_t pos)
	{
	struct kgsl_mem_entry *entry = ptr;
	struct kgsl_process_private *private = s->private;
	int id = 0;

	loff_t temp_pos = 1;

	if (entry != SEQ_START_TOKEN)
	id = entry->id + 1;

	spin_lock(&private->mem_lock);
	for (entry = idr_get_next(&private->mem_idr, &id); entry;
	id++, entry = idr_get_next(&private->mem_idr, &id),
	temp_pos++) {
	if (temp_pos == pos && kgsl_mem_entry_get(entry)) {
	spin_unlock(&private->mem_lock);
	goto found;
	}
	}
	spin_unlock(&private->mem_lock);

	entry = NULL;
	found:
	if (ptr != SEQ_START_TOKEN)
	kgsl_mem_entry_put(ptr);

	return entry;
	}

	static void process_mem_seq_start(struct seq_file s, loff_t *pos)
	{
	loff_t seq_file_offset = *pos;

	if (seq_file_offset == 0)
	return SEQ_START_TOKEN;
	else
	return process_mem_seq_find(s, SEQ_START_TOKEN,
	seq_file_offset);
	}

	static void process_mem_seq_stop(struct seq_file s, void ptr)
	{
	if (ptr && ptr != SEQ_START_TOKEN)
	kgsl_mem_entry_put(ptr);
	}

	static void process_mem_seq_next(struct seq_file s, void *ptr,
	loff_t *pos)
	{
	++*pos;
	return process_mem_seq_find(s, ptr, 1);
	}

	static int process_mem_seq_show(struct seq_file s, void ptr)
	{
	if (ptr == SEQ_START_TOKEN) {
	seq_printf(s, "%16s %16s %16s %5s %10s %10s %16s %5s %10s %6s %6s %10s\n",
	"gpuaddr", "useraddr", "size", "id", "flags", "type",
	"usage", "sglen", "mapcnt", "eglsrf", "eglimg", "inode");
	return 0;
	} else
	return print_mem_entry(s, ptr);
	}

	static const struct seq_operations process_mem_seq_fops = {
	.start = process_mem_seq_start,
	.stop = process_mem_seq_stop,
	.next = process_mem_seq_next,
	.show = process_mem_seq_show,
	};

	static int process_mem_open(struct inode inode, struct file file)
	{
	int ret;
	pid_t pid = (pid_t) (unsigned long) inode->i_private;
	struct seq_file *s = NULL;
	struct kgsl_process_private *private = NULL;

	private = kgsl_process_private_find(pid);

	if (!private)
	return -ENODEV;

	ret = seq_open(file, &process_mem_seq_fops);
	if (ret)
	kgsl_process_private_put(private);
	else {
	s = file->private_data;
	s->private = private;
	}

	return ret;
	}

	static int process_mem_release(struct inode inode, struct file file)
	{
	struct kgsl_process_private *private =
	((struct seq_file *)file->private_data)->private;

	if (private)
	kgsl_process_private_put(private);

	return seq_release(inode, file);
	}

	static const struct file_operations process_mem_fops = {
	.open = process_mem_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = process_mem_release,
	};


	static int print_vbo_ranges(int id, void ptr, void data)
	{
	kgsl_memdesc_print_vbo_ranges(ptr, data);
	return 0;
	}

	static int vbo_print(struct seq_file s, void unused)
	{
	struct kgsl_process_private *private = s->private;

	seq_puts(s, "id child range\n");

	spin_lock(&private->mem_lock);
	idr_for_each(&private->mem_idr, print_vbo_ranges, s);
	spin_unlock(&private->mem_lock);

	return 0;
	}

	static int vbo_open(struct inode inode, struct file file)
	{
	pid_t pid = (pid_t) (unsigned long) inode->i_private;
	struct kgsl_process_private *private;
	int ret;

	private = kgsl_process_private_find(pid);

	if (!private)
	return -ENODEV;

	ret = single_open(file, vbo_print, private);
	if (ret)
	kgsl_process_private_put(private);

	return ret;
	}

	static const struct file_operations vbo_fops = {
	.open = vbo_open,
	.read = seq_read,
	.llseek = seq_lseek,
	/* Reuse the same release function */
	.release = process_mem_release,
	};

	/**
	* kgsl_process_init_debugfs() - Initialize debugfs for a process
	* @private: Pointer to process private structure created for the process
	*
	* kgsl_process_init_debugfs() is called at the time of creating the
	* process struct when a process opens kgsl device for the first time.
	* This function is not fatal - all we do is print a warning message if
	* the files can't be created
	*/
	void kgsl_process_init_debugfs(struct kgsl_process_private *private)
	{
	unsigned char name[16];
	struct dentry *dentry;

	snprintf(name, sizeof(name), "%d", pid_nr(private->pid));

	private->debug_root = debugfs_create_dir(name, proc_d_debugfs);

	if (IS_ERR(private->debug_root)) {
	WARN_ONCE("Unable to create debugfs dir for %s\n", name);
	private->debug_root = NULL;
	return;
	}

	dentry = debugfs_create_file("mem", 0444, private->debug_root,
	(void *) ((unsigned long) pid_nr(private->pid)), &process_mem_fops);

	if (IS_ERR(dentry))
	WARN_ONCE("Unable to create 'mem' file for %s\n", name);

	debugfs_create_file("vbos", 0444, private->debug_root,
	(void *) ((unsigned long) pid_nr(private->pid)), &vbo_fops);
	}

	void kgsl_core_debugfs_init(void)
	{
	struct dentry debug_dir, dentry;

	kgsl_debugfs_dir = debugfs_create_dir("kgsl", NULL);
	if (IS_ERR_OR_NULL(kgsl_debugfs_dir))
	return;

	debug_dir = debugfs_create_dir("debug", kgsl_debugfs_dir);

	proc_d_debugfs = debugfs_create_dir("proc", kgsl_debugfs_dir);

	debugfs_create_bool("strict_memory", 0644, debug_dir,
	&kgsl_sharedmem_noretry_flag);

	mempools_debugfs = debugfs_create_dir("mempools", kgsl_debugfs_dir);

	if (IS_ERR_OR_NULL(mempools_debugfs))
	return;

	dentry = debugfs_create_file("pool_size", 0444,
	mempools_debugfs, NULL, &_pool_size_fops);

	WARN((IS_ERR_OR_NULL(dentry)),
	"Unable to create 'pool_size' file for mempools\n");
	}

	void kgsl_core_debugfs_close(void)
	{
	debugfs_remove_recursive(kgsl_debugfs_dir);
	}