drivers/gpu/drm/drm_exec.c

   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, size + PAGE_SIZE,
 149                                 GFP_KERNEL);
 150                 if (!tmp)
 151                         return -ENOMEM;
 152
 153                 exec->objects = tmp;
 154                 exec->max_objects += PAGE_SIZE / sizeof(void *);
 155         }
 156         drm_gem_object_get(obj);
 157         exec->objects[exec->num_objects++] = obj;
 158
 159         return 0;
 160 }
 161
 162 /* Make sure the contended object is locked first */
 163 static int drm_exec_lock_contended(struct drm_exec *exec)
 164 {
 165         struct drm_gem_object *obj = exec->contended;
 166         int ret;
 167
 168         if (likely(!obj))
 169                 return 0;
 170
 171         /* Always cleanup the contention so that error handling can kick in */
 172         exec->contended = NULL;
 173         if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT) {
 174                 ret = dma_resv_lock_slow_interruptible(obj->resv,
 175                                                        &exec->ticket);
 176                 if (unlikely(ret))
 177                         goto error_dropref;
 178         } else {
 179                 dma_resv_lock_slow(obj->resv, &exec->ticket);
 180         }
 181
 182         ret = drm_exec_obj_locked(exec, obj);
 183         if (unlikely(ret))
 184                 goto error_unlock;
 185
 186         exec->prelocked = obj;
 187         return 0;
 188
 189 error_unlock:
 190         dma_resv_unlock(obj->resv);
 191
 192 error_dropref:
 193         drm_gem_object_put(obj);
 194         return ret;
 195 }
 196
 197 /**
 198  * drm_exec_lock_obj - lock a GEM object for use
 199  * @exec: the drm_exec object with the state
 200  * @obj: the GEM object to lock
 201  *
 202  * Lock a GEM object for use and grab a reference to it.
 203  *
 204  * Returns: -EDEADLK if a contention is detected, -EALREADY when object is
 205  * already locked (can be suppressed by setting the DRM_EXEC_IGNORE_DUPLICATES
 206  * flag), -ENOMEM when memory allocation failed and zero for success.
 207  */
 208 int drm_exec_lock_obj(struct drm_exec *exec, struct drm_gem_object *obj)
 209 {
 210         int ret;
 211
 212         ret = drm_exec_lock_contended(exec);
 213         if (unlikely(ret))
 214                 return ret;
 215
 216         if (exec->prelocked == obj) {
 217                 drm_gem_object_put(exec->prelocked);
 218                 exec->prelocked = NULL;
 219                 return 0;
 220         }
 221
 222         if (exec->flags & DRM_EXEC_INTERRUPTIBLE_WAIT)
 223                 ret = dma_resv_lock_interruptible(obj->resv, &exec->ticket);
 224         else
 225                 ret = dma_resv_lock(obj->resv, &exec->ticket);
 226
 227         if (unlikely(ret == -EDEADLK)) {
 228                 drm_gem_object_get(obj);
 229                 exec->contended = obj;
 230                 return -EDEADLK;
 231         }
 232
 233         if (unlikely(ret == -EALREADY) &&
 234             exec->flags & DRM_EXEC_IGNORE_DUPLICATES)
 235                 return 0;
 236
 237         if (unlikely(ret))
 238                 return ret;
 239
 240         ret = drm_exec_obj_locked(exec, obj);
 241         if (ret)
 242                 goto error_unlock;
 243
 244         return 0;
 245
 246 error_unlock:
 247         dma_resv_unlock(obj->resv);
 248         return ret;
 249 }
 250 EXPORT_SYMBOL(drm_exec_lock_obj);
 251
 252 /**
 253  * drm_exec_unlock_obj - unlock a GEM object in this exec context
 254  * @exec: the drm_exec object with the state
 255  * @obj: the GEM object to unlock
 256  *
 257  * Unlock the GEM object and remove it from the collection of locked objects.
 258  * Should only be used to unlock the most recently locked objects. It's not time
 259  * efficient to unlock objects locked long ago.
 260  */
 261 void drm_exec_unlock_obj(struct drm_exec *exec, struct drm_gem_object *obj)
 262 {
 263         unsigned int i;
 264
 265         for (i = exec->num_objects; i--;) {
 266                 if (exec->objects[i] == obj) {
 267                         dma_resv_unlock(obj->resv);
 268                         for (++i; i < exec->num_objects; ++i)
 269                                 exec->objects[i - 1] = exec->objects[i];
 270                         --exec->num_objects;
 271                         drm_gem_object_put(obj);
 272                         return;
 273                 }
 274
 275         }
 276 }
 277 EXPORT_SYMBOL(drm_exec_unlock_obj);
 278
 279 /**
 280  * drm_exec_prepare_obj - prepare a GEM object for use
 281  * @exec: the drm_exec object with the state
 282  * @obj: the GEM object to prepare
 283  * @num_fences: how many fences to reserve
 284  *
 285  * Prepare a GEM object for use by locking it and reserving fence slots.
 286  *
 287  * Returns: -EDEADLK if a contention is detected, -EALREADY when object is
 288  * already locked, -ENOMEM when memory allocation failed and zero for success.
 289  */
 290 int drm_exec_prepare_obj(struct drm_exec *exec, struct drm_gem_object *obj,
 291                          unsigned int num_fences)
 292 {
 293         int ret;
 294
 295         ret = drm_exec_lock_obj(exec, obj);
 296         if (ret)
 297                 return ret;
 298
 299         ret = dma_resv_reserve_fences(obj->resv, num_fences);
 300         if (ret) {
 301                 drm_exec_unlock_obj(exec, obj);
 302                 return ret;
 303         }
 304
 305         return 0;
 306 }
 307 EXPORT_SYMBOL(drm_exec_prepare_obj);
 308
 309 /**
 310  * drm_exec_prepare_array - helper to prepare an array of objects
 311  * @exec: the drm_exec object with the state
 312  * @objects: array of GEM object to prepare
 313  * @num_objects: number of GEM objects in the array
 314  * @num_fences: number of fences to reserve on each GEM object
 315  *
 316  * Prepares all GEM objects in an array, aborts on first error.
 317  * Reserves @num_fences on each GEM object after locking it.
 318  *
 319  * Returns: -EDEADLOCK on contention, -EALREADY when object is already locked,
 320  * -ENOMEM when memory allocation failed and zero for success.
 321  */
 322 int drm_exec_prepare_array(struct drm_exec *exec,
 323                            struct drm_gem_object **objects,
 324                            unsigned int num_objects,
 325                            unsigned int num_fences)
 326 {
 327         int ret;
 328
 329         for (unsigned int i = 0; i < num_objects; ++i) {
 330                 ret = drm_exec_prepare_obj(exec, objects[i], num_fences);
 331                 if (unlikely(ret))
 332                         return ret;
 333         }
 334
 335         return 0;
 336 }
 337 EXPORT_SYMBOL(drm_exec_prepare_array);
 338
 339 MODULE_DESCRIPTION("DRM execution context");
 340 MODULE_LICENSE("Dual MIT/GPL");