On Thu, Oct 29, 2026 at 09:20:33AM +0530, Yadav, Arvind wrote:
> 
> On 28-10-2026 02:14, Matthew Brost wrote:
> > On Mon, Oct 26, 2026 at 05:50:45PM +0530, Arvind Yadav wrote:
> > > Fault service holds vm->lock for read while using a VMA. SVM garbage
> > > collection also runs under the read lock and can reset AUTORESET
> > > attributes. The reset can split or merge VMAs and immediately free a
> > > VMA that another fault worker is still using. The GC mutex serializes
> > I'll have to think about this one for a bit but quick thought:
> > 
> > Can we use some ref counting (e.g., add a VMA ref count) rather than
> > changing the locking?
> 
> 
> A VMA ref count would keep it alive while the fault worker uses it. But the
> reset also changes "vma->attr" which the fault worker reads. The ref count
> would not protect those updates.
> 

Can't this race only happen if say a fault starts (A), an unmap occurs
on A's fault, and different fault starts (B) and see A's unmap and blows
away A's VMA? This is memory unsafe as A can currently UAF but ref
counting could make this memory safe.

Now to the attribute race - wouldn't A fail somewhere on a notifier
retry if its attributes actually change? I guess we don't always lookup
on a retry but we could.

Matt

> I will check if we can avoid changing the attributes in place and retry the
> fault when the VMA is replaced, keeping the current locking. If You have any
> other suggestion please let me know.
> 
> Thanks,
> Arvind
> 
> > Matt
> > 
> > > collectors but does not protect VMA readers.
> > > 
> > > Keep backing collection under read access when no attribute change is
> > > needed. Defer ranges requiring a reset and return -EAGAIN so the caller
> > > can release its read-side state and collect with write access.
> > > 
> > > In fault service, discard the old VMA pointer before releasing the read
> > > lock. After acquiring write access, recheck VM state and collect the
> > > queued ranges. Downgrade to read and repeat VMA lookup, permission checks
> > > and advice-dependent setup.
> > > 
> > > Drain GC under the existing write lock before madvise, bind and attribute
> > > query. Require write access for VMA changes while retaining parallel
> > > fault service when no reset is needed.
> > > 
> > > [ 2163.042338] 
> > > ==================================================================
> > > [ 2163.042353] BUG: KASAN: slab-use-after-free in 
> > > __xe_svm_handle_pagefault+0x297/0x1460 [xe]
> > > [ 2163.042815] Read of size 8 at addr ffff88813f879b70 by task 
> > > kworker/u65:3/3115
> > > 
> > > [ 2163.042834] CPU: 0 UID: 0 PID: 3115 Comm: kworker/u65:3 Kdump: loaded 
> > > Tainted: G S      W  O        7.3.0-lgci-xe-svm-22oct #16 PREEMPT(full)
> > > [ 2163.042841] Tainted: [S]=CPU_OUT_OF_SPEC, [W]=WARN, [O]=OOT_MODULE
> > > [ 2163.042842] Hardware name: ASUS System Product Name/PRIME Z790-P WIFI, 
> > > BIOS 1002 03/31/2023
> > > [ 2163.042845] Workqueue: xe_page_fault_work_queue 
> > > xe_pagefault_queue_work [xe]
> > > [ 2163.043326] Call Trace:
> > > [ 2163.043327]  <TASK>
> > > [ 2163.043330]  dump_stack_lvl+0x91/0xf0
> > > [ 2163.043336]  print_report+0xd1/0x610
> > > [ 2163.043340]  ? __xe_svm_handle_pagefault+0x297/0x1460 [xe]
> > > [ 2163.043825]  ? __virt_addr_valid+0x1b2/0x350
> > > [ 2163.043831]  ? kasan_complete_mode_report_info+0x6a/0x210
> > > [ 2163.043836]  ? __xe_svm_handle_pagefault+0x297/0x1460 [xe]
> > > [ 2163.044340]  kasan_report+0xa3/0xe0
> > > [ 2163.044344]  ? __xe_svm_handle_pagefault+0x297/0x1460 [xe]
> > > [ 2163.044881]  __asan_load8+0x8b/0xe0
> > > [ 2163.044885]  __xe_svm_handle_pagefault+0x297/0x1460 [xe]
> > > [ 2163.045456]  ? lock_acquire+0x1b0/0x320
> > > [ 2163.045461]  ? xe_vm_find_overlapping_vma+0x88/0x310 [xe]
> > > [ 2163.046072]  ? __pfx___xe_svm_handle_pagefault+0x10/0x10 [xe]
> > > [ 2163.046679]  ? rcu_is_watching+0x21/0x60
> > > [ 2163.046684]  ? __mutex_lock+0x1172/0x18b0
> > > [ 2163.046690]  ? find_held_lock+0x31/0x90
> > > [ 2163.046696]  ? xe_vm_find_overlapping_vma+0xa1/0x310 [xe]
> > > [ 2163.047273]  ? __kasan_check_write+0x14/0x30
> > > [ 2163.047278]  ? __mutex_unlock_slowpath+0x10f/0x660
> > > [ 2163.047285]  ? __pfx___mutex_unlock_slowpath+0x10/0x10
> > > [ 2163.047295]  ? mutex_unlock+0x12/0x20
> > > [ 2163.047299]  ? xe_vm_find_overlapping_vma+0xa1/0x310 [xe]
> > > [ 2163.047844]  xe_svm_handle_pagefault+0x5c/0x140 [xe]
> > > [ 2163.048355]  xe_pagefault_queue_work+0x19ad/0x2450 [xe]
> > > [ 2163.048843]  process_one_work+0x5ae/0xdd0
> > > [ 2163.048847]  ? __lock_acquire+0x58a/0x2820
> > > [ 2163.048850]  ? __schedule+0x22a6/0x3670
> > > [ 2163.048858]  ? __pfx_process_one_work+0x10/0x10
> > > [ 2163.048866]  ? __pfx_xe_pagefault_queue_work+0x10/0x10 [xe]
> > > [ 2163.049345]  ? assign_work+0xe4/0x1d0
> > > [ 2163.049350]  worker_thread+0x3b4/0x6a0
> > > [ 2163.049357]  ? __pfx_worker_thread+0x10/0x10
> > > [ 2163.049361]  kthread+0x204/0x250
> > > [ 2163.049364]  ? kthread+0xf1/0x250
> > > [ 2163.049369]  ? __pfx_kthread+0x10/0x10
> > > [ 2163.049372]  ret_from_fork+0x465/0x6a0
> > > [ 2163.049377]  ? __pfx_ret_from_fork+0x10/0x10
> > > [ 2163.049381]  ? __switch_to+0x26f/0x740
> > > [ 2163.049386]  ? __pfx_kthread+0x10/0x10
> > > [ 2163.049390]  ret_from_fork_asm+0x1a/0x30
> > > [ 2163.049399]  </TASK>
> > > 
> > > [ 2163.049654] Allocated by task 522570:
> > > [ 2163.049662]  kasan_save_stack+0x26/0x60
> > > [ 2163.049668]  kasan_save_track+0x14/0x40
> > > [ 2163.049672]  kasan_save_alloc_info+0x37/0x60
> > > [ 2163.049677]  __kasan_kmalloc+0xc3/0xd0
> > > [ 2163.049681]  __kmalloc_cache_noprof+0x2b4/0x6c0
> > > [ 2163.049686]  xe_vma_create+0xe3/0xe60 [xe]
> > > [ 2163.050170]  new_vma+0x416/0x540 [xe]
> > > [ 2163.050654]  vm_bind_ioctl_ops_parse+0xc3e/0x1110 [xe]
> > > [ 2163.051139]  xe_vm_alloc_vma+0x243/0xd60 [xe]
> > > [ 2163.051623]  xe_vm_alloc_madvise_vma+0x92/0xd0 [xe]
> > > [ 2163.052107]  xe_vm_madvise_ioctl+0x783/0x14f0 [xe]
> > > [ 2163.052591]  drm_ioctl_kernel+0x143/0x200
> > > [ 2163.052597]  drm_ioctl+0x419/0x790
> > > [ 2163.052600]  xe_drm_ioctl+0x9e/0xf0 [xe]
> > > [ 2163.053074]  __x64_sys_ioctl+0xd5/0x130
> > > [ 2163.053079]  x64_sys_call+0x2b5/0x27e0
> > > [ 2163.053084]  do_syscall_64+0xef/0x6c0
> > > [ 2163.053088]  entry_SYSCALL_64_after_hwframe+0x76/0x7e
> > > 
> > > [ 2163.053098] Freed by task 17929:
> > > [ 2163.053105]  kasan_save_stack+0x26/0x60
> > > [ 2163.053110]  kasan_save_track+0x14/0x40
> > > [ 2163.053114]  kasan_save_free_info+0x3b/0x60
> > > [ 2163.053118]  __kasan_slab_free+0x6f/0xa0
> > > [ 2163.053123]  kfree+0x2bb/0x600
> > > [ 2163.053127]  xe_vma_free+0x5a/0x70 [xe]
> > > [ 2163.053610]  xe_vma_destroy_late+0xae/0xf0 [xe]
> > > [ 2163.054093]  xe_vma_destroy+0xda/0xf20 [xe]
> > > [ 2163.054576]  xe_vm_alloc_vma+0x304/0xd60 [xe]
> > > [ 2163.055059]  xe_vm_alloc_cpu_addr_mirror_vma+0x8f/0xd0 [xe]
> > > [ 2163.055543]  xe_svm_garbage_collector+0x388/0x5d0 [xe]
> > > [ 2163.056028]  xe_svm_garbage_collector_work_func+0x2a/0x40 [xe]
> > > [ 2163.056512]  process_one_work+0x5ae/0xdd0
> > > [ 2163.056517]  worker_thread+0x3b4/0x6a0
> > > [ 2163.056521]  kthread+0x204/0x250
> > > [ 2163.056525]  ret_from_fork+0x465/0x6a0
> > > [ 2163.056530]  ret_from_fork_asm+0x1a/0x30
> > > 
> > > Fixes: 941bcc1a4bbf ("drm/xe: Fine grained page fault locking")
> > > Cc: Matthew Brost <[email protected]>
> > > Cc: Thomas Hellström <[email protected]>
> > > Cc: Himal Prasad Ghimiray <[email protected]>
> > > Assisted-by: LLM
> > > Signed-off-by: Arvind Yadav <[email protected]>
> > > ---
> > >   drivers/gpu/drm/xe/xe_pagefault.c  |  37 +++++-
> > >   drivers/gpu/drm/xe/xe_svm.c        | 179 ++++++++++++++++++++++-------
> > >   drivers/gpu/drm/xe/xe_svm.h        |   8 ++
> > >   drivers/gpu/drm/xe/xe_vm.c         |  54 +++++----
> > >   drivers/gpu/drm/xe/xe_vm_madvise.c |   5 +
> > >   5 files changed, 212 insertions(+), 71 deletions(-)
> > > 
> > > diff --git a/drivers/gpu/drm/xe/xe_pagefault.c 
> > > b/drivers/gpu/drm/xe/xe_pagefault.c
> > > index 5247321c805e..9e1377df9d01 100644
> > > --- a/drivers/gpu/drm/xe/xe_pagefault.c
> > > +++ b/drivers/gpu/drm/xe/xe_pagefault.c
> > > @@ -270,8 +270,9 @@ static int xe_pagefault_service(struct xe_pagefault 
> > > *pf)
> > >           struct xe_device *xe = gt_to_xe(gt);
> > >           struct xe_vm *vm;
> > >           struct xe_vma *vma = NULL;
> > > + enum xe_pagefault_error error;
> > >           int err;
> > > - bool atomic;
> > > + bool atomic, svm_relookup = false;
> > >           u32 asid = FIELD_GET(XE_PAGEFAULT_ASID_MASK, pf->consumer.id);
> > >           /* Producer flagged this fault to be nacked */
> > > @@ -297,10 +298,13 @@ static int xe_pagefault_service(struct xe_pagefault 
> > > *pf)
> > >                   goto unlock_vm;
> > >           }
> > > +lookup_vma:
> > >           vma = xe_vm_find_vma_by_addr(vm, xe_pagefault_addr(pf));
> > >           if (!vma) {
> > >                   err = -EINVAL;
> > > -         xe_pagefault_set_error(pf, XE_PAGEFAULT_ERROR_VMA_NOT_FOUND);
> > > +         xe_pagefault_set_error(pf, svm_relookup ?
> > > +                                XE_PAGEFAULT_ERROR_SVM_VMA_NOT_FOUND :
> > > +                                XE_PAGEFAULT_ERROR_VMA_NOT_FOUND);
> > >                   goto unlock_vm;
> > >           }
> > > @@ -313,11 +317,36 @@ static int xe_pagefault_service(struct xe_pagefault 
> > > *pf)
> > >           atomic = 
> > > xe_pagefault_access_is_atomic(pf->consumer.access_type);
> > > - if (xe_vma_is_cpu_addr_mirror(vma))
> > > + if (xe_vma_is_cpu_addr_mirror(vma)) {
> > >                   err = xe_svm_handle_pagefault(vm, vma, pf, gt,
> > >                                                 xe_pagefault_addr(pf), 
> > > atomic);
> > > - else
> > > +         if (err == -EAGAIN) {
> > > +                 /* GC needs to change VMAs. Drop all read-side state. */
> > > +                 vma = NULL;
> > > +                 up_read(&vm->lock);
> > > +                 down_write(&vm->lock);
> > > +
> > > +                 if (xe_vm_is_closed(vm)) {
> > > +                         err = -ENOENT;
> > > +                         error = XE_PAGEFAULT_ERROR_VM_CLOSED;
> > > +                 } else {
> > > +                         err = xe_svm_garbage_collect(vm);
> > > +                         error = 
> > > XE_PAGEFAULT_ERROR_SVM_GARBAGE_COLLECTOR;
> > > +                 }
> > > +
> > > +                 downgrade_write(&vm->lock);
> > > +                 if (err) {
> > > +                         xe_pagefault_set_error(pf, error);
> > > +                         goto unlock_vm;
> > > +                 }
> > > +
> > > +                 xe_pagefault_set_error(pf, XE_PAGEFAULT_ERROR_NONE);
> > > +                 svm_relookup = true;
> > > +                 goto lookup_vma;
> > > +         }
> > > + } else {
> > >                   err = xe_pagefault_handle_vma(gt, vma, pf, atomic);
> > > + }
> > >   unlock_vm:
> > >           if (err)
> > > diff --git a/drivers/gpu/drm/xe/xe_svm.c b/drivers/gpu/drm/xe/xe_svm.c
> > > index bc6902b5bf57..d19cb0c4b154 100644
> > > --- a/drivers/gpu/drm/xe/xe_svm.c
> > > +++ b/drivers/gpu/drm/xe/xe_svm.c
> > > @@ -356,12 +356,36 @@ static void xe_vma_set_default_attributes(struct 
> > > xe_vma *vma)
> > >           xe_vma_mem_attr_copy(&vma->attr, &default_attr);
> > >   }
> > > +/* vm->lock keeps the VMA and its attributes stable during this check. */
> > > +static bool xe_svm_range_needs_attr_reset(struct xe_vm *vm, u64 start)
> > > +{
> > > + struct xe_vma *vma;
> > > + u64 end;
> > > +
> > > + lockdep_assert_held(&vm->lock);
> > > +
> > > + vma = xe_vm_find_vma_by_addr(vm, start);
> > > + if (!vma || !(vma->gpuva.flags & XE_VMA_MADV_AUTORESET))
> > > +         return false;
> > > +
> > > + if (!xe_vma_has_default_mem_attrs(vma))
> > > +         return true;
> > > +
> > > + start = xe_vma_start(vma);
> > > + end = xe_vma_end(vma);
> > > + xe_vm_find_cpu_addr_mirror_vma_range(vm, &start, &end);
> > > +
> > > + return start != xe_vma_start(vma) || end != xe_vma_end(vma);
> > > +}
> > > +
> > >   static int xe_svm_range_set_default_attr(struct xe_vm *vm, u64 start, 
> > > u64 end)
> > >   {
> > >           struct xe_vma *vma;
> > >           bool has_default_attr;
> > >           int err;
> > > + lockdep_assert_held_write(&vm->lock);
> > > +
> > >           vma = xe_vm_find_vma_by_addr(vm, start);
> > >           if (!vma)
> > >                   return -EINVAL;
> > > @@ -397,70 +421,134 @@ static int xe_svm_range_set_default_attr(struct 
> > > xe_vm *vm, u64 start, u64 end)
> > >                   return err;
> > >           }
> > > - /*
> > > -  * On call from xe_svm_handle_pagefault original VMA might be changed
> > > -  * signal this to lookup for VMA again.
> > > -  */
> > > - return -EAGAIN;
> > > + return 0;
> > >   }
> > > -static int xe_svm_garbage_collector(struct xe_vm *vm)
> > > +/*
> > > + * With reset_attrs false, defer ranges requiring a VMA change and return
> > > + * -EAGAIN after collecting the remaining ready ranges in the batch. The
> > > + * caller must release all read-side state before collecting them with
> > > + * vm->lock held for write.
> > > + */
> > > +static int xe_svm_garbage_collector(struct xe_vm *vm, bool reset_attrs)
> > >   {
> > >           struct xe_svm_range *range;
> > > - u64 range_start;
> > > - u64 range_end;
> > > - int err, ret = 0;
> > > + LIST_HEAD(pending);
> > > + LIST_HEAD(deferred);
> > > + u64 range_start, range_end;
> > > + bool needs_reset;
> > > + int err = 0, ret = 0;
> > >           lockdep_assert_held(&vm->lock);
> > > + if (reset_attrs)
> > > +         lockdep_assert_held_write(&vm->lock);
> > >           if (xe_vm_is_closed_or_banned(vm))
> > >                   return -ENOENT;
> > >           guard(mutex)(&vm->svm.garbage_collector.lock);
> > > + /* Process a finite batch, excluding events queued during this pass. */
> > > + spin_lock(&vm->svm.garbage_collector.list_lock);
> > > + if (list_empty(&vm->svm.garbage_collector.range_list)) {
> > > +         spin_unlock(&vm->svm.garbage_collector.list_lock);
> > > +         return 0;
> > > + }
> > > + list_splice_init(&vm->svm.garbage_collector.range_list, &pending);
> > > + spin_unlock(&vm->svm.garbage_collector.list_lock);
> > > +
> > >           for (;;) {
> > >                   spin_lock(&vm->svm.garbage_collector.list_lock);
> > > -         range = 
> > > list_first_entry_or_null(&vm->svm.garbage_collector.range_list,
> > > -                                          typeof(*range),
> > > +         range = list_first_entry_or_null(&pending, typeof(*range),
> > >                                                    
> > > garbage_collector_link);
> > > -         if (!range)
> > > +         if (!range) {
> > > +                 spin_unlock(&vm->svm.garbage_collector.list_lock);
> > >                           break;
> > > +         }
> > >                   range_start = xe_svm_range_start(range);
> > >                   range_end = xe_svm_range_end(range);
> > > -
> > >                   list_del(&range->garbage_collector_link);
> > >                   spin_unlock(&vm->svm.garbage_collector.list_lock);
> > > +         /*
> > > +          * Keep the backing range alive until its attributes can be
> > > +          * reset. The GC mutex excludes other collectors and explicit
> > > +          * range removal requires vm->lock for write.
> > > +          */
> > > +         needs_reset = xe_svm_range_needs_attr_reset(vm, range_start);
> > > +         if (needs_reset && !reset_attrs) {
> > > +                 spin_lock(&vm->svm.garbage_collector.list_lock);
> > > +                 list_add_tail(&range->garbage_collector_link, 
> > > &deferred);
> > > +                 spin_unlock(&vm->svm.garbage_collector.list_lock);
> > > +                 ret = -EAGAIN;
> > > +                 continue;
> > > +         }
> > > +
> > >                   err = __xe_svm_garbage_collector(vm, range);
> > >                   if (err) {
> > >                           drm_warn(&vm->xe->drm,
> > >                                    "Garbage collection failed: %pe\n",
> > >                                    ERR_PTR(err));
> > > +                 /* Leave the failed range in the tree for VM teardown. 
> > > */
> > >                           xe_vm_kill(vm, true);
> > > -                 return err;
> > > +                 goto out;
> > >                   }
> > > -         err = xe_svm_range_set_default_attr(vm, range_start, range_end);
> > > -         if (err) {
> > > -                 if (err == -EAGAIN)
> > > -                         ret = -EAGAIN;
> > > -                 else
> > > -                         return err;
> > > +         if (needs_reset) {
> > > +                 err = xe_svm_range_set_default_attr(vm, range_start, 
> > > range_end);
> > > +                 if (err)
> > > +                         goto out;
> > >                   }
> > >           }
> > > +
> > > +out:
> > > + /* Restore ranges not yet processed, including deferred resets. */
> > > + spin_lock(&vm->svm.garbage_collector.list_lock);
> > > + list_splice_tail_init(&pending, &vm->svm.garbage_collector.range_list);
> > > + list_splice_tail_init(&deferred, &vm->svm.garbage_collector.range_list);
> > >           spin_unlock(&vm->svm.garbage_collector.list_lock);
> > > - return ret;
> > > + return err ?: ret;
> > > +}
> > > +
> > > +/**
> > > + * xe_svm_garbage_collect() - Collect SVM ranges and reset their 
> > > attributes
> > > + * @vm: The VM, with vm->lock held for write.
> > > + *
> > > + * Process one batch of queued ranges, including attribute resets. Ranges
> > > + * queued during this pass are left for a later collection.
> > > + *
> > > + * Call before changing advice or bindings, or querying attributes, so 
> > > the
> > > + * batch is reset before applying new advice or reporting attributes.
> > > + * No VMA pointer may be retained across this call.
> > > + *
> > > + * Return: 0 on success, negative error code on error.
> > > + */
> > > +int xe_svm_garbage_collect(struct xe_vm *vm)
> > > +{
> > > + lockdep_assert_held_write(&vm->lock);
> > > +
> > > + if (!xe_vm_in_fault_mode(vm))
> > > +         return 0;
> > > +
> > > + return xe_svm_garbage_collector(vm, true);
> > >   }
> > >   static void xe_svm_garbage_collector_work_func(struct work_struct *w)
> > >   {
> > >           struct xe_vm *vm = container_of(w, struct xe_vm,
> > >                                           svm.garbage_collector.work);
> > > + int err = 0;
> > > - guard(rwsem_read)(&vm->lock);
> > > - xe_svm_garbage_collector(vm);
> > > + scoped_guard(rwsem_read, &vm->lock)
> > > +         err = xe_svm_garbage_collector(vm, false);
> > > +
> > > + if (err != -EAGAIN)
> > > +         return;
> > > +
> > > + guard(rwsem_write)(&vm->lock);
> > > + xe_svm_garbage_collect(vm);
> > >   }
> > >   #if IS_ENABLED(CONFIG_DRM_XE_PAGEMAP)
> > > @@ -1302,13 +1390,15 @@ static int __xe_svm_handle_pagefault(struct xe_vm 
> > > *vm, struct xe_vma *vma,
> > >           if (range) {
> > >                   mutex_unlock(&range->lock);
> > >                   drm_gpusvm_range_put(&range->base);
> > > - }
> > > - /* Always process UNMAPs first so view SVM ranges is current */
> > > - err = xe_svm_garbage_collector(vm);
> > > - if (err) {
> > > -         xe_pagefault_set_error(pf, 
> > > XE_PAGEFAULT_ERROR_SVM_GARBAGE_COLLECTOR);
> > > -         return err;
> > > +         /* The caller collected before the initial service attempt. */
> > > +         err = xe_svm_garbage_collector(vm, false);
> > > +         if (err) {
> > > +                 if (err != -EAGAIN)
> > > +                         xe_pagefault_set_error(pf,
> > > +                                               
> > > XE_PAGEFAULT_ERROR_SVM_GARBAGE_COLLECTOR);
> > > +                 return err;
> > > +         }
> > >           }
> > >           dpagemap = ctx.devmem_only ? xe_tile_local_pagemap(tile) :
> > > @@ -1468,14 +1558,28 @@ static int __xe_svm_handle_pagefault(struct xe_vm 
> > > *vm, struct xe_vma *vma,
> > >    * Create GPU bindings for a SVM page fault. Optionally migrate to 
> > > device
> > >    * memory.
> > >    *
> > > - * Return: 0 on success, negative error code on error.
> > > + * The caller must hold vm->lock for read. On -EAGAIN, discard @vma 
> > > before
> > > + * releasing that lock. Collect with write access, then repeat VMA lookup
> > > + * and permission checks before retrying.
> > > + *
> > > + * Return: 0 on success, -EAGAIN if the caller must collect with write
> > > + * access and repeat VMA lookup, or another negative error code on error.
> > >    */
> > >   int xe_svm_handle_pagefault(struct xe_vm *vm, struct xe_vma *vma,
> > >                               struct xe_pagefault *pf, struct xe_gt *gt,
> > >                               u64 fault_addr, bool atomic)
> > >   {
> > >           int need_vram, ret;
> > > -retry:
> > > +
> > > + /* Consume older UNMAPs before reading advice or building the context. 
> > > */
> > > + ret = xe_svm_garbage_collector(vm, false);
> > > + if (ret) {
> > > +         if (ret != -EAGAIN)
> > > +                 xe_pagefault_set_error(pf,
> > > +                                        
> > > XE_PAGEFAULT_ERROR_SVM_GARBAGE_COLLECTOR);
> > > +         return ret;
> > > + }
> > > +
> > >           need_vram = xe_vma_need_vram_for_atomic(vm->xe, vma, atomic);
> > >           if (need_vram < 0) {
> > >                   xe_pagefault_set_error(pf, 
> > > XE_PAGEFAULT_ERROR_SVM_NEEDS_VRAM_CHECK);
> > > @@ -1485,18 +1589,9 @@ int xe_svm_handle_pagefault(struct xe_vm *vm, 
> > > struct xe_vma *vma,
> > >           ret =  __xe_svm_handle_pagefault(vm, vma, pf, gt, fault_addr,
> > >                                            need_vram ? true : false);
> > >           if (ret == -EAGAIN) {
> > > -         /*
> > > -          * Retry once on -EAGAIN to re-lookup the VMA, as the original 
> > > VMA
> > > -          * may have been split by xe_svm_range_set_default_attr.
> > > -          */
> > > -         vma = xe_vm_find_vma_by_addr(vm, fault_addr);
> > > -         if (!vma) {
> > > -                 xe_pagefault_set_error(pf, 
> > > XE_PAGEFAULT_ERROR_SVM_VMA_NOT_FOUND);
> > > -                 return -EINVAL;
> > > -         }
> > > -
> > > +         /* Retry from the caller after collecting with write access. */
> > >                   xe_pagefault_set_error(pf, XE_PAGEFAULT_ERROR_NONE);
> > > -         goto retry;
> > > +         return ret;
> > >           }
> > >           if (ret && xe_pagefault_get_error(pf) == 
> > > XE_PAGEFAULT_ERROR_NONE)
> > >                   xe_pagefault_set_error(pf, 
> > > XE_PAGEFAULT_ERROR_SVM_SERVICE_FAILED);
> > > diff --git a/drivers/gpu/drm/xe/xe_svm.h b/drivers/gpu/drm/xe/xe_svm.h
> > > index ffc1cc808102..523213a8cd26 100644
> > > --- a/drivers/gpu/drm/xe/xe_svm.h
> > > +++ b/drivers/gpu/drm/xe/xe_svm.h
> > > @@ -109,6 +109,8 @@ void xe_svm_fini(struct xe_vm *vm);
> > >   void xe_svm_close(struct xe_vm *vm);
> > > +int xe_svm_garbage_collect(struct xe_vm *vm);
> > > +
> > >   int xe_svm_handle_pagefault(struct xe_vm *vm, struct xe_vma *vma,
> > >                               struct xe_pagefault *pf, struct xe_gt *gt,
> > >                               u64 fault_addr, bool atomic);
> > > @@ -316,6 +318,12 @@ void xe_svm_close(struct xe_vm *vm)
> > >   {
> > >   }
> > > +static inline
> > > +int xe_svm_garbage_collect(struct xe_vm *vm)
> > > +{
> > > + return 0;
> > > +}
> > > +
> > >   static inline
> > >   int xe_svm_handle_pagefault(struct xe_vm *vm, struct xe_vma *vma,
> > >                               struct xe_pagefault *pf, struct xe_gt *gt,
> > > diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
> > > index d12365b11186..6afe6f1be1d4 100644
> > > --- a/drivers/gpu/drm/xe/xe_vm.c
> > > +++ b/drivers/gpu/drm/xe/xe_vm.c
> > > @@ -1308,19 +1308,12 @@ static void vma_destroy_cb(struct dma_fence 
> > > *fence,
> > >           xe_destroy_wq_queue(&vma->destroy_work);
> > >   }
> > > -static void xe_vm_assert_write_mode_or_garbage_collector(struct xe_vm 
> > > *vm)
> > > -{
> > > - lockdep_assert(lockdep_is_held_type(&vm->lock, 0) ||
> > > -                (lockdep_is_held_type(&vm->lock, 1) &&
> > > -                 lockdep_is_held_type(&vm->svm.garbage_collector.lock, 
> > > 0)));
> > > -}
> > > -
> > >   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);
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           xe_assert(vm->xe, list_empty(&vma->combined_links.destroy));
> > >           if (xe_vma_is_userptr(vma)) {
> > > @@ -1416,7 +1409,7 @@ static int xe_vm_insert_vma(struct xe_vm *vm, 
> > > struct xe_vma *vma)
> > >           int err;
> > >           xe_assert(vm->xe, xe_vma_vm(vma) == vm);
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           mutex_lock(&vm->snap_mutex);
> > >           err = drm_gpuva_insert(&vm->gpuvm, &vma->gpuva);
> > > @@ -1429,7 +1422,7 @@ static int xe_vm_insert_vma(struct xe_vm *vm, 
> > > struct xe_vma *vma)
> > >   static void xe_vm_remove_vma(struct xe_vm *vm, struct xe_vma *vma)
> > >   {
> > >           xe_assert(vm->xe, xe_vma_vm(vma) == vm);
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           mutex_lock(&vm->snap_mutex);
> > >           drm_gpuva_remove(&vma->gpuva);
> > > @@ -2267,7 +2260,7 @@ static int xe_vm_query_vmas(struct xe_vm *vm, u64 
> > > start, u64 end)
> > >           struct drm_gpuva *gpuva;
> > >           u32 num_vmas = 0;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held(&vm->lock);
> > >           drm_gpuvm_for_each_va_range(gpuva, &vm->gpuvm, start, end)
> > >                   num_vmas++;
> > > @@ -2280,7 +2273,7 @@ static int get_mem_attrs(struct xe_vm *vm, u32 
> > > *num_vmas, u64 start,
> > >           struct drm_gpuva *gpuva;
> > >           int i = 0;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held(&vm->lock);
> > >           drm_gpuvm_for_each_va_range(gpuva, &vm->gpuvm, start, end) {
> > >                   struct xe_vma *vma = gpuva_to_vma(gpuva);
> > > @@ -2330,6 +2323,12 @@ int xe_vm_query_vmas_attrs_ioctl(struct drm_device 
> > > *dev, void *data, struct drm_
> > >           if (err)
> > >                   goto put_vm;
> > > + if (!xe_vm_is_closed_or_banned(vm)) {
> > > +         err = xe_svm_garbage_collect(vm);
> > > +         if (err)
> > > +                 goto unlock_vm;
> > > + }
> > > +
> > >           attrs_user = u64_to_user_ptr(args->vector_of_mem_attr);
> > >           if (args->num_mem_ranges == 0 && !attrs_user) {
> > > @@ -2487,7 +2486,7 @@ vm_bind_ioctl_ops_create(struct xe_vm *vm, struct 
> > > xe_vma_ops *vops,
> > >           u64 range_end = addr + range;
> > >           int err;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           vm_dbg(&vm->xe->drm,
> > >                  "op=%d, addr=0x%016llx, range=0x%016llx, 
> > > bo_offset_or_userptr=0x%016llx",
> > > @@ -2694,7 +2693,7 @@ static struct xe_vma *new_vma(struct xe_vm *vm, 
> > > struct drm_gpuva_op_map *op,
> > >           struct xe_vma *vma;
> > >           int err = 0;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           if (bo) {
> > >                   err = 0;
> > > @@ -2795,7 +2794,7 @@ static int xe_vma_op_commit(struct xe_vm *vm, 
> > > struct xe_vma_op *op)
> > >           switch (op->base.op) {
> > >           case DRM_GPUVA_OP_MAP:
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   err |= xe_vm_insert_vma(vm, op->map.vma);
> > >                   if (!err)
> > > @@ -2806,7 +2805,7 @@ static int xe_vma_op_commit(struct xe_vm *vm, 
> > > struct xe_vma_op *op)
> > >                   u8 tile_present =
> > >                           
> > > gpuva_to_vma(op->base.remap.unmap->va)->tile_present;
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   prep_vma_destroy(vm, 
> > > gpuva_to_vma(op->base.remap.unmap->va),
> > >                                    true);
> > > @@ -2842,7 +2841,7 @@ static int xe_vma_op_commit(struct xe_vm *vm, 
> > > struct xe_vma_op *op)
> > >                   break;
> > >           }
> > >           case DRM_GPUVA_OP_UNMAP:
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   prep_vma_destroy(vm, gpuva_to_vma(op->base.unmap.va), 
> > > true);
> > >                   op->flags |= XE_VMA_OP_COMMITTED;
> > > @@ -2889,7 +2888,7 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm 
> > > *vm, struct drm_gpuva_ops *ops,
> > >           u8 id, tile_mask = 0;
> > >           int err = 0;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           for_each_tile(tile, vm->xe, id)
> > >                   tile_mask |= 0x1 << id;
> > > @@ -3072,7 +3071,7 @@ static void xe_vma_op_unwind(struct xe_vm *vm, 
> > > struct xe_vma_op *op,
> > >           switch (op->base.op) {
> > >           case DRM_GPUVA_OP_MAP:
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   if (op->map.vma) {
> > >                           prep_vma_destroy(vm, op->map.vma, post_commit);
> > > @@ -3083,7 +3082,7 @@ static void xe_vma_op_unwind(struct xe_vm *vm, 
> > > struct xe_vma_op *op,
> > >           {
> > >                   struct xe_vma *vma = gpuva_to_vma(op->base.unmap.va);
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   if (vma) {
> > >                           xe_svm_notifier_lock(vm);
> > > @@ -3098,7 +3097,7 @@ static void xe_vma_op_unwind(struct xe_vm *vm, 
> > > struct xe_vma_op *op,
> > >           {
> > >                   struct xe_vma *vma = 
> > > gpuva_to_vma(op->base.remap.unmap->va);
> > > -         xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > +         lockdep_assert_held_write(&vm->lock);
> > >                   if (op->remap.prev) {
> > >                           prep_vma_destroy(vm, op->remap.prev, 
> > > prev_post_commit);
> > > @@ -4092,6 +4091,11 @@ int xe_vm_bind_ioctl(struct drm_device *dev, void 
> > > *data, struct drm_file *file)
> > >                   goto release_vm_lock;
> > >           }
> > > + /* Consume queued resets before replacing VMAs. */
> > > + err = xe_svm_garbage_collect(vm);
> > > + if (err)
> > > +         goto release_vm_lock;
> > > +
> > >           for (i = 0; i < args->num_binds; ++i) {
> > >                   u64 range = bind_ops[i].range;
> > >                   u64 addr = bind_ops[i].addr;
> > > @@ -4907,7 +4911,7 @@ static int xe_vm_alloc_vma(struct xe_vm *vm,
> > >           u16 default_pat;
> > >           int err;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           if (is_madvise)
> > >                   ops = drm_gpuvm_madvise_ops_create(&vm->gpuvm, map_req);
> > > @@ -5041,7 +5045,7 @@ int xe_vm_alloc_madvise_vma(struct xe_vm *vm, 
> > > uint64_t start, uint64_t range)
> > >                   .map.va.range = range,
> > >           };
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           vm_dbg(&vm->xe->drm, "MADVISE_OPS_CREATE: addr=0x%016llx, 
> > > size=0x%016llx", start, range);
> > > @@ -5073,7 +5077,7 @@ void xe_vm_find_cpu_addr_mirror_vma_range(struct 
> > > xe_vm *vm, u64 *start, u64 *end
> > >   {
> > >           struct xe_vma *prev, *next;
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held(&vm->lock);
> > >           if (*start >= SZ_4K) {
> > >                   prev = xe_vm_find_vma_by_addr(vm, *start - SZ_4K);
> > > @@ -5105,7 +5109,7 @@ int xe_vm_alloc_cpu_addr_mirror_vma(struct xe_vm 
> > > *vm, uint64_t start, uint64_t r
> > >                   .map.va.range = range,
> > >           };
> > > - xe_vm_assert_write_mode_or_garbage_collector(vm);
> > > + lockdep_assert_held_write(&vm->lock);
> > >           vm_dbg(&vm->xe->drm, "CPU_ADDR_MIRROR_VMA_OPS_CREATE: 
> > > addr=0x%016llx, size=0x%016llx",
> > >                  start, range);
> > > diff --git a/drivers/gpu/drm/xe/xe_vm_madvise.c 
> > > b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > index 5c7aefc641ee..1af5e79bbfd3 100644
> > > --- a/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > +++ b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > > @@ -638,6 +638,11 @@ int xe_vm_madvise_ioctl(struct drm_device *dev, void 
> > > *data, struct drm_file *fil
> > >                   goto unlock_vm;
> > >           }
> > > + /* Consume queued resets before publishing new advice. */
> > > + err = xe_svm_garbage_collect(vm);
> > > + if (err)
> > > +         goto unlock_vm;
> > > +
> > >           err = xe_madvise_details_init(vm, args, &details);
> > >           if (err)
> > >                   goto unlock_vm;
> > > -- 
> > > 2.43.0
> > > 

Reply via email to