drm: fix driver deadlock with AIGLX and reclaim_buffers_locked

Bugzilla Bug #9457

Add refcounting of user waiters to the DRM hardware lock, so that we can use
DRM_LOCK_CONT flag more conservatively.

Also add a kernel waiter refcount that if nonzero transfers the lock for the
kernel context when it is released. This is useful when waiting for idle and can be used for very simple fence object driver implementations for the new memory manager

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

1 files changed, 44 insertions, 46 deletions

diff --git a/drivers/char/drm/drm_fops.c b/drivers/char/drm/drm_fops.c
index 314abd9d6510..3b159cab3bc8 100644
--- a/drivers/char/drm/drm_fops.c
+++ b/drivers/char/drm/drm_fops.c
@@ -356,58 +356,56 @@ int drm_release(struct inode *inode, struct file *filp)
                   current->pid, (long)old_encode_dev(priv->head->device),
                   dev->open_count);
 
-        if (priv->lock_count && dev->lock.hw_lock &&
-            _DRM_LOCK_IS_HELD(dev->lock.hw_lock->lock) &&
-            dev->lock.filp == filp) {
-                DRM_DEBUG("File %p released, freeing lock for context %d\n",
-                          filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-
-                if (dev->driver->reclaim_buffers_locked)
+        if (dev->driver->reclaim_buffers_locked && dev->lock.hw_lock) {
+                if (drm_i_have_hw_lock(filp)) {
                         dev->driver->reclaim_buffers_locked(dev, filp);
-
-                drm_lock_free(dev, &dev->lock.hw_lock->lock,
-                              _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
-
-                /* FIXME: may require heavy-handed reset of
-                   hardware at this point, possibly
-                   processed via a callback to the X
-                   server. */
-        } else if (dev->driver->reclaim_buffers_locked && priv->lock_count
-                   && dev->lock.hw_lock) {
-                /* The lock is required to reclaim buffers */
-                DECLARE_WAITQUEUE(entry, current);
-
-                add_wait_queue(&dev->lock.lock_queue, &entry);
-                for (;;) {
-                        __set_current_state(TASK_INTERRUPTIBLE);
-                        if (!dev->lock.hw_lock) {
-                                /* Device has been unregistered */
-                                retcode = -EINTR;
-                                break;
+                } else {
+                        unsigned long _end=jiffies + 3*DRM_HZ;
+                        int locked = 0;
+
+                        drm_idlelock_take(&dev->lock);
+
+                        /*
+                         * Wait for a while.
+                         */
+
+                        do{
+                                spin_lock(&dev->lock.spinlock);
+                                locked = dev->lock.idle_has_lock;
+                                spin_unlock(&dev->lock.spinlock);
+                                if (locked)
+                                        break;
+                                schedule();
+                        } while (!time_after_eq(jiffies, _end));
+
+                        if (!locked) {
+                                DRM_ERROR("reclaim_buffers_locked() deadlock. Please rework this\n"
+                                          "\tdriver to use reclaim_buffers_idlelocked() instead.\n"
+                                          "\tI will go on reclaiming the buffers anyway.\n");
                         }
-                        if (drm_lock_take(&dev->lock.hw_lock->lock,
-                                          DRM_KERNEL_CONTEXT)) {
-                                dev->lock.filp = filp;
-                                dev->lock.lock_time = jiffies;
-                                atomic_inc(&dev->counts[_DRM_STAT_LOCKS]);
-                                break;  /* Got lock */
-                        }
-                        /* Contention */
-                        schedule();
-                        if (signal_pending(current)) {
-                                retcode = -ERESTARTSYS;
-                                break;
-                        }
-                }
-                __set_current_state(TASK_RUNNING);
-                remove_wait_queue(&dev->lock.lock_queue, &entry);
-                if (!retcode) {
+
                         dev->driver->reclaim_buffers_locked(dev, filp);
-                        drm_lock_free(dev, &dev->lock.hw_lock->lock,
-                                      DRM_KERNEL_CONTEXT);
+                        drm_idlelock_release(&dev->lock);
                 }
         }
 
+        if (dev->driver->reclaim_buffers_idlelocked && dev->lock.hw_lock) {
+
+                drm_idlelock_take(&dev->lock);
+                dev->driver->reclaim_buffers_idlelocked(dev, filp);
+                drm_idlelock_release(&dev->lock);
+
+        }
+
+        if (drm_i_have_hw_lock(filp)) {
+                DRM_DEBUG("File %p released, freeing lock for context %d\n",
+                          filp, _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
+
+                drm_lock_free(&dev->lock,
+                              _DRM_LOCKING_CONTEXT(dev->lock.hw_lock->lock));
+        }
+
+
         if (drm_core_check_feature(dev, DRIVER_HAVE_DMA) &&
             !dev->driver->reclaim_buffers_locked) {
                 dev->driver->reclaim_buffers(dev, filp);