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 09/10] drm/amdgpu: Add new AMDGPU_GEM_VA2 ioctl
Date: Tue, 17 Nov 2026 15:34:07 +0000 [thread overview]
Message-ID: <sashiko-outbox-219088@kernel.org> (raw)
In-Reply-To: <20261117-prt-explicit-sync-v2-9-bb3851cb6a0c@pixelcluster.dev>
Thank you for your contribution! Sashiko AI review found 15 potential
issues to consider:
- [High] drm/amdgpu: wrong argument to amdgpu_vm_bo_unmap() in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: syncobj_handles leak in
amdgpu_gem_prepare_timeline_nodes()
- [High] drm/amdgpu: uninitialized fence pointer in
amdgpu_gem_va2_ioctl() error path
- [High] drm/amdgpu: lost bo_va->last_pt_update and TLB fences in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: wrong struct in DRM_IOCTL_AMDGPU_GEM_VA2 macro
definition
- [High] drm/amdgpu: missing runtime PM acquisition in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: unlocked BO update on CLEAR/REPLACE in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: unlocked amdgpu_vm_bo_find() call in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: gobj ref leak on lock contention/error in
amdgpu_gem_va2_ioctl()
- [High] drm/amdgpu: memory leak and list corruption in
amdgpu_vm_update_ctx_rollback()
- [High] drm/amdgpu: fence ref leak when merging fences in
amdgpu_gem_va2_ioctl()
- [Medium] drm/amdgpu: delay never set to true in amdgpu_gem_va2_ioctl()
- [Medium] drm/amdgpu: wrong pointer in PTR_ERR() in
amdgpu_gem_add_input_fence()
- [Medium] drm/amdgpu: gobj ref leak on drm_exec_lock_obj() contention
or error
- [Medium] drm/amdgpu: in-place VA masking in amdgpu_gem_va2_ioctl()
breaks retry
--
commit dddcd1a96bab3eebca95b4fd6d51bf06141d06e1
Author: Natalie Vock <nat@pixelcluster.dev>
drm/amdgpu: Add new AMDGPU_GEM_VA2 ioctl
This commit adds the DRM_IOCTL_AMDGPU_GEM_VA2 ioctl to batch multiple VM
mapping operations in a single call with multiple input and output binary or
timeline syncobjs.
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> index 7eed5c360be20..6d6a6017d4787 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
> @@ -53,10 +53,13 @@ static int
> amdgpu_gem_add_input_fence(struct drm_file *filp,
> struct amdgpu_vm_update_ctx *update_ctx,
> uint64_t syncobj_handles_array,
> + uint64_t syncobj_points_array,
> uint32_t num_syncobj_handles)
> {
> struct dma_fence *fence;
> uint32_t *syncobj_handles;
> + uint64_t *syncobj_points;
> + uint64_t point;
> int ret, i;
>
> if (!num_syncobj_handles)
> @@ -67,6 +70,17 @@ amdgpu_gem_add_input_fence(struct drm_file *filp,
> if (IS_ERR(syncobj_handles))
> return PTR_ERR(syncobj_handles);
>
> + if (syncobj_points_array) {
> + syncobj_points = memdup_user(u64_to_user_ptr(syncobj_points_array),
> + size_mul(sizeof(uint64_t), num_syncobj_handles));
> + if (IS_ERR(syncobj_points)) {
> + kfree(syncobj_handles);
> + return PTR_ERR(syncobj_handles);
> + }
[Severity: Medium]
Should this return PTR_ERR(syncobj_points) instead of
PTR_ERR(syncobj_handles)? syncobj_handles is a valid kernel heap pointer
here, so returning PTR_ERR(syncobj_handles) leaks its lower 32 bits as the
ioctl return value (or returns 0 if 4 GiB-aligned).
[ ... ]
> +static int amdgpu_gem_prepare_timeline_nodes(
> + struct drm_file *filp, uint64_t syncobj_handles_array,
> + uint64_t syncobj_points_array, uint32_t num_syncobjs,
> + struct amdgpu_gem_timeline_out *out)
> +{
> + uint32_t *syncobj_handles;
> + uint32_t i;
> + int r;
> +
> + syncobj_handles = memdup_user(u64_to_user_ptr(syncobj_handles_array),
> + size_mul(sizeof(uint32_t), num_syncobjs));
> + if (IS_ERR(syncobj_handles))
> + return PTR_ERR(syncobj_handles);
[ ... ]
> + for (i = 0; i < num_syncobjs; i++) {
> + out->syncobjs[i] = drm_syncobj_find(filp, syncobj_handles[i]);
> + if (!out->syncobjs[i]) {
> + r = -ENOENT;
> + goto err_loop_rollback;
> + }
> +
> + if (!out->timeline_points[i])
> + continue;
> +
> + out->chains[i] = dma_fence_chain_alloc();
> + if (!out->chains[i]) {
> + r = -ENOMEM;
> + goto err_loop_rollback;
> + }
> +
> + continue;
> +err_loop_rollback:
> + for (;;) {
> + if (out->syncobjs[i])
> + drm_syncobj_put(out->syncobjs[i]);
> + if (out->chains[i])
> + dma_fence_chain_free(out->chains[i]);
> + if (i-- == 0)
> + goto err_free_sync;
> + }
> + }
> +
> + return 0;
[Severity: High]
Does the success path here leak syncobj_handles? kfree(syncobj_handles) is
only called on the error path at err_free_handles, so every call with
num_syncobjs > 0 leaks the memdup_user() buffer.
[ ... ]
> @@ -1100,6 +1218,232 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
> return r;
> }
>
> +int amdgpu_gem_va2_ioctl(struct drm_device *dev, void *data,
> + struct drm_file *filp)
> +{
> + struct drm_amdgpu_gem_va2 *args = data;
> + struct amdgpu_device *adev = drm_to_adev(dev);
> + struct amdgpu_fpriv *fpriv = filp->driver_priv;
> + struct drm_amdgpu_gem_va_mapping *mappings;
> + struct amdgpu_gem_timeline_out tl_out;
> + struct amdgpu_vm_update_ctx update_ctx;
> + struct drm_gem_object *gobj;
> + struct amdgpu_bo_va *bo_va;
> + struct drm_exec exec;
> + bool delay = false;
> + u32 i;
> + int r;
> +
> + mappings = vmemdup_array_user(u64_to_user_ptr(args->mappings),
> + args->num_mappings,
> + sizeof(struct drm_amdgpu_gem_va_mapping));
> + if (IS_ERR(mappings))
> + return PTR_ERR(mappings);
> +
> + r = amdgpu_gem_prepare_timeline_nodes(filp, args->syncobjs_out,
> + args->timeline_points_out,
> + args->num_syncobjs_out, &tl_out);
> + if (r)
> + goto out_free_mappings;
> +
> + drm_exec_init(&exec,
> + DRM_EXEC_INTERRUPTIBLE_WAIT | DRM_EXEC_IGNORE_DUPLICATES,
> + 0);
> + amdgpu_vm_update_ctx_init(&update_ctx, adev, &fpriv->vm);
[Severity: High]
Does amdgpu_gem_va2_ioctl() need to acquire a runtime PM reference via
PM_RUNTIME_ACQUIRE_IF_ENABLED_AUTOSUSPEND(), like amdgpu_gem_va_ioctl() does?
Without it, non-delayed VM updates can write to VRAM, flush HDP via MMIO, or
submit SDMA jobs while the GPU is runtime-suspended.
> + update_ctx.explicit_sync_unmap = true;
> +
> + r = amdgpu_gem_add_input_fence(filp, &update_ctx, args->syncobjs_in,
> + args->timeline_points_in,
> + args->num_syncobjs_in);
> + if (r)
> + goto out;
> +
> + drm_exec_until_all_locked(&exec)
> + {
> + r = amdgpu_vm_lock_pd(&fpriv->vm, &exec, 2);
> + drm_exec_retry_on_contention(&exec);
> + if (unlikely(r))
> + goto out;
> +
> + for (i = 0; i < args->num_mappings; ++i) {
> + r = amdgpu_gem_va_validate_args(adev, mappings[i].va,
> + mappings[i].map_size,
> + mappings[i].flags);
> + if (r)
> + goto out;
> +
> + mappings[i].va &= AMDGPU_GMC_HOLE_MASK;
[Severity: Medium]
Can masking mappings[i].va in place break retries on lock contention? For
an address in the upper canonical range (>= AMDGPU_GMC_HOLE_END), masking it
with AMDGPU_GMC_HOLE_MASK places it inside [AMDGPU_GMC_HOLE_START,
AMDGPU_GMC_HOLE_END), so if drm_exec_until_all_locked() retries the loop,
amdgpu_gem_va_validate_args() will reject mappings[i].va with -EINVAL.
> +
> + if (mappings[i].flags & AMDGPU_VM_DELAY_UPDATE) {
> + /* Can't delay if we're supposed to signal fences */
> + if (args->num_syncobjs_out) {
> + r = -EINVAL;
> + goto out;
> + }
> + /* If one mapping is delayed, all mappings must be delayed */
> + if (i && !delay) {
> + r = -EINVAL;
> + goto out;
> + }
> + } else if (delay) {
> + /* If one mapping is not delayed, no mappings may be delayed */
> + r = -EINVAL;
> + goto out;
> + }
[Severity: Medium]
Is delay ever set to true when AMDGPU_VM_DELAY_UPDATE is set? Because delay
stays false, any batch with two or more delayed mappings fails with -EINVAL
at if (i && !delay), a batch where only mappings[0] is delayed is not
rejected, and page table updates are still executed immediately.
> +
> + if ((mappings[i].operation != AMDGPU_VA_OP_CLEAR) &&
> + !(mappings[i].flags & AMDGPU_VM_PAGE_PRT)) {
> + gobj = drm_gem_object_lookup(
> + filp, mappings[i].handle);
> + if (gobj == NULL) {
> + r = -ENOENT;
> + goto out;
> + }
> + bo_va = amdgpu_vm_bo_find(
> + &fpriv->vm, gem_to_amdgpu_bo(gobj));
> + if (!bo_va) {
> + drm_gem_object_put(gobj);
> + r = -ENOENT;
> + goto out;
> + }
[Severity: High]
Is it safe to call amdgpu_vm_bo_find() before locking gobj with
drm_exec_lock_obj()? amdgpu_vm_bo_find() walks bo->vm_bo, which is
protected by bo->tbo.base.resv; on a shared BO, another DRM file can
concurrently modify bo->vm_bo and free its amdgpu_bo_va in
amdgpu_vm_bo_del().
> + } else {
> + gobj = NULL;
> + bo_va = mappings[i].operation !=
> + AMDGPU_VA_OP_CLEAR ?
> + fpriv->prt_va :
> + NULL;
> + }
> +
> + if (gobj) {
> + r = drm_exec_lock_obj(&exec, gobj);
> + if (drm_exec_is_contended(&exec))
> + amdgpu_vm_update_ctx_rollback(
> + &update_ctx);
[Severity: High]
When amdgpu_vm_update_ctx_rollback() runs here on lock contention (or via
amdgpu_vm_update_ctx_fini() on error), does it leak ctx->new mappings and
corrupt ctx->cleared?
drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c:amdgpu_vm_update_ctx_rollback() {
...
list_for_each_entry_safe(mapping, next, &ctx->new, pending_list)
list_del_init(&mapping->pending_list);
list_for_each_entry_safe(mapping, next, &ctx->deleted, pending_list)
list_del_init(&mapping->pending_list);
...
}
Entries on ctx->new were allocated by amdgpu_vm_bo_map() or
amdgpu_vm_bo_replace_map() and are unlinked without kfree(mapping).
In addition, ctx->cleared is never unlinked at all, leaving live mappings in
fpriv->vm.va with mapping->pending_list pointing into update_ctx.cleared on
the stack.
> + drm_exec_retry_on_contention(&exec);
[Severity: Medium]
Does drm_exec_retry_on_contention(&exec) leak the gobj reference from
drm_gem_object_lookup()? drm_exec_lock_obj() takes its own reference for
exec->contended on -EDEADLK, and jumping back to the start of the loop
skips drm_gem_object_put(gobj) below.
> + if (unlikely(r))
> + goto out;
> + }
[Severity: High]
Does jumping to out when drm_exec_lock_obj() returns a non-contention error
(such as -EINTR or -ENOMEM) also leak the gobj lookup reference?
drm_exec_lock_obj() does not record gobj in exec->objects on failure, and
goto out bypasses drm_gem_object_put(gobj).
> +
> + switch (mappings[i].operation) {
> + case AMDGPU_VA_OP_MAP:
> + r = amdgpu_vm_bo_map(&update_ctx, bo_va,
> + mappings[i].va,
> + mappings[i].offset_in_bo,
> + mappings[i].map_size,
> + mappings[i].flags);
> + break;
> + case AMDGPU_VA_OP_UNMAP:
> + r = amdgpu_vm_bo_unmap(&update_ctx, bo_va,
> + mappings[i].flags);
> + break;
[Severity: High]
Should amdgpu_vm_bo_unmap() be passed mappings[i].va instead of
mappings[i].flags? Passing flags as the virtual address makes
AMDGPU_VA_OP_UNMAP look up page 0 and fail with -ENOENT.
[ ... ]
> + if (!delay && (!adev->debug_vm || args->num_syncobjs_out)) {
> + struct dma_fence *fence, *merged;
> +
> + if (!amdgpu_vm_ready(&fpriv->vm)) {
> + fence = dma_fence_get_stub();
> + goto insert_fence;
> + }
> +
> + r = amdgpu_vm_clear_freed(&update_ctx, &fpriv->vm.last_update);
> + if (r) {
> + drm_err(adev_to_drm(adev),
> + "Could not clear freed PT entries: %d\n", r);
> + goto insert_fence;
> + }
[Severity: High]
If amdgpu_vm_clear_freed() fails, does goto insert_fence use an
uninitialized fence pointer? fence is only initialized afterwards, so
insert_fence will pass stack garbage to drm_syncobj_replace_fence(),
drm_syncobj_add_point(), and dma_fence_put().
> +
> + fence = dma_fence_get(fpriv->vm.last_update);
> +
> + list_for_each_entry(bo_va, &update_ctx.dirty_bo_vas,
> + update_link) {
> + r = amdgpu_vm_bo_update(&update_ctx, bo_va, false);
> + if (r) {
> + drm_err(adev_to_drm(adev),
> + "Could not update BO PT entries: %d\n", r);
> + goto insert_fence;
> + }
> + }
[Severity: High]
Can this loop call amdgpu_vm_bo_update() on BOs whose dma_resv is not
locked?
AMDGPU_VA_OP_CLEAR locks no BO, and AMDGPU_VA_OP_REPLACE only locks the new
BO from mappings[i].handle. However, amdgpu_vm_update_ctx_execute_replace()
adds the bo_va of every existing mapping that was cleared or split to
update_ctx.dirty_bo_vas, so amdgpu_vm_bo_update() then accesses
bo->tbo.resource and calls amdgpu_sync_resv() on those affected BOs without
holding their reservation locks.
> +
> + list_for_each_entry(bo_va, &update_ctx.dirty_bo_vas,
> + update_link) {
> + if (!amdgpu_vm_is_bo_always_valid(&fpriv->vm,
> + bo_va->base.bo)) {
> + dma_fence_put(bo_va->last_pt_update);
> + bo_va->last_pt_update = dma_fence_get(fence);
> + }
> + }
[Severity: High]
Does this discard the page table update fences just generated by
amdgpu_vm_bo_update()?
For non-always-valid BOs (and PRT mappings where bo is NULL),
amdgpu_vm_bo_update() stores the new PT update fence in
bo_va->last_pt_update rather than fpriv->vm.last_update. Overwriting
bo_va->last_pt_update with the pre-update fence without merging
bo_va->last_pt_update (or fpriv->vm.last_tlb_inv) into fence drops those PT
update and TLB invalidation fences from both bo_va->last_pt_update and the
signaled output syncobjs.
> +
> + /* Always update PDEs after we touched the mappings. */
> + r = amdgpu_vm_update_pdes(adev, &fpriv->vm, false);
> + if (r)
> + goto insert_fence;
> +
> + merged = dma_fence_unwrap_merge(fence, fpriv->vm.last_update);
> + if (!merged) {
> + /* As fallback in OOM situations */
> + dma_fence_wait(fpriv->vm.last_update, false);
> + dma_fence_wait(fence, false);
> + merged = dma_fence_get_stub();
> + }
> + fence = merged;
[Severity: High]
Does assigning fence = merged without calling dma_fence_put(fence) leak the
fence reference acquired before the amdgpu_vm_bo_update() loop?
> diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.h
> index 29009f6aabde9..c9e52bfa7d028 100644
> --- a/include/uapi/drm/amdgpu_drm.h
> +++ b/include/uapi/drm/amdgpu_drm.h
> @@ -83,6 +84,7 @@ extern "C" {
> #define DRM_IOCTL_AMDGPU_GEM_LIST_HANDLES DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_LIST_HANDLES, struct drm_amdgpu_gem_list_handles)
> #define DRM_IOCTL_AMDGPU_PROC_OPTIONS DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_PROC_OPTIONS, struct drm_amdgpu_proc_options)
> #define DRM_IOCTL_AMDGPU_UALINK_HANDLE DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_UALINK_HANDLE, union drm_amdgpu_ualink_handle)
> +#define DRM_IOCTL_AMDGPU_GEM_VA2 DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_VA2, struct drm_amdgpu_gem_va)
[Severity: High]
Should DRM_IOCTL_AMDGPU_GEM_VA2 use struct drm_amdgpu_gem_va2 instead of
struct drm_amdgpu_gem_va? struct drm_amdgpu_gem_va is 64 bytes whereas
struct drm_amdgpu_gem_va2 is 56 bytes, so drm_ioctl() will copy 8 bytes past
the end of the user struct.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117-prt-explicit-sync-v2-0-bb3851cb6a0c@pixelcluster.dev?part=9
next prev parent reply other threads:[~2026-11-17 15:34 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
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 [this message]
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-219088@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