drm/ttm, drm/xe: Modify the struct ttm_bo_lru_walk_cursor initialization

Instead of the struct ttm_operation_ctx, Pass a struct ttm_lru_walk_arg
to enable us to easily extend the walk functionality, and to
implement ttm_lru_walk_for_evict() using the guarded LRU iteration.

Signed-off-by: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Reviewed-by: Christian König <christian.koenig@amd.com>
Link: https://lore.kernel.org/r/20250623155313.4901-3-thomas.hellstrom@linux.intel.com

diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c b/drivers/gpu/drm/ttm/ttm_bo_util.c
index 5433eb87593d5b65157e7a9da3798ec5bd3bd8f5..6de1f0c432c29f1d63ce2511f539b980bf7c816c 100644 (file)
--- a/drivers/gpu/drm/ttm/ttm_bo_util.c
+++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
@@ -958,11 +958,11 @@ EXPORT_SYMBOL(ttm_bo_lru_cursor_fini);
  * ttm_bo_lru_cursor_init() - Initialize a struct ttm_bo_lru_cursor
  * @curs: The ttm_bo_lru_cursor to initialize.
  * @man: The ttm resource_manager whose LRU lists to iterate over.
- * @ctx: The ttm_operation_ctx to govern the locking.
+ * @arg: The ttm_lru_walk_arg to govern the walk.
  *
  * Initialize a struct ttm_bo_lru_cursor. Currently only trylocking
  * or prelocked buffer objects are available as detailed by
- * @ctx::resv and @ctx::allow_res_evict. Ticketlocking is not
+ * @arg->ctx.resv and @arg->ctx.allow_res_evict. Ticketlocking is not
  * supported.
  *
  * Return: Pointer to @curs. The function does not fail.
@@ -970,11 +970,11 @@ EXPORT_SYMBOL(ttm_bo_lru_cursor_fini);
 struct ttm_bo_lru_cursor *
 ttm_bo_lru_cursor_init(struct ttm_bo_lru_cursor *curs,
                       struct ttm_resource_manager *man,
-                      struct ttm_operation_ctx *ctx)
+                      struct ttm_lru_walk_arg *arg)
 {
        memset(curs, 0, sizeof(*curs));
        ttm_resource_cursor_init(&curs->res_curs, man);
-       curs->arg.ctx = ctx;
+       curs->arg = arg;
 
        return curs;
 }
@@ -985,7 +985,7 @@ ttm_bo_from_res_reserved(struct ttm_resource *res, struct ttm_bo_lru_cursor *cur
 {
        struct ttm_buffer_object *bo = res->bo;
 
-       if (!ttm_lru_walk_trylock(&curs->arg, bo, &curs->needs_unlock))
+       if (!ttm_lru_walk_trylock(curs->arg, bo, &curs->needs_unlock))
                return NULL;
 
        if (!ttm_bo_get_unless_zero(bo)) {

diff --git a/drivers/gpu/drm/xe/xe_shrinker.c b/drivers/gpu/drm/xe/xe_shrinker.c
index 86d47aaf0358922fde876117914c1b3d1bdd0138..c9df97ccadc3afd0559549b91dfdd14de47e7bce 100644 (file)
--- a/drivers/gpu/drm/xe/xe_shrinker.c
+++ b/drivers/gpu/drm/xe/xe_shrinker.c
@@ -65,11 +65,12 @@ static s64 xe_shrinker_walk(struct xe_device *xe,
                struct ttm_resource_manager *man = ttm_manager_type(&xe->ttm, mem_type);
                struct ttm_bo_lru_cursor curs;
                struct ttm_buffer_object *ttm_bo;
+               struct ttm_lru_walk_arg arg = {.ctx = ctx};
 
                if (!man || !man->use_tt)
                        continue;
 
-               ttm_bo_lru_for_each_reserved_guarded(&curs, man, ctx, ttm_bo) {
+               ttm_bo_lru_for_each_reserved_guarded(&curs, man, &arg, ttm_bo) {
                        if (!ttm_bo_shrink_suitable(ttm_bo, ctx))
                                continue;
 

diff --git a/include/drm/ttm/ttm_bo.h b/include/drm/ttm/ttm_bo.h
index c19ac92c33a904bef10b0f334b4f57d14d81a5d1..ab9a6b343a537d3baed43c1c1d490ae3ca6eeebf 100644 (file)
--- a/include/drm/ttm/ttm_bo.h
+++ b/include/drm/ttm/ttm_bo.h
@@ -484,8 +484,8 @@ struct ttm_bo_lru_cursor {
         * unlock before the next iteration or after loop exit.
         */
        bool needs_unlock;
-       /** @arg: Common BO LRU walk arguments. */
-       struct ttm_lru_walk_arg arg;
+       /** @arg: Pointer to common BO LRU walk arguments. */
+       struct ttm_lru_walk_arg *arg;
 };
 
 void ttm_bo_lru_cursor_fini(struct ttm_bo_lru_cursor *curs);
@@ -493,7 +493,7 @@ void ttm_bo_lru_cursor_fini(struct ttm_bo_lru_cursor *curs);
 struct ttm_bo_lru_cursor *
 ttm_bo_lru_cursor_init(struct ttm_bo_lru_cursor *curs,
                       struct ttm_resource_manager *man,
-                      struct ttm_operation_ctx *ctx);
+                      struct ttm_lru_walk_arg *arg);
 
 struct ttm_buffer_object *ttm_bo_lru_cursor_first(struct ttm_bo_lru_cursor *curs);
 
@@ -504,9 +504,9 @@ struct ttm_buffer_object *ttm_bo_lru_cursor_next(struct ttm_bo_lru_cursor *curs)
  */
 DEFINE_CLASS(ttm_bo_lru_cursor, struct ttm_bo_lru_cursor *,
             if (_T) {ttm_bo_lru_cursor_fini(_T); },
-            ttm_bo_lru_cursor_init(curs, man, ctx),
+            ttm_bo_lru_cursor_init(curs, man, arg),
             struct ttm_bo_lru_cursor *curs, struct ttm_resource_manager *man,
-            struct ttm_operation_ctx *ctx);
+            struct ttm_lru_walk_arg *arg);
 static inline void *
 class_ttm_bo_lru_cursor_lock_ptr(class_ttm_bo_lru_cursor_t *_T)
 { return *_T; }
@@ -517,7 +517,7 @@ class_ttm_bo_lru_cursor_lock_ptr(class_ttm_bo_lru_cursor_t *_T)
  * resources on LRU lists.
  * @_cursor: struct ttm_bo_lru_cursor to use for the iteration.
  * @_man: The resource manager whose LRU lists to iterate over.
- * @_ctx: The struct ttm_operation_context to govern the @_bo locking.
+ * @_arg: The struct ttm_lru_walk_arg to govern the LRU walk.
  * @_bo: The struct ttm_buffer_object pointer pointing to the buffer object
  * for the current iteration.
  *
@@ -530,8 +530,8 @@ class_ttm_bo_lru_cursor_lock_ptr(class_ttm_bo_lru_cursor_t *_T)
  * example a return or break statement. Exiting the loop will also unlock
  * (if needed) and unreference @_bo.
  */
-#define ttm_bo_lru_for_each_reserved_guarded(_cursor, _man, _ctx, _bo) \
-       scoped_guard(ttm_bo_lru_cursor, _cursor, _man, _ctx)            \
+#define ttm_bo_lru_for_each_reserved_guarded(_cursor, _man, _arg, _bo) \
+       scoped_guard(ttm_bo_lru_cursor, _cursor, _man, _arg)            \
                for ((_bo) = ttm_bo_lru_cursor_first(_cursor); (_bo);   \
                     (_bo) = ttm_bo_lru_cursor_next(_cursor))