mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Natalie Vock <nat@pixelcluster.dev>
To: "Felix Kuehling" <Felix.Kuehling@amd.com>,
	"Alex Deucher" <alexander.deucher@amd.com>,
	"Christian König" <christian.koenig@amd.com>,
	"David Airlie" <airlied@gmail.com>,
	"Simona Vetter" <simona@ffwll.ch>,
	"Maarten Lankhorst" <maarten.lankhorst@linux.intel.com>,
	"Maxime Ripard" <mripard@kernel.org>,
	"Thomas Zimmermann" <tzimmermann@suse.de>,
	"Timur Kristóf" <timur.kristof@gmail.com>
Cc: amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org,
	 linux-kernel@vger.kernel.org,
	Natalie Vock <nat@pixelcluster.dev>
Subject: [PATCH v2 09/10] drm/amdgpu: Add new AMDGPU_GEM_VA2 ioctl
Date: Tue, 17 Nov 2026 13:50:15 +0100	[thread overview]
Message-ID: <20261117-prt-explicit-sync-v2-9-bb3851cb6a0c@pixelcluster.dev> (raw)
In-Reply-To: <20261117-prt-explicit-sync-v2-0-bb3851cb6a0c@pixelcluster.dev>

This new ioctl is a modernized version of AMDGPU_GEM_VA, with the
main changes being support for many operations batched in one ioctl,
and a better sync model that allows passing multiple syncobjs for
both wait and signal. Timeline syncobj are now properly supported in
both wait and signal cases.

One breaking change compared to AMDGPU_GEM_VA is that
synchronization is now explicit (where possible), meaning that
previous submissions are not necessarily waited on.

Using this ioctl allows applications that hammer lots of sparse
operations, particularly some games running under Proton, to see
significant reductions in stuttering.

Signed-off-by: Natalie Vock <nat@pixelcluster.dev>
---
 drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c |   3 +-
 drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c | 348 +++++++++++++++++++++++++++++++-
 drivers/gpu/drm/amd/amdgpu/amdgpu_gem.h |   2 +
 include/uapi/drm/amdgpu_drm.h           |  46 +++++
 4 files changed, 396 insertions(+), 3 deletions(-)

diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
index 72b3710462824..188c8ec234c02 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_drv.c
@@ -3124,7 +3124,8 @@ const struct drm_ioctl_desc amdgpu_ioctls_kms[] = {
 	DRM_IOCTL_DEF_DRV(AMDGPU_USERQ_WAIT, amdgpu_userq_wait_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(AMDGPU_GEM_LIST_HANDLES, amdgpu_gem_list_handles_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
 	DRM_IOCTL_DEF_DRV(AMDGPU_PROC_OPTIONS, amdgpu_proc_options_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
-	DRM_IOCTL_DEF_DRV(AMDGPU_UALINK_HANDLE, amdgpu_gem_ualink_handle_ioctl, DRM_AUTH|DRM_RENDER_ALLOW)
+	DRM_IOCTL_DEF_DRV(AMDGPU_UALINK_HANDLE, amdgpu_gem_ualink_handle_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
+	DRM_IOCTL_DEF_DRV(AMDGPU_GEM_VA2, amdgpu_gem_va2_ioctl, DRM_AUTH|DRM_RENDER_ALLOW),
 };
 
 static const struct drm_driver amdgpu_kms_driver = {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
index fb7abb095b8ec..0d77103b0a973 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.c
@@ -53,10 +53,13 @@ static int
 amdgpu_gem_add_input_fence(struct drm_file *filp,
 			   struct amdgpu_vm_update_ctx *update_ctx,
 			   uint64_t syncobj_handles_array,
+			   uint64_t syncobj_points_array,
 			   uint32_t num_syncobj_handles)
 {
 	struct dma_fence *fence;
 	uint32_t *syncobj_handles;
+	uint64_t *syncobj_points;
+	uint64_t point;
 	int ret, i;
 
 	if (!num_syncobj_handles)
@@ -67,6 +70,17 @@ amdgpu_gem_add_input_fence(struct drm_file *filp,
 	if (IS_ERR(syncobj_handles))
 		return PTR_ERR(syncobj_handles);
 
+	if (syncobj_points_array) {
+		syncobj_points = memdup_user(u64_to_user_ptr(syncobj_points_array),
+					      size_mul(sizeof(uint64_t), num_syncobj_handles));
+		if (IS_ERR(syncobj_points)) {
+			kfree(syncobj_handles);
+			return PTR_ERR(syncobj_handles);
+		}
+	} else {
+		syncobj_points = NULL;
+	}
+
 	for (i = 0; i < num_syncobj_handles; i++) {
 
 		if (!syncobj_handles[i]) {
@@ -74,7 +88,9 @@ amdgpu_gem_add_input_fence(struct drm_file *filp,
 			goto free_memdup;
 		}
 
-		ret = drm_syncobj_find_fence(filp, syncobj_handles[i], 0, 0, &fence);
+		point = syncobj_points ? syncobj_points[i] : 0;
+
+		ret = drm_syncobj_find_fence(filp, syncobj_handles[i], point, 0, &fence);
 		if (ret)
 			goto free_memdup;
 
@@ -87,9 +103,111 @@ amdgpu_gem_add_input_fence(struct drm_file *filp,
 
 free_memdup:
 	kfree(syncobj_handles);
+	kfree(syncobj_points);
 	return ret;
 }
 
+struct amdgpu_gem_timeline_out {
+	struct drm_syncobj **syncobjs;
+	struct dma_fence_chain **chains;
+	uint64_t *timeline_points;
+};
+
+static int amdgpu_gem_prepare_timeline_nodes(
+	struct drm_file *filp, uint64_t syncobj_handles_array,
+	uint64_t syncobj_points_array, uint32_t num_syncobjs,
+	struct amdgpu_gem_timeline_out *out)
+{
+	uint32_t *syncobj_handles;
+	uint32_t i;
+	int r;
+
+	syncobj_handles = memdup_user(u64_to_user_ptr(syncobj_handles_array),
+				      size_mul(sizeof(uint32_t), num_syncobjs));
+	if (IS_ERR(syncobj_handles))
+		return PTR_ERR(syncobj_handles);
+
+	out->timeline_points =
+		memdup_user(u64_to_user_ptr(syncobj_points_array),
+			    size_mul(sizeof(uint64_t), num_syncobjs));
+	if (IS_ERR(out->timeline_points)) {
+		r = PTR_ERR(out->timeline_points);
+		goto err_free_handles;
+	}
+
+	out->chains = kzalloc_objs(*out->chains, num_syncobjs);
+	if (!out->chains) {
+		r = -ENOMEM;
+		goto err_free_points;
+	}
+
+	out->syncobjs = kzalloc_objs(*out->syncobjs, num_syncobjs);
+	if (!out->syncobjs) {
+		r = -ENOMEM;
+		goto err_free_chains;
+	}
+
+	for (i = 0; i < num_syncobjs; i++) {
+		out->syncobjs[i] = drm_syncobj_find(filp, syncobj_handles[i]);
+		if (!out->syncobjs[i]) {
+			r = -ENOENT;
+			goto err_loop_rollback;
+		}
+
+		if (!out->timeline_points[i])
+			continue;
+
+		out->chains[i] = dma_fence_chain_alloc();
+		if (!out->chains[i]) {
+			r = -ENOMEM;
+			goto err_loop_rollback;
+		}
+
+		continue;
+err_loop_rollback:
+		for (;;) {
+			if (out->syncobjs[i])
+				drm_syncobj_put(out->syncobjs[i]);
+			if (out->chains[i])
+				dma_fence_chain_free(out->chains[i]);
+			if (i-- == 0)
+				goto err_free_sync;
+		}
+	}
+
+	return 0;
+
+err_free_sync:
+	kfree(out->syncobjs);
+	out->syncobjs = NULL;
+err_free_chains:
+	kfree(out->chains);
+	out->chains = NULL;
+err_free_points:
+	kfree(out->timeline_points);
+	out->timeline_points = NULL;
+err_free_handles:
+	kfree(syncobj_handles);
+	return r;
+}
+
+static void amdgpu_gem_timeline_out_fini(struct amdgpu_gem_timeline_out *tl_out,
+					 uint32_t num_syncobjs)
+{
+	uint32_t i;
+
+	for (i = 0; i < num_syncobjs; i++) {
+		if (tl_out->syncobjs)
+			drm_syncobj_put(tl_out->syncobjs[i]);
+		if (tl_out->chains)
+			dma_fence_chain_free(tl_out->chains[i]);
+	}
+
+	kfree(tl_out->timeline_points);
+	kfree(tl_out->syncobjs);
+	kfree(tl_out->chains);
+}
+
 static int
 amdgpu_gem_update_timeline_node(struct drm_file *filp,
 				uint32_t syncobj_handle,
@@ -982,7 +1100,7 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
 
 	/* Add input syncobj fences (if any) for synchronization. */
 	r = amdgpu_gem_add_input_fence(filp, &update_ctx,
-				       args->input_fence_syncobj_handles,
+				       args->input_fence_syncobj_handles, 0,
 				       args->num_syncobj_handles);
 	if (r)
 		goto error_put_gobj;
@@ -1100,6 +1218,232 @@ int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
 	return r;
 }
 
+int amdgpu_gem_va2_ioctl(struct drm_device *dev, void *data,
+			 struct drm_file *filp)
+{
+	struct drm_amdgpu_gem_va2 *args = data;
+	struct amdgpu_device *adev = drm_to_adev(dev);
+	struct amdgpu_fpriv *fpriv = filp->driver_priv;
+	struct drm_amdgpu_gem_va_mapping *mappings;
+	struct amdgpu_gem_timeline_out tl_out;
+	struct amdgpu_vm_update_ctx update_ctx;
+	struct drm_gem_object *gobj;
+	struct amdgpu_bo_va *bo_va;
+	struct drm_exec exec;
+	bool delay = false;
+	u32 i;
+	int r;
+
+	mappings = vmemdup_array_user(u64_to_user_ptr(args->mappings),
+				      args->num_mappings,
+				      sizeof(struct drm_amdgpu_gem_va_mapping));
+	if (IS_ERR(mappings))
+		return PTR_ERR(mappings);
+
+	r = amdgpu_gem_prepare_timeline_nodes(filp, args->syncobjs_out,
+					      args->timeline_points_out,
+					      args->num_syncobjs_out, &tl_out);
+	if (r)
+		goto out_free_mappings;
+
+	drm_exec_init(&exec,
+		      DRM_EXEC_INTERRUPTIBLE_WAIT | DRM_EXEC_IGNORE_DUPLICATES,
+		      0);
+	amdgpu_vm_update_ctx_init(&update_ctx, adev, &fpriv->vm);
+	update_ctx.explicit_sync_unmap = true;
+
+	r = amdgpu_gem_add_input_fence(filp, &update_ctx, args->syncobjs_in,
+				       args->timeline_points_in,
+				       args->num_syncobjs_in);
+	if (r)
+		goto out;
+
+	drm_exec_until_all_locked(&exec)
+	{
+		r = amdgpu_vm_lock_pd(&fpriv->vm, &exec, 2);
+		drm_exec_retry_on_contention(&exec);
+		if (unlikely(r))
+			goto out;
+
+		for (i = 0; i < args->num_mappings; ++i) {
+			r = amdgpu_gem_va_validate_args(adev, mappings[i].va,
+							mappings[i].map_size,
+							mappings[i].flags);
+			if (r)
+				goto out;
+
+			mappings[i].va &= AMDGPU_GMC_HOLE_MASK;
+
+			if (mappings[i].flags & AMDGPU_VM_DELAY_UPDATE) {
+				/* Can't delay if we're supposed to signal fences */
+				if (args->num_syncobjs_out) {
+					r = -EINVAL;
+					goto out;
+				}
+				/* If one mapping is delayed, all mappings must be delayed */
+				if (i && !delay) {
+					r = -EINVAL;
+					goto out;
+				}
+			} else if (delay) {
+				/* If one mapping is not delayed, no mappings may be delayed */
+				r = -EINVAL;
+				goto out;
+			}
+
+			if ((mappings[i].operation != AMDGPU_VA_OP_CLEAR) &&
+			    !(mappings[i].flags & AMDGPU_VM_PAGE_PRT)) {
+				gobj = drm_gem_object_lookup(
+					filp, mappings[i].handle);
+				if (gobj == NULL) {
+					r = -ENOENT;
+					goto out;
+				}
+				bo_va = amdgpu_vm_bo_find(
+					&fpriv->vm, gem_to_amdgpu_bo(gobj));
+				if (!bo_va) {
+					drm_gem_object_put(gobj);
+					r = -ENOENT;
+					goto out;
+				}
+			} else {
+				gobj = NULL;
+				bo_va = mappings[i].operation !=
+							AMDGPU_VA_OP_CLEAR ?
+						fpriv->prt_va :
+						NULL;
+			}
+
+			if (gobj) {
+				r = drm_exec_lock_obj(&exec, gobj);
+				if (drm_exec_is_contended(&exec))
+					amdgpu_vm_update_ctx_rollback(
+						&update_ctx);
+				drm_exec_retry_on_contention(&exec);
+				if (unlikely(r))
+					goto out;
+			}
+
+			switch (mappings[i].operation) {
+			case AMDGPU_VA_OP_MAP:
+				r = amdgpu_vm_bo_map(&update_ctx, bo_va,
+						     mappings[i].va,
+						     mappings[i].offset_in_bo,
+						     mappings[i].map_size,
+						     mappings[i].flags);
+				break;
+			case AMDGPU_VA_OP_UNMAP:
+				r = amdgpu_vm_bo_unmap(&update_ctx, bo_va,
+						       mappings[i].flags);
+				break;
+
+			case AMDGPU_VA_OP_CLEAR:
+				r = amdgpu_vm_bo_clear_mappings(
+					&update_ctx, mappings[i].va,
+					mappings[i].map_size);
+				break;
+			case AMDGPU_VA_OP_REPLACE:
+				r = amdgpu_vm_bo_replace_map(
+					&update_ctx, bo_va, mappings[i].va,
+					mappings[i].offset_in_bo,
+					mappings[i].map_size,
+					mappings[i].flags);
+				break;
+			default:
+				r = -EINVAL;
+				break;
+			}
+
+			/* It's fine to put our reference here, exec still holds one */
+			drm_gem_object_put(gobj);
+
+			if (r)
+				goto out;
+		}
+	}
+
+	r = amdgpu_vm_update_ctx_execute_replace(&update_ctx);
+	if (r)
+		goto out;
+
+	amdgpu_vm_update_ctx_commit(&update_ctx);
+
+	if (!delay && (!adev->debug_vm || args->num_syncobjs_out)) {
+		struct dma_fence *fence, *merged;
+
+		if (!amdgpu_vm_ready(&fpriv->vm)) {
+			fence = dma_fence_get_stub();
+			goto insert_fence;
+		}
+
+		r = amdgpu_vm_clear_freed(&update_ctx, &fpriv->vm.last_update);
+		if (r) {
+			drm_err(adev_to_drm(adev),
+				"Could not clear freed PT entries: %d\n", r);
+			goto insert_fence;
+		}
+
+		fence = dma_fence_get(fpriv->vm.last_update);
+
+		list_for_each_entry(bo_va, &update_ctx.dirty_bo_vas,
+				    update_link) {
+			r = amdgpu_vm_bo_update(&update_ctx, bo_va, false);
+			if (r) {
+				drm_err(adev_to_drm(adev),
+					"Could not update BO PT entries: %d\n", r);
+				goto insert_fence;
+			}
+		}
+
+		list_for_each_entry(bo_va, &update_ctx.dirty_bo_vas,
+				    update_link) {
+			if (!amdgpu_vm_is_bo_always_valid(&fpriv->vm,
+							  bo_va->base.bo)) {
+				dma_fence_put(bo_va->last_pt_update);
+				bo_va->last_pt_update = dma_fence_get(fence);
+			}
+		}
+
+		/* Always update PDEs after we touched the mappings. */
+		r = amdgpu_vm_update_pdes(adev, &fpriv->vm, false);
+		if (r)
+			goto insert_fence;
+
+		merged = dma_fence_unwrap_merge(fence, fpriv->vm.last_update);
+		if (!merged) {
+			/* As fallback in OOM situations */
+			dma_fence_wait(fpriv->vm.last_update, false);
+			dma_fence_wait(fence, false);
+			merged = dma_fence_get_stub();
+		}
+		fence = merged;
+
+insert_fence:
+		for (i = 0; i < args->num_syncobjs_out; ++i) {
+			if (!tl_out.timeline_points[i]) {
+				/* Replace the existing fence when no point is given. */
+				drm_syncobj_replace_fence(tl_out.syncobjs[i],
+							  fence);
+			} else {
+				/* Attach the last-update fence at a specific point. */
+				drm_syncobj_add_point(
+					tl_out.syncobjs[i], tl_out.chains[i],
+					fence, tl_out.timeline_points[i]);
+				tl_out.chains[i] = NULL;
+			}
+		}
+		dma_fence_put(fence);
+	}
+
+out:
+	amdgpu_vm_update_ctx_fini(&update_ctx);
+	drm_exec_fini(&exec);
+	amdgpu_gem_timeline_out_fini(&tl_out, args->num_syncobjs_out);
+out_free_mappings:
+	kvfree(mappings);
+	return r;
+}
+
 int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
 			struct drm_file *filp)
 {
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.h
index b558336bc4c6c..38fafc978c834 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_gem.h
@@ -65,6 +65,8 @@ int amdgpu_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
 			      struct drm_file *filp);
 int amdgpu_gem_va_ioctl(struct drm_device *dev, void *data,
 			  struct drm_file *filp);
+int amdgpu_gem_va2_ioctl(struct drm_device *dev, void *data,
+			 struct drm_file *filp);
 int amdgpu_gem_op_ioctl(struct drm_device *dev, void *data,
 			struct drm_file *filp);
 int amdgpu_gem_list_handles_ioctl(struct drm_device *dev, void *data,
diff --git a/include/uapi/drm/amdgpu_drm.h b/include/uapi/drm/amdgpu_drm.h
index 29009f6aabde9..c9e52bfa7d028 100644
--- a/include/uapi/drm/amdgpu_drm.h
+++ b/include/uapi/drm/amdgpu_drm.h
@@ -60,6 +60,7 @@ extern "C" {
 #define DRM_AMDGPU_GEM_LIST_HANDLES	0x19
 #define DRM_AMDGPU_PROC_OPTIONS		0x1A
 #define DRM_AMDGPU_UALINK_HANDLE	0x1B
+#define DRM_AMDGPU_GEM_VA2		0x1C
 
 #define DRM_IOCTL_AMDGPU_GEM_CREATE	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_CREATE, union drm_amdgpu_gem_create)
 #define DRM_IOCTL_AMDGPU_GEM_MMAP	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_MMAP, union drm_amdgpu_gem_mmap)
@@ -83,6 +84,7 @@ extern "C" {
 #define DRM_IOCTL_AMDGPU_GEM_LIST_HANDLES DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_LIST_HANDLES, struct drm_amdgpu_gem_list_handles)
 #define DRM_IOCTL_AMDGPU_PROC_OPTIONS	DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_PROC_OPTIONS, struct drm_amdgpu_proc_options)
 #define DRM_IOCTL_AMDGPU_UALINK_HANDLE DRM_IOWR(DRM_COMMAND_BASE + DRM_AMDGPU_UALINK_HANDLE, union drm_amdgpu_ualink_handle)
+#define DRM_IOCTL_AMDGPU_GEM_VA2	DRM_IOW(DRM_COMMAND_BASE + DRM_AMDGPU_GEM_VA2, struct drm_amdgpu_gem_va)
 
 /**
  * DOC: memory domains
@@ -945,6 +947,50 @@ struct drm_amdgpu_gem_va {
 	__u64 input_fence_syncobj_handles;
 };
 
+struct drm_amdgpu_gem_va_mapping {
+	/** GEM object handle */
+	__u32 handle;
+	/** AMDGPU_VA_OP_* */
+	__u32 operation;
+	/** AMDGPU_VM_PAGE_* */
+	__u32 flags;
+	__u32 _pad;
+
+	/** virtual address to assign . Must be correctly aligned.*/
+	__u64 va;
+	/** Specify offset inside of BO to assign. Must be correctly aligned.*/
+	__u64 offset_in_bo;
+	/** Specify mapping size. Must be correctly aligned. */
+	__u64 map_size;
+};
+
+struct drm_amdgpu_gem_va2 {
+	/** Number of mapping ops in @mappings */
+	__u32 num_mappings;
+	__u32 _pad;
+	/** Pointer to array of struct drm_amdgpu_gem_va_mapping */
+	__u64 mappings;
+
+	/** Number of elements in @syncobjs_in and @timeline_points_in */
+	__u32 num_syncobjs_in;
+	/** Number of elements in @syncobjs_out and @timeline_points_out */
+	__u32 num_syncobjs_out;
+	/** Array of u32 syncobj handles to wait for before mapping */
+	__u64 syncobjs_in;
+	/**
+	 * Array of timeline points, one for each object in @syncobjs_in.
+	 * If the syncobj is binary, its corrensponding timeline point must be 0.
+	 */
+	__u64 timeline_points_in;
+	/** Array of u32 syncobj handles to signal after mapping */
+	__u64 syncobjs_out;
+	/**
+	 * Array of timeline points, one for each object in @syncobjs_out.
+	 * If the syncobj is binary, its corrensponding timeline point must be 0.
+	 */
+	__u64 timeline_points_out;
+};
+
 #define AMDGPU_HW_IP_GFX          0
 #define AMDGPU_HW_IP_COMPUTE      1
 #define AMDGPU_HW_IP_DMA          2

-- 
2.56.1


  parent reply	other threads:[~2026-11-17 12:50 UTC|newest]

Thread overview: 11+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-17 12:50 [PATCH v2 00/10] drm/amdgpu: Rework VM update ops for batching and explicit sync Natalie Vock
2026-11-17 12:50 ` [PATCH v2 01/10] drm/amdgpu: Remove unused parameter from amdgpu_vm_pte_fragment Natalie Vock
2026-11-17 12:50 ` [PATCH v2 02/10] drm/amdgpu: Add and use vm_update_ctx struct Natalie Vock
2026-11-17 12:50 ` [PATCH v2 03/10] drm/amdgpu: Make VM maps pending per update context Natalie Vock
2026-11-17 12:50 ` [PATCH v2 04/10] drm/amdgpu: Make removed/cleared mappings " Natalie Vock
2026-11-17 12:50 ` [PATCH v2 05/10] drm/amdgpu: Track dirty bo_va structures in update ctx Natalie Vock
2026-11-17 12:50 ` [PATCH v2 06/10] drm/amdgpu: Add function to roll back a VM " Natalie Vock
2026-11-17 12:50 ` [PATCH v2 07/10] drm/amdgpu: Move some VA op validation to a helper Natalie Vock
2026-11-17 12:50 ` [PATCH v2 08/10] drm/amdgpu: Only reject conflicting mappings if they are not cleared Natalie Vock
2026-11-17 12:50 ` Natalie Vock [this message]
2026-11-17 12:50 ` [PATCH v2 10/10] drm/amdgpu: Bump minor version Natalie Vock

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20261117-prt-explicit-sync-v2-9-bb3851cb6a0c@pixelcluster.dev \
    --to=nat@pixelcluster.dev \
    --cc=Felix.Kuehling@amd.com \
    --cc=airlied@gmail.com \
    --cc=alexander.deucher@amd.com \
    --cc=amd-gfx@lists.freedesktop.org \
    --cc=christian.koenig@amd.com \
    --cc=dri-devel@lists.freedesktop.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=maarten.lankhorst@linux.intel.com \
    --cc=mripard@kernel.org \
    --cc=simona@ffwll.ch \
    --cc=timur.kristof@gmail.com \
    --cc=tzimmermann@suse.de \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox

all inboxes | Powered by JetHome®