AMD-GFX Archive on lore.kernel.org
 help / color / mirror / Atom feed
From: sashiko-bot@kernel.org
To: "Natalie Vock" <nat@pixelcluster.dev>
Cc: amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org
Subject: Re: [PATCH v2 02/10] drm/amdgpu: Add and use vm_update_ctx struct
Date: Tue, 17 Nov 2026 13:26:20 +0000	[thread overview]
Message-ID: <sashiko-outbox-218873@kernel.org> (raw)
In-Reply-To: <20261117-prt-explicit-sync-v2-2-bb3851cb6a0c@pixelcluster.dev>

Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [High] drm/amdgpu: fence and sync leaks in
  amdgpu_gem_add_input_fence() error paths
- [High] drm/amdgpu: stale vm->delayed_freed entries overwrite new PTEs
  in amdgpu_gem_va_update_vm()
- [Medium] drm/amdgpu: swallowed error and sync leak in
  amdgpu_vm_handle_moved()
- [Medium] drm/amdgpu: update_ctx.sync leak on seq64_va error in
  amdgpu_cs_vm_handling()
- [Medium] drm/amdgpu: input fences dropped in amdgpu_gem_va_ioctl()
  without PT range update
- [Medium] drm/amdgpu: cross-BO fence accumulation in
  amdgpu_vm_bo_update()
- [Low] drm/amdgpu: outdated kernel-doc comments for
  amdgpu_vm_bo_update() and vm_update_ctx
--

commit 613a377be8b434a7253a6f919cefd9f59fe0c3de
Author: Natalie Vock <nat@pixelcluster.dev>

drm/amdgpu: Add and use vm_update_ctx struct

This commit introduces struct amdgpu_vm_update_ctx to track freed mappings
and synchronization state across VM mapping and page table update
operations, and moves deferred unmaps onto vm->delayed_freed.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> index 71e2b83faa12b..d1f5ec9a3ef0f 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cs.c
> @@ -1126,6 +1126,7 @@ static int amdgpu_cs_vm_handling(struct amdgpu_cs_parser *p)
>  	struct amdgpu_vm *vm = &fpriv->vm;
>  	struct amdgpu_bo_list_entry *e;
>  	struct amdgpu_bo_va *bo_va;
> +	struct amdgpu_vm_update_ctx update_ctx;
>  	unsigned int i;
>  	int r;
>  
> @@ -1147,34 +1148,36 @@ static int amdgpu_cs_vm_handling(struct amdgpu_cs_parser *p)
>  	if (!amdgpu_vm_ready(vm))
>  		return -EINVAL;
>  
> -	r = amdgpu_vm_clear_freed(adev, vm, NULL);
> +	r = amdgpu_vm_delayed_free(adev, vm, NULL);
>  	if (r)
>  		return r;
>  
> -	r = amdgpu_vm_bo_update(adev, fpriv->prt_va, false);
> +	amdgpu_vm_update_ctx_init(&update_ctx, adev, vm);
> +
> +	r = amdgpu_vm_bo_update(&update_ctx, fpriv->prt_va, false);
>  	if (r)
> -		return r;
> +		goto err_fini_ctx;
>  
>  	r = amdgpu_sync_fence(&p->sync, fpriv->prt_va->last_pt_update,
>  			      GFP_KERNEL);
>  	if (r)
> -		return r;
> +		goto err_fini_ctx;
>  
>  	if (fpriv->csa_va) {
>  		bo_va = fpriv->csa_va;
> -		r = amdgpu_vm_bo_update(adev, bo_va, false);
> +		r = amdgpu_vm_bo_update(&update_ctx, bo_va, false);
>  		if (r)
> -			return r;
> +			goto err_fini_ctx;
>  
>  		r = amdgpu_sync_fence(&p->sync, bo_va->last_pt_update,
>  				      GFP_KERNEL);
>  		if (r)
> -			return r;
> +			goto err_fini_ctx;
>  	}
>  
>  	if (fpriv->seq64_va) {
>  		bo_va = fpriv->seq64_va;
> -		r = amdgpu_vm_bo_update(adev, bo_va, false);
> +		r = amdgpu_vm_bo_update(&update_ctx, bo_va, false);
>  		if (r) {
>  			DRM_ERROR("failed to do vm_bo_update on userq sem\n");
>  			return r;
>  		}
>  
>  		r = amdgpu_sync_fence(&p->sync, bo_va->last_pt_update,
>  				      GFP_KERNEL);
>  		if (r)
>  			return r;
>  	}

[Severity: Medium]
Do the two error returns in the fpriv->seq64_va block leak
update_ctx.sync?  Both paths return r directly instead of jumping to
err_fini_ctx to call amdgpu_vm_update_ctx_fini(&update_ctx), leaking any
amdgpu_sync_entry allocations and dma_fence references added during the
earlier csa_va or seq64_va updates.

[ ... ]

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> index c29df93790c53..e4492c44ce1cb 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> @@ -51,6 +51,7 @@
>  
>  static int
>  amdgpu_gem_add_input_fence(struct drm_file *filp,
> +			   struct amdgpu_vm_update_ctx *update_ctx,
>  			   uint64_t syncobj_handles_array,
>  			   uint32_t num_syncobj_handles)
>  {
> @@ -77,9 +78,10 @@ amdgpu_gem_add_input_fence(struct drm_file *filp,
>  		if (ret)
>  			goto free_memdup;
>  
> -		dma_fence_wait(fence, false);
> +		ret = amdgpu_sync_fence(&update_ctx->sync, fence, GFP_KERNEL);
> +		if (ret)
> +			goto free_memdup;
>  
> -		/* TODO: optimize async handling */
>  		dma_fence_put(fence);
>  	}

[Severity: High]
Does jumping to free_memdup when amdgpu_sync_fence() fails leak the fence
reference acquired by drm_syncobj_find_fence()?

[ ... ]

> @@ -808,8 +811,7 @@ int amdgpu_gem_metadata_ioctl(struct drm_device *dev, void *data,
>   * otherwise stub fence in case of error.
>   */
>  static struct dma_fence *
> -amdgpu_gem_va_update_vm(struct amdgpu_device *adev,
> -			struct amdgpu_vm *vm,
> +amdgpu_gem_va_update_vm(struct amdgpu_vm_update_ctx *ctx,
>  			struct amdgpu_bo_va *bo_va,
>  			uint32_t operation)
>  {
> @@ -817,10 +819,9 @@ amdgpu_gem_va_update_vm(struct amdgpu_device *adev,
>  	int r = 0;
>  
>  	/* If the VM is not ready return only a stub. */
> -	if (!amdgpu_vm_ready(vm))
> +	if (!amdgpu_vm_ready(ctx->vm))
>  		return dma_fence_get_stub();
>  
> -
>  	/*
>  	 * First clean up any freed mappings in the VM.
>  	 *
> @@ -828,20 +829,20 @@ amdgpu_gem_va_update_vm(struct amdgpu_device *adev,
>  	 * schedules GPU work. If nothing needs clearing, @fence can remain as
>  	 * the original vm->last_update.
>  	 */
> -	r = amdgpu_vm_clear_freed(adev, vm, &vm->last_update);
> +	r = amdgpu_vm_clear_freed(ctx, &ctx->vm->last_update);
>  	if (r)
>  		goto error;
>  
>  	/* For MAP/REPLACE we also need to update the BO mappings. */
>  	if (operation == AMDGPU_VA_OP_MAP ||
>  	    operation == AMDGPU_VA_OP_REPLACE) {
> -		r = amdgpu_vm_bo_update(adev, bo_va, false);
> +		r = amdgpu_vm_bo_update(ctx, bo_va, false);
>  		if (r)
>  			goto error;
>  	}

[Severity: High]
Can stale entries on ctx->vm->delayed_freed overwrite newly mapped PTEs?

When an unmap is deferred (for example via AMDGPU_VM_DELAY_UPDATE),
amdgpu_vm_bo_unmap() removes the mapping from vm->va and
amdgpu_vm_update_ctx_fini() splices it onto vm->delayed_freed.  If
userspace then maps a BO at the same VA without AMDGPU_VM_DELAY_UPDATE,
amdgpu_gem_va_update_vm() only clears ctx->freed from the current ioctl and
writes the new BO's valid PTEs while the old unmap remains on
vm->delayed_freed.  A later amdgpu_vm_delayed_free() in
amdgpu_cs_vm_handling() or amdgpu_gem_object_close() will then zero those
active PTEs and cause GPU page faults.

In addition, amdgpu_userq_vm_validate_and_restore_queue() and KFD VM
updates never call amdgpu_vm_delayed_free(), leaving mappings on
vm->delayed_freed uncleared in those paths.

[ ... ]

> @@ -967,8 +969,10 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
>  	if (r)
>  		goto error_put_gobj;
>  
> +	amdgpu_vm_update_ctx_init(&update_ctx, adev, &fpriv->vm);
> +
>  	/* Add input syncobj fences (if any) for synchronization. */
> -	r = amdgpu_gem_add_input_fence(filp,
> +	r = amdgpu_gem_add_input_fence(filp, &update_ctx,
>  				       args->input_fence_syncobj_handles,
>  				       args->num_syncobj_handles);
>  	if (r)
>  		goto error_put_gobj;

[ ... ]

> @@ -1049,7 +1053,7 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
>  	    (!adev->debug_vm || timeline_syncobj)) {
>  		struct dma_fence *fence;
>  
> -		fence = amdgpu_gem_va_update_vm(adev, &fpriv->vm, bo_va,
> +		fence = amdgpu_gem_va_update_vm(&update_ctx, bo_va,
>  						args->operation);
>  		if (timeline_syncobj) {
>  			if (!args->vm_timeline_point) {
> @@ -1070,6 +1074,7 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
>  	}
>  
>  error:
> +	amdgpu_vm_update_ctx_fini(&update_ctx);
>  	dma_fence_chain_free(timeline_chain);
>  	if (timeline_syncobj)
>  		drm_syncobj_put(timeline_syncobj);
>  	drm_exec_fini(&exec);
>  error_put_gobj:
>  	drm_gem_object_put(gobj);
>  	return r;
>  }

[Severity: High]
Does jumping to error_put_gobj when amdgpu_gem_add_input_fence() fails
leak update_ctx.sync?  If amdgpu_gem_add_input_fence() adds a fence to
update_ctx.sync on the first handle and then fails on a later handle,
error_put_gobj skips amdgpu_vm_update_ctx_fini(&update_ctx) and leaks the
accumulated amdgpu_sync_entry allocations and dma_fence references.

[Severity: Medium]
Are input fences in update_ctx.sync silently dropped when
amdgpu_vm_update_range() does not run?

Previously, amdgpu_gem_add_input_fence() waited on each input fence with
dma_fence_wait().  Now the fences are queued in update_ctx.sync, which is
only consumed by amdgpu_vm_update_range().  When AMDGPU_VM_DELAY_UPDATE is
set, or when an operation such as AMDGPU_VA_OP_CLEAR on an unmapped range
does not emit a PT range update, amdgpu_vm_update_ctx_fini() frees
update_ctx.sync without waiting on the input fences or chaining them into
timeline_syncobj.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
> index 94b1cfe05e3e0..90f27feb84257 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
> @@ -1319,37 +1319,31 @@ void amdgpu_vm_get_memory(struct amdgpu_vm *vm,
>   * Returns:
>   * 0 for success, -EINVAL for failure.
>   */
> -int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
> -			bool clear)
> +int amdgpu_vm_bo_update(struct amdgpu_vm_update_ctx *ctx,
> +			struct amdgpu_bo_va *bo_va, bool clear)
>  {
>  	struct amdgpu_bo *bo = bo_va->base.bo;
> -	struct amdgpu_vm *vm = bo_va->base.vm;
> +	struct amdgpu_vm *vm = ctx->vm;
>  	struct amdgpu_bo_va_mapping *mapping;
>  	struct dma_fence **last_update;
>  	dma_addr_t *pages_addr = NULL;
>  	struct ttm_resource *mem;
> -	struct amdgpu_sync sync;
>  	bool flush_tlb = clear;
>  	uint64_t vram_base;
>  	uint64_t flags;
>  	bool uncached;
>  	int r;
>  
> -	amdgpu_sync_create(&sync);
>  	if (clear) {
>  		mem = NULL;
>  
> -		/* Implicitly sync to command submissions in the same VM before
> -		 * unmapping.
> -		 */
> -		r = amdgpu_sync_resv(adev, &sync, vm->root.bo->tbo.base.resv,
> -				     AMDGPU_SYNC_EQ_OWNER, vm);
> +		r = amdgpu_vm_update_ctx_ensure_unmap_synced(ctx);
>  		if (r)
> -			goto error_free;
> +			goto error;
>  		if (bo) {
> -			r = amdgpu_sync_kfd(&sync, bo->tbo.base.resv);
> +			r = amdgpu_sync_kfd(&ctx->sync, bo->tbo.base.resv);
>  			if (r)
> -				goto error_free;
> +				goto error;
>  		}
>  	} else if (!bo) {
>  		mem = NULL;
> @@ -1374,16 +1368,16 @@ int amdgpu_vm_bo_update(struct amdgpu_device *adev, struct amdgpu_bo_va *bo_va,
>  			pages_addr = bo->tbo.ttm->dma_address;
>  
>  		/* Implicitly sync to moving fences before mapping anything */
> -		r = amdgpu_sync_resv(adev, &sync, bo->tbo.base.resv,
> +		r = amdgpu_sync_resv(ctx->adev, &ctx->sync, bo->tbo.base.resv,
>  				     AMDGPU_SYNC_EXPLICIT, vm);
>  		if (r)
> -			goto error_free;
> +			goto error;
>  	}

[Severity: Medium]
Does sharing ctx->sync across multiple amdgpu_vm_bo_update() calls cause
later BO updates to wait on unrelated fences?

amdgpu_vm_bo_update() adds per-BO moving fences, VM-wide
AMDGPU_SYNC_EQ_OWNER fences, and KFD eviction fences to ctx->sync before
checking whether bo_va->invalids is empty, and never clears per-BO fences
between calls.  When amdgpu_cs_vm_handling() or amdgpu_vm_handle_moved()
reuses one update_ctx across a loop of BOs, every subsequent PT update
waits on all earlier BOs' moving fences (even for BOs whose bo_va->invalids
was empty), and an earlier clear=true BO forces later clear=false updates
in amdgpu_vm_handle_moved() to wait on prior VM submissions and enable
signaling on KFD eviction fences.

[ ... ]

> @@ -1679,18 +1748,22 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
>  			   struct amdgpu_vm *vm,
>  			   struct ww_acquire_ctx *ticket)
>  {
> +	struct amdgpu_vm_update_ctx update_ctx;
>  	struct amdgpu_bo_va *bo_va, *tmp;
>  	struct dma_resv *resv;
>  	struct amdgpu_bo *bo;
>  	bool clear, unlock;
>  	int r;
>  
> +	amdgpu_vm_update_ctx_init(&update_ctx, adev, vm);
> +
>  	list_for_each_entry_safe(bo_va, tmp, &vm->always_valid.needs_update,
>  				 base.vm_status) {
>  		/* Per VM BOs never need to bo cleared in the page tables */
> -		r = amdgpu_vm_bo_update(adev, bo_va, false);
> +		r = amdgpu_vm_bo_update(&update_ctx, bo_va, false);
> +
>  		if (r)
> -			return r;
> +			goto error;
>  	}
>  
>  	spin_lock(&vm->individual_lock);
> @@ -1716,7 +1789,7 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
>  			unlock = false;
>  		}
>  
> -		r = amdgpu_vm_bo_update(adev, bo_va, clear);
> +		r = amdgpu_vm_bo_update(&update_ctx, bo_va, clear);
>  
>  		if (unlock)
>  			dma_resv_unlock(resv);
>  		if (r)
>  			return r;
>  
> @@ -1736,6 +1809,9 @@ int amdgpu_vm_handle_moved(struct amdgpu_device *adev,
>  	}
>  	spin_unlock(&vm->individual_lock);
>  
> +error:
> +	amdgpu_vm_update_ctx_fini(&update_ctx);
> +
>  	return 0;
>  }

[Severity: Medium]
Does amdgpu_vm_handle_moved() swallow errors from the always_valid loop and
leak update_ctx.sync on errors in the individual loop?

When amdgpu_vm_bo_update() fails on an entry in
vm->always_valid.needs_update, jumping to error returns 0 instead of r, so
callers such as amdgpu_cs_vm_handling() proceed with stale page tables.
Conversely, when amdgpu_vm_bo_update() fails in the
vm->individual.needs_update loop, returning r directly skips
amdgpu_vm_update_ctx_fini(&update_ctx) and leaks update_ctx.sync.

> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> index f6285a9d9e989..8445599d9539a 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> @@ -264,6 +264,39 @@ struct amdgpu_task_info {
>  	struct kref	refcount;
>  };
>  
> +/**
> + * struct amdgpu_vm_update_ctx
> + *
> + * Encapsulates various state that is carried around during VM updates.
> + */

[Severity: Low]
This isn't a bug, but scripts/kernel-doc expects a short description on the
struct amdgpu_vm_update_ctx line, and the kernel-doc comments on
amdgpu_vm_bo_update() and amdgpu_gem_va_update_vm() still list @adev and
@vm instead of @ctx.

-- 
Sashiko AI review · https://sashiko.dev/#/patchset/20261117-prt-explicit-sync-v2-0-bb3851cb6a0c@pixelcluster.dev?part=2

  reply	other threads:[~2026-11-17 13:26 UTC|newest]

Thread overview: 19+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17 12:50 [PATCH v2 00/10] drm/amdgpu: Rework VM update ops for batching and explicit sync Natalie Vock
2026-11-17 12:50 ` [PATCH v2 01/10] drm/amdgpu: Remove unused parameter from amdgpu_vm_pte_fragment Natalie Vock
2026-11-17 12:50 ` [PATCH v2 02/10] drm/amdgpu: Add and use vm_update_ctx struct Natalie Vock
2026-11-17 13:26   ` sashiko-bot [this message]
2026-11-17 12:50 ` [PATCH v2 03/10] drm/amdgpu: Make VM maps pending per update context Natalie Vock
2026-11-17 13:43   ` sashiko-bot
2026-11-17 12:50 ` [PATCH v2 04/10] drm/amdgpu: Make removed/cleared mappings " Natalie Vock
2026-11-17 14:05   ` sashiko-bot
2026-11-17 12:50 ` [PATCH v2 05/10] drm/amdgpu: Track dirty bo_va structures in update ctx Natalie Vock
2026-11-17 14:28   ` sashiko-bot
2026-11-17 12:50 ` [PATCH v2 06/10] drm/amdgpu: Add function to roll back a VM " Natalie Vock
2026-11-17 14:40   ` sashiko-bot
2026-11-17 12:50 ` [PATCH v2 07/10] drm/amdgpu: Move some VA op validation to a helper Natalie Vock
2026-11-17 12:50 ` [PATCH v2 08/10] drm/amdgpu: Only reject conflicting mappings if they are not cleared Natalie Vock
2026-11-17 15:06   ` sashiko-bot
2026-11-17 12:50 ` [PATCH v2 09/10] drm/amdgpu: Add new AMDGPU_GEM_VA2 ioctl Natalie Vock
2026-11-17 15:34   ` sashiko-bot
2026-11-17 22:46   ` Dave Airlie
2026-11-17 12:50 ` [PATCH v2 10/10] drm/amdgpu: Bump minor version Natalie Vock

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=sashiko-outbox-218873@kernel.org \
    --to=sashiko-bot@kernel.org \
    --cc=amd-gfx@lists.freedesktop.org \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=nat@pixelcluster.dev \
    --cc=sashiko-reviews@lists.linux.dev \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox