drm/xe/vm: Simplify and document xe_vm_lock()

The xe_vm_lock() function was unnecessarily using ttm_eu_reserve_buffers().
Simplify and document the interface.

v4:
- Improve on xe_vm_lock() documentation (Matthew Brost)
v5:
- Rebase conflict.

Signed-off-by: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Reviewed-by: Matthew Brost <matthew.brost@intel.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20230908091716.36984-3-thomas.hellstrom@linux.intel.com
Signed-off-by: Rodrigo Vivi <rodrigo.vivi@intel.com>

diff --git a/drivers/gpu/drm/xe/tests/xe_bo.c b/drivers/gpu/drm/xe/tests/xe_bo.c
index 97788432a122e21aa6022ad2b7ff5c512a52cbb0..ad6dd6fae853b20b9a92fe22d320ceeb9125d8b8 100644 (file)
--- a/drivers/gpu/drm/xe/tests/xe_bo.c
+++ b/drivers/gpu/drm/xe/tests/xe_bo.c
@@ -180,7 +180,6 @@ static int evict_test_run_tile(struct xe_device *xe, struct xe_tile *tile, struc
        unsigned int bo_flags = XE_BO_CREATE_USER_BIT |
                XE_BO_CREATE_VRAM_IF_DGFX(tile);
        struct xe_vm *vm = xe_migrate_get_vm(xe_device_get_root_tile(xe)->migrate);
-       struct ww_acquire_ctx ww;
        struct xe_gt *__gt;
        int err, i, id;
 
@@ -188,10 +187,10 @@ static int evict_test_run_tile(struct xe_device *xe, struct xe_tile *tile, struc
                   dev_name(xe->drm.dev), tile->id);
 
        for (i = 0; i < 2; ++i) {
-               xe_vm_lock(vm, &ww, 0, false);
+               xe_vm_lock(vm, false);
                bo = xe_bo_create(xe, NULL, vm, 0x10000, ttm_bo_type_device,
                                  bo_flags);
-               xe_vm_unlock(vm, &ww);
+               xe_vm_unlock(vm);
                if (IS_ERR(bo)) {
                        KUNIT_FAIL(test, "bo create err=%pe\n", bo);
                        break;
@@ -263,9 +262,9 @@ static int evict_test_run_tile(struct xe_device *xe, struct xe_tile *tile, struc
 
                if (i) {
                        down_read(&vm->lock);
-                       xe_vm_lock(vm, &ww, 0, false);
+                       xe_vm_lock(vm, false);
                        err = xe_bo_validate(bo, bo->vm, false);
-                       xe_vm_unlock(vm, &ww);
+                       xe_vm_unlock(vm);
                        up_read(&vm->lock);
                        if (err) {
                                KUNIT_FAIL(test, "bo valid err=%pe\n",

diff --git a/drivers/gpu/drm/xe/tests/xe_migrate.c b/drivers/gpu/drm/xe/tests/xe_migrate.c
index 5c8d5e78d9bc4a582cd001ab49586b9a0d090ac5..8bb081086ca2e558a13961a97c2c75062bf4fe9b 100644 (file)
--- a/drivers/gpu/drm/xe/tests/xe_migrate.c
+++ b/drivers/gpu/drm/xe/tests/xe_migrate.c
@@ -396,14 +396,13 @@ static int migrate_test_run_device(struct xe_device *xe)
 
        for_each_tile(tile, xe, id) {
                struct xe_migrate *m = tile->migrate;
-               struct ww_acquire_ctx ww;
 
                kunit_info(test, "Testing tile id %d.\n", id);
-               xe_vm_lock(m->q->vm, &ww, 0, true);
+               xe_vm_lock(m->q->vm, true);
                xe_device_mem_access_get(xe);
                xe_migrate_sanity_test(m, test);
                xe_device_mem_access_put(xe);
-               xe_vm_unlock(m->q->vm, &ww);
+               xe_vm_unlock(m->q->vm);
        }
 
        return 0;

diff --git a/drivers/gpu/drm/xe/xe_bo.c b/drivers/gpu/drm/xe/xe_bo.c
index ee8e3c940cf4e2b36fafd39e0816f8e0e3eeda4a..c33a20420022443aeda1825506baff30c8057824 100644 (file)
--- a/drivers/gpu/drm/xe/xe_bo.c
+++ b/drivers/gpu/drm/xe/xe_bo.c
@@ -1759,7 +1759,6 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data,
        struct xe_device *xe = to_xe_device(dev);
        struct xe_file *xef = to_xe_file(file);
        struct drm_xe_gem_create *args = data;
-       struct ww_acquire_ctx ww;
        struct xe_vm *vm = NULL;
        struct xe_bo *bo;
        unsigned int bo_flags = XE_BO_CREATE_USER_BIT;
@@ -1812,7 +1811,7 @@ int xe_gem_create_ioctl(struct drm_device *dev, void *data,
                vm = xe_vm_lookup(xef, args->vm_id);
                if (XE_IOCTL_DBG(xe, !vm))
                        return -ENOENT;
-               err = xe_vm_lock(vm, &ww, 0, true);
+               err = xe_vm_lock(vm, true);
                if (err) {
                        xe_vm_put(vm);
                        return err;
@@ -1840,7 +1839,7 @@ out_put:
        xe_bo_put(bo);
 out_vm:
        if (vm) {
-               xe_vm_unlock(vm, &ww);
+               xe_vm_unlock(vm);
                xe_vm_put(vm);
        }
        return err;

diff --git a/drivers/gpu/drm/xe/xe_exec_queue.c b/drivers/gpu/drm/xe/xe_exec_queue.c
index f28bceceb99aead6ca4e30b6ccc63a601cabd53a..a0b5647923acf38412ff10e580c12e01103958a3 100644 (file)
--- a/drivers/gpu/drm/xe/xe_exec_queue.c
+++ b/drivers/gpu/drm/xe/xe_exec_queue.c
@@ -111,18 +111,17 @@ struct xe_exec_queue *xe_exec_queue_create(struct xe_device *xe, struct xe_vm *v
                                           u32 logical_mask, u16 width,
                                           struct xe_hw_engine *hwe, u32 flags)
 {
-       struct ww_acquire_ctx ww;
        struct xe_exec_queue *q;
        int err;
 
        if (vm) {
-               err = xe_vm_lock(vm, &ww, 0, true);
+               err = xe_vm_lock(vm, true);
                if (err)
                        return ERR_PTR(err);
        }
        q = __xe_exec_queue_create(xe, vm, logical_mask, width, hwe, flags);
        if (vm)
-               xe_vm_unlock(vm, &ww);
+               xe_vm_unlock(vm);
 
        return q;
 }

diff --git a/drivers/gpu/drm/xe/xe_lrc.c b/drivers/gpu/drm/xe/xe_lrc.c
index 2b4219c3835934cdcb6b8ea97aff7290d06d920f..434fbb364b4bf257cbedfa38ca0d5aff903ecef5 100644 (file)
--- a/drivers/gpu/drm/xe/xe_lrc.c
+++ b/drivers/gpu/drm/xe/xe_lrc.c
@@ -789,16 +789,14 @@ err_lrc_finish:
 
 void xe_lrc_finish(struct xe_lrc *lrc)
 {
-       struct ww_acquire_ctx ww;
-
        xe_hw_fence_ctx_finish(&lrc->fence_ctx);
        if (lrc->bo->vm)
-               xe_vm_lock(lrc->bo->vm, &ww, 0, false);
+               xe_vm_lock(lrc->bo->vm, false);
        else
                xe_bo_lock_no_vm(lrc->bo, NULL);
        xe_bo_unpin(lrc->bo);
        if (lrc->bo->vm)
-               xe_vm_unlock(lrc->bo->vm, &ww);
+               xe_vm_unlock(lrc->bo->vm);
        else
                xe_bo_unlock_no_vm(lrc->bo);
        xe_bo_put(lrc->bo);

diff --git a/drivers/gpu/drm/xe/xe_migrate.c b/drivers/gpu/drm/xe/xe_migrate.c
index 799ad020927955d11144e8982f7ed730a0e5658d..8291798e1aaa5f1df1db40c8a6c701e08a234dc3 100644 (file)
--- a/drivers/gpu/drm/xe/xe_migrate.c
+++ b/drivers/gpu/drm/xe/xe_migrate.c
@@ -88,13 +88,12 @@ struct xe_exec_queue *xe_tile_migrate_engine(struct xe_tile *tile)
 static void xe_migrate_fini(struct drm_device *dev, void *arg)
 {
        struct xe_migrate *m = arg;
-       struct ww_acquire_ctx ww;
 
-       xe_vm_lock(m->q->vm, &ww, 0, false);
+       xe_vm_lock(m->q->vm, false);
        xe_bo_unpin(m->pt_bo);
        if (m->cleared_bo)
                xe_bo_unpin(m->cleared_bo);
-       xe_vm_unlock(m->q->vm, &ww);
+       xe_vm_unlock(m->q->vm);
 
        dma_fence_put(m->fence);
        if (m->cleared_bo)
@@ -338,7 +337,6 @@ struct xe_migrate *xe_migrate_init(struct xe_tile *tile)
        struct xe_gt *primary_gt = tile->primary_gt;
        struct xe_migrate *m;
        struct xe_vm *vm;
-       struct ww_acquire_ctx ww;
        int err;
 
        m = drmm_kzalloc(&xe->drm, sizeof(*m), GFP_KERNEL);
@@ -353,9 +351,9 @@ struct xe_migrate *xe_migrate_init(struct xe_tile *tile)
        if (IS_ERR(vm))
                return ERR_CAST(vm);
 
-       xe_vm_lock(vm, &ww, 0, false);
+       xe_vm_lock(vm, false);
        err = xe_migrate_prepare_vm(tile, m, vm);
-       xe_vm_unlock(vm, &ww);
+       xe_vm_unlock(vm);
        if (err) {
                xe_vm_close_and_put(vm);
                return ERR_PTR(err);

diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
index 2bd1fa34256a4a9f97e01f26f2c9b1e478c6b10d..0ac421c4e1847c57c9a4e164f23d4e07fe81bbb8 100644 (file)
--- a/drivers/gpu/drm/xe/xe_vm.c
+++ b/drivers/gpu/drm/xe/xe_vm.c
@@ -523,18 +523,17 @@ void xe_vm_unlock_dma_resv(struct xe_vm *vm,
 
 static void xe_vm_kill(struct xe_vm *vm)
 {
-       struct ww_acquire_ctx ww;
        struct xe_exec_queue *q;
 
        lockdep_assert_held(&vm->lock);
 
-       xe_vm_lock(vm, &ww, 0, false);
+       xe_vm_lock(vm, false);
        vm->flags |= XE_VM_FLAG_BANNED;
        trace_xe_vm_kill(vm);
 
        list_for_each_entry(q, &vm->preempt.exec_queues, compute.link)
                q->ops->kill(q);
-       xe_vm_unlock(vm, &ww);
+       xe_vm_unlock(vm);
 
        /* TODO: Inform user the VM is banned */
 }
@@ -1420,7 +1419,6 @@ static void xe_vm_close(struct xe_vm *vm)
 void xe_vm_close_and_put(struct xe_vm *vm)
 {
        LIST_HEAD(contested);
-       struct ww_acquire_ctx ww;
        struct xe_device *xe = vm->xe;
        struct xe_tile *tile;
        struct xe_vma *vma, *next_vma;
@@ -1443,7 +1441,7 @@ void xe_vm_close_and_put(struct xe_vm *vm)
        }
 
        down_write(&vm->lock);
-       xe_vm_lock(vm, &ww, 0, false);
+       xe_vm_lock(vm, false);
        drm_gpuvm_for_each_va_safe(gpuva, next, &vm->gpuvm) {
                vma = gpuva_to_vma(gpuva);
 
@@ -1488,7 +1486,7 @@ void xe_vm_close_and_put(struct xe_vm *vm)
                        vm->pt_root[id] = NULL;
                }
        }
-       xe_vm_unlock(vm, &ww);
+       xe_vm_unlock(vm);
 
        /*
         * VM is now dead, cannot re-add nodes to vm->vmas if it's NULL
@@ -3442,30 +3440,32 @@ free_objs:
        return err == -ENODATA ? 0 : err;
 }
 
-/*
- * XXX: Using the TTM wrappers for now, likely can call into dma-resv code
- * directly to optimize. Also this likely should be an inline function.
+/**
+ * xe_vm_lock() - Lock the vm's dma_resv object
+ * @vm: The struct xe_vm whose lock is to be locked
+ * @intr: Whether to perform any wait interruptible
+ *
+ * Return: 0 on success, -EINTR if @intr is true and the wait for a
+ * contended lock was interrupted. If @intr is false, the function
+ * always returns 0.
  */
-int xe_vm_lock(struct xe_vm *vm, struct ww_acquire_ctx *ww,
-              int num_resv, bool intr)
+int xe_vm_lock(struct xe_vm *vm, bool intr)
 {
-       struct ttm_validate_buffer tv_vm;
-       LIST_HEAD(objs);
-       LIST_HEAD(dups);
+       if (intr)
+               return dma_resv_lock_interruptible(xe_vm_resv(vm), NULL);
 
-       XE_WARN_ON(!ww);
-
-       tv_vm.num_shared = num_resv;
-       tv_vm.bo = xe_vm_ttm_bo(vm);
-       list_add_tail(&tv_vm.head, &objs);
-
-       return ttm_eu_reserve_buffers(ww, &objs, intr, &dups);
+       return dma_resv_lock(xe_vm_resv(vm), NULL);
 }
 
-void xe_vm_unlock(struct xe_vm *vm, struct ww_acquire_ctx *ww)
+/**
+ * xe_vm_unlock() - Unlock the vm's dma_resv object
+ * @vm: The struct xe_vm whose lock is to be released.
+ *
+ * Unlock a buffer object lock that was locked by xe_vm_lock().
+ */
+void xe_vm_unlock(struct xe_vm *vm)
 {
        dma_resv_unlock(xe_vm_resv(vm));
-       ww_acquire_fini(ww);
 }
 
 /**

diff --git a/drivers/gpu/drm/xe/xe_vm.h b/drivers/gpu/drm/xe/xe_vm.h
index 805236578140cf2a590a73c81f1a36344e0d5d38..dd20e5c8106f0b0b39fa66bf3b8090a1a9957c18 100644 (file)
--- a/drivers/gpu/drm/xe/xe_vm.h
+++ b/drivers/gpu/drm/xe/xe_vm.h
@@ -38,10 +38,9 @@ static inline void xe_vm_put(struct xe_vm *vm)
        drm_gpuvm_put(&vm->gpuvm);
 }
 
-int xe_vm_lock(struct xe_vm *vm, struct ww_acquire_ctx *ww,
-              int num_resv, bool intr);
+int xe_vm_lock(struct xe_vm *vm, bool intr);
 
-void xe_vm_unlock(struct xe_vm *vm, struct ww_acquire_ctx *ww);
+void xe_vm_unlock(struct xe_vm *vm);
 
 static inline bool xe_vm_is_closed(struct xe_vm *vm)
 {