xref: /linux/drivers/gpu/drm/drm_exec.c (revision 78964fcac47fc1525ecb4c37cd5fbc873c28320b)
1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 
3 #include <drm/drm_exec.h>
4 #include <drm/drm_gem.h>
5 #include <linux/dma-resv.h>
6 
7 /**
8  * DOC: Overview
9  *
10  * This component mainly abstracts the retry loop necessary for locking
11  * multiple GEM objects while preparing hardware operations (e.g. command
12  * submissions, page table updates etc..).
13  *
14  * If a contention is detected while locking a GEM object the cleanup procedure
15  * unlocks all previously locked GEM objects and locks the contended one first
16  * before locking any further objects.
17  *
18  * After an object is locked fences slots can optionally be reserved on the
19  * dma_resv object inside the GEM object.
20  *
21  * A typical usage pattern should look like this::
22  *
23  *	struct drm_gem_object *obj;
24  *	struct drm_exec exec;
25  *	unsigned long index;
26  *	int ret;
27  *
28  *	drm_exec_init(&exec, DRM_EXEC_INTERRUPTIBLE_WAIT);
29  *	drm_exec_until_all_locked(&exec) {
30  *		ret = drm_exec_prepare_obj(&exec, boA, 1);
31  *		drm_exec_retry_on_contention(&exec);
32  *		if (ret)
33  *			goto error;
34  *
35  *		ret = drm_exec_prepare_obj(&exec, boB, 1);
36  *		drm_exec_retry_on_contention(&exec);
37  *		if (ret)
38  *			goto error;
39  *	}
40  *
41  *	drm_exec_for_each_locked_object(&exec, index, obj) {
42  *		dma_resv_add_fence(obj->resv, fence, DMA_RESV_USAGE_READ);
43  *		...
44  *	}
45  *	drm_exec_fini(&exec);
46  *
47  * See struct dma_exec for more details.
48  */
49 
50 /* Dummy value used to initially enter the retry loop */
51 #define DRM_EXEC_DUMMY ((void *)~0)
52 
53 /* Unlock all objects and drop references */
54 static void drm_exec_unlock_all(struct drm_exec *exec)
55 {
56 	struct drm_gem_object *obj;
57 	unsigned long index;
58 
59 	drm_exec_for_each_locked_object_reverse(exec, index, obj) {
60 		dma_resv_unlock(obj->resv);
61 		drm_gem_object_put(obj);
62 	}
63 
64 	drm_gem_object_put(exec->prelocked);
65 	exec->prelocked = NULL;
66 }
67 
68 /**
69  * drm_exec_init - initialize a drm_exec object
70  * @exec: the drm_exec object to initialize
71  * @flags: controls locking behavior, see DRM_EXEC_* defines
72  *
73  * Initialize the object and make sure that we can track locked objects.
74  */
75 void drm_exec_init(struct drm_exec *exec, uint32_t flags)
76 {
77 	exec->flags = flags;
78 	exec->objects = kmalloc(PAGE_SIZE, GFP_KERNEL);
79 
80 	/* If allocation here fails, just delay that till the first use */
81 	exec->max_objects = exec->objects ? PAGE_SIZE / sizeof(void *) : 0;
82 	exec->num_objects = 0;
83 	exec->contended = DRM_EXEC_DUMMY;
84 	exec->prelocked = NULL;
85 }
86 EXPORT_SYMBOL(drm_exec_init);
87 
88 /**
89  * drm_exec_fini - finalize a drm_exec object
90  * @exec: the drm_exec object to finalize
91  *
92  * Unlock all locked objects, drop the references to objects and free all memory
93  * used for tracking the state.
94  */
95 void drm_exec_fini(struct drm_exec *exec)
96 {
97 	drm_exec_unlock_all(exec);
98 	kvfree(exec->objects);
99 	if (exec->contended != DRM_EXEC_DUMMY) {
100 		drm_gem_object_put(exec->contended);
101 		ww_acquire_fini(&exec->ticket);
102 	}
103 }
104 EXPORT_SYMBOL(drm_exec_fini);
105 
106 /**
107  * drm_exec_cleanup - cleanup when contention is detected
108  * @exec: the drm_exec object to cleanup
109  *
110  * Cleanup the current state and return true if we should stay inside the retry
111  * loop, false if there wasn't any contention detected and we can keep the
112  * objects locked.
113  */
114 bool drm_exec_cleanup(struct drm_exec *exec)
115 {
116 	if (likely(!exec->contended)) {
117 		ww_acquire_done(&exec->ticket);
118 		return false;
119 	}
120 
121 	if (likely(exec->contended == DRM_EXEC_DUMMY)) {
122 		exec->contended = NULL;
123 		ww_acquire_init(&exec->ticket, &reservation_ww_class);
124 		return true;
125 	}
126 
127 	drm_exec_unlock_all(exec);
128 	exec->num_objects = 0;
129 	return true;
130 }
131 EXPORT_SYMBOL(drm_exec_cleanup);
132 
133 /* Track the locked object in the array */
134 static int drm_exec_obj_locked(struct drm_exec *exec,
135 			       struct drm_gem_object *obj)
136 {
137 	if (unlikely(exec->num_objects == exec->max_objects)) {
138 		size_t size = exec->max_objects * sizeof(void *);
139 		void *tmp;
140 
141 		tmp = kvrealloc(exec->objects, size, size + PAGE_SIZE,
142 				GFP_KERNEL);
143 		if (!tmp)
144 			return -ENOMEM;
145 
146 		exec->objects = tmp;
147 		exec->max_objects += PAGE_SIZE / sizeof(void *);
148 	}
149 	drm_gem_object_get(obj);
150 	exec->objects[exec->num_objects++] = obj;
151 
152 	return 0;
153 }
154 
155 /* Make sure the contended object is locked first */
156 static int drm_exec_lock_contended(struct drm_exec *exec)
157 {
158 	struct drm_gem_object *obj = exec->contended;
159 	int ret;
160 
161 	if (likely(!obj))
162 		return 0;
163 
164 	/* Always cleanup the contention so that error handling can kick in */
165 	exec->contended = NULL;
166 	if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT) {
167 		ret = dma_resv_lock_slow_interruptible(obj->resv,
168 						       &exec->ticket);
169 		if (unlikely(ret))
170 			goto error_dropref;
171 	} else {
172 		dma_resv_lock_slow(obj->resv, &exec->ticket);
173 	}
174 
175 	ret = drm_exec_obj_locked(exec, obj);
176 	if (unlikely(ret))
177 		goto error_unlock;
178 
179 	exec->prelocked = obj;
180 	return 0;
181 
182 error_unlock:
183 	dma_resv_unlock(obj->resv);
184 
185 error_dropref:
186 	drm_gem_object_put(obj);
187 	return ret;
188 }
189 
190 /**
191  * drm_exec_lock_obj - lock a GEM object for use
192  * @exec: the drm_exec object with the state
193  * @obj: the GEM object to lock
194  *
195  * Lock a GEM object for use and grab a reference to it.
196  *
197  * Returns: -EDEADLK if a contention is detected, -EALREADY when object is
198  * already locked (can be suppressed by setting the DRM_EXEC_IGNORE_DUPLICATES
199  * flag), -ENOMEM when memory allocation failed and zero for success.
200  */
201 int drm_exec_lock_obj(struct drm_exec *exec, struct drm_gem_object *obj)
202 {
203 	int ret;
204 
205 	ret = drm_exec_lock_contended(exec);
206 	if (unlikely(ret))
207 		return ret;
208 
209 	if (exec->prelocked == obj) {
210 		drm_gem_object_put(exec->prelocked);
211 		exec->prelocked = NULL;
212 		return 0;
213 	}
214 
215 	if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT)
216 		ret = dma_resv_lock_interruptible(obj->resv, &exec->ticket);
217 	else
218 		ret = dma_resv_lock(obj->resv, &exec->ticket);
219 
220 	if (unlikely(ret == -EDEADLK)) {
221 		drm_gem_object_get(obj);
222 		exec->contended = obj;
223 		return -EDEADLK;
224 	}
225 
226 	if (unlikely(ret == -EALREADY) &&
227 	    exec->flags & DRM_EXEC_IGNORE_DUPLICATES)
228 		return 0;
229 
230 	if (unlikely(ret))
231 		return ret;
232 
233 	ret = drm_exec_obj_locked(exec, obj);
234 	if (ret)
235 		goto error_unlock;
236 
237 	return 0;
238 
239 error_unlock:
240 	dma_resv_unlock(obj->resv);
241 	return ret;
242 }
243 EXPORT_SYMBOL(drm_exec_lock_obj);
244 
245 /**
246  * drm_exec_unlock_obj - unlock a GEM object in this exec context
247  * @exec: the drm_exec object with the state
248  * @obj: the GEM object to unlock
249  *
250  * Unlock the GEM object and remove it from the collection of locked objects.
251  * Should only be used to unlock the most recently locked objects. It's not time
252  * efficient to unlock objects locked long ago.
253  */
254 void drm_exec_unlock_obj(struct drm_exec *exec, struct drm_gem_object *obj)
255 {
256 	unsigned int i;
257 
258 	for (i = exec->num_objects; i--;) {
259 		if (exec->objects[i] == obj) {
260 			dma_resv_unlock(obj->resv);
261 			for (++i; i < exec->num_objects; ++i)
262 				exec->objects[i - 1] = exec->objects[i];
263 			--exec->num_objects;
264 			drm_gem_object_put(obj);
265 			return;
266 		}
267 
268 	}
269 }
270 EXPORT_SYMBOL(drm_exec_unlock_obj);
271 
272 /**
273  * drm_exec_prepare_obj - prepare a GEM object for use
274  * @exec: the drm_exec object with the state
275  * @obj: the GEM object to prepare
276  * @num_fences: how many fences to reserve
277  *
278  * Prepare a GEM object for use by locking it and reserving fence slots.
279  *
280  * Returns: -EDEADLK if a contention is detected, -EALREADY when object is
281  * already locked, -ENOMEM when memory allocation failed and zero for success.
282  */
283 int drm_exec_prepare_obj(struct drm_exec *exec, struct drm_gem_object *obj,
284 			 unsigned int num_fences)
285 {
286 	int ret;
287 
288 	ret = drm_exec_lock_obj(exec, obj);
289 	if (ret)
290 		return ret;
291 
292 	ret = dma_resv_reserve_fences(obj->resv, num_fences);
293 	if (ret) {
294 		drm_exec_unlock_obj(exec, obj);
295 		return ret;
296 	}
297 
298 	return 0;
299 }
300 EXPORT_SYMBOL(drm_exec_prepare_obj);
301 
302 /**
303  * drm_exec_prepare_array - helper to prepare an array of objects
304  * @exec: the drm_exec object with the state
305  * @objects: array of GEM object to prepare
306  * @num_objects: number of GEM objects in the array
307  * @num_fences: number of fences to reserve on each GEM object
308  *
309  * Prepares all GEM objects in an array, aborts on first error.
310  * Reserves @num_fences on each GEM object after locking it.
311  *
312  * Returns: -EDEADLOCK on contention, -EALREADY when object is already locked,
313  * -ENOMEM when memory allocation failed and zero for success.
314  */
315 int drm_exec_prepare_array(struct drm_exec *exec,
316 			   struct drm_gem_object **objects,
317 			   unsigned int num_objects,
318 			   unsigned int num_fences)
319 {
320 	int ret;
321 
322 	for (unsigned int i = 0; i < num_objects; ++i) {
323 		ret = drm_exec_prepare_obj(exec, objects[i], num_fences);
324 		if (unlikely(ret))
325 			return ret;
326 	}
327 
328 	return 0;
329 }
330 EXPORT_SYMBOL(drm_exec_prepare_array);
331 
332 MODULE_DESCRIPTION("DRM execution context");
333 MODULE_LICENSE("Dual MIT/GPL");
334