Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 OR MIT */
       2             : 
       3             : #ifndef __DRM_EXEC_H__
       4             : #define __DRM_EXEC_H__
       5             : 
       6             : #include <linux/ww_mutex.h>
       7             : 
       8             : #define DRM_EXEC_INTERRUPTIBLE_WAIT     BIT(0)
       9             : #define DRM_EXEC_IGNORE_DUPLICATES      BIT(1)
      10             : 
      11             : struct drm_gem_object;
      12             : 
      13             : /**
      14             :  * struct drm_exec - Execution context
      15             :  */
      16             : struct drm_exec {
      17             :         /**
      18             :          * @flags: Flags to control locking behavior
      19             :          */
      20             :         uint32_t                flags;
      21             : 
      22             :         /**
      23             :          * @ticket: WW ticket used for acquiring locks
      24             :          */
      25             :         struct ww_acquire_ctx   ticket;
      26             : 
      27             :         /**
      28             :          * @num_objects: number of objects locked
      29             :          */
      30             :         unsigned int            num_objects;
      31             : 
      32             :         /**
      33             :          * @max_objects: maximum objects in array
      34             :          */
      35             :         unsigned int            max_objects;
      36             : 
      37             :         /**
      38             :          * @objects: array of the locked objects
      39             :          */
      40             :         struct drm_gem_object   **objects;
      41             : 
      42             :         /**
      43             :          * @contended: contended GEM object we backed off for
      44             :          */
      45             :         struct drm_gem_object   *contended;
      46             : 
      47             :         /**
      48             :          * @prelocked: already locked GEM object due to contention
      49             :          */
      50             :         struct drm_gem_object *prelocked;
      51             : };
      52             : 
      53             : /**
      54             :  * drm_exec_for_each_locked_object - iterate over all the locked objects
      55             :  * @exec: drm_exec object
      56             :  * @index: unsigned long index for the iteration
      57             :  * @obj: the current GEM object
      58             :  *
      59             :  * Iterate over all the locked GEM objects inside the drm_exec object.
      60             :  */
      61             : #define drm_exec_for_each_locked_object(exec, index, obj)       \
      62             :         for (index = 0, obj = (exec)->objects[0];            \
      63             :              index < (exec)->num_objects;                 \
      64             :              ++index, obj = (exec)->objects[index])
      65             : 
      66             : /**
      67             :  * drm_exec_until_all_locked - loop until all GEM objects are locked
      68             :  * @exec: drm_exec object
      69             :  *
      70             :  * Core functionality of the drm_exec object. Loops until all GEM objects are
      71             :  * locked and no more contention exists. At the beginning of the loop it is
      72             :  * guaranteed that no GEM object is locked.
      73             :  *
      74             :  * Since labels can't be defined local to the loops body we use a jump pointer
      75             :  * to make sure that the retry is only used from within the loops body.
      76             :  */
      77             : #define drm_exec_until_all_locked(exec)                         \
      78             :         for (void *__drm_exec_retry_ptr; ({                     \
      79             :                 __label__ __drm_exec_retry;                     \
      80             : __drm_exec_retry:                                               \
      81             :                 __drm_exec_retry_ptr = &&__drm_exec_retry;      \
      82             :                 (void)__drm_exec_retry_ptr;                     \
      83             :                 drm_exec_cleanup(exec);                         \
      84             :         });)
      85             : 
      86             : /**
      87             :  * drm_exec_retry_on_contention - restart the loop to grap all locks
      88             :  * @exec: drm_exec object
      89             :  *
      90             :  * Control flow helper to continue when a contention was detected and we need to
      91             :  * clean up and re-start the loop to prepare all GEM objects.
      92             :  */
      93             : #define drm_exec_retry_on_contention(exec)                      \
      94             :         do {                                                    \
      95             :                 if (unlikely(drm_exec_is_contended(exec)))      \
      96             :                         goto *__drm_exec_retry_ptr;             \
      97             :         } while (0)
      98             : 
      99             : /**
     100             :  * drm_exec_is_contended - check for contention
     101             :  * @exec: drm_exec object
     102             :  *
     103             :  * Returns true if the drm_exec object has run into some contention while
     104             :  * locking a GEM object and needs to clean up.
     105             :  */
     106             : static inline bool drm_exec_is_contended(struct drm_exec *exec)
     107             : {
     108           6 :         return !!exec->contended;
     109             : }
     110             : 
     111             : void drm_exec_init(struct drm_exec *exec, uint32_t flags);
     112             : void drm_exec_fini(struct drm_exec *exec);
     113             : bool drm_exec_cleanup(struct drm_exec *exec);
     114             : int drm_exec_lock_obj(struct drm_exec *exec, struct drm_gem_object *obj);
     115             : void drm_exec_unlock_obj(struct drm_exec *exec, struct drm_gem_object *obj);
     116             : int drm_exec_prepare_obj(struct drm_exec *exec, struct drm_gem_object *obj,
     117             :                          unsigned int num_fences);
     118             : int drm_exec_prepare_array(struct drm_exec *exec,
     119             :                            struct drm_gem_object **objects,
     120             :                            unsigned int num_objects,
     121             :                            unsigned int num_fences);
     122             : 
     123             : #endif