Re: [PATCH v5 6/9] drm/xe/madvise: Implement per-VMA purgeable state tracking

[Matthew Brost <matthew.brost@intel.com>]

On Wed, Feb 25, 2026 at 09:21:10AM +0100, Thomas Hellström wrote:
> On Wed, 2026-02-25 at 11:05 +0530, Yadav, Arvind wrote:
> > 
> > On 24-02-2026 22:06, Matthew Brost wrote:
> > > On Tue, Feb 24, 2026 at 08:37:44PM +0530, Yadav, Arvind wrote:
> > > > On 24-02-2026 18:18, Thomas Hellström wrote:
> > > > > On Wed, 2026-02-11 at 20:56 +0530, Arvind Yadav wrote:
> > > > > > Track purgeable state per-VMA instead of using a coarse
> > > > > > shared
> > > > > > BO check. This prevents purging shared BOs until all VMAs
> > > > > > across
> > > > > > all VMs are marked DONTNEED.
> > > > > > 
> > > > > > Add xe_bo_all_vmas_dontneed() to check all VMAs before
> > > > > > marking
> > > > > > a BO purgeable. Add xe_bo_recheck_purgeable_on_vma_unbind()
> > > > > > to
> > > > > > handle state transitions when VMAs are destroyed - if all
> > > > > > remaining VMAs are DONTNEED the BO can become purgeable, or
> > > > > > if
> > > > > > no VMAs remain it transitions to WILLNEED.
> > > > > > 
> > > > > > The per-VMA purgeable_state field stores the madvise hint for
> > > > > > each mapping. Shared BOs can only be purged when all VMAs
> > > > > > unanimously indicate DONTNEED.
> > > > > > 
> > > > > > One thing to note: when the last VMA goes away, we default
> > > > > > back to
> > > > > > WILLNEED. DONTNEED is a per-mapping hint, and without any
> > > > > > mappings
> > > > > > there is no remaining madvise state to justify purging. This
> > > > > > prevents
> > > > > > BOs from becoming purgeable solely due to being temporarily
> > > > > > unmapped.
> > > > > > 
> > > > > > v3:
> > > > > >     - This addresses Thomas Hellström's feedback: "loop over
> > > > > > all vmas
> > > > > >       attached to the bo and check that they all say
> > > > > > WONTNEED. This
> > > > > > will
> > > > > >       also need a check at VMA unbinding"
> > > > > > 
> > > > > > v4:
> > > > > >     - @madv_purgeable atomic_t → u32 change across all
> > > > > > relevant
> > > > > >       patches (Matt)
> > > > > > 
> > > > > > v5:
> > > > > >     - Call xe_bo_recheck_purgeable_on_vma_unbind() from
> > > > > > xe_vma_destroy()
> > > > > >       right after drm_gpuva_unlink() where we already hold
> > > > > > the BO lock,
> > > > > >       drop the trylock-based late destroy path (Matt)
> > > > > >     - Move purgeable_state into xe_vma_mem_attr with the
> > > > > > other madvise
> > > > > >       attributes (Matt)
> > > > > >     - Drop READ_ONCE since the BO lock already protects us
> > > > > > (Matt)
> > > > > >     - Keep returning false when there are no VMAs - otherwise
> > > > > > we'd mark
> > > > > >       BOs purgeable without any user hint (Matt)
> > > > > >     - Use xe_bo_set_purgeable_state() instead of direct
> > > > > > initialization(Matt)
> > > > > >     - use xe_assert instead of drm_war (Thomas)
> > > > > Typo.
> > > > 
> > > > Noted,
> > > > 
> > > > > There were also a couple of review issues in my reply here:
> > > > > 
> > > > > https://patchwork.freedesktop.org/patch/699451/?series=156651&rev=5
> > > > > 
> > > > > that were never addressed or at least commented upon.
> > > > > 
> > > > > The comment there on retaining purgeable state after the last
> > > > > vma is
> > > > > unmapped could be discussed, though.
> > > > > 
> > > > > Let's say we unmap a vma marking a bo purgeable. It then
> > > > > becomes either
> > > > > purged or non-purgeable.
> > > > > 
> > > > > Then an app tries to access it either using a new vma or CPU
> > > > > map. Then
> > > > > it will typically succeed, or might occasionally fail if the bo
> > > > > happened to be purged in between.
> > > > > 
> > > > > How do we handle new vma map requests and cpu-faults to a bo in
> > > > > purgeable state? Do we block those?
> > > > 
> > > > @Thomas,
> > > > 
> > > > The implementation already blocks new access to purged BOs:
> > > >   1. New VMA mappings (Patch 0005): vma_lock_and_validate()
> > > > rejects MAP
> > > > operations to purged BOs with -EINVAL via the check_purged flag.
> > > >   2. CPU faults (Patch 0004): Both xe_bo_cpu_prep() and
> > > > xe_gem_mmap_offset()
> > > > return errors (-EFAULT / VM_FAULT_SIGBUS) when accessing purged
> > > > BOs.
> > > >   3 . "Once purged, always purged": Even when the last VMA is
> > > > unmapped,
> > > > xe_bo_recompute_purgeable_state() preserves the PURGED state - it
> > > > never
> > > > transitions back to WILLNEED or DONTNEED (see early return at the
> > > > top of the
> > > > function).
> > > > 
> > > > The only way forward for the application is to destroy the purged
> > > > BO and
> > > > create a new one.
> > > > 
> > > > Regarding the 'no VMAs → WILLNEED' logic: this only applies to
> > > > non-purged
> > > > BOs that happen to be temporarily unmapped. Purged BOs remain
> > > > permanently
> > > > invalid.
> > > So I think xe_bo_all_vmas_dontneed() isn't 100% correct...
> > > 
> > > I think should return an enum...
> > > 
> > > enum xe_bo_vmas_purge_state {	/* Maybe a better name? */
> > > 	XE_BO_VMAS_STATE_DONTNEED = 0,
> > > 	XE_BO_VMAS_STATE_WILLNEED = 1,
> > > 	XE_BO_VMAS_STATE_NO_VMAS = 2,
> > > };
> > > 
> > > 
> > > Then in xe_bo_recompute_purgeable_state() something like this:
> > > 
> > > void xe_bo_recompute_purgeable_state(struct xe_bo *bo)
> > > {
> > > 	enum xe_bo_vma_purge_state state;
> > > 
> > > 	if (!bo)
> > > 		return;
> > > 
> > > 	xe_bo_assert_held(bo);
> > > 
> > > 	/*
> > > 	 * Once purged, always purged. Cannot transition back to
> > > WILLNEED.
> > > 	 * This matches i915 semantics where purged BOs are
> > > permanently invalid.
> > > 	 */
> > > 	if (bo->madv_purgeable == XE_MADV_PURGEABLE_PURGED)
> > > 		return;
> > > 
> > > 	state = xe_bo_all_vmas_dontneed(bo);
> > > 	if (state == XE_BO_VMAS_STATE_DONTNEED) {
> > > 		/* All VMAs are DONTNEED - mark BO purgeable */
> > > 		if (bo->madv_purgeable !=
> > > XE_MADV_PURGEABLE_DONTNEED)
> > > 			xe_bo_set_purgeable_state(bo,
> > > XE_MADV_PURGEABLE_DONTNEED);
> > > 	} else if (state == XE_BO_VMAS_STATE_WILLNEED) {
> > > 		/* At least one VMA is WILLNEED - BO must not be
> > > purgeable */
> > > 		if (bo->madv_purgeable !=
> > > XE_MADV_PURGEABLE_WILLNEED)
> > > 			xe_bo_set_purgeable_state(bo,
> > > XE_MADV_PURGEABLE_WILLNEED);
> > > 	}
> > > }
> > > 
> > > I think would avoid the last unbind unintentionally flipping from
> > > DONTNEED -> WILLNEED.
> > > 
> > > What do you both of you (Thomas, Arvind) think?
> > 
> > 
> > @Matt,
> > 
> > Good catch—I missed that transition. You’re right: when the last VMA
> > is 
> > unmapped from a DONTNEED BO, the current logic can flip it back to 
> > WILLNEED, which discards the user’s hint. That’s wrong.
> > 
> >    I like the enum approach to distinguish:
> >      -  *_DONTNEED: all VMAs are DONTNEED
> >      - *_WILLNEED: at least one VMA is WILLNEED
> >      - *_NO_VMAS: no VMAs present
> > 
> > With that, xe_bo_recompute_purgeable_state() can avoid changing state
> > on 
> > NO_VMAS and preserve "once purged, always purged," matching i915 
> > semantics. This also addresses Thomas's earlier question about new 
> > VMA/CPU access to purgeable BOs—the enum makes it clear we only 
> > transition on explicit VMA state, not on absence of VMAs.
> > 
> > I'll rework xe_bo_all_vmas_dontneed() to return the enum and update
> > the 
> > recompute path accordingly.
> > 
> > 
> > @Thomas,
> > 
> > Does this direction look good to you? If yes, I will send updated
> > patch.
> 
> Yes, but I'm also as mentioned concerned about whether we can add new
> vmas, cpu faults and exports in the WONTNEED state. If we can do that,
> it might succeed most of the time making a well-behave appearance in
> user-space, but if on occation the bo gets purged, the app would
> seeming unexpectedly fail.
> 
> So do we block new vmas cpu-faults and exports in the WONTNEED state?
> 

I’ve thought about the same thing. The new vmas semantics are a bit odd,
because if you unbind the BO in WONTNEED and disallow creating new VMAs,
the BO can never be used again—madvise requires a VMA to operate thus
you can't move a BO out of WONTNEED. Maybe that’s acceptable or even
desirable, but it would need to be documented, and ultimately we’d need
a UMD ack for those semantics.

CPU faults or exports in WONTNEED also seem like they should be
disallowed with less odd sematics, but again, this should be documented
and require UMD ack.

Matt

> /Thomas
> 
> 
> > 
> > Thanks,
> > Arvind
> > 
> > 
> > > 
> > > Matt
> > > 
> > > > Thanks,
> > > > Arvind
> > > > > Thanks,
> > > > > Thomas
> > > > > 
> > > > > 
> > > > > 
> > > > > > Cc: Matthew Brost <matthew.brost@intel.com>
> > > > > > Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
> > > > > > Cc: Himal Prasad Ghimiray <himal.prasad.ghimiray@intel.com>
> > > > > > Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> > > > > > ---
> > > > > >    drivers/gpu/drm/xe/xe_svm.c        |  1 +
> > > > > >    drivers/gpu/drm/xe/xe_vm.c         |  9 ++-
> > > > > >    drivers/gpu/drm/xe/xe_vm_madvise.c | 98
> > > > > > ++++++++++++++++++++++++++++--
> > > > > >    drivers/gpu/drm/xe/xe_vm_madvise.h |  3 +
> > > > > >    drivers/gpu/drm/xe/xe_vm_types.h   | 11 ++++
> > > > > >    5 files changed, 116 insertions(+), 6 deletions(-)
> > > > > > 
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_svm.c
> > > > > > b/drivers/gpu/drm/xe/xe_svm.c
> > > > > > index cda3bf7e2418..329c77aa5c20 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_svm.c
> > > > > > +++ b/drivers/gpu/drm/xe/xe_svm.c
> > > > > > @@ -318,6 +318,7 @@ static void
> > > > > > xe_vma_set_default_attributes(struct
> > > > > > xe_vma *vma)
> > > > > >    		.preferred_loc.migration_policy =
> > > > > > DRM_XE_MIGRATE_ALL_PAGES,
> > > > > >    		.pat_index = vma->attr.default_pat_index,
> > > > > >    		.atomic_access = DRM_XE_ATOMIC_UNDEFINED,
> > > > > > +		.purgeable_state =
> > > > > > XE_MADV_PURGEABLE_WILLNEED,
> > > > > >    	};
> > > > > >    	xe_vma_mem_attr_copy(&vma->attr, &default_attr);
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_vm.c
> > > > > > b/drivers/gpu/drm/xe/xe_vm.c
> > > > > > index 71cf3ce6c62b..e84b9e7cb5eb 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_vm.c
> > > > > > +++ b/drivers/gpu/drm/xe/xe_vm.c
> > > > > > @@ -39,6 +39,7 @@
> > > > > >    #include "xe_tile.h"
> > > > > >    #include "xe_tlb_inval.h"
> > > > > >    #include "xe_trace_bo.h"
> > > > > > +#include "xe_vm_madvise.h"
> > > > > >    #include "xe_wa.h"
> > > > > >    static struct drm_gem_object *xe_vm_obj(struct xe_vm *vm)
> > > > > > @@ -1085,6 +1086,7 @@ static struct xe_vma
> > > > > > *xe_vma_create(struct
> > > > > > xe_vm *vm,
> > > > > >    static void xe_vma_destroy_late(struct xe_vma *vma)
> > > > > >    {
> > > > > >    	struct xe_vm *vm = xe_vma_vm(vma);
> > > > > > +	struct xe_bo *bo = xe_vma_bo(vma);
> > > > > >    	if (vma->ufence) {
> > > > > >    		xe_sync_ufence_put(vma->ufence);
> > > > > > @@ -1099,7 +1101,7 @@ static void xe_vma_destroy_late(struct
> > > > > > xe_vma
> > > > > > *vma)
> > > > > >    	} else if (xe_vma_is_null(vma) ||
> > > > > > xe_vma_is_cpu_addr_mirror(vma)) {
> > > > > >    		xe_vm_put(vm);
> > > > > >    	} else {
> > > > > > -		xe_bo_put(xe_vma_bo(vma));
> > > > > > +		xe_bo_put(bo);
> > > > > >    	}
> > > > > >    	xe_vma_free(vma);
> > > > > > @@ -1125,6 +1127,7 @@ static void vma_destroy_cb(struct
> > > > > > dma_fence
> > > > > > *fence,
> > > > > >    static void xe_vma_destroy(struct xe_vma *vma, struct
> > > > > > dma_fence
> > > > > > *fence)
> > > > > >    {
> > > > > >    	struct xe_vm *vm = xe_vma_vm(vma);
> > > > > > +	struct xe_bo *bo = xe_vma_bo(vma);
> > > > > >    	lockdep_assert_held_write(&vm->lock);
> > > > > >    	xe_assert(vm->xe, list_empty(&vma-
> > > > > > >combined_links.destroy));
> > > > > > @@ -1133,9 +1136,10 @@ static void xe_vma_destroy(struct
> > > > > > xe_vma *vma,
> > > > > > struct dma_fence *fence)
> > > > > >    		xe_assert(vm->xe, vma->gpuva.flags &
> > > > > > XE_VMA_DESTROYED);
> > > > > >    		xe_userptr_destroy(to_userptr_vma(vma));
> > > > > >    	} else if (!xe_vma_is_null(vma) &&
> > > > > > !xe_vma_is_cpu_addr_mirror(vma)) {
> > > > > > -		xe_bo_assert_held(xe_vma_bo(vma));
> > > > > > +		xe_bo_assert_held(bo);
> > > > > >    		drm_gpuva_unlink(&vma->gpuva);
> > > > > > +		xe_bo_recompute_purgeable_state(bo);
> > > > > >    	}
> > > > > >    	xe_vm_assert_held(vm);
> > > > > > @@ -2681,6 +2685,7 @@ static int
> > > > > > vm_bind_ioctl_ops_parse(struct xe_vm
> > > > > > *vm, struct drm_gpuva_ops *ops,
> > > > > >    				.atomic_access =
> > > > > > DRM_XE_ATOMIC_UNDEFINED,
> > > > > >    				.default_pat_index = op-
> > > > > > > map.pat_index,
> > > > > >    				.pat_index = op-
> > > > > > >map.pat_index,
> > > > > > +				.purgeable_state =
> > > > > > XE_MADV_PURGEABLE_WILLNEED,
> > > > > >    			};
> > > > > >    			flags |= op->map.vma_flags &
> > > > > > XE_VMA_CREATE_MASK;
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > > > > b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > > > > index d9cfba7bfe0b..c184426546a2 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > > > > +++ b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > > > > @@ -12,6 +12,7 @@
> > > > > >    #include "xe_pat.h"
> > > > > >    #include "xe_pt.h"
> > > > > >    #include "xe_svm.h"
> > > > > > +#include "xe_vm.h"
> > > > > >    struct xe_vmas_in_madvise_range {
> > > > > >    	u64 addr;
> > > > > > @@ -183,6 +184,89 @@ static void madvise_pat_index(struct
> > > > > > xe_device
> > > > > > *xe, struct xe_vm *vm,
> > > > > >    	}
> > > > > >    }
> > > > > > +/**
> > > > > > + * xe_bo_all_vmas_dontneed() - Check if all VMAs of a BO are
> > > > > > marked
> > > > > > DONTNEED
> > > > > > + * @bo: Buffer object
> > > > > > + *
> > > > > > + * Check all VMAs across all VMs to determine if BO can be
> > > > > > purged.
> > > > > > + * Shared BOs require unanimous DONTNEED state from all
> > > > > > mappings.
> > > > > > + *
> > > > > > + * Caller must hold BO dma-resv lock.
> > > > > > + *
> > > > > > + * Return: true if all VMAs are DONTNEED, false otherwise
> > > > > > + */
> > > > > > +static bool xe_bo_all_vmas_dontneed(struct xe_bo *bo)
> > > > > > +{
> > > > > > +	struct drm_gpuvm_bo *vm_bo;
> > > > > > +	struct drm_gpuva *gpuva;
> > > > > > +	struct drm_gem_object *obj = &bo->ttm.base;
> > > > > > +	bool has_vmas = false;
> > > > > > +
> > > > > > +	xe_bo_assert_held(bo);
> > > > > > +
> > > > > > +	drm_gem_for_each_gpuvm_bo(vm_bo, obj) {
> > > > > > +		drm_gpuvm_bo_for_each_va(gpuva, vm_bo) {
> > > > > > +			struct xe_vma *vma =
> > > > > > gpuva_to_vma(gpuva);
> > > > > > +
> > > > > > +			has_vmas = true;
> > > > > > +
> > > > > > +			/* Any non-DONTNEED VMA prevents
> > > > > > purging */
> > > > > > +			if (vma->attr.purgeable_state !=
> > > > > > XE_MADV_PURGEABLE_DONTNEED)
> > > > > > +				return false;
> > > > > > +		}
> > > > > > +	}
> > > > > > +
> > > > > > +	/*
> > > > > > +	 * No VMAs => no mapping-level DONTNEED hint.
> > > > > > +	 * Default to WILLNEED to avoid making BOs purgeable
> > > > > > without
> > > > > > +	 * explicit user intent.
> > > > > > +	 */
> > > > > > +	if (!has_vmas)
> > > > > > +		return false;
> > > > > > +
> > > > > > +	return true;
> > > > > > +}
> > > > > > +
> > > > > > +/**
> > > > > > + * xe_bo_recompute_purgeable_state() - Recompute BO
> > > > > > purgeable state
> > > > > > from VMAs
> > > > > > + * @bo: Buffer object
> > > > > > + *
> > > > > > + * Walk all VMAs to determine if BO should be purgeable or
> > > > > > not.
> > > > > > + * Shared BOs require unanimous DONTNEED state from all
> > > > > > mappings.
> > > > > > + *
> > > > > > + * Locking: Caller must hold BO dma-resv lock. When
> > > > > > iterating GPUVM
> > > > > > lists,
> > > > > > + * VM lock must also be held (write) to prevent concurrent
> > > > > > VMA
> > > > > > modifications.
> > > > > > + * This is satisfied at both call sites:
> > > > > > + * - xe_vma_destroy(): holds vm->lock write
> > > > > > + * - madvise_purgeable(): holds vm->lock write (from madvise
> > > > > > ioctl
> > > > > > path)
> > > > > > + *
> > > > > > + * Return: nothing
> > > > > > + */
> > > > > > +void xe_bo_recompute_purgeable_state(struct xe_bo *bo)
> > > > > > +{
> > > > > > +	if (!bo)
> > > > > > +		return;
> > > > > > +
> > > > > > +	xe_bo_assert_held(bo);
> > > > > > +
> > > > > > +	/*
> > > > > > +	 * Once purged, always purged. Cannot transition
> > > > > > back to
> > > > > > WILLNEED.
> > > > > > +	 * This matches i915 semantics where purged BOs are
> > > > > > permanently invalid.
> > > > > > +	 */
> > > > > > +	if (bo->madv_purgeable == XE_MADV_PURGEABLE_PURGED)
> > > > > > +		return;
> > > > > > +
> > > > > > +	if (xe_bo_all_vmas_dontneed(bo)) {
> > > > > > +		/* All VMAs are DONTNEED - mark BO purgeable
> > > > > > */
> > > > > > +		if (bo->madv_purgeable !=
> > > > > > XE_MADV_PURGEABLE_DONTNEED)
> > > > > > +			xe_bo_set_purgeable_state(bo,
> > > > > > XE_MADV_PURGEABLE_DONTNEED);
> > > > > > +	} else {
> > > > > > +		/* At least one VMA is WILLNEED - BO must
> > > > > > not be
> > > > > > purgeable */
> > > > > > +		if (bo->madv_purgeable !=
> > > > > > XE_MADV_PURGEABLE_WILLNEED)
> > > > > > +			xe_bo_set_purgeable_state(bo,
> > > > > > XE_MADV_PURGEABLE_WILLNEED);
> > > > > > +	}
> > > > > > +}
> > > > > > +
> > > > > >    /**
> > > > > >     * madvise_purgeable - Handle purgeable buffer object
> > > > > > advice
> > > > > >     * @xe: XE device
> > > > > > @@ -231,14 +315,20 @@ static void __maybe_unused
> > > > > > madvise_purgeable(struct xe_device *xe,
> > > > > >    		switch (op->purge_state_val.val) {
> > > > > >    		case DRM_XE_VMA_PURGEABLE_STATE_WILLNEED:
> > > > > > -			xe_bo_set_purgeable_state(bo,
> > > > > > XE_MADV_PURGEABLE_WILLNEED);
> > > > > > +			vmas[i]->attr.purgeable_state =
> > > > > > XE_MADV_PURGEABLE_WILLNEED;
> > > > > > +
> > > > > > +			/* Update BO purgeable state */
> > > > > > +			xe_bo_recompute_purgeable_state(bo);
> > > > > >    			break;
> > > > > >    		case DRM_XE_VMA_PURGEABLE_STATE_DONTNEED:
> > > > > > -			xe_bo_set_purgeable_state(bo,
> > > > > > XE_MADV_PURGEABLE_DONTNEED);
> > > > > > +			vmas[i]->attr.purgeable_state =
> > > > > > XE_MADV_PURGEABLE_DONTNEED;
> > > > > > +
> > > > > > +			/* Update BO purgeable state */
> > > > > > +			xe_bo_recompute_purgeable_state(bo);
> > > > > >    			break;
> > > > > >    		default:
> > > > > > -			drm_warn(&vm->xe->drm, "Invalid
> > > > > > madvice
> > > > > > value = %d\n",
> > > > > > -				 op->purge_state_val.val);
> > > > > > +			/* Should never hit - values
> > > > > > validated in
> > > > > > madvise_args_are_sane() */
> > > > > > +			xe_assert(vm->xe, 0);
> > > > > >    			return;
> > > > > >    		}
> > > > > >    	}
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_vm_madvise.h
> > > > > > b/drivers/gpu/drm/xe/xe_vm_madvise.h
> > > > > > index b0e1fc445f23..39acd2689ca0 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_vm_madvise.h
> > > > > > +++ b/drivers/gpu/drm/xe/xe_vm_madvise.h
> > > > > > @@ -8,8 +8,11 @@
> > > > > >    struct drm_device;
> > > > > >    struct drm_file;
> > > > > > +struct xe_bo;
> > > > > >    int xe_vm_madvise_ioctl(struct drm_device *dev, void
> > > > > > *data,
> > > > > >    			struct drm_file *file);
> > > > > > +void xe_bo_recompute_purgeable_state(struct xe_bo *bo);
> > > > > > +
> > > > > >    #endif
> > > > > > diff --git a/drivers/gpu/drm/xe/xe_vm_types.h
> > > > > > b/drivers/gpu/drm/xe/xe_vm_types.h
> > > > > > index 43203e90ee3e..fd563039e8f4 100644
> > > > > > --- a/drivers/gpu/drm/xe/xe_vm_types.h
> > > > > > +++ b/drivers/gpu/drm/xe/xe_vm_types.h
> > > > > > @@ -94,6 +94,17 @@ struct xe_vma_mem_attr {
> > > > > >    	 * same as default_pat_index unless overwritten by
> > > > > > madvise.
> > > > > >    	 */
> > > > > >    	u16 pat_index;
> > > > > > +
> > > > > > +	/**
> > > > > > +	 * @purgeable_state: Purgeable hint for this VMA
> > > > > > mapping
> > > > > > +	 *
> > > > > > +	 * Per-VMA purgeable state from madvise. Valid
> > > > > > states are
> > > > > > WILLNEED (0)
> > > > > > +	 * or DONTNEED (1). Shared BOs require all VMAs to
> > > > > > be
> > > > > > DONTNEED before
> > > > > > +	 * the BO can be purged. PURGED state exists only at
> > > > > > BO
> > > > > > level.
> > > > > > +	 *
> > > > > > +	 * Protected by BO dma-resv lock. Set via
> > > > > > DRM_IOCTL_XE_MADVISE.
> > > > > > +	 */
> > > > > > +	u32 purgeable_state;
> > > > > >    };
> > > > > >    struct xe_vma {