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 * @nr: the initial # of objects 73 * 74 * Initialize the object and make sure that we can track locked objects. 75 * 76 * If nr is non-zero then it is used as the initial objects table size. 77 * In either case, the table will grow (be re-allocated) on demand. 78 */ 79 void drm_exec_init(struct drm_exec *exec, u32 flags, unsigned nr) 80 { 81 if (!nr) 82 nr = PAGE_SIZE / sizeof(void *); 83 84 exec->flags = flags; 85 exec->objects = kvmalloc_array(nr, sizeof(void *), GFP_KERNEL); 86 87 /* If allocation here fails, just delay that till the first use */ 88 exec->max_objects = exec->objects ? nr : 0; 89 exec->num_objects = 0; 90 exec->contended = DRM_EXEC_DUMMY; 91 exec->prelocked = NULL; 92 } 93 EXPORT_SYMBOL(drm_exec_init); 94 95 /** 96 * drm_exec_fini - finalize a drm_exec object 97 * @exec: the drm_exec object to finalize 98 * 99 * Unlock all locked objects, drop the references to objects and free all memory 100 * used for tracking the state. 101 */ 102 void drm_exec_fini(struct drm_exec *exec) 103 { 104 drm_exec_unlock_all(exec); 105 kvfree(exec->objects); 106 if (exec->contended != DRM_EXEC_DUMMY) { 107 drm_gem_object_put(exec->contended); 108 ww_acquire_fini(&exec->ticket); 109 } 110 } 111 EXPORT_SYMBOL(drm_exec_fini); 112 113 /** 114 * drm_exec_cleanup - cleanup when contention is detected 115 * @exec: the drm_exec object to cleanup 116 * 117 * Cleanup the current state and return true if we should stay inside the retry 118 * loop, false if there wasn't any contention detected and we can keep the 119 * objects locked. 120 */ 121 bool drm_exec_cleanup(struct drm_exec *exec) 122 { 123 if (likely(!exec->contended)) { 124 ww_acquire_done(&exec->ticket); 125 return false; 126 } 127 128 if (likely(exec->contended == DRM_EXEC_DUMMY)) { 129 exec->contended = NULL; 130 ww_acquire_init(&exec->ticket, &reservation_ww_class); 131 return true; 132 } 133 134 drm_exec_unlock_all(exec); 135 exec->num_objects = 0; 136 return true; 137 } 138 EXPORT_SYMBOL(drm_exec_cleanup); 139 140 /* Track the locked object in the array */ 141 static int drm_exec_obj_locked(struct drm_exec *exec, 142 struct drm_gem_object *obj) 143 { 144 if (unlikely(exec->num_objects == exec->max_objects)) { 145 size_t size = exec->max_objects * sizeof(void *); 146 void *tmp; 147 148 tmp = kvrealloc(exec->objects, size + PAGE_SIZE, GFP_KERNEL); 149 if (!tmp) 150 return -ENOMEM; 151 152 exec->objects = tmp; 153 exec->max_objects += PAGE_SIZE / sizeof(void *); 154 } 155 drm_gem_object_get(obj); 156 exec->objects[exec->num_objects++] = obj; 157 158 return 0; 159 } 160 161 /* Make sure the contended object is locked first */ 162 static int drm_exec_lock_contended(struct drm_exec *exec) 163 { 164 struct drm_gem_object *obj = exec->contended; 165 int ret; 166 167 if (likely(!obj)) 168 return 0; 169 170 /* Always cleanup the contention so that error handling can kick in */ 171 exec->contended = NULL; 172 if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT) { 173 ret = dma_resv_lock_slow_interruptible(obj->resv, 174 &exec->ticket); 175 if (unlikely(ret)) 176 goto error_dropref; 177 } else { 178 dma_resv_lock_slow(obj->resv, &exec->ticket); 179 } 180 181 ret = drm_exec_obj_locked(exec, obj); 182 if (unlikely(ret)) 183 goto error_unlock; 184 185 exec->prelocked = obj; 186 return 0; 187 188 error_unlock: 189 dma_resv_unlock(obj->resv); 190 191 error_dropref: 192 drm_gem_object_put(obj); 193 return ret; 194 } 195 196 /** 197 * drm_exec_lock_obj - lock a GEM object for use 198 * @exec: the drm_exec object with the state 199 * @obj: the GEM object to lock 200 * 201 * Lock a GEM object for use and grab a reference to it. 202 * 203 * Returns: -EDEADLK if a contention is detected, -EALREADY when object is 204 * already locked (can be suppressed by setting the DRM_EXEC_IGNORE_DUPLICATES 205 * flag), -ENOMEM when memory allocation failed and zero for success. 206 */ 207 int drm_exec_lock_obj(struct drm_exec *exec, struct drm_gem_object *obj) 208 { 209 int ret; 210 211 ret = drm_exec_lock_contended(exec); 212 if (unlikely(ret)) 213 return ret; 214 215 if (exec->prelocked == obj) { 216 drm_gem_object_put(exec->prelocked); 217 exec->prelocked = NULL; 218 return 0; 219 } 220 221 if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT) 222 ret = dma_resv_lock_interruptible(obj->resv, &exec->ticket); 223 else 224 ret = dma_resv_lock(obj->resv, &exec->ticket); 225 226 if (unlikely(ret == -EDEADLK)) { 227 drm_gem_object_get(obj); 228 exec->contended = obj; 229 return -EDEADLK; 230 } 231 232 if (unlikely(ret == -EALREADY) && 233 exec->flags & DRM_EXEC_IGNORE_DUPLICATES) 234 return 0; 235 236 if (unlikely(ret)) 237 return ret; 238 239 ret = drm_exec_obj_locked(exec, obj); 240 if (ret) 241 goto error_unlock; 242 243 return 0; 244 245 error_unlock: 246 dma_resv_unlock(obj->resv); 247 return ret; 248 } 249 EXPORT_SYMBOL(drm_exec_lock_obj); 250 251 /** 252 * drm_exec_unlock_obj - unlock a GEM object in this exec context 253 * @exec: the drm_exec object with the state 254 * @obj: the GEM object to unlock 255 * 256 * Unlock the GEM object and remove it from the collection of locked objects. 257 * Should only be used to unlock the most recently locked objects. It's not time 258 * efficient to unlock objects locked long ago. 259 */ 260 void drm_exec_unlock_obj(struct drm_exec *exec, struct drm_gem_object *obj) 261 { 262 unsigned int i; 263 264 for (i = exec->num_objects; i--;) { 265 if (exec->objects[i] == obj) { 266 dma_resv_unlock(obj->resv); 267 for (++i; i < exec->num_objects; ++i) 268 exec->objects[i - 1] = exec->objects[i]; 269 --exec->num_objects; 270 drm_gem_object_put(obj); 271 return; 272 } 273 274 } 275 } 276 EXPORT_SYMBOL(drm_exec_unlock_obj); 277 278 /** 279 * drm_exec_prepare_obj - prepare a GEM object for use 280 * @exec: the drm_exec object with the state 281 * @obj: the GEM object to prepare 282 * @num_fences: how many fences to reserve 283 * 284 * Prepare a GEM object for use by locking it and reserving fence slots. 285 * 286 * Returns: -EDEADLK if a contention is detected, -EALREADY when object is 287 * already locked, -ENOMEM when memory allocation failed and zero for success. 288 */ 289 int drm_exec_prepare_obj(struct drm_exec *exec, struct drm_gem_object *obj, 290 unsigned int num_fences) 291 { 292 int ret; 293 294 ret = drm_exec_lock_obj(exec, obj); 295 if (ret) 296 return ret; 297 298 ret = dma_resv_reserve_fences(obj->resv, num_fences); 299 if (ret) { 300 drm_exec_unlock_obj(exec, obj); 301 return ret; 302 } 303 304 return 0; 305 } 306 EXPORT_SYMBOL(drm_exec_prepare_obj); 307 308 /** 309 * drm_exec_prepare_array - helper to prepare an array of objects 310 * @exec: the drm_exec object with the state 311 * @objects: array of GEM object to prepare 312 * @num_objects: number of GEM objects in the array 313 * @num_fences: number of fences to reserve on each GEM object 314 * 315 * Prepares all GEM objects in an array, aborts on first error. 316 * Reserves @num_fences on each GEM object after locking it. 317 * 318 * Returns: -EDEADLOCK on contention, -EALREADY when object is already locked, 319 * -ENOMEM when memory allocation failed and zero for success. 320 */ 321 int drm_exec_prepare_array(struct drm_exec *exec, 322 struct drm_gem_object **objects, 323 unsigned int num_objects, 324 unsigned int num_fences) 325 { 326 int ret; 327 328 for (unsigned int i = 0; i < num_objects; ++i) { 329 ret = drm_exec_prepare_obj(exec, objects[i], num_fences); 330 if (unlikely(ret)) 331 return ret; 332 } 333 334 return 0; 335 } 336 EXPORT_SYMBOL(drm_exec_prepare_array); 337 338 MODULE_DESCRIPTION("DRM execution context"); 339 MODULE_LICENSE("Dual MIT/GPL"); 340