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 "drmP.h" 38 39 static int drm_notifier(void *priv); 40 41 static int drm_lock_take(struct drm_lock_data *lock_data, unsigned int context); 42 43 /** 44 * Lock ioctl. 45 * 46 * \param inode device inode. 47 * \param file_priv DRM file private. 48 * \param cmd command. 49 * \param arg user argument, pointing to a drm_lock structure. 50 * \return zero on success or negative number on failure. 51 * 52 * Add the current task to the lock wait queue, and attempt to take to lock. 53 */ 54 int drm_lock(struct drm_device *dev, void *data, struct drm_file *file_priv) 55 { 56 DECLARE_WAITQUEUE(entry, current); 57 struct drm_lock *lock = data; 58 struct drm_master *master = file_priv->master; 59 int ret = 0; 60 61 ++file_priv->lock_count; 62 63 if (lock->context == DRM_KERNEL_CONTEXT) { 64 DRM_ERROR("Process %d using kernel context %d\n", 65 task_pid_nr(current), lock->context); 66 return -EINVAL; 67 } 68 69 DRM_DEBUG("%d (pid %d) requests lock (0x%08x), flags = 0x%08x\n", 70 lock->context, task_pid_nr(current), 71 master->lock.hw_lock->lock, lock->flags); 72 73 if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE)) 74 if (lock->context < 0) 75 return -EINVAL; 76 77 add_wait_queue(&master->lock.lock_queue, &entry); 78 spin_lock_bh(&master->lock.spinlock); 79 master->lock.user_waiters++; 80 spin_unlock_bh(&master->lock.spinlock); 81 82 for (;;) { 83 __set_current_state(TASK_INTERRUPTIBLE); 84 if (!master->lock.hw_lock) { 85 /* Device has been unregistered */ 86 send_sig(SIGTERM, current, 0); 87 ret = -EINTR; 88 break; 89 } 90 if (drm_lock_take(&master->lock, lock->context)) { 91 master->lock.file_priv = file_priv; 92 master->lock.lock_time = jiffies; 93 atomic_inc(&dev->counts[_DRM_STAT_LOCKS]); 94 break; /* Got lock */ 95 } 96 97 /* Contention */ 98 mutex_unlock(&drm_global_mutex); 99 schedule(); 100 mutex_lock(&drm_global_mutex); 101 if (signal_pending(current)) { 102 ret = -EINTR; 103 break; 104 } 105 } 106 spin_lock_bh(&master->lock.spinlock); 107 master->lock.user_waiters--; 108 spin_unlock_bh(&master->lock.spinlock); 109 __set_current_state(TASK_RUNNING); 110 remove_wait_queue(&master->lock.lock_queue, &entry); 111 112 DRM_DEBUG("%d %s\n", lock->context, 113 ret ? "interrupted" : "has lock"); 114 if (ret) return ret; 115 116 /* don't set the block all signals on the master process for now 117 * really probably not the correct answer but lets us debug xkb 118 * xserver for now */ 119 if (!file_priv->is_master) { 120 sigemptyset(&dev->sigmask); 121 sigaddset(&dev->sigmask, SIGSTOP); 122 sigaddset(&dev->sigmask, SIGTSTP); 123 sigaddset(&dev->sigmask, SIGTTIN); 124 sigaddset(&dev->sigmask, SIGTTOU); 125 dev->sigdata.context = lock->context; 126 dev->sigdata.lock = master->lock.hw_lock; 127 block_all_signals(drm_notifier, &dev->sigdata, &dev->sigmask); 128 } 129 130 if (dev->driver->dma_quiescent && (lock->flags & _DRM_LOCK_QUIESCENT)) 131 { 132 if (dev->driver->dma_quiescent(dev)) { 133 DRM_DEBUG("%d waiting for DMA quiescent\n", 134 lock->context); 135 return -EBUSY; 136 } 137 } 138 139 return 0; 140 } 141 142 /** 143 * Unlock ioctl. 144 * 145 * \param inode device inode. 146 * \param file_priv DRM file private. 147 * \param cmd command. 148 * \param arg user argument, pointing to a drm_lock structure. 149 * \return zero on success or negative number on failure. 150 * 151 * Transfer and free the lock. 152 */ 153 int drm_unlock(struct drm_device *dev, void *data, struct drm_file *file_priv) 154 { 155 struct drm_lock *lock = data; 156 struct drm_master *master = file_priv->master; 157 158 if (lock->context == DRM_KERNEL_CONTEXT) { 159 DRM_ERROR("Process %d using kernel context %d\n", 160 task_pid_nr(current), lock->context); 161 return -EINVAL; 162 } 163 164 atomic_inc(&dev->counts[_DRM_STAT_UNLOCKS]); 165 166 if (drm_lock_free(&master->lock, lock->context)) { 167 /* FIXME: Should really bail out here. */ 168 } 169 170 unblock_all_signals(); 171 return 0; 172 } 173 174 /** 175 * Take the heavyweight lock. 176 * 177 * \param lock lock pointer. 178 * \param context locking context. 179 * \return one if the lock is held, or zero otherwise. 180 * 181 * Attempt to mark the lock as held by the given context, via the \p cmpxchg instruction. 182 */ 183 static 184 int drm_lock_take(struct drm_lock_data *lock_data, 185 unsigned int context) 186 { 187 unsigned int old, new, prev; 188 volatile unsigned int *lock = &lock_data->hw_lock->lock; 189 190 spin_lock_bh(&lock_data->spinlock); 191 do { 192 old = *lock; 193 if (old & _DRM_LOCK_HELD) 194 new = old | _DRM_LOCK_CONT; 195 else { 196 new = context | _DRM_LOCK_HELD | 197 ((lock_data->user_waiters + lock_data->kernel_waiters > 1) ? 198 _DRM_LOCK_CONT : 0); 199 } 200 prev = cmpxchg(lock, old, new); 201 } while (prev != old); 202 spin_unlock_bh(&lock_data->spinlock); 203 204 if (_DRM_LOCKING_CONTEXT(old) == context) { 205 if (old & _DRM_LOCK_HELD) { 206 if (context != DRM_KERNEL_CONTEXT) { 207 DRM_ERROR("%d holds heavyweight lock\n", 208 context); 209 } 210 return 0; 211 } 212 } 213 214 if ((_DRM_LOCKING_CONTEXT(new)) == context && (new & _DRM_LOCK_HELD)) { 215 /* Have lock */ 216 return 1; 217 } 218 return 0; 219 } 220 221 /** 222 * This takes a lock forcibly and hands it to context. Should ONLY be used 223 * inside *_unlock to give lock to kernel before calling *_dma_schedule. 224 * 225 * \param dev DRM device. 226 * \param lock lock pointer. 227 * \param context locking context. 228 * \return always one. 229 * 230 * Resets the lock file pointer. 231 * Marks the lock as held by the given context, via the \p cmpxchg instruction. 232 */ 233 static int drm_lock_transfer(struct drm_lock_data *lock_data, 234 unsigned int context) 235 { 236 unsigned int old, new, prev; 237 volatile unsigned int *lock = &lock_data->hw_lock->lock; 238 239 lock_data->file_priv = NULL; 240 do { 241 old = *lock; 242 new = context | _DRM_LOCK_HELD; 243 prev = cmpxchg(lock, old, new); 244 } while (prev != old); 245 return 1; 246 } 247 248 /** 249 * Free lock. 250 * 251 * \param dev DRM device. 252 * \param lock lock. 253 * \param context context. 254 * 255 * Resets the lock file pointer. 256 * Marks the lock as not held, via the \p cmpxchg instruction. Wakes any task 257 * waiting on the lock queue. 258 */ 259 int drm_lock_free(struct drm_lock_data *lock_data, unsigned int context) 260 { 261 unsigned int old, new, prev; 262 volatile unsigned int *lock = &lock_data->hw_lock->lock; 263 264 spin_lock_bh(&lock_data->spinlock); 265 if (lock_data->kernel_waiters != 0) { 266 drm_lock_transfer(lock_data, 0); 267 lock_data->idle_has_lock = 1; 268 spin_unlock_bh(&lock_data->spinlock); 269 return 1; 270 } 271 spin_unlock_bh(&lock_data->spinlock); 272 273 do { 274 old = *lock; 275 new = _DRM_LOCKING_CONTEXT(old); 276 prev = cmpxchg(lock, old, new); 277 } while (prev != old); 278 279 if (_DRM_LOCK_IS_HELD(old) && _DRM_LOCKING_CONTEXT(old) != context) { 280 DRM_ERROR("%d freed heavyweight lock held by %d\n", 281 context, _DRM_LOCKING_CONTEXT(old)); 282 return 1; 283 } 284 wake_up_interruptible(&lock_data->lock_queue); 285 return 0; 286 } 287 288 /** 289 * If we get here, it means that the process has called DRM_IOCTL_LOCK 290 * without calling DRM_IOCTL_UNLOCK. 291 * 292 * If the lock is not held, then let the signal proceed as usual. If the lock 293 * is held, then set the contended flag and keep the signal blocked. 294 * 295 * \param priv pointer to a drm_sigdata structure. 296 * \return one if the signal should be delivered normally, or zero if the 297 * signal should be blocked. 298 */ 299 static int drm_notifier(void *priv) 300 { 301 struct drm_sigdata *s = (struct drm_sigdata *) priv; 302 unsigned int old, new, prev; 303 304 /* Allow signal delivery if lock isn't held */ 305 if (!s->lock || !_DRM_LOCK_IS_HELD(s->lock->lock) 306 || _DRM_LOCKING_CONTEXT(s->lock->lock) != s->context) 307 return 1; 308 309 /* Otherwise, set flag to force call to 310 drmUnlock */ 311 do { 312 old = s->lock->lock; 313 new = old | _DRM_LOCK_CONT; 314 prev = cmpxchg(&s->lock->lock, old, new); 315 } while (prev != old); 316 return 0; 317 } 318 319 /** 320 * This function returns immediately and takes the hw lock 321 * with the kernel context if it is free, otherwise it gets the highest priority when and if 322 * it is eventually released. 323 * 324 * This guarantees that the kernel will _eventually_ have the lock _unless_ it is held 325 * by a blocked process. (In the latter case an explicit wait for the hardware lock would cause 326 * a deadlock, which is why the "idlelock" was invented). 327 * 328 * This should be sufficient to wait for GPU idle without 329 * having to worry about starvation. 330 */ 331 332 void drm_idlelock_take(struct drm_lock_data *lock_data) 333 { 334 int ret = 0; 335 336 spin_lock_bh(&lock_data->spinlock); 337 lock_data->kernel_waiters++; 338 if (!lock_data->idle_has_lock) { 339 340 spin_unlock_bh(&lock_data->spinlock); 341 ret = drm_lock_take(lock_data, DRM_KERNEL_CONTEXT); 342 spin_lock_bh(&lock_data->spinlock); 343 344 if (ret == 1) 345 lock_data->idle_has_lock = 1; 346 } 347 spin_unlock_bh(&lock_data->spinlock); 348 } 349 EXPORT_SYMBOL(drm_idlelock_take); 350 351 void drm_idlelock_release(struct drm_lock_data *lock_data) 352 { 353 unsigned int old, prev; 354 volatile unsigned int *lock = &lock_data->hw_lock->lock; 355 356 spin_lock_bh(&lock_data->spinlock); 357 if (--lock_data->kernel_waiters == 0) { 358 if (lock_data->idle_has_lock) { 359 do { 360 old = *lock; 361 prev = cmpxchg(lock, old, DRM_KERNEL_CONTEXT); 362 } while (prev != old); 363 wake_up_interruptible(&lock_data->lock_queue); 364 lock_data->idle_has_lock = 0; 365 } 366 } 367 spin_unlock_bh(&lock_data->spinlock); 368 } 369 EXPORT_SYMBOL(drm_idlelock_release); 370 371 int drm_i_have_hw_lock(struct drm_device *dev, struct drm_file *file_priv) 372 { 373 struct drm_master *master = file_priv->master; 374 return (file_priv->lock_count && master->lock.hw_lock && 375 _DRM_LOCK_IS_HELD(master->lock.hw_lock->lock) && 376 master->lock.file_priv == file_priv); 377 } 378