[PATCH i-g-t v6 0/9] tests/xe: Add purgeable memory madvise tests for system allocator

[PATCH i-g-t v6 0/9] tests/xe: Add purgeable memory madvise tests for system allocator

[Arvind Yadav]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain; charset=y, Size: 4866 bytes --]

This series adds IGT tests for the purgeable memory madvise functionality
in the XE driver's system allocator path.

Purgeable memory allows userspace to mark buffer objects as DONTNEED,
making them eligible for kernel reclamation under memory pressure. This
is critical for mobile and memory-constrained platforms to prevent OOM
conditions while managing temporary or regeneratable GPU data.

The test suite validates:
- Basic purgeable lifecycle (WILLNEED -> DONTNEED -> PURGED)
- "Once purged, always purged" semantics (i915 compatibility)
- Per-VMA purgeable state tracking for shared buffers
- CPU fault handling on purged BOs (SIGBUS/SIGSEGV)
- GPU execution with purged memory and scratch page protection
- Proper state transitions across multiple VMs

Purgeable Memory States:-
 - **WILLNEED (0)**: Memory is actively needed, kernel should not
                     reclaim it.
 - **DONTNEED (1)**: Application doesn't need this memory right now,
                     kernel can reclaim it if needed

Retained Value
 When querying purgeable state, the kernel returns:
 - retained = 1: Memory is still present (not purged)
 - retained = 0: Memory was purged/reclaimed

Kernel dependency: https://patchwork.freedesktop.org/series/156651/
 
Test Cases :
  1. dontneed-before-mmap
        Purpose: Validate that mmap fails on dontneed BO

  2. purged-mmap-blocked
        Purpose: Validate that mmap fails on already-purged
      
  3. dontneed-after-mmap
        Purpose: Validate that accessing an existing mapping of purged memory
                 triggers SIGBUS/SIGSEGV.

  4. dontneed-before-exec
        Purpose: Validate GPU execution on purgeable BO (before it's used).

  5. dontneed-after-exec
        Purpose: Validate that previously-used BO can be purged and becomes
                 inaccessible.

  6. per-vma-tracking
        Purpose: Validate per-VMA purgeable state tracking

  7. per-vma-protection
        Purpose: Validate that WILLNEED VMA protects BO from purging during
                 GPU operations.
v2:
   - Move tests from xe_exec_system_allocator.c to dedicated
     xe_madvise.c (Thomas Hellström).
   - Fix trigger_memory_pressure to use scalable overpressure
    (25% of VRAM, minimum 64MB instead of fixed 64MB). (Pravalika)
   - Add MAP_FAILED check in trigger_memory_pressure.
   - Touch all pages in allocated chunks, not just first 4KB. (Pravalika)
   - Add 100ms sleep before freeing BOs to allow shrinker time
     to process memory pressure.  (Pravalika)
   - Rename 'bo2' to 'handle' for clarity in trigger_memory_pressure.(Pravalika)
   - Add NEEDS_VISIBLE_VRAM flag to purgeable_setup_simple_bo
     for consistent CPU mapping support on discrete GPUs.  (Pravalika)
   - Add proper NULL mmap handling in test_dontneed_before_mmap
      with cleanup and early return.  (Pravalika)

v3:
   - Added separate commits for each individual test case. (Pravalika)

v4:
   - Move unmap outside the block. (Pravalika)
   - Added proper resource cleanup before calling igt_skip(). (Nishit)
   - Added assertion for xe_bo_map. (Nishit)
   - Now using sync[0] consistently. (Nishit)
   - Added clarifying comment. (Nishit)

v5:
  - Document DONTNEED BO access blocking behavior to prevent undefined
    behavior and clarify uAPI contract (Thomas, Matt)
  - Add query flag DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT for
    feature detection. (Jose)
  - For DONTNEED BO's mmap offset ioctl blocked with -EBUSY.
  - Rename retained to retained_ptr. (Jose)
  - Add new subtest purged-mmap-blocked.

v6:
  - Support iGPU in trigger_memory_pressure() by using total system RAM
    as pressure baseline; raise overpressure to 50% to force shrinker.
  - DONTNEED mmap blocking now enforced at mmap() time (xe_gem_object_mmap),
    not at DRM_IOCTL_XE_GEM_MMAP_OFFSET. Update dontneed-before-mmap and
    purged-mmap-blocked accordingly.
  - Fix graceful skip (instead of fail) in per-vma-tracking and
    per-vma-protection when purge cannot be induced. (Nishit)

Arvind Yadav (8):
  lib/xe: Add purgeable memory ioctl support
  tests/intel/xe_madvise: Add dontneed-before-mmap subtest
  tests/intel/xe_madvise: Add purged-mmap-blocked subtest
  tests/intel/xe_madvise: Add dontneed-after-mmap subtest
  tests/intel/xe_madvise: Add dontneed-before-exec subtest
  tests/intel/xe_madvise: Add dontneed-after-exec subtest
  tests/intel/xe_madvise: Add per-vma-tracking subtest
  tests/intel/xe_madvise: Add per-vma-protection subtest

Himal Prasad Ghimiray (1):
  drm-uapi/xe_drm: Add UAPI support for purgeable buffer objects

 include/drm-uapi/xe_drm.h |  69 ++++
 lib/xe/xe_ioctl.c         |  33 ++
 lib/xe/xe_ioctl.h         |   2 +
 tests/intel/xe_madvise.c  | 840 ++++++++++++++++++++++++++++++++++++++
 tests/meson.build         |   1 +
 5 files changed, 945 insertions(+)
 create mode 100644 tests/intel/xe_madvise.c

-- 
2.43.0

[PATCH i-g-t v6 1/9] drm-uapi/xe_drm: Add UAPI support for purgeable buffer objects

[Arvind Yadav]

From: Himal Prasad Ghimiray <himal.prasad.ghimiray@intel.com>

Extend the DRM_XE_MADVISE ioctl to support purgeable buffer object
management by adding DRM_XE_VMA_ATTR_PURGEABLE_STATE attribute type.

This allows userspace applications to provide memory usage hints to
the kernel for better memory management under pressure:

- WILLNEED: Buffer is needed and should not be purged. If the BO was
  previously purged, retained field returns 0 indicating backing store
  was lost (once purged, always purged semantics matching i915).

- DONTNEED: Buffer is not currently needed and may be purged by the
  kernel under memory pressure to free resources. Only applies to
  non-shared BOs.

  To prevent undefined behavior, the following operations are blocked
  while a BO is in DONTNEED state:
  - New mmap() operations return -EBUSY
  - VM_BIND operations return -EBUSY
  - New dma-buf exports return -EBUSY
  - CPU/GPU page faults return SIGBUS

  This ensures applications cannot use a BO while marked as DONTNEED,
  preventing erratic behavior when the kernel purges the backing store.

The implementation includes a 'retained' output field (matching i915's
drm_i915_gem_madvise.retained) that indicates whether the BO's backing
store still exists (1) or has been purged (0).

Added DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT flag to allow
userspace to detect kernel support for purgeable buffer objects
before attempting to use the feature.

v2:
  - Update UAPI documentation to clarify retained must be initialized
    to 0(Thomas)

v5:
  - Document DONTNEED BO access blocking behavior to prevent undefined
    behavior and clarify uAPI contract (Thomas, Matt)
  - Add query flag DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT for
    feature detection. (Jose)
  - Renamed retained to retained_ptr. (Jose)

v6:
  - Updated UAPI documentation as suggested. (Jose)

Cc: Nishit Sharma <nishit.sharma@intel.com>
Cc: Matthew Brost <matthew.brost@intel.com>
Cc: Thomas Hellström <thomas.hellstrom@linux.intel.com>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Himal Prasad Ghimiray <himal.prasad.ghimiray@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 include/drm-uapi/xe_drm.h | 69 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/include/drm-uapi/xe_drm.h b/include/drm-uapi/xe_drm.h
index 077e66a68..cf0eb3f99 100644
--- a/include/drm-uapi/xe_drm.h
+++ b/include/drm-uapi/xe_drm.h
@@ -431,6 +431,7 @@ struct drm_xe_query_config {
 	#define DRM_XE_QUERY_CONFIG_FLAG_HAS_LOW_LATENCY	(1 << 1)
 	#define DRM_XE_QUERY_CONFIG_FLAG_HAS_CPU_ADDR_MIRROR	(1 << 2)
 	#define DRM_XE_QUERY_CONFIG_FLAG_HAS_NO_COMPRESSION_HINT (1 << 3)
+	#define DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT	(1 << 5)
 #define DRM_XE_QUERY_CONFIG_MIN_ALIGNMENT		2
 #define DRM_XE_QUERY_CONFIG_VA_BITS			3
 #define DRM_XE_QUERY_CONFIG_MAX_EXEC_QUEUE_PRIORITY	4
@@ -2067,6 +2068,7 @@ struct drm_xe_query_eu_stall {
  *  - DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC: Set preferred memory location.
  *  - DRM_XE_MEM_RANGE_ATTR_ATOMIC: Set atomic access policy.
  *  - DRM_XE_MEM_RANGE_ATTR_PAT: Set page attribute table index.
+ *  - DRM_XE_VMA_ATTR_PURGEABLE_STATE: Set purgeable state for BOs.
  *
  * Example:
  *
@@ -2099,6 +2101,7 @@ struct drm_xe_madvise {
 #define DRM_XE_MEM_RANGE_ATTR_PREFERRED_LOC	0
 #define DRM_XE_MEM_RANGE_ATTR_ATOMIC		1
 #define DRM_XE_MEM_RANGE_ATTR_PAT		2
+#define DRM_XE_VMA_ATTR_PURGEABLE_STATE		3
 	/** @type: type of attribute */
 	__u32 type;
 
@@ -2189,6 +2192,72 @@ struct drm_xe_madvise {
 			/** @pat_index.reserved: Reserved */
 			__u64 reserved;
 		} pat_index;
+
+		/**
+		 * @purge_state_val: Purgeable state configuration
+		 *
+		 * Used when @type == DRM_XE_VMA_ATTR_PURGEABLE_STATE.
+		 *
+		 * Configures the purgeable state of buffer objects in the specified
+		 * virtual address range. This allows applications to hint to the kernel
+		 * about bo's usage patterns for better memory management.
+		 *
+		 * By default all VMAs are in WILLNEED state.
+		 *
+		 * Supported values for @purge_state_val.val:
+		 *  - DRM_XE_VMA_PURGEABLE_STATE_WILLNEED (0): Marks BO as needed.
+		 *    If the BO was previously purged, the kernel sets the __u32 at
+		 *    @retained_ptr to 0 (backing store lost) so the application knows
+		 *    it must recreate the BO.
+		 *
+		 *  - DRM_XE_VMA_PURGEABLE_STATE_DONTNEED (1): Marks BO as not currently
+		 *    needed. Kernel may purge it under memory pressure to reclaim memory.
+		 *    Only applies to non-shared BOs. The kernel sets the __u32 at
+		 *    @retained_ptr to 1 if the backing store still exists (not yet purged),
+		 *    or 0 if it was already purged.
+		 *
+		 *    Important: Once marked as DONTNEED, touching the BO's memory
+		 *    is undefined behavior. It may succeed temporarily (before the
+		 *    kernel purges the backing store) but will suddenly fail once
+		 *    the BO transitions to PURGED state.
+		 *
+		 *    To transition back: use WILLNEED and check @retained_ptr —
+		 *    if 0, backing store was lost and the BO must be recreated.
+		 *
+		 *    The following operations are blocked in DONTNEED state to
+		 *    prevent the BO from being re-mapped after madvise:
+		 *    - New mmap() calls: Fail with -EBUSY
+		 *    - VM_BIND operations: Fail with -EBUSY
+		 *    - New dma-buf exports: Fail with -EBUSY
+		 *    - CPU page faults (existing mmap): Fail with SIGBUS
+		 *    - GPU page faults (fault-mode VMs): Fail with -EACCES
+		 */
+		struct {
+#define DRM_XE_VMA_PURGEABLE_STATE_WILLNEED	0
+#define DRM_XE_VMA_PURGEABLE_STATE_DONTNEED	1
+			/** @purge_state_val.val: value for DRM_XE_VMA_ATTR_PURGEABLE_STATE */
+			__u32 val;
+
+			/** @purge_state_val.pad: MBZ */
+			__u32 pad;
+			/**
+			 * @purge_state_val.retained_ptr: Pointer to a __u32 output
+			 * field for backing store status.
+			 *
+			 * Userspace must initialize the __u32 value at this address
+			 * to 0 before the ioctl. Kernel writes a __u32 after the
+			 * operation:
+			 * - 1 if backing store exists (not purged)
+			 * - 0 if backing store was purged
+			 *
+			 * If userspace fails to initialize to 0, ioctl returns -EINVAL.
+			 * This ensures a safe default (0 = assume purged) if kernel
+			 * cannot write the result.
+			 *
+			 * Similar to i915's drm_i915_gem_madvise.retained field.
+			 */
+			__u64 retained_ptr;
+		} purge_state_val;
 	};
 
 	/** @reserved: Reserved */
-- 
2.43.0

[PATCH i-g-t v6 2/9] lib/xe: Add purgeable memory ioctl support

[Arvind Yadav]

Add xe_vm_madvise_purgeable() helper function to support purgeable
memory management through the XE madvise ioctl. This allows applications
to hint to the kernel about buffer object usage patterns for better
memory management under pressure.

The function provides a clean interface to:
- Mark buffer objects as DONTNEED (purgeable)
- Mark buffer objects as WILLNEED (not purgeable)

Returns the retained value directly (1 if backing store exists, 0 if
purged).

Also update __xe_vm_madvise() to reject purgeable state operations
and direct users to the dedicated helper.

v2:
  - retained must be initialized to 0(Thomas)

v5:
  - Rename retained to retained_ptr. (Jose)

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 lib/xe/xe_ioctl.c | 33 +++++++++++++++++++++++++++++++++
 lib/xe/xe_ioctl.h |  2 ++
 2 files changed, 35 insertions(+)

diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
index ea3f2fcaa..955607f93 100644
--- a/lib/xe/xe_ioctl.c
+++ b/lib/xe/xe_ioctl.c
@@ -785,6 +785,9 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 	case DRM_XE_MEM_RANGE_ATTR_PAT:
 		madvise.pat_index.val = op_val;
 		break;
+	case DRM_XE_VMA_ATTR_PURGEABLE_STATE:
+		/* Purgeable state handled by xe_vm_madvise_purgeable */
+		return -EINVAL;
 	default:
 		igt_warn("Unknown attribute\n");
 		return -EINVAL;
@@ -821,6 +824,36 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 				      instance), 0);
 }
 
+/**
+ * xe_vm_madvise_purgeable:
+ * @fd: xe device fd
+ * @vm_id: vm_id of the virtual range
+ * @start: start of the virtual address range
+ * @range: size of the virtual address range
+ * @state: purgeable state (DRM_XE_VMA_PURGEABLE_STATE_WILLNEED or DONTNEED)
+ *
+ * Sets the purgeable state for a virtual memory range. This allows applications
+ * to hint to the kernel about buffer object usage patterns for better memory management.
+ *
+ * Returns: retained value (1 if backing store exists, 0 if purged)
+ */
+uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t start,
+				 uint64_t range, uint32_t state)
+{
+	uint32_t retained_val = 0;
+	struct drm_xe_madvise madvise = {
+		.vm_id = vm_id,
+		.start = start,
+		.range = range,
+		.type = DRM_XE_VMA_ATTR_PURGEABLE_STATE,
+		.purge_state_val.val = state,
+		.purge_state_val.retained_ptr = (uint64_t)(uintptr_t)&retained_val,
+	};
+
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_MADVISE, &madvise), 0);
+	return retained_val;
+}
+
 #define	BIND_SYNC_VAL	0x686868
 void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
 			uint64_t addr, uint64_t size, uint32_t flags)
diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
index b62d259fd..a02d68cfe 100644
--- a/lib/xe/xe_ioctl.h
+++ b/lib/xe/xe_ioctl.h
@@ -108,6 +108,8 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t
 		    uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
 void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
 		   uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
+uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t start,
+				 uint64_t range, uint32_t state);
 int xe_vm_number_vmas_in_range(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr);
 int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr,
 		    struct drm_xe_mem_range_attr *mem_attr);
-- 
2.43.0

[PATCH i-g-t v6 3/9] tests/intel/xe_madvise: Add dontneed-before-mmap subtest

[Arvind Yadav]

This test validates that mmap() fails with -EBUSY when attempting to
map a BO marked DONTNEED. The mmap offset ioctl succeeds (it just
returns the pre-allocated offset); the purgeable check happens in
xe_gem_object_mmap() at mmap() time.

  - DONTNEED BOs: return -EBUSY (temporary purgeable state, BO still
    has backing store but can be purged at any time)
  - Purged BOs: return -EINVAL (permanent, backing store discarded)

v4:
  - Move unmap outside the block. (Pravalika)
  - Added proper resource cleanup before calling igt_skip(). (Nishit)
  - Added assertion for xe_bo_map. (Nishit)

v5:
  - Add kernel capability check *_FLAG_HAS_PURGING_SUPPORT for
    purgeable support. (Jose)
  - Drop memory pressure trigger path; mark DONTNEED directly and
    assert -EBUSY from mmap offset ioctl; restore WILLNEED before
    cleanup.

v6:
  - Support iGPU by using total system RAM as the pressure baseline
    instead of VRAM size (which is 0 on iGPU).
  - Raise overpressure from 25% to 50% of the baseline to ensure the
    kernel shrinker is forced to reclaim on systems with large free RAM.
  - The DONTNEED enforcement point is mmap() itself, not the
    DRM_IOCTL_XE_GEM_MMAP_OFFSET ioctl. Update the test to mark DONTNEED
    first, then verify DRM_IOCTL_XE_GEM_MMAP_OFFSET still succeeds, and
    finally verify that mmap() fails with -EBUSY

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 233 +++++++++++++++++++++++++++++++++++++++
 tests/meson.build        |   1 +
 2 files changed, 234 insertions(+)
 create mode 100644 tests/intel/xe_madvise.c

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
new file mode 100644
index 000000000..de4a6e34c
--- /dev/null
+++ b/tests/intel/xe_madvise.c
@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright © 2025 Intel Corporation
+ */
+
+/**
+ * TEST: Validate purgeable BO madvise functionality
+ * Category: Core
+ * Mega feature: General Core features
+ * Sub-category: Memory management tests
+ * Functionality: madvise, purgeable
+ */
+
+#include "igt.h"
+#include "xe_drm.h"
+
+#include "xe/xe_ioctl.h"
+#include "xe/xe_query.h"
+
+static bool xe_has_purgeable_support(int fd)
+{
+	struct drm_xe_query_config *config = xe_config(fd);
+
+	return config->info[DRM_XE_QUERY_CONFIG_FLAGS] &
+		DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT;
+}
+
+/* Purgeable test constants */
+#define PURGEABLE_ADDR		0x1a0000
+#define PURGEABLE_BO_SIZE	4096
+
+/**
+ * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable reclaim
+ * @fd: DRM file descriptor
+ * @vm: VM handle (unused, kept for API compatibility)
+ *
+ * Allocates BOs in a temporary VM until memory is overcommitted by 50%,
+ * forcing the kernel to purge DONTNEED-marked BOs.
+ */
+static void trigger_memory_pressure(int fd, uint32_t vm)
+{
+	uint64_t vram_size, mem_size, overpressure;
+	const uint64_t chunk = 8ull << 20; /* 8 MiB */
+	int max_objs, n = 0;
+	uint32_t *handles;
+	uint64_t total;
+	void *p;
+	uint32_t handle, temp_vm;
+
+	/* Use a separate VM so pressure BOs don't affect the test VM */
+	temp_vm = xe_vm_create(fd, 0, 0);
+
+	vram_size = xe_visible_vram_size(fd, 0);
+	if (vram_size > 0) {
+		/* dGPU: pressure VRAM to trigger purgeable reclaim */
+		mem_size = vram_size;
+	} else {
+		/*
+		 * iGPU: purgeable BOs reside in system memory. Use *total*
+		 * RAM (not just available) as the baseline so that we always
+		 * over-commit regardless of how much is already in use.
+		 */
+		mem_size = igt_get_total_ram_mb() << 20;
+	}
+
+	/* Scale overpressure to 50% of memory, minimum 64MB */
+	overpressure = mem_size / 2;
+	if (overpressure < (64 << 20))
+		overpressure = 64 << 20;
+
+	max_objs = (mem_size + overpressure) / chunk + 1;
+	handles = malloc(max_objs * sizeof(*handles));
+	igt_assert(handles);
+
+	total = 0;
+	while (total < mem_size + overpressure && n < max_objs) {
+		uint32_t err;
+
+		err = __xe_bo_create(fd, temp_vm, chunk,
+				     vram_if_possible(fd, 0),
+				     DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+				     NULL, &handle);
+		if (err) /* Out of memory — sufficient pressure achieved */
+			break;
+
+		handles[n++] = handle;
+		total += chunk;
+
+		p = xe_bo_map(fd, handle, chunk);
+		igt_assert(p != MAP_FAILED);
+
+		/* Fault in all pages so they actually consume memory */
+		memset(p, 0xCD, chunk);
+		munmap(p, chunk);
+	}
+
+	/* Allow shrinker time to process pressure */
+	usleep(100000);
+
+	for (int i = 0; i < n; i++)
+		gem_close(fd, handles[i]);
+
+	free(handles);
+
+	xe_vm_destroy(fd, temp_vm);
+}
+
+static jmp_buf jmp;
+
+__noreturn static void sigtrap(int sig)
+{
+	siglongjmp(jmp, sig);
+}
+
+/**
+ * purgeable_mark_and_verify_purged - Mark DONTNEED, pressure, check purged
+ * @fd: DRM file descriptor
+ * @vm: VM handle
+ * @addr: Virtual address of the BO
+ * @size: Size of the BO
+ *
+ * Returns true if the BO was purged under memory pressure.
+ */
+static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, uint64_t addr, size_t size)
+{
+	uint32_t retained;
+
+	/* Mark as DONTNEED */
+	retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	if (retained != 1)
+		return false;
+
+	/* Trigger memory pressure */
+	trigger_memory_pressure(fd, vm);
+
+	/* Verify purged */
+	retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
+					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+	return retained == 0;
+}
+
+/**
+ * purgeable_setup_simple_bo - Setup VM and bind a single BO
+ * @fd: DRM file descriptor
+ * @vm: Output VM handle
+ * @bo: Output BO handle
+ * @addr: Virtual address to bind at
+ * @size: Size of the BO
+ * @use_scratch: Whether to use scratch page flag
+ *
+ * Helper to create VM, BO, and bind it at the specified address.
+ */
+static void purgeable_setup_simple_bo(int fd, uint32_t *vm, uint32_t *bo,
+				      uint64_t addr, size_t size, bool use_scratch)
+{
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.timeline_value = 1,
+	};
+	uint64_t sync_val = 0;
+
+	*vm = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
+	*bo = xe_bo_create(fd, *vm, size, vram_if_possible(fd, 0),
+			   DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
+
+	sync.addr = to_user_pointer(&sync_val);
+	xe_vm_bind_async(fd, *vm, 0, *bo, 0, addr, size, &sync, 1);
+	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
+}
+
+/**
+ * SUBTEST: dontneed-before-mmap
+ * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
+ * Test category: functionality test
+ */
+static void test_dontneed_before_mmap(int fd)
+{
+	uint32_t bo, vm;
+	uint64_t addr = PURGEABLE_ADDR;
+	size_t bo_size = PURGEABLE_BO_SIZE;
+	struct drm_xe_gem_mmap_offset mmo = {};
+	uint32_t retained;
+	void *ptr;
+
+	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
+
+	/* Mark BO as DONTNEED - new mmap operations must be blocked */
+	retained = xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	/* Ioctl succeeds even for DONTNEED BO; blocking happens at mmap() time. */
+	mmo.handle = bo;
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 0);
+
+	/* mmap() on a DONTNEED BO must fail with EBUSY. */
+	ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mmo.offset);
+	igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
+	igt_assert_eq(errno, EBUSY);
+
+	/* Restore to WILLNEED before cleanup */
+	xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
+				DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+
+	gem_close(fd, bo);
+	xe_vm_destroy(fd, vm);
+}
+
+int igt_main()
+{
+	struct drm_xe_engine_class_instance *hwe;
+	int fd;
+
+	igt_fixture() {
+		fd = drm_open_driver(DRIVER_XE);
+		xe_device_get(fd);
+		igt_require_f(xe_has_purgeable_support(fd),
+			      "Kernel does not support purgeable buffer objects\n");
+	}
+
+	igt_subtest("dontneed-before-mmap")
+		xe_for_each_engine(fd, hwe) {
+			test_dontneed_before_mmap(fd);
+			break;
+		}
+
+	igt_fixture() {
+		xe_device_put(fd);
+		drm_close_driver(fd);
+	}
+}
diff --git a/tests/meson.build b/tests/meson.build
index cecb4a8ae..a6370b685 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -314,6 +314,7 @@ intel_xe_progs = [
 	'xe_huc_copy',
 	'xe_intel_bb',
 	'xe_live_ktest',
+	'xe_madvise',
 	'xe_media_fill',
 	'xe_mmap',
         'xe_module_load',
-- 
2.43.0

[PATCH i-g-t v6 4/9] tests/intel/xe_madvise: Add purged-mmap-blocked subtest

[Arvind Yadav]

Add a new purged-mmap-blocked subtest that triggers an actual purge
via memory pressure and verifies that mmap() fails with -EINVAL once
the BO backing store has been permanently discarded.

The purgeable check moved from xe_gem_mmap_offset_ioctl()
into a new xe_gem_object_mmap() callback, so the blocking point is now
mmap() itself rather than the mmap offset ioctl:

  - DRM_IOCTL_XE_GEM_MMAP_OFFSET: always succeeds regardless of
    purgeable state (just returns the pre-allocated offset)
  - mmap() on DONTNEED BO: fails with -EBUSY (temporary state)
  - mmap() on purged BO: fails with -EINVAL (permanent, no backing store)

v5:
  - Add purged-mmap-blocked subtest to verify mmap is blocked after
    BO backing store is permanently purged.

v6:
  - DRM_IOCTL_XE_GEM_MMAP_OFFSET always succeeds; the purgeable check
    now happens in xe_gem_object_mmap() at mmap() time. For purged BOs,
    assert mmap() fails with -EINVAL.

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 42 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index de4a6e34c..81e05b6d4 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -170,6 +170,42 @@ static void purgeable_setup_simple_bo(int fd, uint32_t *vm, uint32_t *bo,
 	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
 }
 
+/**
+ * SUBTEST: purged-mmap-blocked
+ * Description: After BO is purged, verify mmap() fails with -EINVAL
+ * Test category: functionality test
+ */
+static void test_purged_mmap_blocked(int fd)
+{
+	uint32_t bo, vm;
+	uint64_t addr = PURGEABLE_ADDR;
+	size_t bo_size = PURGEABLE_BO_SIZE;
+	struct drm_xe_gem_mmap_offset mmo = {};
+	void *ptr;
+
+	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
+	if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
+		gem_close(fd, bo);
+		xe_vm_destroy(fd, vm);
+		igt_skip("Unable to induce purge on this platform/config");
+	}
+
+	/*
+	 * Getting the mmap offset is always allowed regardless of purgeable
+	 * state - the blocking happens at mmap() time (xe_gem_object_mmap).
+	 * For a purged BO, mmap() must fail with -EINVAL (no backing store).
+	 */
+	mmo.handle = bo;
+	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 0);
+
+	ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mmo.offset);
+	igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
+	igt_assert_eq(errno, EINVAL);
+
+	gem_close(fd, bo);
+	xe_vm_destroy(fd, vm);
+}
+
 /**
  * SUBTEST: dontneed-before-mmap
  * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
@@ -226,6 +262,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("purged-mmap-blocked")
+		xe_for_each_engine(fd, hwe) {
+			test_purged_mmap_blocked(fd);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

[PATCH i-g-t v6 5/9] tests/intel/xe_madvise: Add dontneed-after-mmap subtest

[Arvind Yadav]

This test verifies that an existing mmap becomes invalid after the BO
is marked as purgeable and purged. The test creates a BO, maps it,
writes data, then marks it DONTNEED and triggers memory pressure.
Accessing the previously valid mapping should now trigger SIGBUS or
SIGSEGV, confirming that existing mappings are correctly invalidated
when the backing store is purged.

v4:
  - Added proper resource cleanup before calling igt_skip(). (Nishit)
  - Added assertion for xe_bo_map. (Nishit)

v6:
  - Fix sigsetjmp(jmp, SIGBUS | SIGSEGV) to sigsetjmp(jmp, 1). The
    second argument is a plain boolean savemask, not a signal set.

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 64 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index 81e05b6d4..9a157de1d 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -244,6 +244,64 @@ static void test_dontneed_before_mmap(int fd)
 	xe_vm_destroy(fd, vm);
 }
 
+/**
+ * SUBTEST: dontneed-after-mmap
+ * Description: Mark BO as DONTNEED after mmap, verify SIGBUS on accessing purged mapping
+ * Test category: functionality test
+ */
+static void test_dontneed_after_mmap(int fd)
+{
+	uint32_t bo, vm;
+	uint64_t addr = PURGEABLE_ADDR;
+	size_t bo_size = PURGEABLE_BO_SIZE;
+	void *map;
+
+	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, true);
+
+	map = xe_bo_map(fd, bo, bo_size);
+	igt_assert(map != MAP_FAILED);
+	memset(map, 0xAB, bo_size);
+
+	if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
+		munmap(map, bo_size);
+		gem_close(fd, bo);
+		xe_vm_destroy(fd, vm);
+		igt_skip("Unable to induce purge on this platform/config");
+	}
+
+	/* Access purged mapping - should trigger SIGBUS/SIGSEGV */
+	{
+		sighandler_t old_sigsegv, old_sigbus;
+		char *ptr = (char *)map;
+		int sig;
+
+		old_sigsegv = signal(SIGSEGV, (__sighandler_t)sigtrap);
+		old_sigbus = signal(SIGBUS, (__sighandler_t)sigtrap);
+
+		sig = sigsetjmp(jmp, 1); /* savemask=1: save/restore signal mask */
+		switch (sig) {
+		case SIGBUS:
+		case SIGSEGV:
+			/* Expected - purged mapping access failed */
+			break;
+		case 0:
+			*ptr = 0;
+		default:
+			igt_assert_f(false,
+				     "Access to purged mapping should trigger SIGBUS, got sig=%d\n",
+				     sig);
+			break;
+		}
+
+		signal(SIGBUS, old_sigbus);
+		signal(SIGSEGV, old_sigsegv);
+	}
+
+	munmap(map, bo_size);
+	gem_close(fd, bo);
+	xe_vm_destroy(fd, vm);
+}
+
 int igt_main()
 {
 	struct drm_xe_engine_class_instance *hwe;
@@ -268,6 +326,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("dontneed-after-mmap")
+		xe_for_each_engine(fd, hwe) {
+			test_dontneed_after_mmap(fd);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

[PATCH i-g-t v6 6/9] tests/intel/xe_madvise: Add dontneed-before-exec subtest

[Arvind Yadav]

This test validates GPU execution behavior when a data BO is purged
before submission. The test creates a batch that writes to a data BO,
purges the data BO (while keeping the batch BO valid to avoid GPU
reset), then submits for execution. With VM_CREATE_FLAG_SCRATCH_PAGE,
the GPU write may succeed by landing on scratch memory instead of the
purged BO, demonstrating graceful handling of purged memory during
GPU operations.

v4:
  - Added proper resource cleanup before calling igt_skip(). (Nishit)

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Reviewed-by: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 148 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 148 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index 9a157de1d..d126db9ed 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -27,7 +27,11 @@ static bool xe_has_purgeable_support(int fd)
 
 /* Purgeable test constants */
 #define PURGEABLE_ADDR		0x1a0000
+#define PURGEABLE_BATCH_ADDR	0x3c0000
 #define PURGEABLE_BO_SIZE	4096
+#define PURGEABLE_FENCE_VAL	0xbeef
+#define PURGEABLE_TEST_PATTERN	0xc0ffee
+#define PURGEABLE_DEAD_PATTERN	0xdead
 
 /**
  * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable reclaim
@@ -206,6 +210,62 @@ static void test_purged_mmap_blocked(int fd)
 	xe_vm_destroy(fd, vm);
 }
 
+/**
+ * purgeable_setup_batch_and_data - Setup VM with batch and data BOs for GPU exec
+ * @fd: DRM file descriptor
+ * @vm: Output VM handle
+ * @bind_engine: Output bind engine handle
+ * @batch_bo: Output batch BO handle
+ * @data_bo: Output data BO handle
+ * @batch: Output batch buffer pointer
+ * @data: Output data buffer pointer
+ * @batch_addr: Batch virtual address
+ * @data_addr: Data virtual address
+ * @batch_size: Batch buffer size
+ * @data_size: Data buffer size
+ *
+ * Helper to create VM, bind engine, batch and data BOs, and bind them.
+ */
+static void purgeable_setup_batch_and_data(int fd, uint32_t *vm,
+					   uint32_t *bind_engine,
+					   uint32_t *batch_bo,
+					   uint32_t *data_bo,
+					   uint32_t **batch,
+					   uint32_t **data,
+					   uint64_t batch_addr,
+					   uint64_t data_addr,
+					   size_t batch_size,
+					   size_t data_size)
+{
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.timeline_value = PURGEABLE_FENCE_VAL,
+	};
+	uint64_t vm_sync = 0;
+
+	*vm = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE, 0);
+	*bind_engine = xe_bind_exec_queue_create(fd, *vm, 0);
+
+	/* Create and bind batch BO */
+	*batch_bo = xe_bo_create(fd, *vm, batch_size, vram_if_possible(fd, 0),
+				 DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
+	*batch = xe_bo_map(fd, *batch_bo, batch_size);
+
+	sync.addr = to_user_pointer(&vm_sync);
+	xe_vm_bind_async(fd, *vm, *bind_engine, *batch_bo, 0, batch_addr, batch_size, &sync, 1);
+	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
+
+	/* Create and bind data BO */
+	*data_bo = xe_bo_create(fd, *vm, data_size, vram_if_possible(fd, 0),
+				DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
+	*data = xe_bo_map(fd, *data_bo, data_size);
+
+	vm_sync = 0;
+	xe_vm_bind_async(fd, *vm, *bind_engine, *data_bo, 0, data_addr, data_size, &sync, 1);
+	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
+}
+
 /**
  * SUBTEST: dontneed-before-mmap
  * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
@@ -302,6 +362,88 @@ static void test_dontneed_after_mmap(int fd)
 	xe_vm_destroy(fd, vm);
 }
 
+/**
+ * SUBTEST: dontneed-before-exec
+ * Description: Mark BO as DONTNEED before GPU exec, verify GPU behavior with SCRATCH_PAGE
+ * Test category: functionality test
+ */
+static void test_dontneed_before_exec(int fd, struct drm_xe_engine_class_instance *hwe)
+{
+	uint32_t vm, exec_queue, bo, batch_bo, bind_engine;
+	uint64_t data_addr = PURGEABLE_ADDR;
+	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
+	size_t data_size = PURGEABLE_BO_SIZE;
+	size_t batch_size = PURGEABLE_BO_SIZE;
+	struct drm_xe_sync sync[1] = {
+		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		  .timeline_value = PURGEABLE_FENCE_VAL },
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 1,
+		.syncs = to_user_pointer(sync),
+	};
+	uint32_t *data, *batch;
+	uint64_t vm_sync = 0;
+	int b, ret;
+
+	purgeable_setup_batch_and_data(fd, &vm, &bind_engine, &batch_bo,
+				       &bo, &batch, &data, batch_addr,
+				       data_addr, batch_size, data_size);
+
+	/* Prepare batch */
+	b = 0;
+	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
+	batch[b++] = data_addr;
+	batch[b++] = data_addr >> 32;
+	batch[b++] = PURGEABLE_DEAD_PATTERN;
+	batch[b++] = MI_BATCH_BUFFER_END;
+
+	/* Phase 1: Purge data BO, batch BO still valid */
+	if (!purgeable_mark_and_verify_purged(fd, vm, data_addr, data_size)) {
+		munmap(data, data_size);
+		munmap(batch, batch_size);
+		gem_close(fd, bo);
+		gem_close(fd, batch_bo);
+		xe_exec_queue_destroy(fd, bind_engine);
+		xe_vm_destroy(fd, vm);
+		igt_skip("Unable to induce purge on this platform/config");
+	}
+
+	exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
+	exec.exec_queue_id = exec_queue;
+	exec.address = batch_addr;
+
+	vm_sync = 0;
+	sync[0].addr = to_user_pointer(&vm_sync);
+
+	/*
+	 * VM has SCRATCH_PAGE — exec may succeed with the GPU write
+	 * landing on scratch instead of the purged data BO.
+	 */
+	ret = __xe_exec(fd, &exec);
+	if (ret == 0) {
+		int64_t timeout = NSEC_PER_SEC;
+
+		__xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL,
+				 exec_queue, &timeout);
+	}
+
+	/*
+	 * Don't purge the batch BO — GPU would fetch zeroed scratch
+	 * instructions and trigger an engine reset.
+	 */
+
+	munmap(data, data_size);
+	munmap(batch, batch_size);
+	gem_close(fd, bo);
+	gem_close(fd, batch_bo);
+	xe_exec_queue_destroy(fd, bind_engine);
+	xe_exec_queue_destroy(fd, exec_queue);
+	xe_vm_destroy(fd, vm);
+}
+
 int igt_main()
 {
 	struct drm_xe_engine_class_instance *hwe;
@@ -332,6 +474,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("dontneed-before-exec")
+		xe_for_each_engine(fd, hwe) {
+			test_dontneed_before_exec(fd, hwe);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

[PATCH i-g-t v6 7/9] tests/intel/xe_madvise: Add dontneed-after-exec subtest

[Arvind Yadav]

This test verifies that memory can be marked purgeable and reclaimed
after successful GPU execution. The test first executes a batch that
writes to a data BO and verifies the result. It then marks the BO as
DONTNEED, triggers memory pressure to purge it, and attempts a second
execution. The second execution may fail or succeed with scratch
rebind, validating that the kernel correctly handles purged BOs in
GPU submissions.

v4:
   - Added proper resource cleanup before calling igt_skip(). (Nishit)
   - Added assertion for xe_bo_map. (Nishit)
   - Now using sync[0] consistently. (Nishit)
   - Added clarifying comment. (Nishit)

Cc: Nishit Sharma <nishit.sharma@intel.com>
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>
Reviewed-by: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 108 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index d126db9ed..28ea81442 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -16,6 +16,7 @@
 
 #include "xe/xe_ioctl.h"
 #include "xe/xe_query.h"
+#include "lib/igt_syncobj.h"
 
 static bool xe_has_purgeable_support(int fd)
 {
@@ -444,6 +445,107 @@ static void test_dontneed_before_exec(int fd, struct drm_xe_engine_class_instanc
 	xe_vm_destroy(fd, vm);
 }
 
+/**
+ * SUBTEST: dontneed-after-exec
+ * Description: Mark BO as DONTNEED after GPU exec, verify memory becomes inaccessible
+ * Test category: functionality test
+ */
+static void test_dontneed_after_exec(int fd, struct drm_xe_engine_class_instance *hwe)
+{
+	uint32_t vm, exec_queue, bo, batch_bo, bind_engine;
+	uint64_t data_addr = PURGEABLE_ADDR;
+	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
+	size_t data_size = PURGEABLE_BO_SIZE;
+	size_t batch_size = PURGEABLE_BO_SIZE;
+	struct drm_xe_sync sync[2] = {
+		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		  .timeline_value = PURGEABLE_FENCE_VAL },
+		{ .type = DRM_XE_SYNC_TYPE_SYNCOBJ,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL },
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 2,
+		.syncs = to_user_pointer(sync),
+	};
+	uint32_t *data, *batch;
+	uint32_t syncobj;
+	int b, ret;
+
+	purgeable_setup_batch_and_data(fd, &vm, &bind_engine, &batch_bo,
+				       &bo, &batch, &data, batch_addr,
+				       data_addr, batch_size, data_size);
+	memset(data, 0, data_size);
+
+	syncobj = syncobj_create(fd, 0);
+
+	/* Prepare batch to write to data BO */
+	b = 0;
+	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
+	batch[b++] = data_addr;
+	batch[b++] = data_addr >> 32;
+	batch[b++] = 0xfeed0001;
+	batch[b++] = MI_BATCH_BUFFER_END;
+
+	exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
+	exec.exec_queue_id = exec_queue;
+	exec.address = batch_addr;
+
+	/* Use only syncobj for exec (not USER_FENCE) */
+	sync[0].type = DRM_XE_SYNC_TYPE_SYNCOBJ;
+	sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
+	sync[0].handle = syncobj;
+	exec.num_syncs = 1;
+	exec.syncs = to_user_pointer(&sync[0]);
+
+	ret = __xe_exec(fd, &exec);
+	igt_assert_eq(ret, 0);
+
+	igt_assert(syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL));
+	munmap(data, data_size);
+	data = xe_bo_map(fd, bo, data_size);
+	igt_assert(data != MAP_FAILED);
+	igt_assert_eq(data[0], 0xfeed0001);
+
+	if (!purgeable_mark_and_verify_purged(fd, vm, data_addr, data_size)) {
+		munmap(data, data_size);
+		munmap(batch, batch_size);
+		gem_close(fd, bo);
+		gem_close(fd, batch_bo);
+		syncobj_destroy(fd, syncobj);
+		xe_exec_queue_destroy(fd, bind_engine);
+		xe_exec_queue_destroy(fd, exec_queue);
+		xe_vm_destroy(fd, vm);
+		igt_skip("Unable to induce purge on this platform/config");
+	}
+
+	/* Prepare second batch (different value) */
+	b = 0;
+	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
+	batch[b++] = data_addr;
+	batch[b++] = data_addr >> 32;
+	batch[b++] = 0xfeed0002;
+	batch[b++] = MI_BATCH_BUFFER_END;
+
+	/*
+	 * Second exec with purged BO - may succeed (scratch rebind) or fail.
+	 * Either is valid, so don't check results.
+	 */
+	ret = __xe_exec(fd, &exec);
+	if (ret == 0)
+		syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL);
+
+	munmap(data, data_size);
+	munmap(batch, batch_size);
+	gem_close(fd, bo);
+	gem_close(fd, batch_bo);
+	syncobj_destroy(fd, syncobj);
+	xe_exec_queue_destroy(fd, bind_engine);
+	xe_exec_queue_destroy(fd, exec_queue);
+	xe_vm_destroy(fd, vm);
+}
+
 int igt_main()
 {
 	struct drm_xe_engine_class_instance *hwe;
@@ -480,6 +582,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("dontneed-after-exec")
+		xe_for_each_engine(fd, hwe) {
+			test_dontneed_after_exec(fd, hwe);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

[PATCH i-g-t v6 8/9] tests/intel/xe_madvise: Add per-vma-tracking subtest

[Arvind Yadav]

This test validates that purgeable state is tracked per-VMA when a
single BO is bound in multiple VMs. The test creates one BO shared
across two VMs at different virtual addresses. It verifies that marking
only one VMA as DONTNEED does not make the BO purgeable, but marking
both VMAs as DONTNEED allows the kernel to purge the shared BO. This
ensures proper per-VMA tracking for shared memory.

v4:
  -  The comment now clarifies that triggering pressure. (Nishit)

v6:
  - Move resource cleanup before igt_skip() to avoid leaking VM and BO
    handles on platforms where memory pressure cannot be induced; replace
    igt_assert_eq(retained, 0) with a graceful skip. (Nishit)

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>
Cc: Nishit Sharma <nishit.sharma@intel.com>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 114 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index 28ea81442..6c0a563d8 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -28,6 +28,7 @@ static bool xe_has_purgeable_support(int fd)
 
 /* Purgeable test constants */
 #define PURGEABLE_ADDR		0x1a0000
+#define PURGEABLE_ADDR2		0x2b0000
 #define PURGEABLE_BATCH_ADDR	0x3c0000
 #define PURGEABLE_BO_SIZE	4096
 #define PURGEABLE_FENCE_VAL	0xbeef
@@ -267,6 +268,58 @@ static void purgeable_setup_batch_and_data(int fd, uint32_t *vm,
 	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
 }
 
+/**
+ * purgeable_setup_two_vms_shared_bo - Setup two VMs with one shared BO
+ * @fd: DRM file descriptor
+ * @vm1: Output first VM handle
+ * @vm2: Output second VM handle
+ * @bo: Output shared BO handle
+ * @addr1: Virtual address in VM1
+ * @addr2: Virtual address in VM2
+ * @size: Size of the BO
+ * @use_scratch: Whether to use scratch page flag for VMs
+ *
+ * Helper to create two VMs and bind one shared BO in both VMs.
+ * Returns mapped pointer to the BO.
+ */
+static void *purgeable_setup_two_vms_shared_bo(int fd, uint32_t *vm1, uint32_t *vm2,
+					       uint32_t *bo, uint64_t addr1,
+					       uint64_t addr2, size_t size,
+					       bool use_scratch)
+{
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		.timeline_value = 1,
+	};
+	uint64_t sync_val = 0;
+	void *map;
+
+	/* Create two VMs */
+	*vm1 = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
+	*vm2 = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
+
+	/* Create shared BO */
+	*bo = xe_bo_create(fd, 0, size, vram_if_possible(fd, 0),
+			   DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
+
+	map = xe_bo_map(fd, *bo, size);
+	memset(map, 0xAB, size);
+
+	/* Bind BO in VM1 */
+	sync.addr = to_user_pointer(&sync_val);
+	sync_val = 0;
+	xe_vm_bind_async(fd, *vm1, 0, *bo, 0, addr1, size, &sync, 1);
+	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
+
+	/* Bind BO in VM2 */
+	sync_val = 0;
+	xe_vm_bind_async(fd, *vm2, 0, *bo, 0, addr2, size, &sync, 1);
+	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
+
+	return map;
+}
+
 /**
  * SUBTEST: dontneed-before-mmap
  * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
@@ -546,6 +599,61 @@ static void test_dontneed_after_exec(int fd, struct drm_xe_engine_class_instance
 	xe_vm_destroy(fd, vm);
 }
 
+/**
+ * SUBTEST: per-vma-tracking
+ * Description: One BO in two VMs becomes purgeable only when both VMAs are DONTNEED
+ * Test category: functionality test
+ */
+static void test_per_vma_tracking(int fd, struct drm_xe_engine_class_instance *hwe)
+{
+	uint32_t bo, vm1, vm2;
+	uint64_t addr1 = PURGEABLE_ADDR;
+	uint64_t addr2 = PURGEABLE_ADDR2;
+	size_t bo_size = PURGEABLE_BO_SIZE;
+	uint32_t retained;
+	void *map;
+
+	map = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
+						addr1, addr2,
+						bo_size, false);
+
+	/* Mark VMA1 as DONTNEED */
+	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	/* Verify BO NOT purgeable (VMA2 still WILLNEED) */
+	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+	igt_assert_eq(retained, 1);
+
+	/* Mark both VMAs as DONTNEED */
+	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	retained = xe_vm_madvise_purgeable(fd, vm2, addr2, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	/*
+	 * Trigger pressure and verify BO was purged.
+	 * Using vm1 is sufficient since both VMAs are DONTNEED - kernel can purge the BO.
+	 */
+	trigger_memory_pressure(fd, vm1);
+
+	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+	munmap(map, bo_size);
+	gem_close(fd, bo);
+	xe_vm_destroy(fd, vm1);
+	xe_vm_destroy(fd, vm2);
+
+	if (retained != 0)
+		igt_skip("Unable to induce purge on this platform/config");
+
+}
+
 int igt_main()
 {
 	struct drm_xe_engine_class_instance *hwe;
@@ -588,6 +696,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("per-vma-tracking")
+		xe_for_each_engine(fd, hwe) {
+			test_per_vma_tracking(fd, hwe);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

[PATCH i-g-t v6 9/9] tests/intel/xe_madvise: Add per-vma-protection subtest

[Arvind Yadav]

This test validates that a WILLNEED VMA protects a shared BO from being
purged even when other VMAs are marked DONTNEED. The test creates a BO
shared across two VMs, marks VMA1 as DONTNEED while keeping VMA2 as
WILLNEED, then triggers memory pressure. The BO should survive and GPU
execution should succeed. After marking both VMAs as DONTNEED and
triggering pressure again, the BO should be purged, demonstrating that
all VMAs must be DONTNEED for the BO to be purgeable.

v4:
  - Added syncobj_wait() after the second exec. (Nishit)

v6:
  - Move resource cleanup before igt_skip() to avoid leaking VM and BO
    handles on platforms where memory pressure cannot be induced; replace
    igt_assert_eq(retained, 0) with a graceful skip. (Nishit)

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>
Cc: Nishit Sharma <nishit.sharma@intel.com>
Cc: Pravalika Gurram <pravalika.gurram@intel.com>
Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
---
 tests/intel/xe_madvise.c | 127 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
index 6c0a563d8..2375f5475 100644
--- a/tests/intel/xe_madvise.c
+++ b/tests/intel/xe_madvise.c
@@ -654,6 +654,127 @@ static void test_per_vma_tracking(int fd, struct drm_xe_engine_class_instance *h
 
 }
 
+/**
+ * SUBTEST: per-vma-protection
+ * Description: WILLNEED VMA protects BO from purging; both DONTNEED makes BO purgeable
+ * Test category: functionality test
+ */
+static void test_per_vma_protection(int fd, struct drm_xe_engine_class_instance *hwe)
+{
+	uint32_t vm1, vm2, exec_queue, bo, batch_bo, bind_engine;
+	uint64_t data_addr1 = PURGEABLE_ADDR;
+	uint64_t data_addr2 = PURGEABLE_ADDR2;
+	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
+	size_t data_size = PURGEABLE_BO_SIZE;
+	size_t batch_size = PURGEABLE_BO_SIZE;
+	struct drm_xe_sync sync[2] = {
+		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
+		  .timeline_value = PURGEABLE_FENCE_VAL },
+		{ .type = DRM_XE_SYNC_TYPE_SYNCOBJ,
+		  .flags = DRM_XE_SYNC_FLAG_SIGNAL },
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 1,
+		.syncs = to_user_pointer(&sync[1]),
+	};
+	uint32_t *data, *batch;
+	uint64_t vm_sync = 0;
+	uint32_t retained, syncobj;
+	int b, ret;
+
+	/* Create two VMs and bind shared data BO */
+	data = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
+						 data_addr1, data_addr2,
+						 data_size, true);
+	memset(data, 0, data_size);
+	bind_engine = xe_bind_exec_queue_create(fd, vm2, 0);
+
+	/* Create and bind batch BO in VM2 */
+	batch_bo = xe_bo_create(fd, vm2, batch_size, vram_if_possible(fd, 0),
+				DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
+	batch = xe_bo_map(fd, batch_bo, batch_size);
+	igt_assert(batch != MAP_FAILED);
+
+	sync[0].addr = to_user_pointer(&vm_sync);
+	vm_sync = 0;
+	xe_vm_bind_async(fd, vm2, bind_engine, batch_bo, 0, batch_addr, batch_size, sync, 1);
+	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
+
+	/* Mark VMA1 as DONTNEED, VMA2 stays WILLNEED */
+	retained = xe_vm_madvise_purgeable(fd, vm1, data_addr1, data_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	/* Trigger pressure - BO should survive (VMA2 protects) */
+	trigger_memory_pressure(fd, vm1);
+
+	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+	igt_assert_eq(retained, 1);
+
+	/* GPU workload - should succeed */
+	b = 0;
+	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
+	batch[b++] = data_addr2;
+	batch[b++] = data_addr2 >> 32;
+	batch[b++] = PURGEABLE_TEST_PATTERN;
+	batch[b++] = MI_BATCH_BUFFER_END;
+
+	syncobj = syncobj_create(fd, 0);
+	sync[1].handle = syncobj;
+	exec_queue = xe_exec_queue_create(fd, vm2, hwe, 0);
+	exec.exec_queue_id = exec_queue;
+	exec.address = batch_addr;
+
+	ret = __xe_exec(fd, &exec);
+	igt_assert_eq(ret, 0);
+	igt_assert(syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL));
+
+	munmap(data, data_size);
+	data = xe_bo_map(fd, bo, data_size);
+	igt_assert(data != MAP_FAILED);
+	igt_assert_eq(data[0], PURGEABLE_TEST_PATTERN);
+
+	/* Mark both VMAs DONTNEED */
+	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
+	igt_assert_eq(retained, 1);
+
+	/* Trigger pressure - BO should be purged */
+	trigger_memory_pressure(fd, vm1);
+
+	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
+					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
+
+	if (retained != 0)
+		goto out;
+
+	/* GPU workload - should fail or succeed with NULL rebind */
+	batch[3] = PURGEABLE_DEAD_PATTERN;
+
+	ret = __xe_exec(fd, &exec);
+	if (ret == 0) {
+		/* Exec succeeded, wait for completion before cleanup */
+		syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL);
+	}
+
+out:
+	munmap(data, data_size);
+	munmap(batch, batch_size);
+	gem_close(fd, bo);
+	gem_close(fd, batch_bo);
+	syncobj_destroy(fd, syncobj);
+	xe_exec_queue_destroy(fd, bind_engine);
+	xe_exec_queue_destroy(fd, exec_queue);
+	xe_vm_destroy(fd, vm1);
+	xe_vm_destroy(fd, vm2);
+
+	if (retained != 0)
+		igt_skip("Unable to induce purge on this platform/config");
+}
+
 int igt_main()
 {
 	struct drm_xe_engine_class_instance *hwe;
@@ -702,6 +823,12 @@ int igt_main()
 			break;
 		}
 
+	igt_subtest("per-vma-protection")
+		xe_for_each_engine(fd, hwe) {
+			test_per_vma_protection(fd, hwe);
+			break;
+		}
+
 	igt_fixture() {
 		xe_device_put(fd);
 		drm_close_driver(fd);
-- 
2.43.0

✓ Xe.CI.BAT: success for tests/xe: Add purgeable memory madvise tests for system allocator (rev6)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 1751 bytes --]

== Series Details ==

Series: tests/xe: Add purgeable memory madvise tests for system allocator (rev6)
URL   : https://patchwork.freedesktop.org/series/160333/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8829_BAT -> XEIGTPW_14855_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (14 -> 14)
------------------------------

  No changes in participating hosts

Known issues
------------

  Here are the changes found in XEIGTPW_14855_BAT that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_flip@basic-flip-vs-wf_vblank@c-edp1:
    - bat-adlp-7:         [PASS][1] -> [DMESG-WARN][2] ([Intel XE#7483])
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/bat-adlp-7/igt@kms_flip@basic-flip-vs-wf_vblank@c-edp1.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/bat-adlp-7/igt@kms_flip@basic-flip-vs-wf_vblank@c-edp1.html

  
#### Possible fixes ####

  * igt@kms_flip@basic-flip-vs-wf_vblank@d-edp1:
    - bat-adlp-7:         [DMESG-WARN][3] ([Intel XE#7483]) -> [PASS][4]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/bat-adlp-7/igt@kms_flip@basic-flip-vs-wf_vblank@d-edp1.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/bat-adlp-7/igt@kms_flip@basic-flip-vs-wf_vblank@d-edp1.html

  
  [Intel XE#7483]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7483


Build changes
-------------

  * IGT: IGT_8829 -> IGTPW_14855

  IGTPW_14855: 14855
  IGT_8829: 8829
  xe-4785-ec0484d20b9f962d04a62ff1feb03676c3ce7611: ec0484d20b9f962d04a62ff1feb03676c3ce7611

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/index.html

[-- Attachment #2: Type: text/html, Size: 2411 bytes --]

✓ i915.CI.BAT: success for tests/xe: Add purgeable memory madvise tests for system allocator (rev6)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 5316 bytes --]

== Series Details ==

Series: tests/xe: Add purgeable memory madvise tests for system allocator (rev6)
URL   : https://patchwork.freedesktop.org/series/160333/
State : success

== Summary ==

CI Bug Log - changes from IGT_8829 -> IGTPW_14855
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/index.html

Participating hosts (39 -> 39)
------------------------------

  Additional (1): bat-adls-6 
  Missing    (1): bat-dg2-13 

Known issues
------------

  Here are the changes found in IGTPW_14855 that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@gem_lmem_swapping@parallel-random-engines:
    - bat-adls-6:         NOTRUN -> [SKIP][1] ([i915#4613]) +3 other tests skip
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@gem_lmem_swapping@parallel-random-engines.html

  * igt@gem_tiled_pread_basic@basic:
    - bat-adls-6:         NOTRUN -> [SKIP][2] ([i915#15656])
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@gem_tiled_pread_basic@basic.html

  * igt@i915_selftest@live@workarounds:
    - bat-arls-5:         [PASS][3] -> [DMESG-FAIL][4] ([i915#12061]) +1 other test dmesg-fail
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/bat-arls-5/igt@i915_selftest@live@workarounds.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-arls-5/igt@i915_selftest@live@workarounds.html
    - bat-dg2-9:          [PASS][5] -> [DMESG-FAIL][6] ([i915#12061]) +1 other test dmesg-fail
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/bat-dg2-9/igt@i915_selftest@live@workarounds.html
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-dg2-9/igt@i915_selftest@live@workarounds.html

  * igt@intel_hwmon@hwmon-read:
    - bat-adls-6:         NOTRUN -> [SKIP][7] ([i915#7707]) +1 other test skip
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@intel_hwmon@hwmon-read.html

  * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy:
    - bat-adls-6:         NOTRUN -> [SKIP][8] ([i915#4103]) +1 other test skip
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy.html

  * igt@kms_dsc@dsc-basic:
    - bat-adls-6:         NOTRUN -> [SKIP][9] ([i915#3555] / [i915#3840])
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_dsc@dsc-basic.html

  * igt@kms_force_connector_basic@force-load-detect:
    - bat-adls-6:         NOTRUN -> [SKIP][10]
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_force_connector_basic@force-load-detect.html

  * igt@kms_pm_backlight@basic-brightness:
    - bat-adls-6:         NOTRUN -> [SKIP][11] ([i915#5354])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_pm_backlight@basic-brightness.html

  * igt@kms_psr@psr-primary-mmap-gtt:
    - bat-adls-6:         NOTRUN -> [SKIP][12] ([i915#1072] / [i915#9732]) +3 other tests skip
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_psr@psr-primary-mmap-gtt.html

  * igt@kms_setmode@basic-clone-single-crtc:
    - bat-adls-6:         NOTRUN -> [SKIP][13] ([i915#3555])
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@kms_setmode@basic-clone-single-crtc.html

  * igt@prime_vgem@basic-fence-read:
    - bat-adls-6:         NOTRUN -> [SKIP][14] ([i915#3291]) +2 other tests skip
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/bat-adls-6/igt@prime_vgem@basic-fence-read.html

  
#### Possible fixes ####

  * igt@kms_hdmi_inject@inject-audio:
    - fi-tgl-1115g4:      [FAIL][15] ([i915#14867]) -> [PASS][16]
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/fi-tgl-1115g4/igt@kms_hdmi_inject@inject-audio.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/fi-tgl-1115g4/igt@kms_hdmi_inject@inject-audio.html

  
  [i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072
  [i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061
  [i915#14867]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14867
  [i915#15656]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15656
  [i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291
  [i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555
  [i915#3840]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3840
  [i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354
  [i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707
  [i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_8829 -> IGTPW_14855

  CI-20190529: 20190529
  CI_DRM_18214: ec0484d20b9f962d04a62ff1feb03676c3ce7611 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_14855: 14855
  IGT_8829: 8829

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/index.html

[-- Attachment #2: Type: text/html, Size: 6362 bytes --]

✗ Xe.CI.FULL: failure for tests/xe: Add purgeable memory madvise tests for system allocator (rev6)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 5037 bytes --]

== Series Details ==

Series: tests/xe: Add purgeable memory madvise tests for system allocator (rev6)
URL   : https://patchwork.freedesktop.org/series/160333/
State : failure

== Summary ==

CI Bug Log - changes from XEIGT_8829_FULL -> XEIGTPW_14855_FULL
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with XEIGTPW_14855_FULL absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in XEIGTPW_14855_FULL, please notify your bug team (I915-ci-infra@lists.freedesktop.org) to allow them
  to document this new failure mode, which will reduce false positives in CI.

  

Participating hosts (2 -> 2)
------------------------------

  No changes in participating hosts

Possible new issues
-------------------

  Here are the unknown changes that may have been introduced in XEIGTPW_14855_FULL:

### IGT changes ###

#### Possible regressions ####

  * igt@xe_exec_system_allocator@eu-fault-64k-once-device-host:
    - shard-lnl:          [PASS][1] -> [FAIL][2]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-5/igt@xe_exec_system_allocator@eu-fault-64k-once-device-host.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-5/igt@xe_exec_system_allocator@eu-fault-64k-once-device-host.html

  * igt@xe_madvise@dontneed-before-exec (NEW):
    - shard-lnl:          NOTRUN -> [SKIP][3] +6 other tests skip
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-5/igt@xe_madvise@dontneed-before-exec.html

  
New tests
---------

  New tests have been introduced between XEIGT_8829_FULL and XEIGTPW_14855_FULL:

### New IGT tests (7) ###

  * igt@xe_madvise@dontneed-after-exec:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@dontneed-after-mmap:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@dontneed-before-exec:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@dontneed-before-mmap:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@per-vma-protection:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@per-vma-tracking:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  * igt@xe_madvise@purged-mmap-blocked:
    - Statuses : 1 skip(s)
    - Exec time: [0.0] s

  

Known issues
------------

  Here are the changes found in XEIGTPW_14855_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_pm_dc@dc5-dpms:
    - shard-lnl:          [PASS][4] -> [FAIL][5] ([Intel XE#7340] / [Intel XE#7504])
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-4/igt@kms_pm_dc@dc5-dpms.html
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-5/igt@kms_pm_dc@dc5-dpms.html

  * igt@kms_pm_dc@deep-pkgc:
    - shard-lnl:          [PASS][6] -> [FAIL][7] ([Intel XE#2029] / [Intel XE#7395])
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-3/igt@kms_pm_dc@deep-pkgc.html
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-8/igt@kms_pm_dc@deep-pkgc.html

  
#### Possible fixes ####

  * igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1:
    - shard-lnl:          [FAIL][8] ([Intel XE#301]) -> [PASS][9] +2 other tests pass
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-2/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-3/igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1.html

  * igt@kms_pm_dc@dc6-dpms:
    - shard-lnl:          [FAIL][10] ([Intel XE#7340]) -> [PASS][11]
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-3/igt@kms_pm_dc@dc6-dpms.html
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-3/igt@kms_pm_dc@dc6-dpms.html

  * igt@kms_setmode@basic@pipe-a-edp-1:
    - shard-lnl:          [FAIL][12] ([Intel XE#6361]) -> [PASS][13] +2 other tests pass
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8829/shard-lnl-3/igt@kms_setmode@basic@pipe-a-edp-1.html
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/shard-lnl-1/igt@kms_setmode@basic@pipe-a-edp-1.html

  
  [Intel XE#2029]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2029
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#6361]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6361
  [Intel XE#7340]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7340
  [Intel XE#7395]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7395
  [Intel XE#7504]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7504


Build changes
-------------

  * IGT: IGT_8829 -> IGTPW_14855

  IGTPW_14855: 14855
  IGT_8829: 8829
  xe-4785-ec0484d20b9f962d04a62ff1feb03676c3ce7611: ec0484d20b9f962d04a62ff1feb03676c3ce7611

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14855/index.html

[-- Attachment #2: Type: text/html, Size: 6069 bytes --]

✓ i915.CI.Full: success for tests/xe: Add purgeable memory madvise tests for system allocator (rev6)

[Patchwork]

[-- Attachment #1: Type: text/plain, Size: 144798 bytes --]

== Series Details ==

Series: tests/xe: Add purgeable memory madvise tests for system allocator (rev6)
URL   : https://patchwork.freedesktop.org/series/160333/
State : success

== Summary ==

CI Bug Log - changes from IGT_8829_full -> IGTPW_14855_full
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/index.html

Participating hosts (10 -> 10)
------------------------------

  No changes in participating hosts

New tests
---------

  New tests have been introduced between IGT_8829_full and IGTPW_14855_full:

### New IGT tests (4) ###

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs-cc@pipe-a-dp-3:
    - Statuses : 1 skip(s)
    - Exec time: [0.00] s

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs-cc@pipe-b-dp-3:
    - Statuses : 1 skip(s)
    - Exec time: [0.00] s

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs-cc@pipe-c-dp-3:
    - Statuses : 1 skip(s)
    - Exec time: [0.00] s

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-gen12-rc-ccs-cc@pipe-d-dp-3:
    - Statuses : 1 skip(s)
    - Exec time: [0.00] s

  

Known issues
------------

  Here are the changes found in IGTPW_14855_full that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@device_reset@unbind-cold-reset-rebind:
    - shard-rkl:          NOTRUN -> [SKIP][1] ([i915#11078])
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@device_reset@unbind-cold-reset-rebind.html

  * igt@drm_buddy@drm_buddy:
    - shard-tglu:         NOTRUN -> [SKIP][2] ([i915#15678])
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@drm_buddy@drm_buddy.html

  * igt@gem_basic@multigpu-create-close:
    - shard-tglu-1:       NOTRUN -> [SKIP][3] ([i915#7697])
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@gem_basic@multigpu-create-close.html

  * igt@gem_busy@semaphore:
    - shard-dg2:          NOTRUN -> [SKIP][4] ([i915#3936])
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@gem_busy@semaphore.html
    - shard-dg1:          NOTRUN -> [SKIP][5] ([i915#3936])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@gem_busy@semaphore.html
    - shard-mtlp:         NOTRUN -> [SKIP][6] ([i915#3936])
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@gem_busy@semaphore.html

  * igt@gem_close_race@multigpu-basic-threads:
    - shard-rkl:          NOTRUN -> [SKIP][7] ([i915#7697])
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@gem_close_race@multigpu-basic-threads.html

  * igt@gem_create@create-ext-cpu-access-big:
    - shard-tglu:         NOTRUN -> [SKIP][8] ([i915#6335])
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@gem_create@create-ext-cpu-access-big.html

  * igt@gem_ctx_isolation@preservation-s3:
    - shard-rkl:          [PASS][9] -> [INCOMPLETE][10] ([i915#13356]) +1 other test incomplete
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@gem_ctx_isolation@preservation-s3.html
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_ctx_isolation@preservation-s3.html

  * igt@gem_ctx_isolation@preservation-s3@rcs0:
    - shard-glk:          [PASS][11] -> [INCOMPLETE][12] ([i915#13356])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-glk6/igt@gem_ctx_isolation@preservation-s3@rcs0.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk8/igt@gem_ctx_isolation@preservation-s3@rcs0.html

  * igt@gem_ctx_persistence@hang:
    - shard-mtlp:         NOTRUN -> [SKIP][13] ([i915#8555])
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-1/igt@gem_ctx_persistence@hang.html

  * igt@gem_ctx_persistence@legacy-engines-persistence:
    - shard-snb:          NOTRUN -> [SKIP][14] ([i915#1099]) +1 other test skip
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb6/igt@gem_ctx_persistence@legacy-engines-persistence.html

  * igt@gem_ctx_sseu@invalid-args:
    - shard-dg2:          NOTRUN -> [SKIP][15] ([i915#280]) +1 other test skip
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@gem_ctx_sseu@invalid-args.html
    - shard-dg1:          NOTRUN -> [SKIP][16] ([i915#280])
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@gem_ctx_sseu@invalid-args.html
    - shard-tglu:         NOTRUN -> [SKIP][17] ([i915#280])
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@gem_ctx_sseu@invalid-args.html
    - shard-mtlp:         NOTRUN -> [SKIP][18] ([i915#280])
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@gem_ctx_sseu@invalid-args.html

  * igt@gem_ctx_sseu@mmap-args:
    - shard-rkl:          NOTRUN -> [SKIP][19] ([i915#280]) +1 other test skip
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@gem_ctx_sseu@mmap-args.html

  * igt@gem_eio@reset-stress@blt:
    - shard-mtlp:         NOTRUN -> [SKIP][20] ([i915#15314])
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@gem_eio@reset-stress@blt.html

  * igt@gem_eio@reset-stress@bsd:
    - shard-snb:          NOTRUN -> [FAIL][21] ([i915#8898]) +1 other test fail
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb7/igt@gem_eio@reset-stress@bsd.html

  * igt@gem_exec_balancer@bonded-pair:
    - shard-dg1:          NOTRUN -> [SKIP][22] ([i915#4771])
   [22]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@gem_exec_balancer@bonded-pair.html

  * igt@gem_exec_balancer@parallel-contexts:
    - shard-tglu-1:       NOTRUN -> [SKIP][23] ([i915#4525])
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@gem_exec_balancer@parallel-contexts.html

  * igt@gem_exec_balancer@parallel-keep-in-fence:
    - shard-tglu:         NOTRUN -> [SKIP][24] ([i915#4525])
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@gem_exec_balancer@parallel-keep-in-fence.html

  * igt@gem_exec_balancer@parallel-out-fence:
    - shard-rkl:          NOTRUN -> [SKIP][25] ([i915#4525])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-1/igt@gem_exec_balancer@parallel-out-fence.html

  * igt@gem_exec_big@single:
    - shard-tglu:         [PASS][26] -> [DMESG-FAIL][27] ([i915#15478])
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-10/igt@gem_exec_big@single.html
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@gem_exec_big@single.html

  * igt@gem_exec_fence@submit:
    - shard-mtlp:         NOTRUN -> [SKIP][28] ([i915#4812]) +1 other test skip
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@gem_exec_fence@submit.html

  * igt@gem_exec_fence@submit3:
    - shard-dg2:          NOTRUN -> [SKIP][29] ([i915#4812]) +1 other test skip
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@gem_exec_fence@submit3.html

  * igt@gem_exec_flush@basic-wb-ro-before-default:
    - shard-dg2:          NOTRUN -> [SKIP][30] ([i915#3539] / [i915#4852])
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@gem_exec_flush@basic-wb-ro-before-default.html

  * igt@gem_exec_reloc@basic-concurrent0:
    - shard-rkl:          NOTRUN -> [SKIP][31] ([i915#14544] / [i915#3281]) +1 other test skip
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_exec_reloc@basic-concurrent0.html

  * igt@gem_exec_reloc@basic-cpu-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][32] ([i915#3281]) +7 other tests skip
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@gem_exec_reloc@basic-cpu-gtt.html
    - shard-dg1:          NOTRUN -> [SKIP][33] ([i915#3281]) +6 other tests skip
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@gem_exec_reloc@basic-cpu-gtt.html
    - shard-mtlp:         NOTRUN -> [SKIP][34] ([i915#3281]) +6 other tests skip
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@gem_exec_reloc@basic-cpu-gtt.html

  * igt@gem_exec_reloc@basic-write-read-active:
    - shard-rkl:          NOTRUN -> [SKIP][35] ([i915#3281]) +11 other tests skip
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@gem_exec_reloc@basic-write-read-active.html

  * igt@gem_exec_schedule@preempt-queue-contexts:
    - shard-dg1:          NOTRUN -> [SKIP][36] ([i915#4812]) +2 other tests skip
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@gem_exec_schedule@preempt-queue-contexts.html

  * igt@gem_exec_schedule@semaphore-power:
    - shard-rkl:          NOTRUN -> [SKIP][37] ([i915#7276])
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@gem_exec_schedule@semaphore-power.html

  * igt@gem_exec_suspend@basic-s3:
    - shard-rkl:          [PASS][38] -> [ABORT][39] ([i915#15131]) +1 other test abort
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@gem_exec_suspend@basic-s3.html
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-1/igt@gem_exec_suspend@basic-s3.html

  * igt@gem_fence_thrash@bo-write-verify-threaded-none:
    - shard-dg1:          NOTRUN -> [SKIP][40] ([i915#4860]) +1 other test skip
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-18/igt@gem_fence_thrash@bo-write-verify-threaded-none.html
    - shard-mtlp:         NOTRUN -> [SKIP][41] ([i915#4860]) +1 other test skip
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@gem_fence_thrash@bo-write-verify-threaded-none.html
    - shard-dg2:          NOTRUN -> [SKIP][42] ([i915#4860])
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@gem_fence_thrash@bo-write-verify-threaded-none.html

  * igt@gem_lmem_evict@dontneed-evict-race:
    - shard-rkl:          NOTRUN -> [SKIP][43] ([i915#14544] / [i915#4613] / [i915#7582])
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_lmem_evict@dontneed-evict-race.html

  * igt@gem_lmem_swapping@massive-random:
    - shard-tglu-1:       NOTRUN -> [SKIP][44] ([i915#4613]) +2 other tests skip
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@gem_lmem_swapping@massive-random.html

  * igt@gem_lmem_swapping@parallel-multi:
    - shard-rkl:          NOTRUN -> [SKIP][45] ([i915#4613]) +1 other test skip
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_lmem_swapping@parallel-multi.html

  * igt@gem_lmem_swapping@parallel-random-verify:
    - shard-tglu:         NOTRUN -> [SKIP][46] ([i915#4613]) +2 other tests skip
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@gem_lmem_swapping@parallel-random-verify.html

  * igt@gem_lmem_swapping@verify-random:
    - shard-glk:          NOTRUN -> [SKIP][47] ([i915#4613]) +4 other tests skip
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk3/igt@gem_lmem_swapping@verify-random.html

  * igt@gem_mmap_gtt@cpuset-medium-copy-odd:
    - shard-mtlp:         NOTRUN -> [SKIP][48] ([i915#4077]) +6 other tests skip
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@gem_mmap_gtt@cpuset-medium-copy-odd.html

  * igt@gem_mmap_gtt@flink-race:
    - shard-dg1:          NOTRUN -> [SKIP][49] ([i915#4077]) +6 other tests skip
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@gem_mmap_gtt@flink-race.html

  * igt@gem_mmap_wc@coherency:
    - shard-mtlp:         NOTRUN -> [SKIP][50] ([i915#4083]) +1 other test skip
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@gem_mmap_wc@coherency.html

  * igt@gem_mmap_wc@read-write-distinct:
    - shard-dg2:          NOTRUN -> [SKIP][51] ([i915#4083]) +1 other test skip
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@gem_mmap_wc@read-write-distinct.html

  * igt@gem_partial_pwrite_pread@reads:
    - shard-dg2:          NOTRUN -> [SKIP][52] ([i915#3282]) +2 other tests skip
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@gem_partial_pwrite_pread@reads.html

  * igt@gem_partial_pwrite_pread@writes-after-reads:
    - shard-mtlp:         NOTRUN -> [SKIP][53] ([i915#3282])
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@gem_partial_pwrite_pread@writes-after-reads.html

  * igt@gem_pread@uncached:
    - shard-dg1:          NOTRUN -> [SKIP][54] ([i915#3282])
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-18/igt@gem_pread@uncached.html

  * igt@gem_pxp@create-regular-context-2:
    - shard-dg2:          NOTRUN -> [SKIP][55] ([i915#4270]) +2 other tests skip
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@gem_pxp@create-regular-context-2.html

  * igt@gem_pxp@verify-pxp-stale-ctx-execution:
    - shard-rkl:          [PASS][56] -> [SKIP][57] ([i915#4270])
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@gem_pxp@verify-pxp-stale-ctx-execution.html
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_pxp@verify-pxp-stale-ctx-execution.html

  * igt@gem_readwrite@beyond-eob:
    - shard-rkl:          NOTRUN -> [SKIP][58] ([i915#3282]) +5 other tests skip
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@gem_readwrite@beyond-eob.html

  * igt@gem_render_copy@y-tiled-mc-ccs-to-vebox-y-tiled:
    - shard-mtlp:         NOTRUN -> [SKIP][59] ([i915#8428]) +2 other tests skip
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@gem_render_copy@y-tiled-mc-ccs-to-vebox-y-tiled.html

  * igt@gem_render_copy@yf-tiled-mc-ccs-to-vebox-yf-tiled:
    - shard-dg2:          NOTRUN -> [SKIP][60] ([i915#5190] / [i915#8428]) +4 other tests skip
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@gem_render_copy@yf-tiled-mc-ccs-to-vebox-yf-tiled.html

  * igt@gem_set_tiling_vs_blt@tiled-to-untiled:
    - shard-dg2:          NOTRUN -> [SKIP][61] ([i915#4079])
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@gem_set_tiling_vs_blt@tiled-to-untiled.html

  * igt@gem_set_tiling_vs_blt@untiled-to-tiled:
    - shard-rkl:          NOTRUN -> [SKIP][62] ([i915#8411]) +1 other test skip
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_set_tiling_vs_blt@untiled-to-tiled.html

  * igt@gem_set_tiling_vs_gtt:
    - shard-mtlp:         NOTRUN -> [SKIP][63] ([i915#4079])
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-1/igt@gem_set_tiling_vs_gtt.html

  * igt@gem_softpin@evict-snoop:
    - shard-mtlp:         NOTRUN -> [SKIP][64] ([i915#4885])
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-1/igt@gem_softpin@evict-snoop.html

  * igt@gem_softpin@noreloc-s3:
    - shard-glk11:        NOTRUN -> [INCOMPLETE][65] ([i915#13809])
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk11/igt@gem_softpin@noreloc-s3.html

  * igt@gem_tiled_partial_pwrite_pread@reads:
    - shard-dg2:          NOTRUN -> [SKIP][66] ([i915#4077]) +6 other tests skip
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@gem_tiled_partial_pwrite_pread@reads.html

  * igt@gem_tiled_pread_pwrite:
    - shard-dg1:          NOTRUN -> [SKIP][67] ([i915#4079])
   [67]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@gem_tiled_pread_pwrite.html

  * igt@gem_userptr_blits@access-control:
    - shard-mtlp:         NOTRUN -> [SKIP][68] ([i915#3297]) +3 other tests skip
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@gem_userptr_blits@access-control.html

  * igt@gem_userptr_blits@coherency-sync:
    - shard-rkl:          NOTRUN -> [SKIP][69] ([i915#3297]) +2 other tests skip
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@gem_userptr_blits@coherency-sync.html

  * igt@gem_userptr_blits@dmabuf-sync:
    - shard-glk:          NOTRUN -> [SKIP][70] ([i915#3323])
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk2/igt@gem_userptr_blits@dmabuf-sync.html

  * igt@gem_userptr_blits@invalid-mmap-offset-unsync:
    - shard-dg2:          NOTRUN -> [SKIP][71] ([i915#3297]) +2 other tests skip
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@gem_userptr_blits@invalid-mmap-offset-unsync.html
    - shard-tglu:         NOTRUN -> [SKIP][72] ([i915#3297]) +2 other tests skip
   [72]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@gem_userptr_blits@invalid-mmap-offset-unsync.html

  * igt@gem_userptr_blits@map-fixed-invalidate-busy:
    - shard-dg2:          NOTRUN -> [SKIP][73] ([i915#3297] / [i915#4880])
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@gem_userptr_blits@map-fixed-invalidate-busy.html
    - shard-dg1:          NOTRUN -> [SKIP][74] ([i915#3297] / [i915#4880])
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@gem_userptr_blits@map-fixed-invalidate-busy.html

  * igt@gem_userptr_blits@readonly-unsync:
    - shard-tglu-1:       NOTRUN -> [SKIP][75] ([i915#3297])
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@gem_userptr_blits@readonly-unsync.html

  * igt@gem_userptr_blits@relocations:
    - shard-dg2:          NOTRUN -> [SKIP][76] ([i915#3281] / [i915#3297])
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-1/igt@gem_userptr_blits@relocations.html
    - shard-rkl:          NOTRUN -> [SKIP][77] ([i915#3281] / [i915#3297])
   [77]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@gem_userptr_blits@relocations.html

  * igt@gem_userptr_blits@unsync-overlap:
    - shard-dg1:          NOTRUN -> [SKIP][78] ([i915#3297]) +3 other tests skip
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@gem_userptr_blits@unsync-overlap.html

  * igt@gem_workarounds@suspend-resume-context:
    - shard-glk:          NOTRUN -> [INCOMPLETE][79] ([i915#13356])
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk6/igt@gem_workarounds@suspend-resume-context.html

  * igt@gem_workarounds@suspend-resume-fd:
    - shard-rkl:          [PASS][80] -> [ABORT][81] ([i915#15152])
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@gem_workarounds@suspend-resume-fd.html
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-1/igt@gem_workarounds@suspend-resume-fd.html

  * igt@gen9_exec_parse@bb-chained:
    - shard-dg1:          NOTRUN -> [SKIP][82] ([i915#2527])
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@gen9_exec_parse@bb-chained.html

  * igt@gen9_exec_parse@bb-start-cmd:
    - shard-tglu-1:       NOTRUN -> [SKIP][83] ([i915#2527] / [i915#2856]) +1 other test skip
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@gen9_exec_parse@bb-start-cmd.html

  * igt@gen9_exec_parse@cmd-crossing-page:
    - shard-dg2:          NOTRUN -> [SKIP][84] ([i915#2856]) +1 other test skip
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@gen9_exec_parse@cmd-crossing-page.html
    - shard-rkl:          NOTRUN -> [SKIP][85] ([i915#2527])
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@gen9_exec_parse@cmd-crossing-page.html

  * igt@gen9_exec_parse@secure-batches:
    - shard-mtlp:         NOTRUN -> [SKIP][86] ([i915#2856]) +1 other test skip
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@gen9_exec_parse@secure-batches.html

  * igt@gen9_exec_parse@valid-registers:
    - shard-tglu:         NOTRUN -> [SKIP][87] ([i915#2527] / [i915#2856]) +1 other test skip
   [87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@gen9_exec_parse@valid-registers.html

  * igt@i915_drm_fdinfo@busy-idle-check-all@vcs0:
    - shard-dg2:          NOTRUN -> [SKIP][88] ([i915#11527]) +7 other tests skip
   [88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@i915_drm_fdinfo@busy-idle-check-all@vcs0.html

  * igt@i915_drm_fdinfo@isolation@rcs0:
    - shard-dg2:          NOTRUN -> [SKIP][89] ([i915#14073]) +7 other tests skip
   [89]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@i915_drm_fdinfo@isolation@rcs0.html
    - shard-dg1:          NOTRUN -> [SKIP][90] ([i915#14073]) +5 other tests skip
   [90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@i915_drm_fdinfo@isolation@rcs0.html
    - shard-mtlp:         NOTRUN -> [SKIP][91] ([i915#14073]) +6 other tests skip
   [91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-4/igt@i915_drm_fdinfo@isolation@rcs0.html

  * igt@i915_drm_fdinfo@virtual-busy:
    - shard-dg1:          NOTRUN -> [SKIP][92] ([i915#14118]) +1 other test skip
   [92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@i915_drm_fdinfo@virtual-busy.html

  * igt@i915_drm_fdinfo@virtual-busy-all:
    - shard-mtlp:         NOTRUN -> [SKIP][93] ([i915#14118])
   [93]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-4/igt@i915_drm_fdinfo@virtual-busy-all.html
    - shard-dg2:          NOTRUN -> [SKIP][94] ([i915#14118])
   [94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@i915_drm_fdinfo@virtual-busy-all.html

  * igt@i915_module_load@fault-injection@i915_driver_mmio_probe:
    - shard-dg1:          NOTRUN -> [INCOMPLETE][95] ([i915#15481])
   [95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-16/igt@i915_module_load@fault-injection@i915_driver_mmio_probe.html

  * igt@i915_module_load@reload-no-display:
    - shard-dg1:          [PASS][96] -> [DMESG-WARN][97] ([i915#13029] / [i915#14545])
   [96]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@i915_module_load@reload-no-display.html
   [97]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@i915_module_load@reload-no-display.html

  * igt@i915_pm_rpm@gem-pread:
    - shard-dg1:          [PASS][98] -> [SKIP][99] ([i915#4423])
   [98]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@i915_pm_rpm@gem-pread.html
   [99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@i915_pm_rpm@gem-pread.html

  * igt@i915_pm_rpm@system-suspend:
    - shard-tglu:         NOTRUN -> [ABORT][100] ([i915#15652])
   [100]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-9/igt@i915_pm_rpm@system-suspend.html

  * igt@i915_pm_rps@thresholds-park:
    - shard-dg2:          NOTRUN -> [SKIP][101] ([i915#11681])
   [101]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-3/igt@i915_pm_rps@thresholds-park.html
    - shard-dg1:          NOTRUN -> [SKIP][102] ([i915#11681])
   [102]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@i915_pm_rps@thresholds-park.html
    - shard-mtlp:         NOTRUN -> [SKIP][103] ([i915#11681])
   [103]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@i915_pm_rps@thresholds-park.html

  * igt@i915_pm_rps@waitboost:
    - shard-mtlp:         [PASS][104] -> [FAIL][105] ([i915#15365])
   [104]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-1/igt@i915_pm_rps@waitboost.html
   [105]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@i915_pm_rps@waitboost.html

  * igt@i915_pm_sseu@full-enable:
    - shard-tglu:         NOTRUN -> [SKIP][106] ([i915#4387])
   [106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@i915_pm_sseu@full-enable.html

  * igt@i915_query@hwconfig_table:
    - shard-tglu-1:       NOTRUN -> [SKIP][107] ([i915#6245])
   [107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@i915_query@hwconfig_table.html
    - shard-rkl:          NOTRUN -> [SKIP][108] ([i915#6245])
   [108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@i915_query@hwconfig_table.html

  * igt@i915_selftest@live:
    - shard-dg1:          [PASS][109] -> [DMESG-FAIL][110] ([i915#15560])
   [109]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-14/igt@i915_selftest@live.html
   [110]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@i915_selftest@live.html

  * igt@i915_selftest@live@gem_contexts:
    - shard-dg1:          [PASS][111] -> [DMESG-FAIL][112] ([i915#15433])
   [111]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-14/igt@i915_selftest@live@gem_contexts.html
   [112]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@i915_selftest@live@gem_contexts.html

  * igt@i915_suspend@basic-s3-without-i915:
    - shard-glk:          NOTRUN -> [INCOMPLETE][113] ([i915#4817])
   [113]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk2/igt@i915_suspend@basic-s3-without-i915.html

  * igt@i915_suspend@debugfs-reader:
    - shard-glk:          [PASS][114] -> [INCOMPLETE][115] ([i915#4817])
   [114]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-glk5/igt@i915_suspend@debugfs-reader.html
   [115]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk4/igt@i915_suspend@debugfs-reader.html

  * igt@intel_hwmon@hwmon-read:
    - shard-mtlp:         NOTRUN -> [SKIP][116] ([i915#7707])
   [116]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@intel_hwmon@hwmon-read.html

  * igt@kms_3d@basic:
    - shard-mtlp:         [PASS][117] -> [SKIP][118] ([i915#15726])
   [117]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-3/igt@kms_3d@basic.html
   [118]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-1/igt@kms_3d@basic.html

  * igt@kms_addfb_basic@bad-pitch-65536:
    - shard-dg1:          [PASS][119] -> [DMESG-WARN][120] ([i915#4423]) +4 other tests dmesg-warn
   [119]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@kms_addfb_basic@bad-pitch-65536.html
   [120]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_addfb_basic@bad-pitch-65536.html

  * igt@kms_addfb_basic@basic-y-tiled-legacy:
    - shard-dg2:          NOTRUN -> [SKIP][121] ([i915#4215] / [i915#5190])
   [121]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-3/igt@kms_addfb_basic@basic-y-tiled-legacy.html

  * igt@kms_addfb_basic@clobberred-modifier:
    - shard-mtlp:         NOTRUN -> [SKIP][122] ([i915#4212])
   [122]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-3/igt@kms_addfb_basic@clobberred-modifier.html

  * igt@kms_addfb_basic@invalid-smem-bo-on-discrete:
    - shard-rkl:          NOTRUN -> [SKIP][123] ([i915#12454] / [i915#12712])
   [123]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_addfb_basic@invalid-smem-bo-on-discrete.html
    - shard-tglu:         NOTRUN -> [SKIP][124] ([i915#12454] / [i915#12712])
   [124]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_addfb_basic@invalid-smem-bo-on-discrete.html
    - shard-mtlp:         NOTRUN -> [SKIP][125] ([i915#12454] / [i915#12712])
   [125]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_addfb_basic@invalid-smem-bo-on-discrete.html

  * igt@kms_atomic@plane-primary-overlay-mutable-zpos:
    - shard-rkl:          NOTRUN -> [SKIP][126] ([i915#9531])
   [126]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_atomic@plane-primary-overlay-mutable-zpos.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing:
    - shard-dg2:          [PASS][127] -> [FAIL][128] ([i915#5956])
   [127]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_atomic_transition@plane-all-modeset-transition-fencing.html
   [128]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_atomic_transition@plane-all-modeset-transition-fencing.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels:
    - shard-glk:          NOTRUN -> [SKIP][129] ([i915#1769])
   [129]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk3/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
    - shard-dg2:          NOTRUN -> [SKIP][130] ([i915#1769] / [i915#3555])
   [130]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
    - shard-rkl:          NOTRUN -> [SKIP][131] ([i915#1769] / [i915#3555])
   [131]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
    - shard-dg1:          NOTRUN -> [SKIP][132] ([i915#1769] / [i915#3555])
   [132]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
    - shard-snb:          NOTRUN -> [SKIP][133] ([i915#1769])
   [133]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb5/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html
    - shard-tglu:         NOTRUN -> [SKIP][134] ([i915#1769] / [i915#3555])
   [134]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing@pipe-a-hdmi-a-3:
    - shard-dg2:          NOTRUN -> [FAIL][135] ([i915#5956])
   [135]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_atomic_transition@plane-all-modeset-transition-fencing@pipe-a-hdmi-a-3.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels:
    - shard-glk10:        NOTRUN -> [SKIP][136] ([i915#1769])
   [136]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk10/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels.html

  * igt@kms_big_fb@4-tiled-16bpp-rotate-0:
    - shard-tglu-1:       NOTRUN -> [SKIP][137] ([i915#5286]) +4 other tests skip
   [137]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_big_fb@4-tiled-16bpp-rotate-0.html

  * igt@kms_big_fb@4-tiled-addfb:
    - shard-rkl:          NOTRUN -> [SKIP][138] ([i915#5286]) +6 other tests skip
   [138]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_big_fb@4-tiled-addfb.html
    - shard-tglu:         NOTRUN -> [SKIP][139] ([i915#5286]) +1 other test skip
   [139]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_big_fb@4-tiled-addfb.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip:
    - shard-dg1:          NOTRUN -> [SKIP][140] ([i915#4538] / [i915#5286]) +1 other test skip
   [140]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-180-hflip-async-flip.html

  * igt@kms_big_fb@linear-max-hw-stride-64bpp-rotate-180-hflip:
    - shard-tglu:         NOTRUN -> [SKIP][141] ([i915#3828])
   [141]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_big_fb@linear-max-hw-stride-64bpp-rotate-180-hflip.html

  * igt@kms_big_fb@x-tiled-16bpp-rotate-90:
    - shard-dg2:          NOTRUN -> [SKIP][142] +6 other tests skip
   [142]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-1/igt@kms_big_fb@x-tiled-16bpp-rotate-90.html

  * igt@kms_big_fb@x-tiled-64bpp-rotate-270:
    - shard-rkl:          NOTRUN -> [SKIP][143] ([i915#14544] / [i915#3638])
   [143]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_big_fb@x-tiled-64bpp-rotate-270.html

  * igt@kms_big_fb@x-tiled-8bpp-rotate-270:
    - shard-mtlp:         NOTRUN -> [SKIP][144] +10 other tests skip
   [144]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_big_fb@x-tiled-8bpp-rotate-270.html

  * igt@kms_big_fb@y-tiled-8bpp-rotate-90:
    - shard-dg2:          NOTRUN -> [SKIP][145] ([i915#4538] / [i915#5190]) +6 other tests skip
   [145]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_big_fb@y-tiled-8bpp-rotate-90.html
    - shard-rkl:          NOTRUN -> [SKIP][146] ([i915#3638]) +4 other tests skip
   [146]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_big_fb@y-tiled-8bpp-rotate-90.html
    - shard-dg1:          NOTRUN -> [SKIP][147] ([i915#3638]) +3 other tests skip
   [147]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@kms_big_fb@y-tiled-8bpp-rotate-90.html

  * igt@kms_big_fb@y-tiled-addfb-size-offset-overflow:
    - shard-mtlp:         NOTRUN -> [SKIP][148] ([i915#6187])
   [148]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@kms_big_fb@y-tiled-addfb-size-offset-overflow.html

  * igt@kms_big_fb@yf-tiled-64bpp-rotate-90:
    - shard-dg1:          NOTRUN -> [SKIP][149] ([i915#4538]) +1 other test skip
   [149]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@kms_big_fb@yf-tiled-64bpp-rotate-90.html

  * igt@kms_ccs@bad-aux-stride-y-tiled-ccs@pipe-c-hdmi-a-1:
    - shard-tglu:         NOTRUN -> [SKIP][150] ([i915#6095]) +59 other tests skip
   [150]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_ccs@bad-aux-stride-y-tiled-ccs@pipe-c-hdmi-a-1.html

  * igt@kms_ccs@bad-pixel-format-4-tiled-mtl-mc-ccs:
    - shard-dg2:          NOTRUN -> [SKIP][151] ([i915#10307] / [i915#6095]) +98 other tests skip
   [151]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_ccs@bad-pixel-format-4-tiled-mtl-mc-ccs.html

  * igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc@pipe-a-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][152] ([i915#14544] / [i915#6095]) +11 other tests skip
   [152]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc@pipe-a-hdmi-a-2.html

  * igt@kms_ccs@bad-rotation-90-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][153] ([i915#6095]) +67 other tests skip
   [153]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_ccs@bad-rotation-90-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-2.html

  * igt@kms_ccs@crc-primary-basic-4-tiled-lnl-ccs:
    - shard-dg2:          NOTRUN -> [SKIP][154] ([i915#12313]) +1 other test skip
   [154]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_ccs@crc-primary-basic-4-tiled-lnl-ccs.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs:
    - shard-dg1:          NOTRUN -> [SKIP][155] ([i915#12313])
   [155]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs.html
    - shard-tglu:         NOTRUN -> [SKIP][156] ([i915#12313])
   [156]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-9/igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs.html
    - shard-mtlp:         NOTRUN -> [SKIP][157] ([i915#12313]) +2 other tests skip
   [157]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@kms_ccs@crc-primary-rotation-180-4-tiled-bmg-ccs.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-rc-ccs@pipe-a-hdmi-a-3:
    - shard-dg2:          NOTRUN -> [SKIP][158] ([i915#6095]) +53 other tests skip
   [158]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_ccs@crc-primary-rotation-180-4-tiled-dg2-rc-ccs@pipe-a-hdmi-a-3.html

  * igt@kms_ccs@crc-primary-rotation-180-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-1:
    - shard-dg1:          NOTRUN -> [SKIP][159] ([i915#6095]) +174 other tests skip
   [159]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@kms_ccs@crc-primary-rotation-180-4-tiled-mtl-rc-ccs@pipe-b-hdmi-a-1.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs@pipe-c-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][160] ([i915#14098] / [i915#14544] / [i915#6095]) +11 other tests skip
   [160]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_ccs@crc-primary-suspend-4-tiled-dg2-rc-ccs@pipe-c-hdmi-a-2.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs:
    - shard-rkl:          NOTRUN -> [SKIP][161] ([i915#12805])
   [161]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_ccs@crc-primary-suspend-4-tiled-lnl-ccs.html

  * igt@kms_ccs@crc-primary-suspend-y-tiled-ccs@pipe-a-hdmi-a-1:
    - shard-glk:          NOTRUN -> [INCOMPLETE][162] ([i915#14694] / [i915#15582]) +1 other test incomplete
   [162]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk1/igt@kms_ccs@crc-primary-suspend-y-tiled-ccs@pipe-a-hdmi-a-1.html

  * igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs@pipe-a-hdmi-a-1:
    - shard-tglu-1:       NOTRUN -> [SKIP][163] ([i915#6095]) +19 other tests skip
   [163]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs@pipe-a-hdmi-a-1.html

  * igt@kms_ccs@crc-sprite-planes-basic-y-tiled-ccs@pipe-c-hdmi-a-1:
    - shard-rkl:          NOTRUN -> [SKIP][164] ([i915#14098] / [i915#6095]) +40 other tests skip
   [164]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_ccs@crc-sprite-planes-basic-y-tiled-ccs@pipe-c-hdmi-a-1.html

  * igt@kms_ccs@missing-ccs-buffer-yf-tiled-ccs@pipe-a-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][165] ([i915#6095]) +19 other tests skip
   [165]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@kms_ccs@missing-ccs-buffer-yf-tiled-ccs@pipe-a-edp-1.html

  * igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs:
    - shard-rkl:          NOTRUN -> [SKIP][166] ([i915#12313]) +1 other test skip
   [166]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_ccs@random-ccs-data-4-tiled-lnl-ccs.html

  * igt@kms_ccs@random-ccs-data-y-tiled-ccs@pipe-d-hdmi-a-1:
    - shard-dg2:          NOTRUN -> [SKIP][167] ([i915#10307] / [i915#10434] / [i915#6095])
   [167]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_ccs@random-ccs-data-y-tiled-ccs@pipe-d-hdmi-a-1.html

  * igt@kms_cdclk@mode-transition-all-outputs:
    - shard-dg1:          NOTRUN -> [SKIP][168] ([i915#3742])
   [168]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_cdclk@mode-transition-all-outputs.html

  * igt@kms_cdclk@mode-transition@pipe-d-hdmi-a-3:
    - shard-dg2:          NOTRUN -> [SKIP][169] ([i915#13781]) +3 other tests skip
   [169]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_cdclk@mode-transition@pipe-d-hdmi-a-3.html

  * igt@kms_cdclk@plane-scaling@pipe-d-hdmi-a-1:
    - shard-dg2:          NOTRUN -> [SKIP][170] ([i915#13783]) +3 other tests skip
   [170]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_cdclk@plane-scaling@pipe-d-hdmi-a-1.html

  * igt@kms_chamelium_audio@hdmi-audio-edid:
    - shard-tglu-1:       NOTRUN -> [SKIP][171] ([i915#11151] / [i915#7828]) +4 other tests skip
   [171]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_chamelium_audio@hdmi-audio-edid.html

  * igt@kms_chamelium_frames@dp-frame-dump:
    - shard-dg1:          NOTRUN -> [SKIP][172] ([i915#11151] / [i915#7828]) +1 other test skip
   [172]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_chamelium_frames@dp-frame-dump.html

  * igt@kms_chamelium_frames@hdmi-crc-nonplanar-formats:
    - shard-dg2:          NOTRUN -> [SKIP][173] ([i915#11151] / [i915#7828]) +4 other tests skip
   [173]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_chamelium_frames@hdmi-crc-nonplanar-formats.html

  * igt@kms_chamelium_hpd@dp-hpd-enable-disable-mode:
    - shard-rkl:          NOTRUN -> [SKIP][174] ([i915#11151] / [i915#7828]) +7 other tests skip
   [174]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_chamelium_hpd@dp-hpd-enable-disable-mode.html

  * igt@kms_chamelium_hpd@dp-hpd-for-each-pipe:
    - shard-mtlp:         NOTRUN -> [SKIP][175] ([i915#11151] / [i915#7828]) +3 other tests skip
   [175]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@kms_chamelium_hpd@dp-hpd-for-each-pipe.html

  * igt@kms_chamelium_hpd@vga-hpd-for-each-pipe:
    - shard-tglu:         NOTRUN -> [SKIP][176] ([i915#11151] / [i915#7828]) +5 other tests skip
   [176]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_chamelium_hpd@vga-hpd-for-each-pipe.html

  * igt@kms_content_protection@atomic-dpms:
    - shard-tglu:         NOTRUN -> [SKIP][177] ([i915#15865]) +1 other test skip
   [177]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@kms_content_protection@atomic-dpms.html

  * igt@kms_content_protection@atomic-hdcp14@pipe-a-dp-3:
    - shard-dg2:          NOTRUN -> [FAIL][178] ([i915#7173]) +1 other test fail
   [178]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_content_protection@atomic-hdcp14@pipe-a-dp-3.html

  * igt@kms_content_protection@dp-mst-lic-type-1:
    - shard-dg2:          NOTRUN -> [SKIP][179] ([i915#15330] / [i915#3299]) +1 other test skip
   [179]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_content_protection@dp-mst-lic-type-1.html

  * igt@kms_content_protection@dp-mst-type-0:
    - shard-rkl:          NOTRUN -> [SKIP][180] ([i915#15330] / [i915#3116])
   [180]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_content_protection@dp-mst-type-0.html

  * igt@kms_content_protection@dp-mst-type-1:
    - shard-tglu:         NOTRUN -> [SKIP][181] ([i915#15330] / [i915#3116] / [i915#3299])
   [181]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_content_protection@dp-mst-type-1.html

  * igt@kms_content_protection@dp-mst-type-1-suspend-resume:
    - shard-tglu-1:       NOTRUN -> [SKIP][182] ([i915#15330])
   [182]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_content_protection@dp-mst-type-1-suspend-resume.html

  * igt@kms_content_protection@lic-type-0-hdcp14:
    - shard-rkl:          NOTRUN -> [SKIP][183] ([i915#15865]) +1 other test skip
   [183]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_content_protection@lic-type-0-hdcp14.html
    - shard-dg1:          NOTRUN -> [SKIP][184] ([i915#15865]) +1 other test skip
   [184]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_content_protection@lic-type-0-hdcp14.html

  * igt@kms_content_protection@suspend-resume:
    - shard-mtlp:         NOTRUN -> [SKIP][185] ([i915#15865]) +1 other test skip
   [185]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-3/igt@kms_content_protection@suspend-resume.html

  * igt@kms_content_protection@type1:
    - shard-dg2:          NOTRUN -> [SKIP][186] ([i915#15865])
   [186]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_content_protection@type1.html
    - shard-tglu-1:       NOTRUN -> [SKIP][187] ([i915#15865])
   [187]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_content_protection@type1.html

  * igt@kms_cursor_crc@cursor-offscreen-32x10:
    - shard-tglu-1:       NOTRUN -> [SKIP][188] ([i915#3555]) +1 other test skip
   [188]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_cursor_crc@cursor-offscreen-32x10.html
    - shard-dg1:          NOTRUN -> [SKIP][189] ([i915#3555]) +3 other tests skip
   [189]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-18/igt@kms_cursor_crc@cursor-offscreen-32x10.html

  * igt@kms_cursor_crc@cursor-onscreen-32x10:
    - shard-mtlp:         NOTRUN -> [SKIP][190] ([i915#3555] / [i915#8814])
   [190]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@kms_cursor_crc@cursor-onscreen-32x10.html

  * igt@kms_cursor_crc@cursor-onscreen-64x21:
    - shard-rkl:          [PASS][191] -> [FAIL][192] ([i915#13566]) +2 other tests fail
   [191]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@kms_cursor_crc@cursor-onscreen-64x21.html
   [192]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_cursor_crc@cursor-onscreen-64x21.html

  * igt@kms_cursor_crc@cursor-random-max-size:
    - shard-glk:          NOTRUN -> [SKIP][193] +350 other tests skip
   [193]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk8/igt@kms_cursor_crc@cursor-random-max-size.html

  * igt@kms_cursor_crc@cursor-rapid-movement-32x32:
    - shard-rkl:          NOTRUN -> [SKIP][194] ([i915#3555]) +3 other tests skip
   [194]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_cursor_crc@cursor-rapid-movement-32x32.html

  * igt@kms_cursor_crc@cursor-sliding-512x512:
    - shard-tglu:         NOTRUN -> [SKIP][195] ([i915#13049])
   [195]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_cursor_crc@cursor-sliding-512x512.html

  * igt@kms_cursor_crc@cursor-sliding-64x21@pipe-a-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [FAIL][196] ([i915#13566]) +4 other tests fail
   [196]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_cursor_crc@cursor-sliding-64x21@pipe-a-hdmi-a-2.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size:
    - shard-dg2:          NOTRUN -> [SKIP][197] ([i915#13046] / [i915#5354])
   [197]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_cursor_legacy@cursora-vs-flipb-atomic-transitions-varying-size.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-varying-size:
    - shard-rkl:          NOTRUN -> [SKIP][198] +13 other tests skip
   [198]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_cursor_legacy@cursora-vs-flipb-varying-size.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-toggle:
    - shard-rkl:          NOTRUN -> [SKIP][199] ([i915#14544]) +2 other tests skip
   [199]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_cursor_legacy@cursorb-vs-flipa-toggle.html

  * igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions-varying-size:
    - shard-mtlp:         NOTRUN -> [SKIP][200] ([i915#9809]) +1 other test skip
   [200]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_cursor_legacy@cursorb-vs-flipb-atomic-transitions-varying-size.html

  * igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions:
    - shard-glk:          NOTRUN -> [FAIL][201] ([i915#15804])
   [201]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk5/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions:
    - shard-dg1:          NOTRUN -> [SKIP][202] ([i915#4103] / [i915#4213])
   [202]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle:
    - shard-rkl:          NOTRUN -> [SKIP][203] ([i915#4103])
   [203]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html

  * igt@kms_dirtyfb@drrs-dirtyfb-ioctl:
    - shard-dg2:          NOTRUN -> [SKIP][204] ([i915#9833])
   [204]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html
    - shard-rkl:          NOTRUN -> [SKIP][205] ([i915#9723])
   [205]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html
    - shard-tglu-1:       NOTRUN -> [SKIP][206] ([i915#9723])
   [206]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html
    - shard-dg1:          NOTRUN -> [SKIP][207] ([i915#9723])
   [207]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html
    - shard-mtlp:         NOTRUN -> [SKIP][208] ([i915#9833])
   [208]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-4/igt@kms_dirtyfb@drrs-dirtyfb-ioctl.html

  * igt@kms_dither@fb-8bpc-vs-panel-6bpc@pipe-a-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][209] ([i915#14544] / [i915#3804])
   [209]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_dither@fb-8bpc-vs-panel-6bpc@pipe-a-hdmi-a-2.html

  * igt@kms_dp_link_training@uhbr-mst:
    - shard-tglu:         NOTRUN -> [SKIP][210] ([i915#13748])
   [210]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@kms_dp_link_training@uhbr-mst.html

  * igt@kms_dp_link_training@uhbr-sst:
    - shard-mtlp:         NOTRUN -> [SKIP][211] ([i915#13749])
   [211]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-3/igt@kms_dp_link_training@uhbr-sst.html

  * igt@kms_dp_linktrain_fallback@dsc-fallback:
    - shard-rkl:          NOTRUN -> [SKIP][212] ([i915#13707] / [i915#14544])
   [212]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_dp_linktrain_fallback@dsc-fallback.html

  * igt@kms_draw_crc@draw-method-mmap-gtt:
    - shard-dg1:          NOTRUN -> [SKIP][213] ([i915#8812])
   [213]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@kms_draw_crc@draw-method-mmap-gtt.html
    - shard-mtlp:         NOTRUN -> [SKIP][214] ([i915#3555] / [i915#8812])
   [214]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@kms_draw_crc@draw-method-mmap-gtt.html
    - shard-dg2:          NOTRUN -> [SKIP][215] ([i915#8812])
   [215]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_draw_crc@draw-method-mmap-gtt.html

  * igt@kms_dsc@dsc-basic:
    - shard-dg2:          NOTRUN -> [SKIP][216] ([i915#3555] / [i915#3840])
   [216]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_dsc@dsc-basic.html
    - shard-tglu-1:       NOTRUN -> [SKIP][217] ([i915#3555] / [i915#3840])
   [217]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_dsc@dsc-basic.html

  * igt@kms_dsc@dsc-with-output-formats:
    - shard-rkl:          NOTRUN -> [SKIP][218] ([i915#3555] / [i915#3840])
   [218]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_dsc@dsc-with-output-formats.html

  * igt@kms_fbcon_fbt@fbc-suspend:
    - shard-dg1:          [PASS][219] -> [FAIL][220] ([i915#4767])
   [219]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@kms_fbcon_fbt@fbc-suspend.html
   [220]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_fbcon_fbt@fbc-suspend.html

  * igt@kms_fbcon_fbt@psr:
    - shard-rkl:          NOTRUN -> [SKIP][221] ([i915#14544] / [i915#3955])
   [221]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_fbcon_fbt@psr.html
    - shard-tglu:         NOTRUN -> [SKIP][222] ([i915#3469])
   [222]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_fbcon_fbt@psr.html

  * igt@kms_feature_discovery@display-2x:
    - shard-dg2:          NOTRUN -> [SKIP][223] ([i915#1839])
   [223]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@kms_feature_discovery@display-2x.html

  * igt@kms_feature_discovery@display-3x:
    - shard-dg1:          NOTRUN -> [SKIP][224] ([i915#1839])
   [224]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@kms_feature_discovery@display-3x.html

  * igt@kms_feature_discovery@dp-mst:
    - shard-rkl:          NOTRUN -> [SKIP][225] ([i915#9337])
   [225]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_feature_discovery@dp-mst.html

  * igt@kms_flip@2x-blocking-absolute-wf_vblank-interruptible:
    - shard-dg1:          NOTRUN -> [SKIP][226] ([i915#9934])
   [226]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@kms_flip@2x-blocking-absolute-wf_vblank-interruptible.html

  * igt@kms_flip@2x-flip-vs-fences:
    - shard-tglu-1:       NOTRUN -> [SKIP][227] ([i915#3637] / [i915#9934]) +1 other test skip
   [227]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_flip@2x-flip-vs-fences.html

  * igt@kms_flip@2x-flip-vs-suspend@ab-vga1-hdmi-a1:
    - shard-snb:          [PASS][228] -> [TIMEOUT][229] ([i915#14033]) +1 other test timeout
   [228]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-snb1/igt@kms_flip@2x-flip-vs-suspend@ab-vga1-hdmi-a1.html
   [229]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb1/igt@kms_flip@2x-flip-vs-suspend@ab-vga1-hdmi-a1.html

  * igt@kms_flip@2x-modeset-vs-vblank-race-interruptible:
    - shard-tglu:         NOTRUN -> [SKIP][230] ([i915#3637] / [i915#9934]) +3 other tests skip
   [230]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_flip@2x-modeset-vs-vblank-race-interruptible.html

  * igt@kms_flip@2x-plain-flip-fb-recreate-interruptible:
    - shard-rkl:          NOTRUN -> [SKIP][231] ([i915#14544] / [i915#9934])
   [231]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip@2x-plain-flip-fb-recreate-interruptible.html

  * igt@kms_flip@2x-plain-flip-interruptible:
    - shard-rkl:          NOTRUN -> [SKIP][232] ([i915#9934]) +7 other tests skip
   [232]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_flip@2x-plain-flip-interruptible.html

  * igt@kms_flip@2x-single-buffer-flip-vs-dpms-off-vs-modeset:
    - shard-dg2:          NOTRUN -> [SKIP][233] ([i915#9934]) +4 other tests skip
   [233]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@kms_flip@2x-single-buffer-flip-vs-dpms-off-vs-modeset.html

  * igt@kms_flip@flip-vs-suspend:
    - shard-glk11:        NOTRUN -> [INCOMPLETE][234] ([i915#12745] / [i915#4839])
   [234]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk11/igt@kms_flip@flip-vs-suspend.html

  * igt@kms_flip@flip-vs-suspend-interruptible:
    - shard-glk:          NOTRUN -> [INCOMPLETE][235] ([i915#12314] / [i915#12745] / [i915#4839] / [i915#6113])
   [235]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk5/igt@kms_flip@flip-vs-suspend-interruptible.html
    - shard-rkl:          [PASS][236] -> [INCOMPLETE][237] ([i915#6113])
   [236]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@kms_flip@flip-vs-suspend-interruptible.html
   [237]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip@flip-vs-suspend-interruptible.html

  * igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a1:
    - shard-glk:          NOTRUN -> [INCOMPLETE][238] ([i915#12314] / [i915#12745])
   [238]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk5/igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a1.html

  * igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a2:
    - shard-rkl:          NOTRUN -> [INCOMPLETE][239] ([i915#6113])
   [239]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip@flip-vs-suspend-interruptible@a-hdmi-a2.html

  * igt@kms_flip@flip-vs-suspend@a-hdmi-a1:
    - shard-glk11:        NOTRUN -> [INCOMPLETE][240] ([i915#12745])
   [240]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk11/igt@kms_flip@flip-vs-suspend@a-hdmi-a1.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling:
    - shard-tglu-1:       NOTRUN -> [SKIP][241] ([i915#15643]) +1 other test skip
   [241]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-upscaling:
    - shard-rkl:          NOTRUN -> [SKIP][242] ([i915#15643]) +5 other tests skip
   [242]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-64bpp-4tile-upscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling:
    - shard-mtlp:         NOTRUN -> [SKIP][243] ([i915#15643]) +2 other tests skip
   [243]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftileccs-to-64bpp-yftile-upscaling:
    - shard-tglu:         NOTRUN -> [SKIP][244] ([i915#15643]) +2 other tests skip
   [244]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-4/igt@kms_flip_scaled_crc@flip-32bpp-yftileccs-to-64bpp-yftile-upscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling:
    - shard-dg2:          NOTRUN -> [SKIP][245] ([i915#15643] / [i915#5190])
   [245]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-1/igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-upscaling:
    - shard-dg1:          NOTRUN -> [SKIP][246] ([i915#15643]) +1 other test skip
   [246]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-16bpp-4tile-upscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling:
    - shard-dg2:          NOTRUN -> [SKIP][247] ([i915#15643])
   [247]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling:
    - shard-rkl:          NOTRUN -> [SKIP][248] ([i915#14544] / [i915#15643])
   [248]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-32bpp-yftile-upscaling.html

  * igt@kms_frontbuffer_tracking@fbc-1p-offscreen-pri-shrfb-draw-mmap-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][249] ([i915#15104]) +1 other test skip
   [249]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_frontbuffer_tracking@fbc-1p-offscreen-pri-shrfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-cpu:
    - shard-dg2:          [PASS][250] -> [FAIL][251] ([i915#15389] / [i915#6880]) +1 other test fail
   [250]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-8/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-cpu.html
   [251]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-render:
    - shard-dg2:          NOTRUN -> [FAIL][252] ([i915#15389] / [i915#6880])
   [252]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-spr-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-indfb-plflip-blt:
    - shard-rkl:          NOTRUN -> [SKIP][253] ([i915#1825]) +37 other tests skip
   [253]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-indfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-move:
    - shard-tglu:         NOTRUN -> [SKIP][254] +37 other tests skip
   [254]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-move.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt:
    - shard-mtlp:         NOTRUN -> [SKIP][255] ([i915#1825]) +14 other tests skip
   [255]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-gtt:
    - shard-dg1:          NOTRUN -> [SKIP][256] ([i915#8708]) +2 other tests skip
   [256]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-mmap-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][257] ([i915#8708]) +9 other tests skip
   [257]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-spr-indfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-suspend:
    - shard-glk:          NOTRUN -> [INCOMPLETE][258] ([i915#10056])
   [258]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk8/igt@kms_frontbuffer_tracking@fbc-suspend.html

  * igt@kms_frontbuffer_tracking@fbc-tiling-4:
    - shard-rkl:          NOTRUN -> [SKIP][259] ([i915#5439])
   [259]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_frontbuffer_tracking@fbc-tiling-4.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-render:
    - shard-dg2:          NOTRUN -> [SKIP][260] ([i915#15102])
   [260]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-gtt:
    - shard-mtlp:         NOTRUN -> [SKIP][261] ([i915#15104])
   [261]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-gtt.html
    - shard-dg1:          NOTRUN -> [SKIP][262] ([i915#15104])
   [262]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-pwrite:
    - shard-dg2:          NOTRUN -> [SKIP][263] ([i915#15102] / [i915#3458]) +5 other tests skip
   [263]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-pwrite.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-onoff:
    - shard-tglu-1:       NOTRUN -> [SKIP][264] +30 other tests skip
   [264]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_frontbuffer_tracking@fbcpsr-2p-primscrn-spr-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-indfb-draw-mmap-gtt:
    - shard-mtlp:         NOTRUN -> [SKIP][265] ([i915#8708]) +3 other tests skip
   [265]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-3/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-indfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-rgb565-draw-mmap-gtt:
    - shard-rkl:          NOTRUN -> [SKIP][266] ([i915#15102] / [i915#3023]) +15 other tests skip
   [266]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_frontbuffer_tracking@fbcpsr-rgb565-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@pipe-fbc-rte:
    - shard-rkl:          NOTRUN -> [SKIP][267] ([i915#9766])
   [267]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_frontbuffer_tracking@pipe-fbc-rte.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-wc:
    - shard-rkl:          NOTRUN -> [SKIP][268] ([i915#14544] / [i915#15102])
   [268]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-pwrite:
    - shard-rkl:          NOTRUN -> [SKIP][269] ([i915#15102]) +3 other tests skip
   [269]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-shrfb-draw-pwrite.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-pwrite:
    - shard-rkl:          NOTRUN -> [SKIP][270] ([i915#14544] / [i915#15102] / [i915#3023]) +1 other test skip
   [270]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-pwrite.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-render:
    - shard-dg1:          NOTRUN -> [SKIP][271] ([i915#15102] / [i915#3458]) +3 other tests skip
   [271]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-render.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-indfb-plflip-blt:
    - shard-tglu-1:       NOTRUN -> [SKIP][272] ([i915#15102]) +7 other tests skip
   [272]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_frontbuffer_tracking@psr-1p-primscrn-indfb-plflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-cpu:
    - shard-snb:          NOTRUN -> [SKIP][273] +88 other tests skip
   [273]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb1/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-gtt:
    - shard-rkl:          NOTRUN -> [SKIP][274] ([i915#14544] / [i915#1825]) +4 other tests skip
   [274]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-shrfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-blt:
    - shard-dg2:          NOTRUN -> [SKIP][275] ([i915#5354]) +19 other tests skip
   [275]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-7/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-cur-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-spr-indfb-draw-pwrite:
    - shard-dg1:          NOTRUN -> [SKIP][276] +16 other tests skip
   [276]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-spr-indfb-draw-pwrite.html

  * igt@kms_frontbuffer_tracking@psr-shrfb-scaledprimary:
    - shard-tglu:         NOTRUN -> [SKIP][277] ([i915#15102]) +13 other tests skip
   [277]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_frontbuffer_tracking@psr-shrfb-scaledprimary.html

  * igt@kms_hdr@bpc-switch-suspend:
    - shard-tglu-1:       NOTRUN -> [SKIP][278] ([i915#3555] / [i915#8228])
   [278]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_hdr@bpc-switch-suspend.html

  * igt@kms_hdr@static-toggle:
    - shard-tglu:         NOTRUN -> [SKIP][279] ([i915#3555] / [i915#8228])
   [279]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@kms_hdr@static-toggle.html

  * igt@kms_joiner@basic-big-joiner:
    - shard-rkl:          NOTRUN -> [SKIP][280] ([i915#15460])
   [280]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_joiner@basic-big-joiner.html

  * igt@kms_joiner@basic-force-big-joiner:
    - shard-tglu-1:       NOTRUN -> [SKIP][281] ([i915#15459])
   [281]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_joiner@basic-force-big-joiner.html

  * igt@kms_joiner@basic-force-ultra-joiner:
    - shard-dg1:          NOTRUN -> [SKIP][282] ([i915#15458])
   [282]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_joiner@basic-force-ultra-joiner.html

  * igt@kms_joiner@basic-max-non-joiner:
    - shard-tglu:         NOTRUN -> [SKIP][283] ([i915#13688])
   [283]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-10/igt@kms_joiner@basic-max-non-joiner.html

  * igt@kms_joiner@basic-ultra-joiner:
    - shard-tglu-1:       NOTRUN -> [SKIP][284] ([i915#15458])
   [284]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_joiner@basic-ultra-joiner.html

  * igt@kms_pipe_stress@stress-xrgb8888-yftiled:
    - shard-tglu:         NOTRUN -> [SKIP][285] ([i915#14712])
   [285]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@kms_pipe_stress@stress-xrgb8888-yftiled.html

  * igt@kms_plane@pixel-format-4-tiled-dg2-mc-ccs-modifier:
    - shard-glk10:        NOTRUN -> [SKIP][286] +113 other tests skip
   [286]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk10/igt@kms_plane@pixel-format-4-tiled-dg2-mc-ccs-modifier.html

  * igt@kms_plane@pixel-format-4-tiled-lnl-ccs-modifier-source-clamping:
    - shard-dg1:          NOTRUN -> [SKIP][287] ([i915#15709]) +1 other test skip
   [287]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-14/igt@kms_plane@pixel-format-4-tiled-lnl-ccs-modifier-source-clamping.html

  * igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-cc-modifier:
    - shard-tglu-1:       NOTRUN -> [SKIP][288] ([i915#15709]) +1 other test skip
   [288]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_plane@pixel-format-4-tiled-mtl-rc-ccs-cc-modifier.html

  * igt@kms_plane@pixel-format-y-tiled-ccs-modifier:
    - shard-dg2:          NOTRUN -> [SKIP][289] ([i915#15709])
   [289]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_plane@pixel-format-y-tiled-ccs-modifier.html
    - shard-rkl:          NOTRUN -> [SKIP][290] ([i915#15709]) +4 other tests skip
   [290]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_plane@pixel-format-y-tiled-ccs-modifier.html

  * igt@kms_plane@pixel-format-y-tiled-ccs-modifier-source-clamping:
    - shard-rkl:          NOTRUN -> [SKIP][291] ([i915#14544] / [i915#15709])
   [291]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_plane@pixel-format-y-tiled-ccs-modifier-source-clamping.html

  * igt@kms_plane@pixel-format-yf-tiled-ccs-modifier-source-clamping:
    - shard-tglu:         NOTRUN -> [SKIP][292] ([i915#15709]) +2 other tests skip
   [292]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@kms_plane@pixel-format-yf-tiled-ccs-modifier-source-clamping.html

  * igt@kms_plane@pixel-format-yf-tiled-ccs-modifier@pipe-a-plane-4:
    - shard-glk11:        NOTRUN -> [SKIP][293] +40 other tests skip
   [293]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk11/igt@kms_plane@pixel-format-yf-tiled-ccs-modifier@pipe-a-plane-4.html

  * igt@kms_plane@pixel-format-yf-tiled-modifier:
    - shard-mtlp:         NOTRUN -> [SKIP][294] ([i915#15709]) +1 other test skip
   [294]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@kms_plane@pixel-format-yf-tiled-modifier.html

  * igt@kms_plane_alpha_blend@alpha-basic:
    - shard-glk:          NOTRUN -> [FAIL][295] ([i915#12178])
   [295]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk2/igt@kms_plane_alpha_blend@alpha-basic.html

  * igt@kms_plane_alpha_blend@alpha-basic@pipe-a-hdmi-a-1:
    - shard-glk:          NOTRUN -> [FAIL][296] ([i915#7862]) +1 other test fail
   [296]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk2/igt@kms_plane_alpha_blend@alpha-basic@pipe-a-hdmi-a-1.html

  * igt@kms_plane_alpha_blend@alpha-opaque-fb:
    - shard-glk:          NOTRUN -> [FAIL][297] ([i915#10647] / [i915#12169])
   [297]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk3/igt@kms_plane_alpha_blend@alpha-opaque-fb.html

  * igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-a-hdmi-a-1:
    - shard-glk:          NOTRUN -> [FAIL][298] ([i915#10647]) +1 other test fail
   [298]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk3/igt@kms_plane_alpha_blend@alpha-opaque-fb@pipe-a-hdmi-a-1.html

  * igt@kms_plane_multiple@2x-tiling-4:
    - shard-dg2:          NOTRUN -> [SKIP][299] ([i915#13958]) +1 other test skip
   [299]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_plane_multiple@2x-tiling-4.html

  * igt@kms_plane_multiple@2x-tiling-none:
    - shard-tglu:         NOTRUN -> [SKIP][300] ([i915#13958])
   [300]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@kms_plane_multiple@2x-tiling-none.html

  * igt@kms_plane_multiple@2x-tiling-x:
    - shard-rkl:          NOTRUN -> [SKIP][301] ([i915#13958] / [i915#14544])
   [301]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_plane_multiple@2x-tiling-x.html

  * igt@kms_plane_multiple@2x-tiling-yf:
    - shard-tglu-1:       NOTRUN -> [SKIP][302] ([i915#13958])
   [302]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_plane_multiple@2x-tiling-yf.html

  * igt@kms_plane_multiple@tiling-4:
    - shard-tglu:         NOTRUN -> [SKIP][303] ([i915#14259])
   [303]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-6/igt@kms_plane_multiple@tiling-4.html

  * igt@kms_plane_scaling@intel-max-src-size:
    - shard-rkl:          [PASS][304] -> [SKIP][305] ([i915#6953])
   [304]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_plane_scaling@intel-max-src-size.html
   [305]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_plane_scaling@intel-max-src-size.html

  * igt@kms_plane_scaling@plane-scaler-unity-scaling-with-rotation@pipe-b:
    - shard-rkl:          NOTRUN -> [SKIP][306] ([i915#15329]) +3 other tests skip
   [306]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_plane_scaling@plane-scaler-unity-scaling-with-rotation@pipe-b.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-5:
    - shard-mtlp:         NOTRUN -> [SKIP][307] ([i915#15329] / [i915#6953])
   [307]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@kms_plane_scaling@planes-downscale-factor-0-5.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-5@pipe-a:
    - shard-mtlp:         NOTRUN -> [SKIP][308] ([i915#15329]) +3 other tests skip
   [308]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@kms_plane_scaling@planes-downscale-factor-0-5@pipe-a.html

  * igt@kms_pm_backlight@basic-brightness:
    - shard-rkl:          NOTRUN -> [SKIP][309] ([i915#5354]) +1 other test skip
   [309]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_pm_backlight@basic-brightness.html

  * igt@kms_pm_backlight@brightness-with-dpms:
    - shard-tglu-1:       NOTRUN -> [SKIP][310] ([i915#12343])
   [310]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_pm_backlight@brightness-with-dpms.html
    - shard-dg1:          NOTRUN -> [SKIP][311] ([i915#12343])
   [311]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_pm_backlight@brightness-with-dpms.html

  * igt@kms_pm_dc@dc3co-vpb-simulation:
    - shard-dg2:          NOTRUN -> [SKIP][312] ([i915#9685])
   [312]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@kms_pm_dc@dc3co-vpb-simulation.html
    - shard-tglu-1:       NOTRUN -> [SKIP][313] ([i915#9685])
   [313]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_pm_dc@dc3co-vpb-simulation.html

  * igt@kms_pm_rpm@dpms-mode-unset-lpsp:
    - shard-rkl:          [PASS][314] -> [SKIP][315] ([i915#14544] / [i915#15073])
   [314]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html
   [315]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html

  * igt@kms_pm_rpm@dpms-mode-unset-non-lpsp:
    - shard-rkl:          NOTRUN -> [SKIP][316] ([i915#15073])
   [316]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_pm_rpm@dpms-mode-unset-non-lpsp.html
    - shard-mtlp:         NOTRUN -> [SKIP][317] ([i915#15073])
   [317]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_pm_rpm@dpms-mode-unset-non-lpsp.html

  * igt@kms_pm_rpm@dpms-non-lpsp:
    - shard-tglu:         NOTRUN -> [SKIP][318] ([i915#15073]) +1 other test skip
   [318]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-6/igt@kms_pm_rpm@dpms-non-lpsp.html
    - shard-rkl:          [PASS][319] -> [SKIP][320] ([i915#15073])
   [319]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_pm_rpm@dpms-non-lpsp.html
   [320]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_pm_rpm@dpms-non-lpsp.html

  * igt@kms_pm_rpm@modeset-lpsp-stress:
    - shard-dg1:          NOTRUN -> [SKIP][321] ([i915#15073]) +1 other test skip
   [321]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_pm_rpm@modeset-lpsp-stress.html

  * igt@kms_pm_rpm@modeset-non-lpsp:
    - shard-dg2:          NOTRUN -> [SKIP][322] ([i915#15073]) +1 other test skip
   [322]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_pm_rpm@modeset-non-lpsp.html

  * igt@kms_pm_rpm@system-suspend-modeset:
    - shard-rkl:          [PASS][323] -> [INCOMPLETE][324] ([i915#14419])
   [323]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@kms_pm_rpm@system-suspend-modeset.html
   [324]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_pm_rpm@system-suspend-modeset.html

  * igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-exceed-sf:
    - shard-glk11:        NOTRUN -> [SKIP][325] ([i915#11520]) +2 other tests skip
   [325]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk11/igt@kms_psr2_sf@fbc-pr-cursor-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@fbc-pr-plane-move-sf-dmg-area:
    - shard-glk:          NOTRUN -> [SKIP][326] ([i915#11520]) +8 other tests skip
   [326]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk6/igt@kms_psr2_sf@fbc-pr-plane-move-sf-dmg-area.html

  * igt@kms_psr2_sf@fbc-pr-primary-plane-update-sf-dmg-area:
    - shard-dg2:          NOTRUN -> [SKIP][327] ([i915#11520]) +5 other tests skip
   [327]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_psr2_sf@fbc-pr-primary-plane-update-sf-dmg-area.html

  * igt@kms_psr2_sf@fbc-psr2-overlay-plane-move-continuous-exceed-sf:
    - shard-glk10:        NOTRUN -> [SKIP][328] ([i915#11520]) +2 other tests skip
   [328]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk10/igt@kms_psr2_sf@fbc-psr2-overlay-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@pr-cursor-plane-update-sf:
    - shard-mtlp:         NOTRUN -> [SKIP][329] ([i915#12316]) +1 other test skip
   [329]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@kms_psr2_sf@pr-cursor-plane-update-sf.html

  * igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-fully-sf:
    - shard-snb:          NOTRUN -> [SKIP][330] ([i915#11520]) +1 other test skip
   [330]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb5/igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-fully-sf.html
    - shard-dg1:          NOTRUN -> [SKIP][331] ([i915#11520]) +2 other tests skip
   [331]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-13/igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-fully-sf.html
    - shard-tglu:         NOTRUN -> [SKIP][332] ([i915#11520]) +1 other test skip
   [332]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@kms_psr2_sf@psr2-cursor-plane-move-continuous-exceed-fully-sf.html

  * igt@kms_psr2_sf@psr2-overlay-plane-update-sf-dmg-area:
    - shard-rkl:          NOTRUN -> [SKIP][333] ([i915#11520]) +6 other tests skip
   [333]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_psr2_sf@psr2-overlay-plane-update-sf-dmg-area.html

  * igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area:
    - shard-tglu-1:       NOTRUN -> [SKIP][334] ([i915#11520]) +3 other tests skip
   [334]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_psr2_sf@psr2-primary-plane-update-sf-dmg-area.html

  * igt@kms_psr2_su@page_flip-p010:
    - shard-rkl:          NOTRUN -> [SKIP][335] ([i915#9683])
   [335]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_psr2_su@page_flip-p010.html

  * igt@kms_psr@fbc-psr-cursor-plane-move:
    - shard-rkl:          NOTRUN -> [SKIP][336] ([i915#1072] / [i915#9732]) +13 other tests skip
   [336]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_psr@fbc-psr-cursor-plane-move.html

  * igt@kms_psr@pr-primary-render:
    - shard-dg2:          NOTRUN -> [SKIP][337] ([i915#1072] / [i915#9732]) +12 other tests skip
   [337]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_psr@pr-primary-render.html

  * igt@kms_psr@pr-sprite-blt:
    - shard-mtlp:         NOTRUN -> [SKIP][338] ([i915#9688]) +2 other tests skip
   [338]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-4/igt@kms_psr@pr-sprite-blt.html

  * igt@kms_psr@pr-sprite-plane-onoff:
    - shard-dg1:          NOTRUN -> [SKIP][339] ([i915#1072] / [i915#9732]) +7 other tests skip
   [339]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@kms_psr@pr-sprite-plane-onoff.html

  * igt@kms_psr@psr-basic:
    - shard-tglu:         NOTRUN -> [SKIP][340] ([i915#9732]) +10 other tests skip
   [340]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@kms_psr@psr-basic.html

  * igt@kms_psr@psr2-cursor-mmap-gtt:
    - shard-tglu-1:       NOTRUN -> [SKIP][341] ([i915#9732]) +8 other tests skip
   [341]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-1/igt@kms_psr@psr2-cursor-mmap-gtt.html

  * igt@kms_psr@psr2-sprite-mmap-cpu:
    - shard-rkl:          NOTRUN -> [SKIP][342] ([i915#1072] / [i915#14544] / [i915#9732]) +5 other tests skip
   [342]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_psr@psr2-sprite-mmap-cpu.html

  * igt@kms_rotation_crc@primary-x-tiled-reflect-x-0:
    - shard-dg1:          NOTRUN -> [DMESG-WARN][343] ([i915#4423])
   [343]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_rotation_crc@primary-x-tiled-reflect-x-0.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-180:
    - shard-dg2:          NOTRUN -> [SKIP][344] ([i915#5190])
   [344]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_rotation_crc@primary-y-tiled-reflect-x-180.html

  * igt@kms_rotation_crc@primary-y-tiled-reflect-x-270:
    - shard-mtlp:         NOTRUN -> [SKIP][345] ([i915#12755] / [i915#15867])
   [345]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-6/igt@kms_rotation_crc@primary-y-tiled-reflect-x-270.html

  * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-180:
    - shard-rkl:          NOTRUN -> [SKIP][346] ([i915#5289]) +1 other test skip
   [346]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-180.html

  * igt@kms_scaling_modes@scaling-mode-center:
    - shard-dg2:          NOTRUN -> [SKIP][347] ([i915#3555]) +4 other tests skip
   [347]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_scaling_modes@scaling-mode-center.html

  * igt@kms_scaling_modes@scaling-mode-full-aspect:
    - shard-tglu:         NOTRUN -> [SKIP][348] ([i915#3555]) +7 other tests skip
   [348]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@kms_scaling_modes@scaling-mode-full-aspect.html

  * igt@kms_setmode@invalid-clone-exclusive-crtc:
    - shard-rkl:          NOTRUN -> [SKIP][349] ([i915#14544] / [i915#3555])
   [349]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_setmode@invalid-clone-exclusive-crtc.html
    - shard-mtlp:         NOTRUN -> [SKIP][350] ([i915#3555] / [i915#8809] / [i915#8823])
   [350]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@kms_setmode@invalid-clone-exclusive-crtc.html

  * igt@kms_tiled_display@basic-test-pattern:
    - shard-tglu:         NOTRUN -> [SKIP][351] ([i915#8623])
   [351]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-6/igt@kms_tiled_display@basic-test-pattern.html

  * igt@kms_tiled_display@basic-test-pattern-with-chamelium:
    - shard-dg1:          NOTRUN -> [SKIP][352] ([i915#8623])
   [352]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@kms_tiled_display@basic-test-pattern-with-chamelium.html

  * igt@kms_vrr@flip-suspend:
    - shard-rkl:          NOTRUN -> [SKIP][353] ([i915#15243] / [i915#3555])
   [353]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_vrr@flip-suspend.html

  * igt@kms_vrr@max-min:
    - shard-dg2:          NOTRUN -> [SKIP][354] ([i915#9906])
   [354]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-6/igt@kms_vrr@max-min.html
    - shard-rkl:          NOTRUN -> [SKIP][355] ([i915#9906])
   [355]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_vrr@max-min.html
    - shard-dg1:          NOTRUN -> [SKIP][356] ([i915#9906])
   [356]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@kms_vrr@max-min.html
    - shard-tglu:         NOTRUN -> [SKIP][357] ([i915#9906])
   [357]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-10/igt@kms_vrr@max-min.html
    - shard-mtlp:         NOTRUN -> [SKIP][358] ([i915#8808] / [i915#9906])
   [358]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-5/igt@kms_vrr@max-min.html

  * igt@perf@global-sseu-config:
    - shard-mtlp:         NOTRUN -> [SKIP][359] ([i915#7387])
   [359]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-8/igt@perf@global-sseu-config.html

  * igt@perf@mi-rpc:
    - shard-dg2:          NOTRUN -> [SKIP][360] ([i915#2434])
   [360]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@perf@mi-rpc.html
    - shard-rkl:          NOTRUN -> [SKIP][361] ([i915#2434])
   [361]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@perf@mi-rpc.html
    - shard-dg1:          NOTRUN -> [SKIP][362] ([i915#2434])
   [362]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@perf@mi-rpc.html
    - shard-mtlp:         NOTRUN -> [SKIP][363] ([i915#2434])
   [363]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-2/igt@perf@mi-rpc.html

  * igt@perf_pmu@busy-accuracy-98@rcs0:
    - shard-tglu:         NOTRUN -> [FAIL][364] ([i915#4349]) +1 other test fail
   [364]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-6/igt@perf_pmu@busy-accuracy-98@rcs0.html

  * igt@perf_pmu@busy-double-start@bcs0:
    - shard-mtlp:         [PASS][365] -> [FAIL][366] ([i915#4349]) +2 other tests fail
   [365]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-3/igt@perf_pmu@busy-double-start@bcs0.html
   [366]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@perf_pmu@busy-double-start@bcs0.html

  * igt@perf_pmu@busy-double-start@vcs1:
    - shard-dg1:          [PASS][367] -> [FAIL][368] ([i915#4349]) +3 other tests fail
   [367]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@perf_pmu@busy-double-start@vcs1.html
   [368]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@perf_pmu@busy-double-start@vcs1.html

  * igt@perf_pmu@module-unload:
    - shard-dg2:          NOTRUN -> [ABORT][369] ([i915#13029] / [i915#15778])
   [369]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-3/igt@perf_pmu@module-unload.html

  * igt@prime_vgem@basic-fence-read:
    - shard-rkl:          NOTRUN -> [SKIP][370] ([i915#3291] / [i915#3708]) +1 other test skip
   [370]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@prime_vgem@basic-fence-read.html

  * igt@prime_vgem@basic-read:
    - shard-dg1:          NOTRUN -> [SKIP][371] ([i915#3708])
   [371]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-17/igt@prime_vgem@basic-read.html

  * igt@prime_vgem@fence-read-hang:
    - shard-dg2:          NOTRUN -> [SKIP][372] ([i915#3708])
   [372]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-8/igt@prime_vgem@fence-read-hang.html
    - shard-rkl:          NOTRUN -> [SKIP][373] ([i915#3708])
   [373]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@prime_vgem@fence-read-hang.html

  * igt@sriov_basic@enable-vfs-bind-unbind-each:
    - shard-dg1:          NOTRUN -> [SKIP][374] ([i915#9917])
   [374]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@sriov_basic@enable-vfs-bind-unbind-each.html

  
#### Possible fixes ####

  * igt@gem_ccs@suspend-resume:
    - shard-dg2:          [INCOMPLETE][375] ([i915#13356]) -> [PASS][376]
   [375]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-6/igt@gem_ccs@suspend-resume.html
   [376]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@gem_ccs@suspend-resume.html

  * igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0:
    - shard-dg2:          [INCOMPLETE][377] ([i915#12392] / [i915#13356]) -> [PASS][378]
   [377]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-6/igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0.html
   [378]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@gem_ccs@suspend-resume@tile4-compressed-compfmt0-smem-lmem0.html

  * igt@gem_eio@kms:
    - shard-rkl:          [DMESG-WARN][379] ([i915#13363]) -> [PASS][380]
   [379]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@gem_eio@kms.html
   [380]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_eio@kms.html
    - shard-tglu:         [DMESG-WARN][381] ([i915#13363]) -> [PASS][382]
   [381]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-3/igt@gem_eio@kms.html
   [382]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-9/igt@gem_eio@kms.html

  * igt@gem_exec_suspend@basic-s0:
    - shard-rkl:          [INCOMPLETE][383] ([i915#13356]) -> [PASS][384] +2 other tests pass
   [383]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@gem_exec_suspend@basic-s0.html
   [384]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_exec_suspend@basic-s0.html

  * igt@i915_module_load@fault-injection@uc_fw_rsa_data_create:
    - shard-mtlp:         [INCOMPLETE][385] -> [PASS][386]
   [385]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-5/igt@i915_module_load@fault-injection@uc_fw_rsa_data_create.html
   [386]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@i915_module_load@fault-injection@uc_fw_rsa_data_create.html

  * igt@i915_module_load@resize-bar:
    - shard-dg2:          [DMESG-WARN][387] ([i915#14545]) -> [PASS][388]
   [387]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-6/igt@i915_module_load@resize-bar.html
   [388]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@i915_module_load@resize-bar.html

  * igt@i915_pm_rpm@system-suspend-devices:
    - shard-dg2:          [ABORT][389] ([i915#15060]) -> [PASS][390]
   [389]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-10/igt@i915_pm_rpm@system-suspend-devices.html
   [390]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-1/igt@i915_pm_rpm@system-suspend-devices.html

  * igt@i915_pm_rpm@system-suspend-execbuf:
    - shard-glk:          [INCOMPLETE][391] ([i915#13356] / [i915#15172]) -> [PASS][392]
   [391]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-glk9/igt@i915_pm_rpm@system-suspend-execbuf.html
   [392]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk9/igt@i915_pm_rpm@system-suspend-execbuf.html

  * igt@i915_power@sanity:
    - shard-mtlp:         [SKIP][393] ([i915#7984]) -> [PASS][394]
   [393]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-8/igt@i915_power@sanity.html
   [394]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-3/igt@i915_power@sanity.html

  * igt@i915_selftest@live@workarounds:
    - shard-dg2:          [DMESG-FAIL][395] ([i915#12061]) -> [PASS][396] +1 other test pass
   [395]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-7/igt@i915_selftest@live@workarounds.html
   [396]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@i915_selftest@live@workarounds.html

  * igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1:
    - shard-tglu:         [FAIL][397] ([i915#15662]) -> [PASS][398] +3 other tests pass
   [397]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-7/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1.html
   [398]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-5/igt@kms_atomic_transition@plane-toggle-modeset-transition@pipe-a-hdmi-a-1.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip:
    - shard-mtlp:         [FAIL][399] ([i915#15733] / [i915#5138]) -> [PASS][400] +1 other test pass
   [399]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-2/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip.html
   [400]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_big_fb@4-tiled-max-hw-stride-64bpp-rotate-0-hflip.html

  * igt@kms_cursor_crc@cursor-onscreen-128x42:
    - shard-tglu:         [FAIL][401] ([i915#13566]) -> [PASS][402] +3 other tests pass
   [401]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-6/igt@kms_cursor_crc@cursor-onscreen-128x42.html
   [402]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-8/igt@kms_cursor_crc@cursor-onscreen-128x42.html

  * igt@kms_cursor_crc@cursor-random-256x85:
    - shard-rkl:          [FAIL][403] ([i915#13566]) -> [PASS][404]
   [403]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@kms_cursor_crc@cursor-random-256x85.html
   [404]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_cursor_crc@cursor-random-256x85.html

  * igt@kms_cursor_crc@cursor-rapid-movement-64x64:
    - shard-dg1:          [DMESG-WARN][405] ([i915#4423]) -> [PASS][406]
   [405]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@kms_cursor_crc@cursor-rapid-movement-64x64.html
   [406]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_cursor_crc@cursor-rapid-movement-64x64.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible:
    - shard-snb:          [TIMEOUT][407] ([i915#14033] / [i915#14350]) -> [PASS][408]
   [407]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-snb5/igt@kms_flip@2x-flip-vs-suspend-interruptible.html
   [408]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb1/igt@kms_flip@2x-flip-vs-suspend-interruptible.html

  * igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-vga1-hdmi-a1:
    - shard-snb:          [TIMEOUT][409] ([i915#14033]) -> [PASS][410]
   [409]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-snb5/igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-vga1-hdmi-a1.html
   [410]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb1/igt@kms_flip@2x-flip-vs-suspend-interruptible@ab-vga1-hdmi-a1.html

  * igt@kms_flip@flip-vs-suspend:
    - shard-rkl:          [INCOMPLETE][411] ([i915#6113]) -> [PASS][412]
   [411]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-4/igt@kms_flip@flip-vs-suspend.html
   [412]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_flip@flip-vs-suspend.html

  * igt@kms_flip@flip-vs-suspend-interruptible@b-hdmi-a1:
    - shard-snb:          [INCOMPLETE][413] ([i915#12314] / [i915#12745] / [i915#4839]) -> [PASS][414] +1 other test pass
   [413]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-snb6/igt@kms_flip@flip-vs-suspend-interruptible@b-hdmi-a1.html
   [414]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-snb1/igt@kms_flip@flip-vs-suspend-interruptible@b-hdmi-a1.html

  * igt@kms_force_connector_basic@prune-stale-modes:
    - shard-mtlp:         [SKIP][415] ([i915#15672]) -> [PASS][416]
   [415]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-1/igt@kms_force_connector_basic@prune-stale-modes.html
   [416]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@kms_force_connector_basic@prune-stale-modes.html

  * igt@kms_hdr@bpc-switch-dpms:
    - shard-rkl:          [SKIP][417] ([i915#3555] / [i915#8228]) -> [PASS][418]
   [417]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_hdr@bpc-switch-dpms.html
   [418]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_hdr@bpc-switch-dpms.html

  * igt@kms_hdr@static-swap:
    - shard-dg2:          [SKIP][419] ([i915#3555] / [i915#8228]) -> [PASS][420]
   [419]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_hdr@static-swap.html
   [420]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_hdr@static-swap.html

  * igt@kms_joiner@invalid-modeset-force-big-joiner:
    - shard-dg2:          [SKIP][421] ([i915#15459]) -> [PASS][422]
   [421]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_joiner@invalid-modeset-force-big-joiner.html
   [422]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_joiner@invalid-modeset-force-big-joiner.html

  * igt@kms_pm_rpm@dpms-lpsp:
    - shard-dg1:          [SKIP][423] ([i915#15073]) -> [PASS][424] +1 other test pass
   [423]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@kms_pm_rpm@dpms-lpsp.html
   [424]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-15/igt@kms_pm_rpm@dpms-lpsp.html

  * igt@kms_pm_rpm@dpms-mode-unset-lpsp:
    - shard-dg2:          [SKIP][425] ([i915#15073]) -> [PASS][426]
   [425]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-3/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html
   [426]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_pm_rpm@dpms-mode-unset-lpsp.html

  * igt@kms_pm_rpm@system-suspend-idle:
    - shard-rkl:          [INCOMPLETE][427] ([i915#14419]) -> [PASS][428]
   [427]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_pm_rpm@system-suspend-idle.html
   [428]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_pm_rpm@system-suspend-idle.html

  * igt@kms_pm_rpm@system-suspend-modeset:
    - shard-glk:          [INCOMPLETE][429] ([i915#10553]) -> [PASS][430]
   [429]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-glk8/igt@kms_pm_rpm@system-suspend-modeset.html
   [430]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk1/igt@kms_pm_rpm@system-suspend-modeset.html

  * igt@kms_setmode@basic:
    - shard-tglu:         [FAIL][431] ([i915#15106]) -> [PASS][432] +2 other tests pass
   [431]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-6/igt@kms_setmode@basic.html
   [432]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-7/igt@kms_setmode@basic.html
    - shard-dg2:          [FAIL][433] ([i915#15106]) -> [PASS][434]
   [433]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_setmode@basic.html
   [434]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-1/igt@kms_setmode@basic.html

  * igt@kms_setmode@basic@pipe-b-edp-1:
    - shard-mtlp:         [FAIL][435] ([i915#15106]) -> [PASS][436] +2 other tests pass
   [435]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-2/igt@kms_setmode@basic@pipe-b-edp-1.html
   [436]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-1/igt@kms_setmode@basic@pipe-b-edp-1.html

  * igt@kms_vblank@ts-continuation-dpms-suspend:
    - shard-rkl:          [ABORT][437] ([i915#15132]) -> [PASS][438]
   [437]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-1/igt@kms_vblank@ts-continuation-dpms-suspend.html
   [438]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_vblank@ts-continuation-dpms-suspend.html

  * igt@perf@polling@0-rcs0:
    - shard-tglu:         [FAIL][439] ([i915#10538]) -> [PASS][440] +1 other test pass
   [439]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-7/igt@perf@polling@0-rcs0.html
   [440]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-3/igt@perf@polling@0-rcs0.html

  
#### Warnings ####

  * igt@gem_bad_reloc@negative-reloc-lut:
    - shard-rkl:          [SKIP][441] ([i915#14544] / [i915#3281]) -> [SKIP][442] ([i915#3281]) +2 other tests skip
   [441]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@gem_bad_reloc@negative-reloc-lut.html
   [442]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@gem_bad_reloc@negative-reloc-lut.html

  * igt@gem_ctx_sseu@engines:
    - shard-rkl:          [SKIP][443] ([i915#280]) -> [SKIP][444] ([i915#14544] / [i915#280])
   [443]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@gem_ctx_sseu@engines.html
   [444]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_ctx_sseu@engines.html

  * igt@gem_exec_balancer@parallel-dmabuf-import-out-fence:
    - shard-rkl:          [SKIP][445] ([i915#4525]) -> [SKIP][446] ([i915#14544] / [i915#4525])
   [445]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-4/igt@gem_exec_balancer@parallel-dmabuf-import-out-fence.html
   [446]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_exec_balancer@parallel-dmabuf-import-out-fence.html

  * igt@gem_exec_reloc@basic-gtt-cpu-active:
    - shard-rkl:          [SKIP][447] ([i915#3281]) -> [SKIP][448] ([i915#14544] / [i915#3281]) +5 other tests skip
   [447]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@gem_exec_reloc@basic-gtt-cpu-active.html
   [448]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_exec_reloc@basic-gtt-cpu-active.html

  * igt@gem_lmem_swapping@massive:
    - shard-rkl:          [SKIP][449] ([i915#14544] / [i915#4613]) -> [SKIP][450] ([i915#4613]) +1 other test skip
   [449]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@gem_lmem_swapping@massive.html
   [450]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@gem_lmem_swapping@massive.html

  * igt@gem_pread@snoop:
    - shard-rkl:          [SKIP][451] ([i915#14544] / [i915#3282]) -> [SKIP][452] ([i915#3282]) +1 other test skip
   [451]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@gem_pread@snoop.html
   [452]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@gem_pread@snoop.html

  * igt@gem_pread@uncached:
    - shard-rkl:          [SKIP][453] ([i915#3282]) -> [SKIP][454] ([i915#14544] / [i915#3282]) +1 other test skip
   [453]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@gem_pread@uncached.html
   [454]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gem_pread@uncached.html

  * igt@gem_userptr_blits@forbidden-operations:
    - shard-rkl:          [SKIP][455] ([i915#14544] / [i915#3282] / [i915#3297]) -> [SKIP][456] ([i915#3282] / [i915#3297])
   [455]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@gem_userptr_blits@forbidden-operations.html
   [456]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@gem_userptr_blits@forbidden-operations.html

  * igt@gen9_exec_parse@allowed-all:
    - shard-rkl:          [SKIP][457] ([i915#14544] / [i915#2527]) -> [SKIP][458] ([i915#2527]) +2 other tests skip
   [457]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@gen9_exec_parse@allowed-all.html
   [458]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@gen9_exec_parse@allowed-all.html

  * igt@gen9_exec_parse@bb-start-param:
    - shard-rkl:          [SKIP][459] ([i915#2527]) -> [SKIP][460] ([i915#14544] / [i915#2527]) +2 other tests skip
   [459]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@gen9_exec_parse@bb-start-param.html
   [460]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@gen9_exec_parse@bb-start-param.html

  * igt@i915_module_load@fault-injection:
    - shard-dg1:          [ABORT][461] ([i915#11815]) -> [ABORT][462] ([i915#11815] / [i915#15481]) +1 other test abort
   [461]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-16/igt@i915_module_load@fault-injection.html
   [462]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-16/igt@i915_module_load@fault-injection.html
    - shard-mtlp:         [ABORT][463] ([i915#15481]) -> [ABORT][464] ([i915#15342] / [i915#15481])
   [463]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-mtlp-5/igt@i915_module_load@fault-injection.html
   [464]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-mtlp-7/igt@i915_module_load@fault-injection.html

  * igt@i915_pm_freq_api@freq-basic-api:
    - shard-rkl:          [SKIP][465] ([i915#14544] / [i915#8399]) -> [SKIP][466] ([i915#8399])
   [465]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@i915_pm_freq_api@freq-basic-api.html
   [466]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@i915_pm_freq_api@freq-basic-api.html

  * igt@i915_pm_rc6_residency@rc6-idle:
    - shard-rkl:          [SKIP][467] ([i915#14498]) -> [SKIP][468] ([i915#14498] / [i915#14544])
   [467]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@i915_pm_rc6_residency@rc6-idle.html
   [468]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@i915_pm_rc6_residency@rc6-idle.html

  * igt@kms_big_fb@4-tiled-64bpp-rotate-0:
    - shard-rkl:          [SKIP][469] ([i915#5286]) -> [SKIP][470] ([i915#14544] / [i915#5286]) +2 other tests skip
   [469]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-4/igt@kms_big_fb@4-tiled-64bpp-rotate-0.html
   [470]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_big_fb@4-tiled-64bpp-rotate-0.html

  * igt@kms_big_fb@4-tiled-addfb-size-overflow:
    - shard-rkl:          [SKIP][471] ([i915#14544] / [i915#5286]) -> [SKIP][472] ([i915#5286])
   [471]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_big_fb@4-tiled-addfb-size-overflow.html
   [472]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-1/igt@kms_big_fb@4-tiled-addfb-size-overflow.html

  * igt@kms_big_fb@yf-tiled-16bpp-rotate-0:
    - shard-dg1:          [SKIP][473] ([i915#4538]) -> [SKIP][474] ([i915#4423] / [i915#4538])
   [473]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-14/igt@kms_big_fb@yf-tiled-16bpp-rotate-0.html
   [474]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_big_fb@yf-tiled-16bpp-rotate-0.html

  * igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc:
    - shard-rkl:          [SKIP][475] ([i915#14098] / [i915#6095]) -> [SKIP][476] ([i915#14098] / [i915#14544] / [i915#6095]) +5 other tests skip
   [475]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc.html
   [476]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_ccs@bad-pixel-format-4-tiled-mtl-rc-ccs-cc.html

  * igt@kms_ccs@bad-rotation-90-yf-tiled-ccs@pipe-b-hdmi-a-2:
    - shard-rkl:          [SKIP][477] ([i915#6095]) -> [SKIP][478] ([i915#14544] / [i915#6095]) +3 other tests skip
   [477]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@kms_ccs@bad-rotation-90-yf-tiled-ccs@pipe-b-hdmi-a-2.html
   [478]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_ccs@bad-rotation-90-yf-tiled-ccs@pipe-b-hdmi-a-2.html

  * igt@kms_ccs@crc-primary-basic-yf-tiled-ccs@pipe-c-hdmi-a-2:
    - shard-rkl:          [SKIP][479] ([i915#14098] / [i915#14544] / [i915#6095]) -> [SKIP][480] ([i915#14098] / [i915#6095]) +9 other tests skip
   [479]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_ccs@crc-primary-basic-yf-tiled-ccs@pipe-c-hdmi-a-2.html
   [480]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_ccs@crc-primary-basic-yf-tiled-ccs@pipe-c-hdmi-a-2.html

  * igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs:
    - shard-glk:          [INCOMPLETE][481] ([i915#15582]) -> [INCOMPLETE][482] ([i915#14694] / [i915#15582]) +1 other test incomplete
   [481]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-glk9/igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs.html
   [482]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-glk3/igt@kms_ccs@crc-primary-suspend-yf-tiled-ccs.html

  * igt@kms_ccs@random-ccs-data-y-tiled-gen12-mc-ccs@pipe-a-hdmi-a-2:
    - shard-rkl:          [SKIP][483] ([i915#14544] / [i915#6095]) -> [SKIP][484] ([i915#6095]) +5 other tests skip
   [483]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_ccs@random-ccs-data-y-tiled-gen12-mc-ccs@pipe-a-hdmi-a-2.html
   [484]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_ccs@random-ccs-data-y-tiled-gen12-mc-ccs@pipe-a-hdmi-a-2.html

  * igt@kms_cdclk@mode-transition-all-outputs:
    - shard-rkl:          [SKIP][485] ([i915#3742]) -> [SKIP][486] ([i915#14544] / [i915#3742]) +1 other test skip
   [485]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@kms_cdclk@mode-transition-all-outputs.html
   [486]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_cdclk@mode-transition-all-outputs.html

  * igt@kms_chamelium_frames@dp-frame-dump:
    - shard-rkl:          [SKIP][487] ([i915#11151] / [i915#7828]) -> [SKIP][488] ([i915#11151] / [i915#14544] / [i915#7828]) +3 other tests skip
   [487]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@kms_chamelium_frames@dp-frame-dump.html
   [488]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_chamelium_frames@dp-frame-dump.html

  * igt@kms_chamelium_hpd@vga-hpd-fast:
    - shard-rkl:          [SKIP][489] ([i915#11151] / [i915#14544] / [i915#7828]) -> [SKIP][490] ([i915#11151] / [i915#7828]) +2 other tests skip
   [489]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_chamelium_hpd@vga-hpd-fast.html
   [490]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_chamelium_hpd@vga-hpd-fast.html

  * igt@kms_content_protection@dp-mst-type-0-suspend-resume:
    - shard-rkl:          [SKIP][491] ([i915#15330]) -> [SKIP][492] ([i915#14544] / [i915#15330])
   [491]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-4/igt@kms_content_protection@dp-mst-type-0-suspend-resume.html
   [492]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_content_protection@dp-mst-type-0-suspend-resume.html

  * igt@kms_content_protection@dp-mst-type-1:
    - shard-rkl:          [SKIP][493] ([i915#14544] / [i915#15330] / [i915#3116]) -> [SKIP][494] ([i915#15330] / [i915#3116])
   [493]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_content_protection@dp-mst-type-1.html
   [494]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_content_protection@dp-mst-type-1.html

  * igt@kms_content_protection@suspend-resume:
    - shard-dg2:          [SKIP][495] ([i915#15865]) -> [FAIL][496] ([i915#7173]) +1 other test fail
   [495]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-8/igt@kms_content_protection@suspend-resume.html
   [496]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_content_protection@suspend-resume.html

  * igt@kms_cursor_crc@cursor-random-512x170:
    - shard-rkl:          [SKIP][497] ([i915#13049]) -> [SKIP][498] ([i915#13049] / [i915#14544]) +1 other test skip
   [497]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_cursor_crc@cursor-random-512x170.html
   [498]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_cursor_crc@cursor-random-512x170.html

  * igt@kms_cursor_crc@cursor-sliding-32x10:
    - shard-rkl:          [SKIP][499] ([i915#3555]) -> [SKIP][500] ([i915#14544] / [i915#3555]) +1 other test skip
   [499]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@kms_cursor_crc@cursor-sliding-32x10.html
   [500]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_cursor_crc@cursor-sliding-32x10.html

  * igt@kms_cursor_legacy@cursorb-vs-flipa-legacy:
    - shard-rkl:          [SKIP][501] ([i915#14544]) -> [SKIP][502] +6 other tests skip
   [501]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_cursor_legacy@cursorb-vs-flipa-legacy.html
   [502]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_cursor_legacy@cursorb-vs-flipa-legacy.html

  * igt@kms_dirtyfb@psr-dirtyfb-ioctl:
    - shard-rkl:          [SKIP][503] ([i915#14544] / [i915#9723]) -> [SKIP][504] ([i915#9723])
   [503]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html
   [504]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_dirtyfb@psr-dirtyfb-ioctl.html

  * igt@kms_dither@fb-8bpc-vs-panel-6bpc:
    - shard-rkl:          [SKIP][505] ([i915#3555] / [i915#3804]) -> [SKIP][506] ([i915#14544] / [i915#3555] / [i915#3804])
   [505]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-2/igt@kms_dither@fb-8bpc-vs-panel-6bpc.html
   [506]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_dither@fb-8bpc-vs-panel-6bpc.html

  * igt@kms_dp_link_training@uhbr-mst:
    - shard-rkl:          [SKIP][507] ([i915#13748] / [i915#14544]) -> [SKIP][508] ([i915#13748])
   [507]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_dp_link_training@uhbr-mst.html
   [508]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_dp_link_training@uhbr-mst.html

  * igt@kms_dp_link_training@uhbr-sst:
    - shard-rkl:          [SKIP][509] ([i915#13748]) -> [SKIP][510] ([i915#13748] / [i915#14544])
   [509]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@kms_dp_link_training@uhbr-sst.html
   [510]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_dp_link_training@uhbr-sst.html

  * igt@kms_flip@2x-absolute-wf_vblank-interruptible:
    - shard-rkl:          [SKIP][511] ([i915#14544] / [i915#9934]) -> [SKIP][512] ([i915#9934]) +2 other tests skip
   [511]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_flip@2x-absolute-wf_vblank-interruptible.html
   [512]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_flip@2x-absolute-wf_vblank-interruptible.html

  * igt@kms_flip@2x-flip-vs-wf_vblank:
    - shard-dg1:          [SKIP][513] ([i915#9934]) -> [SKIP][514] ([i915#4423] / [i915#9934])
   [513]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@kms_flip@2x-flip-vs-wf_vblank.html
   [514]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_flip@2x-flip-vs-wf_vblank.html

  * igt@kms_flip@2x-flip-vs-wf_vblank-interruptible:
    - shard-rkl:          [SKIP][515] ([i915#9934]) -> [SKIP][516] ([i915#14544] / [i915#9934]) +1 other test skip
   [515]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html
   [516]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip@2x-flip-vs-wf_vblank-interruptible.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling:
    - shard-rkl:          [SKIP][517] ([i915#14544] / [i915#15643]) -> [SKIP][518] ([i915#15643])
   [517]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling.html
   [518]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tile-upscaling.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling:
    - shard-rkl:          [SKIP][519] ([i915#15643]) -> [SKIP][520] ([i915#14544] / [i915#15643]) +1 other test skip
   [519]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html
   [520]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-downscaling.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-blt:
    - shard-rkl:          [SKIP][521] ([i915#15102]) -> [SKIP][522] ([i915#14544] / [i915#15102]) +2 other tests skip
   [521]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-blt.html
   [522]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-shrfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-render:
    - shard-dg1:          [SKIP][523] ([i915#15102] / [i915#3458]) -> [SKIP][524] ([i915#15102] / [i915#3458] / [i915#4423])
   [523]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-16/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-render.html
   [524]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_frontbuffer_tracking@fbcpsr-1p-primscrn-pri-shrfb-draw-render.html

  * igt@kms_frontbuffer_tracking@fbcpsr-indfb-scaledprimary:
    - shard-dg2:          [SKIP][525] ([i915#10433] / [i915#15102] / [i915#3458]) -> [SKIP][526] ([i915#15102] / [i915#3458]) +1 other test skip
   [525]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_frontbuffer_tracking@fbcpsr-indfb-scaledprimary.html
   [526]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-5/igt@kms_frontbuffer_tracking@fbcpsr-indfb-scaledprimary.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-indfb-draw-blt:
    - shard-dg1:          [SKIP][527] ([i915#15102] / [i915#4423]) -> [SKIP][528] ([i915#15102])
   [527]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-indfb-draw-blt.html
   [528]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-18/igt@kms_frontbuffer_tracking@psr-1p-offscreen-pri-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-mmap-cpu:
    - shard-dg2:          [SKIP][529] ([i915#15102] / [i915#3458]) -> [SKIP][530] ([i915#10433] / [i915#15102] / [i915#3458]) +1 other test skip
   [529]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-8/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-mmap-cpu.html
   [530]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-4/igt@kms_frontbuffer_tracking@psr-1p-primscrn-cur-indfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-mmap-wc:
    - shard-dg1:          [SKIP][531] ([i915#8708]) -> [SKIP][532] ([i915#4423] / [i915#8708]) +1 other test skip
   [531]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-mmap-wc.html
   [532]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_frontbuffer_tracking@psr-2p-primscrn-pri-indfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-indfb-msflip-blt:
    - shard-rkl:          [SKIP][533] ([i915#1825]) -> [SKIP][534] ([i915#14544] / [i915#1825]) +13 other tests skip
   [533]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-indfb-msflip-blt.html
   [534]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-indfb-msflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt:
    - shard-rkl:          [SKIP][535] ([i915#14544] / [i915#1825]) -> [SKIP][536] ([i915#1825]) +7 other tests skip
   [535]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt.html
   [536]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-2p-scndscrn-shrfb-pgflip-blt.html

  * igt@kms_frontbuffer_tracking@psr-rgb101010-draw-render:
    - shard-rkl:          [SKIP][537] ([i915#15102] / [i915#3023]) -> [SKIP][538] ([i915#14544] / [i915#15102] / [i915#3023]) +13 other tests skip
   [537]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-4/igt@kms_frontbuffer_tracking@psr-rgb101010-draw-render.html
   [538]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-rgb101010-draw-render.html

  * igt@kms_frontbuffer_tracking@psr-suspend:
    - shard-rkl:          [SKIP][539] ([i915#14544] / [i915#15102] / [i915#3023]) -> [SKIP][540] ([i915#15102] / [i915#3023]) +8 other tests skip
   [539]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_frontbuffer_tracking@psr-suspend.html
   [540]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@kms_frontbuffer_tracking@psr-suspend.html

  * igt@kms_hdr@brightness-with-hdr:
    - shard-dg2:          [SKIP][541] ([i915#12713]) -> [SKIP][542] ([i915#13331])
   [541]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-1/igt@kms_hdr@brightness-with-hdr.html
   [542]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_hdr@brightness-with-hdr.html
    - shard-dg1:          [SKIP][543] ([i915#1187] / [i915#12713]) -> [SKIP][544] ([i915#12713])
   [543]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-13/igt@kms_hdr@brightness-with-hdr.html
   [544]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-12/igt@kms_hdr@brightness-with-hdr.html

  * igt@kms_hdr@invalid-hdr:
    - shard-dg1:          [SKIP][545] ([i915#3555] / [i915#8228]) -> [SKIP][546] ([i915#3555] / [i915#4423] / [i915#8228])
   [545]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-14/igt@kms_hdr@invalid-hdr.html
   [546]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_hdr@invalid-hdr.html

  * igt@kms_joiner@basic-force-big-joiner:
    - shard-rkl:          [SKIP][547] ([i915#14544] / [i915#15459]) -> [SKIP][548] ([i915#15459])
   [547]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_joiner@basic-force-big-joiner.html
   [548]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-2/igt@kms_joiner@basic-force-big-joiner.html

  * igt@kms_pipe_b_c_ivb@from-pipe-c-to-b-with-3-lanes:
    - shard-rkl:          [SKIP][549] -> [SKIP][550] ([i915#14544]) +6 other tests skip
   [549]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@kms_pipe_b_c_ivb@from-pipe-c-to-b-with-3-lanes.html
   [550]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_pipe_b_c_ivb@from-pipe-c-to-b-with-3-lanes.html

  * igt@kms_plane@pixel-format-yf-tiled-ccs-modifier-source-clamping:
    - shard-rkl:          [SKIP][551] ([i915#15709]) -> [SKIP][552] ([i915#14544] / [i915#15709])
   [551]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@kms_plane@pixel-format-yf-tiled-ccs-modifier-source-clamping.html
   [552]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_plane@pixel-format-yf-tiled-ccs-modifier-source-clamping.html

  * igt@kms_pm_dc@dc6-psr:
    - shard-rkl:          [SKIP][553] ([i915#9685]) -> [SKIP][554] ([i915#14544] / [i915#9685])
   [553]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-7/igt@kms_pm_dc@dc6-psr.html
   [554]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_pm_dc@dc6-psr.html

  * igt@kms_pm_dc@dc9-dpms:
    - shard-rkl:          [SKIP][555] ([i915#14544] / [i915#15739]) -> [SKIP][556] ([i915#15739])
   [555]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_pm_dc@dc9-dpms.html
   [556]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-5/igt@kms_pm_dc@dc9-dpms.html
    - shard-tglu:         [SKIP][557] ([i915#15128]) -> [SKIP][558] ([i915#15739])
   [557]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-tglu-6/igt@kms_pm_dc@dc9-dpms.html
   [558]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-tglu-9/igt@kms_pm_dc@dc9-dpms.html

  * igt@kms_psr2_sf@fbc-psr2-cursor-plane-update-sf:
    - shard-rkl:          [SKIP][559] ([i915#11520]) -> [SKIP][560] ([i915#11520] / [i915#14544]) +1 other test skip
   [559]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-8/igt@kms_psr2_sf@fbc-psr2-cursor-plane-update-sf.html
   [560]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_psr2_sf@fbc-psr2-cursor-plane-update-sf.html

  * igt@kms_psr2_sf@pr-primary-plane-update-sf-dmg-area:
    - shard-rkl:          [SKIP][561] ([i915#11520] / [i915#14544]) -> [SKIP][562] ([i915#11520])
   [561]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_psr2_sf@pr-primary-plane-update-sf-dmg-area.html
   [562]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@kms_psr2_sf@pr-primary-plane-update-sf-dmg-area.html

  * igt@kms_psr2_sf@psr2-overlay-plane-update-continuous-sf:
    - shard-dg1:          [SKIP][563] ([i915#11520]) -> [SKIP][564] ([i915#11520] / [i915#4423])
   [563]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-19/igt@kms_psr2_sf@psr2-overlay-plane-update-continuous-sf.html
   [564]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_psr2_sf@psr2-overlay-plane-update-continuous-sf.html

  * igt@kms_psr2_su@page_flip-xrgb8888:
    - shard-rkl:          [SKIP][565] ([i915#9683]) -> [SKIP][566] ([i915#14544] / [i915#9683]) +1 other test skip
   [565]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-5/igt@kms_psr2_su@page_flip-xrgb8888.html
   [566]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_psr2_su@page_flip-xrgb8888.html

  * igt@kms_psr@pr-cursor-plane-onoff:
    - shard-rkl:          [SKIP][567] ([i915#1072] / [i915#14544] / [i915#9732]) -> [SKIP][568] ([i915#1072] / [i915#9732]) +8 other tests skip
   [567]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_psr@pr-cursor-plane-onoff.html
   [568]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_psr@pr-cursor-plane-onoff.html

  * igt@kms_psr@pr-cursor-render:
    - shard-rkl:          [SKIP][569] ([i915#1072] / [i915#9732]) -> [SKIP][570] ([i915#1072] / [i915#14544] / [i915#9732]) +7 other tests skip
   [569]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-3/igt@kms_psr@pr-cursor-render.html
   [570]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-6/igt@kms_psr@pr-cursor-render.html

  * igt@kms_psr@psr2-primary-render:
    - shard-dg1:          [SKIP][571] ([i915#1072] / [i915#9732]) -> [SKIP][572] ([i915#1072] / [i915#4423] / [i915#9732]) +1 other test skip
   [571]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-17/igt@kms_psr@psr2-primary-render.html
   [572]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_psr@psr2-primary-render.html

  * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270:
    - shard-dg2:          [SKIP][573] ([i915#12755] / [i915#15867] / [i915#5190]) -> [SKIP][574] ([i915#15867] / [i915#5190])
   [573]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg2-4/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html
   [574]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg2-10/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html

  * igt@kms_scaling_modes@scaling-mode-none:
    - shard-rkl:          [SKIP][575] ([i915#14544] / [i915#3555]) -> [SKIP][576] ([i915#3555]) +2 other tests skip
   [575]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_scaling_modes@scaling-mode-none.html
   [576]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-7/igt@kms_scaling_modes@scaling-mode-none.html

  * igt@kms_vrr@flip-basic-fastset:
    - shard-rkl:          [SKIP][577] ([i915#14544] / [i915#9906]) -> [SKIP][578] ([i915#9906])
   [577]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@kms_vrr@flip-basic-fastset.html
   [578]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-8/igt@kms_vrr@flip-basic-fastset.html

  * igt@kms_vrr@seamless-rr-switch-drrs:
    - shard-dg1:          [SKIP][579] ([i915#9906]) -> [SKIP][580] ([i915#4423] / [i915#9906])
   [579]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-dg1-12/igt@kms_vrr@seamless-rr-switch-drrs.html
   [580]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-dg1-19/igt@kms_vrr@seamless-rr-switch-drrs.html

  * igt@prime_vgem@coherency-gtt:
    - shard-rkl:          [SKIP][581] ([i915#14544] / [i915#3708]) -> [SKIP][582] ([i915#3708])
   [581]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@prime_vgem@coherency-gtt.html
   [582]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-3/igt@prime_vgem@coherency-gtt.html

  * igt@sriov_basic@enable-vfs-bind-unbind-each-numvfs-all:
    - shard-rkl:          [SKIP][583] ([i915#14544] / [i915#9917]) -> [SKIP][584] ([i915#9917])
   [583]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8829/shard-rkl-6/igt@sriov_basic@enable-vfs-bind-unbind-each-numvfs-all.html
   [584]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/shard-rkl-4/igt@sriov_basic@enable-vfs-bind-unbind-each-numvfs-all.html

  
  [i915#10056]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10056
  [i915#10307]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10307
  [i915#10433]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10433
  [i915#10434]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10434
  [i915#10538]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10538
  [i915#10553]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10553
  [i915#10647]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/10647
  [i915#1072]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1072
  [i915#1099]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1099
  [i915#11078]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11078
  [i915#11151]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11151
  [i915#11520]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11520
  [i915#11527]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11527
  [i915#11681]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11681
  [i915#11815]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/11815
  [i915#1187]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1187
  [i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061
  [i915#12169]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12169
  [i915#12178]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12178
  [i915#12313]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12313
  [i915#12314]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12314
  [i915#12316]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12316
  [i915#12343]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12343
  [i915#12392]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12392
  [i915#12454]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12454
  [i915#12712]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12712
  [i915#12713]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12713
  [i915#12745]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12745
  [i915#12755]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12755
  [i915#12805]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12805
  [i915#13029]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13029
  [i915#13046]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13046
  [i915#13049]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13049
  [i915#13331]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13331
  [i915#13356]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13356
  [i915#13363]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13363
  [i915#13566]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13566
  [i915#13688]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13688
  [i915#13707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13707
  [i915#13748]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13748
  [i915#13749]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13749
  [i915#13781]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13781
  [i915#13783]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13783
  [i915#13809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13809
  [i915#13958]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/13958
  [i915#14033]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14033
  [i915#14073]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14073
  [i915#14098]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14098
  [i915#14118]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14118
  [i915#14259]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14259
  [i915#14350]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14350
  [i915#14419]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14419
  [i915#14498]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14498
  [i915#14544]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14544
  [i915#14545]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14545
  [i915#14694]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14694
  [i915#14712]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/14712
  [i915#15060]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15060
  [i915#15073]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15073
  [i915#15102]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15102
  [i915#15104]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15104
  [i915#15106]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15106
  [i915#15128]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15128
  [i915#15131]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15131
  [i915#15132]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15132
  [i915#15152]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15152
  [i915#15172]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15172
  [i915#15243]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15243
  [i915#15314]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15314
  [i915#15329]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15329
  [i915#15330]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15330
  [i915#15342]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15342
  [i915#15365]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15365
  [i915#15389]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15389
  [i915#15433]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15433
  [i915#15458]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15458
  [i915#15459]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15459
  [i915#15460]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15460
  [i915#15478]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15478
  [i915#15481]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15481
  [i915#15560]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15560
  [i915#15582]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15582
  [i915#15643]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15643
  [i915#15652]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15652
  [i915#15662]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15662
  [i915#15672]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15672
  [i915#15678]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15678
  [i915#15709]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15709
  [i915#15726]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15726
  [i915#15733]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15733
  [i915#15739]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15739
  [i915#15778]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15778
  [i915#15804]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15804
  [i915#15865]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15865
  [i915#15867]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15867
  [i915#1769]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1769
  [i915#1825]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1825
  [i915#1839]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/1839
  [i915#2434]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2434
  [i915#2527]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2527
  [i915#280]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/280
  [i915#2856]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/2856
  [i915#3023]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3023
  [i915#3116]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3116
  [i915#3281]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3281
  [i915#3282]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3282
  [i915#3291]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3291
  [i915#3297]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3297
  [i915#3299]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3299
  [i915#3323]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3323
  [i915#3458]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3458
  [i915#3469]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3469
  [i915#3539]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3539
  [i915#3555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3555
  [i915#3637]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3637
  [i915#3638]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3638
  [i915#3708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3708
  [i915#3742]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3742
  [i915#3804]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3804
  [i915#3828]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3828
  [i915#3840]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3840
  [i915#3936]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3936
  [i915#3955]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/3955
  [i915#4077]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4077
  [i915#4079]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4079
  [i915#4083]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4083
  [i915#4103]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4103
  [i915#4212]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4212
  [i915#4213]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4213
  [i915#4215]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4215
  [i915#4270]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4270
  [i915#4349]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4349
  [i915#4387]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4387
  [i915#4423]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4423
  [i915#4525]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4525
  [i915#4538]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4538
  [i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613
  [i915#4767]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4767
  [i915#4771]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4771
  [i915#4812]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4812
  [i915#4817]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4817
  [i915#4839]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4839
  [i915#4852]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4852
  [i915#4860]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4860
  [i915#4880]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4880
  [i915#4885]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4885
  [i915#5138]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5138
  [i915#5190]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5190
  [i915#5286]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5286
  [i915#5289]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5289
  [i915#5354]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5354
  [i915#5439]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5439
  [i915#5956]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/5956
  [i915#6095]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6095
  [i915#6113]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6113
  [i915#6187]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6187
  [i915#6245]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6245
  [i915#6335]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6335
  [i915#6880]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6880
  [i915#6953]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/6953
  [i915#7173]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7173
  [i915#7276]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7276
  [i915#7387]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7387
  [i915#7582]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7582
  [i915#7697]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7697
  [i915#7707]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7707
  [i915#7828]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7828
  [i915#7862]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7862
  [i915#7984]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/7984
  [i915#8228]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8228
  [i915#8399]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8399
  [i915#8411]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8411
  [i915#8428]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8428
  [i915#8555]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8555
  [i915#8623]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8623
  [i915#8708]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8708
  [i915#8808]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8808
  [i915#8809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8809
  [i915#8812]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8812
  [i915#8814]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8814
  [i915#8823]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8823
  [i915#8898]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/8898
  [i915#9337]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9337
  [i915#9531]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9531
  [i915#9683]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9683
  [i915#9685]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9685
  [i915#9688]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9688
  [i915#9723]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9723
  [i915#9732]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9732
  [i915#9766]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9766
  [i915#9809]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9809
  [i915#9833]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9833
  [i915#9906]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9906
  [i915#9917]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9917
  [i915#9934]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/9934


Build changes
-------------

  * CI: CI-20190529 -> None
  * IGT: IGT_8829 -> IGTPW_14855

  CI-20190529: 20190529
  CI_DRM_18214: ec0484d20b9f962d04a62ff1feb03676c3ce7611 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_14855: 14855
  IGT_8829: 8829

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14855/index.html

[-- Attachment #2: Type: text/html, Size: 193221 bytes --]

Re: [PATCH i-g-t v6 1/9] drm-uapi/xe_drm: Add UAPI support for purgeable buffer objects

[Sharma, Nishit]

It should be like:

drm-uapi/xe: Sync with Add UAPI support for purgeable buffer object

     Align with kernel commit f99a05cc0b85fadd109fb3250fceccc5eaad3830 
("drm/xe/uapi: Extend the DRM_XE_MADVISE ioctl to support purgeable 
buffer object
     management by adding DRM_XE_VMA_ATTR_PURGEABLE_STATE attribute typ").

In IGT you'll be using header from KMD so need to mention alignment with 
KMD commit.

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> Extend the DRM_XE_MADVISE ioctl

Re: [PATCH i-g-t v6 1/9] drm-uapi/xe_drm: Add UAPI support for purgeable buffer objects

[Yadav, Arvind]

On 06-04-2026 10:53, Sharma, Nishit wrote:
> It should be like:
>
> drm-uapi/xe: Sync with Add UAPI support for purgeable buffer object
>
>     Align with kernel commit f99a05cc0b85fadd109fb3250fceccc5eaad3830 
> ("drm/xe/uapi: Extend the DRM_XE_MADVISE ioctl to support purgeable 
> buffer object
>     management by adding DRM_XE_VMA_ATTR_PURGEABLE_STATE attribute typ").
>
> In IGT you'll be using header from KMD so need to mention alignment 
> with KMD commit.


Noted. Since the kernel changes were not merged, I will add this to the 
commit message

~Arvind

>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> Extend the DRM_XE_MADVISE ioctl

Re: [PATCH i-g-t v6 2/9] lib/xe: Add purgeable memory ioctl support

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> Add xe_vm_madvise_purgeable() helper function to support purgeable
> memory management through the XE madvise ioctl. This allows applications
> to hint to the kernel about buffer object usage patterns for better
> memory management under pressure.
>
> The function provides a clean interface to:
> - Mark buffer objects as DONTNEED (purgeable)
> - Mark buffer objects as WILLNEED (not purgeable)
>
> Returns the retained value directly (1 if backing store exists, 0 if
> purged).
>
> Also update __xe_vm_madvise() to reject purgeable state operations
> and direct users to the dedicated helper.

Here you can also mention why this new ioctl when __xe_vm_madvise() 
already available.

You can mention the changes required.

>
> v2:
>    - retained must be initialized to 0(Thomas)
>
> v5:
>    - Rename retained to retained_ptr. (Jose)
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   lib/xe/xe_ioctl.c | 33 +++++++++++++++++++++++++++++++++
>   lib/xe/xe_ioctl.h |  2 ++
>   2 files changed, 35 insertions(+)
>
> diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
> index ea3f2fcaa..955607f93 100644
> --- a/lib/xe/xe_ioctl.c
> +++ b/lib/xe/xe_ioctl.c
> @@ -785,6 +785,9 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
>   	case DRM_XE_MEM_RANGE_ATTR_PAT:
>   		madvise.pat_index.val = op_val;
>   		break;
> +	case DRM_XE_VMA_ATTR_PURGEABLE_STATE:
> +		/* Purgeable state handled by xe_vm_madvise_purgeable */
> +		return -EINVAL;
>   	default:
>   		igt_warn("Unknown attribute\n");
>   		return -EINVAL;
> @@ -821,6 +824,36 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
>   				      instance), 0);
>   }
>   
> +/**
> + * xe_vm_madvise_purgeable:
> + * @fd: xe device fd
> + * @vm_id: vm_id of the virtual range
> + * @start: start of the virtual address range
> + * @range: size of the virtual address range
> + * @state: purgeable state (DRM_XE_VMA_PURGEABLE_STATE_WILLNEED or DONTNEED)
> + *
> + * Sets the purgeable state for a virtual memory range. This allows applications
> + * to hint to the kernel about buffer object usage patterns for better memory management.
> + *
> + * Returns: retained value (1 if backing store exists, 0 if purged)
> + */
> +uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t start,
> +				 uint64_t range, uint32_t state)
> +{
> +	uint32_t retained_val = 0;
> +	struct drm_xe_madvise madvise = {
> +		.vm_id = vm_id,
> +		.start = start,
> +		.range = range,
> +		.type = DRM_XE_VMA_ATTR_PURGEABLE_STATE,
> +		.purge_state_val.val = state,
> +		.purge_state_val.retained_ptr = (uint64_t)(uintptr_t)&retained_val,
> +	};
> +
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_MADVISE, &madvise), 0);
> +	return retained_val;
> +}
> +
>   #define	BIND_SYNC_VAL	0x686868
>   void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
>   			uint64_t addr, uint64_t size, uint32_t flags)
> diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
> index b62d259fd..a02d68cfe 100644
> --- a/lib/xe/xe_ioctl.h
> +++ b/lib/xe/xe_ioctl.h
> @@ -108,6 +108,8 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t
>   		    uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
>   void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range, uint64_t ext,
>   		   uint32_t type, uint32_t op_val, uint16_t policy, uint16_t instance);
> +uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t start,
> +				 uint64_t range, uint32_t state);
>   int xe_vm_number_vmas_in_range(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr);
>   int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr *vmas_attr,
>   		    struct drm_xe_mem_range_attr *mem_attr);

with above change in commit message LGTM:

Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>

Re: [PATCH i-g-t v6 3/9] tests/intel/xe_madvise: Add dontneed-before-mmap subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test validates that mmap() fails with -EBUSY when attempting to
> map a BO marked DONTNEED. The mmap offset ioctl succeeds (it just
> returns the pre-allocated offset); the purgeable check happens in
> xe_gem_object_mmap() at mmap() time.
>
>    - DONTNEED BOs: return -EBUSY (temporary purgeable state, BO still
>      has backing store but can be purged at any time)
>    - Purged BOs: return -EINVAL (permanent, backing store discarded)
>
> v4:
>    - Move unmap outside the block. (Pravalika)
>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>    - Added assertion for xe_bo_map. (Nishit)
>
> v5:
>    - Add kernel capability check *_FLAG_HAS_PURGING_SUPPORT for
>      purgeable support. (Jose)
>    - Drop memory pressure trigger path; mark DONTNEED directly and
>      assert -EBUSY from mmap offset ioctl; restore WILLNEED before
>      cleanup.
>
> v6:
>    - Support iGPU by using total system RAM as the pressure baseline
>      instead of VRAM size (which is 0 on iGPU).
>    - Raise overpressure from 25% to 50% of the baseline to ensure the
>      kernel shrinker is forced to reclaim on systems with large free RAM.
>    - The DONTNEED enforcement point is mmap() itself, not the
>      DRM_IOCTL_XE_GEM_MMAP_OFFSET ioctl. Update the test to mark DONTNEED
>      first, then verify DRM_IOCTL_XE_GEM_MMAP_OFFSET still succeeds, and
>      finally verify that mmap() fails with -EBUSY
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 233 +++++++++++++++++++++++++++++++++++++++
>   tests/meson.build        |   1 +
>   2 files changed, 234 insertions(+)
>   create mode 100644 tests/intel/xe_madvise.c
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> new file mode 100644
> index 000000000..de4a6e34c
> --- /dev/null
> +++ b/tests/intel/xe_madvise.c
> @@ -0,0 +1,233 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright © 2025 Intel Corporation
> + */
> +
> +/**
> + * TEST: Validate purgeable BO madvise functionality
> + * Category: Core
> + * Mega feature: General Core features
> + * Sub-category: Memory management tests
> + * Functionality: madvise, purgeable
> + */
> +
> +#include "igt.h"
> +#include "xe_drm.h"
> +
> +#include "xe/xe_ioctl.h"
> +#include "xe/xe_query.h"
> +
> +static bool xe_has_purgeable_support(int fd)
> +{
> +	struct drm_xe_query_config *config = xe_config(fd);
> +
> +	return config->info[DRM_XE_QUERY_CONFIG_FLAGS] &
> +		DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT;
> +}
> +
> +/* Purgeable test constants */
> +#define PURGEABLE_ADDR		0x1a0000
> +#define PURGEABLE_BO_SIZE	4096
> +
> +/**
> + * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable reclaim
> + * @fd: DRM file descriptor
> + * @vm: VM handle (unused, kept for API compatibility)
> + *
> + * Allocates BOs in a temporary VM until memory is overcommitted by 50%,
> + * forcing the kernel to purge DONTNEED-marked BOs.
> + */
> +static void trigger_memory_pressure(int fd, uint32_t vm)
> +{
> +	uint64_t vram_size, mem_size, overpressure;
> +	const uint64_t chunk = 8ull << 20; /* 8 MiB */
> +	int max_objs, n = 0;
> +	uint32_t *handles;
> +	uint64_t total;
> +	void *p;
> +	uint32_t handle, temp_vm;
> +
> +	/* Use a separate VM so pressure BOs don't affect the test VM */
> +	temp_vm = xe_vm_create(fd, 0, 0);
> +
> +	vram_size = xe_visible_vram_size(fd, 0);
> +	if (vram_size > 0) {
> +		/* dGPU: pressure VRAM to trigger purgeable reclaim */
> +		mem_size = vram_size;
> +	} else {
> +		/*
> +		 * iGPU: purgeable BOs reside in system memory. Use *total*
> +		 * RAM (not just available) as the baseline so that we always
> +		 * over-commit regardless of how much is already in use.
> +		 */
> +		mem_size = igt_get_total_ram_mb() << 20;
> +	}
> +
> +	/* Scale overpressure to 50% of memory, minimum 64MB */
> +	overpressure = mem_size / 2;
> +	if (overpressure < (64 << 20))
> +		overpressure = 64 << 20;
> +
> +	max_objs = (mem_size + overpressure) / chunk + 1;
> +	handles = malloc(max_objs * sizeof(*handles));
> +	igt_assert(handles);
> +
> +	total = 0;
> +	while (total < mem_size + overpressure && n < max_objs) {
> +		uint32_t err;
> +
> +		err = __xe_bo_create(fd, temp_vm, chunk,
> +				     vram_if_possible(fd, 0),
> +				     DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
> +				     NULL, &handle);
> +		if (err) /* Out of memory — sufficient pressure achieved */
> +			break;
> +
> +		handles[n++] = handle;
> +		total += chunk;
> +
> +		p = xe_bo_map(fd, handle, chunk);
> +		igt_assert(p != MAP_FAILED);
> +
> +		/* Fault in all pages so they actually consume memory */
> +		memset(p, 0xCD, chunk);
> +		munmap(p, chunk);
> +	}
> +
> +	/* Allow shrinker time to process pressure */
> +	usleep(100000);
> +
> +	for (int i = 0; i < n; i++)
> +		gem_close(fd, handles[i]);
> +
> +	free(handles);
> +
> +	xe_vm_destroy(fd, temp_vm);
> +}
This function is called from below function which is not part of this 
Patch-3/9. This must be removed and introduced in Patch-4/9.
> +
> +static jmp_buf jmp;
> +
> +__noreturn static void sigtrap(int sig)
> +{
> +	siglongjmp(jmp, sig);
> +}
> +
> +/**
> + * purgeable_mark_and_verify_purged - Mark DONTNEED, pressure, check purged
> + * @fd: DRM file descriptor
> + * @vm: VM handle
> + * @addr: Virtual address of the BO
> + * @size: Size of the BO
> + *
> + * Returns true if the BO was purged under memory pressure.
> + */
> +static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, uint64_t addr, size_t size)
> +{
> +	uint32_t retained;
> +
> +	/* Mark as DONTNEED */
> +	retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	if (retained != 1)
> +		return false;
> +
> +	/* Trigger memory pressure */
> +	trigger_memory_pressure(fd, vm);
> +
> +	/* Verify purged */
> +	retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> +	return retained == 0;
> +}
This function is introduced in test_dontneed_after_mmap() in Patch-4/9. 
Remove this and introduced in Patch-4/9.
> +
> +/**
> + * purgeable_setup_simple_bo - Setup VM and bind a single BO
> + * @fd: DRM file descriptor
> + * @vm: Output VM handle
> + * @bo: Output BO handle
> + * @addr: Virtual address to bind at
> + * @size: Size of the BO
> + * @use_scratch: Whether to use scratch page flag
> + *
> + * Helper to create VM, BO, and bind it at the specified address.
> + */
> +static void purgeable_setup_simple_bo(int fd, uint32_t *vm, uint32_t *bo,
> +				      uint64_t addr, size_t size, bool use_scratch)
> +{
> +	struct drm_xe_sync sync = {
> +		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		.timeline_value = 1,
> +	};
> +	uint64_t sync_val = 0;
> +
> +	*vm = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
> +	*bo = xe_bo_create(fd, *vm, size, vram_if_possible(fd, 0),
> +			   DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
> +
> +	sync.addr = to_user_pointer(&sync_val);
> +	xe_vm_bind_async(fd, *vm, 0, *bo, 0, addr, size, &sync, 1);
> +	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
> +}
> +
> +/**
> + * SUBTEST: dontneed-before-mmap
> + * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
> + * Test category: functionality test
> + */
> +static void test_dontneed_before_mmap(int fd)
> +{
> +	uint32_t bo, vm;
> +	uint64_t addr = PURGEABLE_ADDR;
> +	size_t bo_size = PURGEABLE_BO_SIZE;
> +	struct drm_xe_gem_mmap_offset mmo = {};
> +	uint32_t retained;
> +	void *ptr;
> +
> +	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
> +
> +	/* Mark BO as DONTNEED - new mmap operations must be blocked */
> +	retained = xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/* Ioctl succeeds even for DONTNEED BO; blocking happens at mmap() time. */
> +	mmo.handle = bo;
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 0);
> +
> +	/* mmap() on a DONTNEED BO must fail with EBUSY. */
> +	ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mmo.offset);
> +	igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
> +	igt_assert_eq(errno, EBUSY);
> +
> +	/* Restore to WILLNEED before cleanup */
> +	xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
> +				DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> +
> +	gem_close(fd, bo);
> +	xe_vm_destroy(fd, vm);
> +}
> +
> +int igt_main()
> +{
> +	struct drm_xe_engine_class_instance *hwe;
> +	int fd;
> +
> +	igt_fixture() {
> +		fd = drm_open_driver(DRIVER_XE);
> +		xe_device_get(fd);
> +		igt_require_f(xe_has_purgeable_support(fd),
> +			      "Kernel does not support purgeable buffer objects\n");
> +	}
> +
> +	igt_subtest("dontneed-before-mmap")
> +		xe_for_each_engine(fd, hwe) {
> +			test_dontneed_before_mmap(fd);
> +			break;
> +		}
> +
> +	igt_fixture() {
> +		xe_device_put(fd);
> +		drm_close_driver(fd);
> +	}
> +}
> diff --git a/tests/meson.build b/tests/meson.build
> index cecb4a8ae..a6370b685 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -314,6 +314,7 @@ intel_xe_progs = [
>   	'xe_huc_copy',
>   	'xe_intel_bb',
>   	'xe_live_ktest',
> +	'xe_madvise',
>   	'xe_media_fill',
>   	'xe_mmap',
>           'xe_module_load',

Re: [PATCH i-g-t v6 3/9] tests/intel/xe_madvise: Add dontneed-before-mmap subtest

[Sharma, Nishit]

On 4/6/2026 3:23 PM, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> This test validates that mmap() fails with -EBUSY when attempting to
>> map a BO marked DONTNEED. The mmap offset ioctl succeeds (it just
>> returns the pre-allocated offset); the purgeable check happens in
>> xe_gem_object_mmap() at mmap() time.
>>
>>    - DONTNEED BOs: return -EBUSY (temporary purgeable state, BO still
>>      has backing store but can be purged at any time)
>>    - Purged BOs: return -EINVAL (permanent, backing store discarded)
>>
>> v4:
>>    - Move unmap outside the block. (Pravalika)
>>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>>    - Added assertion for xe_bo_map. (Nishit)
>>
>> v5:
>>    - Add kernel capability check *_FLAG_HAS_PURGING_SUPPORT for
>>      purgeable support. (Jose)
>>    - Drop memory pressure trigger path; mark DONTNEED directly and
>>      assert -EBUSY from mmap offset ioctl; restore WILLNEED before
>>      cleanup.
>>
>> v6:
>>    - Support iGPU by using total system RAM as the pressure baseline
>>      instead of VRAM size (which is 0 on iGPU).
>>    - Raise overpressure from 25% to 50% of the baseline to ensure the
>>      kernel shrinker is forced to reclaim on systems with large free 
>> RAM.
>>    - The DONTNEED enforcement point is mmap() itself, not the
>>      DRM_IOCTL_XE_GEM_MMAP_OFFSET ioctl. Update the test to mark 
>> DONTNEED
>>      first, then verify DRM_IOCTL_XE_GEM_MMAP_OFFSET still succeeds, and
>>      finally verify that mmap() fails with -EBUSY
>>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> 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>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 233 +++++++++++++++++++++++++++++++++++++++
>>   tests/meson.build        |   1 +
>>   2 files changed, 234 insertions(+)
>>   create mode 100644 tests/intel/xe_madvise.c
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> new file mode 100644
>> index 000000000..de4a6e34c
>> --- /dev/null
>> +++ b/tests/intel/xe_madvise.c
>> @@ -0,0 +1,233 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright © 2025 Intel Corporation
>> + */
>> +
>> +/**
>> + * TEST: Validate purgeable BO madvise functionality
>> + * Category: Core
>> + * Mega feature: General Core features
>> + * Sub-category: Memory management tests
>> + * Functionality: madvise, purgeable
>> + */
>> +
>> +#include "igt.h"
>> +#include "xe_drm.h"
>> +
>> +#include "xe/xe_ioctl.h"
>> +#include "xe/xe_query.h"
>> +
>> +static bool xe_has_purgeable_support(int fd)
>> +{
>> +    struct drm_xe_query_config *config = xe_config(fd);
>> +
>> +    return config->info[DRM_XE_QUERY_CONFIG_FLAGS] &
>> +        DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT;
>> +}
>> +
>> +/* Purgeable test constants */
>> +#define PURGEABLE_ADDR        0x1a0000
>> +#define PURGEABLE_BO_SIZE    4096
>> +
>> +/**
>> + * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable 
>> reclaim
>> + * @fd: DRM file descriptor
>> + * @vm: VM handle (unused, kept for API compatibility)
>> + *
>> + * Allocates BOs in a temporary VM until memory is overcommitted by 
>> 50%,
>> + * forcing the kernel to purge DONTNEED-marked BOs.
>> + */
>> +static void trigger_memory_pressure(int fd, uint32_t vm)
>> +{
>> +    uint64_t vram_size, mem_size, overpressure;
>> +    const uint64_t chunk = 8ull << 20; /* 8 MiB */
>> +    int max_objs, n = 0;
>> +    uint32_t *handles;
>> +    uint64_t total;
>> +    void *p;
>> +    uint32_t handle, temp_vm;
>> +
>> +    /* Use a separate VM so pressure BOs don't affect the test VM */
>> +    temp_vm = xe_vm_create(fd, 0, 0);
>> +
>> +    vram_size = xe_visible_vram_size(fd, 0);
>> +    if (vram_size > 0) {
>> +        /* dGPU: pressure VRAM to trigger purgeable reclaim */
>> +        mem_size = vram_size;
>> +    } else {
>> +        /*
>> +         * iGPU: purgeable BOs reside in system memory. Use *total*
>> +         * RAM (not just available) as the baseline so that we always
>> +         * over-commit regardless of how much is already in use.
>> +         */
>> +        mem_size = igt_get_total_ram_mb() << 20;
>> +    }
>> +
>> +    /* Scale overpressure to 50% of memory, minimum 64MB */
>> +    overpressure = mem_size / 2;
>> +    if (overpressure < (64 << 20))
>> +        overpressure = 64 << 20;
>> +
>> +    max_objs = (mem_size + overpressure) / chunk + 1;
>> +    handles = malloc(max_objs * sizeof(*handles));
>> +    igt_assert(handles);
>> +
>> +    total = 0;
>> +    while (total < mem_size + overpressure && n < max_objs) {
>> +        uint32_t err;
>> +
>> +        err = __xe_bo_create(fd, temp_vm, chunk,
>> +                     vram_if_possible(fd, 0),
>> +                     DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
>> +                     NULL, &handle);
>> +        if (err) /* Out of memory — sufficient pressure achieved */
>> +            break;
>> +
>> +        handles[n++] = handle;
>> +        total += chunk;
>> +
>> +        p = xe_bo_map(fd, handle, chunk);
>> +        igt_assert(p != MAP_FAILED);
>> +
>> +        /* Fault in all pages so they actually consume memory */
>> +        memset(p, 0xCD, chunk);
>> +        munmap(p, chunk);
>> +    }
>> +
>> +    /* Allow shrinker time to process pressure */
>> +    usleep(100000);
>> +
>> +    for (int i = 0; i < n; i++)
>> +        gem_close(fd, handles[i]);
>> +
>> +    free(handles);
>> +
>> +    xe_vm_destroy(fd, temp_vm);
>> +}
> This function is called from below function which is not part of this 
> Patch-3/9. This must be removed and introduced in Patch-4/9.
>> +
>> +static jmp_buf jmp;
>> +
>> +__noreturn static void sigtrap(int sig)
>> +{
>> +    siglongjmp(jmp, sig);
>> +}
>> +
>> +/**
>> + * purgeable_mark_and_verify_purged - Mark DONTNEED, pressure, check 
>> purged
>> + * @fd: DRM file descriptor
>> + * @vm: VM handle
>> + * @addr: Virtual address of the BO
>> + * @size: Size of the BO
>> + *
>> + * Returns true if the BO was purged under memory pressure.
>> + */
>> +static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, 
>> uint64_t addr, size_t size)
>> +{
>> +    uint32_t retained;
>> +
>> +    /* Mark as DONTNEED */
>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    if (retained != 1)
>> +        return false;
>> +
>> +    /* Trigger memory pressure */
>> +    trigger_memory_pressure(fd, vm);
>> +
>> +    /* Verify purged */
>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>> +    return retained == 0;
>> +}
> This function is introduced in test_dontneed_after_mmap() in 
> Patch-4/9. Remove this and introduced in Patch-4/9.
Correction here, this function is called from subtest 
test_purged_mmap_blocked(fd); which is in Patch-4/9. Please move these 
functions in Patch-4/9
>> +
>> +/**
>> + * purgeable_setup_simple_bo - Setup VM and bind a single BO
>> + * @fd: DRM file descriptor
>> + * @vm: Output VM handle
>> + * @bo: Output BO handle
>> + * @addr: Virtual address to bind at
>> + * @size: Size of the BO
>> + * @use_scratch: Whether to use scratch page flag
>> + *
>> + * Helper to create VM, BO, and bind it at the specified address.
>> + */
>> +static void purgeable_setup_simple_bo(int fd, uint32_t *vm, uint32_t 
>> *bo,
>> +                      uint64_t addr, size_t size, bool use_scratch)
>> +{
>> +    struct drm_xe_sync sync = {
>> +        .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>> +        .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>> +        .timeline_value = 1,
>> +    };
>> +    uint64_t sync_val = 0;
>> +
>> +    *vm = xe_vm_create(fd, use_scratch ? 
>> DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
>> +    *bo = xe_bo_create(fd, *vm, size, vram_if_possible(fd, 0),
>> +               DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>> +
>> +    sync.addr = to_user_pointer(&sync_val);
>> +    xe_vm_bind_async(fd, *vm, 0, *bo, 0, addr, size, &sync, 1);
>> +    xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>> +}
>> +
>> +/**
>> + * SUBTEST: dontneed-before-mmap
>> + * Description: Mark BO as DONTNEED before mmap, verify mmap() fails 
>> with -EBUSY
>> + * Test category: functionality test
>> + */
>> +static void test_dontneed_before_mmap(int fd)
>> +{
>> +    uint32_t bo, vm;
>> +    uint64_t addr = PURGEABLE_ADDR;
>> +    size_t bo_size = PURGEABLE_BO_SIZE;
>> +    struct drm_xe_gem_mmap_offset mmo = {};
>> +    uint32_t retained;
>> +    void *ptr;
>> +
>> +    purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
>> +
>> +    /* Mark BO as DONTNEED - new mmap operations must be blocked */
>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /* Ioctl succeeds even for DONTNEED BO; blocking happens at 
>> mmap() time. */
>> +    mmo.handle = bo;
>> +    igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 
>> 0);
>> +
>> +    /* mmap() on a DONTNEED BO must fail with EBUSY. */
>> +    ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, 
>> fd, mmo.offset);
>> +    igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
>> +    igt_assert_eq(errno, EBUSY);
>> +
>> +    /* Restore to WILLNEED before cleanup */
>> +    xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
>> +                DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>> +
>> +    gem_close(fd, bo);
>> +    xe_vm_destroy(fd, vm);
>> +}
>> +
>> +int igt_main()
>> +{
>> +    struct drm_xe_engine_class_instance *hwe;
>> +    int fd;
>> +
>> +    igt_fixture() {
>> +        fd = drm_open_driver(DRIVER_XE);
>> +        xe_device_get(fd);
>> +        igt_require_f(xe_has_purgeable_support(fd),
>> +                  "Kernel does not support purgeable buffer 
>> objects\n");
>> +    }
>> +
>> +    igt_subtest("dontneed-before-mmap")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_dontneed_before_mmap(fd);
>> +            break;
>> +        }
>> +
>> +    igt_fixture() {
>> +        xe_device_put(fd);
>> +        drm_close_driver(fd);
>> +    }
>> +}
>> diff --git a/tests/meson.build b/tests/meson.build
>> index cecb4a8ae..a6370b685 100644
>> --- a/tests/meson.build
>> +++ b/tests/meson.build
>> @@ -314,6 +314,7 @@ intel_xe_progs = [
>>       'xe_huc_copy',
>>       'xe_intel_bb',
>>       'xe_live_ktest',
>> +    'xe_madvise',
>>       'xe_media_fill',
>>       'xe_mmap',
>>           'xe_module_load',

Re: [PATCH i-g-t v6 4/9] tests/intel/xe_madvise: Add purged-mmap-blocked subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> Add a new purged-mmap-blocked subtest that triggers an actual purge
> via memory pressure and verifies that mmap() fails with -EINVAL once
> the BO backing store has been permanently discarded.
>
> The purgeable check moved from xe_gem_mmap_offset_ioctl()
> into a new xe_gem_object_mmap() callback, so the blocking point is now
> mmap() itself rather than the mmap offset ioctl:
>
>    - DRM_IOCTL_XE_GEM_MMAP_OFFSET: always succeeds regardless of
>      purgeable state (just returns the pre-allocated offset)
>    - mmap() on DONTNEED BO: fails with -EBUSY (temporary state)
>    - mmap() on purged BO: fails with -EINVAL (permanent, no backing store)
>
> v5:
>    - Add purged-mmap-blocked subtest to verify mmap is blocked after
>      BO backing store is permanently purged.
>
> v6:
>    - DRM_IOCTL_XE_GEM_MMAP_OFFSET always succeeds; the purgeable check
>      now happens in xe_gem_object_mmap() at mmap() time. For purged BOs,
>      assert mmap() fails with -EINVAL.
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 42 ++++++++++++++++++++++++++++++++++++++++
>   1 file changed, 42 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index de4a6e34c..81e05b6d4 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -170,6 +170,42 @@ static void purgeable_setup_simple_bo(int fd, uint32_t *vm, uint32_t *bo,
>   	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>   }
>   
> +/**
> + * SUBTEST: purged-mmap-blocked
> + * Description: After BO is purged, verify mmap() fails with -EINVAL
> + * Test category: functionality test
> + */
> +static void test_purged_mmap_blocked(int fd)
> +{
> +	uint32_t bo, vm;
> +	uint64_t addr = PURGEABLE_ADDR;
> +	size_t bo_size = PURGEABLE_BO_SIZE;
> +	struct drm_xe_gem_mmap_offset mmo = {};
> +	void *ptr;
> +
> +	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
> +	if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {

This function should be defined in this patch. Going through 
implementation available in Patch-3/9. In that below code used

     vram_size = xe_visible_vram_size(fd, 0);

What it returns in igfx platforms? Instead we can use

/* Purgeable BO either in VRAM or SMEM */
mem_size = xe_has_vram(pf_fd)?xe_visible_vram_size(fd, 
0):igt_get_total_ram_mb() << 20;
         if (vram_size > 0) {
                 /* dGPU: pressure VRAM to trigger purgeable reclaim */
                 mem_size = vram_size;
         } else {
                 /*
                  * iGPU: purgeable BOs reside in system memory. Use *total*
                  * RAM (not just available) as the baseline so that we 
always
                  * over-commit regardless of how much is already in use.
                  */
                 mem_size = igt_get_total_ram_mb() << 20;
         }

> +		gem_close(fd, bo);
> +		xe_vm_destroy(fd, vm);
> +		igt_skip("Unable to induce purge on this platform/config");
> +	}
static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, 
uint64_t addr, size_t size) --> this should be part of this patch
{
         uint32_t retained;

         /* Mark as DONTNEED */
         retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
  DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);

         if (retained != 1)

So here if BO was purged after above call it'll return 0, so if (0 != 1) 
will be true and it'll return false.

                 return false;

         /* Trigger memory pressure */
         trigger_memory_pressure(fd, vm);

         /* Verify purged */
         retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
  DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
         return retained == 0;

}

static void test_purged_mmap_blocked(int fd)
{
         uint32_t bo, vm;
         uint64_t addr = PURGEABLE_ADDR;
         size_t bo_size = PURGEABLE_BO_SIZE;
         struct drm_xe_gem_mmap_offset mmo = {};
         void *ptr;

         purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
         if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {

Here if returned false from above which is basically if BO was purged 
retained  = 0 then skip is called which is not the intention
                 gem_close(fd, bo);
                 xe_vm_destroy(fd, vm);
                 igt_skip("Unable to induce purge on this platform/config");
         }

         /*
          * Getting the mmap offset is always allowed regardless of 
purgeable
          * state - the blocking happens at mmap() time 
(xe_gem_object_mmap).
          * For a purged BO, mmap() must fail with -EINVAL (no backing 
store).
          */
         mmo.handle = bo;
         igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, 
&mmo), 0);

         ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, 
fd, mmo.offset);
         igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
         igt_assert_eq(errno, EINVAL);

         gem_close(fd, bo);
         xe_vm_destroy(fd, vm);
}


> +
> +	/*
> +	 * Getting the mmap offset is always allowed regardless of purgeable
> +	 * state - the blocking happens at mmap() time (xe_gem_object_mmap).
> +	 * For a purged BO, mmap() must fail with -EINVAL (no backing store).
> +	 */
> +	mmo.handle = bo;
> +	igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 0);
> +
> +	ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mmo.offset);
> +	igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
> +	igt_assert_eq(errno, EINVAL);
> +
> +	gem_close(fd, bo);
> +	xe_vm_destroy(fd, vm);
> +}
> +
>   /**
>    * SUBTEST: dontneed-before-mmap
>    * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
> @@ -226,6 +262,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("purged-mmap-blocked")
> +		xe_for_each_engine(fd, hwe) {
> +			test_purged_mmap_blocked(fd);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

Re: [PATCH i-g-t v6 5/9] tests/intel/xe_madvise: Add dontneed-after-mmap subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test verifies that an existing mmap becomes invalid after the BO
> is marked as purgeable and purged. The test creates a BO, maps it,
> writes data, then marks it DONTNEED and triggers memory pressure.
> Accessing the previously valid mapping should now trigger SIGBUS or
> SIGSEGV, confirming that existing mappings are correctly invalidated
> when the backing store is purged.
>
> v4:
>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>    - Added assertion for xe_bo_map. (Nishit)
>
> v6:
>    - Fix sigsetjmp(jmp, SIGBUS | SIGSEGV) to sigsetjmp(jmp, 1). The
>      second argument is a plain boolean savemask, not a signal set.
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 64 ++++++++++++++++++++++++++++++++++++++++
>   1 file changed, 64 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index 81e05b6d4..9a157de1d 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -244,6 +244,64 @@ static void test_dontneed_before_mmap(int fd)
>   	xe_vm_destroy(fd, vm);
>   }
>   
> +/**
> + * SUBTEST: dontneed-after-mmap
> + * Description: Mark BO as DONTNEED after mmap, verify SIGBUS on accessing purged mapping
> + * Test category: functionality test
> + */
> +static void test_dontneed_after_mmap(int fd)
> +{
> +	uint32_t bo, vm;
> +	uint64_t addr = PURGEABLE_ADDR;
> +	size_t bo_size = PURGEABLE_BO_SIZE;
> +	void *map;
> +
> +	purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, true);
> +
> +	map = xe_bo_map(fd, bo, bo_size);
> +	igt_assert(map != MAP_FAILED);
> +	memset(map, 0xAB, bo_size);
> +
> +	if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
same comment as in Patch-4/9
> +		munmap(map, bo_size);
> +		gem_close(fd, bo);
> +		xe_vm_destroy(fd, vm);
> +		igt_skip("Unable to induce purge on this platform/config");
> +	}
> +
> +	/* Access purged mapping - should trigger SIGBUS/SIGSEGV */
> +	{
> +		sighandler_t old_sigsegv, old_sigbus;
> +		char *ptr = (char *)map;
> +		int sig;
> +
> +		old_sigsegv = signal(SIGSEGV, (__sighandler_t)sigtrap);
> +		old_sigbus = signal(SIGBUS, (__sighandler_t)sigtrap);
> +
> +		sig = sigsetjmp(jmp, 1); /* savemask=1: save/restore signal mask */
> +		switch (sig) {
> +		case SIGBUS:
> +		case SIGSEGV:
> +			/* Expected - purged mapping access failed */
> +			break;
> +		case 0:
> +			*ptr = 0;
> +		default:
> +			igt_assert_f(false,
> +				     "Access to purged mapping should trigger SIGBUS, got sig=%d\n",
> +				     sig);
> +			break;
> +		}
> +
> +		signal(SIGBUS, old_sigbus);
> +		signal(SIGSEGV, old_sigsegv);
> +	}
> +
> +	munmap(map, bo_size);
> +	gem_close(fd, bo);
> +	xe_vm_destroy(fd, vm);
> +}
> +
>   int igt_main()
>   {
>   	struct drm_xe_engine_class_instance *hwe;
> @@ -268,6 +326,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("dontneed-after-mmap")
> +		xe_for_each_engine(fd, hwe) {
> +			test_dontneed_after_mmap(fd);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

Re: [PATCH i-g-t v6 6/9] tests/intel/xe_madvise: Add dontneed-before-exec subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test validates GPU execution behavior when a data BO is purged
> before submission. The test creates a batch that writes to a data BO,
> purges the data BO (while keeping the batch BO valid to avoid GPU
> reset), then submits for execution. With VM_CREATE_FLAG_SCRATCH_PAGE,
> the GPU write may succeed by landing on scratch memory instead of the
> purged BO, demonstrating graceful handling of purged memory during
> GPU operations.
>
> v4:
>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Reviewed-by: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 148 +++++++++++++++++++++++++++++++++++++++
>   1 file changed, 148 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index 9a157de1d..d126db9ed 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -27,7 +27,11 @@ static bool xe_has_purgeable_support(int fd)
>   
>   /* Purgeable test constants */
>   #define PURGEABLE_ADDR		0x1a0000
> +#define PURGEABLE_BATCH_ADDR	0x3c0000
>   #define PURGEABLE_BO_SIZE	4096
> +#define PURGEABLE_FENCE_VAL	0xbeef
> +#define PURGEABLE_TEST_PATTERN	0xc0ffee
> +#define PURGEABLE_DEAD_PATTERN	0xdead
>   
>   /**
>    * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable reclaim
> @@ -206,6 +210,62 @@ static void test_purged_mmap_blocked(int fd)
>   	xe_vm_destroy(fd, vm);
>   }
>   
> +/**
> + * purgeable_setup_batch_and_data - Setup VM with batch and data BOs for GPU exec
> + * @fd: DRM file descriptor
> + * @vm: Output VM handle
> + * @bind_engine: Output bind engine handle
> + * @batch_bo: Output batch BO handle
> + * @data_bo: Output data BO handle
> + * @batch: Output batch buffer pointer
> + * @data: Output data buffer pointer
> + * @batch_addr: Batch virtual address
> + * @data_addr: Data virtual address
> + * @batch_size: Batch buffer size
> + * @data_size: Data buffer size
> + *
> + * Helper to create VM, bind engine, batch and data BOs, and bind them.
> + */
> +static void purgeable_setup_batch_and_data(int fd, uint32_t *vm,
> +					   uint32_t *bind_engine,
> +					   uint32_t *batch_bo,
> +					   uint32_t *data_bo,
> +					   uint32_t **batch,
> +					   uint32_t **data,
> +					   uint64_t batch_addr,
> +					   uint64_t data_addr,
> +					   size_t batch_size,
> +					   size_t data_size)
> +{
> +	struct drm_xe_sync sync = {
> +		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		.timeline_value = PURGEABLE_FENCE_VAL,
> +	};
> +	uint64_t vm_sync = 0;
> +
> +	*vm = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE, 0);
> +	*bind_engine = xe_bind_exec_queue_create(fd, *vm, 0);
> +
> +	/* Create and bind batch BO */
> +	*batch_bo = xe_bo_create(fd, *vm, batch_size, vram_if_possible(fd, 0),
> +				 DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
> +	*batch = xe_bo_map(fd, *batch_bo, batch_size);
> +
> +	sync.addr = to_user_pointer(&vm_sync);
> +	xe_vm_bind_async(fd, *vm, *bind_engine, *batch_bo, 0, batch_addr, batch_size, &sync, 1);
> +	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
> +
> +	/* Create and bind data BO */
> +	*data_bo = xe_bo_create(fd, *vm, data_size, vram_if_possible(fd, 0),
> +				DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
> +	*data = xe_bo_map(fd, *data_bo, data_size);
> +
> +	vm_sync = 0;
> +	xe_vm_bind_async(fd, *vm, *bind_engine, *data_bo, 0, data_addr, data_size, &sync, 1);
> +	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
> +}
> +
>   /**
>    * SUBTEST: dontneed-before-mmap
>    * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
> @@ -302,6 +362,88 @@ static void test_dontneed_after_mmap(int fd)
>   	xe_vm_destroy(fd, vm);
>   }
>   
> +/**
> + * SUBTEST: dontneed-before-exec
> + * Description: Mark BO as DONTNEED before GPU exec, verify GPU behavior with SCRATCH_PAGE
> + * Test category: functionality test
> + */
> +static void test_dontneed_before_exec(int fd, struct drm_xe_engine_class_instance *hwe)
> +{
> +	uint32_t vm, exec_queue, bo, batch_bo, bind_engine;
> +	uint64_t data_addr = PURGEABLE_ADDR;
> +	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
> +	size_t data_size = PURGEABLE_BO_SIZE;
> +	size_t batch_size = PURGEABLE_BO_SIZE;
> +	struct drm_xe_sync sync[1] = {
> +		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		  .timeline_value = PURGEABLE_FENCE_VAL },
> +	};
> +	struct drm_xe_exec exec = {
> +		.num_batch_buffer = 1,
> +		.num_syncs = 1,
> +		.syncs = to_user_pointer(sync),
> +	};
> +	uint32_t *data, *batch;
> +	uint64_t vm_sync = 0;
> +	int b, ret;
> +
> +	purgeable_setup_batch_and_data(fd, &vm, &bind_engine, &batch_bo,
> +				       &bo, &batch, &data, batch_addr,
> +				       data_addr, batch_size, data_size);
> +
> +	/* Prepare batch */
> +	b = 0;
> +	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> +	batch[b++] = data_addr;
> +	batch[b++] = data_addr >> 32;
> +	batch[b++] = PURGEABLE_DEAD_PATTERN;
> +	batch[b++] = MI_BATCH_BUFFER_END;
> +
> +	/* Phase 1: Purge data BO, batch BO still valid */
> +	if (!purgeable_mark_and_verify_purged(fd, vm, data_addr, data_size)) {
Same comment as in patch-4/9.
> +		munmap(data, data_size);
> +		munmap(batch, batch_size);
> +		gem_close(fd, bo);
> +		gem_close(fd, batch_bo);
> +		xe_exec_queue_destroy(fd, bind_engine);
> +		xe_vm_destroy(fd, vm);
> +		igt_skip("Unable to induce purge on this platform/config");
> +	}
> +
> +	exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
> +	exec.exec_queue_id = exec_queue;
> +	exec.address = batch_addr;
> +
> +	vm_sync = 0;
> +	sync[0].addr = to_user_pointer(&vm_sync);
> +
> +	/*
> +	 * VM has SCRATCH_PAGE — exec may succeed with the GPU write
> +	 * landing on scratch instead of the purged data BO.
> +	 */
> +	ret = __xe_exec(fd, &exec);
You can use xe_exec(fd, &exec) which is internally calling __xe_exec() 
and after use xe_wait_fence()
> +	if (ret == 0) {
> +		int64_t timeout = NSEC_PER_SEC;
> +
> +		__xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL,
> +				 exec_queue, &timeout);
> +	}
> +
> +	/*
> +	 * Don't purge the batch BO — GPU would fetch zeroed scratch
> +	 * instructions and trigger an engine reset.
> +	 */
> +
> +	munmap(data, data_size);
> +	munmap(batch, batch_size);
> +	gem_close(fd, bo);
> +	gem_close(fd, batch_bo);
> +	xe_exec_queue_destroy(fd, bind_engine);
> +	xe_exec_queue_destroy(fd, exec_queue);
> +	xe_vm_destroy(fd, vm);
> +}
> +
>   int igt_main()
>   {
>   	struct drm_xe_engine_class_instance *hwe;
> @@ -332,6 +474,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("dontneed-before-exec")
> +		xe_for_each_engine(fd, hwe) {
> +			test_dontneed_before_exec(fd, hwe);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

Re: [PATCH i-g-t v6 2/9] lib/xe: Add purgeable memory ioctl support

[Yadav, Arvind]

On 06-04-2026 12:29, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> Add xe_vm_madvise_purgeable() helper function to support purgeable
>> memory management through the XE madvise ioctl. This allows applications
>> to hint to the kernel about buffer object usage patterns for better
>> memory management under pressure.
>>
>> The function provides a clean interface to:
>> - Mark buffer objects as DONTNEED (purgeable)
>> - Mark buffer objects as WILLNEED (not purgeable)
>>
>> Returns the retained value directly (1 if backing store exists, 0 if
>> purged).
>>
>> Also update __xe_vm_madvise() to reject purgeable state operations
>> and direct users to the dedicated helper.
>
> Here you can also mention why this new ioctl when __xe_vm_madvise() 
> already available.
>
> You can mention the changes required.


Noted, I will update.
The existing __xe_vm_madvise() uses a generic type/op_val pattern that 
maps to a single scalar field (e.g., pat_index.val, atomic.val). 
Purgeable state requires a different ioctl layout — it populates 
purge_state_val.val (the state) and purge_state_val.retained_ptr (an 
output pointer the kernel writes back to), which doesn't fit the generic 
op_val model. so I have added this new one.

Thanks,
Arvind

>
>>
>> v2:
>>    - retained must be initialized to 0(Thomas)
>>
>> v5:
>>    - Rename retained to retained_ptr. (Jose)
>>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> 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>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   lib/xe/xe_ioctl.c | 33 +++++++++++++++++++++++++++++++++
>>   lib/xe/xe_ioctl.h |  2 ++
>>   2 files changed, 35 insertions(+)
>>
>> diff --git a/lib/xe/xe_ioctl.c b/lib/xe/xe_ioctl.c
>> index ea3f2fcaa..955607f93 100644
>> --- a/lib/xe/xe_ioctl.c
>> +++ b/lib/xe/xe_ioctl.c
>> @@ -785,6 +785,9 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t 
>> addr, uint64_t range,
>>       case DRM_XE_MEM_RANGE_ATTR_PAT:
>>           madvise.pat_index.val = op_val;
>>           break;
>> +    case DRM_XE_VMA_ATTR_PURGEABLE_STATE:
>> +        /* Purgeable state handled by xe_vm_madvise_purgeable */
>> +        return -EINVAL;
>>       default:
>>           igt_warn("Unknown attribute\n");
>>           return -EINVAL;
>> @@ -821,6 +824,36 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t 
>> addr, uint64_t range,
>>                         instance), 0);
>>   }
>>   +/**
>> + * xe_vm_madvise_purgeable:
>> + * @fd: xe device fd
>> + * @vm_id: vm_id of the virtual range
>> + * @start: start of the virtual address range
>> + * @range: size of the virtual address range
>> + * @state: purgeable state (DRM_XE_VMA_PURGEABLE_STATE_WILLNEED or 
>> DONTNEED)
>> + *
>> + * Sets the purgeable state for a virtual memory range. This allows 
>> applications
>> + * to hint to the kernel about buffer object usage patterns for 
>> better memory management.
>> + *
>> + * Returns: retained value (1 if backing store exists, 0 if purged)
>> + */
>> +uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t 
>> start,
>> +                 uint64_t range, uint32_t state)
>> +{
>> +    uint32_t retained_val = 0;
>> +    struct drm_xe_madvise madvise = {
>> +        .vm_id = vm_id,
>> +        .start = start,
>> +        .range = range,
>> +        .type = DRM_XE_VMA_ATTR_PURGEABLE_STATE,
>> +        .purge_state_val.val = state,
>> +        .purge_state_val.retained_ptr = 
>> (uint64_t)(uintptr_t)&retained_val,
>> +    };
>> +
>> +    igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_MADVISE, &madvise), 0);
>> +    return retained_val;
>> +}
>> +
>>   #define    BIND_SYNC_VAL    0x686868
>>   void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t 
>> offset,
>>               uint64_t addr, uint64_t size, uint32_t flags)
>> diff --git a/lib/xe/xe_ioctl.h b/lib/xe/xe_ioctl.h
>> index b62d259fd..a02d68cfe 100644
>> --- a/lib/xe/xe_ioctl.h
>> +++ b/lib/xe/xe_ioctl.h
>> @@ -108,6 +108,8 @@ int __xe_vm_madvise(int fd, uint32_t vm, uint64_t 
>> addr, uint64_t range, uint64_t
>>               uint32_t type, uint32_t op_val, uint16_t policy, 
>> uint16_t instance);
>>   void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t 
>> range, uint64_t ext,
>>              uint32_t type, uint32_t op_val, uint16_t policy, 
>> uint16_t instance);
>> +uint32_t xe_vm_madvise_purgeable(int fd, uint32_t vm_id, uint64_t 
>> start,
>> +                 uint64_t range, uint32_t state);
>>   int xe_vm_number_vmas_in_range(int fd, struct 
>> drm_xe_vm_query_mem_range_attr *vmas_attr);
>>   int xe_vm_vma_attrs(int fd, struct drm_xe_vm_query_mem_range_attr 
>> *vmas_attr,
>>               struct drm_xe_mem_range_attr *mem_attr);
>
> with above change in commit message LGTM:
>
> Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>
>

Re: [PATCH i-g-t v6 3/9] tests/intel/xe_madvise: Add dontneed-before-mmap subtest

[Yadav, Arvind]

On 06-04-2026 16:00, Sharma, Nishit wrote:
>
> On 4/6/2026 3:23 PM, Sharma, Nishit wrote:
>>
>> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>>> This test validates that mmap() fails with -EBUSY when attempting to
>>> map a BO marked DONTNEED. The mmap offset ioctl succeeds (it just
>>> returns the pre-allocated offset); the purgeable check happens in
>>> xe_gem_object_mmap() at mmap() time.
>>>
>>>    - DONTNEED BOs: return -EBUSY (temporary purgeable state, BO still
>>>      has backing store but can be purged at any time)
>>>    - Purged BOs: return -EINVAL (permanent, backing store discarded)
>>>
>>> v4:
>>>    - Move unmap outside the block. (Pravalika)
>>>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>>>    - Added assertion for xe_bo_map. (Nishit)
>>>
>>> v5:
>>>    - Add kernel capability check *_FLAG_HAS_PURGING_SUPPORT for
>>>      purgeable support. (Jose)
>>>    - Drop memory pressure trigger path; mark DONTNEED directly and
>>>      assert -EBUSY from mmap offset ioctl; restore WILLNEED before
>>>      cleanup.
>>>
>>> v6:
>>>    - Support iGPU by using total system RAM as the pressure baseline
>>>      instead of VRAM size (which is 0 on iGPU).
>>>    - Raise overpressure from 25% to 50% of the baseline to ensure the
>>>      kernel shrinker is forced to reclaim on systems with large free 
>>> RAM.
>>>    - The DONTNEED enforcement point is mmap() itself, not the
>>>      DRM_IOCTL_XE_GEM_MMAP_OFFSET ioctl. Update the test to mark 
>>> DONTNEED
>>>      first, then verify DRM_IOCTL_XE_GEM_MMAP_OFFSET still succeeds, 
>>> and
>>>      finally verify that mmap() fails with -EBUSY
>>>
>>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>>> 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>
>>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>>> ---
>>>   tests/intel/xe_madvise.c | 233 
>>> +++++++++++++++++++++++++++++++++++++++
>>>   tests/meson.build        |   1 +
>>>   2 files changed, 234 insertions(+)
>>>   create mode 100644 tests/intel/xe_madvise.c
>>>
>>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>>> new file mode 100644
>>> index 000000000..de4a6e34c
>>> --- /dev/null
>>> +++ b/tests/intel/xe_madvise.c
>>> @@ -0,0 +1,233 @@
>>> +// SPDX-License-Identifier: MIT
>>> +/*
>>> + * Copyright © 2025 Intel Corporation
>>> + */
>>> +
>>> +/**
>>> + * TEST: Validate purgeable BO madvise functionality
>>> + * Category: Core
>>> + * Mega feature: General Core features
>>> + * Sub-category: Memory management tests
>>> + * Functionality: madvise, purgeable
>>> + */
>>> +
>>> +#include "igt.h"
>>> +#include "xe_drm.h"
>>> +
>>> +#include "xe/xe_ioctl.h"
>>> +#include "xe/xe_query.h"
>>> +
>>> +static bool xe_has_purgeable_support(int fd)
>>> +{
>>> +    struct drm_xe_query_config *config = xe_config(fd);
>>> +
>>> +    return config->info[DRM_XE_QUERY_CONFIG_FLAGS] &
>>> +        DRM_XE_QUERY_CONFIG_FLAG_HAS_PURGING_SUPPORT;
>>> +}
>>> +
>>> +/* Purgeable test constants */
>>> +#define PURGEABLE_ADDR        0x1a0000
>>> +#define PURGEABLE_BO_SIZE    4096
>>> +
>>> +/**
>>> + * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable 
>>> reclaim
>>> + * @fd: DRM file descriptor
>>> + * @vm: VM handle (unused, kept for API compatibility)
>>> + *
>>> + * Allocates BOs in a temporary VM until memory is overcommitted by 
>>> 50%,
>>> + * forcing the kernel to purge DONTNEED-marked BOs.
>>> + */
>>> +static void trigger_memory_pressure(int fd, uint32_t vm)
>>> +{
>>> +    uint64_t vram_size, mem_size, overpressure;
>>> +    const uint64_t chunk = 8ull << 20; /* 8 MiB */
>>> +    int max_objs, n = 0;
>>> +    uint32_t *handles;
>>> +    uint64_t total;
>>> +    void *p;
>>> +    uint32_t handle, temp_vm;
>>> +
>>> +    /* Use a separate VM so pressure BOs don't affect the test VM */
>>> +    temp_vm = xe_vm_create(fd, 0, 0);
>>> +
>>> +    vram_size = xe_visible_vram_size(fd, 0);
>>> +    if (vram_size > 0) {
>>> +        /* dGPU: pressure VRAM to trigger purgeable reclaim */
>>> +        mem_size = vram_size;
>>> +    } else {
>>> +        /*
>>> +         * iGPU: purgeable BOs reside in system memory. Use *total*
>>> +         * RAM (not just available) as the baseline so that we always
>>> +         * over-commit regardless of how much is already in use.
>>> +         */
>>> +        mem_size = igt_get_total_ram_mb() << 20;
>>> +    }
>>> +
>>> +    /* Scale overpressure to 50% of memory, minimum 64MB */
>>> +    overpressure = mem_size / 2;
>>> +    if (overpressure < (64 << 20))
>>> +        overpressure = 64 << 20;
>>> +
>>> +    max_objs = (mem_size + overpressure) / chunk + 1;
>>> +    handles = malloc(max_objs * sizeof(*handles));
>>> +    igt_assert(handles);
>>> +
>>> +    total = 0;
>>> +    while (total < mem_size + overpressure && n < max_objs) {
>>> +        uint32_t err;
>>> +
>>> +        err = __xe_bo_create(fd, temp_vm, chunk,
>>> +                     vram_if_possible(fd, 0),
>>> + DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
>>> +                     NULL, &handle);
>>> +        if (err) /* Out of memory — sufficient pressure achieved */
>>> +            break;
>>> +
>>> +        handles[n++] = handle;
>>> +        total += chunk;
>>> +
>>> +        p = xe_bo_map(fd, handle, chunk);
>>> +        igt_assert(p != MAP_FAILED);
>>> +
>>> +        /* Fault in all pages so they actually consume memory */
>>> +        memset(p, 0xCD, chunk);
>>> +        munmap(p, chunk);
>>> +    }
>>> +
>>> +    /* Allow shrinker time to process pressure */
>>> +    usleep(100000);
>>> +
>>> +    for (int i = 0; i < n; i++)
>>> +        gem_close(fd, handles[i]);
>>> +
>>> +    free(handles);
>>> +
>>> +    xe_vm_destroy(fd, temp_vm);
>>> +}
>> This function is called from below function which is not part of this 
>> Patch-3/9. This must be removed and introduced in Patch-4/9.


Noted.

>>> +
>>> +static jmp_buf jmp;
>>> +
>>> +__noreturn static void sigtrap(int sig)
>>> +{
>>> +    siglongjmp(jmp, sig);
>>> +}
>>> +
>>> +/**
>>> + * purgeable_mark_and_verify_purged - Mark DONTNEED, pressure, 
>>> check purged
>>> + * @fd: DRM file descriptor
>>> + * @vm: VM handle
>>> + * @addr: Virtual address of the BO
>>> + * @size: Size of the BO
>>> + *
>>> + * Returns true if the BO was purged under memory pressure.
>>> + */
>>> +static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, 
>>> uint64_t addr, size_t size)
>>> +{
>>> +    uint32_t retained;
>>> +
>>> +    /* Mark as DONTNEED */
>>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>>> +    if (retained != 1)
>>> +        return false;
>>> +
>>> +    /* Trigger memory pressure */
>>> +    trigger_memory_pressure(fd, vm);
>>> +
>>> +    /* Verify purged */
>>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>>> +    return retained == 0;
>>> +}
>> This function is introduced in test_dontneed_after_mmap() in 
>> Patch-4/9. Remove this and introduced in Patch-4/9.
> Correction here, this function is called from subtest 
> test_purged_mmap_blocked(fd); which is in Patch-4/9. Please move these 
> functions in Patch-4/9


Noted.

Thanks,
Arvind

>>> +
>>> +/**
>>> + * purgeable_setup_simple_bo - Setup VM and bind a single BO
>>> + * @fd: DRM file descriptor
>>> + * @vm: Output VM handle
>>> + * @bo: Output BO handle
>>> + * @addr: Virtual address to bind at
>>> + * @size: Size of the BO
>>> + * @use_scratch: Whether to use scratch page flag
>>> + *
>>> + * Helper to create VM, BO, and bind it at the specified address.
>>> + */
>>> +static void purgeable_setup_simple_bo(int fd, uint32_t *vm, 
>>> uint32_t *bo,
>>> +                      uint64_t addr, size_t size, bool use_scratch)
>>> +{
>>> +    struct drm_xe_sync sync = {
>>> +        .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>>> +        .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>>> +        .timeline_value = 1,
>>> +    };
>>> +    uint64_t sync_val = 0;
>>> +
>>> +    *vm = xe_vm_create(fd, use_scratch ? 
>>> DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
>>> +    *bo = xe_bo_create(fd, *vm, size, vram_if_possible(fd, 0),
>>> +               DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>>> +
>>> +    sync.addr = to_user_pointer(&sync_val);
>>> +    xe_vm_bind_async(fd, *vm, 0, *bo, 0, addr, size, &sync, 1);
>>> +    xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>>> +}
>>> +
>>> +/**
>>> + * SUBTEST: dontneed-before-mmap
>>> + * Description: Mark BO as DONTNEED before mmap, verify mmap() 
>>> fails with -EBUSY
>>> + * Test category: functionality test
>>> + */
>>> +static void test_dontneed_before_mmap(int fd)
>>> +{
>>> +    uint32_t bo, vm;
>>> +    uint64_t addr = PURGEABLE_ADDR;
>>> +    size_t bo_size = PURGEABLE_BO_SIZE;
>>> +    struct drm_xe_gem_mmap_offset mmo = {};
>>> +    uint32_t retained;
>>> +    void *ptr;
>>> +
>>> +    purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
>>> +
>>> +    /* Mark BO as DONTNEED - new mmap operations must be blocked */
>>> +    retained = xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
>>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>>> +    igt_assert_eq(retained, 1);
>>> +
>>> +    /* Ioctl succeeds even for DONTNEED BO; blocking happens at 
>>> mmap() time. */
>>> +    mmo.handle = bo;
>>> +    igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, 
>>> &mmo), 0);
>>> +
>>> +    /* mmap() on a DONTNEED BO must fail with EBUSY. */
>>> +    ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, 
>>> fd, mmo.offset);
>>> +    igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
>>> +    igt_assert_eq(errno, EBUSY);
>>> +
>>> +    /* Restore to WILLNEED before cleanup */
>>> +    xe_vm_madvise_purgeable(fd, vm, addr, bo_size,
>>> +                DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>>> +
>>> +    gem_close(fd, bo);
>>> +    xe_vm_destroy(fd, vm);
>>> +}
>>> +
>>> +int igt_main()
>>> +{
>>> +    struct drm_xe_engine_class_instance *hwe;
>>> +    int fd;
>>> +
>>> +    igt_fixture() {
>>> +        fd = drm_open_driver(DRIVER_XE);
>>> +        xe_device_get(fd);
>>> +        igt_require_f(xe_has_purgeable_support(fd),
>>> +                  "Kernel does not support purgeable buffer 
>>> objects\n");
>>> +    }
>>> +
>>> +    igt_subtest("dontneed-before-mmap")
>>> +        xe_for_each_engine(fd, hwe) {
>>> +            test_dontneed_before_mmap(fd);
>>> +            break;
>>> +        }
>>> +
>>> +    igt_fixture() {
>>> +        xe_device_put(fd);
>>> +        drm_close_driver(fd);
>>> +    }
>>> +}
>>> diff --git a/tests/meson.build b/tests/meson.build
>>> index cecb4a8ae..a6370b685 100644
>>> --- a/tests/meson.build
>>> +++ b/tests/meson.build
>>> @@ -314,6 +314,7 @@ intel_xe_progs = [
>>>       'xe_huc_copy',
>>>       'xe_intel_bb',
>>>       'xe_live_ktest',
>>> +    'xe_madvise',
>>>       'xe_media_fill',
>>>       'xe_mmap',
>>>           'xe_module_load',

Re: [PATCH i-g-t v6 4/9] tests/intel/xe_madvise: Add purged-mmap-blocked subtest

[Yadav, Arvind]

On 06-04-2026 18:04, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> Add a new purged-mmap-blocked subtest that triggers an actual purge
>> via memory pressure and verifies that mmap() fails with -EINVAL once
>> the BO backing store has been permanently discarded.
>>
>> The purgeable check moved from xe_gem_mmap_offset_ioctl()
>> into a new xe_gem_object_mmap() callback, so the blocking point is now
>> mmap() itself rather than the mmap offset ioctl:
>>
>>    - DRM_IOCTL_XE_GEM_MMAP_OFFSET: always succeeds regardless of
>>      purgeable state (just returns the pre-allocated offset)
>>    - mmap() on DONTNEED BO: fails with -EBUSY (temporary state)
>>    - mmap() on purged BO: fails with -EINVAL (permanent, no backing 
>> store)
>>
>> v5:
>>    - Add purged-mmap-blocked subtest to verify mmap is blocked after
>>      BO backing store is permanently purged.
>>
>> v6:
>>    - DRM_IOCTL_XE_GEM_MMAP_OFFSET always succeeds; the purgeable check
>>      now happens in xe_gem_object_mmap() at mmap() time. For purged BOs,
>>      assert mmap() fails with -EINVAL.
>>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> 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>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 42 ++++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 42 insertions(+)
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> index de4a6e34c..81e05b6d4 100644
>> --- a/tests/intel/xe_madvise.c
>> +++ b/tests/intel/xe_madvise.c
>> @@ -170,6 +170,42 @@ static void purgeable_setup_simple_bo(int fd, 
>> uint32_t *vm, uint32_t *bo,
>>       xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>>   }
>>   +/**
>> + * SUBTEST: purged-mmap-blocked
>> + * Description: After BO is purged, verify mmap() fails with -EINVAL
>> + * Test category: functionality test
>> + */
>> +static void test_purged_mmap_blocked(int fd)
>> +{
>> +    uint32_t bo, vm;
>> +    uint64_t addr = PURGEABLE_ADDR;
>> +    size_t bo_size = PURGEABLE_BO_SIZE;
>> +    struct drm_xe_gem_mmap_offset mmo = {};
>> +    void *ptr;
>> +
>> +    purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
>> +    if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
>
> This function should be defined in this patch. Going through 
> implementation available in Patch-3/9. In that below code used
>
>     vram_size = xe_visible_vram_size(fd, 0);
>
> What it returns in igfx platforms? Instead we can use
>
> /* Purgeable BO either in VRAM or SMEM */
> mem_size = xe_has_vram(pf_fd)?xe_visible_vram_size(fd, 
> 0):igt_get_total_ram_mb() << 20;


Agreed — using xe_has_vram() is more explicit. Will switch to this.


> if (vram_size > 0) {
>                 /* dGPU: pressure VRAM to trigger purgeable reclaim */
>                 mem_size = vram_size;
>         } else {
>                 /*
>                  * iGPU: purgeable BOs reside in system memory. Use 
> *total*
>                  * RAM (not just available) as the baseline so that we 
> always
>                  * over-commit regardless of how much is already in use.
>                  */
>                 mem_size = igt_get_total_ram_mb() << 20;
>         }
>
>> +        gem_close(fd, bo);
>> +        xe_vm_destroy(fd, vm);
>> +        igt_skip("Unable to induce purge on this platform/config");
>> +    }
> static bool purgeable_mark_and_verify_purged(int fd, uint32_t vm, 
> uint64_t addr, size_t size) --> this should be part of this patch
> {
>         uint32_t retained;
>
>         /* Mark as DONTNEED */
>         retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>  DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>
>         if (retained != 1)
>
> So here if BO was purged after above call it'll return 0, so if (0 != 
> 1) will be true and it'll return false.


You're right — if the BO is already purged when we mark DONTNEED 
(retained == 0), the function incorrectly returns false, causing the 
test to skip. Will fix to treat retained == 0 from DONTNEED as already 
purged and return true.


>
>                 return false;
>
>         /* Trigger memory pressure */
>         trigger_memory_pressure(fd, vm);
>
>         /* Verify purged */
>         retained = xe_vm_madvise_purgeable(fd, vm, addr, size,
>  DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>         return retained == 0;
>
> }
>
> static void test_purged_mmap_blocked(int fd)
> {
>         uint32_t bo, vm;
>         uint64_t addr = PURGEABLE_ADDR;
>         size_t bo_size = PURGEABLE_BO_SIZE;
>         struct drm_xe_gem_mmap_offset mmo = {};
>         void *ptr;
>
>         purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, false);
>         if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
>
> Here if returned false from above which is basically if BO was purged 
> retained  = 0 then skip is called which is not the intention


Noted,

Thanks,
Arvind

>         gem_close(fd, bo);
>                 xe_vm_destroy(fd, vm);
>                 igt_skip("Unable to induce purge on this 
> platform/config");
>         }
>
>         /*
>          * Getting the mmap offset is always allowed regardless of 
> purgeable
>          * state - the blocking happens at mmap() time 
> (xe_gem_object_mmap).
>          * For a purged BO, mmap() must fail with -EINVAL (no backing 
> store).
>          */
>         mmo.handle = bo;
>         igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, 
> &mmo), 0);
>
>         ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, 
> fd, mmo.offset);
>         igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
>         igt_assert_eq(errno, EINVAL);
>
>         gem_close(fd, bo);
>         xe_vm_destroy(fd, vm);
> }
>
>
>> +
>> +    /*
>> +     * Getting the mmap offset is always allowed regardless of 
>> purgeable
>> +     * state - the blocking happens at mmap() time 
>> (xe_gem_object_mmap).
>> +     * For a purged BO, mmap() must fail with -EINVAL (no backing 
>> store).
>> +     */
>> +    mmo.handle = bo;
>> +    igt_assert_eq(igt_ioctl(fd, DRM_IOCTL_XE_GEM_MMAP_OFFSET, &mmo), 
>> 0);
>> +
>> +    ptr = mmap(NULL, bo_size, PROT_READ | PROT_WRITE, MAP_SHARED, 
>> fd, mmo.offset);
>> +    igt_assert_eq_u64((uint64_t)ptr, (uint64_t)MAP_FAILED);
>> +    igt_assert_eq(errno, EINVAL);
>> +
>> +    gem_close(fd, bo);
>> +    xe_vm_destroy(fd, vm);
>> +}
>> +
>>   /**
>>    * SUBTEST: dontneed-before-mmap
>>    * Description: Mark BO as DONTNEED before mmap, verify mmap() 
>> fails with -EBUSY
>> @@ -226,6 +262,12 @@ int igt_main()
>>               break;
>>           }
>>   +    igt_subtest("purged-mmap-blocked")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_purged_mmap_blocked(fd);
>> +            break;
>> +        }
>> +
>>       igt_fixture() {
>>           xe_device_put(fd);
>>           drm_close_driver(fd);

Re: [PATCH i-g-t v6 5/9] tests/intel/xe_madvise: Add dontneed-after-mmap subtest

[Yadav, Arvind]

On 06-04-2026 19:03, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> This test verifies that an existing mmap becomes invalid after the BO
>> is marked as purgeable and purged. The test creates a BO, maps it,
>> writes data, then marks it DONTNEED and triggers memory pressure.
>> Accessing the previously valid mapping should now trigger SIGBUS or
>> SIGSEGV, confirming that existing mappings are correctly invalidated
>> when the backing store is purged.
>>
>> v4:
>>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>>    - Added assertion for xe_bo_map. (Nishit)
>>
>> v6:
>>    - Fix sigsetjmp(jmp, SIGBUS | SIGSEGV) to sigsetjmp(jmp, 1). The
>>      second argument is a plain boolean savemask, not a signal set.
>>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> 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>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 64 ++++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 64 insertions(+)
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> index 81e05b6d4..9a157de1d 100644
>> --- a/tests/intel/xe_madvise.c
>> +++ b/tests/intel/xe_madvise.c
>> @@ -244,6 +244,64 @@ static void test_dontneed_before_mmap(int fd)
>>       xe_vm_destroy(fd, vm);
>>   }
>>   +/**
>> + * SUBTEST: dontneed-after-mmap
>> + * Description: Mark BO as DONTNEED after mmap, verify SIGBUS on 
>> accessing purged mapping
>> + * Test category: functionality test
>> + */
>> +static void test_dontneed_after_mmap(int fd)
>> +{
>> +    uint32_t bo, vm;
>> +    uint64_t addr = PURGEABLE_ADDR;
>> +    size_t bo_size = PURGEABLE_BO_SIZE;
>> +    void *map;
>> +
>> +    purgeable_setup_simple_bo(fd, &vm, &bo, addr, bo_size, true);
>> +
>> +    map = xe_bo_map(fd, bo, bo_size);
>> +    igt_assert(map != MAP_FAILED);
>> +    memset(map, 0xAB, bo_size);
>> +
>> +    if (!purgeable_mark_and_verify_purged(fd, vm, addr, bo_size)) {
> same comment as in Patch-4/9


Noted.

Thanks,
Arvind

>> +        munmap(map, bo_size);
>> +        gem_close(fd, bo);
>> +        xe_vm_destroy(fd, vm);
>> +        igt_skip("Unable to induce purge on this platform/config");
>> +    }
>> +
>> +    /* Access purged mapping - should trigger SIGBUS/SIGSEGV */
>> +    {
>> +        sighandler_t old_sigsegv, old_sigbus;
>> +        char *ptr = (char *)map;
>> +        int sig;
>> +
>> +        old_sigsegv = signal(SIGSEGV, (__sighandler_t)sigtrap);
>> +        old_sigbus = signal(SIGBUS, (__sighandler_t)sigtrap);
>> +
>> +        sig = sigsetjmp(jmp, 1); /* savemask=1: save/restore signal 
>> mask */
>> +        switch (sig) {
>> +        case SIGBUS:
>> +        case SIGSEGV:
>> +            /* Expected - purged mapping access failed */
>> +            break;
>> +        case 0:
>> +            *ptr = 0;
>> +        default:
>> +            igt_assert_f(false,
>> +                     "Access to purged mapping should trigger 
>> SIGBUS, got sig=%d\n",
>> +                     sig);
>> +            break;
>> +        }
>> +
>> +        signal(SIGBUS, old_sigbus);
>> +        signal(SIGSEGV, old_sigsegv);
>> +    }
>> +
>> +    munmap(map, bo_size);
>> +    gem_close(fd, bo);
>> +    xe_vm_destroy(fd, vm);
>> +}
>> +
>>   int igt_main()
>>   {
>>       struct drm_xe_engine_class_instance *hwe;
>> @@ -268,6 +326,12 @@ int igt_main()
>>               break;
>>           }
>>   +    igt_subtest("dontneed-after-mmap")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_dontneed_after_mmap(fd);
>> +            break;
>> +        }
>> +
>>       igt_fixture() {
>>           xe_device_put(fd);
>>           drm_close_driver(fd);

Re: [PATCH i-g-t v6 6/9] tests/intel/xe_madvise: Add dontneed-before-exec subtest

[Yadav, Arvind]

On 06-04-2026 22:18, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> This test validates GPU execution behavior when a data BO is purged
>> before submission. The test creates a batch that writes to a data BO,
>> purges the data BO (while keeping the batch BO valid to avoid GPU
>> reset), then submits for execution. With VM_CREATE_FLAG_SCRATCH_PAGE,
>> the GPU write may succeed by landing on scratch memory instead of the
>> purged BO, demonstrating graceful handling of purged memory during
>> GPU operations.
>>
>> v4:
>>    - Added proper resource cleanup before calling igt_skip(). (Nishit)
>>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> 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>
>> Reviewed-by: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 148 +++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 148 insertions(+)
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> index 9a157de1d..d126db9ed 100644
>> --- a/tests/intel/xe_madvise.c
>> +++ b/tests/intel/xe_madvise.c
>> @@ -27,7 +27,11 @@ static bool xe_has_purgeable_support(int fd)
>>     /* Purgeable test constants */
>>   #define PURGEABLE_ADDR        0x1a0000
>> +#define PURGEABLE_BATCH_ADDR    0x3c0000
>>   #define PURGEABLE_BO_SIZE    4096
>> +#define PURGEABLE_FENCE_VAL    0xbeef
>> +#define PURGEABLE_TEST_PATTERN    0xc0ffee
>> +#define PURGEABLE_DEAD_PATTERN    0xdead
>>     /**
>>    * trigger_memory_pressure - Fill VRAM/RAM + 50% to force purgeable 
>> reclaim
>> @@ -206,6 +210,62 @@ static void test_purged_mmap_blocked(int fd)
>>       xe_vm_destroy(fd, vm);
>>   }
>>   +/**
>> + * purgeable_setup_batch_and_data - Setup VM with batch and data BOs 
>> for GPU exec
>> + * @fd: DRM file descriptor
>> + * @vm: Output VM handle
>> + * @bind_engine: Output bind engine handle
>> + * @batch_bo: Output batch BO handle
>> + * @data_bo: Output data BO handle
>> + * @batch: Output batch buffer pointer
>> + * @data: Output data buffer pointer
>> + * @batch_addr: Batch virtual address
>> + * @data_addr: Data virtual address
>> + * @batch_size: Batch buffer size
>> + * @data_size: Data buffer size
>> + *
>> + * Helper to create VM, bind engine, batch and data BOs, and bind them.
>> + */
>> +static void purgeable_setup_batch_and_data(int fd, uint32_t *vm,
>> +                       uint32_t *bind_engine,
>> +                       uint32_t *batch_bo,
>> +                       uint32_t *data_bo,
>> +                       uint32_t **batch,
>> +                       uint32_t **data,
>> +                       uint64_t batch_addr,
>> +                       uint64_t data_addr,
>> +                       size_t batch_size,
>> +                       size_t data_size)
>> +{
>> +    struct drm_xe_sync sync = {
>> +        .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>> +        .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>> +        .timeline_value = PURGEABLE_FENCE_VAL,
>> +    };
>> +    uint64_t vm_sync = 0;
>> +
>> +    *vm = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE, 0);
>> +    *bind_engine = xe_bind_exec_queue_create(fd, *vm, 0);
>> +
>> +    /* Create and bind batch BO */
>> +    *batch_bo = xe_bo_create(fd, *vm, batch_size, 
>> vram_if_possible(fd, 0),
>> +                 DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>> +    *batch = xe_bo_map(fd, *batch_bo, batch_size);
>> +
>> +    sync.addr = to_user_pointer(&vm_sync);
>> +    xe_vm_bind_async(fd, *vm, *bind_engine, *batch_bo, 0, 
>> batch_addr, batch_size, &sync, 1);
>> +    xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
>> +
>> +    /* Create and bind data BO */
>> +    *data_bo = xe_bo_create(fd, *vm, data_size, vram_if_possible(fd, 
>> 0),
>> +                DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>> +    *data = xe_bo_map(fd, *data_bo, data_size);
>> +
>> +    vm_sync = 0;
>> +    xe_vm_bind_async(fd, *vm, *bind_engine, *data_bo, 0, data_addr, 
>> data_size, &sync, 1);
>> +    xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
>> +}
>> +
>>   /**
>>    * SUBTEST: dontneed-before-mmap
>>    * Description: Mark BO as DONTNEED before mmap, verify mmap() 
>> fails with -EBUSY
>> @@ -302,6 +362,88 @@ static void test_dontneed_after_mmap(int fd)
>>       xe_vm_destroy(fd, vm);
>>   }
>>   +/**
>> + * SUBTEST: dontneed-before-exec
>> + * Description: Mark BO as DONTNEED before GPU exec, verify GPU 
>> behavior with SCRATCH_PAGE
>> + * Test category: functionality test
>> + */
>> +static void test_dontneed_before_exec(int fd, struct 
>> drm_xe_engine_class_instance *hwe)
>> +{
>> +    uint32_t vm, exec_queue, bo, batch_bo, bind_engine;
>> +    uint64_t data_addr = PURGEABLE_ADDR;
>> +    uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
>> +    size_t data_size = PURGEABLE_BO_SIZE;
>> +    size_t batch_size = PURGEABLE_BO_SIZE;
>> +    struct drm_xe_sync sync[1] = {
>> +        { .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>> +          .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>> +          .timeline_value = PURGEABLE_FENCE_VAL },
>> +    };
>> +    struct drm_xe_exec exec = {
>> +        .num_batch_buffer = 1,
>> +        .num_syncs = 1,
>> +        .syncs = to_user_pointer(sync),
>> +    };
>> +    uint32_t *data, *batch;
>> +    uint64_t vm_sync = 0;
>> +    int b, ret;
>> +
>> +    purgeable_setup_batch_and_data(fd, &vm, &bind_engine, &batch_bo,
>> +                       &bo, &batch, &data, batch_addr,
>> +                       data_addr, batch_size, data_size);
>> +
>> +    /* Prepare batch */
>> +    b = 0;
>> +    batch[b++] = MI_STORE_DWORD_IMM_GEN4;
>> +    batch[b++] = data_addr;
>> +    batch[b++] = data_addr >> 32;
>> +    batch[b++] = PURGEABLE_DEAD_PATTERN;
>> +    batch[b++] = MI_BATCH_BUFFER_END;
>> +
>> +    /* Phase 1: Purge data BO, batch BO still valid */
>> +    if (!purgeable_mark_and_verify_purged(fd, vm, data_addr, 
>> data_size)) {
> Same comment as in patch-4/9.


Fixed — purgeable_mark_and_verify_purged() now handles retained == 0 
from DONTNEED as already-purged success

>> +        munmap(data, data_size);
>> +        munmap(batch, batch_size);
>> +        gem_close(fd, bo);
>> +        gem_close(fd, batch_bo);
>> +        xe_exec_queue_destroy(fd, bind_engine);
>> +        xe_vm_destroy(fd, vm);
>> +        igt_skip("Unable to induce purge on this platform/config");
>> +    }
>> +
>> +    exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
>> +    exec.exec_queue_id = exec_queue;
>> +    exec.address = batch_addr;
>> +
>> +    vm_sync = 0;
>> +    sync[0].addr = to_user_pointer(&vm_sync);
>> +
>> +    /*
>> +     * VM has SCRATCH_PAGE — exec may succeed with the GPU write
>> +     * landing on scratch instead of the purged data BO.
>> +     */
>> +    ret = __xe_exec(fd, &exec);
> You can use xe_exec(fd, &exec) which is internally calling __xe_exec() 
> and after use xe_wait_fence()


We can't use xe_exec() here,  the data BO has been purged, so exec may 
legitimately fail. xe_exec() asserts success internally, which would 
cause a false test failure. We need __xe_exec() to handle both outcomes: 
success (GPU write lands on scratch page) or failure (exec rejected for 
purged BO).


Thanks,
Arvind

>> +    if (ret == 0) {
>> +        int64_t timeout = NSEC_PER_SEC;
>> +
>> +        __xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL,
>> +                 exec_queue, &timeout);
>> +    }
>> +
>> +    /*
>> +     * Don't purge the batch BO — GPU would fetch zeroed scratch
>> +     * instructions and trigger an engine reset.
>> +     */
>> +
>> +    munmap(data, data_size);
>> +    munmap(batch, batch_size);
>> +    gem_close(fd, bo);
>> +    gem_close(fd, batch_bo);
>> +    xe_exec_queue_destroy(fd, bind_engine);
>> +    xe_exec_queue_destroy(fd, exec_queue);
>> +    xe_vm_destroy(fd, vm);
>> +}
>> +
>>   int igt_main()
>>   {
>>       struct drm_xe_engine_class_instance *hwe;
>> @@ -332,6 +474,12 @@ int igt_main()
>>               break;
>>           }
>>   +    igt_subtest("dontneed-before-exec")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_dontneed_before_exec(fd, hwe);
>> +            break;
>> +        }
>> +
>>       igt_fixture() {
>>           xe_device_put(fd);
>>           drm_close_driver(fd);

Re: [PATCH i-g-t v6 8/9] tests/intel/xe_madvise: Add per-vma-tracking subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test validates that purgeable state is tracked per-VMA when a
> single BO is bound in multiple VMs. The test creates one BO shared
> across two VMs at different virtual addresses. It verifies that marking
> only one VMA as DONTNEED does not make the BO purgeable, but marking
> both VMAs as DONTNEED allows the kernel to purge the shared BO. This
> ensures proper per-VMA tracking for shared memory.
>
> v4:
>    -  The comment now clarifies that triggering pressure. (Nishit)
>
> v6:
>    - Move resource cleanup before igt_skip() to avoid leaking VM and BO
>      handles on platforms where memory pressure cannot be induced; replace
>      igt_assert_eq(retained, 0) with a graceful skip. (Nishit)
>
> 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>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 114 +++++++++++++++++++++++++++++++++++++++
>   1 file changed, 114 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index 28ea81442..6c0a563d8 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -28,6 +28,7 @@ static bool xe_has_purgeable_support(int fd)
>   
>   /* Purgeable test constants */
>   #define PURGEABLE_ADDR		0x1a0000
> +#define PURGEABLE_ADDR2		0x2b0000
>   #define PURGEABLE_BATCH_ADDR	0x3c0000
>   #define PURGEABLE_BO_SIZE	4096
>   #define PURGEABLE_FENCE_VAL	0xbeef
> @@ -267,6 +268,58 @@ static void purgeable_setup_batch_and_data(int fd, uint32_t *vm,
>   	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
>   }
>   
> +/**
> + * purgeable_setup_two_vms_shared_bo - Setup two VMs with one shared BO
> + * @fd: DRM file descriptor
> + * @vm1: Output first VM handle
> + * @vm2: Output second VM handle
> + * @bo: Output shared BO handle
> + * @addr1: Virtual address in VM1
> + * @addr2: Virtual address in VM2
> + * @size: Size of the BO
> + * @use_scratch: Whether to use scratch page flag for VMs
> + *
> + * Helper to create two VMs and bind one shared BO in both VMs.
> + * Returns mapped pointer to the BO.
> + */
> +static void *purgeable_setup_two_vms_shared_bo(int fd, uint32_t *vm1, uint32_t *vm2,
> +					       uint32_t *bo, uint64_t addr1,
> +					       uint64_t addr2, size_t size,
> +					       bool use_scratch)
> +{
> +	struct drm_xe_sync sync = {
> +		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		.timeline_value = 1,
> +	};
> +	uint64_t sync_val = 0;
> +	void *map;
> +
> +	/* Create two VMs */
> +	*vm1 = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
> +	*vm2 = xe_vm_create(fd, use_scratch ? DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
> +
> +	/* Create shared BO */
> +	*bo = xe_bo_create(fd, 0, size, vram_if_possible(fd, 0),
> +			   DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
> +
> +	map = xe_bo_map(fd, *bo, size);
> +	memset(map, 0xAB, size);
> +
> +	/* Bind BO in VM1 */
> +	sync.addr = to_user_pointer(&sync_val);
> +	sync_val = 0;
> +	xe_vm_bind_async(fd, *vm1, 0, *bo, 0, addr1, size, &sync, 1);
> +	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
> +
> +	/* Bind BO in VM2 */
> +	sync_val = 0;
> +	xe_vm_bind_async(fd, *vm2, 0, *bo, 0, addr2, size, &sync, 1);
> +	xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
> +
> +	return map;
> +}
> +
>   /**
>    * SUBTEST: dontneed-before-mmap
>    * Description: Mark BO as DONTNEED before mmap, verify mmap() fails with -EBUSY
> @@ -546,6 +599,61 @@ static void test_dontneed_after_exec(int fd, struct drm_xe_engine_class_instance
>   	xe_vm_destroy(fd, vm);
>   }
>   
> +/**
> + * SUBTEST: per-vma-tracking
> + * Description: One BO in two VMs becomes purgeable only when both VMAs are DONTNEED
> + * Test category: functionality test
> + */
> +static void test_per_vma_tracking(int fd, struct drm_xe_engine_class_instance *hwe)
> +{
> +	uint32_t bo, vm1, vm2;
> +	uint64_t addr1 = PURGEABLE_ADDR;
> +	uint64_t addr2 = PURGEABLE_ADDR2;
> +	size_t bo_size = PURGEABLE_BO_SIZE;
> +	uint32_t retained;
> +	void *map;
> +
> +	map = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
> +						addr1, addr2,
> +						bo_size, false);
> +
> +	/* Mark VMA1 as DONTNEED */
> +	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);

As per description  if VM1 is set to DONTNEED it'll not purge untill VM2 
also set to DONTNEED. So retained = 1 is expected which also verifies

BO is purged or not, if returned 0, So below VM1 WILLNEED check can be 
dropped.

> +
> +	/* Verify BO NOT purgeable (VMA2 still WILLNEED) */
> +	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/* Mark both VMAs as DONTNEED */
> +	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	retained = xe_vm_madvise_purgeable(fd, vm2, addr2, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/*
> +	 * Trigger pressure and verify BO was purged.
> +	 * Using vm1 is sufficient since both VMAs are DONTNEED - kernel can purge the BO.
> +	 */
> +	trigger_memory_pressure(fd, vm1);
> +
> +	retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
Expecting 0 (for purge) here, right? Can we put a check over here?
> +	munmap(map, bo_size);
> +	gem_close(fd, bo);
> +	xe_vm_destroy(fd, vm1);
> +	xe_vm_destroy(fd, vm2);
> +
> +	if (retained != 0)
> +		igt_skip("Unable to induce purge on this platform/config");
> +
> +}
> +
>   int igt_main()
>   {
>   	struct drm_xe_engine_class_instance *hwe;
> @@ -588,6 +696,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("per-vma-tracking")
> +		xe_for_each_engine(fd, hwe) {
> +			test_per_vma_tracking(fd, hwe);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

Re: [PATCH i-g-t v6 9/9] tests/intel/xe_madvise: Add per-vma-protection subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test validates that a WILLNEED VMA protects a shared BO from being
> purged even when other VMAs are marked DONTNEED. The test creates a BO
> shared across two VMs, marks VMA1 as DONTNEED while keeping VMA2 as
> WILLNEED, then triggers memory pressure. The BO should survive and GPU
> execution should succeed. After marking both VMAs as DONTNEED and
> triggering pressure again, the BO should be purged, demonstrating that
> all VMAs must be DONTNEED for the BO to be purgeable.
>
> v4:
>    - Added syncobj_wait() after the second exec. (Nishit)
>
> v6:
>    - Move resource cleanup before igt_skip() to avoid leaking VM and BO
>      handles on platforms where memory pressure cannot be induced; replace
>      igt_assert_eq(retained, 0) with a graceful skip. (Nishit)
>
> 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>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 127 +++++++++++++++++++++++++++++++++++++++
>   1 file changed, 127 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index 6c0a563d8..2375f5475 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -654,6 +654,127 @@ static void test_per_vma_tracking(int fd, struct drm_xe_engine_class_instance *h
>   
>   }
>   
> +/**
> + * SUBTEST: per-vma-protection
> + * Description: WILLNEED VMA protects BO from purging; both DONTNEED makes BO purgeable
> + * Test category: functionality test
> + */
> +static void test_per_vma_protection(int fd, struct drm_xe_engine_class_instance *hwe)
> +{
> +	uint32_t vm1, vm2, exec_queue, bo, batch_bo, bind_engine;
> +	uint64_t data_addr1 = PURGEABLE_ADDR;
> +	uint64_t data_addr2 = PURGEABLE_ADDR2;
> +	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
> +	size_t data_size = PURGEABLE_BO_SIZE;
> +	size_t batch_size = PURGEABLE_BO_SIZE;
> +	struct drm_xe_sync sync[2] = {
> +		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		  .timeline_value = PURGEABLE_FENCE_VAL },
> +		{ .type = DRM_XE_SYNC_TYPE_SYNCOBJ,
> +		  .flags = DRM_XE_SYNC_FLAG_SIGNAL },
> +	};
> +	struct drm_xe_exec exec = {
> +		.num_batch_buffer = 1,
> +		.num_syncs = 1,
> +		.syncs = to_user_pointer(&sync[1]),
> +	};
> +	uint32_t *data, *batch;
> +	uint64_t vm_sync = 0;
> +	uint32_t retained, syncobj;
> +	int b, ret;
> +
> +	/* Create two VMs and bind shared data BO */
> +	data = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
> +						 data_addr1, data_addr2,
> +						 data_size, true);
> +	memset(data, 0, data_size);
> +	bind_engine = xe_bind_exec_queue_create(fd, vm2, 0);
> +
> +	/* Create and bind batch BO in VM2 */
> +	batch_bo = xe_bo_create(fd, vm2, batch_size, vram_if_possible(fd, 0),
> +				DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
> +	batch = xe_bo_map(fd, batch_bo, batch_size);
> +	igt_assert(batch != MAP_FAILED);
> +
> +	sync[0].addr = to_user_pointer(&vm_sync);
> +	vm_sync = 0;
> +	xe_vm_bind_async(fd, vm2, bind_engine, batch_bo, 0, batch_addr, batch_size, sync, 1);
> +	xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
> +
> +	/* Mark VMA1 as DONTNEED, VMA2 stays WILLNEED */
> +	retained = xe_vm_madvise_purgeable(fd, vm1, data_addr1, data_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/* Trigger pressure - BO should survive (VMA2 protects) */
> +	trigger_memory_pressure(fd, vm1);
> +
> +	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/* GPU workload - should succeed */
> +	b = 0;
> +	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> +	batch[b++] = data_addr2;
> +	batch[b++] = data_addr2 >> 32;
> +	batch[b++] = PURGEABLE_TEST_PATTERN;
> +	batch[b++] = MI_BATCH_BUFFER_END;
> +
> +	syncobj = syncobj_create(fd, 0);
> +	sync[1].handle = syncobj;
> +	exec_queue = xe_exec_queue_create(fd, vm2, hwe, 0);
> +	exec.exec_queue_id = exec_queue;
> +	exec.address = batch_addr;
> +
> +	ret = __xe_exec(fd, &exec);
> +	igt_assert_eq(ret, 0);
> +	igt_assert(syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL));
> +
> +	munmap(data, data_size);
> +	data = xe_bo_map(fd, bo, data_size);
> +	igt_assert(data != MAP_FAILED);
> +	igt_assert_eq(data[0], PURGEABLE_TEST_PATTERN);
> +
> +	/* Mark both VMAs DONTNEED */
> +	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
> +	igt_assert_eq(retained, 1);
> +
> +	/* Trigger pressure - BO should be purged */
> +	trigger_memory_pressure(fd, vm1);
> +
> +	retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
> +					   DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> +
> +	if (retained != 0)
> +		goto out;
> +
> +	/* GPU workload - should fail or succeed with NULL rebind */
> +	batch[3] = PURGEABLE_DEAD_PATTERN;
> +
> +	ret = __xe_exec(fd, &exec);
> +	if (ret == 0) {
> +		/* Exec succeeded, wait for completion before cleanup */
> +		syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL);
> +	}
> +
> +out:
> +	munmap(data, data_size);
> +	munmap(batch, batch_size);
> +	gem_close(fd, bo);
> +	gem_close(fd, batch_bo);
> +	syncobj_destroy(fd, syncobj);
> +	xe_exec_queue_destroy(fd, bind_engine);
> +	xe_exec_queue_destroy(fd, exec_queue);
> +	xe_vm_destroy(fd, vm1);
> +	xe_vm_destroy(fd, vm2);
> +
> +	if (retained != 0)
This condition is not required here, already you have checked above and 
then jump in goto:
> +		igt_skip("Unable to induce purge on this platform/config");
> +}
> +
>   int igt_main()
>   {
>   	struct drm_xe_engine_class_instance *hwe;
> @@ -702,6 +823,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("per-vma-protection")
> +		xe_for_each_engine(fd, hwe) {
> +			test_per_vma_protection(fd, hwe);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

with above change LGTM:

Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>

Re: [PATCH i-g-t v6 8/9] tests/intel/xe_madvise: Add per-vma-tracking subtest

[Yadav, Arvind]

On 07-04-2026 12:50, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> This test validates that purgeable state is tracked per-VMA when a
>> single BO is bound in multiple VMs. The test creates one BO shared
>> across two VMs at different virtual addresses. It verifies that marking
>> only one VMA as DONTNEED does not make the BO purgeable, but marking
>> both VMAs as DONTNEED allows the kernel to purge the shared BO. This
>> ensures proper per-VMA tracking for shared memory.
>>
>> v4:
>>    -  The comment now clarifies that triggering pressure. (Nishit)
>>
>> v6:
>>    - Move resource cleanup before igt_skip() to avoid leaking VM and BO
>>      handles on platforms where memory pressure cannot be induced; 
>> replace
>>      igt_assert_eq(retained, 0) with a graceful skip. (Nishit)
>>
>> 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>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 114 +++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 114 insertions(+)
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> index 28ea81442..6c0a563d8 100644
>> --- a/tests/intel/xe_madvise.c
>> +++ b/tests/intel/xe_madvise.c
>> @@ -28,6 +28,7 @@ static bool xe_has_purgeable_support(int fd)
>>     /* Purgeable test constants */
>>   #define PURGEABLE_ADDR        0x1a0000
>> +#define PURGEABLE_ADDR2        0x2b0000
>>   #define PURGEABLE_BATCH_ADDR    0x3c0000
>>   #define PURGEABLE_BO_SIZE    4096
>>   #define PURGEABLE_FENCE_VAL    0xbeef
>> @@ -267,6 +268,58 @@ static void purgeable_setup_batch_and_data(int 
>> fd, uint32_t *vm,
>>       xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, 
>> NSEC_PER_SEC);
>>   }
>>   +/**
>> + * purgeable_setup_two_vms_shared_bo - Setup two VMs with one shared BO
>> + * @fd: DRM file descriptor
>> + * @vm1: Output first VM handle
>> + * @vm2: Output second VM handle
>> + * @bo: Output shared BO handle
>> + * @addr1: Virtual address in VM1
>> + * @addr2: Virtual address in VM2
>> + * @size: Size of the BO
>> + * @use_scratch: Whether to use scratch page flag for VMs
>> + *
>> + * Helper to create two VMs and bind one shared BO in both VMs.
>> + * Returns mapped pointer to the BO.
>> + */
>> +static void *purgeable_setup_two_vms_shared_bo(int fd, uint32_t 
>> *vm1, uint32_t *vm2,
>> +                           uint32_t *bo, uint64_t addr1,
>> +                           uint64_t addr2, size_t size,
>> +                           bool use_scratch)
>> +{
>> +    struct drm_xe_sync sync = {
>> +        .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>> +        .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>> +        .timeline_value = 1,
>> +    };
>> +    uint64_t sync_val = 0;
>> +    void *map;
>> +
>> +    /* Create two VMs */
>> +    *vm1 = xe_vm_create(fd, use_scratch ? 
>> DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
>> +    *vm2 = xe_vm_create(fd, use_scratch ? 
>> DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE : 0, 0);
>> +
>> +    /* Create shared BO */
>> +    *bo = xe_bo_create(fd, 0, size, vram_if_possible(fd, 0),
>> +               DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>> +
>> +    map = xe_bo_map(fd, *bo, size);
>> +    memset(map, 0xAB, size);
>> +
>> +    /* Bind BO in VM1 */
>> +    sync.addr = to_user_pointer(&sync_val);
>> +    sync_val = 0;
>> +    xe_vm_bind_async(fd, *vm1, 0, *bo, 0, addr1, size, &sync, 1);
>> +    xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>> +
>> +    /* Bind BO in VM2 */
>> +    sync_val = 0;
>> +    xe_vm_bind_async(fd, *vm2, 0, *bo, 0, addr2, size, &sync, 1);
>> +    xe_wait_ufence(fd, &sync_val, 1, 0, NSEC_PER_SEC);
>> +
>> +    return map;
>> +}
>> +
>>   /**
>>    * SUBTEST: dontneed-before-mmap
>>    * Description: Mark BO as DONTNEED before mmap, verify mmap() 
>> fails with -EBUSY
>> @@ -546,6 +599,61 @@ static void test_dontneed_after_exec(int fd, 
>> struct drm_xe_engine_class_instance
>>       xe_vm_destroy(fd, vm);
>>   }
>>   +/**
>> + * SUBTEST: per-vma-tracking
>> + * Description: One BO in two VMs becomes purgeable only when both 
>> VMAs are DONTNEED
>> + * Test category: functionality test
>> + */
>> +static void test_per_vma_tracking(int fd, struct 
>> drm_xe_engine_class_instance *hwe)
>> +{
>> +    uint32_t bo, vm1, vm2;
>> +    uint64_t addr1 = PURGEABLE_ADDR;
>> +    uint64_t addr2 = PURGEABLE_ADDR2;
>> +    size_t bo_size = PURGEABLE_BO_SIZE;
>> +    uint32_t retained;
>> +    void *map;
>> +
>> +    map = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
>> +                        addr1, addr2,
>> +                        bo_size, false);
>> +
>> +    /* Mark VMA1 as DONTNEED */
>> +    retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>
> As per description  if VM1 is set to DONTNEED it'll not purge untill 
> VM2 also set to DONTNEED. So retained = 1 is expected which also verifies
>
> BO is purged or not, if returned 0, So below VM1 WILLNEED check can be 
> dropped.


The WILLNEED round‑trip is intentional. It checks that the state change 
from WILLNEED (default) → DONTNEED → WILLNEED works correctly and that 
the BO is retained during this process. This ensures the DONTNEED to 
WILLNEED transition happens smoothly.
Only after that do we mark both VMAs as DONTNEED and confirm that 
purging occurs when all VMAs agree. Removing the WILLNEED check would 
miss coverage of this state‑transition path.
It will never return 0 because both VMAs must first be set to DONTNEED.


>
>> +
>> +    /* Verify BO NOT purgeable (VMA2 still WILLNEED) */
>> +    retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /* Mark both VMAs as DONTNEED */
>> +    retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    retained = xe_vm_madvise_purgeable(fd, vm2, addr2, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /*
>> +     * Trigger pressure and verify BO was purged.
>> +     * Using vm1 is sufficient since both VMAs are DONTNEED - kernel 
>> can purge the BO.
>> +     */
>> +    trigger_memory_pressure(fd, vm1);
>> +
>> +    retained = xe_vm_madvise_purgeable(fd, vm1, addr1, bo_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
> Expecting 0 (for purge) here, right? Can we put a check over here?


Yes, we are checking this below. After cleanup, we verify if (retained 
!= 0) and skip.

Thanks,
Arvind

>> +    munmap(map, bo_size);
>> +    gem_close(fd, bo);
>> +    xe_vm_destroy(fd, vm1);
>> +    xe_vm_destroy(fd, vm2);
>> +
>> +    if (retained != 0)
>> +        igt_skip("Unable to induce purge on this platform/config");
>> +
>> +}
>> +
>>   int igt_main()
>>   {
>>       struct drm_xe_engine_class_instance *hwe;
>> @@ -588,6 +696,12 @@ int igt_main()
>>               break;
>>           }
>>   +    igt_subtest("per-vma-tracking")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_per_vma_tracking(fd, hwe);
>> +            break;
>> +        }
>> +
>>       igt_fixture() {
>>           xe_device_put(fd);
>>           drm_close_driver(fd);

Re: [PATCH i-g-t v6 9/9] tests/intel/xe_madvise: Add per-vma-protection subtest

[Yadav, Arvind]

On 07-04-2026 13:01, Sharma, Nishit wrote:
>
> On 3/25/2026 6:14 PM, Arvind Yadav wrote:
>> This test validates that a WILLNEED VMA protects a shared BO from being
>> purged even when other VMAs are marked DONTNEED. The test creates a BO
>> shared across two VMs, marks VMA1 as DONTNEED while keeping VMA2 as
>> WILLNEED, then triggers memory pressure. The BO should survive and GPU
>> execution should succeed. After marking both VMAs as DONTNEED and
>> triggering pressure again, the BO should be purged, demonstrating that
>> all VMAs must be DONTNEED for the BO to be purgeable.
>>
>> v4:
>>    - Added syncobj_wait() after the second exec. (Nishit)
>>
>> v6:
>>    - Move resource cleanup before igt_skip() to avoid leaking VM and BO
>>      handles on platforms where memory pressure cannot be induced; 
>> replace
>>      igt_assert_eq(retained, 0) with a graceful skip. (Nishit)
>>
>> 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>
>> Cc: Nishit Sharma <nishit.sharma@intel.com>
>> Cc: Pravalika Gurram <pravalika.gurram@intel.com>
>> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
>> ---
>>   tests/intel/xe_madvise.c | 127 +++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 127 insertions(+)
>>
>> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
>> index 6c0a563d8..2375f5475 100644
>> --- a/tests/intel/xe_madvise.c
>> +++ b/tests/intel/xe_madvise.c
>> @@ -654,6 +654,127 @@ static void test_per_vma_tracking(int fd, 
>> struct drm_xe_engine_class_instance *h
>>     }
>>   +/**
>> + * SUBTEST: per-vma-protection
>> + * Description: WILLNEED VMA protects BO from purging; both DONTNEED 
>> makes BO purgeable
>> + * Test category: functionality test
>> + */
>> +static void test_per_vma_protection(int fd, struct 
>> drm_xe_engine_class_instance *hwe)
>> +{
>> +    uint32_t vm1, vm2, exec_queue, bo, batch_bo, bind_engine;
>> +    uint64_t data_addr1 = PURGEABLE_ADDR;
>> +    uint64_t data_addr2 = PURGEABLE_ADDR2;
>> +    uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
>> +    size_t data_size = PURGEABLE_BO_SIZE;
>> +    size_t batch_size = PURGEABLE_BO_SIZE;
>> +    struct drm_xe_sync sync[2] = {
>> +        { .type = DRM_XE_SYNC_TYPE_USER_FENCE,
>> +          .flags = DRM_XE_SYNC_FLAG_SIGNAL,
>> +          .timeline_value = PURGEABLE_FENCE_VAL },
>> +        { .type = DRM_XE_SYNC_TYPE_SYNCOBJ,
>> +          .flags = DRM_XE_SYNC_FLAG_SIGNAL },
>> +    };
>> +    struct drm_xe_exec exec = {
>> +        .num_batch_buffer = 1,
>> +        .num_syncs = 1,
>> +        .syncs = to_user_pointer(&sync[1]),
>> +    };
>> +    uint32_t *data, *batch;
>> +    uint64_t vm_sync = 0;
>> +    uint32_t retained, syncobj;
>> +    int b, ret;
>> +
>> +    /* Create two VMs and bind shared data BO */
>> +    data = purgeable_setup_two_vms_shared_bo(fd, &vm1, &vm2, &bo,
>> +                         data_addr1, data_addr2,
>> +                         data_size, true);
>> +    memset(data, 0, data_size);
>> +    bind_engine = xe_bind_exec_queue_create(fd, vm2, 0);
>> +
>> +    /* Create and bind batch BO in VM2 */
>> +    batch_bo = xe_bo_create(fd, vm2, batch_size, 
>> vram_if_possible(fd, 0),
>> +                DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
>> +    batch = xe_bo_map(fd, batch_bo, batch_size);
>> +    igt_assert(batch != MAP_FAILED);
>> +
>> +    sync[0].addr = to_user_pointer(&vm_sync);
>> +    vm_sync = 0;
>> +    xe_vm_bind_async(fd, vm2, bind_engine, batch_bo, 0, batch_addr, 
>> batch_size, sync, 1);
>> +    xe_wait_ufence(fd, &vm_sync, PURGEABLE_FENCE_VAL, 0, NSEC_PER_SEC);
>> +
>> +    /* Mark VMA1 as DONTNEED, VMA2 stays WILLNEED */
>> +    retained = xe_vm_madvise_purgeable(fd, vm1, data_addr1, data_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /* Trigger pressure - BO should survive (VMA2 protects) */
>> +    trigger_memory_pressure(fd, vm1);
>> +
>> +    retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /* GPU workload - should succeed */
>> +    b = 0;
>> +    batch[b++] = MI_STORE_DWORD_IMM_GEN4;
>> +    batch[b++] = data_addr2;
>> +    batch[b++] = data_addr2 >> 32;
>> +    batch[b++] = PURGEABLE_TEST_PATTERN;
>> +    batch[b++] = MI_BATCH_BUFFER_END;
>> +
>> +    syncobj = syncobj_create(fd, 0);
>> +    sync[1].handle = syncobj;
>> +    exec_queue = xe_exec_queue_create(fd, vm2, hwe, 0);
>> +    exec.exec_queue_id = exec_queue;
>> +    exec.address = batch_addr;
>> +
>> +    ret = __xe_exec(fd, &exec);
>> +    igt_assert_eq(ret, 0);
>> +    igt_assert(syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL));
>> +
>> +    munmap(data, data_size);
>> +    data = xe_bo_map(fd, bo, data_size);
>> +    igt_assert(data != MAP_FAILED);
>> +    igt_assert_eq(data[0], PURGEABLE_TEST_PATTERN);
>> +
>> +    /* Mark both VMAs DONTNEED */
>> +    retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_DONTNEED);
>> +    igt_assert_eq(retained, 1);
>> +
>> +    /* Trigger pressure - BO should be purged */
>> +    trigger_memory_pressure(fd, vm1);
>> +
>> +    retained = xe_vm_madvise_purgeable(fd, vm2, data_addr2, data_size,
>> +                       DRM_XE_VMA_PURGEABLE_STATE_WILLNEED);
>> +
>> +    if (retained != 0)
>> +        goto out;
>> +
>> +    /* GPU workload - should fail or succeed with NULL rebind */
>> +    batch[3] = PURGEABLE_DEAD_PATTERN;
>> +
>> +    ret = __xe_exec(fd, &exec);
>> +    if (ret == 0) {
>> +        /* Exec succeeded, wait for completion before cleanup */
>> +        syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL);
>> +    }
>> +
>> +out:
>> +    munmap(data, data_size);
>> +    munmap(batch, batch_size);
>> +    gem_close(fd, bo);
>> +    gem_close(fd, batch_bo);
>> +    syncobj_destroy(fd, syncobj);
>> +    xe_exec_queue_destroy(fd, bind_engine);
>> +    xe_exec_queue_destroy(fd, exec_queue);
>> +    xe_vm_destroy(fd, vm1);
>> +    xe_vm_destroy(fd, vm2);
>> +
>> +    if (retained != 0)
> This condition is not required here, already you have checked above 
> and then jump in goto: 


This also handles the normal case. Without any jumps in the working 
flow, we check after cleanup whether it was purged, and if not, we skip it


Thanks,
Arvind

>> +        igt_skip("Unable to induce purge on this platform/config");
>> +}
>> +
>>   int igt_main()
>>   {
>>       struct drm_xe_engine_class_instance *hwe;
>> @@ -702,6 +823,12 @@ int igt_main()
>>               break;
>>           }
>>   +    igt_subtest("per-vma-protection")
>> +        xe_for_each_engine(fd, hwe) {
>> +            test_per_vma_protection(fd, hwe);
>> +            break;
>> +        }
>> +
>>       igt_fixture() {
>>           xe_device_put(fd);
>>           drm_close_driver(fd);
>
> with above change LGTM:
>
> Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>
>

Re: [PATCH i-g-t v6 7/9] tests/intel/xe_madvise: Add dontneed-after-exec subtest

[Sharma, Nishit]

On 3/25/2026 6:14 PM, Arvind Yadav wrote:
> This test verifies that memory can be marked purgeable and reclaimed
> after successful GPU execution. The test first executes a batch that
> writes to a data BO and verifies the result. It then marks the BO as
> DONTNEED, triggers memory pressure to purge it, and attempts a second
> execution. The second execution may fail or succeed with scratch
> rebind, validating that the kernel correctly handles purged BOs in
> GPU submissions.
>
> v4:
>     - Added proper resource cleanup before calling igt_skip(). (Nishit)
>     - Added assertion for xe_bo_map. (Nishit)
>     - Now using sync[0] consistently. (Nishit)
>     - Added clarifying comment. (Nishit)
>
> Cc: Nishit Sharma <nishit.sharma@intel.com>
> 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>
> Reviewed-by: Pravalika Gurram <pravalika.gurram@intel.com>
> Signed-off-by: Arvind Yadav <arvind.yadav@intel.com>
> ---
>   tests/intel/xe_madvise.c | 108 +++++++++++++++++++++++++++++++++++++++
>   1 file changed, 108 insertions(+)
>
> diff --git a/tests/intel/xe_madvise.c b/tests/intel/xe_madvise.c
> index d126db9ed..28ea81442 100644
> --- a/tests/intel/xe_madvise.c
> +++ b/tests/intel/xe_madvise.c
> @@ -16,6 +16,7 @@
>   
>   #include "xe/xe_ioctl.h"
>   #include "xe/xe_query.h"
> +#include "lib/igt_syncobj.h"
>   
>   static bool xe_has_purgeable_support(int fd)
>   {
> @@ -444,6 +445,107 @@ static void test_dontneed_before_exec(int fd, struct drm_xe_engine_class_instanc
>   	xe_vm_destroy(fd, vm);
>   }
>   
> +/**
> + * SUBTEST: dontneed-after-exec
> + * Description: Mark BO as DONTNEED after GPU exec, verify memory becomes inaccessible
> + * Test category: functionality test
> + */
> +static void test_dontneed_after_exec(int fd, struct drm_xe_engine_class_instance *hwe)
> +{
> +	uint32_t vm, exec_queue, bo, batch_bo, bind_engine;
> +	uint64_t data_addr = PURGEABLE_ADDR;
> +	uint64_t batch_addr = PURGEABLE_BATCH_ADDR;
> +	size_t data_size = PURGEABLE_BO_SIZE;
> +	size_t batch_size = PURGEABLE_BO_SIZE;
> +	struct drm_xe_sync sync[2] = {
> +		{ .type = DRM_XE_SYNC_TYPE_USER_FENCE,
> +		  .flags = DRM_XE_SYNC_FLAG_SIGNAL,
> +		  .timeline_value = PURGEABLE_FENCE_VAL },
> +		{ .type = DRM_XE_SYNC_TYPE_SYNCOBJ,
> +		  .flags = DRM_XE_SYNC_FLAG_SIGNAL },
> +	};
> +	struct drm_xe_exec exec = {
> +		.num_batch_buffer = 1,
> +		.num_syncs = 2,
> +		.syncs = to_user_pointer(sync),
> +	};
> +	uint32_t *data, *batch;
> +	uint32_t syncobj;
> +	int b, ret;
> +
> +	purgeable_setup_batch_and_data(fd, &vm, &bind_engine, &batch_bo,
> +				       &bo, &batch, &data, batch_addr,
> +				       data_addr, batch_size, data_size);
> +	memset(data, 0, data_size);
> +
> +	syncobj = syncobj_create(fd, 0);
> +
> +	/* Prepare batch to write to data BO */
> +	b = 0;
> +	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> +	batch[b++] = data_addr;
> +	batch[b++] = data_addr >> 32;
> +	batch[b++] = 0xfeed0001;
> +	batch[b++] = MI_BATCH_BUFFER_END;
> +
> +	exec_queue = xe_exec_queue_create(fd, vm, hwe, 0);
> +	exec.exec_queue_id = exec_queue;
> +	exec.address = batch_addr;
> +
> +	/* Use only syncobj for exec (not USER_FENCE) */
> +	sync[0].type = DRM_XE_SYNC_TYPE_SYNCOBJ;
> +	sync[0].flags = DRM_XE_SYNC_FLAG_SIGNAL;
> +	sync[0].handle = syncobj;
> +	exec.num_syncs = 1;
> +	exec.syncs = to_user_pointer(&sync[0]);
> +
> +	ret = __xe_exec(fd, &exec);
> +	igt_assert_eq(ret, 0);
> +
> +	igt_assert(syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL));
> +	munmap(data, data_size);
> +	data = xe_bo_map(fd, bo, data_size);
> +	igt_assert(data != MAP_FAILED);
> +	igt_assert_eq(data[0], 0xfeed0001);
> +
> +	if (!purgeable_mark_and_verify_purged(fd, vm, data_addr, data_size)) {
> +		munmap(data, data_size);
> +		munmap(batch, batch_size);
> +		gem_close(fd, bo);
> +		gem_close(fd, batch_bo);
> +		syncobj_destroy(fd, syncobj);
> +		xe_exec_queue_destroy(fd, bind_engine);
> +		xe_exec_queue_destroy(fd, exec_queue);
> +		xe_vm_destroy(fd, vm);
> +		igt_skip("Unable to induce purge on this platform/config");
> +	}
> +
> +	/* Prepare second batch (different value) */
> +	b = 0;
> +	batch[b++] = MI_STORE_DWORD_IMM_GEN4;
> +	batch[b++] = data_addr;
> +	batch[b++] = data_addr >> 32;
> +	batch[b++] = 0xfeed0002;
> +	batch[b++] = MI_BATCH_BUFFER_END;
> +
> +	/*
> +	 * Second exec with purged BO - may succeed (scratch rebind) or fail.
> +	 * Either is valid, so don't check results.
> +	 */
> +	ret = __xe_exec(fd, &exec);
> +	if (ret == 0)
> +		syncobj_wait(fd, &syncobj, 1, INT64_MAX, 0, NULL);
> +
> +	munmap(data, data_size);
> +	munmap(batch, batch_size);
> +	gem_close(fd, bo);
> +	gem_close(fd, batch_bo);
> +	syncobj_destroy(fd, syncobj);
> +	xe_exec_queue_destroy(fd, bind_engine);
> +	xe_exec_queue_destroy(fd, exec_queue);
> +	xe_vm_destroy(fd, vm);
> +}
> +
>   int igt_main()
>   {
>   	struct drm_xe_engine_class_instance *hwe;
> @@ -480,6 +582,12 @@ int igt_main()
>   			break;
>   		}
>   
> +	igt_subtest("dontneed-after-exec")
> +		xe_for_each_engine(fd, hwe) {
> +			test_dontneed_after_exec(fd, hwe);
> +			break;
> +		}
> +
>   	igt_fixture() {
>   		xe_device_put(fd);
>   		drm_close_driver(fd);

LGTM:

Reviewed-by: Nishit Sharma <nishit.sharma@intel.com>