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: obj->resv); |
61 | drm_gem_object_put(obj); |
62 | } |
63 | |
64 | drm_gem_object_put(obj: 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(addr: exec->objects); |
99 | if (exec->contended != DRM_EXEC_DUMMY) { |
100 | drm_gem_object_put(obj: exec->contended); |
101 | ww_acquire_fini(ctx: &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(ctx: &exec->ticket); |
118 | return false; |
119 | } |
120 | |
121 | if (likely(exec->contended == DRM_EXEC_DUMMY)) { |
122 | exec->contended = NULL; |
123 | ww_acquire_init(ctx: &exec->ticket, ww_class: &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(p: exec->objects, oldsize: size, newsize: 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: obj->resv, |
168 | ctx: &exec->ticket); |
169 | if (unlikely(ret)) |
170 | goto error_dropref; |
171 | } else { |
172 | dma_resv_lock_slow(obj: obj->resv, ctx: &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: 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(obj: 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: obj->resv, ctx: &exec->ticket); |
217 | else |
218 | ret = dma_resv_lock(obj: obj->resv, ctx: &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: 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: 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: 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 | |