drm: Convert proc files to seq_file and introduce debugfs
Ben Gamari [Wed, 18 Feb 2009 01:08:49 +0000 (20:08 -0500)]
The old mechanism to formatting proc files is extremely ugly. The
seq_file API was designed specifically for cases like this and greatly
simplifies the process.

Also, most of the files in /proc really don't belong there. This patch
introduces the infrastructure for putting these into debugfs and exposes
all of the proc files in debugfs as well.

This contains the i915 hooks rewrite as well, to make bisectability better.

Signed-off-by: Ben Gamari <bgamari@gmail.com>
Signed-off-by: Eric Anholt <eric@anholt.net>
Signed-off-by: Dave Airlie <airlied@redhat.com>

12 files changed:
drivers/gpu/drm/Makefile
drivers/gpu/drm/drm_debugfs.c [new file with mode: 0644]
drivers/gpu/drm/drm_drv.c
drivers/gpu/drm/drm_info.c [new file with mode: 0644]
drivers/gpu/drm/drm_proc.c
drivers/gpu/drm/drm_stub.c
drivers/gpu/drm/i915/Makefile
drivers/gpu/drm/i915/i915_drv.c
drivers/gpu/drm/i915/i915_drv.h
drivers/gpu/drm/i915/i915_gem_debugfs.c [new file with mode: 0644]
drivers/gpu/drm/i915/i915_gem_proc.c [deleted file]
include/drm/drmP.h

index 30022c4..4ec5061 100644 (file)
@@ -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
 
diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
new file mode 100644 (file)
index 0000000..c77c6c6
--- /dev/null
@@ -0,0 +1,235 @@
+/**
+ * \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 */
+
index 1441655..c26ee08 100644 (file)
  * 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);
 
@@ -178,7 +180,7 @@ int drm_lastclose(struct drm_device * dev)
 
        /* Clear AGP information */
        if (drm_core_has_AGP(dev) && dev->agp &&
-           !drm_core_check_feature(dev, DRIVER_MODESET)) {
+                       !drm_core_check_feature(dev, DRIVER_MODESET)) {
                struct drm_agp_mem *entry, *tempe;
 
                /* Remove AGP resources, but leave dev->agp
@@ -335,6 +337,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",
@@ -353,6 +362,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");
diff --git a/drivers/gpu/drm/drm_info.c b/drivers/gpu/drm/drm_info.c
new file mode 100644 (file)
index 0000000..fc98952
--- /dev/null
@@ -0,0 +1,328 @@
+/**
+ * \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
+
index 2e3f907..bae5391 100644 (file)
  * OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#include <linux/seq_file.h>
 #include "drmP.h"
 
-static int drm_name_info(char *buf, char **start, off_t offset,
-                        int request, int *eof, void *data);
-static int drm_vm_info(char *buf, char **start, off_t offset,
-                      int request, int *eof, void *data);
-static int drm_clients_info(char *buf, char **start, off_t offset,
-                           int request, int *eof, void *data);
-static int drm_queues_info(char *buf, char **start, off_t offset,
-                          int request, int *eof, void *data);
-static int drm_bufs_info(char *buf, char **start, off_t offset,
-                        int request, int *eof, void *data);
-static int drm_vblank_info(char *buf, char **start, off_t offset,
-                          int request, int *eof, void *data);
-static int drm_gem_name_info(char *buf, char **start, off_t offset,
-                            int request, int *eof, void *data);
-static int drm_gem_object_info(char *buf, char **start, off_t offset,
-                              int request, int *eof, void *data);
-#if DRM_DEBUG_CODE
-static int drm_vma_info(char *buf, char **start, off_t offset,
-                       int request, int *eof, void *data);
-#endif
+/***************************************************
+ * Initialization, etc.
+ **************************************************/
 
 /**
  * Proc file list.
  */
-static struct drm_proc_list {
-       const char *name;       /**< file name */
-       int (*f) (char *, char **, off_t, int, int *, void *);          /**< proc callback*/
-       u32 driver_features; /**< Required driver features for this entry */
-} drm_proc_list[] = {
+static struct drm_info_list drm_proc_list[] = {
        {"name", drm_name_info, 0},
-       {"mem", drm_mem_info, 0},
        {"vm", drm_vm_info, 0},
        {"clients", drm_clients_info, 0},
        {"queues", drm_queues_info, 0},
        {"bufs", drm_bufs_info, 0},
-       {"vblank", drm_vblank_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},
+       {"vma", drm_vma_info, 0},
 #endif
 };
-
 #define DRM_PROC_ENTRIES ARRAY_SIZE(drm_proc_list)
 
+static int drm_proc_open(struct inode *inode, struct file *file)
+{
+       struct drm_info_node* node = PDE(inode)->data;
+
+       return single_open(file, node->info_ent->show, node);
+}
+
+static const struct file_operations drm_proc_fops = {
+       .owner = THIS_MODULE,
+       .open = drm_proc_open,
+       .read = seq_read,
+       .llseek = seq_lseek,
+       .release = single_release,
+};
+
+
 /**
- * Initialize the DRI proc filesystem for a device.
+ * Initialize a given set of proc files for a device
  *
- * \param dev DRM device.
- * \param minor device minor number.
+ * \param files The array of files to create
+ * \param count The number of files given
  * \param root DRI proc dir entry.
- * \param dev_root resulting DRI device proc dir entry.
- * \return root entry pointer on success, or NULL on failure.
+ * \param minor device minor number
+ * \return Zero on success, non-zero on failure
  *
- * Create the DRI proc root entry "/proc/dri", the device proc root entry
- * "/proc/dri/%minor%/", and each entry in proc_list as
- * "/proc/dri/%minor%/%name%".
+ * Create a given set of proc files represented by an array of
+ * gdm_proc_lists in the given root directory.
  */
-int drm_proc_init(struct drm_minor *minor, int minor_id,
-                 struct proc_dir_entry *root)
+int drm_proc_create_files(struct drm_info_list *files, int count,
+                         struct proc_dir_entry *root, struct drm_minor *minor)
 {
        struct drm_device *dev = minor->dev;
        struct proc_dir_entry *ent;
-       int i, j, ret;
+       struct drm_info_node *tmp;
        char name[64];
+       int i, ret;
 
-       sprintf(name, "%d", minor_id);
-       minor->dev_root = proc_mkdir(name, root);
-       if (!minor->dev_root) {
-               DRM_ERROR("Cannot create /proc/dri/%s\n", name);
-               return -1;
-       }
-
-       for (i = 0; i < DRM_PROC_ENTRIES; i++) {
-               u32 features = drm_proc_list[i].driver_features;
+       for (i = 0; i < count; i++) {
+               u32 features = files[i].driver_features;
 
                if (features != 0 &&
                    (dev->driver->driver_features & features) != features)
                        continue;
 
-               ent = create_proc_entry(drm_proc_list[i].name,
-                                       S_IFREG | S_IRUGO, minor->dev_root);
+               tmp = drm_alloc(sizeof(struct drm_info_node), _DRM_DRIVER);
+               ent = create_proc_entry(files[i].name, S_IFREG | S_IRUGO, root);
                if (!ent) {
                        DRM_ERROR("Cannot create /proc/dri/%s/%s\n",
-                                 name, drm_proc_list[i].name);
+                                 name, files[i].name);
+                       drm_free(tmp, sizeof(struct drm_info_node),
+                                _DRM_DRIVER);
                        ret = -1;
                        goto fail;
                }
-               ent->read_proc = drm_proc_list[i].f;
-               ent->data = minor;
-       }
 
-       if (dev->driver->proc_init) {
-               ret = dev->driver->proc_init(minor);
-               if (ret) {
-                       DRM_ERROR("DRM: Driver failed to initialize "
-                                 "/proc/dri.\n");
-                       goto fail;
-               }
+               ent->proc_fops = &drm_proc_fops;
+               ent->data = tmp;
+               tmp->minor = minor;
+               tmp->info_ent = &files[i];
+               list_add(&(tmp->list), &(minor->proc_nodes.list));
        }
-
        return 0;
- fail:
 
-       for (j = 0; j < i; j++)
-               remove_proc_entry(drm_proc_list[i].name,
-                                 minor->dev_root);
-       remove_proc_entry(name, root);
-       minor->dev_root = NULL;
+fail:
+       for (i = 0; i < count; i++)
+               remove_proc_entry(drm_proc_list[i].name, minor->proc_root);
        return ret;
 }
 
 /**
- * Cleanup the proc filesystem resources.
+ * Initialize the DRI proc filesystem for a device
  *
- * \param minor device minor number.
+ * \param dev DRM device
+ * \param minor device minor number
  * \param root DRI proc dir entry.
- * \param dev_root DRI device proc dir entry.
- * \return always zero.
+ * \param dev_root resulting DRI device proc dir entry.
+ * \return root entry pointer on success, or NULL on failure.
  *
- * Remove all proc entries created by proc_init().
+ * Create the DRI proc root entry "/proc/dri", the device proc root entry
+ * "/proc/dri/%minor%/", and each entry in proc_list as
+ * "/proc/dri/%minor%/%name%".
  */
-int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root)
+int drm_proc_init(struct drm_minor *minor, int minor_id,
+                 struct proc_dir_entry *root)
 {
        struct drm_device *dev = minor->dev;
-       int i;
        char name[64];
+       int ret;
 
-       if (!root || !minor->dev_root)
-               return 0;
-
-       if (dev->driver->proc_cleanup)
-               dev->driver->proc_cleanup(minor);
-
-       for (i = 0; i < DRM_PROC_ENTRIES; i++)
-               remove_proc_entry(drm_proc_list[i].name, minor->dev_root);
-       sprintf(name, "%d", minor->index);
-       remove_proc_entry(name, root);
-
-       return 0;
-}
-
-/**
- * Called when "/proc/dri/.../name" is read.
- *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- *
- * Prints the device name together with the bus id if available.
- */
-static int drm_name_info(char *buf, char **start, off_t offset, int request,
-                        int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_master *master = minor->master;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
+       INIT_LIST_HEAD(&minor->proc_nodes.list);
+       sprintf(name, "%d", minor_id);
+       minor->proc_root = proc_mkdir(name, root);
+       if (!minor->proc_root) {
+               DRM_ERROR("Cannot create /proc/dri/%s\n", name);
+               return -1;
        }
 
-       if (!master)
-               return 0;
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       if (master->unique) {
-               DRM_PROC_PRINT("%s %s %s\n",
-                              dev->driver->pci_driver.name,
-                              pci_name(dev->pdev), master->unique);
-       } else {
-               DRM_PROC_PRINT("%s %s\n", dev->driver->pci_driver.name,
-                              pci_name(dev->pdev));
+       ret = drm_proc_create_files(drm_proc_list, DRM_PROC_ENTRIES,
+                                   minor->proc_root, minor);
+       if (ret) {
+               remove_proc_entry(name, root);
+               minor->proc_root = NULL;
+               DRM_ERROR("Failed to create core drm proc files\n");
+               return ret;
        }
 
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Called when "/proc/dri/.../vm" is read.
- *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- *
- * Prints information about all mappings in drm_device::maplist.
- */
-static int drm__vm_info(char *buf, char **start, off_t offset, int request,
-                       int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-       struct drm_local_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;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       DRM_PROC_PRINT("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];
-               DRM_PROC_PRINT("%4d 0x%08llx 0x%08lx %4.4s  0x%02x 0x%08lx ",
-                              i,
-                              (unsigned long long)map->offset,
-                              map->size, type, map->flags,
-                              (unsigned long) r_list->user_token);
-               if (map->mtrr < 0) {
-                       DRM_PROC_PRINT("none\n");
-               } else {
-                       DRM_PROC_PRINT("%4d\n", map->mtrr);
+       if (dev->driver->proc_init) {
+               ret = dev->driver->proc_init(minor);
+               if (ret) {
+                       DRM_ERROR("DRM: Driver failed to initialize "
+                                 "/proc/dri.\n");
+                       return ret;
                }
-               i++;
-       }
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Simply calls _vm_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_vm_info(char *buf, char **start, off_t offset, int request,
-                      int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__vm_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
-}
-
-/**
- * Called when "/proc/dri/.../queues" is read.
- *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- */
-static int drm__queues_info(char *buf, char **start, off_t offset,
-                           int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-       int i;
-       struct drm_queue *q;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
        }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       DRM_PROC_PRINT("  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);
-               DRM_PROC_PRINT_RET(atomic_dec(&q->use_count),
-                                  "%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);
-       }
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Simply calls _queues_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_queues_info(char *buf, char **start, off_t offset, int request,
-                          int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__queues_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
+       return 0;
 }
 
-/**
- * Called when "/proc/dri/.../bufs" is read.
- *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- */
-static int drm__bufs_info(char *buf, char **start, off_t offset, int request,
-                         int *eof, void *data)
+int drm_proc_remove_files(struct drm_info_list *files, int count,
+                         struct drm_minor *minor)
 {
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-       struct drm_device_dma *dma = dev->dma;
+       struct list_head *pos, *q;
+       struct drm_info_node *tmp;
        int i;
 
-       if (!dma || offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       DRM_PROC_PRINT(" o     size count  free  segs pages    kB\n\n");
-       for (i = 0; i <= DRM_MAX_ORDER; i++) {
-               if (dma->bufs[i].buf_count)
-                       DRM_PROC_PRINT("%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,
-                                      dma->bufs[i].seg_count
-                                      * (1 << dma->bufs[i].page_order),
-                                      (dma->bufs[i].seg_count
-                                       * (1 << dma->bufs[i].page_order))
-                                      * PAGE_SIZE / 1024);
-       }
-       DRM_PROC_PRINT("\n");
-       for (i = 0; i < dma->buf_count; i++) {
-               if (i && !(i % 32))
-                       DRM_PROC_PRINT("\n");
-               DRM_PROC_PRINT(" %d", dma->buflist[i]->list);
+       for (i = 0; i < count; i++) {
+               list_for_each_safe(pos, q, &minor->proc_nodes.list) {
+                       tmp = list_entry(pos, struct drm_info_node, list);
+                       if (tmp->info_ent == &files[i]) {
+                               remove_proc_entry(files[i].name,
+                                                 minor->proc_root);
+                               list_del(pos);
+                               drm_free(tmp, sizeof(struct drm_info_node),
+                                        _DRM_DRIVER);
+                       }
+               }
        }
-       DRM_PROC_PRINT("\n");
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Simply calls _bufs_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_bufs_info(char *buf, char **start, off_t offset, int request,
-                        int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__bufs_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
+       return 0;
 }
 
 /**
- * Called when "/proc/dri/.../vblank" is read.
+ * Cleanup the proc filesystem resources.
  *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
- */
-static int drm__vblank_info(char *buf, char **start, off_t offset, int request,
-                         int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-       int crtc;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       for (crtc = 0; crtc < dev->num_crtcs; crtc++) {
-               DRM_PROC_PRINT("CRTC %d enable:     %d\n",
-                              crtc, atomic_read(&dev->vblank_refcount[crtc]));
-               DRM_PROC_PRINT("CRTC %d counter:    %d\n",
-                              crtc, drm_vblank_count(dev, crtc));
-               DRM_PROC_PRINT("CRTC %d last wait:  %d\n",
-                              crtc, dev->last_vblank_wait[crtc]);
-               DRM_PROC_PRINT("CRTC %d in modeset: %d\n",
-                              crtc, dev->vblank_inmodeset[crtc]);
-       }
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Simply calls _vblank_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_vblank_info(char *buf, char **start, off_t offset, int request,
-                        int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__vblank_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
-}
-
-/**
- * Called when "/proc/dri/.../clients" is read.
+ * \param minor device minor number.
+ * \param root DRI proc dir entry.
+ * \param dev_root DRI device proc dir entry.
+ * \return always zero.
  *
- * \param buf output buffer.
- * \param start start of output data.
- * \param offset requested start offset.
- * \param request requested number of bytes.
- * \param eof whether there is no more data to return.
- * \param data private data.
- * \return number of written bytes.
+ * Remove all proc entries created by proc_init().
  */
-static int drm__clients_info(char *buf, char **start, off_t offset,
-                            int request, int *eof, void *data)
+int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root)
 {
-       struct drm_minor *minor = (struct drm_minor *) data;
        struct drm_device *dev = minor->dev;
-       int len = 0;
-       struct drm_file *priv;
+       char name[64];
 
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
+       if (!root || !minor->proc_root)
                return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       DRM_PROC_PRINT("a dev   pid    uid      magic     ioctls\n\n");
-       list_for_each_entry(priv, &dev->filelist, lhead) {
-               DRM_PROC_PRINT("%c %3d %5d %5d %10u %10lu\n",
-                              priv->authenticated ? 'y' : 'n',
-                              priv->minor->index,
-                              priv->pid,
-                              priv->uid, priv->magic, priv->ioctl_count);
-       }
 
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-/**
- * Simply calls _clients_info() while holding the drm_device::struct_mutex lock.
- */
-static int drm_clients_info(char *buf, char **start, off_t offset,
-                           int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__clients_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
-}
-
-struct drm_gem_name_info_data {
-       int                     len;
-       char                    *buf;
-       int                     eof;
-};
+       if (dev->driver->proc_cleanup)
+               dev->driver->proc_cleanup(minor);
 
-static int drm_gem_one_name_info(int id, void *ptr, void *data)
-{
-       struct drm_gem_object *obj = ptr;
-       struct drm_gem_name_info_data   *nid = data;
+       drm_proc_remove_files(drm_proc_list, DRM_PROC_ENTRIES, minor);
 
-       DRM_INFO("name %d size %zd\n", obj->name, obj->size);
-       if (nid->eof)
-               return 0;
+       sprintf(name, "%d", minor->index);
+       remove_proc_entry(name, root);
 
-       nid->len += sprintf(&nid->buf[nid->len],
-                           "%6d %8zd %7d %8d\n",
-                           obj->name, obj->size,
-                           atomic_read(&obj->handlecount.refcount),
-                           atomic_read(&obj->refcount.refcount));
-       if (nid->len > DRM_PROC_LIMIT) {
-               nid->eof = 1;
-               return 0;
-       }
        return 0;
 }
 
-static int drm_gem_name_info(char *buf, char **start, off_t offset,
-                            int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       struct drm_gem_name_info_data nid;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       nid.len = sprintf(buf, "  name     size handles refcount\n");
-       nid.buf = buf;
-       nid.eof = 0;
-       idr_for_each(&dev->object_name_idr, drm_gem_one_name_info, &nid);
-
-       *start = &buf[offset];
-       *eof = 0;
-       if (nid.len > request + offset)
-               return request;
-       *eof = 1;
-       return nid.len - offset;
-}
-
-static int drm_gem_object_info(char *buf, char **start, off_t offset,
-                              int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("%d objects\n", atomic_read(&dev->object_count));
-       DRM_PROC_PRINT("%d object bytes\n", atomic_read(&dev->object_memory));
-       DRM_PROC_PRINT("%d pinned\n", atomic_read(&dev->pin_count));
-       DRM_PROC_PRINT("%d pin bytes\n", atomic_read(&dev->pin_memory));
-       DRM_PROC_PRINT("%d gtt bytes\n", atomic_read(&dev->gtt_memory));
-       DRM_PROC_PRINT("%d gtt total\n", dev->gtt_total);
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-#if DRM_DEBUG_CODE
-
-static int drm__vma_info(char *buf, char **start, off_t offset, int request,
-                        int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int len = 0;
-       struct drm_vma_entry *pt;
-       struct vm_area_struct *vma;
-#if defined(__i386__)
-       unsigned int pgprot;
-#endif
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-
-       DRM_PROC_PRINT("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) {
-               if (!(vma = pt->vma))
-                       continue;
-               DRM_PROC_PRINT("\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);
-               DRM_PROC_PRINT(" %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
-               DRM_PROC_PRINT("\n");
-       }
-
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int drm_vma_info(char *buf, char **start, off_t offset, int request,
-                       int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       int ret;
-
-       mutex_lock(&dev->struct_mutex);
-       ret = drm__vma_info(buf, start, offset, request, eof, data);
-       mutex_unlock(&dev->struct_mutex);
-       return ret;
-}
-#endif
index 45a536b..d009661 100644 (file)
@@ -50,6 +50,7 @@ struct idr drm_minors_idr;
 
 struct class *drm_class;
 struct proc_dir_entry *drm_proc_root;
+struct dentry *drm_debugfs_root;
 
 static int drm_minor_get_id(struct drm_device *dev, int type)
 {
@@ -313,7 +314,15 @@ static int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int t
                        goto err_mem;
                }
        } else
-               new_minor->dev_root = NULL;
+               new_minor->proc_root = NULL;
+
+#if defined(CONFIG_DEBUG_FS)
+       ret = drm_debugfs_init(new_minor, minor_id, drm_debugfs_root);
+       if (ret) {
+               DRM_ERROR("DRM: Failed to initialize /debugfs/dri.\n");
+               goto err_g2;
+       }
+#endif
 
        ret = drm_sysfs_device_add(new_minor);
        if (ret) {
@@ -430,6 +439,10 @@ int drm_put_minor(struct drm_minor **minor_p)
 
        if (minor->type == DRM_MINOR_LEGACY)
                drm_proc_cleanup(minor, drm_proc_root);
+#if defined(CONFIG_DEBUG_FS)
+       drm_debugfs_cleanup(minor);
+#endif
+
        drm_sysfs_device_remove(minor);
 
        idr_remove(&drm_minors_idr, minor->index);
index 793cba3..51c5a05 100644 (file)
@@ -7,7 +7,7 @@ i915-y := i915_drv.o i915_dma.o i915_irq.o i915_mem.o \
           i915_suspend.o \
          i915_gem.o \
          i915_gem_debug.o \
-         i915_gem_proc.o \
+         i915_gem_debugfs.o \
          i915_gem_tiling.o \
          intel_display.o \
          intel_crt.o \
index d10ec9e..2c01676 100644 (file)
@@ -182,8 +182,10 @@ static struct drm_driver driver = {
        .get_reg_ofs = drm_core_get_reg_ofs,
        .master_create = i915_master_create,
        .master_destroy = i915_master_destroy,
-       .proc_init = i915_gem_proc_init,
-       .proc_cleanup = i915_gem_proc_cleanup,
+#if defined(CONFIG_DEBUG_FS)
+       .debugfs_init = i915_gem_debugfs_init,
+       .debugfs_cleanup = i915_gem_debugfs_cleanup,
+#endif
        .gem_init_object = i915_gem_init_object,
        .gem_free_object = i915_gem_free_object,
        .gem_vm_ops = &i915_gem_vm_ops,
index d6cc986..1bc45a7 100644 (file)
@@ -604,8 +604,6 @@ int i915_gem_get_tiling(struct drm_device *dev, void *data,
 int i915_gem_get_aperture_ioctl(struct drm_device *dev, void *data,
                                struct drm_file *file_priv);
 void i915_gem_load(struct drm_device *dev);
-int i915_gem_proc_init(struct drm_minor *minor);
-void i915_gem_proc_cleanup(struct drm_minor *minor);
 int i915_gem_init_object(struct drm_gem_object *obj);
 void i915_gem_free_object(struct drm_gem_object *obj);
 int i915_gem_object_pin(struct drm_gem_object *obj, uint32_t alignment);
@@ -649,6 +647,10 @@ void i915_gem_dump_object(struct drm_gem_object *obj, int len,
                          const char *where, uint32_t mark);
 void i915_dump_lru(struct drm_device *dev, const char *where);
 
+/* i915_debugfs.c */
+int i915_gem_debugfs_init(struct drm_minor *minor);
+void i915_gem_debugfs_cleanup(struct drm_minor *minor);
+
 /* i915_suspend.c */
 extern int i915_save_state(struct drm_device *dev);
 extern int i915_restore_state(struct drm_device *dev);
diff --git a/drivers/gpu/drm/i915/i915_gem_debugfs.c b/drivers/gpu/drm/i915/i915_gem_debugfs.c
new file mode 100644 (file)
index 0000000..dd2b0ed
--- /dev/null
@@ -0,0 +1,230 @@
+/*
+ * Copyright © 2008 Intel Corporation
+ *
+ * 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
+ * THE AUTHORS OR COPYRIGHT HOLDERS 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.
+ *
+ * Authors:
+ *    Eric Anholt <eric@anholt.net>
+ *    Keith Packard <keithp@keithp.com>
+ *
+ */
+
+#include <linux/seq_file.h>
+#include "drmP.h"
+#include "drm.h"
+#include "i915_drm.h"
+#include "i915_drv.h"
+
+#define DRM_I915_RING_DEBUG 1
+
+
+#if defined(CONFIG_DEBUG_FS)
+
+static int i915_gem_active_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+       struct drm_i915_gem_object *obj_priv;
+
+       seq_printf(m, "Active:\n");
+       list_for_each_entry(obj_priv, &dev_priv->mm.active_list,
+                       list)
+       {
+               struct drm_gem_object *obj = obj_priv->obj;
+               if (obj->name) {
+                       seq_printf(m, "    %p(%d): %08x %08x %d\n",
+                                       obj, obj->name,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               } else {
+                       seq_printf(m, "       %p: %08x %08x %d\n",
+                                       obj,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               }
+       }
+       return 0;
+}
+
+static int i915_gem_flushing_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+       struct drm_i915_gem_object *obj_priv;
+
+       seq_printf(m, "Flushing:\n");
+       list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list,
+                       list)
+       {
+               struct drm_gem_object *obj = obj_priv->obj;
+               if (obj->name) {
+                       seq_printf(m, "    %p(%d): %08x %08x %d\n",
+                                       obj, obj->name,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               } else {
+                       seq_printf(m, "       %p: %08x %08x %d\n", obj,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               }
+       }
+       return 0;
+}
+
+static int i915_gem_inactive_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+       struct drm_i915_gem_object *obj_priv;
+
+       seq_printf(m, "Inactive:\n");
+       list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list,
+                       list)
+       {
+               struct drm_gem_object *obj = obj_priv->obj;
+               if (obj->name) {
+                       seq_printf(m, "    %p(%d): %08x %08x %d\n",
+                                       obj, obj->name,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               } else {
+                       seq_printf(m, "       %p: %08x %08x %d\n", obj,
+                                       obj->read_domains, obj->write_domain,
+                                       obj_priv->last_rendering_seqno);
+               }
+       }
+       return 0;
+}
+
+static int i915_gem_request_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+       struct drm_i915_gem_request *gem_request;
+
+       seq_printf(m, "Request:\n");
+       list_for_each_entry(gem_request, &dev_priv->mm.request_list, list) {
+               seq_printf(m, "    %d @ %d\n",
+                          gem_request->seqno,
+                          (int) (jiffies - gem_request->emitted_jiffies));
+       }
+       return 0;
+}
+
+static int i915_gem_seqno_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+
+       if (dev_priv->hw_status_page != NULL) {
+               seq_printf(m, "Current sequence: %d\n",
+                          i915_get_gem_seqno(dev));
+       } else {
+               seq_printf(m, "Current sequence: hws uninitialized\n");
+       }
+       seq_printf(m, "Waiter sequence:  %d\n",
+                       dev_priv->mm.waiting_gem_seqno);
+       seq_printf(m, "IRQ sequence:     %d\n", dev_priv->mm.irq_gem_seqno);
+       return 0;
+}
+
+
+static int i915_interrupt_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+
+       seq_printf(m, "Interrupt enable:    %08x\n",
+                  I915_READ(IER));
+       seq_printf(m, "Interrupt identity:  %08x\n",
+                  I915_READ(IIR));
+       seq_printf(m, "Interrupt mask:      %08x\n",
+                  I915_READ(IMR));
+       seq_printf(m, "Pipe A stat:         %08x\n",
+                  I915_READ(PIPEASTAT));
+       seq_printf(m, "Pipe B stat:         %08x\n",
+                  I915_READ(PIPEBSTAT));
+       seq_printf(m, "Interrupts received: %d\n",
+                  atomic_read(&dev_priv->irq_received));
+       if (dev_priv->hw_status_page != NULL) {
+               seq_printf(m, "Current sequence:    %d\n",
+                          i915_get_gem_seqno(dev));
+       } else {
+               seq_printf(m, "Current sequence:    hws uninitialized\n");
+       }
+       seq_printf(m, "Waiter sequence:     %d\n",
+                  dev_priv->mm.waiting_gem_seqno);
+       seq_printf(m, "IRQ sequence:        %d\n",
+                  dev_priv->mm.irq_gem_seqno);
+       return 0;
+}
+
+static int i915_hws_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;
+       drm_i915_private_t *dev_priv = dev->dev_private;
+       int i;
+       volatile u32 *hws;
+
+       hws = (volatile u32 *)dev_priv->hw_status_page;
+       if (hws == NULL)
+               return 0;
+
+       for (i = 0; i < 4096 / sizeof(u32) / 4; i += 4) {
+               seq_printf(m, "0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
+                          i * 4,
+                          hws[i], hws[i + 1], hws[i + 2], hws[i + 3]);
+       }
+       return 0;
+}
+
+static struct drm_info_list i915_gem_debugfs_list[] = {
+       {"i915_gem_active", i915_gem_active_info, 0},
+       {"i915_gem_flushing", i915_gem_flushing_info, 0},
+       {"i915_gem_inactive", i915_gem_inactive_info, 0},
+       {"i915_gem_request", i915_gem_request_info, 0},
+       {"i915_gem_seqno", i915_gem_seqno_info, 0},
+       {"i915_gem_interrupt", i915_interrupt_info, 0},
+       {"i915_gem_hws", i915_hws_info, 0},
+};
+#define I915_GEM_DEBUGFS_ENTRIES ARRAY_SIZE(i915_gem_debugfs_list)
+
+int i915_gem_debugfs_init(struct drm_minor *minor)
+{
+       return drm_debugfs_create_files(i915_gem_debugfs_list,
+                                       I915_GEM_DEBUGFS_ENTRIES,
+                                       minor->debugfs_root, minor);
+}
+
+void i915_gem_debugfs_cleanup(struct drm_minor *minor)
+{
+       drm_debugfs_remove_files(i915_gem_debugfs_list,
+                                I915_GEM_DEBUGFS_ENTRIES, minor);
+}
+
+#endif /* CONFIG_DEBUG_FS */
+
diff --git a/drivers/gpu/drm/i915/i915_gem_proc.c b/drivers/gpu/drm/i915/i915_gem_proc.c
deleted file mode 100644 (file)
index 4d1b9de..0000000
+++ /dev/null
@@ -1,334 +0,0 @@
-/*
- * Copyright © 2008 Intel Corporation
- *
- * 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
- * THE AUTHORS OR COPYRIGHT HOLDERS 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.
- *
- * Authors:
- *    Eric Anholt <eric@anholt.net>
- *    Keith Packard <keithp@keithp.com>
- *
- */
-
-#include "drmP.h"
-#include "drm.h"
-#include "i915_drm.h"
-#include "i915_drv.h"
-
-static int i915_gem_active_info(char *buf, char **start, off_t offset,
-                               int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       struct drm_i915_gem_object *obj_priv;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("Active:\n");
-       list_for_each_entry(obj_priv, &dev_priv->mm.active_list,
-                           list)
-       {
-               struct drm_gem_object *obj = obj_priv->obj;
-               if (obj->name) {
-                       DRM_PROC_PRINT("    %p(%d): %08x %08x %d\n",
-                                      obj, obj->name,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               } else {
-                       DRM_PROC_PRINT("       %p: %08x %08x %d\n",
-                                      obj,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               }
-       }
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int i915_gem_flushing_info(char *buf, char **start, off_t offset,
-                                 int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       struct drm_i915_gem_object *obj_priv;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("Flushing:\n");
-       list_for_each_entry(obj_priv, &dev_priv->mm.flushing_list,
-                           list)
-       {
-               struct drm_gem_object *obj = obj_priv->obj;
-               if (obj->name) {
-                       DRM_PROC_PRINT("    %p(%d): %08x %08x %d\n",
-                                      obj, obj->name,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               } else {
-                       DRM_PROC_PRINT("       %p: %08x %08x %d\n", obj,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               }
-       }
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int i915_gem_inactive_info(char *buf, char **start, off_t offset,
-                                 int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       struct drm_i915_gem_object *obj_priv;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("Inactive:\n");
-       list_for_each_entry(obj_priv, &dev_priv->mm.inactive_list,
-                           list)
-       {
-               struct drm_gem_object *obj = obj_priv->obj;
-               if (obj->name) {
-                       DRM_PROC_PRINT("    %p(%d): %08x %08x %d\n",
-                                      obj, obj->name,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               } else {
-                       DRM_PROC_PRINT("       %p: %08x %08x %d\n", obj,
-                                      obj->read_domains, obj->write_domain,
-                                      obj_priv->last_rendering_seqno);
-               }
-       }
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int i915_gem_request_info(char *buf, char **start, off_t offset,
-                                int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       struct drm_i915_gem_request *gem_request;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("Request:\n");
-       list_for_each_entry(gem_request, &dev_priv->mm.request_list,
-                           list)
-       {
-               DRM_PROC_PRINT("    %d @ %d\n",
-                              gem_request->seqno,
-                              (int) (jiffies - gem_request->emitted_jiffies));
-       }
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int i915_gem_seqno_info(char *buf, char **start, off_t offset,
-                              int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       if (dev_priv->hw_status_page != NULL) {
-               DRM_PROC_PRINT("Current sequence: %d\n",
-                              i915_get_gem_seqno(dev));
-       } else {
-               DRM_PROC_PRINT("Current sequence: hws uninitialized\n");
-       }
-       DRM_PROC_PRINT("Waiter sequence:  %d\n",
-                      dev_priv->mm.waiting_gem_seqno);
-       DRM_PROC_PRINT("IRQ sequence:     %d\n", dev_priv->mm.irq_gem_seqno);
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-
-static int i915_interrupt_info(char *buf, char **start, off_t offset,
-                              int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       int len = 0;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       DRM_PROC_PRINT("Interrupt enable:    %08x\n",
-                      I915_READ(IER));
-       DRM_PROC_PRINT("Interrupt identity:  %08x\n",
-                      I915_READ(IIR));
-       DRM_PROC_PRINT("Interrupt mask:      %08x\n",
-                      I915_READ(IMR));
-       DRM_PROC_PRINT("Pipe A stat:         %08x\n",
-                      I915_READ(PIPEASTAT));
-       DRM_PROC_PRINT("Pipe B stat:         %08x\n",
-                      I915_READ(PIPEBSTAT));
-       DRM_PROC_PRINT("Interrupts received: %d\n",
-                      atomic_read(&dev_priv->irq_received));
-       if (dev_priv->hw_status_page != NULL) {
-               DRM_PROC_PRINT("Current sequence:    %d\n",
-                              i915_get_gem_seqno(dev));
-       } else {
-               DRM_PROC_PRINT("Current sequence:    hws uninitialized\n");
-       }
-       DRM_PROC_PRINT("Waiter sequence:     %d\n",
-                      dev_priv->mm.waiting_gem_seqno);
-       DRM_PROC_PRINT("IRQ sequence:        %d\n",
-                      dev_priv->mm.irq_gem_seqno);
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static int i915_hws_info(char *buf, char **start, off_t offset,
-                        int request, int *eof, void *data)
-{
-       struct drm_minor *minor = (struct drm_minor *) data;
-       struct drm_device *dev = minor->dev;
-       drm_i915_private_t *dev_priv = dev->dev_private;
-       int len = 0, i;
-       volatile u32 *hws;
-
-       if (offset > DRM_PROC_LIMIT) {
-               *eof = 1;
-               return 0;
-       }
-
-       hws = (volatile u32 *)dev_priv->hw_status_page;
-       if (hws == NULL) {
-               *eof = 1;
-               return 0;
-       }
-
-       *start = &buf[offset];
-       *eof = 0;
-       for (i = 0; i < 4096 / sizeof(u32) / 4; i += 4) {
-               DRM_PROC_PRINT("0x%08x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
-                              i * 4,
-                              hws[i], hws[i + 1], hws[i + 2], hws[i + 3]);
-       }
-       if (len > request + offset)
-               return request;
-       *eof = 1;
-       return len - offset;
-}
-
-static struct drm_proc_list {
-       /** file name */
-       const char *name;
-       /** proc callback*/
-       int (*f) (char *, char **, off_t, int, int *, void *);
-} i915_gem_proc_list[] = {
-       {"i915_gem_active", i915_gem_active_info},
-       {"i915_gem_flushing", i915_gem_flushing_info},
-       {"i915_gem_inactive", i915_gem_inactive_info},
-       {"i915_gem_request", i915_gem_request_info},
-       {"i915_gem_seqno", i915_gem_seqno_info},
-       {"i915_gem_interrupt", i915_interrupt_info},
-       {"i915_gem_hws", i915_hws_info},
-};
-
-#define I915_GEM_PROC_ENTRIES ARRAY_SIZE(i915_gem_proc_list)
-
-int i915_gem_proc_init(struct drm_minor *minor)
-{
-       struct proc_dir_entry *ent;
-       int i, j;
-
-       for (i = 0; i < I915_GEM_PROC_ENTRIES; i++) {
-               ent = create_proc_entry(i915_gem_proc_list[i].name,
-                                       S_IFREG | S_IRUGO, minor->dev_root);
-               if (!ent) {
-                       DRM_ERROR("Cannot create /proc/dri/.../%s\n",
-                                 i915_gem_proc_list[i].name);
-                       for (j = 0; j < i; j++)
-                               remove_proc_entry(i915_gem_proc_list[i].name,
-                                                 minor->dev_root);
-                       return -1;
-               }
-               ent->read_proc = i915_gem_proc_list[i].f;
-               ent->data = minor;
-       }
-       return 0;
-}
-
-void i915_gem_proc_cleanup(struct drm_minor *minor)
-{
-       int i;
-
-       if (!minor->dev_root)
-               return;
-
-       for (i = 0; i < I915_GEM_PROC_ENTRIES; i++)
-               remove_proc_entry(i915_gem_proc_list[i].name, minor->dev_root);
-}
index 458e38e..ccbcd13 100644 (file)
@@ -770,6 +770,8 @@ struct drm_driver {
 
        int (*proc_init)(struct drm_minor *minor);
        void (*proc_cleanup)(struct drm_minor *minor);
+       int (*debugfs_init)(struct drm_minor *minor);
+       void (*debugfs_cleanup)(struct drm_minor *minor);
 
        /**
         * Driver-specific constructor for drm_gem_objects, to set up
@@ -805,6 +807,48 @@ struct drm_driver {
 #define DRM_MINOR_CONTROL 2
 #define DRM_MINOR_RENDER 3
 
+
+/**
+ * debugfs node list. This structure represents a debugfs file to
+ * be created by the drm core
+ */
+struct drm_debugfs_list {
+       const char *name; /** file name */
+       int (*show)(struct seq_file*, void*); /** show callback */
+       u32 driver_features; /**< Required driver features for this entry */
+};
+
+/**
+ * debugfs node structure. This structure represents a debugfs file.
+ */
+struct drm_debugfs_node {
+       struct list_head list;
+       struct drm_minor *minor;
+       struct drm_debugfs_list *debugfs_ent;
+       struct dentry *dent;
+};
+
+/**
+ * Info file list entry. This structure represents a debugfs or proc file to
+ * be created by the drm core
+ */
+struct drm_info_list {
+       const char *name; /** file name */
+       int (*show)(struct seq_file*, void*); /** show callback */
+       u32 driver_features; /**< Required driver features for this entry */
+       void *data;
+};
+
+/**
+ * debugfs node structure. This structure represents a debugfs file.
+ */
+struct drm_info_node {
+       struct list_head list;
+       struct drm_minor *minor;
+       struct drm_info_list *info_ent;
+       struct dentry *dent;
+};
+
 /**
  * DRM minor structure. This structure represents a drm minor number.
  */
@@ -814,7 +858,12 @@ struct drm_minor {
        dev_t device;                   /**< Device number for mknod */
        struct device kdev;             /**< Linux device */
        struct drm_device *dev;
-       struct proc_dir_entry *dev_root;  /**< proc directory entry */
+
+       struct proc_dir_entry *proc_root;  /**< proc directory entry */
+       struct drm_info_node proc_nodes;
+       struct dentry *debugfs_root;
+       struct drm_info_node debugfs_nodes;
+
        struct drm_master *master; /* currently active master for this node */
        struct list_head master_list;
        struct drm_mode_group mode_group;
@@ -1270,6 +1319,7 @@ extern unsigned int drm_debug;
 
 extern struct class *drm_class;
 extern struct proc_dir_entry *drm_proc_root;
+extern struct dentry *drm_debugfs_root;
 
 extern struct idr drm_minors_idr;
 
@@ -1280,6 +1330,31 @@ extern int drm_proc_init(struct drm_minor *minor, int minor_id,
                         struct proc_dir_entry *root);
 extern int drm_proc_cleanup(struct drm_minor *minor, struct proc_dir_entry *root);
 
+                               /* Debugfs support */
+#if defined(CONFIG_DEBUG_FS)
+extern int drm_debugfs_init(struct drm_minor *minor, int minor_id,
+                           struct dentry *root);
+extern int drm_debugfs_create_files(struct drm_info_list *files, int count,
+                                   struct dentry *root, struct drm_minor *minor);
+extern int drm_debugfs_remove_files(struct drm_info_list *files, int count,
+                                    struct drm_minor *minor);
+extern int drm_debugfs_cleanup(struct drm_minor *minor);
+#endif
+
+                               /* Info file support */
+extern int drm_name_info(struct seq_file *m, void *data);
+extern int drm_vm_info(struct seq_file *m, void *data);
+extern int drm_queues_info(struct seq_file *m, void *data);
+extern int drm_bufs_info(struct seq_file *m, void *data);
+extern int drm_vblank_info(struct seq_file *m, void *data);
+extern int drm_clients_info(struct seq_file *m, void* data);
+extern int drm_gem_name_info(struct seq_file *m, void *data);
+extern int drm_gem_object_info(struct seq_file *m, void* data);
+
+#if DRM_DEBUG_CODE
+extern int drm_vma_info(struct seq_file *m, void *data);
+#endif
+
                                /* Scatter Gather Support (drm_scatter.h) */
 extern void drm_sg_cleanup(struct drm_sg_mem * entry);
 extern int drm_sg_alloc_ioctl(struct drm_device *dev, void *data,