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
next prev parent 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