Re: [PATCH v2 09/10] drm/ttm: support using drm_exec during eviction v4

[sashiko-bot@kernel.org]

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 <nat@pixelcluster.dev>

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/20260706-ttm_2_drm_exec-v2-0-4bf6bfc0d320@pixelcluster.dev?part=9