Thank you for your contribution! Sashiko AI review found 1 potential issue(s) 
to consider:
- [High] The logic change silently overrides `trylock_only` and `no_wait_gpu` 
flags when `ctx->exec` is provided, forcing blocking locks instead of trylocks.
--

commit 5fb376340fb1686ce3b629a364137351ecc0b343
Author: Natalie Vock <[email protected]>

drm/ttm: support using drm_exec during eviction v4

Allow specifying a drm_exec object in TTMs operation context which is
used to lock objects during eviction.

> diff --git a/drivers/gpu/drm/ttm/ttm_bo_util.c 
> b/drivers/gpu/drm/ttm/ttm_bo_util.c
> index a53b25e8c2967..96699532817c2 100644
> --- a/drivers/gpu/drm/ttm/ttm_bo_util.c
> +++ b/drivers/gpu/drm/ttm/ttm_bo_util.c
[ ... ]
> @@ -837,6 +838,8 @@ static bool ttm_lru_walk_trylock(struct ttm_bo_lru_cursor 
> *curs,
>       struct ttm_operation_ctx *ctx = curs->arg->ctx;
>  
>       curs->needs_unlock = false;
> +     if (ctx->exec)
> +             return false;

[Severity: High]
Does returning false here when ctx->exec is set force the walk to bypass
trylocking and push the logic into a blocking fallback?

>  
>       if (dma_resv_trylock(bo->base.resv)) {
>               curs->needs_unlock = true;
[ ... ]
> @@ -857,7 +860,9 @@ static int ttm_lru_walk_ticketlock(struct 
> ttm_bo_lru_cursor *curs,
>       struct ttm_lru_walk_arg *arg = curs->arg;
>       int ret;
>  
> -     if (arg->ctx->interruptible)
> +     if (arg->ctx->exec)
> +             ret = drm_exec_lock_obj_report_dup(arg->ctx->exec, &bo->base);

[Severity: High]
Does this perform a blocking WW mutex lock via drm_exec, completely ignoring
the trylock_only intent of the caller?

> +     else if (arg->ctx->interruptible)
>               ret = dma_resv_lock_interruptible(bo->base.resv, arg->ticket);
>       else
>               ret = dma_resv_lock(bo->base.resv, arg->ticket);
[ ... ]
> @@ -1016,8 +1030,8 @@ __ttm_bo_lru_cursor_next(struct ttm_bo_lru_cursor *curs)
>               if (ttm_lru_walk_trylock(curs, bo)) {
>                       bo_locked = true;
>  
> -             } else if (!arg->ticket || arg->ctx->no_wait_gpu ||
> -                        arg->trylock_only) {
> +             } else if ((!arg->ticket || arg->ctx->no_wait_gpu ||
> +                         arg->trylock_only) && !arg->ctx->exec) {

[Severity: High]
Does negating the non-blocking flags when ctx->exec is present force the
walk to fall through to a blocking lock attempt?

This appears to silently override the trylock_only and no_wait_gpu flags.
When amdgpu_cs_bo_validate() triggers TTM eviction under memory pressure, it
passes an operation context with ctx->exec set. ttm_bo_evict_first() initiates
its first pass with trylock_only = true to find an idle buffer.

Because of these changes, the walk bypasses the trylock_only check and falls
through to ttm_lru_walk_ticketlock(), which calls
drm_exec_lock_obj_report_dup() and performs a blocking WW mutex lock.

Could this cause the eviction to block and wait on the first busy buffer in
the LRU instead of skipping it, potentially breaking the two-pass eviction
strategy and leading to unnecessary command submission backoffs or
serialization of independent workloads?

>                       spin_unlock(lru_lock);
>                       ttm_bo_put(bo);
>                       spin_lock(lru_lock);

-- 
Sashiko AI review ยท 
https://sashiko.dev/#/patchset/[email protected]?part=9

Reply via email to