drivers/gpu/drm/drm_lock.c

   1 /**
   2  * \file drm_lock.c
   3  * IOCTLs for locking
   4  *
   5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
   6  * \author Gareth Hughes <gareth@valinux.com>
   7  */
   8
   9 /*
  10  * Created: Tue Feb  2 08:37:54 1999 by faith@valinux.com
  11  *
  12  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  13  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  14  * All Rights Reserved.
  15  *
  16  * Permission is hereby granted, free of charge, to any person obtaining a
  17  * copy of this software and associated documentation files (the "Software"),
  18  * to deal in the Software without restriction, including without limitation
  19  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  20  * and/or sell copies of the Software, and to permit persons to whom the
  21  * Software is furnished to do so, subject to the following conditions:
  22  *
  23  * The above copyright notice and this permission notice (including the next
  24  * paragraph) shall be included in all copies or substantial portions of the
  25  * Software.
  26  *
  27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  28  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  29  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  30  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  31  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  32  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  33  * OTHER DEALINGS IN THE SOFTWARE.
  34  */
  35
  36 #include <linux/export.h>
  37 #include <linux/sched/signal.h>
  38
  39 #include <drm/drmP.h>
  40 #include "drm_legacy.h"
  41 #include "drm_internal.h"
  42
  43 static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context);
  44
  45 /**
  46  * Take the heavyweight lock.
  47  *
  48  * \param lock lock pointer.
  49  * \param context locking context.
  50  * \return one if the lock is held, or zero otherwise.
  51  *
  52  * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction.
  53  */
  54 static
  55 int drm_lock_take(struct drm_lock_data *lock_data,
  56                   unsigned int context)
  57 {
  58         unsigned int old, new, prev;
  59         volatile unsigned int *lock = &lock_data->hw_lock->lock;
  60
  61         spin_lock_bh(&lock_data->spinlock);
  62         do {
  63                 old = *lock;
  64                 if (old & _DRM_LOCK_HELD)
  65                         new = old | _DRM_LOCK_CONT;
  66                 else {
  67                         new = context | _DRM_LOCK_HELD |
  68                                 ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ?
  69                                  _DRM_LOCK_CONT : 0);
  70                 }
  71                 prev = cmpxchg(lock, old, new);
  72         } while (prev != old);
  73         spin_unlock_bh(&lock_data->spinlock);
  74
  75         if (_DRM_LOCKING_CONTEXT(old) == context) {
  76                 if (old & _DRM_LOCK_HELD) {
  77                         if (context != DRM_KERNEL_CONTEXT) {
  78                                 DRM_ERROR("%d holds heavyweight lock\n",
  79                                           context);
  80                         }
  81                         return 0;
  82                 }
  83         }
  84
  85         if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) {
  86                 /* Have lock */
  87                 return 1;
  88         }
  89         return 0;
  90 }
  91
  92 /**
  93  * This takes a lock forcibly and hands it to context.  Should ONLY be used
  94  * inside *_unlock to give lock to kernel before calling *_dma_schedule.
  95  *
  96  * \param dev DRM device.
  97  * \param lock lock pointer.
  98  * \param context locking context.
  99  * \return always one.
 100  *
 101  * Resets the lock file pointer.
 102  * Marks the lock as held by the given context, via the \p cmpxchg instruction.
 103  */
 104 static int drm_lock_transfer(struct drm_lock_data *lock_data,
 105                              unsigned int context)
 106 {
 107         unsigned int old, new, prev;
 108         volatile unsigned int *lock = &lock_data->hw_lock->lock;
 109
 110         lock_data->file_priv = NULL;
 111         do {
 112                 old = *lock;
 113                 new = context | _DRM_LOCK_HELD;
 114                 prev = cmpxchg(lock, old, new);
 115         } while (prev != old);
 116         return 1;
 117 }
 118
 119 static int drm_legacy_lock_free(struct drm_lock_data *lock_data,
 120                                 unsigned int context)
 121 {
 122         unsigned int old, new, prev;
 123         volatile unsigned int *lock = &lock_data->hw_lock->lock;
 124
 125         spin_lock_bh(&lock_data->spinlock);
 126         if (lock_data->kernel_waiters != 0) {
 127                 drm_lock_transfer(lock_data, 0);
 128                 lock_data->idle_has_lock = 1;
 129                 spin_unlock_bh(&lock_data->spinlock);
 130                 return 1;
 131         }
 132         spin_unlock_bh(&lock_data->spinlock);
 133
 134         do {
 135                 old = *lock;
 136                 new = _DRM_LOCKING_CONTEXT(old);
 137                 prev = cmpxchg(lock, old, new);
 138         } while (prev != old);
 139
 140         if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) {
 141                 DRM_ERROR("%d freed heavyweight lock held by %d\n",
 142                           context, _DRM_LOCKING_CONTEXT(old));
 143                 return 1;
 144         }
 145         wake_up_interruptible(&lock_data->lock_queue);
 146         return 0;
 147 }
 148
 149 /**
 150  * Lock ioctl.
 151  *
 152  * \param inode device inode.
 153  * \param file_priv DRM file private.
 154  * \param cmd command.
 155  * \param arg user argument, pointing to a drm_lock structure.
 156  * \return zero on success or negative number on failure.
 157  *
 158  * Add the current task to the lock wait queue, and attempt to take to lock.
 159  */
 160 int drm_legacy_lock(struct drm_device *dev, void *data,
 161                     struct drm_file *file_priv)
 162 {
 163         DECLARE_WAITQUEUE(entry, current);
 164         struct drm_lock *lock = data;
 165         struct drm_master *master = file_priv->master;
 166         int ret = 0;
 167
 168         if (!drm_core_check_feature(dev, DRIVER_LEGACY))
 169                 return -EINVAL;
 170
 171         ++file_priv->lock_count;
 172
 173         if (lock->context == DRM_KERNEL_CONTEXT) {
 174                 DRM_ERROR("Process %d using kernel context %d\n",
 175                           task_pid_nr(current), lock->context);
 176                 return -EINVAL;
 177         }
 178
 179         DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n",
 180                   lock->context, task_pid_nr(current),
 181                   master->lock.hw_lock ? master->lock.hw_lock->lock : -1,
 182                   lock->flags);
 183
 184         add_wait_queue(&master->lock.lock_queue, &entry);
 185         spin_lock_bh(&master->lock.spinlock);
 186         master->lock.user_waiters++;
 187         spin_unlock_bh(&master->lock.spinlock);
 188
 189         for (;;) {
 190                 __set_current_state(TASK_INTERRUPTIBLE);
 191                 if (!master->lock.hw_lock) {
 192                         /* Device has been unregistered */
 193                         send_sig(SIGTERM, current, 0);
 194                         ret = -EINTR;
 195                         break;
 196                 }
 197                 if (drm_lock_take(&master->lock, lock->context)) {
 198                         master->lock.file_priv = file_priv;
 199                         master->lock.lock_time = jiffies;
 200                         break;  /* Got lock */
 201                 }
 202
 203                 /* Contention */
 204                 mutex_unlock(&drm_global_mutex);
 205                 schedule();
 206                 mutex_lock(&drm_global_mutex);
 207                 if (signal_pending(current)) {
 208                         ret = -EINTR;
 209                         break;
 210                 }
 211         }
 212         spin_lock_bh(&master->lock.spinlock);
 213         master->lock.user_waiters--;
 214         spin_unlock_bh(&master->lock.spinlock);
 215         __set_current_state(TASK_RUNNING);
 216         remove_wait_queue(&master->lock.lock_queue, &entry);
 217
 218         DRM_DEBUG("%d %s\n", lock->context,
 219                   ret ? "interrupted" : "has lock");
 220         if (ret) return ret;
 221
 222         /* don't set the block all signals on the master process for now
 223          * really probably not the correct answer but lets us debug xkb
 224          * xserver for now */
 225         if (!drm_is_current_master(file_priv)) {
 226                 dev->sigdata.context = lock->context;
 227                 dev->sigdata.lock = master->lock.hw_lock;
 228         }
 229
 230         if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT))
 231         {
 232                 if (dev->driver->dma_quiescent(dev)) {
 233                         DRM_DEBUG("%d waiting for DMA quiescent\n",
 234                                   lock->context);
 235                         return -EBUSY;
 236                 }
 237         }
 238
 239         return 0;
 240 }
 241
 242 /**
 243  * Unlock ioctl.
 244  *
 245  * \param inode device inode.
 246  * \param file_priv DRM file private.
 247  * \param cmd command.
 248  * \param arg user argument, pointing to a drm_lock structure.
 249  * \return zero on success or negative number on failure.
 250  *
 251  * Transfer and free the lock.
 252  */
 253 int drm_legacy_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv)
 254 {
 255         struct drm_lock *lock = data;
 256         struct drm_master *master = file_priv->master;
 257
 258         if (!drm_core_check_feature(dev, DRIVER_LEGACY))
 259                 return -EINVAL;
 260
 261         if (lock->context == DRM_KERNEL_CONTEXT) {
 262                 DRM_ERROR("Process %d using kernel context %d\n",
 263                           task_pid_nr(current), lock->context);
 264                 return -EINVAL;
 265         }
 266
 267         if (drm_legacy_lock_free(&master->lock, lock->context)) {
 268                 /* FIXME: Should really bail out here. */
 269         }
 270
 271         return 0;
 272 }
 273
 274 /**
 275  * This function returns immediately and takes the hw lock
 276  * with the kernel context if it is free, otherwise it gets the highest priority when and if
 277  * it is eventually released.
 278  *
 279  * This guarantees that the kernel will _eventually_ have the lock _unless_ it is held
 280  * by a blocked process. (In the latter case an explicit wait for the hardware lock would cause
 281  * a deadlock, which is why the "idlelock" was invented).
 282  *
 283  * This should be sufficient to wait for GPU idle without
 284  * having to worry about starvation.
 285  */
 286
 287 void drm_legacy_idlelock_take(struct drm_lock_data *lock_data)
 288 {
 289         int ret;
 290
 291         spin_lock_bh(&lock_data->spinlock);
 292         lock_data->kernel_waiters++;
 293         if (!lock_data->idle_has_lock) {
 294
 295                 spin_unlock_bh(&lock_data->spinlock);
 296                 ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT);
 297                 spin_lock_bh(&lock_data->spinlock);
 298
 299                 if (ret == 1)
 300                         lock_data->idle_has_lock = 1;
 301         }
 302         spin_unlock_bh(&lock_data->spinlock);
 303 }
 304 EXPORT_SYMBOL(drm_legacy_idlelock_take);
 305
 306 void drm_legacy_idlelock_release(struct drm_lock_data *lock_data)
 307 {
 308         unsigned int old, prev;
 309         volatile unsigned int *lock = &lock_data->hw_lock->lock;
 310
 311         spin_lock_bh(&lock_data->spinlock);
 312         if (--lock_data->kernel_waiters == 0) {
 313                 if (lock_data->idle_has_lock) {
 314                         do {
 315                                 old = *lock;
 316                                 prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT);
 317                         } while (prev != old);
 318                         wake_up_interruptible(&lock_data->lock_queue);
 319                         lock_data->idle_has_lock = 0;
 320                 }
 321         }
 322         spin_unlock_bh(&lock_data->spinlock);
 323 }
 324 EXPORT_SYMBOL(drm_legacy_idlelock_release);
 325
 326 static int drm_legacy_i_have_hw_lock(struct drm_device *dev,
 327                                      struct drm_file *file_priv)
 328 {
 329         struct drm_master *master = file_priv->master;
 330         return (file_priv->lock_count && master->lock.hw_lock &&
 331                 _DRM_LOCK_IS_HELD(master->lock.hw_lock->lock) &&
 332                 master->lock.file_priv == file_priv);
 333 }
 334
 335 void drm_legacy_lock_release(struct drm_device *dev, struct file *filp)
 336 {
 337         struct drm_file *file_priv = filp->private_data;
 338
 339         /* if the master has gone away we can't do anything with the lock */
 340         if (!dev->master)
 341                 return;
 342
 343         if (drm_legacy_i_have_hw_lock(dev, file_priv)) {
 344                 DRM_DEBUG("File %p released, freeing lock for context %d\n",
 345                           filp, _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
 346                 drm_legacy_lock_free(&file_priv->master->lock,
 347                                      _DRM_LOCKING_CONTEXT(file_priv->master->lock.hw_lock->lock));
 348         }
 349 }