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 04/10] drm/amdgpu: Make removed/cleared mappings pending per update context
Date: Tue, 17 Nov 2026 14:05:12 +0000 [thread overview]
Message-ID: <sashiko-outbox-218921@kernel.org> (raw)
In-Reply-To: <20261117-prt-explicit-sync-v2-4-bb3851cb6a0c@pixelcluster.dev>
Thank you for your contribution! Sashiko AI review found 6 potential
issues to consider:
- [High] drm/amdgpu: missing amdgpu_vm_update_ctx_commit() in
unmap_bo_from_gpuvm()
- [High] drm/amdgpu: unclamped cleared mapping unmaps surviving gaps in
clear_freed()
- [Medium] drm/amdgpu: uncleaned pending lists in
amdgpu_vm_update_ctx_fini() on error
- [Medium] drm/amdgpu: cur_end moves backward on nested ranges in
execute_replace()
- [Medium] drm/amdgpu: 32-bit PFN truncation in cleared_ranges
interval_tree_node
- [Low] drm/amdgpu: mismatched @replaced kernel-doc tag for cleared
list_head
--
commit 2c940ee3e7377ed3b2aa248bd851e7573259f51f
Author: Natalie Vock <nat@pixelcluster.dev>
drm/amdgpu: Make removed/cleared mappings pending per update context
This commit defers VM mapping removals and range clears into lists and
interval trees on struct amdgpu_vm_update_ctx until the context is
committed, and allows explicit synchronization when unmapping always-valid
BOs or PRT mappings.
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
> index 97cf04da6a025..1e2d45979efdb 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
[ ... ]
> @@ -1652,10 +1716,103 @@ amdgpu_vm_update_ctx_add_new_mapping(struct amdgpu_vm_update_ctx *ctx,
> interval_tree_insert(pending, &ctx->pending_maps);
>
> mapping->bo_va = bo_va;
> + WARN_ON(!list_empty(&mapping->pending_list));
> list_add(&mapping->pending_list, &ctx->new);
> return 0;
> }
>
> +static void
> +amdgpu_vm_update_ctx_add_replaced_mapping(struct amdgpu_vm_update_ctx *ctx,
> + struct amdgpu_bo_va_mapping *mapping)
> +{
> + if (list_empty(&mapping->pending_list))
> + list_add(&mapping->pending_list, &ctx->cleared);
> +}
> +
> +static void
> +amdgpu_vm_update_ctx_add_freed_mapping(struct amdgpu_vm_update_ctx *ctx,
> + struct amdgpu_bo_va_mapping *mapping)
> +{
> + WARN_ON(!list_empty(&mapping->pending_list));
> + list_add(&mapping->pending_list, &ctx->deleted);
> +}
> +
> +int amdgpu_vm_update_ctx_execute_replace(struct amdgpu_vm_update_ctx *ctx)
> +{
> + LIST_HEAD(new_maps);
> + struct interval_tree_node *map;
> + struct amdgpu_bo_va_mapping *cleared, *next, *gap;
> + uint64_t cur_end;
> + int r;
> +
> + list_for_each_entry_safe(cleared, next, &ctx->cleared, pending_list) {
> + cur_end = cleared->start;
> +
> + map = interval_tree_iter_first(&ctx->cleared_ranges, cleared->start, cleared->last);
> + while (map && map->start <= cleared->last) {
> + if (map->start <= cur_end) {
> + cur_end = map->last + 1;
> + map = interval_tree_iter_next(map, cleared->start, cleared->last);
> + continue;
> + }
[Severity: Medium]
Can cur_end move backward here when ctx->cleared_ranges contains nested or
overlapping intervals? interval_tree_iter_first() and
interval_tree_iter_next() walk intervals in ascending order of map->start,
so if an earlier interval extends past a later one (for example, [0x10,
0x20] followed by [0x12, 0x15]), the second iteration sees map->start <=
cur_end and rewinds cur_end from 0x21 back to 0x16, causing the already
cleared subrange [0x16, 0x20] to be treated as an uncleared gap and
re-mapped (or rejected as a duplicate in
amdgpu_vm_update_ctx_add_new_mapping()). Using max(cur_end, map->last + 1)
would prevent cur_end from decreasing.
> +
> + gap = kmalloc_obj(*gap);
> + if (!gap) {
> + r = -ENOMEM;
> + goto error;
> + }
> +
> + gap->bo_va = cleared->bo_va;
> + gap->start = cur_end;
> + gap->last = map->start - 1;
> + gap->offset = cleared->offset;
> + gap->offset += (gap->start - cleared->start) << AMDGPU_GPU_PAGE_SHIFT;
> + gap->flags = cleared->flags;
> + list_add(&gap->pending_list, &new_maps);
> +
> + cur_end = map->last + 1;
> + map = interval_tree_iter_next(map, cleared->start, cleared->last);
> + }
> +
> + if (cur_end <= cleared->last) {
> + gap = kmalloc_obj(*gap);
> + if (!gap) {
> + r = -ENOMEM;
> + goto error;
> + }
> +
> + gap->bo_va = cleared->bo_va;
> + gap->start = cur_end;
> + gap->last = cleared->last;
> + gap->offset = cleared->offset;
> + gap->offset += (gap->start - cleared->start) << AMDGPU_GPU_PAGE_SHIFT;
> + gap->flags = cleared->flags;
> + list_add(&gap->pending_list, &new_maps);
> + }
> +
> + list_del_init(&cleared->pending_list);
> + amdgpu_vm_update_ctx_add_freed_mapping(ctx, cleared);
> + }
[Severity: High]
Does queueing the unclamped cleared mapping onto ctx->deleted cause
amdgpu_vm_clear_freed() to wipe the hardware PTEs for the surviving gap
subranges too?
Previously, amdgpu_vm_bo_clear_mappings() clamped tmp->start and tmp->last
to [saddr, eaddr] before adding tmp to ctx->freed, so
amdgpu_vm_clear_freed() only cleared PTEs in the unmapped range. With this
change, cleared keeps its full [cleared->start, cleared->last] span when
amdgpu_vm_bo_commit_remove() moves it to ctx->freed, while the surviving
gap mappings are added to cleared->bo_va->invalids. In
amdgpu_gem_va_update_vm(), amdgpu_vm_clear_freed() then zeroes the hardware
PTEs across the entire original mapping, and the surviving gaps are never
re-populated in the page tables for AMDGPU_VA_OP_CLEAR (which never calls
amdgpu_vm_bo_update()) or for AMDGPU_VA_OP_REPLACE when the split mapping
belongs to another BO or fpriv->prt_va:
drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c:amdgpu_gem_va_update_vm() {
...
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(ctx, bo_va, false);
if (r)
goto error;
}
...
}
Even when replacing a subrange with the same bo_va, amdgpu_vm_clear_freed()
clears the full original range and flushes the TLB before
amdgpu_vm_bo_update() restores the surviving subranges, which can fault
concurrent GPU work accessing the unmodified parts of the mapping.
[ ... ]
> @@ -1715,17 +1877,23 @@ void amdgpu_vm_update_ctx_init(struct amdgpu_vm_update_ctx *ctx,
> */
> void amdgpu_vm_update_ctx_fini(struct amdgpu_vm_update_ctx *ctx)
> {
> - struct interval_tree_node *pending, *next_pending;
> + struct interval_tree_node *node, *next_node;
>
> list_splice(&ctx->freed, &ctx->vm->delayed_freed);
> amdgpu_sync_free(&ctx->sync);
>
> - rbtree_postorder_for_each_entry_safe(pending, next_pending, &ctx->pending_maps.rb_root, rb)
> - kfree(pending);
> + rbtree_postorder_for_each_entry_safe(node, next_node, &ctx->pending_maps.rb_root, rb) {
> + kfree(node);
> + }
> + rbtree_postorder_for_each_entry_safe(node, next_node, &ctx->cleared_ranges.rb_root, rb) {
> + kfree(node);
> + }
>
> ctx->pending_maps = RB_ROOT_CACHED;
> + ctx->cleared_ranges = RB_ROOT_CACHED;
>
> WARN_ON(!list_empty(&ctx->new));
> + WARN_ON(!list_empty(&ctx->deleted));
> }
[Severity: Medium]
If an error occurs before amdgpu_vm_update_ctx_commit() is called—for
example, when amdgpu_vm_update_ctx_add_new_mapping() fails in
amdgpu_vm_bo_replace_map() after amdgpu_vm_bo_clear_mappings() has already
populated ctx->cleared, or when an allocation or mapping insertion fails
midway through amdgpu_vm_update_ctx_execute_replace()—does
amdgpu_vm_update_ctx_fini() leak ctx->new mappings and leave live mappings
linked into the stack-allocated ctx->deleted and ctx->cleared lists?
In this commit, jumping to error in amdgpu_gem_va_ioctl() hits the WARN_ON()
checks, leaks any struct amdgpu_bo_va_mapping objects already moved to
ctx->new, and leaves existing mappings with mapping->pending_list pointing
into the popped update_ctx stack frame. Note that commit "drm/amdgpu: Add
function to roll back a VM update ctx" later in the series adds
amdgpu_vm_update_ctx_rollback(), but that helper still only unlinks
ctx->new entries without calling kfree(mapping) and does not unlink entries
on ctx->cleared at all.
[ ... ]
> @@ -2178,24 +2345,7 @@ int amdgpu_vm_bo_unmap(struct amdgpu_vm_update_ctx *ctx,
> return -ENOENT;
> }
>
> - /* It's unlikely to happen that the mapping userq hasn't been idled
> - * during user requests GEM unmap IOCTL except for forcing the unmap
> - * from user space.
> - */
> - if (unlikely(bo_va->userq_va_mapped))
> - amdgpu_userq_gem_va_unmap_validate(ctx->adev, mapping);
> -
> - list_del(&mapping->list);
> - amdgpu_vm_it_remove(mapping, &vm->va);
> - mapping->bo_va = NULL;
> - trace_amdgpu_vm_bo_unmap(bo_va, mapping);
> -
> - if (valid)
> - list_add(&mapping->list, &ctx->freed);
> - else
> - amdgpu_vm_free_mapping(ctx->adev, vm, mapping,
> - bo_va->last_pt_update);
> -
> + amdgpu_vm_update_ctx_add_freed_mapping(ctx, mapping);
> return 0;
> }
[Severity: High]
Does unmap_bo_from_gpuvm() also need to call amdgpu_vm_update_ctx_commit()
after amdgpu_vm_bo_unmap()?
drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c:unmap_bo_from_gpuvm() {
struct amdgpu_bo_va *bo_va = entry->bo_va;
struct amdgpu_vm *vm = peer_vm;
struct amdgpu_vm_update_ctx update_ctx;
amdgpu_vm_update_ctx_init(&update_ctx, adev, vm);
(void)amdgpu_vm_bo_unmap(&update_ctx, bo_va, entry->va);
/* VM entity stopped if process killed, don't clear freed pt bo */
if (!amdgpu_vm_ready(vm))
goto out;
(void)amdgpu_vm_clear_freed(&update_ctx, &bo_va->last_pt_update);
(void)amdgpu_sync_fence(sync, bo_va->last_pt_update, GFP_KERNEL);
out:
amdgpu_vm_update_ctx_fini(&update_ctx);
return 0;
}
Because amdgpu_vm_bo_unmap() now only queues the mapping onto
update_ctx.deleted until amdgpu_vm_update_ctx_commit() runs,
unmap_bo_from_gpuvm() passes an empty update_ctx.freed list to
amdgpu_vm_clear_freed() and never removes the mapping from bo_va or vm->va.
Every KFD unmap leaves the GPU page tables mapped, triggers
WARN_ON(!list_empty(&ctx->deleted)) in amdgpu_vm_update_ctx_fini(), and
leaves mapping->pending_list pointing at the stack-allocated update_ctx (or
rolls the unmap back once commit "drm/amdgpu: Add function to roll back a
VM update ctx" is applied).
>
> @@ -2214,8 +2364,8 @@ int amdgpu_vm_bo_unmap(struct amdgpu_vm_update_ctx *ctx,
> int amdgpu_vm_bo_clear_mappings(struct amdgpu_vm_update_ctx *ctx,
> uint64_t saddr, uint64_t size)
> {
> - struct amdgpu_bo_va_mapping *before, *after, *tmp, *next;
> - LIST_HEAD(removed);
> + struct interval_tree_node *cleared_range;
> + struct amdgpu_bo_va_mapping *tmp;
> uint64_t eaddr;
> int r;
>
> @@ -2223,96 +2373,23 @@ int amdgpu_vm_bo_clear_mappings(struct amdgpu_vm_update_ctx *ctx,
> if (r)
> return r;
>
> - saddr /= AMDGPU_GPU_PAGE_SIZE;
> - eaddr = saddr + (size - 1) / AMDGPU_GPU_PAGE_SIZE;
> -
> - /* Allocate all the needed memory */
> - before = kzalloc_obj(*before);
> - if (!before)
> + cleared_range = kmalloc_obj(*cleared_range);
> + if (!cleared_range)
> return -ENOMEM;
> - INIT_LIST_HEAD(&before->list);
>
> - after = kzalloc_obj(*after);
> - if (!after) {
> - kfree(before);
> - return -ENOMEM;
> - }
> - INIT_LIST_HEAD(&after->list);
> + saddr /= AMDGPU_GPU_PAGE_SIZE;
> + eaddr = saddr + (size - 1) / AMDGPU_GPU_PAGE_SIZE;
>
> /* Now gather all removed mappings */
> tmp = amdgpu_vm_it_iter_first(&ctx->vm->va, saddr, eaddr);
> while (tmp) {
> - /* Remember mapping split at the start */
> - if (tmp->start < saddr) {
> - before->start = tmp->start;
> - before->last = saddr - 1;
> - before->offset = tmp->offset;
> - before->flags = tmp->flags;
> - before->bo_va = tmp->bo_va;
> - list_add(&before->list, &tmp->bo_va->invalids);
> - }
> -
> - /* Remember mapping split at the end */
> - if (tmp->last > eaddr) {
> - after->start = eaddr + 1;
> - after->last = tmp->last;
> - after->offset = tmp->offset;
> - after->offset += (after->start - tmp->start) << AMDGPU_GPU_PAGE_SHIFT;
> - after->flags = tmp->flags;
> - after->bo_va = tmp->bo_va;
> - list_add(&after->list, &tmp->bo_va->invalids);
> - }
> -
> - list_del(&tmp->list);
> - list_add(&tmp->list, &removed);
> -
> + amdgpu_vm_update_ctx_add_replaced_mapping(ctx, tmp);
> tmp = amdgpu_vm_it_iter_next(tmp, saddr, eaddr);
> }
>
> - /* And free them up */
> - list_for_each_entry_safe(tmp, next, &removed, list) {
> - amdgpu_vm_it_remove(tmp, &ctx->vm->va);
> - list_del(&tmp->list);
> -
> - if (tmp->start < saddr)
> - tmp->start = saddr;
> - if (tmp->last > eaddr)
> - tmp->last = eaddr;
> -
> - tmp->bo_va = NULL;
> - list_add(&tmp->list, &ctx->freed);
> - trace_amdgpu_vm_bo_unmap(NULL, tmp);
> - }
> -
> - /* Insert partial mapping before the range */
> - if (!list_empty(&before->list)) {
> - struct amdgpu_bo *bo = before->bo_va->base.bo;
> -
> - amdgpu_vm_it_insert(before, &ctx->vm->va);
> - if (before->flags & AMDGPU_VM_PAGE_PRT)
> - amdgpu_vm_prt_get(ctx->adev);
> -
> - if (amdgpu_vm_is_bo_always_valid(ctx->vm, bo) &&
> - !before->bo_va->base.moved)
> - amdgpu_vm_bo_needs_update(&before->bo_va->base);
> - } else {
> - kfree(before);
> - }
> -
> - /* Insert partial mapping after the range */
> - if (!list_empty(&after->list)) {
> - struct amdgpu_bo *bo = after->bo_va->base.bo;
> -
> - amdgpu_vm_it_insert(after, &ctx->vm->va);
> - if (after->flags & AMDGPU_VM_PAGE_PRT)
> - amdgpu_vm_prt_get(ctx->adev);
> -
> - if (amdgpu_vm_is_bo_always_valid(ctx->vm, bo) &&
> - !after->bo_va->base.moved)
> - amdgpu_vm_bo_needs_update(&after->bo_va->base);
> - } else {
> - kfree(after);
> - }
> + cleared_range->start = saddr;
> + cleared_range->last = eaddr;
> + interval_tree_insert(cleared_range, &ctx->cleared_ranges);
[Severity: Medium]
On 32-bit architectures, does storing 64-bit GPU page frame numbers into
struct interval_tree_node truncate saddr and eaddr?
struct interval_tree_node uses unsigned long for start and last, whereas GPU
PFNs are uint64_t (up to 36 bits on 48-bit GPU VA spaces, which is why
amdgpu_vm.c defines its own uint64_t amdgpu_vm_it interval tree). When a
mapping at or above 16 TiB (PFN >= 1ULL << 32) is cleared on a 32-bit build,
cleared_range->start and cleared_range->last are truncated to 32 bits; in
amdgpu_vm_update_ctx_execute_replace(), cur_end = map->last + 1 then drops
below the 64-bit cleared->start, causing (gap->start - cleared->start) <<
AMDGPU_GPU_PAGE_SHIFT to underflow and produce an out-of-bounds gap->offset.
[ ... ]
> diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> index d35494440cb5a..5657aa63e9491 100644
> --- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> +++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.h
> @@ -284,11 +284,27 @@ struct amdgpu_vm_update_ctx {
> */
> struct rb_root_cached pending_maps;
>
> + /**
> + * @cleared_ranges: Interval tree of VA ranges cleared by this update operation.
> + */
> + struct rb_root_cached cleared_ranges;
> +
> /**
> * @new: Pending new mappings not yet applied to bookkeeping structures.
> */
> struct list_head new;
>
> + /**
> + * @deleted: Pending freed mappings not yet applied to bookkeeping structures.
> + */
> + struct list_head deleted;
> +
> + /**
> + * @replaced: Pending mappings that have been cleared, potentially partially,
> + * and are not yet applied to bookkeeping structures.
> + */
> + struct list_head cleared;
[Severity: Low]
This kernel-doc comment uses @replaced instead of @cleared to document
struct list_head cleared, which triggers a kernel-doc warning on W=1 builds.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117-prt-explicit-sync-v2-0-bb3851cb6a0c@pixelcluster.dev?part=4
next prev parent reply other threads:[~2026-11-17 14:05 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 [this message]
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-218921@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 an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.