Skip to content

Commit 0959321

Browse files
drm: execution context for GEM buffers v7
This adds the infrastructure for an execution context for GEM buffers which is similar to the existing TTMs execbuf util and intended to replace it in the long term. The basic functionality is that we abstracts the necessary loop to lock many different GEM buffers with automated deadlock and duplicate handling. v2: drop xarray and use dynamic resized array instead, the locking overhead is unnecessary and measurable. v3: drop duplicate tracking, radeon is really the only one needing that. v4: fixes issues pointed out by Danilo, some typos in comments and a helper for lock arrays of GEM objects. v5: some suggestions by Boris Brezillon, especially just use one retry macro, drop loop in prepare_array, use flags instead of bool v6: minor changes suggested by Thomas, Boris and Danilo v7: minor typos pointed out by checkpatch.pl fixed Signed-off-by: Christian König <[email protected]> Reviewed-by: Boris Brezillon <[email protected]> Reviewed-by: Danilo Krummrich <[email protected]> Tested-by: Danilo Krummrich <[email protected]> Acked-by: Alex Deucher <[email protected]> Link: https://patchwork.freedesktop.org/patch/msgid/[email protected]
1 parent f1b215f commit 0959321

File tree

5 files changed

+476
-0
lines changed

5 files changed

+476
-0
lines changed

Documentation/gpu/drm-mm.rst

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -493,6 +493,18 @@ DRM Sync Objects
493493
.. kernel-doc:: drivers/gpu/drm/drm_syncobj.c
494494
:export:
495495

496+
DRM Execution context
497+
=====================
498+
499+
.. kernel-doc:: drivers/gpu/drm/drm_exec.c
500+
:doc: Overview
501+
502+
.. kernel-doc:: include/drm/drm_exec.h
503+
:internal:
504+
505+
.. kernel-doc:: drivers/gpu/drm/drm_exec.c
506+
:export:
507+
496508
GPU Scheduler
497509
=============
498510

drivers/gpu/drm/Kconfig

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -194,6 +194,12 @@ config DRM_TTM
194194
GPU memory types. Will be enabled automatically if a device driver
195195
uses it.
196196

197+
config DRM_EXEC
198+
tristate
199+
depends on DRM
200+
help
201+
Execution context for command submissions
202+
197203
config DRM_BUDDY
198204
tristate
199205
depends on DRM

drivers/gpu/drm/Makefile

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -78,6 +78,8 @@ obj-$(CONFIG_DRM_PANEL_ORIENTATION_QUIRKS) += drm_panel_orientation_quirks.o
7878
#
7979
# Memory-management helpers
8080
#
81+
#
82+
obj-$(CONFIG_DRM_EXEC) += drm_exec.o
8183

8284
obj-$(CONFIG_DRM_BUDDY) += drm_buddy.o
8385

drivers/gpu/drm/drm_exec.c

Lines changed: 333 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,333 @@
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(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");

0 commit comments

Comments
 (0)