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 	if (oops_in_progress)
256 		return;
257 
258 	drm_for_each_crtc(crtc, dev)
259 		WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
260 
261 	WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
262 	WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
263 }
264 EXPORT_SYMBOL(drm_warn_on_modeset_not_all_locked);
265 
266 /**
267  * drm_modeset_acquire_init - initialize acquire context
268  * @ctx: the acquire context
269  * @flags: for future
270  */
271 void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
272 		uint32_t flags)
273 {
274 	memset(ctx, 0, sizeof(*ctx));
275 	ww_acquire_init(&ctx->ww_ctx, &crtc_ww_class);
276 	INIT_LIST_HEAD(&ctx->locked);
277 }
278 EXPORT_SYMBOL(drm_modeset_acquire_init);
279 
280 /**
281  * drm_modeset_acquire_fini - cleanup acquire context
282  * @ctx: the acquire context
283  */
284 void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx)
285 {
286 	ww_acquire_fini(&ctx->ww_ctx);
287 }
288 EXPORT_SYMBOL(drm_modeset_acquire_fini);
289 
290 /**
291  * drm_modeset_drop_locks - drop all locks
292  * @ctx: the acquire context
293  *
294  * Drop all locks currently held against this acquire context.
295  */
296 void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx)
297 {
298 	WARN_ON(ctx->contended);
299 	while (!list_empty(&ctx->locked)) {
300 		struct drm_modeset_lock *lock;
301 
302 		lock = list_first_entry(&ctx->locked,
303 				struct drm_modeset_lock, head);
304 
305 		drm_modeset_unlock(lock);
306 	}
307 }
308 EXPORT_SYMBOL(drm_modeset_drop_locks);
309 
310 static inline int modeset_lock(struct drm_modeset_lock *lock,
311 		struct drm_modeset_acquire_ctx *ctx,
312 		bool interruptible, bool slow)
313 {
314 	int ret;
315 
316 	WARN_ON(ctx->contended);
317 
318 	if (ctx->trylock_only) {
319 		lockdep_assert_held(&ctx->ww_ctx);
320 
321 		if (!ww_mutex_trylock(&lock->mutex))
322 			return -EBUSY;
323 		else
324 			return 0;
325 	} else if (interruptible && slow) {
326 		ret = ww_mutex_lock_slow_interruptible(&lock->mutex, &ctx->ww_ctx);
327 	} else if (interruptible) {
328 		ret = ww_mutex_lock_interruptible(&lock->mutex, &ctx->ww_ctx);
329 	} else if (slow) {
330 		ww_mutex_lock_slow(&lock->mutex, &ctx->ww_ctx);
331 		ret = 0;
332 	} else {
333 		ret = ww_mutex_lock(&lock->mutex, &ctx->ww_ctx);
334 	}
335 	if (!ret) {
336 		WARN_ON(!list_empty(&lock->head));
337 		list_add(&lock->head, &ctx->locked);
338 	} else if (ret == -EALREADY) {
339 		/* we already hold the lock.. this is fine.  For atomic
340 		 * we will need to be able to drm_modeset_lock() things
341 		 * without having to keep track of what is already locked
342 		 * or not.
343 		 */
344 		ret = 0;
345 	} else if (ret == -EDEADLK) {
346 		ctx->contended = lock;
347 	}
348 
349 	return ret;
350 }
351 
352 static int modeset_backoff(struct drm_modeset_acquire_ctx *ctx,
353 		bool interruptible)
354 {
355 	struct drm_modeset_lock *contended = ctx->contended;
356 
357 	ctx->contended = NULL;
358 
359 	if (WARN_ON(!contended))
360 		return 0;
361 
362 	drm_modeset_drop_locks(ctx);
363 
364 	return modeset_lock(contended, ctx, interruptible, true);
365 }
366 
367 /**
368  * drm_modeset_backoff - deadlock avoidance backoff
369  * @ctx: the acquire context
370  *
371  * If deadlock is detected (ie. drm_modeset_lock() returns -EDEADLK),
372  * you must call this function to drop all currently held locks and
373  * block until the contended lock becomes available.
374  */
375 void drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx)
376 {
377 	modeset_backoff(ctx, false);
378 }
379 EXPORT_SYMBOL(drm_modeset_backoff);
380 
381 /**
382  * drm_modeset_backoff_interruptible - deadlock avoidance backoff
383  * @ctx: the acquire context
384  *
385  * Interruptible version of drm_modeset_backoff()
386  */
387 int drm_modeset_backoff_interruptible(struct drm_modeset_acquire_ctx *ctx)
388 {
389 	return modeset_backoff(ctx, true);
390 }
391 EXPORT_SYMBOL(drm_modeset_backoff_interruptible);
392 
393 /**
394  * drm_modeset_lock - take modeset lock
395  * @lock: lock to take
396  * @ctx: acquire ctx
397  *
398  * If ctx is not NULL, then its ww acquire context is used and the
399  * lock will be tracked by the context and can be released by calling
400  * drm_modeset_drop_locks().  If -EDEADLK is returned, this means a
401  * deadlock scenario has been detected and it is an error to attempt
402  * to take any more locks without first calling drm_modeset_backoff().
403  */
404 int drm_modeset_lock(struct drm_modeset_lock *lock,
405 		struct drm_modeset_acquire_ctx *ctx)
406 {
407 	if (ctx)
408 		return modeset_lock(lock, ctx, false, false);
409 
410 	ww_mutex_lock(&lock->mutex, NULL);
411 	return 0;
412 }
413 EXPORT_SYMBOL(drm_modeset_lock);
414 
415 /**
416  * drm_modeset_lock_interruptible - take modeset lock
417  * @lock: lock to take
418  * @ctx: acquire ctx
419  *
420  * Interruptible version of drm_modeset_lock()
421  */
422 int drm_modeset_lock_interruptible(struct drm_modeset_lock *lock,
423 		struct drm_modeset_acquire_ctx *ctx)
424 {
425 	if (ctx)
426 		return modeset_lock(lock, ctx, true, false);
427 
428 	return ww_mutex_lock_interruptible(&lock->mutex, NULL);
429 }
430 EXPORT_SYMBOL(drm_modeset_lock_interruptible);
431 
432 /**
433  * drm_modeset_unlock - drop modeset lock
434  * @lock: lock to release
435  */
436 void drm_modeset_unlock(struct drm_modeset_lock *lock)
437 {
438 	list_del_init(&lock->head);
439 	ww_mutex_unlock(&lock->mutex);
440 }
441 EXPORT_SYMBOL(drm_modeset_unlock);
442 
443 /**
444  * drm_modeset_lock_all_ctx - take all modeset locks
445  * @dev: DRM device
446  * @ctx: lock acquisition context
447  *
448  * This function takes all modeset locks, suitable where a more fine-grained
449  * scheme isn't (yet) implemented.
450  *
451  * Unlike drm_modeset_lock_all(), it doesn't take the dev->mode_config.mutex
452  * since that lock isn't required for modeset state changes. Callers which
453  * need to grab that lock too need to do so outside of the acquire context
454  * @ctx.
455  *
456  * Locks acquired with this function should be released by calling the
457  * drm_modeset_drop_locks() function on @ctx.
458  *
459  * Returns: 0 on success or a negative error-code on failure.
460  */
461 int drm_modeset_lock_all_ctx(struct drm_device *dev,
462 			     struct drm_modeset_acquire_ctx *ctx)
463 {
464 	struct drm_crtc *crtc;
465 	struct drm_plane *plane;
466 	int ret;
467 
468 	ret = drm_modeset_lock(&dev->mode_config.connection_mutex, ctx);
469 	if (ret)
470 		return ret;
471 
472 	drm_for_each_crtc(crtc, dev) {
473 		ret = drm_modeset_lock(&crtc->mutex, ctx);
474 		if (ret)
475 			return ret;
476 	}
477 
478 	drm_for_each_plane(plane, dev) {
479 		ret = drm_modeset_lock(&plane->mutex, ctx);
480 		if (ret)
481 			return ret;
482 	}
483 
484 	return 0;
485 }
486 EXPORT_SYMBOL(drm_modeset_lock_all_ctx);
487