Nouveau - Sep 2023 - [PATCH drm-misc-next v4 1/8] drm/gpuvm: rename struct drm_gpuva_manager to struct drm_gpuvm

Rename struct drm_gpuva_manager to struct drm_gpuvm including
corresponding functions. This way the GPUVA manager's structures align
very well with the documentation of VM_BIND [1] and VM_BIND locking [2].

It also provides a better foundation for the naming of data structures
and functions introduced for implementing a common dma-resv per GPU-VM
including tracking of external and evicted objects in subsequent
patches.

[1] Documentation/gpu/drm-vm-bind-async.rst
[2] Documentation/gpu/drm-vm-bind-locking.rst

Cc: Thomas Hellstr?m <thomas.hellstrom at linux.intel.com>
Cc: Matthew Brost <matthew.brost at intel.com>
Signed-off-by: Danilo Krummrich <dakr at redhat.com>
---
 drivers/gpu/drm/Makefile                      |   2 +-
 drivers/gpu/drm/drm_debugfs.c                 |  16 +-
 .../gpu/drm/{drm_gpuva_mgr.c => drm_gpuvm.c}  | 400 +++++++++---------
 drivers/gpu/drm/nouveau/nouveau_exec.c        |   2 +-
 drivers/gpu/drm/nouveau/nouveau_uvmm.c        |  24 +-
 drivers/gpu/drm/nouveau/nouveau_uvmm.h        |   6 +-
 include/drm/drm_debugfs.h                     |   6 +-
 include/drm/{drm_gpuva_mgr.h => drm_gpuvm.h}  | 153 ++++---
 8 files changed, 304 insertions(+), 305 deletions(-)
 rename drivers/gpu/drm/{drm_gpuva_mgr.c => drm_gpuvm.c} (78%)
 rename include/drm/{drm_gpuva_mgr.h => drm_gpuvm.h} (78%)

diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
index 215e78e79125..7a84b3cddeab 100644
--- a/drivers/gpu/drm/Makefile
+++ b/drivers/gpu/drm/Makefile
@@ -45,7 +45,7 @@ drm-y := \
 	drm_vblank.o \
 	drm_vblank_work.o \
 	drm_vma_manager.o \
-	drm_gpuva_mgr.o \
+	drm_gpuvm.o \
 	drm_writeback.o
 drm-$(CONFIG_DRM_LEGACY) += \
 	drm_agpsupport.o \
diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
index 44ecd7d0daac..f291fb4b359f 100644
--- a/drivers/gpu/drm/drm_debugfs.c
+++ b/drivers/gpu/drm/drm_debugfs.c
@@ -40,7 +40,7 @@
 #include <drm/drm_file.h>
 #include <drm/drm_gem.h>
 #include <drm/drm_managed.h>
-#include <drm/drm_gpuva_mgr.h>
+#include <drm/drm_gpuvm.h>
 
 #include "drm_crtc_internal.h"
 #include "drm_internal.h"
@@ -189,31 +189,31 @@ static const struct file_operations drm_debugfs_fops = {
 /**
  * drm_debugfs_gpuva_info - dump the given DRM GPU VA space
  * @m: pointer to the &seq_file to write
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  *
  * Dumps the GPU VA mappings of a given DRM GPU VA manager.
  *
  * For each DRM GPU VA space drivers should call this function from their
  * &drm_info_list's show callback.
  *
- * Returns: 0 on success, -ENODEV if the &mgr is not initialized
+ * Returns: 0 on success, -ENODEV if the &gpuvm is not initialized
  */
 int drm_debugfs_gpuva_info(struct seq_file *m,
-			   struct drm_gpuva_manager *mgr)
+			   struct drm_gpuvm *gpuvm)
 {
-	struct drm_gpuva *va, *kva = &mgr->kernel_alloc_node;
+	struct drm_gpuva *va, *kva = &gpuvm->kernel_alloc_node;
 
-	if (!mgr->name)
+	if (!gpuvm->name)
 		return -ENODEV;
 
 	seq_printf(m, "DRM GPU VA space (%s) [0x%016llx;0x%016llx]\n",
-		   mgr->name, mgr->mm_start, mgr->mm_start + mgr->mm_range);
+		   gpuvm->name, gpuvm->mm_start, gpuvm->mm_start +
gpuvm->mm_range);
 	seq_printf(m, "Kernel reserved node [0x%016llx;0x%016llx]\n",
 		   kva->va.addr, kva->va.addr + kva->va.range);
 	seq_puts(m, "\n");
 	seq_puts(m, " VAs | start              | range              | end        
| object             | object offset\n");
 	seq_puts(m,
"-------------------------------------------------------------------------------------------------------------\n");
-	drm_gpuva_for_each_va(va, mgr) {
+	drm_gpuvm_for_each_va(va, gpuvm) {
 		if (unlikely(va == kva))
 			continue;
 
diff --git a/drivers/gpu/drm/drm_gpuva_mgr.c b/drivers/gpu/drm/drm_gpuvm.c
similarity index 78%
rename from drivers/gpu/drm/drm_gpuva_mgr.c
rename to drivers/gpu/drm/drm_gpuvm.c
index f86bfad74ff8..7074bcad5b28 100644
--- a/drivers/gpu/drm/drm_gpuva_mgr.c
+++ b/drivers/gpu/drm/drm_gpuvm.c
@@ -25,7 +25,7 @@
  *
  */
 
-#include <drm/drm_gpuva_mgr.h>
+#include <drm/drm_gpuvm.h>
 
 #include <linux/interval_tree_generic.h>
 #include <linux/mm.h>
@@ -33,8 +33,8 @@
 /**
  * DOC: Overview
  *
- * The DRM GPU VA Manager, represented by struct drm_gpuva_manager keeps track
- * of a GPU's virtual address (VA) space and manages the corresponding
virtual
+ * The DRM GPU VA Manager, represented by struct drm_gpuvm keeps track of a
+ * GPU's virtual address (VA) space and manages the corresponding virtual
  * mappings represented by &drm_gpuva objects. It also keeps track of the
  * mapping's backing &drm_gem_object buffers.
  *
@@ -47,28 +47,28 @@
  * The GPU VA manager internally uses a rb-tree to manage the
  * &drm_gpuva mappings within a GPU's virtual address space.
  *
- * The &drm_gpuva_manager contains a special &drm_gpuva representing
the
+ * The &drm_gpuvm structure contains a special &drm_gpuva representing
the
  * portion of VA space reserved by the kernel. This node is initialized
together
  * with the GPU VA manager instance and removed when the GPU VA manager is
  * destroyed.
  *
- * In a typical application drivers would embed struct drm_gpuva_manager and
+ * In a typical application drivers would embed struct drm_gpuvm and
  * struct drm_gpuva within their own driver specific structures, there
won't be
  * any memory allocations of its own nor memory allocations of &drm_gpuva
  * entries.
  *
- * The data structures needed to store &drm_gpuvas within the
&drm_gpuva_manager
- * are contained within struct drm_gpuva already. Hence, for inserting
- * &drm_gpuva entries from within dma-fence signalling critical sections it
is
- * enough to pre-allocate the &drm_gpuva structures.
+ * The data structures needed to store &drm_gpuvas within the
&drm_gpuvm are
+ * contained within struct drm_gpuva already. Hence, for inserting
&drm_gpuva
+ * entries from within dma-fence signalling critical sections it is enough to
+ * pre-allocate the &drm_gpuva structures.
  */
 
 /**
  * DOC: Split and Merge
  *
  * Besides its capability to manage and represent a GPU VA space, the
- * &drm_gpuva_manager also provides functions to let the
&drm_gpuva_manager
- * calculate a sequence of operations to satisfy a given map or unmap request.
+ * GPU VA manager also provides functions to let the &drm_gpuvm calculate a
+ * sequence of operations to satisfy a given map or unmap request.
  *
  * Therefore the DRM GPU VA manager provides an algorithm implementing
splitting
  * and merging of existent GPU VA mappings with the ones that are requested to
@@ -76,16 +76,16 @@
  * implement Vulkan 'Sparse Memory Bindings' - drivers UAPIs often
refer to this
  * as VM BIND.
  *
- * Drivers can call drm_gpuva_sm_map() to receive a sequence of callbacks
+ * Drivers can call drm_gpuvm_sm_map() to receive a sequence of callbacks
  * containing map, unmap and remap operations for a given newly requested
  * mapping. The sequence of callbacks represents the set of operations to
  * execute in order to integrate the new mapping cleanly into the current state
  * of the GPU VA space.
  *
  * Depending on how the new GPU VA mapping intersects with the existent
mappings
- * of the GPU VA space the &drm_gpuva_fn_ops callbacks contain an arbitrary
- * amount of unmap operations, a maximum of two remap operations and a single
- * map operation. The caller might receive no callback at all if no operation
is
+ * of the GPU VA space the &drm_gpuvm_ops callbacks contain an arbitrary
amount
+ * of unmap operations, a maximum of two remap operations and a single map
+ * operation. The caller might receive no callback at all if no operation is
  * required, e.g. if the requested mapping already exists in the exact same
way.
  *
  * The single map operation represents the original map operation requested by
@@ -95,7 +95,7 @@
  * &drm_gpuva to unmap is physically contiguous with the original mapping
  * request. Optionally, if 'keep' is set, drivers may keep the actual
page table
  * entries for this &drm_gpuva, adding the missing page table entries only
and
- * update the &drm_gpuva_manager's view of things accordingly.
+ * update the &drm_gpuvm's view of things accordingly.
  *
  * Drivers may do the same optimization, namely delta page table updates, also
  * for remap operations. This is possible since &drm_gpuva_op_remap
consists of
@@ -106,34 +106,34 @@
  * the beginning and one at the end of the new mapping, hence there is a
  * maximum of two remap operations.
  *
- * Analogous to drm_gpuva_sm_map() drm_gpuva_sm_unmap() uses
&drm_gpuva_fn_ops
- * to call back into the driver in order to unmap a range of GPU VA space. The
+ * Analogous to drm_gpuvm_sm_map() drm_gpuvm_sm_unmap() uses &drm_gpuvm_ops
to
+ * call back into the driver in order to unmap a range of GPU VA space. The
  * logic behind this function is way simpler though: For all existent mappings
  * enclosed by the given range unmap operations are created. For mappings which
  * are only partically located within the given range, remap operations are
  * created such that those mappings are split up and re-mapped partically.
  *
- * As an alternative to drm_gpuva_sm_map() and drm_gpuva_sm_unmap(),
- * drm_gpuva_sm_map_ops_create() and drm_gpuva_sm_unmap_ops_create() can be
used
+ * As an alternative to drm_gpuvm_sm_map() and drm_gpuvm_sm_unmap(),
+ * drm_gpuvm_sm_map_ops_create() and drm_gpuvm_sm_unmap_ops_create() can be
used
  * to directly obtain an instance of struct drm_gpuva_ops containing a list of
  * &drm_gpuva_op, which can be iterated with drm_gpuva_for_each_op(). This
list
  * contains the &drm_gpuva_ops analogous to the callbacks one would receive
when
- * calling drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). While this way requires
+ * calling drm_gpuvm_sm_map() or drm_gpuvm_sm_unmap(). While this way requires
  * more memory (to allocate the &drm_gpuva_ops), it provides drivers a way
to
  * iterate the &drm_gpuva_op multiple times, e.g. once in a context where
memory
  * allocations are possible (e.g. to allocate GPU page tables) and once in the
  * dma-fence signalling critical path.
  *
- * To update the &drm_gpuva_manager's view of the GPU VA space
- * drm_gpuva_insert() and drm_gpuva_remove() may be used. These functions can
- * safely be used from &drm_gpuva_fn_ops callbacks originating from
- * drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). However, it might be more
- * convenient to use the provided helper functions drm_gpuva_map(),
- * drm_gpuva_remap() and drm_gpuva_unmap() instead.
+ * To update the &drm_gpuvm's view of the GPU VA space
drm_gpuva_insert() and
+ * drm_gpuva_remove() may be used. These functions can safely be used from
+ * &drm_gpuvm_ops callbacks originating from drm_gpuvm_sm_map() or
+ * drm_gpuvm_sm_unmap(). However, it might be more convenient to use the
+ * provided helper functions drm_gpuva_map(), drm_gpuva_remap() and
+ * drm_gpuva_unmap() instead.
  *
  * The following diagram depicts the basic relationships of existent GPU VA
  * mappings, a newly requested mapping and the resulting mappings as
implemented
- * by drm_gpuva_sm_map() - it doesn't cover any arbitrary combinations of
these.
+ * by drm_gpuvm_sm_map() - it doesn't cover any arbitrary combinations of
these.
  *
  * 1) Requested mapping is identical. Replace it, but indicate the backing PTEs
  *    could be kept.
@@ -421,10 +421,10 @@
  *	// Allocates a new &drm_gpuva.
  *	struct drm_gpuva * driver_gpuva_alloc(void);
  *
- *	// Typically drivers would embedd the &drm_gpuva_manager and
&drm_gpuva
+ *	// Typically drivers would embedd the &drm_gpuvm and &drm_gpuva
  *	// structure in individual driver structures and lock the dma-resv with
  *	// drm_exec or similar helpers.
- *	int driver_mapping_create(struct drm_gpuva_manager *mgr,
+ *	int driver_mapping_create(struct drm_gpuvm *gpuvm,
  *				  u64 addr, u64 range,
  *				  struct drm_gem_object *obj, u64 offset)
  *	{
@@ -432,7 +432,7 @@
  *		struct drm_gpuva_op *op
  *
  *		driver_lock_va_space();
- *		ops = drm_gpuva_sm_map_ops_create(mgr, addr, range,
+ *		ops = drm_gpuvm_sm_map_ops_create(gpuvm, addr, range,
  *						  obj, offset);
  *		if (IS_ERR(ops))
  *			return PTR_ERR(ops);
@@ -448,7 +448,7 @@
  *					  // free memory and unlock
  *
  *				driver_vm_map();
- *				drm_gpuva_map(mgr, va, &op->map);
+ *				drm_gpuva_map(gpuvm, va, &op->map);
  *				drm_gpuva_link(va);
  *
  *				break;
@@ -504,23 +504,23 @@
  * 2) Receive a callback for each &drm_gpuva_op to create a new mapping::
  *
  *	struct driver_context {
- *		struct drm_gpuva_manager *mgr;
+ *		struct drm_gpuvm *gpuvm;
  *		struct drm_gpuva *new_va;
  *		struct drm_gpuva *prev_va;
  *		struct drm_gpuva *next_va;
  *	};
  *
- *	// ops to pass to drm_gpuva_manager_init()
- *	static const struct drm_gpuva_fn_ops driver_gpuva_ops = {
+ *	// ops to pass to drm_gpuvm_init()
+ *	static const struct drm_gpuvm_ops driver_gpuvm_ops = {
  *		.sm_step_map = driver_gpuva_map,
  *		.sm_step_remap = driver_gpuva_remap,
  *		.sm_step_unmap = driver_gpuva_unmap,
  *	};
  *
- *	// Typically drivers would embedd the &drm_gpuva_manager and
&drm_gpuva
+ *	// Typically drivers would embedd the &drm_gpuvm and &drm_gpuva
  *	// structure in individual driver structures and lock the dma-resv with
  *	// drm_exec or similar helpers.
- *	int driver_mapping_create(struct drm_gpuva_manager *mgr,
+ *	int driver_mapping_create(struct drm_gpuvm *gpuvm,
  *				  u64 addr, u64 range,
  *				  struct drm_gem_object *obj, u64 offset)
  *	{
@@ -529,7 +529,7 @@
  *		struct drm_gpuva_op *op;
  *		int ret = 0;
  *
- *		ctx.mgr = mgr;
+ *		ctx.gpuvm = gpuvm;
  *
  *		ctx.new_va = kzalloc(sizeof(*ctx.new_va), GFP_KERNEL);
  *		ctx.prev_va = kzalloc(sizeof(*ctx.prev_va), GFP_KERNEL);
@@ -540,7 +540,7 @@
  *		}
  *
  *		driver_lock_va_space();
- *		ret = drm_gpuva_sm_map(mgr, &ctx, addr, range, obj, offset);
+ *		ret = drm_gpuvm_sm_map(gpuvm, &ctx, addr, range, obj, offset);
  *		driver_unlock_va_space();
  *
  *	out:
@@ -554,7 +554,7 @@
  *	{
  *		struct driver_context *ctx = __ctx;
  *
- *		drm_gpuva_map(ctx->mgr, ctx->new_va, &op->map);
+ *		drm_gpuva_map(ctx->vm, ctx->new_va, &op->map);
  *
  *		drm_gpuva_link(ctx->new_va);
  *
@@ -609,12 +609,12 @@ INTERVAL_TREE_DEFINE(struct drm_gpuva, rb.node, u64,
rb.__subtree_last,
 		     GPUVA_START, GPUVA_LAST, static __maybe_unused,
 		     drm_gpuva_it)
 
-static int __drm_gpuva_insert(struct drm_gpuva_manager *mgr,
+static int __drm_gpuva_insert(struct drm_gpuvm *gpuvm,
 			      struct drm_gpuva *va);
 static void __drm_gpuva_remove(struct drm_gpuva *va);
 
 static bool
-drm_gpuva_check_overflow(u64 addr, u64 range)
+drm_gpuvm_check_overflow(u64 addr, u64 range)
 {
 	u64 end;
 
@@ -623,121 +623,121 @@ drm_gpuva_check_overflow(u64 addr, u64 range)
 }
 
 static bool
-drm_gpuva_in_mm_range(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
+drm_gpuvm_in_mm_range(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
 {
 	u64 end = addr + range;
-	u64 mm_start = mgr->mm_start;
-	u64 mm_end = mm_start + mgr->mm_range;
+	u64 mm_start = gpuvm->mm_start;
+	u64 mm_end = mm_start + gpuvm->mm_range;
 
 	return addr >= mm_start && end <= mm_end;
 }
 
 static bool
-drm_gpuva_in_kernel_node(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
+drm_gpuvm_in_kernel_node(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
 {
 	u64 end = addr + range;
-	u64 kstart = mgr->kernel_alloc_node.va.addr;
-	u64 krange = mgr->kernel_alloc_node.va.range;
+	u64 kstart = gpuvm->kernel_alloc_node.va.addr;
+	u64 krange = gpuvm->kernel_alloc_node.va.range;
 	u64 kend = kstart + krange;
 
 	return krange && addr < kend && kstart < end;
 }
 
 static bool
-drm_gpuva_range_valid(struct drm_gpuva_manager *mgr,
+drm_gpuva_range_valid(struct drm_gpuvm *gpuvm,
 		      u64 addr, u64 range)
 {
-	return !drm_gpuva_check_overflow(addr, range) &&
-	       drm_gpuva_in_mm_range(mgr, addr, range) &&
-	       !drm_gpuva_in_kernel_node(mgr, addr, range);
+	return !drm_gpuvm_check_overflow(addr, range) &&
+	       drm_gpuvm_in_mm_range(gpuvm, addr, range) &&
+	       !drm_gpuvm_in_kernel_node(gpuvm, addr, range);
 }
 
 /**
- * drm_gpuva_manager_init() - initialize a &drm_gpuva_manager
- * @mgr: pointer to the &drm_gpuva_manager to initialize
+ * drm_gpuvm_init() - initialize a &drm_gpuvm
+ * @gpuvm: pointer to the &drm_gpuvm to initialize
  * @name: the name of the GPU VA space
  * @start_offset: the start offset of the GPU VA space
  * @range: the size of the GPU VA space
  * @reserve_offset: the start of the kernel reserved GPU VA area
  * @reserve_range: the size of the kernel reserved GPU VA area
- * @ops: &drm_gpuva_fn_ops called on &drm_gpuva_sm_map /
&drm_gpuva_sm_unmap
+ * @ops: &drm_gpuvm_ops called on &drm_gpuvm_sm_map /
&drm_gpuvm_sm_unmap
  *
- * The &drm_gpuva_manager must be initialized with this function before
use.
+ * The &drm_gpuvm must be initialized with this function before use.
  *
- * Note that @mgr must be cleared to 0 before calling this function. The given
+ * Note that @gpuvm must be cleared to 0 before calling this function. The
given
  * &name is expected to be managed by the surrounding driver structures.
  */
 void
-drm_gpuva_manager_init(struct drm_gpuva_manager *mgr,
-		       const char *name,
-		       u64 start_offset, u64 range,
-		       u64 reserve_offset, u64 reserve_range,
-		       const struct drm_gpuva_fn_ops *ops)
+drm_gpuvm_init(struct drm_gpuvm *gpuvm,
+	       const char *name,
+	       u64 start_offset, u64 range,
+	       u64 reserve_offset, u64 reserve_range,
+	       const struct drm_gpuvm_ops *ops)
 {
-	mgr->rb.tree = RB_ROOT_CACHED;
-	INIT_LIST_HEAD(&mgr->rb.list);
+	gpuvm->rb.tree = RB_ROOT_CACHED;
+	INIT_LIST_HEAD(&gpuvm->rb.list);
 
-	drm_gpuva_check_overflow(start_offset, range);
-	mgr->mm_start = start_offset;
-	mgr->mm_range = range;
+	drm_gpuvm_check_overflow(start_offset, range);
+	gpuvm->mm_start = start_offset;
+	gpuvm->mm_range = range;
 
-	mgr->name = name ? name : "unknown";
-	mgr->ops = ops;
+	gpuvm->name = name ? name : "unknown";
+	gpuvm->ops = ops;
 
-	memset(&mgr->kernel_alloc_node, 0, sizeof(struct drm_gpuva));
+	memset(&gpuvm->kernel_alloc_node, 0, sizeof(struct drm_gpuva));
 
 	if (reserve_range) {
-		mgr->kernel_alloc_node.va.addr = reserve_offset;
-		mgr->kernel_alloc_node.va.range = reserve_range;
+		gpuvm->kernel_alloc_node.va.addr = reserve_offset;
+		gpuvm->kernel_alloc_node.va.range = reserve_range;
 
-		if (likely(!drm_gpuva_check_overflow(reserve_offset,
+		if (likely(!drm_gpuvm_check_overflow(reserve_offset,
 						     reserve_range)))
-			__drm_gpuva_insert(mgr, &mgr->kernel_alloc_node);
+			__drm_gpuva_insert(gpuvm, &gpuvm->kernel_alloc_node);
 	}
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_manager_init);
+EXPORT_SYMBOL_GPL(drm_gpuvm_init);
 
 /**
- * drm_gpuva_manager_destroy() - cleanup a &drm_gpuva_manager
- * @mgr: pointer to the &drm_gpuva_manager to clean up
+ * drm_gpuvm_destroy() - cleanup a &drm_gpuvm
+ * @gpuvm: pointer to the &drm_gpuvm to clean up
  *
  * Note that it is a bug to call this function on a manager that still
  * holds GPU VA mappings.
  */
 void
-drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr)
+drm_gpuvm_destroy(struct drm_gpuvm *gpuvm)
 {
-	mgr->name = NULL;
+	gpuvm->name = NULL;
 
-	if (mgr->kernel_alloc_node.va.range)
-		__drm_gpuva_remove(&mgr->kernel_alloc_node);
+	if (gpuvm->kernel_alloc_node.va.range)
+		__drm_gpuva_remove(&gpuvm->kernel_alloc_node);
 
-	WARN(!RB_EMPTY_ROOT(&mgr->rb.tree.rb_root),
+	WARN(!RB_EMPTY_ROOT(&gpuvm->rb.tree.rb_root),
 	     "GPUVA tree is not empty, potentially leaking memory.");
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_manager_destroy);
+EXPORT_SYMBOL_GPL(drm_gpuvm_destroy);
 
 static int
-__drm_gpuva_insert(struct drm_gpuva_manager *mgr,
+__drm_gpuva_insert(struct drm_gpuvm *gpuvm,
 		   struct drm_gpuva *va)
 {
 	struct rb_node *node;
 	struct list_head *head;
 
-	if (drm_gpuva_it_iter_first(&mgr->rb.tree,
+	if (drm_gpuva_it_iter_first(&gpuvm->rb.tree,
 				    GPUVA_START(va),
 				    GPUVA_LAST(va)))
 		return -EEXIST;
 
-	va->mgr = mgr;
+	va->vm = gpuvm;
 
-	drm_gpuva_it_insert(va, &mgr->rb.tree);
+	drm_gpuva_it_insert(va, &gpuvm->rb.tree);
 
 	node = rb_prev(&va->rb.node);
 	if (node)
 		head = &(to_drm_gpuva(node))->rb.entry;
 	else
-		head = &mgr->rb.list;
+		head = &gpuvm->rb.list;
 
 	list_add(&va->rb.entry, head);
 
@@ -746,36 +746,36 @@ __drm_gpuva_insert(struct drm_gpuva_manager *mgr,
 
 /**
  * drm_gpuva_insert() - insert a &drm_gpuva
- * @mgr: the &drm_gpuva_manager to insert the &drm_gpuva in
+ * @gpuvm: the &drm_gpuvm to insert the &drm_gpuva in
  * @va: the &drm_gpuva to insert
  *
  * Insert a &drm_gpuva with a given address and range into a
- * &drm_gpuva_manager.
+ * &drm_gpuvm.
  *
  * It is safe to use this function using the safe versions of iterating the GPU
- * VA space, such as drm_gpuva_for_each_va_safe() and
- * drm_gpuva_for_each_va_range_safe().
+ * VA space, such as drm_gpuvm_for_each_va_safe() and
+ * drm_gpuvm_for_each_va_range_safe().
  *
  * Returns: 0 on success, negative error code on failure.
  */
 int
-drm_gpuva_insert(struct drm_gpuva_manager *mgr,
+drm_gpuva_insert(struct drm_gpuvm *gpuvm,
 		 struct drm_gpuva *va)
 {
 	u64 addr = va->va.addr;
 	u64 range = va->va.range;
 
-	if (unlikely(!drm_gpuva_range_valid(mgr, addr, range)))
+	if (unlikely(!drm_gpuva_range_valid(gpuvm, addr, range)))
 		return -EINVAL;
 
-	return __drm_gpuva_insert(mgr, va);
+	return __drm_gpuva_insert(gpuvm, va);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_insert);
 
 static void
 __drm_gpuva_remove(struct drm_gpuva *va)
 {
-	drm_gpuva_it_remove(va, &va->mgr->rb.tree);
+	drm_gpuva_it_remove(va, &va->vm->rb.tree);
 	list_del_init(&va->rb.entry);
 }
 
@@ -786,15 +786,15 @@ __drm_gpuva_remove(struct drm_gpuva *va)
  * This removes the given &va from the underlaying tree.
  *
  * It is safe to use this function using the safe versions of iterating the GPU
- * VA space, such as drm_gpuva_for_each_va_safe() and
- * drm_gpuva_for_each_va_range_safe().
+ * VA space, such as drm_gpuvm_for_each_va_safe() and
+ * drm_gpuvm_for_each_va_range_safe().
  */
 void
 drm_gpuva_remove(struct drm_gpuva *va)
 {
-	struct drm_gpuva_manager *mgr = va->mgr;
+	struct drm_gpuvm *gpuvm = va->vm;
 
-	if (unlikely(va == &mgr->kernel_alloc_node)) {
+	if (unlikely(va == &gpuvm->kernel_alloc_node)) {
 		WARN(1, "Can't destroy kernel reserved node.\n");
 		return;
 	}
@@ -853,37 +853,37 @@ EXPORT_SYMBOL_GPL(drm_gpuva_unlink);
 
 /**
  * drm_gpuva_find_first() - find the first &drm_gpuva in the given range
- * @mgr: the &drm_gpuva_manager to search in
+ * @gpuvm: the &drm_gpuvm to search in
  * @addr: the &drm_gpuvas address
  * @range: the &drm_gpuvas range
  *
  * Returns: the first &drm_gpuva within the given range
  */
 struct drm_gpuva *
-drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
+drm_gpuva_find_first(struct drm_gpuvm *gpuvm,
 		     u64 addr, u64 range)
 {
 	u64 last = addr + range - 1;
 
-	return drm_gpuva_it_iter_first(&mgr->rb.tree, addr, last);
+	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, addr, last);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_find_first);
 
 /**
  * drm_gpuva_find() - find a &drm_gpuva
- * @mgr: the &drm_gpuva_manager to search in
+ * @gpuvm: the &drm_gpuvm to search in
  * @addr: the &drm_gpuvas address
  * @range: the &drm_gpuvas range
  *
  * Returns: the &drm_gpuva at a given &addr and with a given &range
  */
 struct drm_gpuva *
-drm_gpuva_find(struct drm_gpuva_manager *mgr,
+drm_gpuva_find(struct drm_gpuvm *gpuvm,
 	       u64 addr, u64 range)
 {
 	struct drm_gpuva *va;
 
-	va = drm_gpuva_find_first(mgr, addr, range);
+	va = drm_gpuva_find_first(gpuvm, addr, range);
 	if (!va)
 		goto out;
 
@@ -900,7 +900,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find);
 
 /**
  * drm_gpuva_find_prev() - find the &drm_gpuva before the given address
- * @mgr: the &drm_gpuva_manager to search in
+ * @gpuvm: the &drm_gpuvm to search in
  * @start: the given GPU VA's start address
  *
  * Find the adjacent &drm_gpuva before the GPU VA with given &start
address.
@@ -911,18 +911,18 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find);
  * Returns: a pointer to the found &drm_gpuva or NULL if none was found
  */
 struct drm_gpuva *
-drm_gpuva_find_prev(struct drm_gpuva_manager *mgr, u64 start)
+drm_gpuva_find_prev(struct drm_gpuvm *gpuvm, u64 start)
 {
-	if (!drm_gpuva_range_valid(mgr, start - 1, 1))
+	if (!drm_gpuva_range_valid(gpuvm, start - 1, 1))
 		return NULL;
 
-	return drm_gpuva_it_iter_first(&mgr->rb.tree, start - 1, start);
+	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, start - 1, start);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_find_prev);
 
 /**
  * drm_gpuva_find_next() - find the &drm_gpuva after the given address
- * @mgr: the &drm_gpuva_manager to search in
+ * @gpuvm: the &drm_gpuvm to search in
  * @end: the given GPU VA's end address
  *
  * Find the adjacent &drm_gpuva after the GPU VA with given &end
address.
@@ -933,47 +933,47 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find_prev);
  * Returns: a pointer to the found &drm_gpuva or NULL if none was found
  */
 struct drm_gpuva *
-drm_gpuva_find_next(struct drm_gpuva_manager *mgr, u64 end)
+drm_gpuva_find_next(struct drm_gpuvm *gpuvm, u64 end)
 {
-	if (!drm_gpuva_range_valid(mgr, end, 1))
+	if (!drm_gpuva_range_valid(gpuvm, end, 1))
 		return NULL;
 
-	return drm_gpuva_it_iter_first(&mgr->rb.tree, end, end + 1);
+	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, end, end + 1);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_find_next);
 
 /**
  * drm_gpuva_interval_empty() - indicate whether a given interval of the VA
space
  * is empty
- * @mgr: the &drm_gpuva_manager to check the range for
+ * @gpuvm: the &drm_gpuvm to check the range for
  * @addr: the start address of the range
  * @range: the range of the interval
  *
  * Returns: true if the interval is empty, false otherwise
  */
 bool
-drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
+drm_gpuva_interval_empty(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
 {
-	return !drm_gpuva_find_first(mgr, addr, range);
+	return !drm_gpuva_find_first(gpuvm, addr, range);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_interval_empty);
 
 /**
  * drm_gpuva_map() - helper to insert a &drm_gpuva according to a
  * &drm_gpuva_op_map
- * @mgr: the &drm_gpuva_manager
+ * @gpuvm: the &drm_gpuvm
  * @va: the &drm_gpuva to insert
  * @op: the &drm_gpuva_op_map to initialize @va with
  *
- * Initializes the @va from the @op and inserts it into the given @mgr.
+ * Initializes the @va from the @op and inserts it into the given @gpuvm.
  */
 void
-drm_gpuva_map(struct drm_gpuva_manager *mgr,
+drm_gpuva_map(struct drm_gpuvm *gpuvm,
 	      struct drm_gpuva *va,
 	      struct drm_gpuva_op_map *op)
 {
 	drm_gpuva_init_from_op(va, op);
-	drm_gpuva_insert(mgr, va);
+	drm_gpuva_insert(gpuvm, va);
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_map);
 
@@ -993,18 +993,18 @@ drm_gpuva_remap(struct drm_gpuva *prev,
 		struct drm_gpuva_op_remap *op)
 {
 	struct drm_gpuva *curr = op->unmap->va;
-	struct drm_gpuva_manager *mgr = curr->mgr;
+	struct drm_gpuvm *gpuvm = curr->vm;
 
 	drm_gpuva_remove(curr);
 
 	if (op->prev) {
 		drm_gpuva_init_from_op(prev, op->prev);
-		drm_gpuva_insert(mgr, prev);
+		drm_gpuva_insert(gpuvm, prev);
 	}
 
 	if (op->next) {
 		drm_gpuva_init_from_op(next, op->next);
-		drm_gpuva_insert(mgr, next);
+		drm_gpuva_insert(gpuvm, next);
 	}
 }
 EXPORT_SYMBOL_GPL(drm_gpuva_remap);
@@ -1024,7 +1024,7 @@ drm_gpuva_unmap(struct drm_gpuva_op_unmap *op)
 EXPORT_SYMBOL_GPL(drm_gpuva_unmap);
 
 static int
-op_map_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
+op_map_cb(const struct drm_gpuvm_ops *fn, void *priv,
 	  u64 addr, u64 range,
 	  struct drm_gem_object *obj, u64 offset)
 {
@@ -1040,7 +1040,7 @@ op_map_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
 }
 
 static int
-op_remap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
+op_remap_cb(const struct drm_gpuvm_ops *fn, void *priv,
 	    struct drm_gpuva_op_map *prev,
 	    struct drm_gpuva_op_map *next,
 	    struct drm_gpuva_op_unmap *unmap)
@@ -1058,7 +1058,7 @@ op_remap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
 }
 
 static int
-op_unmap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
+op_unmap_cb(const struct drm_gpuvm_ops *fn, void *priv,
 	    struct drm_gpuva *va, bool merge)
 {
 	struct drm_gpuva_op op = {};
@@ -1071,8 +1071,8 @@ op_unmap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
 }
 
 static int
-__drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
-		   const struct drm_gpuva_fn_ops *ops, void *priv,
+__drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm,
+		   const struct drm_gpuvm_ops *ops, void *priv,
 		   u64 req_addr, u64 req_range,
 		   struct drm_gem_object *req_obj, u64 req_offset)
 {
@@ -1080,10 +1080,10 @@ __drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
 	u64 req_end = req_addr + req_range;
 	int ret;
 
-	if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
+	if (unlikely(!drm_gpuva_range_valid(gpuvm, req_addr, req_range)))
 		return -EINVAL;
 
-	drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
+	drm_gpuvm_for_each_va_range_safe(va, next, gpuvm, req_addr, req_end) {
 		struct drm_gem_object *obj = va->gem.obj;
 		u64 offset = va->gem.offset;
 		u64 addr = va->va.addr;
@@ -1215,18 +1215,18 @@ __drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
 }
 
 static int
-__drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
-		     const struct drm_gpuva_fn_ops *ops, void *priv,
+__drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm,
+		     const struct drm_gpuvm_ops *ops, void *priv,
 		     u64 req_addr, u64 req_range)
 {
 	struct drm_gpuva *va, *next;
 	u64 req_end = req_addr + req_range;
 	int ret;
 
-	if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
+	if (unlikely(!drm_gpuva_range_valid(gpuvm, req_addr, req_range)))
 		return -EINVAL;
 
-	drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
+	drm_gpuvm_for_each_va_range_safe(va, next, gpuvm, req_addr, req_end) {
 		struct drm_gpuva_op_map prev = {}, next = {};
 		bool prev_split = false, next_split = false;
 		struct drm_gem_object *obj = va->gem.obj;
@@ -1273,8 +1273,8 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
 }
 
 /**
- * drm_gpuva_sm_map() - creates the &drm_gpuva_op split/merge steps
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * drm_gpuvm_sm_map() - creates the &drm_gpuva_op split/merge steps
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @req_addr: the start address of the new mapping
  * @req_range: the range of the new mapping
  * @req_obj: the &drm_gem_object to map
@@ -1282,15 +1282,15 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
  * @priv: pointer to a driver private data structure
  *
  * This function iterates the given range of the GPU VA space. It utilizes the
- * &drm_gpuva_fn_ops to call back into the driver providing the split and
merge
+ * &drm_gpuvm_ops to call back into the driver providing the split and
merge
  * steps.
  *
  * Drivers may use these callbacks to update the GPU VA space right away within
  * the callback. In case the driver decides to copy and store the operations
for
- * later processing neither this function nor &drm_gpuva_sm_unmap is
allowed to
- * be called before the &drm_gpuva_manager's view of the GPU VA space
was
+ * later processing neither this function nor &drm_gpuvm_sm_unmap is
allowed to
+ * be called before the &drm_gpuvm's view of the GPU VA space was
  * updated with the previous set of operations. To update the
- * &drm_gpuva_manager's view of the GPU VA space drm_gpuva_insert(),
+ * &drm_gpuvm's view of the GPU VA space drm_gpuva_insert(),
  * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
  * used.
  *
@@ -1305,39 +1305,39 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
  * Returns: 0 on success or a negative error code
  */
 int
-drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
+drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm, void *priv,
 		 u64 req_addr, u64 req_range,
 		 struct drm_gem_object *req_obj, u64 req_offset)
 {
-	const struct drm_gpuva_fn_ops *ops = mgr->ops;
+	const struct drm_gpuvm_ops *ops = gpuvm->ops;
 
 	if (unlikely(!(ops && ops->sm_step_map &&
 		       ops->sm_step_remap &&
 		       ops->sm_step_unmap)))
 		return -EINVAL;
 
-	return __drm_gpuva_sm_map(mgr, ops, priv,
+	return __drm_gpuvm_sm_map(gpuvm, ops, priv,
 				  req_addr, req_range,
 				  req_obj, req_offset);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_sm_map);
+EXPORT_SYMBOL_GPL(drm_gpuvm_sm_map);
 
 /**
- * drm_gpuva_sm_unmap() - creates the &drm_gpuva_ops to split on unmap
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * drm_gpuvm_sm_unmap() - creates the &drm_gpuva_ops to split on unmap
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @priv: pointer to a driver private data structure
  * @req_addr: the start address of the range to unmap
  * @req_range: the range of the mappings to unmap
  *
  * This function iterates the given range of the GPU VA space. It utilizes the
- * &drm_gpuva_fn_ops to call back into the driver providing the operations
to
+ * &drm_gpuvm_ops to call back into the driver providing the operations to
  * unmap and, if required, split existent mappings.
  *
  * Drivers may use these callbacks to update the GPU VA space right away within
  * the callback. In case the driver decides to copy and store the operations
for
- * later processing neither this function nor &drm_gpuva_sm_map is allowed
to be
- * called before the &drm_gpuva_manager's view of the GPU VA space was
updated
- * with the previous set of operations. To update the
&drm_gpuva_manager's view
+ * later processing neither this function nor &drm_gpuvm_sm_map is allowed
to be
+ * called before the &drm_gpuvm's view of the GPU VA space was updated
+ * with the previous set of operations. To update the &drm_gpuvm's view
  * of the GPU VA space drm_gpuva_insert(), drm_gpuva_destroy_locked() and/or
  * drm_gpuva_destroy_unlocked() should be used.
  *
@@ -1350,24 +1350,24 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map);
  * Returns: 0 on success or a negative error code
  */
 int
-drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
+drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm, void *priv,
 		   u64 req_addr, u64 req_range)
 {
-	const struct drm_gpuva_fn_ops *ops = mgr->ops;
+	const struct drm_gpuvm_ops *ops = gpuvm->ops;
 
 	if (unlikely(!(ops && ops->sm_step_remap &&
 		       ops->sm_step_unmap)))
 		return -EINVAL;
 
-	return __drm_gpuva_sm_unmap(mgr, ops, priv,
+	return __drm_gpuvm_sm_unmap(gpuvm, ops, priv,
 				    req_addr, req_range);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap);
+EXPORT_SYMBOL_GPL(drm_gpuvm_sm_unmap);
 
 static struct drm_gpuva_op *
-gpuva_op_alloc(struct drm_gpuva_manager *mgr)
+gpuva_op_alloc(struct drm_gpuvm *gpuvm)
 {
-	const struct drm_gpuva_fn_ops *fn = mgr->ops;
+	const struct drm_gpuvm_ops *fn = gpuvm->ops;
 	struct drm_gpuva_op *op;
 
 	if (fn && fn->op_alloc)
@@ -1382,10 +1382,10 @@ gpuva_op_alloc(struct drm_gpuva_manager *mgr)
 }
 
 static void
-gpuva_op_free(struct drm_gpuva_manager *mgr,
+gpuva_op_free(struct drm_gpuvm *gpuvm,
 	      struct drm_gpuva_op *op)
 {
-	const struct drm_gpuva_fn_ops *fn = mgr->ops;
+	const struct drm_gpuvm_ops *fn = gpuvm->ops;
 
 	if (fn && fn->op_free)
 		fn->op_free(op);
@@ -1398,14 +1398,14 @@ drm_gpuva_sm_step(struct drm_gpuva_op *__op,
 		  void *priv)
 {
 	struct {
-		struct drm_gpuva_manager *mgr;
+		struct drm_gpuvm *vm;
 		struct drm_gpuva_ops *ops;
 	} *args = priv;
-	struct drm_gpuva_manager *mgr = args->mgr;
+	struct drm_gpuvm *gpuvm = args->vm;
 	struct drm_gpuva_ops *ops = args->ops;
 	struct drm_gpuva_op *op;
 
-	op = gpuva_op_alloc(mgr);
+	op = gpuva_op_alloc(gpuvm);
 	if (unlikely(!op))
 		goto err;
 
@@ -1444,20 +1444,20 @@ drm_gpuva_sm_step(struct drm_gpuva_op *__op,
 err_free_prev:
 	kfree(op->remap.prev);
 err_free_op:
-	gpuva_op_free(mgr, op);
+	gpuva_op_free(gpuvm, op);
 err:
 	return -ENOMEM;
 }
 
-static const struct drm_gpuva_fn_ops gpuva_list_ops = {
+static const struct drm_gpuvm_ops gpuvm_list_ops = {
 	.sm_step_map = drm_gpuva_sm_step,
 	.sm_step_remap = drm_gpuva_sm_step,
 	.sm_step_unmap = drm_gpuva_sm_step,
 };
 
 /**
- * drm_gpuva_sm_map_ops_create() - creates the &drm_gpuva_ops to split and
merge
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * drm_gpuvm_sm_map_ops_create() - creates the &drm_gpuva_ops to split and
merge
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @req_addr: the start address of the new mapping
  * @req_range: the range of the new mapping
  * @req_obj: the &drm_gem_object to map
@@ -1476,9 +1476,9 @@ static const struct drm_gpuva_fn_ops gpuva_list_ops = {
  * map operation requested by the caller.
  *
  * Note that before calling this function again with another mapping request it
- * is necessary to update the &drm_gpuva_manager's view of the GPU VA
space. The
+ * is necessary to update the &drm_gpuvm's view of the GPU VA space.
The
  * previously obtained operations must be either processed or abandoned. To
- * update the &drm_gpuva_manager's view of the GPU VA space
drm_gpuva_insert(),
+ * update the &drm_gpuvm's view of the GPU VA space drm_gpuva_insert(),
  * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
  * used.
  *
@@ -1488,13 +1488,13 @@ static const struct drm_gpuva_fn_ops gpuva_list_ops = {
  * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
  */
 struct drm_gpuva_ops *
-drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_sm_map_ops_create(struct drm_gpuvm *gpuvm,
 			    u64 req_addr, u64 req_range,
 			    struct drm_gem_object *req_obj, u64 req_offset)
 {
 	struct drm_gpuva_ops *ops;
 	struct {
-		struct drm_gpuva_manager *mgr;
+		struct drm_gpuvm *vm;
 		struct drm_gpuva_ops *ops;
 	} args;
 	int ret;
@@ -1505,10 +1505,10 @@ drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager
*mgr,
 
 	INIT_LIST_HEAD(&ops->list);
 
-	args.mgr = mgr;
+	args.vm = gpuvm;
 	args.ops = ops;
 
-	ret = __drm_gpuva_sm_map(mgr, &gpuva_list_ops, &args,
+	ret = __drm_gpuvm_sm_map(gpuvm, &gpuvm_list_ops, &args,
 				 req_addr, req_range,
 				 req_obj, req_offset);
 	if (ret)
@@ -1517,15 +1517,15 @@ drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager
*mgr,
 	return ops;
 
 err_free_ops:
-	drm_gpuva_ops_free(mgr, ops);
+	drm_gpuva_ops_free(gpuvm, ops);
 	return ERR_PTR(ret);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
+EXPORT_SYMBOL_GPL(drm_gpuvm_sm_map_ops_create);
 
 /**
- * drm_gpuva_sm_unmap_ops_create() - creates the &drm_gpuva_ops to split on
+ * drm_gpuvm_sm_unmap_ops_create() - creates the &drm_gpuva_ops to split on
  * unmap
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @req_addr: the start address of the range to unmap
  * @req_range: the range of the mappings to unmap
  *
@@ -1540,9 +1540,9 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
  * remap operations.
  *
  * Note that before calling this function again with another range to unmap it
- * is necessary to update the &drm_gpuva_manager's view of the GPU VA
space. The
+ * is necessary to update the &drm_gpuvm's view of the GPU VA space.
The
  * previously obtained operations must be processed or abandoned. To update the
- * &drm_gpuva_manager's view of the GPU VA space drm_gpuva_insert(),
+ * &drm_gpuvm's view of the GPU VA space drm_gpuva_insert(),
  * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should be
  * used.
  *
@@ -1552,12 +1552,12 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
  * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
  */
 struct drm_gpuva_ops *
-drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_sm_unmap_ops_create(struct drm_gpuvm *gpuvm,
 			      u64 req_addr, u64 req_range)
 {
 	struct drm_gpuva_ops *ops;
 	struct {
-		struct drm_gpuva_manager *mgr;
+		struct drm_gpuvm *vm;
 		struct drm_gpuva_ops *ops;
 	} args;
 	int ret;
@@ -1568,10 +1568,10 @@ drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager
*mgr,
 
 	INIT_LIST_HEAD(&ops->list);
 
-	args.mgr = mgr;
+	args.vm = gpuvm;
 	args.ops = ops;
 
-	ret = __drm_gpuva_sm_unmap(mgr, &gpuva_list_ops, &args,
+	ret = __drm_gpuvm_sm_unmap(gpuvm, &gpuvm_list_ops, &args,
 				   req_addr, req_range);
 	if (ret)
 		goto err_free_ops;
@@ -1579,14 +1579,14 @@ drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager
*mgr,
 	return ops;
 
 err_free_ops:
-	drm_gpuva_ops_free(mgr, ops);
+	drm_gpuva_ops_free(gpuvm, ops);
 	return ERR_PTR(ret);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap_ops_create);
+EXPORT_SYMBOL_GPL(drm_gpuvm_sm_unmap_ops_create);
 
 /**
- * drm_gpuva_prefetch_ops_create() - creates the &drm_gpuva_ops to prefetch
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * drm_gpuvm_prefetch_ops_create() - creates the &drm_gpuva_ops to prefetch
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @addr: the start address of the range to prefetch
  * @range: the range of the mappings to prefetch
  *
@@ -1603,7 +1603,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap_ops_create);
  * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
  */
 struct drm_gpuva_ops *
-drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_prefetch_ops_create(struct drm_gpuvm *gpuvm,
 			      u64 addr, u64 range)
 {
 	struct drm_gpuva_ops *ops;
@@ -1618,8 +1618,8 @@ drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager
*mgr,
 
 	INIT_LIST_HEAD(&ops->list);
 
-	drm_gpuva_for_each_va_range(va, mgr, addr, end) {
-		op = gpuva_op_alloc(mgr);
+	drm_gpuvm_for_each_va_range(va, gpuvm, addr, end) {
+		op = gpuva_op_alloc(gpuvm);
 		if (!op) {
 			ret = -ENOMEM;
 			goto err_free_ops;
@@ -1633,14 +1633,14 @@ drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager
*mgr,
 	return ops;
 
 err_free_ops:
-	drm_gpuva_ops_free(mgr, ops);
+	drm_gpuva_ops_free(gpuvm, ops);
 	return ERR_PTR(ret);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_prefetch_ops_create);
+EXPORT_SYMBOL_GPL(drm_gpuvm_prefetch_ops_create);
 
 /**
- * drm_gpuva_gem_unmap_ops_create() - creates the &drm_gpuva_ops to unmap a
GEM
- * @mgr: the &drm_gpuva_manager representing the GPU VA space
+ * drm_gpuvm_gem_unmap_ops_create() - creates the &drm_gpuva_ops to unmap a
GEM
+ * @gpuvm: the &drm_gpuvm representing the GPU VA space
  * @obj: the &drm_gem_object to unmap
  *
  * This function creates a list of operations to perform unmapping for every
@@ -1658,7 +1658,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_prefetch_ops_create);
  * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
  */
 struct drm_gpuva_ops *
-drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_gem_unmap_ops_create(struct drm_gpuvm *gpuvm,
 			       struct drm_gem_object *obj)
 {
 	struct drm_gpuva_ops *ops;
@@ -1675,7 +1675,7 @@ drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager
*mgr,
 	INIT_LIST_HEAD(&ops->list);
 
 	drm_gem_for_each_gpuva(va, obj) {
-		op = gpuva_op_alloc(mgr);
+		op = gpuva_op_alloc(gpuvm);
 		if (!op) {
 			ret = -ENOMEM;
 			goto err_free_ops;
@@ -1689,21 +1689,21 @@ drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager
*mgr,
 	return ops;
 
 err_free_ops:
-	drm_gpuva_ops_free(mgr, ops);
+	drm_gpuva_ops_free(gpuvm, ops);
 	return ERR_PTR(ret);
 }
-EXPORT_SYMBOL_GPL(drm_gpuva_gem_unmap_ops_create);
+EXPORT_SYMBOL_GPL(drm_gpuvm_gem_unmap_ops_create);
 
 /**
  * drm_gpuva_ops_free() - free the given &drm_gpuva_ops
- * @mgr: the &drm_gpuva_manager the ops were created for
+ * @gpuvm: the &drm_gpuvm the ops were created for
  * @ops: the &drm_gpuva_ops to free
  *
  * Frees the given &drm_gpuva_ops structure including all the ops
associated
  * with it.
  */
 void
-drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
+drm_gpuva_ops_free(struct drm_gpuvm *gpuvm,
 		   struct drm_gpuva_ops *ops)
 {
 	struct drm_gpuva_op *op, *next;
@@ -1717,7 +1717,7 @@ drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
 			kfree(op->remap.unmap);
 		}
 
-		gpuva_op_free(mgr, op);
+		gpuva_op_free(gpuvm, op);
 	}
 
 	kfree(ops);
diff --git a/drivers/gpu/drm/nouveau/nouveau_exec.c
b/drivers/gpu/drm/nouveau/nouveau_exec.c
index a90c4cd8cbb2..c001952cd678 100644
--- a/drivers/gpu/drm/nouveau/nouveau_exec.c
+++ b/drivers/gpu/drm/nouveau/nouveau_exec.c
@@ -106,7 +106,7 @@ nouveau_exec_job_submit(struct nouveau_job *job)
 	drm_exec_until_all_locked(exec) {
 		struct drm_gpuva *va;
 
-		drm_gpuva_for_each_va(va, &uvmm->umgr) {
+		drm_gpuvm_for_each_va(va, &uvmm->umgr) {
 			if (unlikely(va == &uvmm->umgr.kernel_alloc_node))
 				continue;
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_uvmm.c
b/drivers/gpu/drm/nouveau/nouveau_uvmm.c
index aae780e4a4aa..c750072cb268 100644
--- a/drivers/gpu/drm/nouveau/nouveau_uvmm.c
+++ b/drivers/gpu/drm/nouveau/nouveau_uvmm.c
@@ -444,7 +444,7 @@ op_map_prepare_unwind(struct nouveau_uvma *uvma)
 static void
 op_unmap_prepare_unwind(struct drm_gpuva *va)
 {
-	drm_gpuva_insert(va->mgr, va);
+	drm_gpuva_insert(va->vm, va);
 }
 
 static void
@@ -1194,7 +1194,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
 				goto unwind_continue;
 			}
 
-			op->ops = drm_gpuva_sm_unmap_ops_create(&uvmm->umgr,
+			op->ops = drm_gpuvm_sm_unmap_ops_create(&uvmm->umgr,
 								op->va.addr,
 								op->va.range);
 			if (IS_ERR(op->ops)) {
@@ -1240,7 +1240,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
 				}
 			}
 
-			op->ops = drm_gpuva_sm_map_ops_create(&uvmm->umgr,
+			op->ops = drm_gpuvm_sm_map_ops_create(&uvmm->umgr,
 							      op->va.addr,
 							      op->va.range,
 							      op->gem.obj,
@@ -1264,7 +1264,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
 			break;
 		}
 		case OP_UNMAP:
-			op->ops = drm_gpuva_sm_unmap_ops_create(&uvmm->umgr,
+			op->ops = drm_gpuvm_sm_unmap_ops_create(&uvmm->umgr,
 								op->va.addr,
 								op->va.range);
 			if (IS_ERR(op->ops)) {
@@ -1836,11 +1836,11 @@ nouveau_uvmm_init(struct nouveau_uvmm *uvmm, struct
nouveau_cli *cli,
 	uvmm->kernel_managed_addr = kernel_managed_addr;
 	uvmm->kernel_managed_size = kernel_managed_size;
 
-	drm_gpuva_manager_init(&uvmm->umgr, cli->name,
-			       NOUVEAU_VA_SPACE_START,
-			       NOUVEAU_VA_SPACE_END,
-			       kernel_managed_addr, kernel_managed_size,
-			       NULL);
+	drm_gpuvm_init(&uvmm->umgr, cli->name,
+		       NOUVEAU_VA_SPACE_START,
+		       NOUVEAU_VA_SPACE_END,
+		       kernel_managed_addr, kernel_managed_size,
+		       NULL);
 
 	ret = nvif_vmm_ctor(&cli->mmu, "uvmm",
 			    cli->vmm.vmm.object.oclass, RAW,
@@ -1855,7 +1855,7 @@ nouveau_uvmm_init(struct nouveau_uvmm *uvmm, struct
nouveau_cli *cli,
 	return 0;
 
 out_free_gpuva_mgr:
-	drm_gpuva_manager_destroy(&uvmm->umgr);
+	drm_gpuvm_destroy(&uvmm->umgr);
 out_unlock:
 	mutex_unlock(&cli->mutex);
 	return ret;
@@ -1877,7 +1877,7 @@ nouveau_uvmm_fini(struct nouveau_uvmm *uvmm)
 	wait_event(entity->job.wq, list_empty(&entity->job.list.head));
 
 	nouveau_uvmm_lock(uvmm);
-	drm_gpuva_for_each_va_safe(va, next, &uvmm->umgr) {
+	drm_gpuvm_for_each_va_safe(va, next, &uvmm->umgr) {
 		struct nouveau_uvma *uvma = uvma_from_va(va);
 		struct drm_gem_object *obj = va->gem.obj;
 
@@ -1910,7 +1910,7 @@ nouveau_uvmm_fini(struct nouveau_uvmm *uvmm)
 
 	mutex_lock(&cli->mutex);
 	nouveau_vmm_fini(&uvmm->vmm);
-	drm_gpuva_manager_destroy(&uvmm->umgr);
+	drm_gpuvm_destroy(&uvmm->umgr);
 	mutex_unlock(&cli->mutex);
 
 	dma_resv_fini(&uvmm->resv);
diff --git a/drivers/gpu/drm/nouveau/nouveau_uvmm.h
b/drivers/gpu/drm/nouveau/nouveau_uvmm.h
index fc7f6fd2a4e1..e96c9919d1bd 100644
--- a/drivers/gpu/drm/nouveau/nouveau_uvmm.h
+++ b/drivers/gpu/drm/nouveau/nouveau_uvmm.h
@@ -3,13 +3,13 @@
 #ifndef __NOUVEAU_UVMM_H__
 #define __NOUVEAU_UVMM_H__
 
-#include <drm/drm_gpuva_mgr.h>
+#include <drm/drm_gpuvm.h>
 
 #include "nouveau_drv.h"
 
 struct nouveau_uvmm {
 	struct nouveau_vmm vmm;
-	struct drm_gpuva_manager umgr;
+	struct drm_gpuvm umgr;
 	struct maple_tree region_mt;
 	struct mutex mutex;
 	struct dma_resv resv;
@@ -44,7 +44,7 @@ struct nouveau_uvma {
 #define uvmm_from_mgr(x) container_of((x), struct nouveau_uvmm, umgr)
 #define uvma_from_va(x) container_of((x), struct nouveau_uvma, va)
 
-#define to_uvmm(x) uvmm_from_mgr((x)->va.mgr)
+#define to_uvmm(x) uvmm_from_mgr((x)->va.vm)
 
 struct nouveau_uvmm_bind_job {
 	struct nouveau_job base;
diff --git a/include/drm/drm_debugfs.h b/include/drm/drm_debugfs.h
index 3bba169f9bae..cf06cee4343f 100644
--- a/include/drm/drm_debugfs.h
+++ b/include/drm/drm_debugfs.h
@@ -35,7 +35,7 @@
 #include <linux/types.h>
 #include <linux/seq_file.h>
 
-#include <drm/drm_gpuva_mgr.h>
+#include <drm/drm_gpuvm.h>
 
 /**
  * DRM_DEBUGFS_GPUVA_INFO - &drm_info_list entry to dump a GPU VA space
@@ -152,7 +152,7 @@ void drm_debugfs_add_files(struct drm_device *dev,
 			   const struct drm_debugfs_info *files, int count);
 
 int drm_debugfs_gpuva_info(struct seq_file *m,
-			   struct drm_gpuva_manager *mgr);
+			   struct drm_gpuvm *gpuvm);
 #else
 static inline void drm_debugfs_create_files(const struct drm_info_list *files,
 					    int count, struct dentry *root,
@@ -177,7 +177,7 @@ static inline void drm_debugfs_add_files(struct drm_device
*dev,
 {}
 
 static inline int drm_debugfs_gpuva_info(struct seq_file *m,
-					 struct drm_gpuva_manager *mgr)
+					 struct drm_gpuvm *gpuvm)
 {
 	return 0;
 }
diff --git a/include/drm/drm_gpuva_mgr.h b/include/drm/drm_gpuvm.h
similarity index 78%
rename from include/drm/drm_gpuva_mgr.h
rename to include/drm/drm_gpuvm.h
index ed8d50200cc3..0e802676e0a9 100644
--- a/include/drm/drm_gpuva_mgr.h
+++ b/include/drm/drm_gpuvm.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 
-#ifndef __DRM_GPUVA_MGR_H__
-#define __DRM_GPUVA_MGR_H__
+#ifndef __DRM_GPUVM_H__
+#define __DRM_GPUVM_H__
 
 /*
  * Copyright (c) 2022 Red Hat.
@@ -31,8 +31,8 @@
 
 #include <drm/drm_gem.h>
 
-struct drm_gpuva_manager;
-struct drm_gpuva_fn_ops;
+struct drm_gpuvm;
+struct drm_gpuvm_ops;
 
 /**
  * enum drm_gpuva_flags - flags for struct drm_gpuva
@@ -62,15 +62,15 @@ enum drm_gpuva_flags {
  * struct drm_gpuva - structure to track a GPU VA mapping
  *
  * This structure represents a GPU VA mapping and is associated with a
- * &drm_gpuva_manager.
+ * &drm_gpuvm.
  *
  * Typically, this structure is embedded in bigger driver structures.
  */
 struct drm_gpuva {
 	/**
-	 * @mgr: the &drm_gpuva_manager this object is associated with
+	 * @vm: the &drm_gpuvm this object is associated with
 	 */
-	struct drm_gpuva_manager *mgr;
+	struct drm_gpuvm *vm;
 
 	/**
 	 * @flags: the &drm_gpuva_flags for this mapping
@@ -137,20 +137,20 @@ struct drm_gpuva {
 	} rb;
 };
 
-int drm_gpuva_insert(struct drm_gpuva_manager *mgr, struct drm_gpuva *va);
+int drm_gpuva_insert(struct drm_gpuvm *gpuvm, struct drm_gpuva *va);
 void drm_gpuva_remove(struct drm_gpuva *va);
 
 void drm_gpuva_link(struct drm_gpuva *va);
 void drm_gpuva_unlink(struct drm_gpuva *va);
 
-struct drm_gpuva *drm_gpuva_find(struct drm_gpuva_manager *mgr,
+struct drm_gpuva *drm_gpuva_find(struct drm_gpuvm *gpuvm,
 				 u64 addr, u64 range);
-struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
+struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuvm *gpuvm,
 				       u64 addr, u64 range);
-struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuva_manager *mgr, u64
start);
-struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuva_manager *mgr, u64 end);
+struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuvm *gpuvm, u64 start);
+struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuvm *gpuvm, u64 end);
 
-bool drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 addr, u64
range);
+bool drm_gpuva_interval_empty(struct drm_gpuvm *gpuvm, u64 addr, u64 range);
 
 static inline void drm_gpuva_init(struct drm_gpuva *va, u64 addr, u64 range,
 				  struct drm_gem_object *obj, u64 offset)
@@ -186,7 +186,7 @@ static inline bool drm_gpuva_invalidated(struct drm_gpuva
*va)
 }
 
 /**
- * struct drm_gpuva_manager - DRM GPU VA Manager
+ * struct drm_gpuvm - DRM GPU VA Manager
  *
  * The DRM GPU VA Manager keeps track of a GPU's virtual address space by
using
  * &maple_tree structures. Typically, this structure is embedded in bigger
@@ -197,7 +197,7 @@ static inline bool drm_gpuva_invalidated(struct drm_gpuva
*va)
  *
  * There should be one manager instance per GPU virtual address space.
  */
-struct drm_gpuva_manager {
+struct drm_gpuvm {
 	/**
 	 * @name: the name of the DRM GPU VA space
 	 */
@@ -237,100 +237,99 @@ struct drm_gpuva_manager {
 	struct drm_gpuva kernel_alloc_node;
 
 	/**
-	 * @ops: &drm_gpuva_fn_ops providing the split/merge steps to drivers
+	 * @ops: &drm_gpuvm_ops providing the split/merge steps to drivers
 	 */
-	const struct drm_gpuva_fn_ops *ops;
+	const struct drm_gpuvm_ops *ops;
 };
 
-void drm_gpuva_manager_init(struct drm_gpuva_manager *mgr,
-			    const char *name,
-			    u64 start_offset, u64 range,
-			    u64 reserve_offset, u64 reserve_range,
-			    const struct drm_gpuva_fn_ops *ops);
-void drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr);
+void drm_gpuvm_init(struct drm_gpuvm *gpuvm, const char *name,
+		    u64 start_offset, u64 range,
+		    u64 reserve_offset, u64 reserve_range,
+		    const struct drm_gpuvm_ops *ops);
+void drm_gpuvm_destroy(struct drm_gpuvm *gpuvm);
 
 static inline struct drm_gpuva *
 __drm_gpuva_next(struct drm_gpuva *va)
 {
-	if (va && !list_is_last(&va->rb.entry,
&va->mgr->rb.list))
+	if (va && !list_is_last(&va->rb.entry,
&va->vm->rb.list))
 		return list_next_entry(va, rb.entry);
 
 	return NULL;
 }
 
 /**
- * drm_gpuva_for_each_va_range() - iterate over a range of &drm_gpuvas
+ * drm_gpuvm_for_each_va_range() - iterate over a range of &drm_gpuvas
  * @va__: &drm_gpuva structure to assign to in each iteration step
- * @mgr__: &drm_gpuva_manager to walk over
+ * @gpuvm__: &drm_gpuvm to walk over
  * @start__: starting offset, the first gpuva will overlap this
  * @end__: ending offset, the last gpuva will start before this (but may
  * overlap)
  *
- * This iterator walks over all &drm_gpuvas in the &drm_gpuva_manager
that lie
+ * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that lie
  * between @start__ and @end__. It is implemented similarly to list_for_each(),
- * but is using the &drm_gpuva_manager's internal interval tree to
accelerate
+ * but is using the &drm_gpuvm's internal interval tree to accelerate
  * the search for the starting &drm_gpuva, and hence isn't safe against
removal
  * of elements. It assumes that @end__ is within (or is the upper limit of) the
- * &drm_gpuva_manager. This iterator does not skip over the
&drm_gpuva_manager's
+ * &drm_gpuvm. This iterator does not skip over the &drm_gpuvm's
  * @kernel_alloc_node.
  */
-#define drm_gpuva_for_each_va_range(va__, mgr__, start__, end__) \
-	for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__) - (start__)); \
+#define drm_gpuvm_for_each_va_range(va__, gpuvm__, start__, end__) \
+	for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) - (start__)); \
 	     va__ && (va__->va.addr < (end__)); \
 	     va__ = __drm_gpuva_next(va__))
 
 /**
- * drm_gpuva_for_each_va_range_safe() - safely iterate over a range of
+ * drm_gpuvm_for_each_va_range_safe() - safely iterate over a range of
  * &drm_gpuvas
  * @va__: &drm_gpuva to assign to in each iteration step
  * @next__: another &drm_gpuva to use as temporary storage
- * @mgr__: &drm_gpuva_manager to walk over
+ * @gpuvm__: &drm_gpuvm to walk over
  * @start__: starting offset, the first gpuva will overlap this
  * @end__: ending offset, the last gpuva will start before this (but may
  * overlap)
  *
- * This iterator walks over all &drm_gpuvas in the &drm_gpuva_manager
that lie
+ * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that lie
  * between @start__ and @end__. It is implemented similarly to
- * list_for_each_safe(), but is using the &drm_gpuva_manager's internal
interval
+ * list_for_each_safe(), but is using the &drm_gpuvm's internal
interval
  * tree to accelerate the search for the starting &drm_gpuva, and hence is
safe
  * against removal of elements. It assumes that @end__ is within (or is the
- * upper limit of) the &drm_gpuva_manager. This iterator does not skip over
the
- * &drm_gpuva_manager's @kernel_alloc_node.
+ * upper limit of) the &drm_gpuvm. This iterator does not skip over the
+ * &drm_gpuvm's @kernel_alloc_node.
  */
-#define drm_gpuva_for_each_va_range_safe(va__, next__, mgr__, start__, end__) \
-	for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__) - (start__)), \
+#define drm_gpuvm_for_each_va_range_safe(va__, next__, gpuvm__, start__, end__)
\
+	for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) - (start__)), \
 	     next__ = __drm_gpuva_next(va__); \
 	     va__ && (va__->va.addr < (end__)); \
 	     va__ = next__, next__ = __drm_gpuva_next(va__))
 
 /**
- * drm_gpuva_for_each_va() - iterate over all &drm_gpuvas
+ * drm_gpuvm_for_each_va() - iterate over all &drm_gpuvas
  * @va__: &drm_gpuva to assign to in each iteration step
- * @mgr__: &drm_gpuva_manager to walk over
+ * @gpuvm__: &drm_gpuvm to walk over
  *
  * This iterator walks over all &drm_gpuva structures associated with the
given
- * &drm_gpuva_manager.
+ * &drm_gpuvm.
  */
-#define drm_gpuva_for_each_va(va__, mgr__) \
-	list_for_each_entry(va__, &(mgr__)->rb.list, rb.entry)
+#define drm_gpuvm_for_each_va(va__, gpuvm__) \
+	list_for_each_entry(va__, &(gpuvm__)->rb.list, rb.entry)
 
 /**
- * drm_gpuva_for_each_va_safe() - safely iterate over all &drm_gpuvas
+ * drm_gpuvm_for_each_va_safe() - safely iterate over all &drm_gpuvas
  * @va__: &drm_gpuva to assign to in each iteration step
  * @next__: another &drm_gpuva to use as temporary storage
- * @mgr__: &drm_gpuva_manager to walk over
+ * @gpuvm__: &drm_gpuvm to walk over
  *
  * This iterator walks over all &drm_gpuva structures associated with the
given
- * &drm_gpuva_manager. It is implemented with list_for_each_entry_safe(),
and
+ * &drm_gpuvm. It is implemented with list_for_each_entry_safe(), and
  * hence safe against the removal of elements.
  */
-#define drm_gpuva_for_each_va_safe(va__, next__, mgr__) \
-	list_for_each_entry_safe(va__, next__, &(mgr__)->rb.list, rb.entry)
+#define drm_gpuvm_for_each_va_safe(va__, next__, gpuvm__) \
+	list_for_each_entry_safe(va__, next__, &(gpuvm__)->rb.list, rb.entry)
 
 /**
  * enum drm_gpuva_op_type - GPU VA operation type
  *
- * Operations to alter the GPU VA mappings tracked by the
&drm_gpuva_manager.
+ * Operations to alter the GPU VA mappings tracked by the &drm_gpuvm.
  */
 enum drm_gpuva_op_type {
 	/**
@@ -413,7 +412,7 @@ struct drm_gpuva_op_unmap {
 	 *
 	 * Optionally, if &keep is set, drivers may keep the actual page table
 	 * mappings for this &drm_gpuva, adding the missing page table entries
-	 * only and update the &drm_gpuva_manager accordingly.
+	 * only and update the &drm_gpuvm accordingly.
 	 */
 	bool keep;
 };
@@ -584,22 +583,22 @@ struct drm_gpuva_ops {
 #define drm_gpuva_next_op(op) list_next_entry(op, entry)
 
 struct drm_gpuva_ops *
-drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_sm_map_ops_create(struct drm_gpuvm *gpuvm,
 			    u64 addr, u64 range,
 			    struct drm_gem_object *obj, u64 offset);
 struct drm_gpuva_ops *
-drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_sm_unmap_ops_create(struct drm_gpuvm *gpuvm,
 			      u64 addr, u64 range);
 
 struct drm_gpuva_ops *
-drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_prefetch_ops_create(struct drm_gpuvm *gpuvm,
 				 u64 addr, u64 range);
 
 struct drm_gpuva_ops *
-drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
+drm_gpuvm_gem_unmap_ops_create(struct drm_gpuvm *gpuvm,
 			       struct drm_gem_object *obj);
 
-void drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
+void drm_gpuva_ops_free(struct drm_gpuvm *gpuvm,
 			struct drm_gpuva_ops *ops);
 
 static inline void drm_gpuva_init_from_op(struct drm_gpuva *va,
@@ -610,15 +609,15 @@ static inline void drm_gpuva_init_from_op(struct drm_gpuva
*va,
 }
 
 /**
- * struct drm_gpuva_fn_ops - callbacks for split/merge steps
+ * struct drm_gpuvm_ops - callbacks for split/merge steps
  *
- * This structure defines the callbacks used by &drm_gpuva_sm_map and
- * &drm_gpuva_sm_unmap to provide the split/merge steps for map and unmap
+ * This structure defines the callbacks used by &drm_gpuvm_sm_map and
+ * &drm_gpuvm_sm_unmap to provide the split/merge steps for map and unmap
  * operations to drivers.
  */
-struct drm_gpuva_fn_ops {
+struct drm_gpuvm_ops {
 	/**
-	 * @op_alloc: called when the &drm_gpuva_manager allocates
+	 * @op_alloc: called when the &drm_gpuvm allocates
 	 * a struct drm_gpuva_op
 	 *
 	 * Some drivers may want to embed struct drm_gpuva_op into driver
@@ -630,7 +629,7 @@ struct drm_gpuva_fn_ops {
 	struct drm_gpuva_op *(*op_alloc)(void);
 
 	/**
-	 * @op_free: called when the &drm_gpuva_manager frees a
+	 * @op_free: called when the &drm_gpuvm frees a
 	 * struct drm_gpuva_op
 	 *
 	 * Some drivers may want to embed struct drm_gpuva_op into driver
@@ -642,19 +641,19 @@ struct drm_gpuva_fn_ops {
 	void (*op_free)(struct drm_gpuva_op *op);
 
 	/**
-	 * @sm_step_map: called from &drm_gpuva_sm_map to finally insert the
+	 * @sm_step_map: called from &drm_gpuvm_sm_map to finally insert the
 	 * mapping once all previous steps were completed
 	 *
 	 * The &priv pointer matches the one the driver passed to
-	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
+	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 	 *
-	 * Can be NULL if &drm_gpuva_sm_map is used.
+	 * Can be NULL if &drm_gpuvm_sm_map is used.
 	 */
 	int (*sm_step_map)(struct drm_gpuva_op *op, void *priv);
 
 	/**
-	 * @sm_step_remap: called from &drm_gpuva_sm_map and
-	 * &drm_gpuva_sm_unmap to split up an existent mapping
+	 * @sm_step_remap: called from &drm_gpuvm_sm_map and
+	 * &drm_gpuvm_sm_unmap to split up an existent mapping
 	 *
 	 * This callback is called when existent mapping needs to be split up.
 	 * This is the case when either a newly requested mapping overlaps or
@@ -662,38 +661,38 @@ struct drm_gpuva_fn_ops {
 	 * mapping is requested.
 	 *
 	 * The &priv pointer matches the one the driver passed to
-	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
+	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 	 *
-	 * Can be NULL if neither &drm_gpuva_sm_map nor &drm_gpuva_sm_unmap is
+	 * Can be NULL if neither &drm_gpuvm_sm_map nor &drm_gpuvm_sm_unmap is
 	 * used.
 	 */
 	int (*sm_step_remap)(struct drm_gpuva_op *op, void *priv);
 
 	/**
-	 * @sm_step_unmap: called from &drm_gpuva_sm_map and
-	 * &drm_gpuva_sm_unmap to unmap an existent mapping
+	 * @sm_step_unmap: called from &drm_gpuvm_sm_map and
+	 * &drm_gpuvm_sm_unmap to unmap an existent mapping
 	 *
 	 * This callback is called when existent mapping needs to be unmapped.
 	 * This is the case when either a newly requested mapping encloses an
 	 * existent mapping or an unmap of an existent mapping is requested.
 	 *
 	 * The &priv pointer matches the one the driver passed to
-	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
+	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
 	 *
-	 * Can be NULL if neither &drm_gpuva_sm_map nor &drm_gpuva_sm_unmap is
+	 * Can be NULL if neither &drm_gpuvm_sm_map nor &drm_gpuvm_sm_unmap is
 	 * used.
 	 */
 	int (*sm_step_unmap)(struct drm_gpuva_op *op, void *priv);
 };
 
-int drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
+int drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm, void *priv,
 		     u64 addr, u64 range,
 		     struct drm_gem_object *obj, u64 offset);
 
-int drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
+int drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm, void *priv,
 		       u64 addr, u64 range);
 
-void drm_gpuva_map(struct drm_gpuva_manager *mgr,
+void drm_gpuva_map(struct drm_gpuvm *gpuvm,
 		   struct drm_gpuva *va,
 		   struct drm_gpuva_op_map *op);
 
@@ -703,4 +702,4 @@ void drm_gpuva_remap(struct drm_gpuva *prev,
 
 void drm_gpuva_unmap(struct drm_gpuva_op_unmap *op);
 
-#endif /* __DRM_GPUVA_MGR_H__ */
+#endif /* __DRM_GPUVM_H__ */
-- 
2.41.0

Am 20.09.23 um 16:42 schrieb Danilo Krummrich:
> Rename struct drm_gpuva_manager to struct drm_gpuvm including
> corresponding functions. This way the GPUVA manager's structures align
> very well with the documentation of VM_BIND [1] and VM_BIND locking [2].
>
> It also provides a better foundation for the naming of data structures
> and functions introduced for implementing a common dma-resv per GPU-VM
> including tracking of external and evicted objects in subsequent
> patches.
>
> [1] Documentation/gpu/drm-vm-bind-async.rst
> [2] Documentation/gpu/drm-vm-bind-locking.rst
>
> Cc: Thomas Hellstr?m <thomas.hellstrom at linux.intel.com>
> Cc: Matthew Brost <matthew.brost at intel.com>
> Signed-off-by: Danilo Krummrich <dakr at redhat.com>
Not sure if that name is better or worse, but from the handling I 
suggest to have this patch separately pushed to drm-misc-next.

Feel free to add my Acked-by for pushing this.

Regards,
Christian.
> ---
>   drivers/gpu/drm/Makefile                      |   2 +-
>   drivers/gpu/drm/drm_debugfs.c                 |  16 +-
>   .../gpu/drm/{drm_gpuva_mgr.c => drm_gpuvm.c}  | 400 +++++++++---------
>   drivers/gpu/drm/nouveau/nouveau_exec.c        |   2 +-
>   drivers/gpu/drm/nouveau/nouveau_uvmm.c        |  24 +-
>   drivers/gpu/drm/nouveau/nouveau_uvmm.h        |   6 +-
>   include/drm/drm_debugfs.h                     |   6 +-
>   include/drm/{drm_gpuva_mgr.h => drm_gpuvm.h}  | 153 ++++---
>   8 files changed, 304 insertions(+), 305 deletions(-)
>   rename drivers/gpu/drm/{drm_gpuva_mgr.c => drm_gpuvm.c} (78%)
>   rename include/drm/{drm_gpuva_mgr.h => drm_gpuvm.h} (78%)
>
> diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile
> index 215e78e79125..7a84b3cddeab 100644
> --- a/drivers/gpu/drm/Makefile
> +++ b/drivers/gpu/drm/Makefile
> @@ -45,7 +45,7 @@ drm-y := \
>   	drm_vblank.o \
>   	drm_vblank_work.o \
>   	drm_vma_manager.o \
> -	drm_gpuva_mgr.o \
> +	drm_gpuvm.o \
>   	drm_writeback.o
>   drm-$(CONFIG_DRM_LEGACY) += \
>   	drm_agpsupport.o \
> diff --git a/drivers/gpu/drm/drm_debugfs.c b/drivers/gpu/drm/drm_debugfs.c
> index 44ecd7d0daac..f291fb4b359f 100644
> --- a/drivers/gpu/drm/drm_debugfs.c
> +++ b/drivers/gpu/drm/drm_debugfs.c
> @@ -40,7 +40,7 @@
>   #include <drm/drm_file.h>
>   #include <drm/drm_gem.h>
>   #include <drm/drm_managed.h>
> -#include <drm/drm_gpuva_mgr.h>
> +#include <drm/drm_gpuvm.h>
>   
>   #include "drm_crtc_internal.h"
>   #include "drm_internal.h"
> @@ -189,31 +189,31 @@ static const struct file_operations drm_debugfs_fops
= {
>   /**
>    * drm_debugfs_gpuva_info - dump the given DRM GPU VA space
>    * @m: pointer to the &seq_file to write
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    *
>    * Dumps the GPU VA mappings of a given DRM GPU VA manager.
>    *
>    * For each DRM GPU VA space drivers should call this function from their
>    * &drm_info_list's show callback.
>    *
> - * Returns: 0 on success, -ENODEV if the &mgr is not initialized
> + * Returns: 0 on success, -ENODEV if the &gpuvm is not initialized
>    */
>   int drm_debugfs_gpuva_info(struct seq_file *m,
> -			   struct drm_gpuva_manager *mgr)
> +			   struct drm_gpuvm *gpuvm)
>   {
> -	struct drm_gpuva *va, *kva = &mgr->kernel_alloc_node;
> +	struct drm_gpuva *va, *kva = &gpuvm->kernel_alloc_node;
>   
> -	if (!mgr->name)
> +	if (!gpuvm->name)
>   		return -ENODEV;
>   
>   	seq_printf(m, "DRM GPU VA space (%s) [0x%016llx;0x%016llx]\n",
> -		   mgr->name, mgr->mm_start, mgr->mm_start + mgr->mm_range);
> +		   gpuvm->name, gpuvm->mm_start, gpuvm->mm_start +
gpuvm->mm_range);
>   	seq_printf(m, "Kernel reserved node [0x%016llx;0x%016llx]\n",
>   		   kva->va.addr, kva->va.addr + kva->va.range);
>   	seq_puts(m, "\n");
>   	seq_puts(m, " VAs | start              | range              | end  
| object             | object offset\n");
>   	seq_puts(m,
"-------------------------------------------------------------------------------------------------------------\n");
> -	drm_gpuva_for_each_va(va, mgr) {
> +	drm_gpuvm_for_each_va(va, gpuvm) {
>   		if (unlikely(va == kva))
>   			continue;
>   
> diff --git a/drivers/gpu/drm/drm_gpuva_mgr.c b/drivers/gpu/drm/drm_gpuvm.c
> similarity index 78%
> rename from drivers/gpu/drm/drm_gpuva_mgr.c
> rename to drivers/gpu/drm/drm_gpuvm.c
> index f86bfad74ff8..7074bcad5b28 100644
> --- a/drivers/gpu/drm/drm_gpuva_mgr.c
> +++ b/drivers/gpu/drm/drm_gpuvm.c
> @@ -25,7 +25,7 @@
>    *
>    */
>   
> -#include <drm/drm_gpuva_mgr.h>
> +#include <drm/drm_gpuvm.h>
>   
>   #include <linux/interval_tree_generic.h>
>   #include <linux/mm.h>
> @@ -33,8 +33,8 @@
>   /**
>    * DOC: Overview
>    *
> - * The DRM GPU VA Manager, represented by struct drm_gpuva_manager keeps
track
> - * of a GPU's virtual address (VA) space and manages the corresponding
virtual
> + * The DRM GPU VA Manager, represented by struct drm_gpuvm keeps track of
a
> + * GPU's virtual address (VA) space and manages the corresponding
virtual
>    * mappings represented by &drm_gpuva objects. It also keeps track of
the
>    * mapping's backing &drm_gem_object buffers.
>    *
> @@ -47,28 +47,28 @@
>    * The GPU VA manager internally uses a rb-tree to manage the
>    * &drm_gpuva mappings within a GPU's virtual address space.
>    *
> - * The &drm_gpuva_manager contains a special &drm_gpuva
representing the
> + * The &drm_gpuvm structure contains a special &drm_gpuva
representing the
>    * portion of VA space reserved by the kernel. This node is initialized
together
>    * with the GPU VA manager instance and removed when the GPU VA manager
is
>    * destroyed.
>    *
> - * In a typical application drivers would embed struct drm_gpuva_manager
and
> + * In a typical application drivers would embed struct drm_gpuvm and
>    * struct drm_gpuva within their own driver specific structures, there
won't be
>    * any memory allocations of its own nor memory allocations of
&drm_gpuva
>    * entries.
>    *
> - * The data structures needed to store &drm_gpuvas within the
&drm_gpuva_manager
> - * are contained within struct drm_gpuva already. Hence, for inserting
> - * &drm_gpuva entries from within dma-fence signalling critical
sections it is
> - * enough to pre-allocate the &drm_gpuva structures.
> + * The data structures needed to store &drm_gpuvas within the
&drm_gpuvm are
> + * contained within struct drm_gpuva already. Hence, for inserting
&drm_gpuva
> + * entries from within dma-fence signalling critical sections it is enough
to
> + * pre-allocate the &drm_gpuva structures.
>    */
>   
>   /**
>    * DOC: Split and Merge
>    *
>    * Besides its capability to manage and represent a GPU VA space, the
> - * &drm_gpuva_manager also provides functions to let the
&drm_gpuva_manager
> - * calculate a sequence of operations to satisfy a given map or unmap
request.
> + * GPU VA manager also provides functions to let the &drm_gpuvm
calculate a
> + * sequence of operations to satisfy a given map or unmap request.
>    *
>    * Therefore the DRM GPU VA manager provides an algorithm implementing
splitting
>    * and merging of existent GPU VA mappings with the ones that are
requested to
> @@ -76,16 +76,16 @@
>    * implement Vulkan 'Sparse Memory Bindings' - drivers UAPIs
often refer to this
>    * as VM BIND.
>    *
> - * Drivers can call drm_gpuva_sm_map() to receive a sequence of callbacks
> + * Drivers can call drm_gpuvm_sm_map() to receive a sequence of callbacks
>    * containing map, unmap and remap operations for a given newly requested
>    * mapping. The sequence of callbacks represents the set of operations to
>    * execute in order to integrate the new mapping cleanly into the current
state
>    * of the GPU VA space.
>    *
>    * Depending on how the new GPU VA mapping intersects with the existent
mappings
> - * of the GPU VA space the &drm_gpuva_fn_ops callbacks contain an
arbitrary
> - * amount of unmap operations, a maximum of two remap operations and a
single
> - * map operation. The caller might receive no callback at all if no
operation is
> + * of the GPU VA space the &drm_gpuvm_ops callbacks contain an
arbitrary amount
> + * of unmap operations, a maximum of two remap operations and a single map
> + * operation. The caller might receive no callback at all if no operation
is
>    * required, e.g. if the requested mapping already exists in the exact
same way.
>    *
>    * The single map operation represents the original map operation
requested by
> @@ -95,7 +95,7 @@
>    * &drm_gpuva to unmap is physically contiguous with the original
mapping
>    * request. Optionally, if 'keep' is set, drivers may keep the
actual page table
>    * entries for this &drm_gpuva, adding the missing page table entries
only and
> - * update the &drm_gpuva_manager's view of things accordingly.
> + * update the &drm_gpuvm's view of things accordingly.
>    *
>    * Drivers may do the same optimization, namely delta page table updates,
also
>    * for remap operations. This is possible since &drm_gpuva_op_remap
consists of
> @@ -106,34 +106,34 @@
>    * the beginning and one at the end of the new mapping, hence there is a
>    * maximum of two remap operations.
>    *
> - * Analogous to drm_gpuva_sm_map() drm_gpuva_sm_unmap() uses
&drm_gpuva_fn_ops
> - * to call back into the driver in order to unmap a range of GPU VA space.
The
> + * Analogous to drm_gpuvm_sm_map() drm_gpuvm_sm_unmap() uses
&drm_gpuvm_ops to
> + * call back into the driver in order to unmap a range of GPU VA space.
The
>    * logic behind this function is way simpler though: For all existent
mappings
>    * enclosed by the given range unmap operations are created. For mappings
which
>    * are only partically located within the given range, remap operations
are
>    * created such that those mappings are split up and re-mapped
partically.
>    *
> - * As an alternative to drm_gpuva_sm_map() and drm_gpuva_sm_unmap(),
> - * drm_gpuva_sm_map_ops_create() and drm_gpuva_sm_unmap_ops_create() can
be used
> + * As an alternative to drm_gpuvm_sm_map() and drm_gpuvm_sm_unmap(),
> + * drm_gpuvm_sm_map_ops_create() and drm_gpuvm_sm_unmap_ops_create() can
be used
>    * to directly obtain an instance of struct drm_gpuva_ops containing a
list of
>    * &drm_gpuva_op, which can be iterated with drm_gpuva_for_each_op().
This list
>    * contains the &drm_gpuva_ops analogous to the callbacks one would
receive when
> - * calling drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). While this way
requires
> + * calling drm_gpuvm_sm_map() or drm_gpuvm_sm_unmap(). While this way
requires
>    * more memory (to allocate the &drm_gpuva_ops), it provides drivers
a way to
>    * iterate the &drm_gpuva_op multiple times, e.g. once in a context
where memory
>    * allocations are possible (e.g. to allocate GPU page tables) and once
in the
>    * dma-fence signalling critical path.
>    *
> - * To update the &drm_gpuva_manager's view of the GPU VA space
> - * drm_gpuva_insert() and drm_gpuva_remove() may be used. These functions
can
> - * safely be used from &drm_gpuva_fn_ops callbacks originating from
> - * drm_gpuva_sm_map() or drm_gpuva_sm_unmap(). However, it might be more
> - * convenient to use the provided helper functions drm_gpuva_map(),
> - * drm_gpuva_remap() and drm_gpuva_unmap() instead.
> + * To update the &drm_gpuvm's view of the GPU VA space
drm_gpuva_insert() and
> + * drm_gpuva_remove() may be used. These functions can safely be used from
> + * &drm_gpuvm_ops callbacks originating from drm_gpuvm_sm_map() or
> + * drm_gpuvm_sm_unmap(). However, it might be more convenient to use the
> + * provided helper functions drm_gpuva_map(), drm_gpuva_remap() and
> + * drm_gpuva_unmap() instead.
>    *
>    * The following diagram depicts the basic relationships of existent GPU
VA
>    * mappings, a newly requested mapping and the resulting mappings as
implemented
> - * by drm_gpuva_sm_map() - it doesn't cover any arbitrary combinations
of these.
> + * by drm_gpuvm_sm_map() - it doesn't cover any arbitrary combinations
of these.
>    *
>    * 1) Requested mapping is identical. Replace it, but indicate the
backing PTEs
>    *    could be kept.
> @@ -421,10 +421,10 @@
>    *	// Allocates a new &drm_gpuva.
>    *	struct drm_gpuva * driver_gpuva_alloc(void);
>    *
> - *	// Typically drivers would embedd the &drm_gpuva_manager and
&drm_gpuva
> + *	// Typically drivers would embedd the &drm_gpuvm and &drm_gpuva
>    *	// structure in individual driver structures and lock the dma-resv
with
>    *	// drm_exec or similar helpers.
> - *	int driver_mapping_create(struct drm_gpuva_manager *mgr,
> + *	int driver_mapping_create(struct drm_gpuvm *gpuvm,
>    *				  u64 addr, u64 range,
>    *				  struct drm_gem_object *obj, u64 offset)
>    *	{
> @@ -432,7 +432,7 @@
>    *		struct drm_gpuva_op *op
>    *
>    *		driver_lock_va_space();
> - *		ops = drm_gpuva_sm_map_ops_create(mgr, addr, range,
> + *		ops = drm_gpuvm_sm_map_ops_create(gpuvm, addr, range,
>    *						  obj, offset);
>    *		if (IS_ERR(ops))
>    *			return PTR_ERR(ops);
> @@ -448,7 +448,7 @@
>    *					  // free memory and unlock
>    *
>    *				driver_vm_map();
> - *				drm_gpuva_map(mgr, va, &op->map);
> + *				drm_gpuva_map(gpuvm, va, &op->map);
>    *				drm_gpuva_link(va);
>    *
>    *				break;
> @@ -504,23 +504,23 @@
>    * 2) Receive a callback for each &drm_gpuva_op to create a new
mapping::
>    *
>    *	struct driver_context {
> - *		struct drm_gpuva_manager *mgr;
> + *		struct drm_gpuvm *gpuvm;
>    *		struct drm_gpuva *new_va;
>    *		struct drm_gpuva *prev_va;
>    *		struct drm_gpuva *next_va;
>    *	};
>    *
> - *	// ops to pass to drm_gpuva_manager_init()
> - *	static const struct drm_gpuva_fn_ops driver_gpuva_ops = {
> + *	// ops to pass to drm_gpuvm_init()
> + *	static const struct drm_gpuvm_ops driver_gpuvm_ops = {
>    *		.sm_step_map = driver_gpuva_map,
>    *		.sm_step_remap = driver_gpuva_remap,
>    *		.sm_step_unmap = driver_gpuva_unmap,
>    *	};
>    *
> - *	// Typically drivers would embedd the &drm_gpuva_manager and
&drm_gpuva
> + *	// Typically drivers would embedd the &drm_gpuvm and &drm_gpuva
>    *	// structure in individual driver structures and lock the dma-resv
with
>    *	// drm_exec or similar helpers.
> - *	int driver_mapping_create(struct drm_gpuva_manager *mgr,
> + *	int driver_mapping_create(struct drm_gpuvm *gpuvm,
>    *				  u64 addr, u64 range,
>    *				  struct drm_gem_object *obj, u64 offset)
>    *	{
> @@ -529,7 +529,7 @@
>    *		struct drm_gpuva_op *op;
>    *		int ret = 0;
>    *
> - *		ctx.mgr = mgr;
> + *		ctx.gpuvm = gpuvm;
>    *
>    *		ctx.new_va = kzalloc(sizeof(*ctx.new_va), GFP_KERNEL);
>    *		ctx.prev_va = kzalloc(sizeof(*ctx.prev_va), GFP_KERNEL);
> @@ -540,7 +540,7 @@
>    *		}
>    *
>    *		driver_lock_va_space();
> - *		ret = drm_gpuva_sm_map(mgr, &ctx, addr, range, obj, offset);
> + *		ret = drm_gpuvm_sm_map(gpuvm, &ctx, addr, range, obj, offset);
>    *		driver_unlock_va_space();
>    *
>    *	out:
> @@ -554,7 +554,7 @@
>    *	{
>    *		struct driver_context *ctx = __ctx;
>    *
> - *		drm_gpuva_map(ctx->mgr, ctx->new_va, &op->map);
> + *		drm_gpuva_map(ctx->vm, ctx->new_va, &op->map);
>    *
>    *		drm_gpuva_link(ctx->new_va);
>    *
> @@ -609,12 +609,12 @@ INTERVAL_TREE_DEFINE(struct drm_gpuva, rb.node, u64,
rb.__subtree_last,
>   		     GPUVA_START, GPUVA_LAST, static __maybe_unused,
>   		     drm_gpuva_it)
>   
> -static int __drm_gpuva_insert(struct drm_gpuva_manager *mgr,
> +static int __drm_gpuva_insert(struct drm_gpuvm *gpuvm,
>   			      struct drm_gpuva *va);
>   static void __drm_gpuva_remove(struct drm_gpuva *va);
>   
>   static bool
> -drm_gpuva_check_overflow(u64 addr, u64 range)
> +drm_gpuvm_check_overflow(u64 addr, u64 range)
>   {
>   	u64 end;
>   
> @@ -623,121 +623,121 @@ drm_gpuva_check_overflow(u64 addr, u64 range)
>   }
>   
>   static bool
> -drm_gpuva_in_mm_range(struct drm_gpuva_manager *mgr, u64 addr, u64 range)
> +drm_gpuvm_in_mm_range(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
>   {
>   	u64 end = addr + range;
> -	u64 mm_start = mgr->mm_start;
> -	u64 mm_end = mm_start + mgr->mm_range;
> +	u64 mm_start = gpuvm->mm_start;
> +	u64 mm_end = mm_start + gpuvm->mm_range;
>   
>   	return addr >= mm_start && end <= mm_end;
>   }
>   
>   static bool
> -drm_gpuva_in_kernel_node(struct drm_gpuva_manager *mgr, u64 addr, u64
range)
> +drm_gpuvm_in_kernel_node(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
>   {
>   	u64 end = addr + range;
> -	u64 kstart = mgr->kernel_alloc_node.va.addr;
> -	u64 krange = mgr->kernel_alloc_node.va.range;
> +	u64 kstart = gpuvm->kernel_alloc_node.va.addr;
> +	u64 krange = gpuvm->kernel_alloc_node.va.range;
>   	u64 kend = kstart + krange;
>   
>   	return krange && addr < kend && kstart < end;
>   }
>   
>   static bool
> -drm_gpuva_range_valid(struct drm_gpuva_manager *mgr,
> +drm_gpuva_range_valid(struct drm_gpuvm *gpuvm,
>   		      u64 addr, u64 range)
>   {
> -	return !drm_gpuva_check_overflow(addr, range) &&
> -	       drm_gpuva_in_mm_range(mgr, addr, range) &&
> -	       !drm_gpuva_in_kernel_node(mgr, addr, range);
> +	return !drm_gpuvm_check_overflow(addr, range) &&
> +	       drm_gpuvm_in_mm_range(gpuvm, addr, range) &&
> +	       !drm_gpuvm_in_kernel_node(gpuvm, addr, range);
>   }
>   
>   /**
> - * drm_gpuva_manager_init() - initialize a &drm_gpuva_manager
> - * @mgr: pointer to the &drm_gpuva_manager to initialize
> + * drm_gpuvm_init() - initialize a &drm_gpuvm
> + * @gpuvm: pointer to the &drm_gpuvm to initialize
>    * @name: the name of the GPU VA space
>    * @start_offset: the start offset of the GPU VA space
>    * @range: the size of the GPU VA space
>    * @reserve_offset: the start of the kernel reserved GPU VA area
>    * @reserve_range: the size of the kernel reserved GPU VA area
> - * @ops: &drm_gpuva_fn_ops called on &drm_gpuva_sm_map /
&drm_gpuva_sm_unmap
> + * @ops: &drm_gpuvm_ops called on &drm_gpuvm_sm_map /
&drm_gpuvm_sm_unmap
>    *
> - * The &drm_gpuva_manager must be initialized with this function
before use.
> + * The &drm_gpuvm must be initialized with this function before use.
>    *
> - * Note that @mgr must be cleared to 0 before calling this function. The
given
> + * Note that @gpuvm must be cleared to 0 before calling this function. The
given
>    * &name is expected to be managed by the surrounding driver
structures.
>    */
>   void
> -drm_gpuva_manager_init(struct drm_gpuva_manager *mgr,
> -		       const char *name,
> -		       u64 start_offset, u64 range,
> -		       u64 reserve_offset, u64 reserve_range,
> -		       const struct drm_gpuva_fn_ops *ops)
> +drm_gpuvm_init(struct drm_gpuvm *gpuvm,
> +	       const char *name,
> +	       u64 start_offset, u64 range,
> +	       u64 reserve_offset, u64 reserve_range,
> +	       const struct drm_gpuvm_ops *ops)
>   {
> -	mgr->rb.tree = RB_ROOT_CACHED;
> -	INIT_LIST_HEAD(&mgr->rb.list);
> +	gpuvm->rb.tree = RB_ROOT_CACHED;
> +	INIT_LIST_HEAD(&gpuvm->rb.list);
>   
> -	drm_gpuva_check_overflow(start_offset, range);
> -	mgr->mm_start = start_offset;
> -	mgr->mm_range = range;
> +	drm_gpuvm_check_overflow(start_offset, range);
> +	gpuvm->mm_start = start_offset;
> +	gpuvm->mm_range = range;
>   
> -	mgr->name = name ? name : "unknown";
> -	mgr->ops = ops;
> +	gpuvm->name = name ? name : "unknown";
> +	gpuvm->ops = ops;
>   
> -	memset(&mgr->kernel_alloc_node, 0, sizeof(struct drm_gpuva));
> +	memset(&gpuvm->kernel_alloc_node, 0, sizeof(struct drm_gpuva));
>   
>   	if (reserve_range) {
> -		mgr->kernel_alloc_node.va.addr = reserve_offset;
> -		mgr->kernel_alloc_node.va.range = reserve_range;
> +		gpuvm->kernel_alloc_node.va.addr = reserve_offset;
> +		gpuvm->kernel_alloc_node.va.range = reserve_range;
>   
> -		if (likely(!drm_gpuva_check_overflow(reserve_offset,
> +		if (likely(!drm_gpuvm_check_overflow(reserve_offset,
>   						     reserve_range)))
> -			__drm_gpuva_insert(mgr, &mgr->kernel_alloc_node);
> +			__drm_gpuva_insert(gpuvm, &gpuvm->kernel_alloc_node);
>   	}
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_manager_init);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_init);
>   
>   /**
> - * drm_gpuva_manager_destroy() - cleanup a &drm_gpuva_manager
> - * @mgr: pointer to the &drm_gpuva_manager to clean up
> + * drm_gpuvm_destroy() - cleanup a &drm_gpuvm
> + * @gpuvm: pointer to the &drm_gpuvm to clean up
>    *
>    * Note that it is a bug to call this function on a manager that still
>    * holds GPU VA mappings.
>    */
>   void
> -drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr)
> +drm_gpuvm_destroy(struct drm_gpuvm *gpuvm)
>   {
> -	mgr->name = NULL;
> +	gpuvm->name = NULL;
>   
> -	if (mgr->kernel_alloc_node.va.range)
> -		__drm_gpuva_remove(&mgr->kernel_alloc_node);
> +	if (gpuvm->kernel_alloc_node.va.range)
> +		__drm_gpuva_remove(&gpuvm->kernel_alloc_node);
>   
> -	WARN(!RB_EMPTY_ROOT(&mgr->rb.tree.rb_root),
> +	WARN(!RB_EMPTY_ROOT(&gpuvm->rb.tree.rb_root),
>   	     "GPUVA tree is not empty, potentially leaking memory.");
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_manager_destroy);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_destroy);
>   
>   static int
> -__drm_gpuva_insert(struct drm_gpuva_manager *mgr,
> +__drm_gpuva_insert(struct drm_gpuvm *gpuvm,
>   		   struct drm_gpuva *va)
>   {
>   	struct rb_node *node;
>   	struct list_head *head;
>   
> -	if (drm_gpuva_it_iter_first(&mgr->rb.tree,
> +	if (drm_gpuva_it_iter_first(&gpuvm->rb.tree,
>   				    GPUVA_START(va),
>   				    GPUVA_LAST(va)))
>   		return -EEXIST;
>   
> -	va->mgr = mgr;
> +	va->vm = gpuvm;
>   
> -	drm_gpuva_it_insert(va, &mgr->rb.tree);
> +	drm_gpuva_it_insert(va, &gpuvm->rb.tree);
>   
>   	node = rb_prev(&va->rb.node);
>   	if (node)
>   		head = &(to_drm_gpuva(node))->rb.entry;
>   	else
> -		head = &mgr->rb.list;
> +		head = &gpuvm->rb.list;
>   
>   	list_add(&va->rb.entry, head);
>   
> @@ -746,36 +746,36 @@ __drm_gpuva_insert(struct drm_gpuva_manager *mgr,
>   
>   /**
>    * drm_gpuva_insert() - insert a &drm_gpuva
> - * @mgr: the &drm_gpuva_manager to insert the &drm_gpuva in
> + * @gpuvm: the &drm_gpuvm to insert the &drm_gpuva in
>    * @va: the &drm_gpuva to insert
>    *
>    * Insert a &drm_gpuva with a given address and range into a
> - * &drm_gpuva_manager.
> + * &drm_gpuvm.
>    *
>    * It is safe to use this function using the safe versions of iterating
the GPU
> - * VA space, such as drm_gpuva_for_each_va_safe() and
> - * drm_gpuva_for_each_va_range_safe().
> + * VA space, such as drm_gpuvm_for_each_va_safe() and
> + * drm_gpuvm_for_each_va_range_safe().
>    *
>    * Returns: 0 on success, negative error code on failure.
>    */
>   int
> -drm_gpuva_insert(struct drm_gpuva_manager *mgr,
> +drm_gpuva_insert(struct drm_gpuvm *gpuvm,
>   		 struct drm_gpuva *va)
>   {
>   	u64 addr = va->va.addr;
>   	u64 range = va->va.range;
>   
> -	if (unlikely(!drm_gpuva_range_valid(mgr, addr, range)))
> +	if (unlikely(!drm_gpuva_range_valid(gpuvm, addr, range)))
>   		return -EINVAL;
>   
> -	return __drm_gpuva_insert(mgr, va);
> +	return __drm_gpuva_insert(gpuvm, va);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_insert);
>   
>   static void
>   __drm_gpuva_remove(struct drm_gpuva *va)
>   {
> -	drm_gpuva_it_remove(va, &va->mgr->rb.tree);
> +	drm_gpuva_it_remove(va, &va->vm->rb.tree);
>   	list_del_init(&va->rb.entry);
>   }
>   
> @@ -786,15 +786,15 @@ __drm_gpuva_remove(struct drm_gpuva *va)
>    * This removes the given &va from the underlaying tree.
>    *
>    * It is safe to use this function using the safe versions of iterating
the GPU
> - * VA space, such as drm_gpuva_for_each_va_safe() and
> - * drm_gpuva_for_each_va_range_safe().
> + * VA space, such as drm_gpuvm_for_each_va_safe() and
> + * drm_gpuvm_for_each_va_range_safe().
>    */
>   void
>   drm_gpuva_remove(struct drm_gpuva *va)
>   {
> -	struct drm_gpuva_manager *mgr = va->mgr;
> +	struct drm_gpuvm *gpuvm = va->vm;
>   
> -	if (unlikely(va == &mgr->kernel_alloc_node)) {
> +	if (unlikely(va == &gpuvm->kernel_alloc_node)) {
>   		WARN(1, "Can't destroy kernel reserved node.\n");
>   		return;
>   	}
> @@ -853,37 +853,37 @@ EXPORT_SYMBOL_GPL(drm_gpuva_unlink);
>   
>   /**
>    * drm_gpuva_find_first() - find the first &drm_gpuva in the given
range
> - * @mgr: the &drm_gpuva_manager to search in
> + * @gpuvm: the &drm_gpuvm to search in
>    * @addr: the &drm_gpuvas address
>    * @range: the &drm_gpuvas range
>    *
>    * Returns: the first &drm_gpuva within the given range
>    */
>   struct drm_gpuva *
> -drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
> +drm_gpuva_find_first(struct drm_gpuvm *gpuvm,
>   		     u64 addr, u64 range)
>   {
>   	u64 last = addr + range - 1;
>   
> -	return drm_gpuva_it_iter_first(&mgr->rb.tree, addr, last);
> +	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, addr, last);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_find_first);
>   
>   /**
>    * drm_gpuva_find() - find a &drm_gpuva
> - * @mgr: the &drm_gpuva_manager to search in
> + * @gpuvm: the &drm_gpuvm to search in
>    * @addr: the &drm_gpuvas address
>    * @range: the &drm_gpuvas range
>    *
>    * Returns: the &drm_gpuva at a given &addr and with a given
&range
>    */
>   struct drm_gpuva *
> -drm_gpuva_find(struct drm_gpuva_manager *mgr,
> +drm_gpuva_find(struct drm_gpuvm *gpuvm,
>   	       u64 addr, u64 range)
>   {
>   	struct drm_gpuva *va;
>   
> -	va = drm_gpuva_find_first(mgr, addr, range);
> +	va = drm_gpuva_find_first(gpuvm, addr, range);
>   	if (!va)
>   		goto out;
>   
> @@ -900,7 +900,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find);
>   
>   /**
>    * drm_gpuva_find_prev() - find the &drm_gpuva before the given
address
> - * @mgr: the &drm_gpuva_manager to search in
> + * @gpuvm: the &drm_gpuvm to search in
>    * @start: the given GPU VA's start address
>    *
>    * Find the adjacent &drm_gpuva before the GPU VA with given
&start address.
> @@ -911,18 +911,18 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find);
>    * Returns: a pointer to the found &drm_gpuva or NULL if none was
found
>    */
>   struct drm_gpuva *
> -drm_gpuva_find_prev(struct drm_gpuva_manager *mgr, u64 start)
> +drm_gpuva_find_prev(struct drm_gpuvm *gpuvm, u64 start)
>   {
> -	if (!drm_gpuva_range_valid(mgr, start - 1, 1))
> +	if (!drm_gpuva_range_valid(gpuvm, start - 1, 1))
>   		return NULL;
>   
> -	return drm_gpuva_it_iter_first(&mgr->rb.tree, start - 1, start);
> +	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, start - 1, start);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_find_prev);
>   
>   /**
>    * drm_gpuva_find_next() - find the &drm_gpuva after the given
address
> - * @mgr: the &drm_gpuva_manager to search in
> + * @gpuvm: the &drm_gpuvm to search in
>    * @end: the given GPU VA's end address
>    *
>    * Find the adjacent &drm_gpuva after the GPU VA with given &end
address.
> @@ -933,47 +933,47 @@ EXPORT_SYMBOL_GPL(drm_gpuva_find_prev);
>    * Returns: a pointer to the found &drm_gpuva or NULL if none was
found
>    */
>   struct drm_gpuva *
> -drm_gpuva_find_next(struct drm_gpuva_manager *mgr, u64 end)
> +drm_gpuva_find_next(struct drm_gpuvm *gpuvm, u64 end)
>   {
> -	if (!drm_gpuva_range_valid(mgr, end, 1))
> +	if (!drm_gpuva_range_valid(gpuvm, end, 1))
>   		return NULL;
>   
> -	return drm_gpuva_it_iter_first(&mgr->rb.tree, end, end + 1);
> +	return drm_gpuva_it_iter_first(&gpuvm->rb.tree, end, end + 1);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_find_next);
>   
>   /**
>    * drm_gpuva_interval_empty() - indicate whether a given interval of the
VA space
>    * is empty
> - * @mgr: the &drm_gpuva_manager to check the range for
> + * @gpuvm: the &drm_gpuvm to check the range for
>    * @addr: the start address of the range
>    * @range: the range of the interval
>    *
>    * Returns: true if the interval is empty, false otherwise
>    */
>   bool
> -drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 addr, u64
range)
> +drm_gpuva_interval_empty(struct drm_gpuvm *gpuvm, u64 addr, u64 range)
>   {
> -	return !drm_gpuva_find_first(mgr, addr, range);
> +	return !drm_gpuva_find_first(gpuvm, addr, range);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_interval_empty);
>   
>   /**
>    * drm_gpuva_map() - helper to insert a &drm_gpuva according to a
>    * &drm_gpuva_op_map
> - * @mgr: the &drm_gpuva_manager
> + * @gpuvm: the &drm_gpuvm
>    * @va: the &drm_gpuva to insert
>    * @op: the &drm_gpuva_op_map to initialize @va with
>    *
> - * Initializes the @va from the @op and inserts it into the given @mgr.
> + * Initializes the @va from the @op and inserts it into the given @gpuvm.
>    */
>   void
> -drm_gpuva_map(struct drm_gpuva_manager *mgr,
> +drm_gpuva_map(struct drm_gpuvm *gpuvm,
>   	      struct drm_gpuva *va,
>   	      struct drm_gpuva_op_map *op)
>   {
>   	drm_gpuva_init_from_op(va, op);
> -	drm_gpuva_insert(mgr, va);
> +	drm_gpuva_insert(gpuvm, va);
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_map);
>   
> @@ -993,18 +993,18 @@ drm_gpuva_remap(struct drm_gpuva *prev,
>   		struct drm_gpuva_op_remap *op)
>   {
>   	struct drm_gpuva *curr = op->unmap->va;
> -	struct drm_gpuva_manager *mgr = curr->mgr;
> +	struct drm_gpuvm *gpuvm = curr->vm;
>   
>   	drm_gpuva_remove(curr);
>   
>   	if (op->prev) {
>   		drm_gpuva_init_from_op(prev, op->prev);
> -		drm_gpuva_insert(mgr, prev);
> +		drm_gpuva_insert(gpuvm, prev);
>   	}
>   
>   	if (op->next) {
>   		drm_gpuva_init_from_op(next, op->next);
> -		drm_gpuva_insert(mgr, next);
> +		drm_gpuva_insert(gpuvm, next);
>   	}
>   }
>   EXPORT_SYMBOL_GPL(drm_gpuva_remap);
> @@ -1024,7 +1024,7 @@ drm_gpuva_unmap(struct drm_gpuva_op_unmap *op)
>   EXPORT_SYMBOL_GPL(drm_gpuva_unmap);
>   
>   static int
> -op_map_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
> +op_map_cb(const struct drm_gpuvm_ops *fn, void *priv,
>   	  u64 addr, u64 range,
>   	  struct drm_gem_object *obj, u64 offset)
>   {
> @@ -1040,7 +1040,7 @@ op_map_cb(const struct drm_gpuva_fn_ops *fn, void
*priv,
>   }
>   
>   static int
> -op_remap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
> +op_remap_cb(const struct drm_gpuvm_ops *fn, void *priv,
>   	    struct drm_gpuva_op_map *prev,
>   	    struct drm_gpuva_op_map *next,
>   	    struct drm_gpuva_op_unmap *unmap)
> @@ -1058,7 +1058,7 @@ op_remap_cb(const struct drm_gpuva_fn_ops *fn, void
*priv,
>   }
>   
>   static int
> -op_unmap_cb(const struct drm_gpuva_fn_ops *fn, void *priv,
> +op_unmap_cb(const struct drm_gpuvm_ops *fn, void *priv,
>   	    struct drm_gpuva *va, bool merge)
>   {
>   	struct drm_gpuva_op op = {};
> @@ -1071,8 +1071,8 @@ op_unmap_cb(const struct drm_gpuva_fn_ops *fn, void
*priv,
>   }
>   
>   static int
> -__drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
> -		   const struct drm_gpuva_fn_ops *ops, void *priv,
> +__drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm,
> +		   const struct drm_gpuvm_ops *ops, void *priv,
>   		   u64 req_addr, u64 req_range,
>   		   struct drm_gem_object *req_obj, u64 req_offset)
>   {
> @@ -1080,10 +1080,10 @@ __drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
>   	u64 req_end = req_addr + req_range;
>   	int ret;
>   
> -	if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
> +	if (unlikely(!drm_gpuva_range_valid(gpuvm, req_addr, req_range)))
>   		return -EINVAL;
>   
> -	drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
> +	drm_gpuvm_for_each_va_range_safe(va, next, gpuvm, req_addr, req_end) {
>   		struct drm_gem_object *obj = va->gem.obj;
>   		u64 offset = va->gem.offset;
>   		u64 addr = va->va.addr;
> @@ -1215,18 +1215,18 @@ __drm_gpuva_sm_map(struct drm_gpuva_manager *mgr,
>   }
>   
>   static int
> -__drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
> -		     const struct drm_gpuva_fn_ops *ops, void *priv,
> +__drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm,
> +		     const struct drm_gpuvm_ops *ops, void *priv,
>   		     u64 req_addr, u64 req_range)
>   {
>   	struct drm_gpuva *va, *next;
>   	u64 req_end = req_addr + req_range;
>   	int ret;
>   
> -	if (unlikely(!drm_gpuva_range_valid(mgr, req_addr, req_range)))
> +	if (unlikely(!drm_gpuva_range_valid(gpuvm, req_addr, req_range)))
>   		return -EINVAL;
>   
> -	drm_gpuva_for_each_va_range_safe(va, next, mgr, req_addr, req_end) {
> +	drm_gpuvm_for_each_va_range_safe(va, next, gpuvm, req_addr, req_end) {
>   		struct drm_gpuva_op_map prev = {}, next = {};
>   		bool prev_split = false, next_split = false;
>   		struct drm_gem_object *obj = va->gem.obj;
> @@ -1273,8 +1273,8 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
>   }
>   
>   /**
> - * drm_gpuva_sm_map() - creates the &drm_gpuva_op split/merge steps
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * drm_gpuvm_sm_map() - creates the &drm_gpuva_op split/merge steps
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @req_addr: the start address of the new mapping
>    * @req_range: the range of the new mapping
>    * @req_obj: the &drm_gem_object to map
> @@ -1282,15 +1282,15 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
>    * @priv: pointer to a driver private data structure
>    *
>    * This function iterates the given range of the GPU VA space. It
utilizes the
> - * &drm_gpuva_fn_ops to call back into the driver providing the split
and merge
> + * &drm_gpuvm_ops to call back into the driver providing the split and
merge
>    * steps.
>    *
>    * Drivers may use these callbacks to update the GPU VA space right away
within
>    * the callback. In case the driver decides to copy and store the
operations for
> - * later processing neither this function nor &drm_gpuva_sm_unmap is
allowed to
> - * be called before the &drm_gpuva_manager's view of the GPU VA
space was
> + * later processing neither this function nor &drm_gpuvm_sm_unmap is
allowed to
> + * be called before the &drm_gpuvm's view of the GPU VA space was
>    * updated with the previous set of operations. To update the
> - * &drm_gpuva_manager's view of the GPU VA space
drm_gpuva_insert(),
> + * &drm_gpuvm's view of the GPU VA space drm_gpuva_insert(),
>    * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should
be
>    * used.
>    *
> @@ -1305,39 +1305,39 @@ __drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr,
>    * Returns: 0 on success or a negative error code
>    */
>   int
> -drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
> +drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm, void *priv,
>   		 u64 req_addr, u64 req_range,
>   		 struct drm_gem_object *req_obj, u64 req_offset)
>   {
> -	const struct drm_gpuva_fn_ops *ops = mgr->ops;
> +	const struct drm_gpuvm_ops *ops = gpuvm->ops;
>   
>   	if (unlikely(!(ops && ops->sm_step_map &&
>   		       ops->sm_step_remap &&
>   		       ops->sm_step_unmap)))
>   		return -EINVAL;
>   
> -	return __drm_gpuva_sm_map(mgr, ops, priv,
> +	return __drm_gpuvm_sm_map(gpuvm, ops, priv,
>   				  req_addr, req_range,
>   				  req_obj, req_offset);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_sm_map);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_sm_map);
>   
>   /**
> - * drm_gpuva_sm_unmap() - creates the &drm_gpuva_ops to split on unmap
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * drm_gpuvm_sm_unmap() - creates the &drm_gpuva_ops to split on unmap
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @priv: pointer to a driver private data structure
>    * @req_addr: the start address of the range to unmap
>    * @req_range: the range of the mappings to unmap
>    *
>    * This function iterates the given range of the GPU VA space. It
utilizes the
> - * &drm_gpuva_fn_ops to call back into the driver providing the
operations to
> + * &drm_gpuvm_ops to call back into the driver providing the
operations to
>    * unmap and, if required, split existent mappings.
>    *
>    * Drivers may use these callbacks to update the GPU VA space right away
within
>    * the callback. In case the driver decides to copy and store the
operations for
> - * later processing neither this function nor &drm_gpuva_sm_map is
allowed to be
> - * called before the &drm_gpuva_manager's view of the GPU VA space
was updated
> - * with the previous set of operations. To update the
&drm_gpuva_manager's view
> + * later processing neither this function nor &drm_gpuvm_sm_map is
allowed to be
> + * called before the &drm_gpuvm's view of the GPU VA space was
updated
> + * with the previous set of operations. To update the &drm_gpuvm's
view
>    * of the GPU VA space drm_gpuva_insert(), drm_gpuva_destroy_locked()
and/or
>    * drm_gpuva_destroy_unlocked() should be used.
>    *
> @@ -1350,24 +1350,24 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map);
>    * Returns: 0 on success or a negative error code
>    */
>   int
> -drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
> +drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm, void *priv,
>   		   u64 req_addr, u64 req_range)
>   {
> -	const struct drm_gpuva_fn_ops *ops = mgr->ops;
> +	const struct drm_gpuvm_ops *ops = gpuvm->ops;
>   
>   	if (unlikely(!(ops && ops->sm_step_remap &&
>   		       ops->sm_step_unmap)))
>   		return -EINVAL;
>   
> -	return __drm_gpuva_sm_unmap(mgr, ops, priv,
> +	return __drm_gpuvm_sm_unmap(gpuvm, ops, priv,
>   				    req_addr, req_range);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_sm_unmap);
>   
>   static struct drm_gpuva_op *
> -gpuva_op_alloc(struct drm_gpuva_manager *mgr)
> +gpuva_op_alloc(struct drm_gpuvm *gpuvm)
>   {
> -	const struct drm_gpuva_fn_ops *fn = mgr->ops;
> +	const struct drm_gpuvm_ops *fn = gpuvm->ops;
>   	struct drm_gpuva_op *op;
>   
>   	if (fn && fn->op_alloc)
> @@ -1382,10 +1382,10 @@ gpuva_op_alloc(struct drm_gpuva_manager *mgr)
>   }
>   
>   static void
> -gpuva_op_free(struct drm_gpuva_manager *mgr,
> +gpuva_op_free(struct drm_gpuvm *gpuvm,
>   	      struct drm_gpuva_op *op)
>   {
> -	const struct drm_gpuva_fn_ops *fn = mgr->ops;
> +	const struct drm_gpuvm_ops *fn = gpuvm->ops;
>   
>   	if (fn && fn->op_free)
>   		fn->op_free(op);
> @@ -1398,14 +1398,14 @@ drm_gpuva_sm_step(struct drm_gpuva_op *__op,
>   		  void *priv)
>   {
>   	struct {
> -		struct drm_gpuva_manager *mgr;
> +		struct drm_gpuvm *vm;
>   		struct drm_gpuva_ops *ops;
>   	} *args = priv;
> -	struct drm_gpuva_manager *mgr = args->mgr;
> +	struct drm_gpuvm *gpuvm = args->vm;
>   	struct drm_gpuva_ops *ops = args->ops;
>   	struct drm_gpuva_op *op;
>   
> -	op = gpuva_op_alloc(mgr);
> +	op = gpuva_op_alloc(gpuvm);
>   	if (unlikely(!op))
>   		goto err;
>   
> @@ -1444,20 +1444,20 @@ drm_gpuva_sm_step(struct drm_gpuva_op *__op,
>   err_free_prev:
>   	kfree(op->remap.prev);
>   err_free_op:
> -	gpuva_op_free(mgr, op);
> +	gpuva_op_free(gpuvm, op);
>   err:
>   	return -ENOMEM;
>   }
>   
> -static const struct drm_gpuva_fn_ops gpuva_list_ops = {
> +static const struct drm_gpuvm_ops gpuvm_list_ops = {
>   	.sm_step_map = drm_gpuva_sm_step,
>   	.sm_step_remap = drm_gpuva_sm_step,
>   	.sm_step_unmap = drm_gpuva_sm_step,
>   };
>   
>   /**
> - * drm_gpuva_sm_map_ops_create() - creates the &drm_gpuva_ops to split
and merge
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * drm_gpuvm_sm_map_ops_create() - creates the &drm_gpuva_ops to split
and merge
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @req_addr: the start address of the new mapping
>    * @req_range: the range of the new mapping
>    * @req_obj: the &drm_gem_object to map
> @@ -1476,9 +1476,9 @@ static const struct drm_gpuva_fn_ops gpuva_list_ops =
{
>    * map operation requested by the caller.
>    *
>    * Note that before calling this function again with another mapping
request it
> - * is necessary to update the &drm_gpuva_manager's view of the GPU
VA space. The
> + * is necessary to update the &drm_gpuvm's view of the GPU VA
space. The
>    * previously obtained operations must be either processed or abandoned.
To
> - * update the &drm_gpuva_manager's view of the GPU VA space
drm_gpuva_insert(),
> + * update the &drm_gpuvm's view of the GPU VA space
drm_gpuva_insert(),
>    * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should
be
>    * used.
>    *
> @@ -1488,13 +1488,13 @@ static const struct drm_gpuva_fn_ops gpuva_list_ops
= {
>    * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
>    */
>   struct drm_gpuva_ops *
> -drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_sm_map_ops_create(struct drm_gpuvm *gpuvm,
>   			    u64 req_addr, u64 req_range,
>   			    struct drm_gem_object *req_obj, u64 req_offset)
>   {
>   	struct drm_gpuva_ops *ops;
>   	struct {
> -		struct drm_gpuva_manager *mgr;
> +		struct drm_gpuvm *vm;
>   		struct drm_gpuva_ops *ops;
>   	} args;
>   	int ret;
> @@ -1505,10 +1505,10 @@ drm_gpuva_sm_map_ops_create(struct
drm_gpuva_manager *mgr,
>   
>   	INIT_LIST_HEAD(&ops->list);
>   
> -	args.mgr = mgr;
> +	args.vm = gpuvm;
>   	args.ops = ops;
>   
> -	ret = __drm_gpuva_sm_map(mgr, &gpuva_list_ops, &args,
> +	ret = __drm_gpuvm_sm_map(gpuvm, &gpuvm_list_ops, &args,
>   				 req_addr, req_range,
>   				 req_obj, req_offset);
>   	if (ret)
> @@ -1517,15 +1517,15 @@ drm_gpuva_sm_map_ops_create(struct
drm_gpuva_manager *mgr,
>   	return ops;
>   
>   err_free_ops:
> -	drm_gpuva_ops_free(mgr, ops);
> +	drm_gpuva_ops_free(gpuvm, ops);
>   	return ERR_PTR(ret);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_sm_map_ops_create);
>   
>   /**
> - * drm_gpuva_sm_unmap_ops_create() - creates the &drm_gpuva_ops to
split on
> + * drm_gpuvm_sm_unmap_ops_create() - creates the &drm_gpuva_ops to
split on
>    * unmap
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @req_addr: the start address of the range to unmap
>    * @req_range: the range of the mappings to unmap
>    *
> @@ -1540,9 +1540,9 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
>    * remap operations.
>    *
>    * Note that before calling this function again with another range to
unmap it
> - * is necessary to update the &drm_gpuva_manager's view of the GPU
VA space. The
> + * is necessary to update the &drm_gpuvm's view of the GPU VA
space. The
>    * previously obtained operations must be processed or abandoned. To
update the
> - * &drm_gpuva_manager's view of the GPU VA space
drm_gpuva_insert(),
> + * &drm_gpuvm's view of the GPU VA space drm_gpuva_insert(),
>    * drm_gpuva_destroy_locked() and/or drm_gpuva_destroy_unlocked() should
be
>    * used.
>    *
> @@ -1552,12 +1552,12 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_map_ops_create);
>    * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
>    */
>   struct drm_gpuva_ops *
> -drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_sm_unmap_ops_create(struct drm_gpuvm *gpuvm,
>   			      u64 req_addr, u64 req_range)
>   {
>   	struct drm_gpuva_ops *ops;
>   	struct {
> -		struct drm_gpuva_manager *mgr;
> +		struct drm_gpuvm *vm;
>   		struct drm_gpuva_ops *ops;
>   	} args;
>   	int ret;
> @@ -1568,10 +1568,10 @@ drm_gpuva_sm_unmap_ops_create(struct
drm_gpuva_manager *mgr,
>   
>   	INIT_LIST_HEAD(&ops->list);
>   
> -	args.mgr = mgr;
> +	args.vm = gpuvm;
>   	args.ops = ops;
>   
> -	ret = __drm_gpuva_sm_unmap(mgr, &gpuva_list_ops, &args,
> +	ret = __drm_gpuvm_sm_unmap(gpuvm, &gpuvm_list_ops, &args,
>   				   req_addr, req_range);
>   	if (ret)
>   		goto err_free_ops;
> @@ -1579,14 +1579,14 @@ drm_gpuva_sm_unmap_ops_create(struct
drm_gpuva_manager *mgr,
>   	return ops;
>   
>   err_free_ops:
> -	drm_gpuva_ops_free(mgr, ops);
> +	drm_gpuva_ops_free(gpuvm, ops);
>   	return ERR_PTR(ret);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap_ops_create);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_sm_unmap_ops_create);
>   
>   /**
> - * drm_gpuva_prefetch_ops_create() - creates the &drm_gpuva_ops to
prefetch
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * drm_gpuvm_prefetch_ops_create() - creates the &drm_gpuva_ops to
prefetch
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @addr: the start address of the range to prefetch
>    * @range: the range of the mappings to prefetch
>    *
> @@ -1603,7 +1603,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_sm_unmap_ops_create);
>    * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
>    */
>   struct drm_gpuva_ops *
> -drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_prefetch_ops_create(struct drm_gpuvm *gpuvm,
>   			      u64 addr, u64 range)
>   {
>   	struct drm_gpuva_ops *ops;
> @@ -1618,8 +1618,8 @@ drm_gpuva_prefetch_ops_create(struct
drm_gpuva_manager *mgr,
>   
>   	INIT_LIST_HEAD(&ops->list);
>   
> -	drm_gpuva_for_each_va_range(va, mgr, addr, end) {
> -		op = gpuva_op_alloc(mgr);
> +	drm_gpuvm_for_each_va_range(va, gpuvm, addr, end) {
> +		op = gpuva_op_alloc(gpuvm);
>   		if (!op) {
>   			ret = -ENOMEM;
>   			goto err_free_ops;
> @@ -1633,14 +1633,14 @@ drm_gpuva_prefetch_ops_create(struct
drm_gpuva_manager *mgr,
>   	return ops;
>   
>   err_free_ops:
> -	drm_gpuva_ops_free(mgr, ops);
> +	drm_gpuva_ops_free(gpuvm, ops);
>   	return ERR_PTR(ret);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_prefetch_ops_create);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_prefetch_ops_create);
>   
>   /**
> - * drm_gpuva_gem_unmap_ops_create() - creates the &drm_gpuva_ops to
unmap a GEM
> - * @mgr: the &drm_gpuva_manager representing the GPU VA space
> + * drm_gpuvm_gem_unmap_ops_create() - creates the &drm_gpuva_ops to
unmap a GEM
> + * @gpuvm: the &drm_gpuvm representing the GPU VA space
>    * @obj: the &drm_gem_object to unmap
>    *
>    * This function creates a list of operations to perform unmapping for
every
> @@ -1658,7 +1658,7 @@ EXPORT_SYMBOL_GPL(drm_gpuva_prefetch_ops_create);
>    * Returns: a pointer to the &drm_gpuva_ops on success, an ERR_PTR on
failure
>    */
>   struct drm_gpuva_ops *
> -drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_gem_unmap_ops_create(struct drm_gpuvm *gpuvm,
>   			       struct drm_gem_object *obj)
>   {
>   	struct drm_gpuva_ops *ops;
> @@ -1675,7 +1675,7 @@ drm_gpuva_gem_unmap_ops_create(struct
drm_gpuva_manager *mgr,
>   	INIT_LIST_HEAD(&ops->list);
>   
>   	drm_gem_for_each_gpuva(va, obj) {
> -		op = gpuva_op_alloc(mgr);
> +		op = gpuva_op_alloc(gpuvm);
>   		if (!op) {
>   			ret = -ENOMEM;
>   			goto err_free_ops;
> @@ -1689,21 +1689,21 @@ drm_gpuva_gem_unmap_ops_create(struct
drm_gpuva_manager *mgr,
>   	return ops;
>   
>   err_free_ops:
> -	drm_gpuva_ops_free(mgr, ops);
> +	drm_gpuva_ops_free(gpuvm, ops);
>   	return ERR_PTR(ret);
>   }
> -EXPORT_SYMBOL_GPL(drm_gpuva_gem_unmap_ops_create);
> +EXPORT_SYMBOL_GPL(drm_gpuvm_gem_unmap_ops_create);
>   
>   /**
>    * drm_gpuva_ops_free() - free the given &drm_gpuva_ops
> - * @mgr: the &drm_gpuva_manager the ops were created for
> + * @gpuvm: the &drm_gpuvm the ops were created for
>    * @ops: the &drm_gpuva_ops to free
>    *
>    * Frees the given &drm_gpuva_ops structure including all the ops
associated
>    * with it.
>    */
>   void
> -drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
> +drm_gpuva_ops_free(struct drm_gpuvm *gpuvm,
>   		   struct drm_gpuva_ops *ops)
>   {
>   	struct drm_gpuva_op *op, *next;
> @@ -1717,7 +1717,7 @@ drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
>   			kfree(op->remap.unmap);
>   		}
>   
> -		gpuva_op_free(mgr, op);
> +		gpuva_op_free(gpuvm, op);
>   	}
>   
>   	kfree(ops);
> diff --git a/drivers/gpu/drm/nouveau/nouveau_exec.c
b/drivers/gpu/drm/nouveau/nouveau_exec.c
> index a90c4cd8cbb2..c001952cd678 100644
> --- a/drivers/gpu/drm/nouveau/nouveau_exec.c
> +++ b/drivers/gpu/drm/nouveau/nouveau_exec.c
> @@ -106,7 +106,7 @@ nouveau_exec_job_submit(struct nouveau_job *job)
>   	drm_exec_until_all_locked(exec) {
>   		struct drm_gpuva *va;
>   
> -		drm_gpuva_for_each_va(va, &uvmm->umgr) {
> +		drm_gpuvm_for_each_va(va, &uvmm->umgr) {
>   			if (unlikely(va == &uvmm->umgr.kernel_alloc_node))
>   				continue;
>   
> diff --git a/drivers/gpu/drm/nouveau/nouveau_uvmm.c
b/drivers/gpu/drm/nouveau/nouveau_uvmm.c
> index aae780e4a4aa..c750072cb268 100644
> --- a/drivers/gpu/drm/nouveau/nouveau_uvmm.c
> +++ b/drivers/gpu/drm/nouveau/nouveau_uvmm.c
> @@ -444,7 +444,7 @@ op_map_prepare_unwind(struct nouveau_uvma *uvma)
>   static void
>   op_unmap_prepare_unwind(struct drm_gpuva *va)
>   {
> -	drm_gpuva_insert(va->mgr, va);
> +	drm_gpuva_insert(va->vm, va);
>   }
>   
>   static void
> @@ -1194,7 +1194,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
>   				goto unwind_continue;
>   			}
>   
> -			op->ops = drm_gpuva_sm_unmap_ops_create(&uvmm->umgr,
> +			op->ops = drm_gpuvm_sm_unmap_ops_create(&uvmm->umgr,
>   								op->va.addr,
>   								op->va.range);
>   			if (IS_ERR(op->ops)) {
> @@ -1240,7 +1240,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
>   				}
>   			}
>   
> -			op->ops = drm_gpuva_sm_map_ops_create(&uvmm->umgr,
> +			op->ops = drm_gpuvm_sm_map_ops_create(&uvmm->umgr,
>   							      op->va.addr,
>   							      op->va.range,
>   							      op->gem.obj,
> @@ -1264,7 +1264,7 @@ nouveau_uvmm_bind_job_submit(struct nouveau_job *job)
>   			break;
>   		}
>   		case OP_UNMAP:
> -			op->ops = drm_gpuva_sm_unmap_ops_create(&uvmm->umgr,
> +			op->ops = drm_gpuvm_sm_unmap_ops_create(&uvmm->umgr,
>   								op->va.addr,
>   								op->va.range);
>   			if (IS_ERR(op->ops)) {
> @@ -1836,11 +1836,11 @@ nouveau_uvmm_init(struct nouveau_uvmm *uvmm, struct
nouveau_cli *cli,
>   	uvmm->kernel_managed_addr = kernel_managed_addr;
>   	uvmm->kernel_managed_size = kernel_managed_size;
>   
> -	drm_gpuva_manager_init(&uvmm->umgr, cli->name,
> -			       NOUVEAU_VA_SPACE_START,
> -			       NOUVEAU_VA_SPACE_END,
> -			       kernel_managed_addr, kernel_managed_size,
> -			       NULL);
> +	drm_gpuvm_init(&uvmm->umgr, cli->name,
> +		       NOUVEAU_VA_SPACE_START,
> +		       NOUVEAU_VA_SPACE_END,
> +		       kernel_managed_addr, kernel_managed_size,
> +		       NULL);
>   
>   	ret = nvif_vmm_ctor(&cli->mmu, "uvmm",
>   			    cli->vmm.vmm.object.oclass, RAW,
> @@ -1855,7 +1855,7 @@ nouveau_uvmm_init(struct nouveau_uvmm *uvmm, struct
nouveau_cli *cli,
>   	return 0;
>   
>   out_free_gpuva_mgr:
> -	drm_gpuva_manager_destroy(&uvmm->umgr);
> +	drm_gpuvm_destroy(&uvmm->umgr);
>   out_unlock:
>   	mutex_unlock(&cli->mutex);
>   	return ret;
> @@ -1877,7 +1877,7 @@ nouveau_uvmm_fini(struct nouveau_uvmm *uvmm)
>   	wait_event(entity->job.wq,
list_empty(&entity->job.list.head));
>   
>   	nouveau_uvmm_lock(uvmm);
> -	drm_gpuva_for_each_va_safe(va, next, &uvmm->umgr) {
> +	drm_gpuvm_for_each_va_safe(va, next, &uvmm->umgr) {
>   		struct nouveau_uvma *uvma = uvma_from_va(va);
>   		struct drm_gem_object *obj = va->gem.obj;
>   
> @@ -1910,7 +1910,7 @@ nouveau_uvmm_fini(struct nouveau_uvmm *uvmm)
>   
>   	mutex_lock(&cli->mutex);
>   	nouveau_vmm_fini(&uvmm->vmm);
> -	drm_gpuva_manager_destroy(&uvmm->umgr);
> +	drm_gpuvm_destroy(&uvmm->umgr);
>   	mutex_unlock(&cli->mutex);
>   
>   	dma_resv_fini(&uvmm->resv);
> diff --git a/drivers/gpu/drm/nouveau/nouveau_uvmm.h
b/drivers/gpu/drm/nouveau/nouveau_uvmm.h
> index fc7f6fd2a4e1..e96c9919d1bd 100644
> --- a/drivers/gpu/drm/nouveau/nouveau_uvmm.h
> +++ b/drivers/gpu/drm/nouveau/nouveau_uvmm.h
> @@ -3,13 +3,13 @@
>   #ifndef __NOUVEAU_UVMM_H__
>   #define __NOUVEAU_UVMM_H__
>   
> -#include <drm/drm_gpuva_mgr.h>
> +#include <drm/drm_gpuvm.h>
>   
>   #include "nouveau_drv.h"
>   
>   struct nouveau_uvmm {
>   	struct nouveau_vmm vmm;
> -	struct drm_gpuva_manager umgr;
> +	struct drm_gpuvm umgr;
>   	struct maple_tree region_mt;
>   	struct mutex mutex;
>   	struct dma_resv resv;
> @@ -44,7 +44,7 @@ struct nouveau_uvma {
>   #define uvmm_from_mgr(x) container_of((x), struct nouveau_uvmm, umgr)
>   #define uvma_from_va(x) container_of((x), struct nouveau_uvma, va)
>   
> -#define to_uvmm(x) uvmm_from_mgr((x)->va.mgr)
> +#define to_uvmm(x) uvmm_from_mgr((x)->va.vm)
>   
>   struct nouveau_uvmm_bind_job {
>   	struct nouveau_job base;
> diff --git a/include/drm/drm_debugfs.h b/include/drm/drm_debugfs.h
> index 3bba169f9bae..cf06cee4343f 100644
> --- a/include/drm/drm_debugfs.h
> +++ b/include/drm/drm_debugfs.h
> @@ -35,7 +35,7 @@
>   #include <linux/types.h>
>   #include <linux/seq_file.h>
>   
> -#include <drm/drm_gpuva_mgr.h>
> +#include <drm/drm_gpuvm.h>
>   
>   /**
>    * DRM_DEBUGFS_GPUVA_INFO - &drm_info_list entry to dump a GPU VA
space
> @@ -152,7 +152,7 @@ void drm_debugfs_add_files(struct drm_device *dev,
>   			   const struct drm_debugfs_info *files, int count);
>   
>   int drm_debugfs_gpuva_info(struct seq_file *m,
> -			   struct drm_gpuva_manager *mgr);
> +			   struct drm_gpuvm *gpuvm);
>   #else
>   static inline void drm_debugfs_create_files(const struct drm_info_list
*files,
>   					    int count, struct dentry *root,
> @@ -177,7 +177,7 @@ static inline void drm_debugfs_add_files(struct
drm_device *dev,
>   {}
>   
>   static inline int drm_debugfs_gpuva_info(struct seq_file *m,
> -					 struct drm_gpuva_manager *mgr)
> +					 struct drm_gpuvm *gpuvm)
>   {
>   	return 0;
>   }
> diff --git a/include/drm/drm_gpuva_mgr.h b/include/drm/drm_gpuvm.h
> similarity index 78%
> rename from include/drm/drm_gpuva_mgr.h
> rename to include/drm/drm_gpuvm.h
> index ed8d50200cc3..0e802676e0a9 100644
> --- a/include/drm/drm_gpuva_mgr.h
> +++ b/include/drm/drm_gpuvm.h
> @@ -1,7 +1,7 @@
>   /* SPDX-License-Identifier: GPL-2.0-only */
>   
> -#ifndef __DRM_GPUVA_MGR_H__
> -#define __DRM_GPUVA_MGR_H__
> +#ifndef __DRM_GPUVM_H__
> +#define __DRM_GPUVM_H__
>   
>   /*
>    * Copyright (c) 2022 Red Hat.
> @@ -31,8 +31,8 @@
>   
>   #include <drm/drm_gem.h>
>   
> -struct drm_gpuva_manager;
> -struct drm_gpuva_fn_ops;
> +struct drm_gpuvm;
> +struct drm_gpuvm_ops;
>   
>   /**
>    * enum drm_gpuva_flags - flags for struct drm_gpuva
> @@ -62,15 +62,15 @@ enum drm_gpuva_flags {
>    * struct drm_gpuva - structure to track a GPU VA mapping
>    *
>    * This structure represents a GPU VA mapping and is associated with a
> - * &drm_gpuva_manager.
> + * &drm_gpuvm.
>    *
>    * Typically, this structure is embedded in bigger driver structures.
>    */
>   struct drm_gpuva {
>   	/**
> -	 * @mgr: the &drm_gpuva_manager this object is associated with
> +	 * @vm: the &drm_gpuvm this object is associated with
>   	 */
> -	struct drm_gpuva_manager *mgr;
> +	struct drm_gpuvm *vm;
>   
>   	/**
>   	 * @flags: the &drm_gpuva_flags for this mapping
> @@ -137,20 +137,20 @@ struct drm_gpuva {
>   	} rb;
>   };
>   
> -int drm_gpuva_insert(struct drm_gpuva_manager *mgr, struct drm_gpuva *va);
> +int drm_gpuva_insert(struct drm_gpuvm *gpuvm, struct drm_gpuva *va);
>   void drm_gpuva_remove(struct drm_gpuva *va);
>   
>   void drm_gpuva_link(struct drm_gpuva *va);
>   void drm_gpuva_unlink(struct drm_gpuva *va);
>   
> -struct drm_gpuva *drm_gpuva_find(struct drm_gpuva_manager *mgr,
> +struct drm_gpuva *drm_gpuva_find(struct drm_gpuvm *gpuvm,
>   				 u64 addr, u64 range);
> -struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuva_manager *mgr,
> +struct drm_gpuva *drm_gpuva_find_first(struct drm_gpuvm *gpuvm,
>   				       u64 addr, u64 range);
> -struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuva_manager *mgr, u64
start);
> -struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuva_manager *mgr, u64
end);
> +struct drm_gpuva *drm_gpuva_find_prev(struct drm_gpuvm *gpuvm, u64 start);
> +struct drm_gpuva *drm_gpuva_find_next(struct drm_gpuvm *gpuvm, u64 end);
>   
> -bool drm_gpuva_interval_empty(struct drm_gpuva_manager *mgr, u64 addr, u64
range);
> +bool drm_gpuva_interval_empty(struct drm_gpuvm *gpuvm, u64 addr, u64
range);
>   
>   static inline void drm_gpuva_init(struct drm_gpuva *va, u64 addr, u64
range,
>   				  struct drm_gem_object *obj, u64 offset)
> @@ -186,7 +186,7 @@ static inline bool drm_gpuva_invalidated(struct
drm_gpuva *va)
>   }
>   
>   /**
> - * struct drm_gpuva_manager - DRM GPU VA Manager
> + * struct drm_gpuvm - DRM GPU VA Manager
>    *
>    * The DRM GPU VA Manager keeps track of a GPU's virtual address
space by using
>    * &maple_tree structures. Typically, this structure is embedded in
bigger
> @@ -197,7 +197,7 @@ static inline bool drm_gpuva_invalidated(struct
drm_gpuva *va)
>    *
>    * There should be one manager instance per GPU virtual address space.
>    */
> -struct drm_gpuva_manager {
> +struct drm_gpuvm {
>   	/**
>   	 * @name: the name of the DRM GPU VA space
>   	 */
> @@ -237,100 +237,99 @@ struct drm_gpuva_manager {
>   	struct drm_gpuva kernel_alloc_node;
>   
>   	/**
> -	 * @ops: &drm_gpuva_fn_ops providing the split/merge steps to drivers
> +	 * @ops: &drm_gpuvm_ops providing the split/merge steps to drivers
>   	 */
> -	const struct drm_gpuva_fn_ops *ops;
> +	const struct drm_gpuvm_ops *ops;
>   };
>   
> -void drm_gpuva_manager_init(struct drm_gpuva_manager *mgr,
> -			    const char *name,
> -			    u64 start_offset, u64 range,
> -			    u64 reserve_offset, u64 reserve_range,
> -			    const struct drm_gpuva_fn_ops *ops);
> -void drm_gpuva_manager_destroy(struct drm_gpuva_manager *mgr);
> +void drm_gpuvm_init(struct drm_gpuvm *gpuvm, const char *name,
> +		    u64 start_offset, u64 range,
> +		    u64 reserve_offset, u64 reserve_range,
> +		    const struct drm_gpuvm_ops *ops);
> +void drm_gpuvm_destroy(struct drm_gpuvm *gpuvm);
>   
>   static inline struct drm_gpuva *
>   __drm_gpuva_next(struct drm_gpuva *va)
>   {
> -	if (va && !list_is_last(&va->rb.entry,
&va->mgr->rb.list))
> +	if (va && !list_is_last(&va->rb.entry,
&va->vm->rb.list))
>   		return list_next_entry(va, rb.entry);
>   
>   	return NULL;
>   }
>   
>   /**
> - * drm_gpuva_for_each_va_range() - iterate over a range of &drm_gpuvas
> + * drm_gpuvm_for_each_va_range() - iterate over a range of &drm_gpuvas
>    * @va__: &drm_gpuva structure to assign to in each iteration step
> - * @mgr__: &drm_gpuva_manager to walk over
> + * @gpuvm__: &drm_gpuvm to walk over
>    * @start__: starting offset, the first gpuva will overlap this
>    * @end__: ending offset, the last gpuva will start before this (but may
>    * overlap)
>    *
> - * This iterator walks over all &drm_gpuvas in the
&drm_gpuva_manager that lie
> + * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that
lie
>    * between @start__ and @end__. It is implemented similarly to
list_for_each(),
> - * but is using the &drm_gpuva_manager's internal interval tree to
accelerate
> + * but is using the &drm_gpuvm's internal interval tree to
accelerate
>    * the search for the starting &drm_gpuva, and hence isn't safe
against removal
>    * of elements. It assumes that @end__ is within (or is the upper limit
of) the
> - * &drm_gpuva_manager. This iterator does not skip over the
&drm_gpuva_manager's
> + * &drm_gpuvm. This iterator does not skip over the
&drm_gpuvm's
>    * @kernel_alloc_node.
>    */
> -#define drm_gpuva_for_each_va_range(va__, mgr__, start__, end__) \
> -	for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__) -
(start__)); \
> +#define drm_gpuvm_for_each_va_range(va__, gpuvm__, start__, end__) \
> +	for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) -
(start__)); \
>   	     va__ && (va__->va.addr < (end__)); \
>   	     va__ = __drm_gpuva_next(va__))
>   
>   /**
> - * drm_gpuva_for_each_va_range_safe() - safely iterate over a range of
> + * drm_gpuvm_for_each_va_range_safe() - safely iterate over a range of
>    * &drm_gpuvas
>    * @va__: &drm_gpuva to assign to in each iteration step
>    * @next__: another &drm_gpuva to use as temporary storage
> - * @mgr__: &drm_gpuva_manager to walk over
> + * @gpuvm__: &drm_gpuvm to walk over
>    * @start__: starting offset, the first gpuva will overlap this
>    * @end__: ending offset, the last gpuva will start before this (but may
>    * overlap)
>    *
> - * This iterator walks over all &drm_gpuvas in the
&drm_gpuva_manager that lie
> + * This iterator walks over all &drm_gpuvas in the &drm_gpuvm that
lie
>    * between @start__ and @end__. It is implemented similarly to
> - * list_for_each_safe(), but is using the &drm_gpuva_manager's
internal interval
> + * list_for_each_safe(), but is using the &drm_gpuvm's internal
interval
>    * tree to accelerate the search for the starting &drm_gpuva, and
hence is safe
>    * against removal of elements. It assumes that @end__ is within (or is
the
> - * upper limit of) the &drm_gpuva_manager. This iterator does not skip
over the
> - * &drm_gpuva_manager's @kernel_alloc_node.
> + * upper limit of) the &drm_gpuvm. This iterator does not skip over
the
> + * &drm_gpuvm's @kernel_alloc_node.
>    */
> -#define drm_gpuva_for_each_va_range_safe(va__, next__, mgr__, start__,
end__) \
> -	for (va__ = drm_gpuva_find_first((mgr__), (start__), (end__) -
(start__)), \
> +#define drm_gpuvm_for_each_va_range_safe(va__, next__, gpuvm__, start__,
end__) \
> +	for (va__ = drm_gpuva_find_first((gpuvm__), (start__), (end__) -
(start__)), \
>   	     next__ = __drm_gpuva_next(va__); \
>   	     va__ && (va__->va.addr < (end__)); \
>   	     va__ = next__, next__ = __drm_gpuva_next(va__))
>   
>   /**
> - * drm_gpuva_for_each_va() - iterate over all &drm_gpuvas
> + * drm_gpuvm_for_each_va() - iterate over all &drm_gpuvas
>    * @va__: &drm_gpuva to assign to in each iteration step
> - * @mgr__: &drm_gpuva_manager to walk over
> + * @gpuvm__: &drm_gpuvm to walk over
>    *
>    * This iterator walks over all &drm_gpuva structures associated with
the given
> - * &drm_gpuva_manager.
> + * &drm_gpuvm.
>    */
> -#define drm_gpuva_for_each_va(va__, mgr__) \
> -	list_for_each_entry(va__, &(mgr__)->rb.list, rb.entry)
> +#define drm_gpuvm_for_each_va(va__, gpuvm__) \
> +	list_for_each_entry(va__, &(gpuvm__)->rb.list, rb.entry)
>   
>   /**
> - * drm_gpuva_for_each_va_safe() - safely iterate over all &drm_gpuvas
> + * drm_gpuvm_for_each_va_safe() - safely iterate over all &drm_gpuvas
>    * @va__: &drm_gpuva to assign to in each iteration step
>    * @next__: another &drm_gpuva to use as temporary storage
> - * @mgr__: &drm_gpuva_manager to walk over
> + * @gpuvm__: &drm_gpuvm to walk over
>    *
>    * This iterator walks over all &drm_gpuva structures associated with
the given
> - * &drm_gpuva_manager. It is implemented with
list_for_each_entry_safe(), and
> + * &drm_gpuvm. It is implemented with list_for_each_entry_safe(), and
>    * hence safe against the removal of elements.
>    */
> -#define drm_gpuva_for_each_va_safe(va__, next__, mgr__) \
> -	list_for_each_entry_safe(va__, next__, &(mgr__)->rb.list,
rb.entry)
> +#define drm_gpuvm_for_each_va_safe(va__, next__, gpuvm__) \
> +	list_for_each_entry_safe(va__, next__, &(gpuvm__)->rb.list,
rb.entry)
>   
>   /**
>    * enum drm_gpuva_op_type - GPU VA operation type
>    *
> - * Operations to alter the GPU VA mappings tracked by the
&drm_gpuva_manager.
> + * Operations to alter the GPU VA mappings tracked by the &drm_gpuvm.
>    */
>   enum drm_gpuva_op_type {
>   	/**
> @@ -413,7 +412,7 @@ struct drm_gpuva_op_unmap {
>   	 *
>   	 * Optionally, if &keep is set, drivers may keep the actual page
table
>   	 * mappings for this &drm_gpuva, adding the missing page table
entries
> -	 * only and update the &drm_gpuva_manager accordingly.
> +	 * only and update the &drm_gpuvm accordingly.
>   	 */
>   	bool keep;
>   };
> @@ -584,22 +583,22 @@ struct drm_gpuva_ops {
>   #define drm_gpuva_next_op(op) list_next_entry(op, entry)
>   
>   struct drm_gpuva_ops *
> -drm_gpuva_sm_map_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_sm_map_ops_create(struct drm_gpuvm *gpuvm,
>   			    u64 addr, u64 range,
>   			    struct drm_gem_object *obj, u64 offset);
>   struct drm_gpuva_ops *
> -drm_gpuva_sm_unmap_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_sm_unmap_ops_create(struct drm_gpuvm *gpuvm,
>   			      u64 addr, u64 range);
>   
>   struct drm_gpuva_ops *
> -drm_gpuva_prefetch_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_prefetch_ops_create(struct drm_gpuvm *gpuvm,
>   				 u64 addr, u64 range);
>   
>   struct drm_gpuva_ops *
> -drm_gpuva_gem_unmap_ops_create(struct drm_gpuva_manager *mgr,
> +drm_gpuvm_gem_unmap_ops_create(struct drm_gpuvm *gpuvm,
>   			       struct drm_gem_object *obj);
>   
> -void drm_gpuva_ops_free(struct drm_gpuva_manager *mgr,
> +void drm_gpuva_ops_free(struct drm_gpuvm *gpuvm,
>   			struct drm_gpuva_ops *ops);
>   
>   static inline void drm_gpuva_init_from_op(struct drm_gpuva *va,
> @@ -610,15 +609,15 @@ static inline void drm_gpuva_init_from_op(struct
drm_gpuva *va,
>   }
>   
>   /**
> - * struct drm_gpuva_fn_ops - callbacks for split/merge steps
> + * struct drm_gpuvm_ops - callbacks for split/merge steps
>    *
> - * This structure defines the callbacks used by &drm_gpuva_sm_map and
> - * &drm_gpuva_sm_unmap to provide the split/merge steps for map and
unmap
> + * This structure defines the callbacks used by &drm_gpuvm_sm_map and
> + * &drm_gpuvm_sm_unmap to provide the split/merge steps for map and
unmap
>    * operations to drivers.
>    */
> -struct drm_gpuva_fn_ops {
> +struct drm_gpuvm_ops {
>   	/**
> -	 * @op_alloc: called when the &drm_gpuva_manager allocates
> +	 * @op_alloc: called when the &drm_gpuvm allocates
>   	 * a struct drm_gpuva_op
>   	 *
>   	 * Some drivers may want to embed struct drm_gpuva_op into driver
> @@ -630,7 +629,7 @@ struct drm_gpuva_fn_ops {
>   	struct drm_gpuva_op *(*op_alloc)(void);
>   
>   	/**
> -	 * @op_free: called when the &drm_gpuva_manager frees a
> +	 * @op_free: called when the &drm_gpuvm frees a
>   	 * struct drm_gpuva_op
>   	 *
>   	 * Some drivers may want to embed struct drm_gpuva_op into driver
> @@ -642,19 +641,19 @@ struct drm_gpuva_fn_ops {
>   	void (*op_free)(struct drm_gpuva_op *op);
>   
>   	/**
> -	 * @sm_step_map: called from &drm_gpuva_sm_map to finally insert the
> +	 * @sm_step_map: called from &drm_gpuvm_sm_map to finally insert the
>   	 * mapping once all previous steps were completed
>   	 *
>   	 * The &priv pointer matches the one the driver passed to
> -	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
> +	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
>   	 *
> -	 * Can be NULL if &drm_gpuva_sm_map is used.
> +	 * Can be NULL if &drm_gpuvm_sm_map is used.
>   	 */
>   	int (*sm_step_map)(struct drm_gpuva_op *op, void *priv);
>   
>   	/**
> -	 * @sm_step_remap: called from &drm_gpuva_sm_map and
> -	 * &drm_gpuva_sm_unmap to split up an existent mapping
> +	 * @sm_step_remap: called from &drm_gpuvm_sm_map and
> +	 * &drm_gpuvm_sm_unmap to split up an existent mapping
>   	 *
>   	 * This callback is called when existent mapping needs to be split up.
>   	 * This is the case when either a newly requested mapping overlaps or
> @@ -662,38 +661,38 @@ struct drm_gpuva_fn_ops {
>   	 * mapping is requested.
>   	 *
>   	 * The &priv pointer matches the one the driver passed to
> -	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
> +	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
>   	 *
> -	 * Can be NULL if neither &drm_gpuva_sm_map nor
&drm_gpuva_sm_unmap is
> +	 * Can be NULL if neither &drm_gpuvm_sm_map nor
&drm_gpuvm_sm_unmap is
>   	 * used.
>   	 */
>   	int (*sm_step_remap)(struct drm_gpuva_op *op, void *priv);
>   
>   	/**
> -	 * @sm_step_unmap: called from &drm_gpuva_sm_map and
> -	 * &drm_gpuva_sm_unmap to unmap an existent mapping
> +	 * @sm_step_unmap: called from &drm_gpuvm_sm_map and
> +	 * &drm_gpuvm_sm_unmap to unmap an existent mapping
>   	 *
>   	 * This callback is called when existent mapping needs to be unmapped.
>   	 * This is the case when either a newly requested mapping encloses an
>   	 * existent mapping or an unmap of an existent mapping is requested.
>   	 *
>   	 * The &priv pointer matches the one the driver passed to
> -	 * &drm_gpuva_sm_map or &drm_gpuva_sm_unmap, respectively.
> +	 * &drm_gpuvm_sm_map or &drm_gpuvm_sm_unmap, respectively.
>   	 *
> -	 * Can be NULL if neither &drm_gpuva_sm_map nor
&drm_gpuva_sm_unmap is
> +	 * Can be NULL if neither &drm_gpuvm_sm_map nor
&drm_gpuvm_sm_unmap is
>   	 * used.
>   	 */
>   	int (*sm_step_unmap)(struct drm_gpuva_op *op, void *priv);
>   };
>   
> -int drm_gpuva_sm_map(struct drm_gpuva_manager *mgr, void *priv,
> +int drm_gpuvm_sm_map(struct drm_gpuvm *gpuvm, void *priv,
>   		     u64 addr, u64 range,
>   		     struct drm_gem_object *obj, u64 offset);
>   
> -int drm_gpuva_sm_unmap(struct drm_gpuva_manager *mgr, void *priv,
> +int drm_gpuvm_sm_unmap(struct drm_gpuvm *gpuvm, void *priv,
>   		       u64 addr, u64 range);
>   
> -void drm_gpuva_map(struct drm_gpuva_manager *mgr,
> +void drm_gpuva_map(struct drm_gpuvm *gpuvm,
>   		   struct drm_gpuva *va,
>   		   struct drm_gpuva_op_map *op);
>   
> @@ -703,4 +702,4 @@ void drm_gpuva_remap(struct drm_gpuva *prev,
>   
>   void drm_gpuva_unmap(struct drm_gpuva_op_unmap *op);
>   
> -#endif /* __DRM_GPUVA_MGR_H__ */
> +#endif /* __DRM_GPUVM_H__ */