drm_modeset_lock.h 6.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206
  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. #ifndef DRM_MODESET_LOCK_H_
  24. #define DRM_MODESET_LOCK_H_
  25. #include <linux/ww_mutex.h>
  26. struct drm_modeset_lock;
  27. /**
  28. * struct drm_modeset_acquire_ctx - locking context (see ww_acquire_ctx)
  29. * @ww_ctx: base acquire ctx
  30. * @contended: used internally for -EDEADLK handling
  31. * @locked: list of held locks
  32. * @trylock_only: trylock mode used in atomic contexts/panic notifiers
  33. * @interruptible: whether interruptible locking should be used.
  34. *
  35. * Each thread competing for a set of locks must use one acquire
  36. * ctx. And if any lock fxn returns -EDEADLK, it must backoff and
  37. * retry.
  38. */
  39. struct drm_modeset_acquire_ctx {
  40. struct ww_acquire_ctx ww_ctx;
  41. /*
  42. * Contended lock: if a lock is contended you should only call
  43. * drm_modeset_backoff() which drops locks and slow-locks the
  44. * contended lock.
  45. */
  46. struct drm_modeset_lock *contended;
  47. /*
  48. * list of held locks (drm_modeset_lock)
  49. */
  50. struct list_head locked;
  51. /*
  52. * Trylock mode, use only for panic handlers!
  53. */
  54. bool trylock_only;
  55. /* Perform interruptible waits on this context. */
  56. bool interruptible;
  57. };
  58. /**
  59. * struct drm_modeset_lock - used for locking modeset resources.
  60. * @mutex: resource locking
  61. * @head: used to hold its place on &drm_atomi_state.locked list when
  62. * part of an atomic update
  63. *
  64. * Used for locking CRTCs and other modeset resources.
  65. */
  66. struct drm_modeset_lock {
  67. /*
  68. * modeset lock
  69. */
  70. struct ww_mutex mutex;
  71. /*
  72. * Resources that are locked as part of an atomic update are added
  73. * to a list (so we know what to unlock at the end).
  74. */
  75. struct list_head head;
  76. };
  77. #define DRM_MODESET_ACQUIRE_INTERRUPTIBLE BIT(0)
  78. void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
  79. uint32_t flags);
  80. void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx);
  81. void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx);
  82. int drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx);
  83. void drm_modeset_lock_init(struct drm_modeset_lock *lock);
  84. /**
  85. * drm_modeset_lock_fini - cleanup lock
  86. * @lock: lock to cleanup
  87. */
  88. static inline void drm_modeset_lock_fini(struct drm_modeset_lock *lock)
  89. {
  90. WARN_ON(!list_empty(&lock->head));
  91. }
  92. /**
  93. * drm_modeset_is_locked - equivalent to mutex_is_locked()
  94. * @lock: lock to check
  95. */
  96. static inline bool drm_modeset_is_locked(struct drm_modeset_lock *lock)
  97. {
  98. return ww_mutex_is_locked(&lock->mutex);
  99. }
  100. /**
  101. * drm_modeset_lock_assert_held - equivalent to lockdep_assert_held()
  102. * @lock: lock to check
  103. */
  104. static inline void drm_modeset_lock_assert_held(struct drm_modeset_lock *lock)
  105. {
  106. lockdep_assert_held(&lock->mutex.base);
  107. }
  108. int drm_modeset_lock(struct drm_modeset_lock *lock,
  109. struct drm_modeset_acquire_ctx *ctx);
  110. int __must_check drm_modeset_lock_single_interruptible(struct drm_modeset_lock *lock);
  111. void drm_modeset_unlock(struct drm_modeset_lock *lock);
  112. struct drm_device;
  113. struct drm_crtc;
  114. struct drm_plane;
  115. void drm_modeset_lock_all(struct drm_device *dev);
  116. void drm_modeset_unlock_all(struct drm_device *dev);
  117. void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
  118. int drm_modeset_lock_all_ctx(struct drm_device *dev,
  119. struct drm_modeset_acquire_ctx *ctx);
  120. /**
  121. * DRM_MODESET_LOCK_ALL_BEGIN - Helper to acquire modeset locks
  122. * @dev: drm device
  123. * @ctx: local modeset acquire context, will be dereferenced
  124. * @flags: DRM_MODESET_ACQUIRE_* flags to pass to drm_modeset_acquire_init()
  125. * @ret: local ret/err/etc variable to track error status
  126. *
  127. * Use these macros to simplify grabbing all modeset locks using a local
  128. * context. This has the advantage of reducing boilerplate, but also properly
  129. * checking return values where appropriate.
  130. *
  131. * Any code run between BEGIN and END will be holding the modeset locks.
  132. *
  133. * This must be paired with DRM_MODESET_LOCK_ALL_END(). We will jump back and
  134. * forth between the labels on deadlock and error conditions.
  135. *
  136. * Drivers can acquire additional modeset locks. If any lock acquisition
  137. * fails, the control flow needs to jump to DRM_MODESET_LOCK_ALL_END() with
  138. * the @ret parameter containing the return value of drm_modeset_lock().
  139. *
  140. * Returns:
  141. * The only possible value of ret immediately after DRM_MODESET_LOCK_ALL_BEGIN()
  142. * is 0, so no error checking is necessary
  143. */
  144. #define DRM_MODESET_LOCK_ALL_BEGIN(dev, ctx, flags, ret) \
  145. if (!drm_drv_uses_atomic_modeset(dev)) \
  146. mutex_lock(&dev->mode_config.mutex); \
  147. drm_modeset_acquire_init(&ctx, flags); \
  148. modeset_lock_retry: \
  149. ret = drm_modeset_lock_all_ctx(dev, &ctx); \
  150. if (ret) \
  151. goto modeset_lock_fail;
  152. /**
  153. * DRM_MODESET_LOCK_ALL_END - Helper to release and cleanup modeset locks
  154. * @dev: drm device
  155. * @ctx: local modeset acquire context, will be dereferenced
  156. * @ret: local ret/err/etc variable to track error status
  157. *
  158. * The other side of DRM_MODESET_LOCK_ALL_BEGIN(). It will bounce back to BEGIN
  159. * if ret is -EDEADLK.
  160. *
  161. * It's important that you use the same ret variable for begin and end so
  162. * deadlock conditions are properly handled.
  163. *
  164. * Returns:
  165. * ret will be untouched unless it is -EDEADLK on entry. That means that if you
  166. * successfully acquire the locks, ret will be whatever your code sets it to. If
  167. * there is a deadlock or other failure with acquire or backoff, ret will be set
  168. * to that failure. In both of these cases the code between BEGIN/END will not
  169. * be run, so the failure will reflect the inability to grab the locks.
  170. */
  171. #define DRM_MODESET_LOCK_ALL_END(dev, ctx, ret) \
  172. modeset_lock_fail: \
  173. if (ret == -EDEADLK) { \
  174. ret = drm_modeset_backoff(&ctx); \
  175. if (!ret) \
  176. goto modeset_lock_retry; \
  177. } \
  178. drm_modeset_drop_locks(&ctx); \
  179. drm_modeset_acquire_fini(&ctx); \
  180. if (!drm_drv_uses_atomic_modeset(dev)) \
  181. mutex_unlock(&dev->mode_config.mutex);
  182. #endif /* DRM_MODESET_LOCK_H_ */