1 /* 2 * Copyright (C) 2014 Red Hat 3 * Author: Rob Clark <robdclark@gmail.com> 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR 19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 21 * OTHER DEALINGS IN THE SOFTWARE. 22 */ 23 24 #include <drm/drmP.h> 25 #include <drm/drm_crtc.h> 26 #include <drm/drm_modeset_lock.h> 27 28 /** 29 * DOC: kms locking 30 * 31 * As KMS moves toward more fine grained locking, and atomic ioctl where 32 * userspace can indirectly control locking order, it becomes necessary 33 * to use ww_mutex and acquire-contexts to avoid deadlocks. But because 34 * the locking is more distributed around the driver code, we want a bit 35 * of extra utility/tracking out of our acquire-ctx. This is provided 36 * by drm_modeset_lock / drm_modeset_acquire_ctx. 37 * 38 * For basic principles of ww_mutex, see: Documentation/locking/ww-mutex-design.txt 39 * 40 * The basic usage pattern is to: 41 * 42 * drm_modeset_acquire_init(&ctx) 43 * retry: 44 * foreach (lock in random_ordered_set_of_locks) { 45 * ret = drm_modeset_lock(lock, &ctx) 46 * if (ret == -EDEADLK) { 47 * drm_modeset_backoff(&ctx); 48 * goto retry; 49 * } 50 * } 51 * ... do stuff ... 52 * drm_modeset_drop_locks(&ctx); 53 * drm_modeset_acquire_fini(&ctx); 54 */ 55 56 /** 57 * drm_modeset_lock_all - take all modeset locks 58 * @dev: DRM device 59 * 60 * This function takes all modeset locks, suitable where a more fine-grained 61 * scheme isn't (yet) implemented. Locks must be dropped by calling the 62 * drm_modeset_unlock_all() function. 63 * 64 * This function is deprecated. It allocates a lock acquisition context and 65 * stores it in the DRM device's ->mode_config. This facilitate conversion of 66 * existing code because it removes the need to manually deal with the 67 * acquisition context, but it is also brittle because the context is global 68 * and care must be taken not to nest calls. New code should use the 69 * drm_modeset_lock_all_ctx() function and pass in the context explicitly. 70 */ 71 void drm_modeset_lock_all(struct drm_device *dev) 72 { 73 struct drm_mode_config *config = &dev->mode_config; 74 struct drm_modeset_acquire_ctx *ctx; 75 int ret; 76 77 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 78 if (WARN_ON(!ctx)) 79 return; 80 81 mutex_lock(&config->mutex); 82 83 drm_modeset_acquire_init(ctx, 0); 84 85 retry: 86 ret = drm_modeset_lock_all_ctx(dev, ctx); 87 if (ret < 0) { 88 if (ret == -EDEADLK) { 89 drm_modeset_backoff(ctx); 90 goto retry; 91 } 92 93 drm_modeset_acquire_fini(ctx); 94 kfree(ctx); 95 return; 96 } 97 98 WARN_ON(config->acquire_ctx); 99 100 /* 101 * We hold the locks now, so it is safe to stash the acquisition 102 * context for drm_modeset_unlock_all(). 103 */ 104 config->acquire_ctx = ctx; 105 106 drm_warn_on_modeset_not_all_locked(dev); 107 } 108 EXPORT_SYMBOL(drm_modeset_lock_all); 109 110 /** 111 * drm_modeset_unlock_all - drop all modeset locks 112 * @dev: DRM device 113 * 114 * This function drops all modeset locks taken by a previous call to the 115 * drm_modeset_lock_all() function. 116 * 117 * This function is deprecated. It uses the lock acquisition context stored 118 * in the DRM device's ->mode_config. This facilitates conversion of existing 119 * code because it removes the need to manually deal with the acquisition 120 * context, but it is also brittle because the context is global and care must 121 * be taken not to nest calls. New code should pass the acquisition context 122 * directly to the drm_modeset_drop_locks() function. 123 */ 124 void drm_modeset_unlock_all(struct drm_device *dev) 125 { 126 struct drm_mode_config *config = &dev->mode_config; 127 struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx; 128 129 if (WARN_ON(!ctx)) 130 return; 131 132 config->acquire_ctx = NULL; 133 drm_modeset_drop_locks(ctx); 134 drm_modeset_acquire_fini(ctx); 135 136 kfree(ctx); 137 138 mutex_unlock(&dev->mode_config.mutex); 139 } 140 EXPORT_SYMBOL(drm_modeset_unlock_all); 141 142 /** 143 * drm_modeset_lock_crtc - lock crtc with hidden acquire ctx for a plane update 144 * @crtc: DRM CRTC 145 * @plane: DRM plane to be updated on @crtc 146 * 147 * This function locks the given crtc and plane (which should be either the 148 * primary or cursor plane) using a hidden acquire context. This is necessary so 149 * that drivers internally using the atomic interfaces can grab further locks 150 * with the lock acquire context. 151 * 152 * Note that @plane can be NULL, e.g. when the cursor support hasn't yet been 153 * converted to universal planes yet. 154 */ 155 void drm_modeset_lock_crtc(struct drm_crtc *crtc, 156 struct drm_plane *plane) 157 { 158 struct drm_modeset_acquire_ctx *ctx; 159 int ret; 160 161 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL); 162 if (WARN_ON(!ctx)) 163 return; 164 165 drm_modeset_acquire_init(ctx, 0); 166 167 retry: 168 ret = drm_modeset_lock(&crtc->mutex, ctx); 169 if (ret) 170 goto fail; 171 172 if (plane) { 173 ret = drm_modeset_lock(&plane->mutex, ctx); 174 if (ret) 175 goto fail; 176 177 if (plane->crtc) { 178 ret = drm_modeset_lock(&plane->crtc->mutex, ctx); 179 if (ret) 180 goto fail; 181 } 182 } 183 184 WARN_ON(crtc->acquire_ctx); 185 186 /* now we hold the locks, so now that it is safe, stash the 187 * ctx for drm_modeset_unlock_crtc(): 188 */ 189 crtc->acquire_ctx = ctx; 190 191 return; 192 193 fail: 194 if (ret == -EDEADLK) { 195 drm_modeset_backoff(ctx); 196 goto retry; 197 } 198 } 199 EXPORT_SYMBOL(drm_modeset_lock_crtc); 200 201 /** 202 * drm_modeset_legacy_acquire_ctx - find acquire ctx for legacy ioctls 203 * @crtc: drm crtc 204 * 205 * Legacy ioctl operations like cursor updates or page flips only have per-crtc 206 * locking, and store the acquire ctx in the corresponding crtc. All other 207 * legacy operations take all locks and use a global acquire context. This 208 * function grabs the right one. 209 */ 210 struct drm_modeset_acquire_ctx * 211 drm_modeset_legacy_acquire_ctx(struct drm_crtc *crtc) 212 { 213 if (crtc->acquire_ctx) 214 return crtc->acquire_ctx; 215 216 WARN_ON(!crtc->dev->mode_config.acquire_ctx); 217 218 return crtc->dev->mode_config.acquire_ctx; 219 } 220 EXPORT_SYMBOL(drm_modeset_legacy_acquire_ctx); 221 222 /** 223 * drm_modeset_unlock_crtc - drop crtc lock 224 * @crtc: drm crtc 225 * 226 * This drops the crtc lock acquire with drm_modeset_lock_crtc() and all other 227 * locks acquired through the hidden context. 228 */ 229 void drm_modeset_unlock_crtc(struct drm_crtc *crtc) 230 { 231 struct drm_modeset_acquire_ctx *ctx = crtc->acquire_ctx; 232 233 if (WARN_ON(!ctx)) 234 return; 235 236 crtc->acquire_ctx = NULL; 237 drm_modeset_drop_locks(ctx); 238 drm_modeset_acquire_fini(ctx); 239 240 kfree(ctx); 241 } 242 EXPORT_SYMBOL(drm_modeset_unlock_crtc); 243 244 /** 245 * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked 246 * @dev: device 247 * 248 * Useful as a debug assert. 249 */ 250 void drm_warn_on_modeset_not_all_locked(struct drm_device *dev) 251 { 252 struct drm_crtc *crtc; 253 254 /* Locking is currently fubar in the panic handler. */ 255 #ifdef __DragonFly__ 256 if (panicstr) 257 return; 258 #else 259 if (oops_in_progress) 260 return; 261 #endif 262 263 drm_for_each_crtc(crtc, dev) 264 WARN_ON(!drm_modeset_is_locked(&crtc->mutex)); 265 266 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex)); 267 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex)); 268 } 269 EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked); 270 271 /** 272 * drm_modeset_acquire_init - initialize acquire context 273 * @ctx: the acquire context 274 * @flags: for future 275 */ 276 void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx, 277 uint32_t flags) 278 { 279 memset(ctx, 0, sizeof(*ctx)); 280 ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class); 281 INIT_LIST_HEAD(&ctx->locked); 282 } 283 EXPORT_SYMBOL(drm_modeset_acquire_init); 284 285 /** 286 * drm_modeset_acquire_fini - cleanup acquire context 287 * @ctx: the acquire context 288 */ 289 void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx) 290 { 291 ww_acquire_fini(&ctx->ww_ctx); 292 } 293 EXPORT_SYMBOL(drm_modeset_acquire_fini); 294 295 /** 296 * drm_modeset_drop_locks - drop all locks 297 * @ctx: the acquire context 298 * 299 * Drop all locks currently held against this acquire context. 300 */ 301 void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx) 302 { 303 WARN_ON(ctx->contended); 304 while (!list_empty(&ctx->locked)) { 305 struct drm_modeset_lock_info *info; 306 307 info = list_first_entry(&ctx->locked, 308 struct drm_modeset_lock_info, ctx_entry); 309 310 drm_modeset_unlock(info->lock); 311 } 312 } 313 EXPORT_SYMBOL(drm_modeset_drop_locks); 314 315 static inline int modeset_lock(struct drm_modeset_lock *lock, 316 struct drm_modeset_acquire_ctx *ctx, 317 bool interruptible, bool slow) 318 { 319 int ret; 320 321 WARN_ON(ctx->contended); 322 323 if (ctx->trylock_only) { 324 #if 0 325 lockdep_assert_held(&ctx->ww_ctx); 326 #endif 327 328 if (!ww_mutex_trylock(&lock->mutex)) 329 return -EBUSY; 330 else 331 return 0; 332 } else if (interruptible && slow) { 333 ret = ww_mutex_lock_slow_interruptible(&lock->mutex, &ctx->ww_ctx); 334 } else if (interruptible) { 335 ret = ww_mutex_lock_interruptible(&lock->mutex, &ctx->ww_ctx); 336 } else if (slow) { 337 ww_mutex_lock_slow(&lock->mutex, &ctx->ww_ctx); 338 ret = 0; 339 } else { 340 ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx); 341 } 342 if (ret == -EALREADY) { 343 /* we already hold the lock.. this is fine. For atomic 344 * we will need to be able to drm_modeset_lock() things 345 * without having to keep track of what is already locked 346 * or not. 347 */ 348 ret = 0; 349 } else if (ret == -EDEADLK) { 350 ctx->contended = lock; 351 } 352 if (ret == 0) { 353 struct drm_modeset_lock_info *info; 354 355 info = kzalloc(sizeof(*info), GFP_KERNEL); 356 INIT_LIST_HEAD(&info->ctx_entry); 357 INIT_LIST_HEAD(&info->lock_entry); 358 info->lock = lock; 359 info->ctx = ctx; 360 list_add(&info->ctx_entry, &ctx->locked); 361 list_add(&info->lock_entry, &lock->locked); 362 } 363 364 return ret; 365 } 366 367 static int modeset_backoff(struct drm_modeset_acquire_ctx *ctx, 368 bool interruptible) 369 { 370 struct drm_modeset_lock *contended = ctx->contended; 371 372 ctx->contended = NULL; 373 374 if (WARN_ON(!contended)) 375 return 0; 376 377 drm_modeset_drop_locks(ctx); 378 379 return modeset_lock(contended, ctx, interruptible, true); 380 } 381 382 /** 383 * drm_modeset_backoff - deadlock avoidance backoff 384 * @ctx: the acquire context 385 * 386 * If deadlock is detected (ie. drm_modeset_lock() returns -EDEADLK), 387 * you must call this function to drop all currently held locks and 388 * block until the contended lock becomes available. 389 */ 390 void drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx) 391 { 392 modeset_backoff(ctx, false); 393 } 394 EXPORT_SYMBOL(drm_modeset_backoff); 395 396 /** 397 * drm_modeset_backoff_interruptible - deadlock avoidance backoff 398 * @ctx: the acquire context 399 * 400 * Interruptible version of drm_modeset_backoff() 401 */ 402 int drm_modeset_backoff_interruptible(struct drm_modeset_acquire_ctx *ctx) 403 { 404 return modeset_backoff(ctx, true); 405 } 406 EXPORT_SYMBOL(drm_modeset_backoff_interruptible); 407 408 /** 409 * drm_modeset_lock - take modeset lock 410 * @lock: lock to take 411 * @ctx: acquire ctx 412 * 413 * If ctx is not NULL, then its ww acquire context is used and the 414 * lock will be tracked by the context and can be released by calling 415 * drm_modeset_drop_locks(). If -EDEADLK is returned, this means a 416 * deadlock scenario has been detected and it is an error to attempt 417 * to take any more locks without first calling drm_modeset_backoff(). 418 */ 419 int drm_modeset_lock(struct drm_modeset_lock *lock, 420 struct drm_modeset_acquire_ctx *ctx) 421 { 422 if (ctx) 423 return modeset_lock(lock, ctx, false, false); 424 425 ww_mutex_lock(&lock->mutex, NULL); 426 return 0; 427 } 428 EXPORT_SYMBOL(drm_modeset_lock); 429 430 /** 431 * drm_modeset_lock_interruptible - take modeset lock 432 * @lock: lock to take 433 * @ctx: acquire ctx 434 * 435 * Interruptible version of drm_modeset_lock() 436 */ 437 int drm_modeset_lock_interruptible(struct drm_modeset_lock *lock, 438 struct drm_modeset_acquire_ctx *ctx) 439 { 440 if (ctx) 441 return modeset_lock(lock, ctx, true, false); 442 443 return ww_mutex_lock_interruptible(&lock->mutex, NULL); 444 } 445 EXPORT_SYMBOL(drm_modeset_lock_interruptible); 446 447 /** 448 * drm_modeset_unlock - drop modeset lock 449 * @lock: lock to release 450 */ 451 void drm_modeset_unlock(struct drm_modeset_lock *lock) 452 { 453 struct drm_modeset_lock_info *info; 454 455 /* undo in reverse order */ 456 if (!list_empty(&lock->locked)) { 457 info = list_last_entry(&lock->locked, 458 struct drm_modeset_lock_info, lock_entry); 459 list_del_init(&info->lock_entry); 460 if (info->ctx) 461 list_del_init(&info->ctx_entry); 462 kfree(info); 463 } 464 ww_mutex_unlock(&lock->mutex); 465 } 466 EXPORT_SYMBOL(drm_modeset_unlock); 467 468 /** 469 * drm_modeset_lock_all_ctx - take all modeset locks 470 * @dev: DRM device 471 * @ctx: lock acquisition context 472 * 473 * This function takes all modeset locks, suitable where a more fine-grained 474 * scheme isn't (yet) implemented. 475 * 476 * Unlike drm_modeset_lock_all(), it doesn't take the dev->mode_config.mutex 477 * since that lock isn't required for modeset state changes. Callers which 478 * need to grab that lock too need to do so outside of the acquire context 479 * @ctx. 480 * 481 * Locks acquired with this function should be released by calling the 482 * drm_modeset_drop_locks() function on @ctx. 483 * 484 * Returns: 0 on success or a negative error-code on failure. 485 */ 486 int drm_modeset_lock_all_ctx(struct drm_device *dev, 487 struct drm_modeset_acquire_ctx *ctx) 488 { 489 struct drm_crtc *crtc; 490 struct drm_plane *plane; 491 int ret; 492 493 ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx); 494 if (ret) 495 return ret; 496 497 drm_for_each_crtc(crtc, dev) { 498 ret = drm_modeset_lock(&crtc->mutex, ctx); 499 if (ret) 500 return ret; 501 } 502 503 drm_for_each_plane(plane, dev) { 504 ret = drm_modeset_lock(&plane->mutex, ctx); 505 if (ret) 506 return ret; 507 } 508 509 return 0; 510 } 511 EXPORT_SYMBOL(drm_modeset_lock_all_ctx); 512