drm: Convert proc files to seq_file and introduce debugfs (28a62277) · Commits · e / devices / android_kernel_sony_msm8994

drivers/gpu/drm/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -10,7 +10,8 @@ drm-y := drm_auth.o drm_bufs.o drm_cache.o \
		drm_lock.o drm_memory.o drm_proc.o drm_stub.o drm_vm.o \
		drm_agpsupport.o drm_scatter.o ati_pcigart.o drm_pci.o \
		drm_sysfs.o drm_hashtab.o drm_sman.o drm_mm.o \
		drm_crtc.o drm_crtc_helper.o drm_modes.o drm_edid.o
		drm_crtc.o drm_crtc_helper.o drm_modes.o drm_edid.o \
		drm_info.o drm_debugfs.o

		drm-$(CONFIG_COMPAT) += drm_ioc32.o

drivers/gpu/drm/drm_debugfs.c

0 → 100644

+235 −0

Original line number	Diff line number	Diff line
		/**
		* \file drm_debugfs.c
		* debugfs support for DRM
		*
		* \author Ben Gamari <bgamari@gmail.com>
		*/

		/*
		* Created: Sun Dec 21 13:08:50 2008 by bgamari@gmail.com
		*
		* Copyright 2008 Ben Gamari <bgamari@gmail.com>
		*
		* Permission is hereby granted, free of charge, to any person obtaining a
		* copy of this software and associated documentation files (the "Software"),
		* to deal in the Software without restriction, including without limitation
		* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		* and/or sell copies of the Software, and to permit persons to whom the
		* Software is furnished to do so, subject to the following conditions:
		*
		* The above copyright notice and this permission notice (including the next
		* paragraph) shall be included in all copies or substantial portions of the
		* Software.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
		* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		* OTHER DEALINGS IN THE SOFTWARE.
		*/

		#include <linux/debugfs.h>
		#include <linux/seq_file.h>
		#include "drmP.h"

		#if defined(CONFIG_DEBUG_FS)

		/***************************************************
		* Initialization, etc.
		**************************************************/

		static struct drm_info_list drm_debugfs_list[] = {
		{"name", drm_name_info, 0},
		{"vm", drm_vm_info, 0},
		{"clients", drm_clients_info, 0},
		{"queues", drm_queues_info, 0},
		{"bufs", drm_bufs_info, 0},
		{"gem_names", drm_gem_name_info, DRIVER_GEM},
		{"gem_objects", drm_gem_object_info, DRIVER_GEM},
		#if DRM_DEBUG_CODE
		{"vma", drm_vma_info, 0},
		#endif
		};
		#define DRM_DEBUGFS_ENTRIES ARRAY_SIZE(drm_debugfs_list)


		static int drm_debugfs_open(struct inode inode, struct file file)
		{
		struct drm_info_node *node = inode->i_private;

		return single_open(file, node->info_ent->show, node);
		}


		static const struct file_operations drm_debugfs_fops = {
		.owner = THIS_MODULE,
		.open = drm_debugfs_open,
		.read = seq_read,
		.llseek = seq_lseek,
		.release = single_release,
		};


		/**
		* Initialize a given set of debugfs files for a device
		*
		* \param files The array of files to create
		* \param count The number of files given
		* \param root DRI debugfs dir entry.
		* \param minor device minor number
		* \return Zero on success, non-zero on failure
		*
		* Create a given set of debugfs files represented by an array of
		* gdm_debugfs_lists in the given root directory.
		*/
		int drm_debugfs_create_files(struct drm_info_list *files, int count,
		struct dentry root, struct drm_minor minor)
		{
		struct drm_device *dev = minor->dev;
		struct dentry *ent;
		struct drm_info_node *tmp;
		char name[64];
		int i, ret;

		for (i = 0; i < count; i++) {
		u32 features = files[i].driver_features;

		if (features != 0 &&
		(dev->driver->driver_features & features) != features)
		continue;

		tmp = drm_alloc(sizeof(struct drm_info_node),
		_DRM_DRIVER);
		ent = debugfs_create_file(files[i].name, S_IFREG \| S_IRUGO,
		root, tmp, &drm_debugfs_fops);
		if (!ent) {
		DRM_ERROR("Cannot create /debugfs/dri/%s/%s\n",
		name, files[i].name);
		drm_free(tmp, sizeof(struct drm_info_node),
		_DRM_DRIVER);
		ret = -1;
		goto fail;
		}

		tmp->minor = minor;
		tmp->dent = ent;
		tmp->info_ent = &files[i];
		list_add(&(tmp->list), &(minor->debugfs_nodes.list));
		}
		return 0;

		fail:
		drm_debugfs_remove_files(files, count, minor);
		return ret;
		}
		EXPORT_SYMBOL(drm_debugfs_create_files);

		/**
		* Initialize the DRI debugfs filesystem for a device
		*
		* \param dev DRM device
		* \param minor device minor number
		* \param root DRI debugfs dir entry.
		*
		* Create the DRI debugfs root entry "/debugfs/dri", the device debugfs root entry
		* "/debugfs/dri/%minor%/", and each entry in debugfs_list as
		* "/debugfs/dri/%minor%/%name%".
		*/
		int drm_debugfs_init(struct drm_minor *minor, int minor_id,
		struct dentry *root)
		{
		struct drm_device *dev = minor->dev;
		char name[64];
		int ret;

		INIT_LIST_HEAD(&minor->debugfs_nodes.list);
		sprintf(name, "%d", minor_id);
		minor->debugfs_root = debugfs_create_dir(name, root);
		if (!minor->debugfs_root) {
		DRM_ERROR("Cannot create /debugfs/dri/%s\n", name);
		return -1;
		}

		ret = drm_debugfs_create_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES,
		minor->debugfs_root, minor);
		if (ret) {
		debugfs_remove(minor->debugfs_root);
		minor->debugfs_root = NULL;
		DRM_ERROR("Failed to create core drm debugfs files\n");
		return ret;
		}

		if (dev->driver->debugfs_init) {
		ret = dev->driver->debugfs_init(minor);
		if (ret) {
		DRM_ERROR("DRM: Driver failed to initialize "
		"/debugfs/dri.\n");
		return ret;
		}
		}
		return 0;
		}


		/**
		* Remove a list of debugfs files
		*
		* \param files The list of files
		* \param count The number of files
		* \param minor The minor of which we should remove the files
		* \return always zero.
		*
		* Remove all debugfs entries created by debugfs_init().
		*/
		int drm_debugfs_remove_files(struct drm_info_list *files, int count,
		struct drm_minor *minor)
		{
		struct list_head pos, q;
		struct drm_info_node *tmp;
		int i;

		for (i = 0; i < count; i++) {
		list_for_each_safe(pos, q, &minor->debugfs_nodes.list) {
		tmp = list_entry(pos, struct drm_info_node, list);
		if (tmp->info_ent == &files[i]) {
		debugfs_remove(tmp->dent);
		list_del(pos);
		drm_free(tmp, sizeof(struct drm_info_node),
		_DRM_DRIVER);
		}
		}
		}
		return 0;
		}
		EXPORT_SYMBOL(drm_debugfs_remove_files);

		/**
		* Cleanup the debugfs filesystem resources.
		*
		* \param minor device minor number.
		* \return always zero.
		*
		* Remove all debugfs entries created by debugfs_init().
		*/
		int drm_debugfs_cleanup(struct drm_minor *minor)
		{
		struct drm_device *dev = minor->dev;

		if (!minor->debugfs_root)
		return 0;

		if (dev->driver->debugfs_cleanup)
		dev->driver->debugfs_cleanup(minor);

		drm_debugfs_remove_files(drm_debugfs_list, DRM_DEBUGFS_ENTRIES, minor);

		debugfs_remove(minor->debugfs_root);
		minor->debugfs_root = NULL;

		return 0;
		}

		#endif /* CONFIG_DEBUG_FS */

drivers/gpu/drm/drm_drv.c

+11 −1

Original line number	Diff line number	Diff line
		@@ -46,9 +46,11 @@
		* OTHER DEALINGS IN THE SOFTWARE.
		*/

		#include <linux/debugfs.h>
		#include "drmP.h"
		#include "drm_core.h"


		static int drm_version(struct drm_device dev, void data,
		struct drm_file *file_priv);

		@@ -382,6 +384,13 @@ static int __init drm_core_init(void)
		goto err_p3;
		}

		drm_debugfs_root = debugfs_create_dir("dri", NULL);
		if (!drm_debugfs_root) {
		DRM_ERROR("Cannot create /debugfs/dri\n");
		ret = -1;
		goto err_p3;
		}

		drm_mem_init();

		DRM_INFO("Initialized %s %d.%d.%d %s\n",
		@@ -400,6 +409,7 @@ err_p1:
		static void __exit drm_core_exit(void)
		{
		remove_proc_entry("dri", NULL);
		debugfs_remove(drm_debugfs_root);
		drm_sysfs_destroy();

		unregister_chrdev(DRM_MAJOR, "drm");

drivers/gpu/drm/drm_info.c

0 → 100644

+328 −0

Original line number	Diff line number	Diff line
		/**
		* \file drm_info.c
		* DRM info file implementations
		*
		* \author Ben Gamari <bgamari@gmail.com>
		*/

		/*
		* Created: Sun Dec 21 13:09:50 2008 by bgamari@gmail.com
		*
		* Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
		* Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
		* Copyright 2008 Ben Gamari <bgamari@gmail.com>
		* All Rights Reserved.
		*
		* Permission is hereby granted, free of charge, to any person obtaining a
		* copy of this software and associated documentation files (the "Software"),
		* to deal in the Software without restriction, including without limitation
		* the rights to use, copy, modify, merge, publish, distribute, sublicense,
		* and/or sell copies of the Software, and to permit persons to whom the
		* Software is furnished to do so, subject to the following conditions:
		*
		* The above copyright notice and this permission notice (including the next
		* paragraph) shall be included in all copies or substantial portions of the
		* Software.
		*
		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
		* VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
		* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
		* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
		* OTHER DEALINGS IN THE SOFTWARE.
		*/

		#include <linux/seq_file.h>
		#include "drmP.h"

		/**
		* Called when "/proc/dri/.../name" is read.
		*
		* Prints the device name together with the bus id if available.
		*/
		int drm_name_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_minor *minor = node->minor;
		struct drm_device *dev = minor->dev;
		struct drm_master *master = minor->master;

		if (!master)
		return 0;

		if (master->unique) {
		seq_printf(m, "%s %s %s\n",
		dev->driver->pci_driver.name,
		pci_name(dev->pdev), master->unique);
		} else {
		seq_printf(m, "%s %s\n", dev->driver->pci_driver.name,
		pci_name(dev->pdev));
		}

		return 0;
		}

		/**
		* Called when "/proc/dri/.../vm" is read.
		*
		* Prints information about all mappings in drm_device::maplist.
		*/
		int drm_vm_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		struct drm_map *map;
		struct drm_map_list *r_list;

		/* Hardcoded from _DRM_FRAME_BUFFER,
		_DRM_REGISTERS, _DRM_SHM, _DRM_AGP, and
		_DRM_SCATTER_GATHER and _DRM_CONSISTENT */
		const char *types[] = { "FB", "REG", "SHM", "AGP", "SG", "PCI" };
		const char *type;
		int i;

		mutex_lock(&dev->struct_mutex);
		seq_printf(m, "slot offset size type flags address mtrr\n\n");
		i = 0;
		list_for_each_entry(r_list, &dev->maplist, head) {
		map = r_list->map;
		if (!map)
		continue;
		if (map->type < 0 \|\| map->type > 5)
		type = "??";
		else
		type = types[map->type];

		seq_printf(m, "%4d 0x%08lx 0x%08lx %4.4s 0x%02x 0x%08lx ",
		i,
		map->offset,
		map->size, type, map->flags,
		(unsigned long) r_list->user_token);
		if (map->mtrr < 0)
		seq_printf(m, "none\n");
		else
		seq_printf(m, "%4d\n", map->mtrr);
		i++;
		}
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		/**
		* Called when "/proc/dri/.../queues" is read.
		*/
		int drm_queues_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		int i;
		struct drm_queue *q;

		mutex_lock(&dev->struct_mutex);
		seq_printf(m, " ctx/flags use fin"
		" blk/rw/rwf wait flushed queued"
		" locks\n\n");
		for (i = 0; i < dev->queue_count; i++) {
		q = dev->queuelist[i];
		atomic_inc(&q->use_count);
		seq_printf(m, "%5d/0x%03x %5d %5d"
		" %5d/%c%c/%c%c%c %5Zd\n",
		i,
		q->flags,
		atomic_read(&q->use_count),
		atomic_read(&q->finalization),
		atomic_read(&q->block_count),
		atomic_read(&q->block_read) ? 'r' : '-',
		atomic_read(&q->block_write) ? 'w' : '-',
		waitqueue_active(&q->read_queue) ? 'r' : '-',
		waitqueue_active(&q->write_queue) ? 'w' : '-',
		waitqueue_active(&q->flush_queue) ? 'f' : '-',
		DRM_BUFCOUNT(&q->waitlist));
		atomic_dec(&q->use_count);
		}
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		/**
		* Called when "/proc/dri/.../bufs" is read.
		*/
		int drm_bufs_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		struct drm_device_dma *dma;
		int i, seg_pages;

		mutex_lock(&dev->struct_mutex);
		dma = dev->dma;
		if (!dma) {
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		seq_printf(m, " o size count free segs pages kB\n\n");
		for (i = 0; i <= DRM_MAX_ORDER; i++) {
		if (dma->bufs[i].buf_count) {
		seg_pages = dma->bufs[i].seg_count * (1 << dma->bufs[i].page_order);
		seq_printf(m, "%2d %8d %5d %5d %5d %5d %5ld\n",
		i,
		dma->bufs[i].buf_size,
		dma->bufs[i].buf_count,
		atomic_read(&dma->bufs[i].freelist.count),
		dma->bufs[i].seg_count,
		seg_pages,
		seg_pages * PAGE_SIZE / 1024);
		}
		}
		seq_printf(m, "\n");
		for (i = 0; i < dma->buf_count; i++) {
		if (i && !(i % 32))
		seq_printf(m, "\n");
		seq_printf(m, " %d", dma->buflist[i]->list);
		}
		seq_printf(m, "\n");
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		/**
		* Called when "/proc/dri/.../vblank" is read.
		*/
		int drm_vblank_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		int crtc;

		mutex_lock(&dev->struct_mutex);
		for (crtc = 0; crtc < dev->num_crtcs; crtc++) {
		seq_printf(m, "CRTC %d enable: %d\n",
		crtc, atomic_read(&dev->vblank_refcount[crtc]));
		seq_printf(m, "CRTC %d counter: %d\n",
		crtc, drm_vblank_count(dev, crtc));
		seq_printf(m, "CRTC %d last wait: %d\n",
		crtc, dev->last_vblank_wait[crtc]);
		seq_printf(m, "CRTC %d in modeset: %d\n",
		crtc, dev->vblank_inmodeset[crtc]);
		}
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		/**
		* Called when "/proc/dri/.../clients" is read.
		*
		*/
		int drm_clients_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		struct drm_file *priv;

		mutex_lock(&dev->struct_mutex);
		seq_printf(m, "a dev pid uid magic ioctls\n\n");
		list_for_each_entry(priv, &dev->filelist, lhead) {
		seq_printf(m, "%c %3d %5d %5d %10u %10lu\n",
		priv->authenticated ? 'y' : 'n',
		priv->minor->index,
		priv->pid,
		priv->uid, priv->magic, priv->ioctl_count);
		}
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}


		int drm_gem_one_name_info(int id, void ptr, void data)
		{
		struct drm_gem_object *obj = ptr;
		struct seq_file *m = data;

		seq_printf(m, "name %d size %zd\n", obj->name, obj->size);

		seq_printf(m, "%6d %8zd %7d %8d\n",
		obj->name, obj->size,
		atomic_read(&obj->handlecount.refcount),
		atomic_read(&obj->refcount.refcount));
		return 0;
		}

		int drm_gem_name_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;

		seq_printf(m, " name size handles refcount\n");
		idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, m);
		return 0;
		}

		int drm_gem_object_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;

		seq_printf(m, "%d objects\n", atomic_read(&dev->object_count));
		seq_printf(m, "%d object bytes\n", atomic_read(&dev->object_memory));
		seq_printf(m, "%d pinned\n", atomic_read(&dev->pin_count));
		seq_printf(m, "%d pin bytes\n", atomic_read(&dev->pin_memory));
		seq_printf(m, "%d gtt bytes\n", atomic_read(&dev->gtt_memory));
		seq_printf(m, "%d gtt total\n", dev->gtt_total);
		return 0;
		}

		#if DRM_DEBUG_CODE

		int drm_vma_info(struct seq_file m, void data)
		{
		struct drm_info_node node = (struct drm_info_node ) m->private;
		struct drm_device *dev = node->minor->dev;
		struct drm_vma_entry *pt;
		struct vm_area_struct *vma;
		#if defined(__i386__)
		unsigned int pgprot;
		#endif

		mutex_lock(&dev->struct_mutex);
		seq_printf(m, "vma use count: %d, high_memory = %p, 0x%08lx\n",
		atomic_read(&dev->vma_count),
		high_memory, virt_to_phys(high_memory));

		list_for_each_entry(pt, &dev->vmalist, head) {
		vma = pt->vma;
		if (!vma)
		continue;
		seq_printf(m,
		"\n%5d 0x%08lx-0x%08lx %c%c%c%c%c%c 0x%08lx000",
		pt->pid, vma->vm_start, vma->vm_end,
		vma->vm_flags & VM_READ ? 'r' : '-',
		vma->vm_flags & VM_WRITE ? 'w' : '-',
		vma->vm_flags & VM_EXEC ? 'x' : '-',
		vma->vm_flags & VM_MAYSHARE ? 's' : 'p',
		vma->vm_flags & VM_LOCKED ? 'l' : '-',
		vma->vm_flags & VM_IO ? 'i' : '-',
		vma->vm_pgoff);

		#if defined(__i386__)
		pgprot = pgprot_val(vma->vm_page_prot);
		seq_printf(m, " %c%c%c%c%c%c%c%c%c",
		pgprot & _PAGE_PRESENT ? 'p' : '-',
		pgprot & _PAGE_RW ? 'w' : 'r',
		pgprot & _PAGE_USER ? 'u' : 's',
		pgprot & _PAGE_PWT ? 't' : 'b',
		pgprot & _PAGE_PCD ? 'u' : 'c',
		pgprot & _PAGE_ACCESSED ? 'a' : '-',
		pgprot & _PAGE_DIRTY ? 'd' : '-',
		pgprot & _PAGE_PSE ? 'm' : 'k',
		pgprot & _PAGE_GLOBAL ? 'g' : 'l');
		#endif
		seq_printf(m, "\n");
		}
		mutex_unlock(&dev->struct_mutex);
		return 0;
		}

		#endif

drivers/gpu/drm/drm_proc.c

+110 −611

File changed.

Preview size limit exceeded, changes collapsed.