[RFC v2 2/7] drm/xe/vm: Preserve cpu_autoreset_active across GPUVA operations

[Arvind Yadav <arvind.yadav@intel.com>]

GPUVA split and remap rebuild VMAs using XE_VMA_CREATE_MASK, which does
not carry runtime-only state. Forward XE_VMA_CPU_AUTORESET_ACTIVE through
the pipeline so xe_vma_create() restores cpu_autoreset_active in the new
VMA.

Also preserve the effective PAT index on REMAP so madvise-applied
overrides survive splits.

Relax XE_WARN_ON in the UNMAP path to allow non-default attributes on
cpu_autoreset_active VMAs.

Add xe_vma_effective_create_flags() to centralise flag propagation.

v2:
  - Move runtime state to xe_vma bool and keep
    XE_VMA_CPU_AUTORESET_ACTIVE as pipeline-only. (Matt)
  - Add xe_vma_effective_create_flags() to centralise flag handling.

Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Himal Prasad Ghimiray <himal.prasad.ghimiray@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 drivers/gpu/drm/xe/xe_vm.c | 52 +++++++++++++++++++++++++++++++++-----
 1 file changed, 45 insertions(+), 7 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_vm.c b/drivers/gpu/drm/xe/xe_vm.c
index 2408b547ca3d..65425f2f1bf1 100644
--- a/drivers/gpu/drm/xe/xe_vm.c
+++ b/drivers/gpu/drm/xe/xe_vm.c
@@ -1106,7 +1106,9 @@ static struct xe_vma *xe_vma_create(struct xe_vm *vm,
 	vma->gpuva.vm = &vm->gpuvm;
 	vma->gpuva.va.addr = start;
 	vma->gpuva.va.range = end - start + 1;
-	vma->gpuva.flags = flags;
+	/* Pipeline-only; runtime state lives in vma->cpu_autoreset_active. */
+	vma->gpuva.flags = flags & ~XE_VMA_CPU_AUTORESET_ACTIVE;
+	vma->cpu_autoreset_active = !!(flags & XE_VMA_CPU_AUTORESET_ACTIVE);
 
 	for_each_tile(tile, vm->xe, id)
 		vma->tile_mask |= 0x1 << id;
@@ -2454,8 +2456,10 @@ vm_bind_ioctl_ops_create(struct xe_vm *vm, struct xe_vma_ops *vops,
 				op->map.vma_flags |= XE_VMA_SYSTEM_ALLOCATOR;
 			if (flags & DRM_XE_VM_BIND_FLAG_DUMPABLE)
 				op->map.vma_flags |= XE_VMA_DUMPABLE;
-			if (flags & DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET)
+			if (flags & DRM_XE_VM_BIND_FLAG_MADVISE_AUTORESET) {
 				op->map.vma_flags |= XE_VMA_MADV_AUTORESET;
+				op->map.vma_flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
+			}
 			op->map.request_decompress = flags & DRM_XE_VM_BIND_FLAG_DECOMPRESS;
 			op->map.pat_index = pat_index;
 			op->map.invalidate_on_bind =
@@ -2775,6 +2779,12 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm *vm, struct drm_gpuva_ops *ops,
 			};
 
 			flags |= op->map.vma_flags & XE_VMA_CREATE_MASK;
+			/*
+			 * Pipeline-only flag; forward explicitly so xe_vma_create()
+			 * restores state.
+			 */
+			if (op->map.vma_flags & XE_VMA_CPU_AUTORESET_ACTIVE)
+				flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
 
 			vma = new_vma(vm, &op->base.map, &default_attr,
 				      flags);
@@ -2817,6 +2827,10 @@ static int vm_bind_ioctl_ops_parse(struct xe_vm *vm, struct drm_gpuva_ops *ops,
 			op->remap.old_range = op->remap.range;
 
 			flags |= op->base.remap.unmap->va->flags & XE_VMA_CREATE_MASK;
+			/* Pipeline-only; forward explicitly. */
+			if (xe_vma_has_cpu_autoreset_active(old))
+				flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
+
 			if (op->base.remap.prev) {
 				vma = new_vma(vm, op->base.remap.prev,
 					      &old->attr, flags);
@@ -4659,6 +4673,20 @@ int xe_vma_need_vram_for_atomic(struct xe_device *xe, struct xe_vma *vma, bool i
 	}
 }
 
+/*
+ * Returns vma->gpuva.flags with XE_VMA_CPU_AUTORESET_ACTIVE injected if
+ * the runtime state is set, for passing through MAP/REMAP pipelines.
+ */
+static unsigned int xe_vma_effective_create_flags(struct xe_vma *vma)
+{
+	unsigned int flags = vma->gpuva.flags;
+
+	if (xe_vma_has_cpu_autoreset_active(vma))
+		flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
+
+	return flags;
+}
+
 static int xe_vm_alloc_vma(struct xe_vm *vm,
 			   struct drm_gpuvm_map_req *map_req,
 			   bool is_madvise)
@@ -4694,19 +4722,25 @@ static int xe_vm_alloc_vma(struct xe_vm *vm,
 		if (!is_madvise) {
 			if (__op->op == DRM_GPUVA_OP_UNMAP) {
 				vma = gpuva_to_vma(op->base.unmap.va);
-				XE_WARN_ON(!xe_vma_has_default_mem_attrs(vma));
+				/* Attributes must be default on UNMAP; CPU-only VMAs are exempt. */
+				XE_WARN_ON(!xe_vma_has_default_mem_attrs(vma) &&
+					   !xe_vma_has_cpu_autoreset_active(vma));
 				default_pat = vma->attr.default_pat_index;
-				vma_flags = vma->gpuva.flags;
+				vma_flags = xe_vma_effective_create_flags(vma);
 			}
 
 			if (__op->op == DRM_GPUVA_OP_REMAP) {
 				vma = gpuva_to_vma(op->base.remap.unmap->va);
-				default_pat = vma->attr.default_pat_index;
-				vma_flags = vma->gpuva.flags;
+				/* Preserve current PAT index, not default, for remap */
+				default_pat = vma->attr.pat_index;
+				vma_flags = xe_vma_effective_create_flags(vma);
 			}
 
 			if (__op->op == DRM_GPUVA_OP_MAP) {
 				op->map.vma_flags |= vma_flags & XE_VMA_CREATE_MASK;
+				/* Pipeline-only; forward explicitly. */
+				if (vma_flags & XE_VMA_CPU_AUTORESET_ACTIVE)
+					op->map.vma_flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
 				op->map.pat_index = default_pat;
 			}
 		} else {
@@ -4715,10 +4749,11 @@ static int xe_vm_alloc_vma(struct xe_vm *vm,
 				xe_assert(vm->xe, !remap_op);
 				xe_assert(vm->xe, xe_vma_has_no_bo(vma));
 				remap_op = true;
-				vma_flags = vma->gpuva.flags;
+				vma_flags = xe_vma_effective_create_flags(vma);
 			}
 
 			if (__op->op == DRM_GPUVA_OP_MAP) {
+				/* Madvise MAP follows REMAP (split/merge). */
 				xe_assert(vm->xe, remap_op);
 				remap_op = false;
 				/*
@@ -4728,6 +4763,9 @@ static int xe_vm_alloc_vma(struct xe_vm *vm,
 				 * unmapping.
 				 */
 				op->map.vma_flags |= vma_flags & XE_VMA_CREATE_MASK;
+				/* Pipeline-only; forward explicitly. */
+				if (vma_flags & XE_VMA_CPU_AUTORESET_ACTIVE)
+					op->map.vma_flags |= XE_VMA_CPU_AUTORESET_ACTIVE;
 			}
 		}
 		print_op(vm->xe, __op);
-- 
2.43.0