GNU Linux-libre 5.10.219-gnu1
[releases.git] / drivers / gpu / drm / drm_modeset_lock.c
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/drm_atomic.h>
25 #include <drm/drm_crtc.h>
26 #include <drm/drm_device.h>
27 #include <drm/drm_modeset_lock.h>
28
29 /**
30  * DOC: kms locking
31  *
32  * As KMS moves toward more fine grained locking, and atomic ioctl where
33  * userspace can indirectly control locking order, it becomes necessary
34  * to use &ww_mutex and acquire-contexts to avoid deadlocks.  But because
35  * the locking is more distributed around the driver code, we want a bit
36  * of extra utility/tracking out of our acquire-ctx.  This is provided
37  * by &struct drm_modeset_lock and &struct drm_modeset_acquire_ctx.
38  *
39  * For basic principles of &ww_mutex, see: Documentation/locking/ww-mutex-design.rst
40  *
41  * The basic usage pattern is to::
42  *
43  *     drm_modeset_acquire_init(ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE)
44  *     retry:
45  *     foreach (lock in random_ordered_set_of_locks) {
46  *         ret = drm_modeset_lock(lock, ctx)
47  *         if (ret == -EDEADLK) {
48  *             ret = drm_modeset_backoff(ctx);
49  *             if (!ret)
50  *                 goto retry;
51  *         }
52  *         if (ret)
53  *             goto out;
54  *     }
55  *     ... do stuff ...
56  *     out:
57  *     drm_modeset_drop_locks(ctx);
58  *     drm_modeset_acquire_fini(ctx);
59  *
60  * For convenience this control flow is implemented in
61  * DRM_MODESET_LOCK_ALL_BEGIN() and DRM_MODESET_LOCK_ALL_END() for the case
62  * where all modeset locks need to be taken through drm_modeset_lock_all_ctx().
63  *
64  * If all that is needed is a single modeset lock, then the &struct
65  * drm_modeset_acquire_ctx is not needed and the locking can be simplified
66  * by passing a NULL instead of ctx in the drm_modeset_lock() call or
67  * calling  drm_modeset_lock_single_interruptible(). To unlock afterwards
68  * call drm_modeset_unlock().
69  *
70  * On top of these per-object locks using &ww_mutex there's also an overall
71  * &drm_mode_config.mutex, for protecting everything else. Mostly this means
72  * probe state of connectors, and preventing hotplug add/removal of connectors.
73  *
74  * Finally there's a bunch of dedicated locks to protect drm core internal
75  * lists and lookup data structures.
76  */
77
78 static DEFINE_WW_CLASS(crtc_ww_class);
79
80 /**
81  * drm_modeset_lock_all - take all modeset locks
82  * @dev: DRM device
83  *
84  * This function takes all modeset locks, suitable where a more fine-grained
85  * scheme isn't (yet) implemented. Locks must be dropped by calling the
86  * drm_modeset_unlock_all() function.
87  *
88  * This function is deprecated. It allocates a lock acquisition context and
89  * stores it in &drm_device.mode_config. This facilitate conversion of
90  * existing code because it removes the need to manually deal with the
91  * acquisition context, but it is also brittle because the context is global
92  * and care must be taken not to nest calls. New code should use the
93  * drm_modeset_lock_all_ctx() function and pass in the context explicitly.
94  */
95 void drm_modeset_lock_all(struct drm_device *dev)
96 {
97         struct drm_mode_config *config = &dev->mode_config;
98         struct drm_modeset_acquire_ctx *ctx;
99         int ret;
100
101         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL | __GFP_NOFAIL);
102         if (WARN_ON(!ctx))
103                 return;
104
105         mutex_lock(&config->mutex);
106
107         drm_modeset_acquire_init(ctx, 0);
108
109 retry:
110         ret = drm_modeset_lock_all_ctx(dev, ctx);
111         if (ret < 0) {
112                 if (ret == -EDEADLK) {
113                         drm_modeset_backoff(ctx);
114                         goto retry;
115                 }
116
117                 drm_modeset_acquire_fini(ctx);
118                 kfree(ctx);
119                 return;
120         }
121         ww_acquire_done(&ctx->ww_ctx);
122
123         WARN_ON(config->acquire_ctx);
124
125         /*
126          * We hold the locks now, so it is safe to stash the acquisition
127          * context for drm_modeset_unlock_all().
128          */
129         config->acquire_ctx = ctx;
130
131         drm_warn_on_modeset_not_all_locked(dev);
132 }
133 EXPORT_SYMBOL(drm_modeset_lock_all);
134
135 /**
136  * drm_modeset_unlock_all - drop all modeset locks
137  * @dev: DRM device
138  *
139  * This function drops all modeset locks taken by a previous call to the
140  * drm_modeset_lock_all() function.
141  *
142  * This function is deprecated. It uses the lock acquisition context stored
143  * in &drm_device.mode_config. This facilitates conversion of existing
144  * code because it removes the need to manually deal with the acquisition
145  * context, but it is also brittle because the context is global and care must
146  * be taken not to nest calls. New code should pass the acquisition context
147  * directly to the drm_modeset_drop_locks() function.
148  */
149 void drm_modeset_unlock_all(struct drm_device *dev)
150 {
151         struct drm_mode_config *config = &dev->mode_config;
152         struct drm_modeset_acquire_ctx *ctx = config->acquire_ctx;
153
154         if (WARN_ON(!ctx))
155                 return;
156
157         config->acquire_ctx = NULL;
158         drm_modeset_drop_locks(ctx);
159         drm_modeset_acquire_fini(ctx);
160
161         kfree(ctx);
162
163         mutex_unlock(&dev->mode_config.mutex);
164 }
165 EXPORT_SYMBOL(drm_modeset_unlock_all);
166
167 /**
168  * drm_warn_on_modeset_not_all_locked - check that all modeset locks are locked
169  * @dev: device
170  *
171  * Useful as a debug assert.
172  */
173 void drm_warn_on_modeset_not_all_locked(struct drm_device *dev)
174 {
175         struct drm_crtc *crtc;
176
177         /* Locking is currently fubar in the panic handler. */
178         if (oops_in_progress)
179                 return;
180
181         drm_for_each_crtc(crtc, dev)
182                 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
183
184         WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
185         WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
186 }
187 EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
188
189 /**
190  * drm_modeset_acquire_init - initialize acquire context
191  * @ctx: the acquire context
192  * @flags: 0 or %DRM_MODESET_ACQUIRE_INTERRUPTIBLE
193  *
194  * When passing %DRM_MODESET_ACQUIRE_INTERRUPTIBLE to @flags,
195  * all calls to drm_modeset_lock() will perform an interruptible
196  * wait.
197  */
198 void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
199                 uint32_t flags)
200 {
201         memset(ctx, 0, sizeof(*ctx));
202         ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class);
203         INIT_LIST_HEAD(&ctx->locked);
204
205         if (flags & DRM_MODESET_ACQUIRE_INTERRUPTIBLE)
206                 ctx->interruptible = true;
207 }
208 EXPORT_SYMBOL(drm_modeset_acquire_init);
209
210 /**
211  * drm_modeset_acquire_fini - cleanup acquire context
212  * @ctx: the acquire context
213  */
214 void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx)
215 {
216         ww_acquire_fini(&ctx->ww_ctx);
217 }
218 EXPORT_SYMBOL(drm_modeset_acquire_fini);
219
220 /**
221  * drm_modeset_drop_locks - drop all locks
222  * @ctx: the acquire context
223  *
224  * Drop all locks currently held against this acquire context.
225  */
226 void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx)
227 {
228         WARN_ON(ctx->contended);
229         while (!list_empty(&ctx->locked)) {
230                 struct drm_modeset_lock *lock;
231
232                 lock = list_first_entry(&ctx->locked,
233                                 struct drm_modeset_lock, head);
234
235                 drm_modeset_unlock(lock);
236         }
237 }
238 EXPORT_SYMBOL(drm_modeset_drop_locks);
239
240 static inline int modeset_lock(struct drm_modeset_lock *lock,
241                 struct drm_modeset_acquire_ctx *ctx,
242                 bool interruptible, bool slow)
243 {
244         int ret;
245
246         WARN_ON(ctx->contended);
247
248         if (ctx->trylock_only) {
249                 lockdep_assert_held(&ctx->ww_ctx);
250
251                 if (!ww_mutex_trylock(&lock->mutex))
252                         return -EBUSY;
253                 else
254                         return 0;
255         } else if (interruptible && slow) {
256                 ret = ww_mutex_lock_slow_interruptible(&lock->mutex, &ctx->ww_ctx);
257         } else if (interruptible) {
258                 ret = ww_mutex_lock_interruptible(&lock->mutex, &ctx->ww_ctx);
259         } else if (slow) {
260                 ww_mutex_lock_slow(&lock->mutex, &ctx->ww_ctx);
261                 ret = 0;
262         } else {
263                 ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx);
264         }
265         if (!ret) {
266                 WARN_ON(!list_empty(&lock->head));
267                 list_add(&lock->head, &ctx->locked);
268         } else if (ret == -EALREADY) {
269                 /* we already hold the lock.. this is fine.  For atomic
270                  * we will need to be able to drm_modeset_lock() things
271                  * without having to keep track of what is already locked
272                  * or not.
273                  */
274                 ret = 0;
275         } else if (ret == -EDEADLK) {
276                 ctx->contended = lock;
277         }
278
279         return ret;
280 }
281
282 /**
283  * drm_modeset_backoff - deadlock avoidance backoff
284  * @ctx: the acquire context
285  *
286  * If deadlock is detected (ie. drm_modeset_lock() returns -EDEADLK),
287  * you must call this function to drop all currently held locks and
288  * block until the contended lock becomes available.
289  *
290  * This function returns 0 on success, or -ERESTARTSYS if this context
291  * is initialized with %DRM_MODESET_ACQUIRE_INTERRUPTIBLE and the
292  * wait has been interrupted.
293  */
294 int drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx)
295 {
296         struct drm_modeset_lock *contended = ctx->contended;
297
298         ctx->contended = NULL;
299
300         if (WARN_ON(!contended))
301                 return 0;
302
303         drm_modeset_drop_locks(ctx);
304
305         return modeset_lock(contended, ctx, ctx->interruptible, true);
306 }
307 EXPORT_SYMBOL(drm_modeset_backoff);
308
309 /**
310  * drm_modeset_lock_init - initialize lock
311  * @lock: lock to init
312  */
313 void drm_modeset_lock_init(struct drm_modeset_lock *lock)
314 {
315         ww_mutex_init(&lock->mutex, &crtc_ww_class);
316         INIT_LIST_HEAD(&lock->head);
317 }
318 EXPORT_SYMBOL(drm_modeset_lock_init);
319
320 /**
321  * drm_modeset_lock - take modeset lock
322  * @lock: lock to take
323  * @ctx: acquire ctx
324  *
325  * If @ctx is not NULL, then its ww acquire context is used and the
326  * lock will be tracked by the context and can be released by calling
327  * drm_modeset_drop_locks().  If -EDEADLK is returned, this means a
328  * deadlock scenario has been detected and it is an error to attempt
329  * to take any more locks without first calling drm_modeset_backoff().
330  *
331  * If the @ctx is not NULL and initialized with
332  * %DRM_MODESET_ACQUIRE_INTERRUPTIBLE, this function will fail with
333  * -ERESTARTSYS when interrupted.
334  *
335  * If @ctx is NULL then the function call behaves like a normal,
336  * uninterruptible non-nesting mutex_lock() call.
337  */
338 int drm_modeset_lock(struct drm_modeset_lock *lock,
339                 struct drm_modeset_acquire_ctx *ctx)
340 {
341         if (ctx)
342                 return modeset_lock(lock, ctx, ctx->interruptible, false);
343
344         ww_mutex_lock(&lock->mutex, NULL);
345         return 0;
346 }
347 EXPORT_SYMBOL(drm_modeset_lock);
348
349 /**
350  * drm_modeset_lock_single_interruptible - take a single modeset lock
351  * @lock: lock to take
352  *
353  * This function behaves as drm_modeset_lock() with a NULL context,
354  * but performs interruptible waits.
355  *
356  * This function returns 0 on success, or -ERESTARTSYS when interrupted.
357  */
358 int drm_modeset_lock_single_interruptible(struct drm_modeset_lock *lock)
359 {
360         return ww_mutex_lock_interruptible(&lock->mutex, NULL);
361 }
362 EXPORT_SYMBOL(drm_modeset_lock_single_interruptible);
363
364 /**
365  * drm_modeset_unlock - drop modeset lock
366  * @lock: lock to release
367  */
368 void drm_modeset_unlock(struct drm_modeset_lock *lock)
369 {
370         list_del_init(&lock->head);
371         ww_mutex_unlock(&lock->mutex);
372 }
373 EXPORT_SYMBOL(drm_modeset_unlock);
374
375 /**
376  * drm_modeset_lock_all_ctx - take all modeset locks
377  * @dev: DRM device
378  * @ctx: lock acquisition context
379  *
380  * This function takes all modeset locks, suitable where a more fine-grained
381  * scheme isn't (yet) implemented.
382  *
383  * Unlike drm_modeset_lock_all(), it doesn't take the &drm_mode_config.mutex
384  * since that lock isn't required for modeset state changes. Callers which
385  * need to grab that lock too need to do so outside of the acquire context
386  * @ctx.
387  *
388  * Locks acquired with this function should be released by calling the
389  * drm_modeset_drop_locks() function on @ctx.
390  *
391  * See also: DRM_MODESET_LOCK_ALL_BEGIN() and DRM_MODESET_LOCK_ALL_END()
392  *
393  * Returns: 0 on success or a negative error-code on failure.
394  */
395 int drm_modeset_lock_all_ctx(struct drm_device *dev,
396                              struct drm_modeset_acquire_ctx *ctx)
397 {
398         struct drm_private_obj *privobj;
399         struct drm_crtc *crtc;
400         struct drm_plane *plane;
401         int ret;
402
403         ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
404         if (ret)
405                 return ret;
406
407         drm_for_each_crtc(crtc, dev) {
408                 ret = drm_modeset_lock(&crtc->mutex, ctx);
409                 if (ret)
410                         return ret;
411         }
412
413         drm_for_each_plane(plane, dev) {
414                 ret = drm_modeset_lock(&plane->mutex, ctx);
415                 if (ret)
416                         return ret;
417         }
418
419         drm_for_each_privobj(privobj, dev) {
420                 ret = drm_modeset_lock(&privobj->lock, ctx);
421                 if (ret)
422                         return ret;
423         }
424
425         return 0;
426 }
427 EXPORT_SYMBOL(drm_modeset_lock_all_ctx);