drm: Replace filp in ioctl arguments with drm_file *file_priv.

As a fallout, replace filp storage with file_priv storage for "unique
identifier of a client" all over the DRM.  There is a 1:1 mapping, so this
should be a noop.  This could be a minor performance improvement, as everyth
on Linux dereferenced filp to get file_priv anyway, while only the mmap ioct
went the other direction.

Signed-off-by: Dave Airlie <airlied@linux.ie>

1 files changed, 17 insertions, 17 deletions

diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 7bc51bac450d..1100c51aa4d6 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -242,6 +242,7 @@ static int drm_open_helper(struct inode *inode, struct file *filp,
 
         memset(priv, 0, sizeof(*priv));
         filp->private_data = priv;
+        priv->filp = filp;
         priv->uid = current->euid;
         priv->pid = current->pid;
         priv->minor = minor;
@@ -312,7 +313,7 @@ EXPORT_SYMBOL(drm_fasync);
  * Release file.
  *
  * \param inode device inode
- * \param filp file pointer.
+ * \param file_priv DRM file private.
  * \return zero on success or a negative number on failure.
  *
  * If the hardware lock is held then free it, and take it again for the kernel
@@ -322,29 +323,28 @@ EXPORT_SYMBOL(drm_fasync);
  */
 int drm_release(struct inode *inode, struct file *filp)
 {
-        struct drm_file *priv = filp->private_data;
-        struct drm_device *dev;
+        struct drm_file *file_priv = filp->private_data;
+        struct drm_device *dev = file_priv->head->dev;
         int retcode = 0;
 
         lock_kernel();
-        dev = priv->head->dev;
 
         DRM_DEBUG("open_count = %d\n", dev->open_count);
 
         if (dev->driver->preclose)
-                dev->driver->preclose(dev, filp);
+                dev->driver->preclose(dev, file_priv);
 
         /* ========================================================
          * Begin inline drm_release
          */
 
         DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
-                  current->pid, (long)old_encode_dev(priv->head->device),
+                  current->pid, (long)old_encode_dev(file_priv->head->device),
                   dev->open_count);
 
         if (dev->driver->reclaim_buffers_locked && dev->lock.hw_lock) {
-                if (drm_i_have_hw_lock(filp)) {
-                        dev->driver->reclaim_buffers_locked(dev, filp);
+                if (drm_i_have_hw_lock(file_priv)) {
+                        dev->driver->reclaim_buffers_locked(dev, file_priv);
                 } else {
                         unsigned long _end=jiffies + 3*DRM_HZ;
                         int locked = 0;
@@ -370,7 +370,7 @@ int drm_release(struct inode *inode, struct file *filp)
                                           "\tI will go on reclaiming the buffers anyway.\n");
                         }
 
-                        dev->driver->reclaim_buffers_locked(dev, filp);
+                        dev->driver->reclaim_buffers_locked(dev, file_priv);
                         drm_idlelock_release(&dev->lock);
                 }
         }
@@ -378,12 +378,12 @@ int drm_release(struct inode *inode, struct file *filp)
         if (dev->driver->reclaim_buffers_idlelocked && dev->lock.hw_lock) {
 
                 drm_idlelock_take(&dev->lock);
-                dev->driver->reclaim_buffers_idlelocked(dev, filp);
+                dev->driver->reclaim_buffers_idlelocked(dev, file_priv);
                 drm_idlelock_release(&dev->lock);
 
         }
 
-        if (drm_i_have_hw_lock(filp)) {
+        if (drm_i_have_hw_lock(file_priv)) {
                 DRM_DEBUG("File %p released, freeing lock for context %d\n",
                           filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
 
@@ -394,7 +394,7 @@ int drm_release(struct inode *inode, struct file *filp)
 
         if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
             !dev->driver->reclaim_buffers_locked) {
-                dev->driver->reclaim_buffers(dev, filp);
+                dev->driver->reclaim_buffers(dev, file_priv);
         }
 
         drm_fasync(-1, filp, 0);
@@ -404,7 +404,7 @@ int drm_release(struct inode *inode, struct file *filp)
                 struct drm_ctx_list *pos, *n;
 
                 list_for_each_entry_safe(pos, n, &dev->ctxlist, head) {
-                        if (pos->tag == priv &&
+                        if (pos->tag == file_priv &&
                             pos->handle != DRM_KERNEL_CONTEXT) {
                                 if (dev->driver->context_dtor)
                                         dev->driver->context_dtor(dev,
@@ -421,18 +421,18 @@ int drm_release(struct inode *inode, struct file *filp)
         mutex_unlock(&dev->ctxlist_mutex);
 
         mutex_lock(&dev->struct_mutex);
-        if (priv->remove_auth_on_close == 1) {
+        if (file_priv->remove_auth_on_close == 1) {
                 struct drm_file *temp;
 
                 list_for_each_entry(temp, &dev->filelist, lhead)
                         temp->authenticated = 0;
         }
-        list_del(&priv->lhead);
+        list_del(&file_priv->lhead);
         mutex_unlock(&dev->struct_mutex);
 
         if (dev->driver->postclose)
-                dev->driver->postclose(dev, priv);
-        drm_free(priv, sizeof(*priv), DRM_MEM_FILES);
+                dev->driver->postclose(dev, file_priv);
+        drm_free(file_priv, sizeof(*file_priv), DRM_MEM_FILES);
 
         /* ========================================================
          * End inline drm_release