[Intel-xe] [PATCH v4 2/9] drm/xe: Add helpers to hide struct xe_vma internals
Matthew Brost
matthew.brost at intel.com
Thu Jul 6 15:06:50 UTC 2023
On Thu, Jul 06, 2023 at 03:22:43PM +0200, Thomas Hellström wrote:
>
> On 6/30/23 19:57, Matthew Brost wrote:
> > This will help with the GPUVA port as the internals of struct xe_vma
> > will change.
> >
> > Signed-off-by: Matthew Brost <matthew.brost at intel.com>
> > ---
> > drivers/gpu/drm/xe/xe_bo.c | 4 +-
> > drivers/gpu/drm/xe/xe_exec.c | 2 +-
> > drivers/gpu/drm/xe/xe_gt_pagefault.c | 7 +-
> > drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c | 14 +-
> > drivers/gpu/drm/xe/xe_pt.c | 88 +++++------
> > drivers/gpu/drm/xe/xe_trace.h | 10 +-
> > drivers/gpu/drm/xe/xe_vm.c | 163 ++++++++++----------
> > drivers/gpu/drm/xe/xe_vm.h | 76 +++++++--
> > drivers/gpu/drm/xe/xe_vm_madvise.c | 12 +-
> > 9 files changed, 211 insertions(+), 165 deletions(-)
> >
> > diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c
> > index 71a14e1f25be..0cd179ba41a5 100644
> > --- a/drivers/gpu/drm/xe/xe_bo.c
> > +++ b/drivers/gpu/drm/xe/xe_bo.c
> > @@ -411,7 +411,7 @@ static int xe_bo_trigger_rebind(struct xe_device *xe, struct xe_bo *bo,
> > }
> > list_for_each_entry(vma, &bo->vmas, bo_link) {
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > trace_xe_vma_evict(vma);
> > @@ -439,7 +439,7 @@ static int xe_bo_trigger_rebind(struct xe_device *xe, struct xe_bo *bo,
> > } else {
> > bool vm_resv_locked = false;
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > /*
> > * We need to put the vma on the vm's rebind_list,
> > diff --git a/drivers/gpu/drm/xe/xe_exec.c b/drivers/gpu/drm/xe/xe_exec.c
> > index bdf00e59e7a4..ba13d20ed348 100644
> > --- a/drivers/gpu/drm/xe/xe_exec.c
> > +++ b/drivers/gpu/drm/xe/xe_exec.c
> > @@ -126,7 +126,7 @@ static int xe_exec_begin(struct xe_engine *e, struct ww_acquire_ctx *ww,
> > if (xe_vma_is_userptr(vma))
> > continue;
> > - err = xe_bo_validate(vma->bo, vm, false);
> > + err = xe_bo_validate(xe_vma_bo(vma), vm, false);
> > if (err) {
> > xe_vm_unlock_dma_resv(vm, tv_onstack, *tv, ww, objs);
> > *tv = NULL;
> > diff --git a/drivers/gpu/drm/xe/xe_gt_pagefault.c b/drivers/gpu/drm/xe/xe_gt_pagefault.c
> > index 6faebd02f3fb..0e91ab67d617 100644
> > --- a/drivers/gpu/drm/xe/xe_gt_pagefault.c
> > +++ b/drivers/gpu/drm/xe/xe_gt_pagefault.c
> > @@ -77,7 +77,8 @@ static bool vma_is_valid(struct xe_gt *gt, struct xe_vma *vma)
> > static bool vma_matches(struct xe_vma *vma, struct xe_vma *lookup)
> > {
> > - if (lookup->start > vma->end || lookup->end < vma->start)
> > + if (xe_vma_start(lookup) > xe_vma_end(vma) - 1 ||
> > + xe_vma_end(lookup) - 1 < xe_vma_start(vma))
> > return false;
> > return true;
> > @@ -171,7 +172,7 @@ static int handle_pagefault(struct xe_gt *gt, struct pagefault *pf)
> > }
> > /* Lock VM and BOs dma-resv */
> > - bo = vma->bo;
> > + bo = xe_vma_bo(vma);
> > if (only_needs_bo_lock(bo)) {
> > /* This path ensures the BO's LRU is updated */
> > ret = xe_bo_lock(bo, &ww, xe->info.tile_count, false);
> > @@ -538,7 +539,7 @@ static int handle_acc(struct xe_gt *gt, struct acc *acc)
> > goto unlock_vm;
> > /* Lock VM and BOs dma-resv */
> > - bo = vma->bo;
> > + bo = xe_vma_bo(vma);
> > if (only_needs_bo_lock(bo)) {
> > /* This path ensures the BO's LRU is updated */
> > ret = xe_bo_lock(bo, &ww, xe->info.tile_count, false);
> > diff --git a/drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c b/drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c
> > index 2fcb477604e2..f77368a16409 100644
> > --- a/drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c
> > +++ b/drivers/gpu/drm/xe/xe_gt_tlb_invalidation.c
> > @@ -203,8 +203,8 @@ int xe_gt_tlb_invalidation_vma(struct xe_gt *gt,
> > if (!xe->info.has_range_tlb_invalidation) {
> > action[len++] = MAKE_INVAL_OP(XE_GUC_TLB_INVAL_FULL);
> > } else {
> > - u64 start = vma->start;
> > - u64 length = vma->end - vma->start + 1;
> > + u64 start = xe_vma_start(vma);
> > + u64 length = xe_vma_size(vma);
> > u64 align, end;
> > if (length < SZ_4K)
> > @@ -217,12 +217,12 @@ int xe_gt_tlb_invalidation_vma(struct xe_gt *gt,
> > * address mask covering the required range.
> > */
> > align = roundup_pow_of_two(length);
> > - start = ALIGN_DOWN(vma->start, align);
> > - end = ALIGN(vma->start + length, align);
> > + start = ALIGN_DOWN(xe_vma_start(vma), align);
> > + end = ALIGN(xe_vma_end(vma), align);
> > length = align;
> > while (start + length < end) {
> > length <<= 1;
> > - start = ALIGN_DOWN(vma->start, length);
> > + start = ALIGN_DOWN(xe_vma_start(vma), length);
> > }
> > /*
> > @@ -231,7 +231,7 @@ int xe_gt_tlb_invalidation_vma(struct xe_gt *gt,
> > */
> > if (length >= SZ_2M) {
> > length = max_t(u64, SZ_16M, length);
> > - start = ALIGN_DOWN(vma->start, length);
> > + start = ALIGN_DOWN(xe_vma_start(vma), length);
> > }
> > XE_BUG_ON(length < SZ_4K);
> > @@ -240,7 +240,7 @@ int xe_gt_tlb_invalidation_vma(struct xe_gt *gt,
> > XE_BUG_ON(!IS_ALIGNED(start, length));
> > action[len++] = MAKE_INVAL_OP(XE_GUC_TLB_INVAL_PAGE_SELECTIVE);
> > - action[len++] = vma->vm->usm.asid;
> > + action[len++] = xe_vma_vm(vma)->usm.asid;
> > action[len++] = lower_32_bits(start);
> > action[len++] = upper_32_bits(start);
> > action[len++] = ilog2(length) - ilog2(SZ_4K);
> > diff --git a/drivers/gpu/drm/xe/xe_pt.c b/drivers/gpu/drm/xe/xe_pt.c
> > index fe1c77b139e4..a697d43ec293 100644
> > --- a/drivers/gpu/drm/xe/xe_pt.c
> > +++ b/drivers/gpu/drm/xe/xe_pt.c
> > @@ -96,7 +96,7 @@ static dma_addr_t vma_addr(struct xe_vma *vma, u64 offset,
> > &cur);
> > return xe_res_dma(&cur) + offset;
> > } else {
> > - return xe_bo_addr(vma->bo, offset, page_size, is_vram);
> > + return xe_bo_addr(xe_vma_bo(vma), offset, page_size, is_vram);
> > }
> > }
> > @@ -749,7 +749,7 @@ static int
> > xe_pt_stage_bind(struct xe_tile *tile, struct xe_vma *vma,
> > struct xe_vm_pgtable_update *entries, u32 *num_entries)
> > {
> > - struct xe_bo *bo = vma->bo;
> > + struct xe_bo *bo = xe_vma_bo(vma);
> > bool is_vram = !xe_vma_is_userptr(vma) && bo && xe_bo_is_vram(bo);
> > struct xe_res_cursor curs;
> > struct xe_pt_stage_bind_walk xe_walk = {
> > @@ -758,15 +758,15 @@ xe_pt_stage_bind(struct xe_tile *tile, struct xe_vma *vma,
> > .shifts = xe_normal_pt_shifts,
> > .max_level = XE_PT_HIGHEST_LEVEL,
> > },
> > - .vm = vma->vm,
> > + .vm = xe_vma_vm(vma),
> > .tile = tile,
> > .curs = &curs,
> > - .va_curs_start = vma->start,
> > + .va_curs_start = xe_vma_start(vma),
> > .pte_flags = vma->pte_flags,
> > .wupd.entries = entries,
> > - .needs_64K = (vma->vm->flags & XE_VM_FLAGS_64K) && is_vram,
> > + .needs_64K = (xe_vma_vm(vma)->flags & XE_VM_FLAGS_64K) && is_vram,
> > };
> > - struct xe_pt *pt = vma->vm->pt_root[tile->id];
> > + struct xe_pt *pt = xe_vma_vm(vma)->pt_root[tile->id];
> > int ret;
> > if (is_vram) {
> > @@ -788,20 +788,20 @@ xe_pt_stage_bind(struct xe_tile *tile, struct xe_vma *vma,
> > if (!xe_vma_is_null(vma)) {
> > if (xe_vma_is_userptr(vma))
> > - xe_res_first_sg(vma->userptr.sg, 0,
> > - vma->end - vma->start + 1, &curs);
> > + xe_res_first_sg(vma->userptr.sg, 0, xe_vma_size(vma),
> > + &curs);
> > else if (xe_bo_is_vram(bo) || xe_bo_is_stolen(bo))
> > - xe_res_first(bo->ttm.resource, vma->bo_offset,
> > - vma->end - vma->start + 1, &curs);
> > + xe_res_first(bo->ttm.resource, xe_vma_bo_offset(vma),
> > + xe_vma_size(vma), &curs);
> > else
> > - xe_res_first_sg(xe_bo_get_sg(bo), vma->bo_offset,
> > - vma->end - vma->start + 1, &curs);
> > + xe_res_first_sg(xe_bo_get_sg(bo), xe_vma_bo_offset(vma),
> > + xe_vma_size(vma), &curs);
> > } else {
> > - curs.size = vma->end - vma->start + 1;
> > + curs.size = xe_vma_size(vma);
> > }
> > - ret = xe_pt_walk_range(&pt->base, pt->level, vma->start, vma->end + 1,
> > - &xe_walk.base);
> > + ret = xe_pt_walk_range(&pt->base, pt->level, xe_vma_start(vma),
> > + xe_vma_end(vma), &xe_walk.base);
> > *num_entries = xe_walk.wupd.num_used_entries;
> > return ret;
> > @@ -933,13 +933,13 @@ bool xe_pt_zap_ptes(struct xe_tile *tile, struct xe_vma *vma)
> > },
> > .tile = tile,
> > };
> > - struct xe_pt *pt = vma->vm->pt_root[tile->id];
> > + struct xe_pt *pt = xe_vma_vm(vma)->pt_root[tile->id];
> > if (!(vma->tile_present & BIT(tile->id)))
> > return false;
> > - (void)xe_pt_walk_shared(&pt->base, pt->level, vma->start, vma->end + 1,
> > - &xe_walk.base);
> > + (void)xe_pt_walk_shared(&pt->base, pt->level, xe_vma_start(vma),
> > + xe_vma_end(vma), &xe_walk.base);
> > return xe_walk.needs_invalidate;
> > }
> > @@ -974,21 +974,21 @@ static void xe_pt_abort_bind(struct xe_vma *vma,
> > continue;
> > for (j = 0; j < entries[i].qwords; j++)
> > - xe_pt_destroy(entries[i].pt_entries[j].pt, vma->vm->flags, NULL);
> > + xe_pt_destroy(entries[i].pt_entries[j].pt, xe_vma_vm(vma)->flags, NULL);
> > kfree(entries[i].pt_entries);
> > }
> > }
> > static void xe_pt_commit_locks_assert(struct xe_vma *vma)
> > {
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > lockdep_assert_held(&vm->lock);
> > if (xe_vma_is_userptr(vma))
> > lockdep_assert_held_read(&vm->userptr.notifier_lock);
> > else if (!xe_vma_is_null(vma))
> > - dma_resv_assert_held(vma->bo->ttm.base.resv);
> > + dma_resv_assert_held(xe_vma_bo(vma)->ttm.base.resv);
> > dma_resv_assert_held(&vm->resv);
> > }
> > @@ -1021,7 +1021,7 @@ static void xe_pt_commit_bind(struct xe_vma *vma,
> > if (xe_pt_entry(pt_dir, j_))
> > xe_pt_destroy(xe_pt_entry(pt_dir, j_),
> > - vma->vm->flags, deferred);
> > + xe_vma_vm(vma)->flags, deferred);
> > pt_dir->dir.entries[j_] = &newpte->base;
> > }
> > @@ -1082,7 +1082,7 @@ static int xe_pt_userptr_inject_eagain(struct xe_vma *vma)
> > static u32 count;
> > if (count++ % divisor == divisor - 1) {
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > vma->userptr.divisor = divisor << 1;
> > spin_lock(&vm->userptr.invalidated_lock);
> > @@ -1125,7 +1125,7 @@ static int xe_pt_userptr_pre_commit(struct xe_migrate_pt_update *pt_update)
> > container_of(pt_update, typeof(*userptr_update), base);
> > struct xe_vma *vma = pt_update->vma;
> > unsigned long notifier_seq = vma->userptr.notifier_seq;
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > userptr_update->locked = false;
> > @@ -1296,19 +1296,19 @@ __xe_pt_bind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_engine *e,
> > },
> > .bind = true,
> > };
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > u32 num_entries;
> > struct dma_fence *fence;
> > struct invalidation_fence *ifence = NULL;
> > int err;
> > bind_pt_update.locked = false;
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > xe_vm_assert_held(vm);
> > - vm_dbg(&vma->vm->xe->drm,
> > + vm_dbg(&xe_vma_vm(vma)->xe->drm,
> > "Preparing bind, with range [%llx...%llx) engine %p.\n",
> > - vma->start, vma->end, e);
> > + xe_vma_start(vma), xe_vma_end(vma) - 1, e);
> > err = xe_pt_prepare_bind(tile, vma, entries, &num_entries, rebind);
> > if (err)
> > @@ -1337,7 +1337,7 @@ __xe_pt_bind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_engine *e,
> > }
> > fence = xe_migrate_update_pgtables(tile->migrate,
> > - vm, vma->bo,
> > + vm, xe_vma_bo(vma),
> > e ? e : vm->eng[tile->id],
> > entries, num_entries,
> > syncs, num_syncs,
> > @@ -1363,8 +1363,8 @@ __xe_pt_bind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_engine *e,
> > DMA_RESV_USAGE_KERNEL :
> > DMA_RESV_USAGE_BOOKKEEP);
> > - if (!xe_vma_has_no_bo(vma) && !vma->bo->vm)
> > - dma_resv_add_fence(vma->bo->ttm.base.resv, fence,
> > + if (!xe_vma_has_no_bo(vma) && !xe_vma_bo(vma)->vm)
> > + dma_resv_add_fence(xe_vma_bo(vma)->ttm.base.resv, fence,
> > DMA_RESV_USAGE_BOOKKEEP);
> > xe_pt_commit_bind(vma, entries, num_entries, rebind,
> > bind_pt_update.locked ? &deferred : NULL);
> > @@ -1526,14 +1526,14 @@ static unsigned int xe_pt_stage_unbind(struct xe_tile *tile, struct xe_vma *vma,
> > .max_level = XE_PT_HIGHEST_LEVEL,
> > },
> > .tile = tile,
> > - .modified_start = vma->start,
> > - .modified_end = vma->end + 1,
> > + .modified_start = xe_vma_start(vma),
> > + .modified_end = xe_vma_end(vma),
> > .wupd.entries = entries,
> > };
> > - struct xe_pt *pt = vma->vm->pt_root[tile->id];
> > + struct xe_pt *pt = xe_vma_vm(vma)->pt_root[tile->id];
> > - (void)xe_pt_walk_shared(&pt->base, pt->level, vma->start, vma->end + 1,
> > - &xe_walk.base);
> > + (void)xe_pt_walk_shared(&pt->base, pt->level, xe_vma_start(vma),
> > + xe_vma_end(vma), &xe_walk.base);
> > return xe_walk.wupd.num_used_entries;
> > }
> > @@ -1545,7 +1545,7 @@ xe_migrate_clear_pgtable_callback(struct xe_migrate_pt_update *pt_update,
> > const struct xe_vm_pgtable_update *update)
> > {
> > struct xe_vma *vma = pt_update->vma;
> > - u64 empty = __xe_pt_empty_pte(tile, vma->vm, update->pt->level);
> > + u64 empty = __xe_pt_empty_pte(tile, xe_vma_vm(vma), update->pt->level);
> > int i;
> > if (map && map->is_iomem)
> > @@ -1581,7 +1581,7 @@ xe_pt_commit_unbind(struct xe_vma *vma,
> > i++) {
> > if (xe_pt_entry(pt_dir, i))
> > xe_pt_destroy(xe_pt_entry(pt_dir, i),
> > - vma->vm->flags, deferred);
> > + xe_vma_vm(vma)->flags, deferred);
> > pt_dir->dir.entries[i] = NULL;
> > }
> > @@ -1630,18 +1630,18 @@ __xe_pt_unbind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_engine *e
> > .vma = vma,
> > },
> > };
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > u32 num_entries;
> > struct dma_fence *fence = NULL;
> > struct invalidation_fence *ifence;
> > LLIST_HEAD(deferred);
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > xe_vm_assert_held(vm);
> > - vm_dbg(&vma->vm->xe->drm,
> > + vm_dbg(&xe_vma_vm(vma)->xe->drm,
> > "Preparing unbind, with range [%llx...%llx) engine %p.\n",
> > - vma->start, vma->end, e);
> > + xe_vma_start(vma), xe_vma_end(vma) - 1, e);
> > num_entries = xe_pt_stage_unbind(tile, vma, entries);
> > XE_BUG_ON(num_entries > ARRAY_SIZE(entries));
> > @@ -1680,8 +1680,8 @@ __xe_pt_unbind_vma(struct xe_tile *tile, struct xe_vma *vma, struct xe_engine *e
> > DMA_RESV_USAGE_BOOKKEEP);
> > /* This fence will be installed by caller when doing eviction */
> > - if (!xe_vma_has_no_bo(vma) && !vma->bo->vm)
> > - dma_resv_add_fence(vma->bo->ttm.base.resv, fence,
> > + if (!xe_vma_has_no_bo(vma) && !xe_vma_bo(vma)->vm)
> > + dma_resv_add_fence(xe_vma_bo(vma)->ttm.base.resv, fence,
> > DMA_RESV_USAGE_BOOKKEEP);
> > xe_pt_commit_unbind(vma, entries, num_entries,
> > unbind_pt_update.locked ? &deferred : NULL);
> > diff --git a/drivers/gpu/drm/xe/xe_trace.h b/drivers/gpu/drm/xe/xe_trace.h
> > index ca96a0a4bb80..b3828e2f0aab 100644
> > --- a/drivers/gpu/drm/xe/xe_trace.h
> > +++ b/drivers/gpu/drm/xe/xe_trace.h
> > @@ -18,7 +18,7 @@
> > #include "xe_gt_types.h"
> > #include "xe_guc_engine_types.h"
> > #include "xe_sched_job.h"
> > -#include "xe_vm_types.h"
> > +#include "xe_vm.h"
> > DECLARE_EVENT_CLASS(xe_gt_tlb_invalidation_fence,
> > TP_PROTO(struct xe_gt_tlb_invalidation_fence *fence),
> > @@ -373,10 +373,10 @@ DECLARE_EVENT_CLASS(xe_vma,
> > TP_fast_assign(
> > __entry->vma = (unsigned long)vma;
> > - __entry->asid = vma->vm->usm.asid;
> > - __entry->start = vma->start;
> > - __entry->end = vma->end;
> > - __entry->ptr = (u64)vma->userptr.ptr;
> > + __entry->asid = xe_vma_vm(vma)->usm.asid;
> > + __entry->start = xe_vma_start(vma);
> > + __entry->end = xe_vma_end(vma) - 1;
> > + __entry->ptr = xe_vma_userptr(vma);
> > ),
> > TP_printk("vma=0x%016llx, asid=0x%05x, start=0x%012llx, end=0x%012llx, ptr=0x%012llx,",
> > diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
> > index 3c8a48f9a0d3..7be4436272f7 100644
> > --- a/drivers/gpu/drm/xe/xe_vm.c
> > +++ b/drivers/gpu/drm/xe/xe_vm.c
> > @@ -53,15 +53,14 @@ int xe_vma_userptr_check_repin(struct xe_vma *vma)
> > int xe_vma_userptr_pin_pages(struct xe_vma *vma)
> > {
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > struct xe_device *xe = vm->xe;
> > - const unsigned long num_pages =
> > - (vma->end - vma->start + 1) >> PAGE_SHIFT;
> > + const unsigned long num_pages = xe_vma_size(vma) >> PAGE_SHIFT;
> > struct page **pages;
> > bool in_kthread = !current->mm;
> > unsigned long notifier_seq;
> > int pinned, ret, i;
> > - bool read_only = vma->pte_flags & XE_PTE_FLAG_READ_ONLY;
> > + bool read_only = xe_vma_read_only(vma);
> > lockdep_assert_held(&vm->lock);
> > XE_BUG_ON(!xe_vma_is_userptr(vma));
> > @@ -96,7 +95,8 @@ int xe_vma_userptr_pin_pages(struct xe_vma *vma)
> > }
> > while (pinned < num_pages) {
> > - ret = get_user_pages_fast(vma->userptr.ptr + pinned * PAGE_SIZE,
> > + ret = get_user_pages_fast(xe_vma_userptr(vma) +
> > + pinned * PAGE_SIZE,
> > num_pages - pinned,
> > read_only ? 0 : FOLL_WRITE,
> > &pages[pinned]);
> > @@ -299,7 +299,7 @@ void xe_vm_fence_all_extobjs(struct xe_vm *vm, struct dma_fence *fence,
> > struct xe_vma *vma;
> > list_for_each_entry(vma, &vm->extobj.list, extobj.link)
> > - dma_resv_add_fence(vma->bo->ttm.base.resv, fence, usage);
> > + dma_resv_add_fence(xe_vma_bo(vma)->ttm.base.resv, fence, usage);
> > }
> > static void resume_and_reinstall_preempt_fences(struct xe_vm *vm)
> > @@ -448,7 +448,7 @@ int xe_vm_lock_dma_resv(struct xe_vm *vm, struct ww_acquire_ctx *ww,
> > INIT_LIST_HEAD(objs);
> > list_for_each_entry(vma, &vm->extobj.list, extobj.link) {
> > tv_bo->num_shared = num_shared;
> > - tv_bo->bo = &vma->bo->ttm;
> > + tv_bo->bo = &xe_vma_bo(vma)->ttm;
> > list_add_tail(&tv_bo->head, objs);
> > tv_bo++;
> > @@ -463,7 +463,7 @@ int xe_vm_lock_dma_resv(struct xe_vm *vm, struct ww_acquire_ctx *ww,
> > spin_lock(&vm->notifier.list_lock);
> > list_for_each_entry_safe(vma, next, &vm->notifier.rebind_list,
> > notifier.rebind_link) {
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > list_del_init(&vma->notifier.rebind_link);
> > if (vma->tile_present && !vma->destroyed)
> > @@ -612,7 +612,7 @@ static void preempt_rebind_work_func(struct work_struct *w)
> > if (xe_vma_has_no_bo(vma) || vma->destroyed)
> > continue;
> > - err = xe_bo_validate(vma->bo, vm, false);
> > + err = xe_bo_validate(xe_vma_bo(vma), vm, false);
> > if (err)
> > goto out_unlock;
> > }
> > @@ -704,7 +704,7 @@ static bool vma_userptr_invalidate(struct mmu_interval_notifier *mni,
> > unsigned long cur_seq)
> > {
> > struct xe_vma *vma = container_of(mni, struct xe_vma, userptr.notifier);
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > struct dma_resv_iter cursor;
> > struct dma_fence *fence;
> > long err;
> > @@ -923,7 +923,7 @@ static struct xe_vma *xe_vma_create(struct xe_vm *vm,
> > err = mmu_interval_notifier_insert(&vma->userptr.notifier,
> > current->mm,
> > - vma->userptr.ptr, size,
> > + xe_vma_userptr(vma), size,
> > &vma_userptr_notifier_ops);
> > if (err) {
> > kfree(vma);
> > @@ -943,7 +943,7 @@ static struct xe_vma *xe_vma_create(struct xe_vm *vm,
> > static bool vm_remove_extobj(struct xe_vma *vma)
> > {
> > if (!list_empty(&vma->extobj.link)) {
> > - vma->vm->extobj.entries--;
> > + xe_vma_vm(vma)->extobj.entries--;
> > list_del_init(&vma->extobj.link);
> > return true;
> > }
> > @@ -952,9 +952,9 @@ static bool vm_remove_extobj(struct xe_vma *vma)
> > static void xe_vma_destroy_late(struct xe_vma *vma)
> > {
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > struct xe_device *xe = vm->xe;
> > - bool read_only = vma->pte_flags & XE_PTE_FLAG_READ_ONLY;
> > + bool read_only = xe_vma_read_only(vma);
> > if (xe_vma_is_userptr(vma)) {
> > if (vma->userptr.sg) {
> > @@ -976,7 +976,7 @@ static void xe_vma_destroy_late(struct xe_vma *vma)
> > } else if (xe_vma_is_null(vma)) {
> > xe_vm_put(vm);
> > } else {
> > - xe_bo_put(vma->bo);
> > + xe_bo_put(xe_vma_bo(vma));
> > }
> > kfree(vma);
> > @@ -997,7 +997,7 @@ bo_has_vm_references_locked(struct xe_bo *bo, struct xe_vm *vm,
> > struct xe_vma *vma;
> > list_for_each_entry(vma, &bo->vmas, bo_link) {
> > - if (vma != ignore && vma->vm == vm)
> > + if (vma != ignore && xe_vma_vm(vma) == vm)
> > return vma;
> > }
> > @@ -1025,7 +1025,7 @@ static void __vm_insert_extobj(struct xe_vm *vm, struct xe_vma *vma)
> > static void vm_insert_extobj(struct xe_vm *vm, struct xe_vma *vma)
> > {
> > - struct xe_bo *bo = vma->bo;
> > + struct xe_bo *bo = xe_vma_bo(vma);
> > lockdep_assert_held_write(&vm->lock);
> > @@ -1046,7 +1046,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 = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > lockdep_assert_held_write(&vm->lock);
> > XE_BUG_ON(!list_empty(&vma->unbind_link));
> > @@ -1058,17 +1058,17 @@ static void xe_vma_destroy(struct xe_vma *vma, struct dma_fence *fence)
> > spin_unlock(&vm->userptr.invalidated_lock);
> > list_del(&vma->userptr_link);
> > } else if (!xe_vma_is_null(vma)) {
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > list_del(&vma->bo_link);
> > spin_lock(&vm->notifier.list_lock);
> > list_del(&vma->notifier.rebind_link);
> > spin_unlock(&vm->notifier.list_lock);
> > - if (!vma->bo->vm && vm_remove_extobj(vma)) {
> > + if (!xe_vma_bo(vma)->vm && vm_remove_extobj(vma)) {
> > struct xe_vma *other;
> > - other = bo_has_vm_references_locked(vma->bo, vm, NULL);
> > + other = bo_has_vm_references_locked(xe_vma_bo(vma), vm, NULL);
> > if (other)
> > __vm_insert_extobj(vm, other);
> > @@ -1096,13 +1096,13 @@ static void xe_vma_destroy_unlocked(struct xe_vma *vma)
> > {
> > struct ttm_validate_buffer tv[2];
> > struct ww_acquire_ctx ww;
> > - struct xe_bo *bo = vma->bo;
> > + struct xe_bo *bo = xe_vma_bo(vma);
> > LIST_HEAD(objs);
> > LIST_HEAD(dups);
> > int err;
> > memset(tv, 0, sizeof(tv));
> > - tv[0].bo = xe_vm_ttm_bo(vma->vm);
> > + tv[0].bo = xe_vm_ttm_bo(xe_vma_vm(vma));
> > list_add(&tv[0].head, &objs);
> > if (bo) {
> > @@ -1125,11 +1125,11 @@ static struct xe_vma *to_xe_vma(const struct rb_node *node)
> > return (struct xe_vma *)node;
> > }
> > -static int xe_vma_cmp(const struct xe_vma *a, const struct xe_vma *b)
> > +static int xe_vma_cmp(struct xe_vma *a, struct xe_vma *b)
> > {
> > - if (a->end < b->start) {
> > + if (xe_vma_end(a) - 1 < xe_vma_start(b)) {
> > return -1;
> > - } else if (b->end < a->start) {
> > + } else if (xe_vma_end(b) - 1 < xe_vma_start(a)) {
> > return 1;
> > } else {
> > return 0;
> > @@ -1144,19 +1144,19 @@ static bool xe_vma_less_cb(struct rb_node *a, const struct rb_node *b)
> > int xe_vma_cmp_vma_cb(const void *key, const struct rb_node *node)
> > {
> > struct xe_vma *cmp = to_xe_vma(node);
> > - const struct xe_vma *own = key;
> > + struct xe_vma *own = (struct xe_vma *)key;
> > - if (own->start > cmp->end)
> > + if (xe_vma_start(own) > xe_vma_end(cmp) - 1)
> > return 1;
> > - if (own->end < cmp->start)
> > + if (xe_vma_end(own) - 1 < xe_vma_start(cmp))
> > return -1;
> > return 0;
> > }
> > struct xe_vma *
> > -xe_vm_find_overlapping_vma(struct xe_vm *vm, const struct xe_vma *vma)
> > +xe_vm_find_overlapping_vma(struct xe_vm *vm, struct xe_vma *vma)
> > {
> > struct rb_node *node;
> > @@ -1165,7 +1165,7 @@ xe_vm_find_overlapping_vma(struct xe_vm *vm, const struct xe_vma *vma)
> > if (xe_vm_is_closed_or_banned(vm))
> > return NULL;
> > - XE_BUG_ON(vma->end >= vm->size);
> > + XE_BUG_ON(xe_vma_end(vma) > vm->size);
> > node = rb_find(vma, &vm->vmas, xe_vma_cmp_vma_cb);
> > @@ -1174,7 +1174,7 @@ xe_vm_find_overlapping_vma(struct xe_vm *vm, const struct xe_vma *vma)
> > static void xe_vm_insert_vma(struct xe_vm *vm, struct xe_vma *vma)
> > {
> > - XE_BUG_ON(vma->vm != vm);
> > + XE_BUG_ON(xe_vma_vm(vma) != vm);
> > lockdep_assert_held(&vm->lock);
> > rb_add(&vma->vm_node, &vm->vmas, xe_vma_less_cb);
> > @@ -1182,7 +1182,7 @@ static void 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_BUG_ON(vma->vm != vm);
> > + XE_BUG_ON(xe_vma_vm(vma) != vm);
> > lockdep_assert_held(&vm->lock);
> > rb_erase(&vma->vm_node, &vm->vmas);
> > @@ -1436,7 +1436,7 @@ void xe_vm_close_and_put(struct xe_vm *vm)
> > rb_erase(&vma->vm_node, &vm->vmas);
> > /* easy case, remove from VMA? */
> > - if (xe_vma_has_no_bo(vma) || vma->bo->vm) {
> > + if (xe_vma_has_no_bo(vma) || xe_vma_bo(vma)->vm) {
> > xe_vma_destroy(vma, NULL);
> > continue;
> > }
> > @@ -1576,7 +1576,7 @@ xe_vm_unbind_vma(struct xe_vma *vma, struct xe_engine *e,
> > struct dma_fence *fence = NULL;
> > struct dma_fence **fences = NULL;
> > struct dma_fence_array *cf = NULL;
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > int cur_fence = 0, i;
> > int number_tiles = hweight_long(vma->tile_present);
> > int err;
> > @@ -1646,7 +1646,7 @@ xe_vm_bind_vma(struct xe_vma *vma, struct xe_engine *e,
> > struct dma_fence *fence;
> > struct dma_fence **fences = NULL;
> > struct dma_fence_array *cf = NULL;
> > - struct xe_vm *vm = vma->vm;
> > + struct xe_vm *vm = xe_vma_vm(vma);
> > int cur_fence = 0, i;
> > int number_tiles = hweight_long(vma->tile_mask);
> > int err;
> > @@ -1832,7 +1832,7 @@ static int xe_vm_unbind(struct xe_vm *vm, struct xe_vma *vma,
> > struct dma_fence *fence;
> > xe_vm_assert_held(vm);
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > fence = xe_vm_unbind_vma(vma, e, syncs, num_syncs);
> > if (IS_ERR(fence))
> > @@ -2071,13 +2071,13 @@ static int xe_vm_prefetch(struct xe_vm *vm, struct xe_vma *vma,
> > XE_BUG_ON(region > ARRAY_SIZE(region_to_mem_type));
> > if (!xe_vma_has_no_bo(vma)) {
> > - err = xe_bo_migrate(vma->bo, region_to_mem_type[region]);
> > + err = xe_bo_migrate(xe_vma_bo(vma), region_to_mem_type[region]);
> > if (err)
> > return err;
> > }
> > if (vma->tile_mask != (vma->tile_present & ~vma->usm.tile_invalidated)) {
> > - return xe_vm_bind(vm, vma, e, vma->bo, syncs, num_syncs,
> > + return xe_vm_bind(vm, vma, e, xe_vma_bo(vma), syncs, num_syncs,
> > afence);
> > } else {
> > int i;
> > @@ -2173,7 +2173,7 @@ static int vm_bind_ioctl(struct xe_vm *vm, struct xe_vma *vma,
> > xe_vm_tv_populate(vm, &tv_vm);
> > list_add_tail(&tv_vm.head, &objs);
> > - vbo = vma->bo;
> > + vbo = xe_vma_bo(vma);
> > if (vbo) {
> > /*
> > * An unbind can drop the last reference to the BO and
> > @@ -2533,7 +2533,7 @@ static int vm_bind_ioctl_async(struct xe_vm *vm, struct xe_vma *vma,
> > } else {
> > bind_op->op = XE_VM_BIND_FLAG_ASYNC |
> > XE_VM_BIND_OP_MAP;
> > - xe_bo_get(__vma->bo);
> > + xe_bo_get(xe_vma_bo(__vma));
> > }
> > if (!last) {
> > @@ -2543,7 +2543,7 @@ static int vm_bind_ioctl_async(struct xe_vm *vm, struct xe_vma *vma,
> > }
> > err = __vm_bind_ioctl_async(vm, __vma, e,
> > - __vma->bo, bind_op, last ?
> > + xe_vma_bo(__vma), bind_op, last ?
> > out_syncs : NULL,
> > last ? num_out_syncs : 0);
> > if (err) {
> > @@ -2590,8 +2590,8 @@ static int __vm_bind_ioctl_lookup_vma(struct xe_vm *vm, struct xe_bo *bo,
> > case XE_VM_BIND_OP_PREFETCH:
> > vma = xe_vm_find_overlapping_vma(vm, &lookup);
> > if (XE_IOCTL_ERR(xe, !vma) ||
> > - XE_IOCTL_ERR(xe, (vma->start != addr ||
> > - vma->end != addr + range - 1) && !async))
> > + XE_IOCTL_ERR(xe, (xe_vma_start(vma) != addr ||
> > + xe_vma_end(vma) != addr + range) && !async))
> > return -EINVAL;
> > break;
> > case XE_VM_BIND_OP_UNMAP_ALL:
> > @@ -2616,9 +2616,9 @@ static int prep_replacement_vma(struct xe_vm *vm, struct xe_vma *vma)
> > {
> > int err;
> > - if (vma->bo && !vma->bo->vm) {
> > + if (xe_vma_bo(vma) && !xe_vma_bo(vma)->vm) {
> > vm_insert_extobj(vm, vma);
> > - err = add_preempt_fences(vm, vma->bo);
> > + err = add_preempt_fences(vm, xe_vma_bo(vma));
> > if (err)
> > return err;
> > }
> > @@ -2667,25 +2667,25 @@ static struct xe_vma *vm_unbind_lookup_vmas(struct xe_vm *vm,
> > }
> > }
> > - if (first->start != lookup->start) {
> > + if (xe_vma_start(first) != xe_vma_start(lookup)) {
> > struct ww_acquire_ctx ww;
> > - if (first->bo)
> > - err = xe_bo_lock(first->bo, &ww, 0, true);
> > + if (xe_vma_bo(first))
> > + err = xe_bo_lock(xe_vma_bo(first), &ww, 0, true);
> > if (err)
> > goto unwind;
> > - new_first = xe_vma_create(first->vm, first->bo,
> > - first->bo ? first->bo_offset :
> > - first->userptr.ptr,
> > - first->start,
> > - lookup->start - 1,
> > - (first->pte_flags &
> > - XE_PTE_FLAG_READ_ONLY),
> > + new_first = xe_vma_create(xe_vma_vm(first), xe_vma_bo(first),
> > + xe_vma_bo(first) ?
> > + xe_vma_bo_offset(first) :
> > + xe_vma_userptr(first),
> > + xe_vma_start(first),
> > + xe_vma_start(lookup) - 1,
> > + xe_vma_read_only(first),
> > (first->pte_flags &
> > XE_PTE_FLAG_NULL),
> > first->tile_mask);
> > - if (first->bo)
> > - xe_bo_unlock(first->bo, &ww);
> > + if (xe_vma_bo(first))
> > + xe_bo_unlock(xe_vma_bo(first), &ww);
> > if (!new_first) {
> > err = -ENOMEM;
> > goto unwind;
> > @@ -2700,25 +2700,25 @@ static struct xe_vma *vm_unbind_lookup_vmas(struct xe_vm *vm,
> > goto unwind;
> > }
> > - if (last->end != lookup->end) {
> > + if (xe_vma_end(last) != xe_vma_end(lookup)) {
> > struct ww_acquire_ctx ww;
> > - u64 chunk = lookup->end + 1 - last->start;
> > + u64 chunk = xe_vma_end(lookup) - xe_vma_start(last);
> > - if (last->bo)
> > - err = xe_bo_lock(last->bo, &ww, 0, true);
> > + if (xe_vma_bo(last))
> > + err = xe_bo_lock(xe_vma_bo(last), &ww, 0, true);
> > if (err)
> > goto unwind;
> > - new_last = xe_vma_create(last->vm, last->bo,
> > - last->bo ? last->bo_offset + chunk :
> > - last->userptr.ptr + chunk,
> > - last->start + chunk,
> > - last->end,
> > - (last->pte_flags &
> > - XE_PTE_FLAG_READ_ONLY),
> > + new_last = xe_vma_create(xe_vma_vm(last), xe_vma_bo(last),
> > + xe_vma_bo(last) ?
> > + xe_vma_bo_offset(last) + chunk :
> > + xe_vma_userptr(last) + chunk,
> > + xe_vma_start(last) + chunk,
> > + xe_vma_end(last) - 1,
> > + xe_vma_read_only(last),
> > (last->pte_flags & XE_PTE_FLAG_NULL),
> > last->tile_mask);
> > - if (last->bo)
> > - xe_bo_unlock(last->bo, &ww);
> > + if (xe_vma_bo(last))
> > + xe_bo_unlock(xe_vma_bo(last), &ww);
> > if (!new_last) {
> > err = -ENOMEM;
> > goto unwind;
> > @@ -2784,7 +2784,7 @@ static struct xe_vma *vm_prefetch_lookup_vmas(struct xe_vm *vm,
> > struct rb_node *node;
> > if (!xe_vma_has_no_bo(vma)) {
> > - if (!xe_bo_can_migrate(vma->bo, region_to_mem_type[region]))
> > + if (!xe_bo_can_migrate(xe_vma_bo(vma), region_to_mem_type[region]))
> > return ERR_PTR(-EINVAL);
> > }
> > @@ -2793,7 +2793,7 @@ static struct xe_vma *vm_prefetch_lookup_vmas(struct xe_vm *vm,
> > if (!xe_vma_cmp_vma_cb(lookup, node)) {
> > __vma = to_xe_vma(node);
> > if (!xe_vma_has_no_bo(__vma)) {
> > - if (!xe_bo_can_migrate(__vma->bo, region_to_mem_type[region]))
> > + if (!xe_bo_can_migrate(xe_vma_bo(__vma), region_to_mem_type[region]))
> > goto flush_list;
> > }
> > list_add_tail(&__vma->unbind_link, &vma->unbind_link);
> > @@ -2807,7 +2807,7 @@ static struct xe_vma *vm_prefetch_lookup_vmas(struct xe_vm *vm,
> > if (!xe_vma_cmp_vma_cb(lookup, node)) {
> > __vma = to_xe_vma(node);
> > if (!xe_vma_has_no_bo(__vma)) {
> > - if (!xe_bo_can_migrate(__vma->bo, region_to_mem_type[region]))
> > + if (!xe_bo_can_migrate(xe_vma_bo(__vma), region_to_mem_type[region]))
> > goto flush_list;
> > }
> > list_add(&__vma->unbind_link, &vma->unbind_link);
> > @@ -2835,7 +2835,7 @@ static struct xe_vma *vm_unbind_all_lookup_vmas(struct xe_vm *vm,
> > xe_bo_assert_held(bo);
> > list_for_each_entry(vma, &bo->vmas, bo_link) {
> > - if (vma->vm != vm)
> > + if (xe_vma_vm(vma) != vm)
> > continue;
> > prep_vma_destroy(vm, vma);
> > @@ -3430,14 +3430,14 @@ void xe_vm_unlock(struct xe_vm *vm, struct ww_acquire_ctx *ww)
> > */
> > int xe_vm_invalidate_vma(struct xe_vma *vma)
> > {
> > - struct xe_device *xe = vma->vm->xe;
> > + struct xe_device *xe = xe_vma_vm(vma)->xe;
> > struct xe_tile *tile;
> > u32 tile_needs_invalidate = 0;
> > int seqno[XE_MAX_TILES_PER_DEVICE];
> > u8 id;
> > int ret;
> > - XE_BUG_ON(!xe_vm_in_fault_mode(vma->vm));
> > + XE_BUG_ON(!xe_vm_in_fault_mode(xe_vma_vm(vma)));
> > XE_WARN_ON(xe_vma_is_null(vma));
> > trace_xe_vma_usm_invalidate(vma);
> > @@ -3447,11 +3447,11 @@ int xe_vm_invalidate_vma(struct xe_vma *vma)
> > WARN_ON_ONCE(!mmu_interval_check_retry
> > (&vma->userptr.notifier,
> > vma->userptr.notifier_seq));
> > - WARN_ON_ONCE(!dma_resv_test_signaled(&vma->vm->resv,
> > + WARN_ON_ONCE(!dma_resv_test_signaled(&xe_vma_vm(vma)->resv,
> > DMA_RESV_USAGE_BOOKKEEP));
> > } else {
> > - xe_bo_assert_held(vma->bo);
> > + xe_bo_assert_held(xe_vma_bo(vma));
> > }
> > }
> > @@ -3516,10 +3516,11 @@ int xe_analyze_vm(struct drm_printer *p, struct xe_vm *vm, int gt_id)
> > addr = 0;
> > }
> > } else {
> > - addr = __xe_bo_addr(vma->bo, 0, XE_PAGE_SIZE, &is_vram);
> > + addr = __xe_bo_addr(xe_vma_bo(vma), 0, XE_PAGE_SIZE, &is_vram);
> > }
> > drm_printf(p, " [%016llx-%016llx] S:0x%016llx A:%016llx %s\n",
> > - vma->start, vma->end, vma->end - vma->start + 1ull,
> > + xe_vma_start(vma), xe_vma_end(vma) - 1,
> > + xe_vma_size(vma),
> > addr, is_null ? "NULL" : is_userptr ? "USR" :
> > is_vram ? "VRAM" : "SYS");
> > }
> > diff --git a/drivers/gpu/drm/xe/xe_vm.h b/drivers/gpu/drm/xe/xe_vm.h
> > index 47bc7fbb2f50..3d542ceb5327 100644
> > --- a/drivers/gpu/drm/xe/xe_vm.h
> > +++ b/drivers/gpu/drm/xe/xe_vm.h
> > @@ -61,7 +61,66 @@ static inline bool xe_vm_is_closed_or_banned(struct xe_vm *vm)
> > }
> > struct xe_vma *
> > -xe_vm_find_overlapping_vma(struct xe_vm *vm, const struct xe_vma *vma);
> > +xe_vm_find_overlapping_vma(struct xe_vm *vm, struct xe_vma *vma);
> > +
> > +/*
> > + * Let's abstract start, size, end, bo_offset, vm, and bo as the underlying
> > + * implementation may change
> > + */
>
> According to the linux kernel patch guidelines we're required to kerneldoc
> those below.
> Not going to insist on that, but perhaps just a more formal summarizing
> comment:
>
> /**
> * DOC: Provide accessors for vma members to facilitate easy change of
> implementation.
> */
>
Sure.
> Otherwise
>
> Reviewed-by: Thomas Hellström <thomas.hellstrom at linux.kernel.org>
>
>
> > +static inline u64 xe_vma_start(struct xe_vma *vma)
> > +{
> > + return vma->start;
> > +}
> > +
> > +static inline u64 xe_vma_size(struct xe_vma *vma)
> > +{
> > + return vma->end - vma->start + 1;
> > +}
> > +
> > +static inline u64 xe_vma_end(struct xe_vma *vma)
> > +{
> > + return xe_vma_start(vma) + xe_vma_size(vma);
> > +}
> vma->end - 1; ?
xe_vma_end() == vma->end + 1, I intentionally made this change as this
more aligns with the gpuva usage.
Probably going to rebase and merge this one asap as this one is really
hard to get it to apply.
Matt
> > +
> > +static inline u64 xe_vma_bo_offset(struct xe_vma *vma)
> > +{
> > + return vma->bo_offset;
> > +}
> > +
> > +static inline struct xe_bo *xe_vma_bo(struct xe_vma *vma)
> > +{
> > + return vma->bo;
> > +}
> > +
> > +static inline struct xe_vm *xe_vma_vm(struct xe_vma *vma)
> > +{
> > + return vma->vm;
> > +}
> > +
> > +static inline bool xe_vma_read_only(struct xe_vma *vma)
> > +{
> > + return vma->pte_flags & XE_PTE_FLAG_READ_ONLY;
> > +}
> > +
> > +static inline u64 xe_vma_userptr(struct xe_vma *vma)
> > +{
> > + return vma->userptr.ptr;
> > +}
> > +
> > +static inline bool xe_vma_is_null(struct xe_vma *vma)
> > +{
> > + return vma->pte_flags & XE_PTE_FLAG_NULL;
> > +}
> > +
> > +static inline bool xe_vma_has_no_bo(struct xe_vma *vma)
> > +{
> > + return !xe_vma_bo(vma);
> > +}
> > +
> > +static inline bool xe_vma_is_userptr(struct xe_vma *vma)
> > +{
> > + return xe_vma_has_no_bo(vma) && !xe_vma_is_null(vma);
> > +}
> > #define xe_vm_assert_held(vm) dma_resv_assert_held(&(vm)->resv)
> > @@ -126,21 +185,6 @@ static inline void xe_vm_reactivate_rebind(struct xe_vm *vm)
> > }
> > }
> > -static inline bool xe_vma_is_null(struct xe_vma *vma)
> > -{
> > - return vma->pte_flags & XE_PTE_FLAG_NULL;
> > -}
> > -
> > -static inline bool xe_vma_has_no_bo(struct xe_vma *vma)
> > -{
> > - return !vma->bo;
> > -}
> > -
> > -static inline bool xe_vma_is_userptr(struct xe_vma *vma)
> > -{
> > - return xe_vma_has_no_bo(vma) && !xe_vma_is_null(vma);
> > -}
> > -
> > int xe_vma_userptr_pin_pages(struct xe_vma *vma);
> > int xe_vma_userptr_check_repin(struct xe_vma *vma);
> > diff --git a/drivers/gpu/drm/xe/xe_vm_madvise.c b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > index 76458f8d57f3..f29a67cb941f 100644
> > --- a/drivers/gpu/drm/xe/xe_vm_madvise.c
> > +++ b/drivers/gpu/drm/xe/xe_vm_madvise.c
> > @@ -30,7 +30,7 @@ static int madvise_preferred_mem_class(struct xe_device *xe, struct xe_vm *vm,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > err = xe_bo_lock(bo, &ww, 0, true);
> > if (err)
> > @@ -55,7 +55,7 @@ static int madvise_preferred_gt(struct xe_device *xe, struct xe_vm *vm,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > err = xe_bo_lock(bo, &ww, 0, true);
> > if (err)
> > @@ -91,7 +91,7 @@ static int madvise_preferred_mem_class_gt(struct xe_device *xe,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > err = xe_bo_lock(bo, &ww, 0, true);
> > if (err)
> > @@ -114,7 +114,7 @@ static int madvise_cpu_atomic(struct xe_device *xe, struct xe_vm *vm,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > if (XE_IOCTL_ERR(xe, !(bo->flags & XE_BO_CREATE_SYSTEM_BIT)))
> > return -EINVAL;
> > @@ -145,7 +145,7 @@ static int madvise_device_atomic(struct xe_device *xe, struct xe_vm *vm,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > if (XE_IOCTL_ERR(xe, !(bo->flags & XE_BO_CREATE_VRAM0_BIT) &&
> > !(bo->flags & XE_BO_CREATE_VRAM1_BIT)))
> > return -EINVAL;
> > @@ -176,7 +176,7 @@ static int madvise_priority(struct xe_device *xe, struct xe_vm *vm,
> > struct xe_bo *bo;
> > struct ww_acquire_ctx ww;
> > - bo = vmas[i]->bo;
> > + bo = xe_vma_bo(vmas[i]);
> > err = xe_bo_lock(bo, &ww, 0, true);
> > if (err)
More information about the Intel-xe
mailing list