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 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

  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 a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox