[igt-dev] [PATCH i-g-t 0/8] Initial SR-IOV validation

[igt-dev] [PATCH i-g-t 0/8] Initial SR-IOV validation

[Lukasz Laguna]

Series introduces a basic SR-IOV test that validates VFs enabling in
different scenarios together with VF DRM driver binding. Implemented
library helpers rely on generic PCI device attributes defined in ABI.

Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>

Daniel Mrzyglod (1):
  lib/igt_sriov_device: add helper for checking if VF DRM driver is
    probed

Katarzyna Dec (4):
  lib/igt_sriov_device: add core SR-IOV helpers
  lib/igt_sriov_device: add helper for opening VF device
  tests/sriov_basic: add basic tests for enabling SR-IOV VFs
  tests/sriov_basic: validate driver binding to VFs

Lukasz Laguna (3):
  lib/igt_sriov_device: add helpers for operations in different VFs
    scenarios
  lib/igt_sriov_device: add helpers for VF DRM driver bind and unbind
  tests/sriov_basic: add more tests for VF driver binding

 lib/drmtest.c          |  17 ++-
 lib/drmtest.h          |   1 +
 lib/igt_sriov_device.c | 308 +++++++++++++++++++++++++++++++++++++++++
 lib/igt_sriov_device.h |  42 ++++++
 lib/meson.build        |   1 +
 tests/meson.build      |   1 +
 tests/sriov_basic.c    | 271 ++++++++++++++++++++++++++++++++++++
 7 files changed, 637 insertions(+), 4 deletions(-)
 create mode 100644 lib/igt_sriov_device.c
 create mode 100644 lib/igt_sriov_device.h
 create mode 100644 tests/sriov_basic.c

-- 
2.40.0

[igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.

Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
 lib/igt_sriov_device.h |  20 +++++
 lib/meson.build        |   1 +
 3 files changed, 195 insertions(+)
 create mode 100644 lib/igt_sriov_device.c
 create mode 100644 lib/igt_sriov_device.h

diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
new file mode 100644
index 000000000..7d53c2045
--- /dev/null
+++ b/lib/igt_sriov_device.c
@@ -0,0 +1,174 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright(c) 2023 Intel Corporation. All rights reserved.
+ */
+
+#include "igt_core.h"
+#include "igt_sriov_device.h"
+#include "igt_sysfs.h"
+
+/**
+ * igt_sriov_is_pf:
+ * @device: device file descriptor
+ *
+ * Check if device is PF by checking existence of sriov_totalvfs file
+ * and non-zero value read from that file.
+ *
+ * Returns:
+ * True if device is PF, false otherwise.
+ */
+bool igt_sriov_is_pf(int device)
+{
+	int sysfs;
+	bool ret;
+	uint32_t totalvfs;
+
+	sysfs = igt_sysfs_open(device);
+	igt_assert_fd(sysfs);
+
+	ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs", &totalvfs);
+	close(sysfs);
+
+	if (!ret)
+		return false;
+
+	return totalvfs > 0;
+}
+
+static uint32_t __pf_attr_get_u32(int pf, const char *attr)
+{
+	int sysfs;
+	uint32_t value;
+
+	igt_assert(igt_sriov_is_pf(pf));
+
+	sysfs = igt_sysfs_open(pf);
+	igt_assert_fd(sysfs);
+
+	value = igt_sysfs_get_u32(sysfs, attr);
+	close(sysfs);
+
+	return value;
+}
+
+static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
+{
+	int sysfs;
+	bool ret;
+
+	igt_assert(igt_sriov_is_pf(pf));
+
+	sysfs = igt_sysfs_open(pf);
+	igt_assert_fd(sysfs);
+
+	ret = __igt_sysfs_set_u32(sysfs, attr, value);
+	close(sysfs);
+
+	return ret;
+}
+
+/**
+ * igt_sriov_get_totalvfs:
+ * @pf: PF device file descriptor
+ *
+ * Get maximum number of VFs that can be enabled.
+ *
+ * Returns:
+ * Maximum number of VFs that could be associated with given PF.
+ */
+unsigned int igt_sriov_get_total_vfs(int pf)
+{
+	return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
+}
+
+/**
+ * igt_sriov_get_numvfs:
+ * @pf: PF device file descriptor
+ *
+ * Get number of enabled VFs.
+ *
+ * Returns:
+ * Number of VFs enabled by given PF.
+ */
+unsigned int igt_sriov_get_enabled_vfs(int pf)
+{
+	return __pf_attr_get_u32(pf, "device/sriov_numvfs");
+}
+
+/**
+ * igt_sriov_enable_vfs:
+ * @pf: PF device file descriptor
+ * @num_vfs: Number of virtual functions to be enabled
+ *
+ * Helper for VFs enabling.
+ *
+ * Returns:
+ * True on success and false on failure.
+ */
+bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
+{
+	igt_assert(num_vfs > 0);
+	igt_debug("Enabling %u VFs\n", num_vfs);
+	return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
+}
+
+/**
+ * igt_sriov_disable_vfs:
+ * @pf: PF device file descriptor
+ *
+ * Set 0 in sriov_numvfs file to disable VFs.
+ *
+ * Returns:
+ * True on success and false on failure.
+ */
+bool igt_sriov_disable_vfs(int pf)
+{
+	igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));
+	return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
+}
+
+/**
+ * igt_sriov_is_driver_autoprobe_enabled:
+ * @pf: PF device file descriptor
+ *
+ * Get current driver autoprobe setting.
+ *
+ * Returns:
+ * True if autoprobe is enabled, false otherwise.
+ */
+bool igt_sriov_is_driver_autoprobe_enabled(int pf)
+{
+	return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
+}
+
+/**
+ * igt_sriov_enable_driver_autoprobe:
+ * @pf: PF device file descriptor
+ *
+ * Set driver autoprobe to true.
+ *
+ * During VFs enabling driver will be bound to VFs.
+ *
+ * Return:
+ * True if setting driver autoprobe succeed, otherwise false.
+ */
+bool igt_sriov_enable_driver_autoprobe(int pf)
+{
+	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", true);
+}
+
+/**
+ * igt_sriov_disable_driver_autoprobe:
+ * @pf: PF device file descriptor
+ *
+ * Set driver autoprobe to false.
+ *
+ * During VFs enabling driver won't be bound to VFs.
+ *
+ * Return:
+ * True if setting driver autoprobe succeed, otherwise false.
+ */
+bool igt_sriov_disable_driver_autoprobe(int pf)
+{
+	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", false);
+}
diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
new file mode 100644
index 000000000..f2c5c44fa
--- /dev/null
+++ b/lib/igt_sriov_device.h
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Copyright(c) 2023 Intel Corporation. All rights reserved.
+ */
+
+#ifndef __IGT_SRIOV_DEVICE_H__
+#define __IGT_SRIOV_DEVICE_H__
+
+#include <stdint.h>
+
+bool igt_sriov_is_pf(int device);
+unsigned int igt_sriov_get_total_vfs(int pf);
+unsigned int igt_sriov_get_enabled_vfs(int pf);
+bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
+bool igt_sriov_disable_vfs(int pf);
+bool igt_sriov_is_driver_autoprobe_enabled(int pf);
+bool igt_sriov_enable_driver_autoprobe(int pf);
+bool igt_sriov_disable_driver_autoprobe(int pf);
+
+#endif /* __IGT_SRIOV_DEVICE_H__ */
diff --git a/lib/meson.build b/lib/meson.build
index a7bccafc3..083baa68a 100644
--- a/lib/meson.build
+++ b/lib/meson.build
@@ -38,6 +38,7 @@ lib_sources = [
 	'igt_primes.c',
 	'igt_pci.c',
 	'igt_rand.c',
+	'igt_sriov_device.c',
 	'igt_stats.c',
 	'igt_syncobj.c',
 	'igt_sysfs.c',
-- 
2.40.0

[igt-dev] [PATCH i-g-t 2/8] lib/igt_sriov_device: add helper for opening VF device

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Helper opens DRM device node and returns its file descriptor.

Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 lib/drmtest.c          | 17 +++++++++++----
 lib/drmtest.h          |  1 +
 lib/igt_sriov_device.c | 48 ++++++++++++++++++++++++++++++++++++++++++
 lib/igt_sriov_device.h |  1 +
 4 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/lib/drmtest.c b/lib/drmtest.c
index e1da66c87..88965ac6a 100644
--- a/lib/drmtest.c
+++ b/lib/drmtest.c
@@ -245,7 +245,16 @@ static void log_opened_device_path(const char *device_path)
 	igt_info("Opened device: %s\n", item->path);
 }
 
-static int open_device(const char *name, unsigned int chipset)
+/**
+ * drm_open_device:
+ * @name: DRM node name
+ * @chipset: OR'd flags for each chipset to search, eg. #DRIVER_INTEL
+ *
+ * Open a drm legacy device node.
+ *
+ * Returns: DRM file descriptor or -1 on error
+ */
+int drm_open_device(const char *name, unsigned int chipset)
 {
 	const char *forced;
 	char dev_name[16] = "";
@@ -347,7 +356,7 @@ static int __search_and_open(const char *base, int offset, unsigned int chipset,
 		if (_is_already_opened(name, as_idx))
 			continue;
 
-		fd = open_device(name, chipset);
+		fd = drm_open_device(name, chipset);
 		if (fd != -1)
 			return fd;
 	}
@@ -389,13 +398,13 @@ static int __open_driver_exact(const char *name, unsigned int chipset)
 {
 	int fd;
 
-	fd = open_device(name, chipset);
+	fd = drm_open_device(name, chipset);
 	if (fd != -1)
 		return fd;
 
 	drm_load_module(chipset);
 
-	return open_device(name, chipset);
+	return drm_open_device(name, chipset);
 }
 
 /*
diff --git a/lib/drmtest.h b/lib/drmtest.h
index 97ab6e759..01785f675 100644
--- a/lib/drmtest.h
+++ b/lib/drmtest.h
@@ -98,6 +98,7 @@ void __set_forced_driver(const char *name);
  */
 #define ALIGN_DOWN(x, a)	ALIGN((x) - ((a) - 1), (a))
 
+int drm_open_device(const char *name, unsigned int chipset);
 void drm_load_module(unsigned int chipset);
 int drm_open_driver(int chipset);
 int drm_open_driver_master(int chipset);
diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
index 7d53c2045..2898765f1 100644
--- a/lib/igt_sriov_device.c
+++ b/lib/igt_sriov_device.c
@@ -3,6 +3,9 @@
  * Copyright(c) 2023 Intel Corporation. All rights reserved.
  */
 
+#include <dirent.h>
+
+#include "drmtest.h"
 #include "igt_core.h"
 #include "igt_sriov_device.h"
 #include "igt_sysfs.h"
@@ -172,3 +175,48 @@ bool igt_sriov_disable_driver_autoprobe(int pf)
 {
 	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", false);
 }
+
+/**
+ * igt_sriov_open_vf_drm_device:
+ * @pf: PF device file descriptor
+ * @vf_num: VF number (1-based to identify single VF)
+ *
+ * Open DRM device node for given VF.
+ *
+ * Return:
+ * VF file descriptor or -1 on error.
+ */
+int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num)
+{
+	char dir_path[PATH_MAX], path[PATH_MAX], dev_name[16];
+	DIR *dir;
+	struct dirent *de;
+	bool found = false;
+
+	igt_assert(vf_num > 0);
+
+	if (!igt_sysfs_path(pf, dir_path, sizeof(dir_path)))
+		return -1;
+	/* vf_num is 1-based, but virtfn is 0-based */
+	snprintf(path, sizeof(path), "/device/virtfn%u/drm", vf_num - 1);
+	strncat(dir_path, path, sizeof(dir_path) - strlen(dir_path));
+
+	dir = opendir(dir_path);
+	if (!dir)
+		return -1;
+	while ((de = readdir(dir))) {
+		unsigned int card_num;
+
+		if (sscanf(de->d_name, "card%d", &card_num) == 1) {
+			snprintf(dev_name, sizeof(dev_name), "/dev/dri/card%u", card_num);
+			found = true;
+			break;
+		}
+	}
+	closedir(dir);
+
+	if (!found)
+		return -1;
+
+	return drm_open_device(dev_name, DRIVER_ANY);
+}
diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
index f2c5c44fa..b58dd4098 100644
--- a/lib/igt_sriov_device.h
+++ b/lib/igt_sriov_device.h
@@ -16,5 +16,6 @@ bool igt_sriov_disable_vfs(int pf);
 bool igt_sriov_is_driver_autoprobe_enabled(int pf);
 bool igt_sriov_enable_driver_autoprobe(int pf);
 bool igt_sriov_disable_driver_autoprobe(int pf);
+int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
 
 #endif /* __IGT_SRIOV_DEVICE_H__ */
-- 
2.40.0

[igt-dev] [PATCH i-g-t 3/8] lib/igt_sriov_device: add helper for checking if VF DRM driver is probed

[Lukasz Laguna]

From: Daniel Mrzyglod <daniel.t.mrzyglod@intel.com>

Probe check is based on existence of the DRM subsystem attribute in
sysfs.

Signed-off-by: Daniel Mrzyglod <daniel.t.mrzyglod@intel.com>
Reviewed-by: Katarzyna Dec <katarzyna.dec@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 lib/igt_sriov_device.c | 30 ++++++++++++++++++++++++++++++
 lib/igt_sriov_device.h |  1 +
 2 files changed, 31 insertions(+)

diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
index 2898765f1..81b046cf9 100644
--- a/lib/igt_sriov_device.c
+++ b/lib/igt_sriov_device.c
@@ -220,3 +220,33 @@ int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num)
 
 	return drm_open_device(dev_name, DRIVER_ANY);
 }
+
+/**
+ * igt_sriov_is_vf_drm_driver_probed:
+ * @pf: PF device file descriptor
+ * @vf_num: VF number (1-based to identify single VF)
+ *
+ * This function verifies if DRM driver is bound to VF device.
+ *
+ * Probe check is based on existence of the DRM subsystem attribute in sysfs.
+ *
+ * Returns:
+ * True if VF has DRM driver loaded, false if not.
+ */
+bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num)
+{
+	char path[PATH_MAX];
+	int sysfs;
+	bool ret;
+
+	igt_assert(vf_num > 0);
+
+	sysfs = igt_sysfs_open(pf);
+	igt_assert_fd(sysfs);
+	/* vf_num is 1-based, but virtfn is 0-based */
+	snprintf(path, sizeof(path), "device/virtfn%u/drm", vf_num - 1);
+	ret = igt_sysfs_has_attr(sysfs, path);
+	close(sysfs);
+
+	return ret;
+}
diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
index b58dd4098..be4e56cf3 100644
--- a/lib/igt_sriov_device.h
+++ b/lib/igt_sriov_device.h
@@ -17,5 +17,6 @@ bool igt_sriov_is_driver_autoprobe_enabled(int pf);
 bool igt_sriov_enable_driver_autoprobe(int pf);
 bool igt_sriov_disable_driver_autoprobe(int pf);
 int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
+bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num);
 
 #endif /* __IGT_SRIOV_DEVICE_H__ */
-- 
2.40.0

[igt-dev] [PATCH i-g-t 4/8] lib/igt_sriov_device: add helpers for operations in different VFs scenarios

[Lukasz Laguna]

Added helpers:
- for_each_vf and for_each_num_vfs
- for_random_vf and for_random_num_vfs
- for_last_vf and for_max_num_vfs

Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 lib/igt_sriov_device.h | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
index be4e56cf3..78cb0e73b 100644
--- a/lib/igt_sriov_device.h
+++ b/lib/igt_sriov_device.h
@@ -19,4 +19,22 @@ bool igt_sriov_disable_driver_autoprobe(int pf);
 int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
 bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num);
 
+#define for_each_vf(__pf_fd, __vf_num) \
+	for (unsigned int __vf_num = 1, __total_vfs = igt_sriov_get_total_vfs(__pf_fd); \
+	     __vf_num <= __total_vfs; \
+	     ++__vf_num)
+#define for_each_num_vfs for_each_vf
+
+#define for_random_vf(__pf_fd, __vf_num) \
+	for (unsigned int __vf_num = 1 + random() % igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
+	     __tmp < 1; \
+	     ++__tmp)
+#define for_random_num_vfs for_random_vf
+
+#define for_last_vf(__pf_fd, __vf_num) \
+	for (unsigned int __vf_num = igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
+	     __tmp < 1; \
+	     ++__tmp)
+#define for_max_num_vfs for_last_vf
+
 #endif /* __IGT_SRIOV_DEVICE_H__ */
-- 
2.40.0

[igt-dev] [PATCH i-g-t 5/8] tests/sriov_basic: add basic tests for enabling SR-IOV VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Add subtests that validate SR-IOV VFs enabling in two variants: with
autoprobe disabled and enabled.

Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 tests/meson.build   |   1 +
 tests/sriov_basic.c | 126 ++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 127 insertions(+)
 create mode 100644 tests/sriov_basic.c

diff --git a/tests/meson.build b/tests/meson.build
index 62721157d..7413d978c 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -71,6 +71,7 @@ test_progs = [
 	'panfrost_submit',
 	'prime_udl',
 	'prime_vgem',
+	'sriov_basic',
 	'syncobj_basic',
 	'syncobj_eventfd',
 	'syncobj_wait',
diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
new file mode 100644
index 000000000..fc0914962
--- /dev/null
+++ b/tests/sriov_basic.c
@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: MIT
+/*
+ * Copyright(c) 2023 Intel Corporation. All rights reserved.
+ */
+
+#include "drmtest.h"
+#include "igt_core.h"
+#include "igt_sriov_device.h"
+
+IGT_TEST_DESCRIPTION("Basic tests for enabling SR-IOV Virtual Functions");
+
+/**
+ * TEST: sriov_basic
+ * Category: Software building block
+ * Mega feature: SR-IOV
+ * Sub-category: VFs enabling
+ * Run type: BAT
+ * Description: Validate SR-IOV VFs enabling
+ */
+
+/**
+ * SUBTEST: enable-vfs-autoprobe-off
+ * Description:
+ *   Verify VFs enabling without probing VF driver
+ */
+static void enable_disable_vfs(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Using num_vfs=%u\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+}
+
+/**
+ * SUBTEST: enable-vfs-autoprobe-on
+ * Description:
+ *   Verify VFs enabling and auto-probing VF driver
+ */
+static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
+{
+	bool err = false;
+
+	igt_debug("Using num_vfs=%u\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+	igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
+	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
+	for (int vf_num = 1; vf_num <= num_vfs; ++vf_num) {
+		if (!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num)) {
+			igt_debug("VF%u probe failed\n", vf_num);
+			err = true;
+		}
+	}
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+	igt_assert(!err);
+}
+
+igt_main
+{
+	int pf_fd;
+	bool autoprobe;
+
+	igt_fixture {
+		pf_fd = drm_open_driver(DRIVER_ANY);
+		igt_require(igt_sriov_is_pf(pf_fd));
+		igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+		autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
+
+		igt_srandom();
+	}
+
+	igt_describe("Verify VFs enabling without probing VF driver");
+	igt_subtest_with_dynamic("enable-vfs-autoprobe-off") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+	}
+
+	igt_describe("Verify VFs enabling and auto-probing VF driver");
+	igt_subtest_with_dynamic("enable-vfs-autoprobe-on") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				probe_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				probe_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				probe_disable_vfs(pf_fd, num_vfs);
+			}
+		}
+	}
+
+	igt_fixture {
+		igt_sriov_disable_vfs(pf_fd);
+		/* abort to avoid execution of next tests with enabled VFs */
+		igt_abort_on_f(igt_sriov_get_enabled_vfs(pf_fd) > 0, "Failed to disable VF(s)");
+		autoprobe ? igt_sriov_enable_driver_autoprobe(pf_fd) :
+			    igt_sriov_disable_driver_autoprobe(pf_fd);
+		igt_abort_on_f(autoprobe != igt_sriov_is_driver_autoprobe_enabled(pf_fd),
+			       "Failed to restore sriov_drivers_autoprobe value\n");
+		close(pf_fd);
+	}
+}
-- 
2.40.0

[igt-dev] [PATCH i-g-t 6/8] lib/igt_sriov_device: add helpers for VF DRM driver bind and unbind

[Lukasz Laguna]

Helpers allow to bind and unbind a DRM driver for specified VF of a
given PF device.

Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 lib/igt_sriov_device.c | 56 ++++++++++++++++++++++++++++++++++++++++++
 lib/igt_sriov_device.h |  2 ++
 2 files changed, 58 insertions(+)

diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
index 81b046cf9..78af5c115 100644
--- a/lib/igt_sriov_device.c
+++ b/lib/igt_sriov_device.c
@@ -4,9 +4,11 @@
  */
 
 #include <dirent.h>
+#include <pciaccess.h>
 
 #include "drmtest.h"
 #include "igt_core.h"
+#include "igt_device.h"
 #include "igt_sriov_device.h"
 #include "igt_sysfs.h"
 
@@ -250,3 +252,57 @@ bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num)
 
 	return ret;
 }
+
+static bool __igt_sriov_bind_vf_drm_driver(int pf, unsigned int vf_num, bool bind)
+{
+	int sysfs, ret;
+	struct pci_device *pci_dev;
+	char pci_slot[14];
+
+	igt_assert(vf_num > 0);
+
+	pci_dev = __igt_device_get_pci_device(pf, vf_num);
+	igt_assert_f(pci_dev, "No PCI device for given VF number: %d\n", vf_num);
+	sprintf(pci_slot, "%04x:%02x:%02x.%x",
+		pci_dev->domain_16, pci_dev->bus, pci_dev->dev, pci_dev->func);
+
+	sysfs = igt_sysfs_open(pf);
+	igt_assert_fd(sysfs);
+
+	igt_debug("vf_num: %u, pci_slot: %s\n", vf_num, pci_slot);
+	ret = igt_sysfs_set(sysfs, bind ? "device/driver/bind" : "device/driver/unbind", pci_slot);
+
+	close(sysfs);
+
+	return ret;
+}
+
+/**
+ * igt_sriov_bind_vf_drm_driver
+ * @pf: PF device file descriptor
+ * @vf_num: VF number (1-based to identify single VF)
+ *
+ * Bind the DRM driver for given VF.
+ *
+ * Returns:
+ * True on success, false on failure.
+ */
+bool igt_sriov_bind_vf_drm_driver(int pf, unsigned int vf_num)
+{
+	return __igt_sriov_bind_vf_drm_driver(pf, vf_num, true);
+}
+
+/**
+ * igt_sriov_unbind_vf_drm_driver
+ * @pf: PF device file descriptor
+ * @vf_num: VF number (1-based to identify single VF)
+ *
+ * Unind the DRM driver for given VF.
+ *
+ * Returns:
+ * True on success, false on failure.
+ */
+bool igt_sriov_unbind_vf_drm_driver(int pf, unsigned int vf_num)
+{
+	return __igt_sriov_bind_vf_drm_driver(pf, vf_num, false);
+}
diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
index 78cb0e73b..466bda49c 100644
--- a/lib/igt_sriov_device.h
+++ b/lib/igt_sriov_device.h
@@ -18,6 +18,8 @@ bool igt_sriov_enable_driver_autoprobe(int pf);
 bool igt_sriov_disable_driver_autoprobe(int pf);
 int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
 bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num);
+bool igt_sriov_bind_vf_drm_driver(int pf, unsigned int vf_num);
+bool igt_sriov_unbind_vf_drm_driver(int pf, unsigned int vf_num);
 
 #define for_each_vf(__pf_fd, __vf_num) \
 	for (unsigned int __vf_num = 1, __total_vfs = igt_sriov_get_total_vfs(__pf_fd); \
-- 
2.40.0

[igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Test enables VFs in range <1..totalvfs>, bind driver to all of them and
then unbind driver from all of them.

Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 tests/sriov_basic.c | 51 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index fc0914962..179731daf 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -61,6 +61,38 @@ static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
 	igt_assert(!err);
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-all-unbind-all
+ * Description:
+ *   Verify VFs enabling, binding the driver and then unbinding it from all of them
+ */
+static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Using num_vfs=%u\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+	igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
+	igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
+	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+}
+
 igt_main
 {
 	int pf_fd;
@@ -113,6 +145,25 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0

[igt-dev] [PATCH i-g-t 8/8] tests/sriov_basic: add more tests for VF driver binding

[Lukasz Laguna]

- bind-unbind-vf: validate driver binding and unbinding to specified VF
- enable-vfs-bind-unbind-each: validate driver binding and unbinding to
  VFs from specified range.

Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 tests/sriov_basic.c | 94 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index 179731daf..b71bfa947 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -93,6 +93,62 @@ static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
 	igt_assert(igt_sriov_disable_vfs(pf_fd));
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-unbind-each
+ * Description:
+ *   Verify VFs enabling with binding and unbinding the driver one be one to each of them
+ */
+static void enable_vfs_bind_unbind_each(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Using num_vfs=%u\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+	igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
+	igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
+	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+}
+
+/**
+ * SUBTEST: bind-unbind-vf
+ * Description:
+ *   Verify binding and unbinding the driver to specific VF
+ */
+static void bind_unbind_vf(int pf_fd, unsigned int vf_num)
+{
+	igt_debug("Using vf_num=%u\n", vf_num);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+	igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	igt_warn_on(!igt_sriov_enable_vfs(pf_fd, vf_num));
+	igt_assert_eq(vf_num, igt_sriov_get_enabled_vfs(pf_fd));
+	igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
+	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+
+	igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num));
+	igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, vf_num));
+	igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num));
+	igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, vf_num));
+	igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num));
+
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+}
+
 igt_main
 {
 	int pf_fd;
@@ -164,6 +220,44 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling with binding and unbinding the driver one be one to each of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-unbind-each") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_unbind_each(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_unbind_each(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_unbind_each(pf_fd, num_vfs);
+			}
+		}
+	}
+
+	igt_describe("Test binds and unbinds the driver to specific VF");
+	igt_subtest_with_dynamic("bind-unbind-vf") {
+		for_each_vf(pf_fd, vf) {
+			igt_dynamic_f("vf-%u", vf) {
+				bind_unbind_vf(pf_fd, vf);
+			}
+		}
+		for_random_vf(pf_fd, vf) {
+			igt_dynamic_f("vf-random") {
+				bind_unbind_vf(pf_fd, vf);
+			}
+		}
+		for_last_vf(pf_fd, vf) {
+			igt_dynamic_f("vf-last") {
+				bind_unbind_vf(pf_fd, vf);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0

[igt-dev] ✓ CI.xeBAT: success for Initial SR-IOV validation

[Patchwork]

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

== Series Details ==

Series: Initial SR-IOV validation
URL   : https://patchwork.freedesktop.org/series/126034/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_7574_BAT -> XEIGTPW_10122_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (4 -> 4)
------------------------------

  No changes in participating hosts

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

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

### IGT changes ###

#### Possible fixes ####

  * igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size:
    - bat-dg2-oem2:       [FAIL][1] ([i915#2346]) -> [PASS][2]
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7574/bat-dg2-oem2/igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_10122/bat-dg2-oem2/igt@kms_cursor_legacy@basic-flip-after-cursor-varying-size.html

  * igt@kms_flip@basic-flip-vs-wf_vblank:
    - bat-dg2-oem2:       [FAIL][3] ([Intel XE#480]) -> [PASS][4] +1 other test pass
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7574/bat-dg2-oem2/igt@kms_flip@basic-flip-vs-wf_vblank.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_10122/bat-dg2-oem2/igt@kms_flip@basic-flip-vs-wf_vblank.html

  * {igt@xe_create@create-execqueues-noleak}:
    - bat-adlp-7:         [FAIL][5] ([Intel XE#524]) -> [PASS][6]
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7574/bat-adlp-7/igt@xe_create@create-execqueues-noleak.html
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_10122/bat-adlp-7/igt@xe_create@create-execqueues-noleak.html

  
#### Warnings ####

  * igt@kms_frontbuffer_tracking@basic:
    - bat-adlp-7:         [DMESG-FAIL][7] ([Intel XE#282] / [i915#2017]) -> [FAIL][8] ([Intel XE#616] / [Intel XE#750])
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_7574/bat-adlp-7/igt@kms_frontbuffer_tracking@basic.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_10122/bat-adlp-7/igt@kms_frontbuffer_tracking@basic.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [Intel XE#282]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/282
  [Intel XE#480]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/480
  [Intel XE#524]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/524
  [Intel XE#616]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/616
  [Intel XE#750]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/750
  [i915#2017]: https://gitlab.freedesktop.org/drm/intel/issues/2017
  [i915#2346]: https://gitlab.freedesktop.org/drm/intel/issues/2346


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

  * IGT: IGT_7574 -> IGTPW_10122
  * Linux: xe-471-fc457bcc18109467961edc92c80b238009f6a9fb -> xe-472-5a3a6fdda31fc8fa60db6d2fa30bd4db2509eb8b

  IGTPW_10122: 10122
  IGT_7574: 0485a4bf66f69aaf7244a3e689402b522f636780 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-471-fc457bcc18109467961edc92c80b238009f6a9fb: fc457bcc18109467961edc92c80b238009f6a9fb
  xe-472-5a3a6fdda31fc8fa60db6d2fa30bd4db2509eb8b: 5a3a6fdda31fc8fa60db6d2fa30bd4db2509eb8b

== Logs ==

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

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

[igt-dev] ✓ Fi.CI.BAT: success for Initial SR-IOV validation

[Patchwork]

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

== Series Details ==

Series: Initial SR-IOV validation
URL   : https://patchwork.freedesktop.org/series/126034/
State : success

== Summary ==

CI Bug Log - changes from CI_DRM_13844 -> IGTPW_10122
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

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

Participating hosts (33 -> 33)
------------------------------

  Additional (2): fi-kbl-soraka fi-hsw-4770 
  Missing    (2): fi-skl-guc fi-snb-2520m 

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

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

### IGT changes ###

#### Issues hit ####

  * igt@gem_huc_copy@huc-copy:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][1] ([fdo#109271] / [i915#2190])
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-soraka/igt@gem_huc_copy@huc-copy.html

  * igt@gem_lmem_swapping@basic:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][2] ([fdo#109271] / [i915#4613]) +3 other tests skip
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-soraka/igt@gem_lmem_swapping@basic.html

  * igt@i915_selftest@live@gt_heartbeat:
    - fi-kbl-soraka:      NOTRUN -> [DMESG-FAIL][3] ([i915#5334] / [i915#7872])
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-soraka/igt@i915_selftest@live@gt_heartbeat.html

  * igt@i915_selftest@live@gt_pm:
    - fi-kbl-soraka:      NOTRUN -> [DMESG-FAIL][4] ([i915#1886])
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-soraka/igt@i915_selftest@live@gt_pm.html

  * igt@i915_suspend@basic-s3-without-i915:
    - bat-rpls-1:         NOTRUN -> [ABORT][5] ([i915#7978] / [i915#9631])
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/bat-rpls-1/igt@i915_suspend@basic-s3-without-i915.html

  * igt@kms_addfb_basic@addfb25-y-tiled-small-legacy:
    - fi-hsw-4770:        NOTRUN -> [SKIP][6] ([fdo#109271] / [i915#5190])
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-hsw-4770/igt@kms_addfb_basic@addfb25-y-tiled-small-legacy.html

  * igt@kms_dsc@dsc-basic:
    - fi-kbl-soraka:      NOTRUN -> [SKIP][7] ([fdo#109271]) +9 other tests skip
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-soraka/igt@kms_dsc@dsc-basic.html

  * igt@kms_hdmi_inject@inject-audio:
    - fi-kbl-guc:         [PASS][8] -> [FAIL][9] ([IGT#3])
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/fi-kbl-guc/igt@kms_hdmi_inject@inject-audio.html
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-kbl-guc/igt@kms_hdmi_inject@inject-audio.html

  * igt@kms_pipe_crc_basic@compare-crc-sanitycheck-nv12@pipe-a-vga-1:
    - fi-hsw-4770:        NOTRUN -> [SKIP][10] ([fdo#109271]) +12 other tests skip
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-hsw-4770/igt@kms_pipe_crc_basic@compare-crc-sanitycheck-nv12@pipe-a-vga-1.html

  * igt@kms_pipe_crc_basic@nonblocking-crc-frame-sequence:
    - bat-adlp-9:         NOTRUN -> [SKIP][11] ([i915#3546]) +2 other tests skip
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/bat-adlp-9/igt@kms_pipe_crc_basic@nonblocking-crc-frame-sequence.html

  * igt@kms_pipe_crc_basic@suspend-read-crc@pipe-c-vga-1:
    - fi-hsw-4770:        NOTRUN -> [DMESG-WARN][12] ([i915#8841]) +6 other tests dmesg-warn
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-hsw-4770/igt@kms_pipe_crc_basic@suspend-read-crc@pipe-c-vga-1.html

  * igt@kms_psr@sprite_plane_onoff:
    - fi-hsw-4770:        NOTRUN -> [SKIP][13] ([fdo#109271] / [i915#1072]) +3 other tests skip
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-hsw-4770/igt@kms_psr@sprite_plane_onoff.html

  
#### Possible fixes ####

  * igt@gem_exec_suspend@basic-s0@smem:
    - fi-rkl-11600:       [FAIL][14] ([fdo#103375]) -> [PASS][15]
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/fi-rkl-11600/igt@gem_exec_suspend@basic-s0@smem.html
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-rkl-11600/igt@gem_exec_suspend@basic-s0@smem.html

  * igt@i915_selftest@live@gt_heartbeat:
    - fi-apl-guc:         [DMESG-FAIL][16] ([i915#5334]) -> [PASS][17]
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/fi-apl-guc/igt@i915_selftest@live@gt_heartbeat.html
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/fi-apl-guc/igt@i915_selftest@live@gt_heartbeat.html

  * igt@i915_selftest@live@workarounds:
    - bat-rpls-1:         [INCOMPLETE][18] -> [PASS][19]
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/bat-rpls-1/igt@i915_selftest@live@workarounds.html
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/bat-rpls-1/igt@i915_selftest@live@workarounds.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [IGT#3]: https://gitlab.freedesktop.org/drm/igt-gpu-tools/issues/3
  [fdo#103375]: https://bugs.freedesktop.org/show_bug.cgi?id=103375
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
  [i915#1886]: https://gitlab.freedesktop.org/drm/intel/issues/1886
  [i915#2190]: https://gitlab.freedesktop.org/drm/intel/issues/2190
  [i915#3546]: https://gitlab.freedesktop.org/drm/intel/issues/3546
  [i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
  [i915#5190]: https://gitlab.freedesktop.org/drm/intel/issues/5190
  [i915#5334]: https://gitlab.freedesktop.org/drm/intel/issues/5334
  [i915#7872]: https://gitlab.freedesktop.org/drm/intel/issues/7872
  [i915#7978]: https://gitlab.freedesktop.org/drm/intel/issues/7978
  [i915#8841]: https://gitlab.freedesktop.org/drm/intel/issues/8841
  [i915#9631]: https://gitlab.freedesktop.org/drm/intel/issues/9631


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

  * CI: CI-20190529 -> None
  * IGT: IGT_7574 -> IGTPW_10122

  CI-20190529: 20190529
  CI_DRM_13844: 98a039fc048898d9ecec16153267968fd18a5a52 @ git://anongit.freedesktop.org/gfx-ci/linux
  IGTPW_10122: 10122
  IGT_7574: 0485a4bf66f69aaf7244a3e689402b522f636780 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git


Testlist changes
----------------

+igt@sriov_basic@bind-unbind-vf
+igt@sriov_basic@enable-vfs-autoprobe-off
+igt@sriov_basic@enable-vfs-autoprobe-on
+igt@sriov_basic@enable-vfs-bind-all-unbind-all
+igt@sriov_basic@enable-vfs-bind-unbind-each

== Logs ==

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

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

Re: [igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Michal Wajdeczko]

On 06.11.2023 20:59, Lukasz Laguna wrote:
> From: Katarzyna Dec <katarzyna.dec@intel.com>
> 
> Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.
> 
> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
> ---
>  lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
>  lib/igt_sriov_device.h |  20 +++++
>  lib/meson.build        |   1 +
>  3 files changed, 195 insertions(+)
>  create mode 100644 lib/igt_sriov_device.c
>  create mode 100644 lib/igt_sriov_device.h
> 
> diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
> new file mode 100644
> index 000000000..7d53c2045
> --- /dev/null
> +++ b/lib/igt_sriov_device.c
> @@ -0,0 +1,174 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
> + */
> +
> +#include "igt_core.h"
> +#include "igt_sriov_device.h"
> +#include "igt_sysfs.h"
> +
> +/**
> + * igt_sriov_is_pf:

nit: short function description missing, not required anymore?

> + * @device: device file descriptor
> + *
> + * Check if device is PF by checking existence of sriov_totalvfs file
> + * and non-zero value read from that file.

just to clarify/be precise, do you want to check here "device"
capability or "driver" capability ?

IIRC the PCI subsystem will set these attributes on the "PF device" even
if attached "PF driver" does not provide required hook to enable VFs
(and this is main purpose of being a "PF", no?)

> + *
> + * Returns:
> + * True if device is PF, false otherwise.
> + */
> +bool igt_sriov_is_pf(int device)
> +{
> +	int sysfs;
> +	bool ret;
> +	uint32_t totalvfs;

nit: we shouldn't specify width if not needed, maybe plain unsigned int
will just work ? shame that there are no __igt_sysfs_get_uint()

> +
> +	sysfs = igt_sysfs_open(device);
> +	igt_assert_fd(sysfs);
> +
> +	ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs", &totalvfs);
> +	close(sysfs);
> +
> +	if (!ret)
> +		return false;
> +
> +	return totalvfs > 0;
> +}
> +
> +static uint32_t __pf_attr_get_u32(int pf, const char *attr)
> +{
> +	int sysfs;
> +	uint32_t value;
> +
> +	igt_assert(igt_sriov_is_pf(pf));
> +
> +	sysfs = igt_sysfs_open(pf);
> +	igt_assert_fd(sysfs);
> +
> +	value = igt_sysfs_get_u32(sysfs, attr);
> +	close(sysfs);
> +
> +	return value;
> +}
> +
> +static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
> +{
> +	int sysfs;
> +	bool ret;
> +
> +	igt_assert(igt_sriov_is_pf(pf));
> +
> +	sysfs = igt_sysfs_open(pf);
> +	igt_assert_fd(sysfs);
> +
> +	ret = __igt_sysfs_set_u32(sysfs, attr, value);
> +	close(sysfs);
> +
> +	return ret;
> +}
> +
> +/**
> + * igt_sriov_get_totalvfs:
> + * @pf: PF device file descriptor
> + *
> + * Get maximum number of VFs that can be enabled.
> + *
> + * Returns:
> + * Maximum number of VFs that could be associated with given PF.
> + */
> +unsigned int igt_sriov_get_total_vfs(int pf)
> +{
> +	return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
> +}
> +
> +/**
> + * igt_sriov_get_numvfs:
> + * @pf: PF device file descriptor
> + *
> + * Get number of enabled VFs.
> + *
> + * Returns:
> + * Number of VFs enabled by given PF.
> + */
> +unsigned int igt_sriov_get_enabled_vfs(int pf)
> +{
> +	return __pf_attr_get_u32(pf, "device/sriov_numvfs");
> +}
> +
> +/**
> + * igt_sriov_enable_vfs:

Helper for VFs enabling

> + * @pf: PF device file descriptor
> + * @num_vfs: Number of virtual functions to be enabled
> + *
> + * Helper for VFs enabling.

"This will try to enable VFs by writing @num_vfs to ...

> + *
> + * Returns:
> + * True on success and false on failure.
> + */
> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
> +{
> +	igt_assert(num_vfs > 0);
> +	igt_debug("Enabling %u VFs\n", num_vfs);
> +	return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
> +}
> +
> +/**
> + * igt_sriov_disable_vfs:

Helper for VFs disabling

> + * @pf: PF device file descriptor
> + *
> + * Set 0 in sriov_numvfs file to disable VFs.

"This will try to disable already enabled VFs by writing 0 to ...

> + *
> + * Returns:
> + * True on success and false on failure.
> + */
> +bool igt_sriov_disable_vfs(int pf)
> +{
> +	igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));

this will trigger unnecessary "read" operation just for debug purposes,
while in log you should already see "Enabling N VFs", so we know the N.

> +	return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
> +}
> +
> +/**
> + * igt_sriov_is_driver_autoprobe_enabled:
> + * @pf: PF device file descriptor
> + *
> + * Get current driver autoprobe setting.

hmm, this is SRIOV driver autoprobe (or VF driver autoprobe for
short/clarity)

> + *
> + * Returns:
> + * True if autoprobe is enabled, false otherwise.
> + */
> +bool igt_sriov_is_driver_autoprobe_enabled(int pf)
> +{
> +	return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
> +}
> +
> +/**
> + * igt_sriov_enable_driver_autoprobe:
> + * @pf: PF device file descriptor
> + *
> + * Set driver autoprobe to true.
> + *
> + * During VFs enabling driver will be bound to VFs.

"If successful, then kernel will automatically bind VFs to a compatible
driver immediately after they are enabled.

> + *
> + * Return:
> + * True if setting driver autoprobe succeed, otherwise false.
> + */
> +bool igt_sriov_enable_driver_autoprobe(int pf)
> +{
> +	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", true);
> +}
> +
> +/**
> + * igt_sriov_disable_driver_autoprobe:
> + * @pf: PF device file descriptor
> + *
> + * Set driver autoprobe to false.
> + *
> + * During VFs enabling driver won't be bound to VFs.
> + *
> + * Return:
> + * True if setting driver autoprobe succeed, otherwise false.
> + */
> +bool igt_sriov_disable_driver_autoprobe(int pf)
> +{
> +	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", false);
> +}
> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
> new file mode 100644
> index 000000000..f2c5c44fa
> --- /dev/null
> +++ b/lib/igt_sriov_device.h
> @@ -0,0 +1,20 @@
> +/* SPDX-License-Identifier: MIT */
> +/*
> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
> + */
> +
> +#ifndef __IGT_SRIOV_DEVICE_H__
> +#define __IGT_SRIOV_DEVICE_H__
> +
> +#include <stdint.h>
> +
> +bool igt_sriov_is_pf(int device);
> +unsigned int igt_sriov_get_total_vfs(int pf);
> +unsigned int igt_sriov_get_enabled_vfs(int pf);
> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
> +bool igt_sriov_disable_vfs(int pf);
> +bool igt_sriov_is_driver_autoprobe_enabled(int pf);
> +bool igt_sriov_enable_driver_autoprobe(int pf);
> +bool igt_sriov_disable_driver_autoprobe(int pf);

nit: I'm wondering if there is any pattern to have:

a) void function that has igt_assert() inside
b) bool function that has no igt_assert() inside

then for writing scenario you just use a) without need to check
and use b) only when doing lower level testing and use dedicated checks

> +
> +#endif /* __IGT_SRIOV_DEVICE_H__ */
> diff --git a/lib/meson.build b/lib/meson.build
> index a7bccafc3..083baa68a 100644
> --- a/lib/meson.build
> +++ b/lib/meson.build
> @@ -38,6 +38,7 @@ lib_sources = [
>  	'igt_primes.c',
>  	'igt_pci.c',
>  	'igt_rand.c',
> +	'igt_sriov_device.c',
>  	'igt_stats.c',
>  	'igt_syncobj.c',
>  	'igt_sysfs.c',

Re: [igt-dev] [PATCH i-g-t 4/8] lib/igt_sriov_device: add helpers for operations in different VFs scenarios

[Michal Wajdeczko]

On 06.11.2023 20:59, Lukasz Laguna wrote:
> Added helpers:
> - for_each_vf and for_each_num_vfs
> - for_random_vf and for_random_num_vfs
> - for_last_vf and for_max_num_vfs
> 
> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
> ---
>  lib/igt_sriov_device.h | 18 ++++++++++++++++++
>  1 file changed, 18 insertions(+)
> 
> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
> index be4e56cf3..78cb0e73b 100644
> --- a/lib/igt_sriov_device.h
> +++ b/lib/igt_sriov_device.h
> @@ -19,4 +19,22 @@ bool igt_sriov_disable_driver_autoprobe(int pf);
>  int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
>  bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num);
>  

please document macros and their params

> +#define for_each_vf(__pf_fd, __vf_num) \
> +	for (unsigned int __vf_num = 1, __total_vfs = igt_sriov_get_total_vfs(__pf_fd); \
> +	     __vf_num <= __total_vfs; \
> +	     ++__vf_num)
> +#define for_each_num_vfs for_each_vf

why do you need this alias ?

> +
> +#define for_random_vf(__pf_fd, __vf_num) \
> +	for (unsigned int __vf_num = 1 + random() % igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
> +	     __tmp < 1; \
> +	     ++__tmp)
> +#define for_random_num_vfs for_random_vf
> +
> +#define for_last_vf(__pf_fd, __vf_num) \
> +	for (unsigned int __vf_num = igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
> +	     __tmp < 1; \
> +	     ++__tmp)
> +#define for_max_num_vfs for_last_vf
> +
>  #endif /* __IGT_SRIOV_DEVICE_H__ */

Re: [igt-dev] [PATCH i-g-t 5/8] tests/sriov_basic: add basic tests for enabling SR-IOV VFs

[Michal Wajdeczko]

On 06.11.2023 20:59, Lukasz Laguna wrote:
> From: Katarzyna Dec <katarzyna.dec@intel.com>
> 
> Add subtests that validate SR-IOV VFs enabling in two variants: with
> autoprobe disabled and enabled.
> 
> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
> ---
>  tests/meson.build   |   1 +
>  tests/sriov_basic.c | 126 ++++++++++++++++++++++++++++++++++++++++++++
>  2 files changed, 127 insertions(+)
>  create mode 100644 tests/sriov_basic.c
> 
> diff --git a/tests/meson.build b/tests/meson.build
> index 62721157d..7413d978c 100644
> --- a/tests/meson.build
> +++ b/tests/meson.build
> @@ -71,6 +71,7 @@ test_progs = [
>  	'panfrost_submit',
>  	'prime_udl',
>  	'prime_vgem',
> +	'sriov_basic',
>  	'syncobj_basic',
>  	'syncobj_eventfd',
>  	'syncobj_wait',
> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
> new file mode 100644
> index 000000000..fc0914962
> --- /dev/null
> +++ b/tests/sriov_basic.c
> @@ -0,0 +1,126 @@
> +// SPDX-License-Identifier: MIT
> +/*
> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
> + */
> +
> +#include "drmtest.h"
> +#include "igt_core.h"
> +#include "igt_sriov_device.h"
> +
> +IGT_TEST_DESCRIPTION("Basic tests for enabling SR-IOV Virtual Functions");
> +
> +/**
> + * TEST: sriov_basic
> + * Category: Software building block
> + * Mega feature: SR-IOV
> + * Sub-category: VFs enabling
> + * Run type: BAT
> + * Description: Validate SR-IOV VFs enabling
> + */
> +
> +/**
> + * SUBTEST: enable-vfs-autoprobe-off
> + * Description:
> + *   Verify VFs enabling without probing VF driver
> + */
> +static void enable_disable_vfs(int pf_fd, unsigned int num_vfs)

	"enable-vfs-autoprobe-off"
and
	"enable_disable_vfs"
are different
shouldn't they match somehow ?

> +{
> +	igt_debug("Using num_vfs=%u\n", num_vfs);
> +
> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);

this seems to duplicate first fixture, do we really need to repeat that
over and over ?

> +	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
> +	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));

this seems crazy and unrelated to test scope - we are not checking here
the behavior of the "driver_autoprobe" attribute, we should just trust
that 'disable' above worked since it returned true and we already
asserted that

> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));

this should be "expect" type of check, as we still want to disable VFs

> +	igt_assert(igt_sriov_disable_vfs(pf_fd));

maybe assert here that enabled_vfs == num_vfs ?

> +}
> +
> +/**
> + * SUBTEST: enable-vfs-autoprobe-on
> + * Description:
> + *   Verify VFs enabling and auto-probing VF driver
> + */
> +static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)

here is even more different

	"enable-vfs-autoprobe-on"
vs
	"probe_disable_vfs"

also "probe" here may clash with future test that will "probe" just
selected VF

> +{
> +	bool err = false;
> +
> +	igt_debug("Using num_vfs=%u\n", num_vfs);
> +
> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);

ditto

> +	igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
> +	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));

ditto

> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));

ditto

> +	for (int vf_num = 1; vf_num <= num_vfs; ++vf_num) {
> +		if (!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num)) {
> +			igt_debug("VF%u probe failed\n", vf_num);
> +			err = true;
> +		}
> +	}
> +	igt_assert(igt_sriov_disable_vfs(pf_fd));

disabling VFs immediately after enabling could be treated as a "stress"
test - shouldn't we have some grace period for a "basic" class test ?

stress loop with probe/unload could be different test case

> +	igt_assert(!err);
> +}
> +
> +igt_main
> +{
> +	int pf_fd;
> +	bool autoprobe;
> +
> +	igt_fixture {
> +		pf_fd = drm_open_driver(DRIVER_ANY);
> +		igt_require(igt_sriov_is_pf(pf_fd));
> +		igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
> +		autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
> +
> +		igt_srandom();

shouldn't this be part of the main() or something ?

> +	}
> +
> +	igt_describe("Verify VFs enabling without probing VF driver");
> +	igt_subtest_with_dynamic("enable-vfs-autoprobe-off") {
> +		for_each_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-%u", num_vfs) {
> +				enable_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +		for_random_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-random") {
> +				enable_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +		for_max_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-all") {
> +				enable_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +	}
> +
> +	igt_describe("Verify VFs enabling and auto-probing VF driver");
> +	igt_subtest_with_dynamic("enable-vfs-autoprobe-on") {
> +		for_each_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-%u", num_vfs) {
> +				probe_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +		for_random_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-random") {
> +				probe_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +		for_max_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-all") {
> +				probe_disable_vfs(pf_fd, num_vfs);
> +			}
> +		}
> +	}
> +
> +	igt_fixture {
> +		igt_sriov_disable_vfs(pf_fd);
> +		/* abort to avoid execution of next tests with enabled VFs */
> +		igt_abort_on_f(igt_sriov_get_enabled_vfs(pf_fd) > 0, "Failed to disable VF(s)");

can't this be just:

	igt_abort_on_f(!igt_sriov_disable_vfs(pf_fd), "");
	igt_abort_on_f(!igt_sriov_set_driver_autoprobe(autoprobe), "");

> +		autoprobe ? igt_sriov_enable_driver_autoprobe(pf_fd) :
> +			    igt_sriov_disable_driver_autoprobe(pf_fd);
> +		igt_abort_on_f(autoprobe != igt_sriov_is_driver_autoprobe_enabled(pf_fd),
> +			       "Failed to restore sriov_drivers_autoprobe value\n");
> +		close(pf_fd);
> +	}
> +}

Re: [igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Michal Wajdeczko]

On 06.11.2023 20:59, Lukasz Laguna wrote:
> From: Katarzyna Dec <katarzyna.dec@intel.com>
> 
> Test enables VFs in range <1..totalvfs>, bind driver to all of them and
> then unbind driver from all of them.

commit message seems outdated

> 
> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
> ---
>  tests/sriov_basic.c | 51 +++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 51 insertions(+)
> 
> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
> index fc0914962..179731daf 100644
> --- a/tests/sriov_basic.c
> +++ b/tests/sriov_basic.c
> @@ -61,6 +61,38 @@ static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
>  	igt_assert(!err);
>  }
>  
> +/**
> + * SUBTEST: enable-vfs-bind-all-unbind-all
> + * Description:
> + *   Verify VFs enabling, binding the driver and then unbinding it from all of them
> + */
> +static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
> +{
> +	igt_debug("Using num_vfs=%u\n", num_vfs);

nit: "Testing %u VFs" ?

> +
> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);

duplicates main fixture

> +	igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
> +	igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));

why do we need warn/skip here ?
can't we just assert that 'disable' worked ?

> +
> +	igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));

can't we just assert ?

> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));

why we care here ? if not all are enabled then we fail just later
and this is not a test for "enable VFs" that enabled==requested

> +	igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
> +	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));

can't we just warn ?
if that we fail to enable then probe below will fail anyway

> +
> +	for (int i = 1; i <= num_vfs; i++) {
> +		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
> +		igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
> +		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));

shouldn't we just "expect" to make sure to call "disable VFs" ?

> +	}
> +
> +	for (int i = 1; i <= num_vfs; i++) {
> +		igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
> +		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));

do we need to have all VFs loaded ?
maybe for BAT test we can just bind/unload one VF at the time ?

otherwise it will be almost the same level of stress as in
"enable-vfs-autoprobe-on" but with 'manual probe' loop of all VFs

> +	}
> +
> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
> +}
> +
>  igt_main
>  {
>  	int pf_fd;
> @@ -113,6 +145,25 @@ igt_main
>  		}
>  	}
>  
> +	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
> +	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
> +		for_each_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-%u", num_vfs) {
> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
> +			}
> +		}
> +		for_random_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-random") {
> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
> +			}
> +		}
> +		for_max_num_vfs(pf_fd, num_vfs) {
> +			igt_dynamic_f("numvfs-all") {
> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
> +			}
> +		}
> +	}
> +
>  	igt_fixture {
>  		igt_sriov_disable_vfs(pf_fd);
>  		/* abort to avoid execution of next tests with enabled VFs */

[igt-dev] ✗ Fi.CI.IGT: failure for Initial SR-IOV validation

[Patchwork]

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

== Series Details ==

Series: Initial SR-IOV validation
URL   : https://patchwork.freedesktop.org/series/126034/
State : failure

== Summary ==

CI Bug Log - changes from CI_DRM_13844_full -> IGTPW_10122_full
====================================================

Summary
-------

  **FAILURE**

  Serious unknown changes coming with IGTPW_10122_full absolutely need to be
  verified manually.
  
  If you think the reported changes have nothing to do with the changes
  introduced in IGTPW_10122_full, please notify your bug team (lgci.bug.filing@intel.com) to allow them
  to document this new failure mode, which will reduce false positives in CI.

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

Participating hosts (11 -> 12)
------------------------------

  Additional (1): shard-tglu0 

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

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

### IGT changes ###

#### Possible regressions ####

  * igt@i915_selftest@live@execlists:
    - shard-glk:          [PASS][1] -> [ABORT][2]
   [1]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-glk1/igt@i915_selftest@live@execlists.html
   [2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk3/igt@i915_selftest@live@execlists.html

  * igt@kms_flip@dpms-off-confusion@a-dp1:
    - shard-apl:          [PASS][3] -> [INCOMPLETE][4]
   [3]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-apl7/igt@kms_flip@dpms-off-confusion@a-dp1.html
   [4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl6/igt@kms_flip@dpms-off-confusion@a-dp1.html

  * {igt@sriov_basic@bind-unbind-vf} (NEW):
    - shard-dg2:          NOTRUN -> [SKIP][5] +3 other tests skip
   [5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@sriov_basic@bind-unbind-vf.html
    - shard-rkl:          NOTRUN -> [SKIP][6] +3 other tests skip
   [6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@sriov_basic@bind-unbind-vf.html
    - shard-dg1:          NOTRUN -> [SKIP][7] +4 other tests skip
   [7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-13/igt@sriov_basic@bind-unbind-vf.html

  * {igt@sriov_basic@enable-vfs-autoprobe-on} (NEW):
    - shard-tglu:         NOTRUN -> [SKIP][8] +4 other tests skip
   [8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-7/igt@sriov_basic@enable-vfs-autoprobe-on.html

  * {igt@sriov_basic@enable-vfs-bind-all-unbind-all} (NEW):
    - shard-mtlp:         NOTRUN -> [SKIP][9] +4 other tests skip
   [9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@sriov_basic@enable-vfs-bind-all-unbind-all.html

  
#### Suppressed ####

  The following results come from untrusted machines, tests, or statuses.
  They do not affect the overall result.

  * {igt@drm_fdinfo@context-close-stress}:
    - shard-dg2:          NOTRUN -> [SKIP][10]
   [10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@drm_fdinfo@context-close-stress.html

  
New tests
---------

  New tests have been introduced between CI_DRM_13844_full and IGTPW_10122_full:

### New IGT tests (5) ###

  * igt@sriov_basic@bind-unbind-vf:
    - Statuses : 7 skip(s)
    - Exec time: [0.0] s

  * igt@sriov_basic@enable-vfs-autoprobe-off:
    - Statuses : 8 skip(s)
    - Exec time: [0.0] s

  * igt@sriov_basic@enable-vfs-autoprobe-on:
    - Statuses : 6 skip(s)
    - Exec time: [0.0] s

  * igt@sriov_basic@enable-vfs-bind-all-unbind-all:
    - Statuses : 8 skip(s)
    - Exec time: [0.0] s

  * igt@sriov_basic@enable-vfs-bind-unbind-each:
    - Statuses : 8 skip(s)
    - Exec time: [0.0] s

  

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

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

### IGT changes ###

#### Issues hit ####

  * igt@api_intel_bb@blit-reloc-keep-cache:
    - shard-rkl:          [PASS][11] -> [SKIP][12] ([i915#8411])
   [11]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@api_intel_bb@blit-reloc-keep-cache.html
   [12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@api_intel_bb@blit-reloc-keep-cache.html

  * igt@drm_fdinfo@idle@rcs0:
    - shard-rkl:          NOTRUN -> [FAIL][13] ([i915#7742])
   [13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@drm_fdinfo@idle@rcs0.html

  * igt@drm_fdinfo@most-busy-check-all@bcs0:
    - shard-dg2:          NOTRUN -> [SKIP][14] ([i915#8414]) +30 other tests skip
   [14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@drm_fdinfo@most-busy-check-all@bcs0.html

  * igt@drm_fdinfo@most-busy-check-all@rcs0:
    - shard-rkl:          [PASS][15] -> [FAIL][16] ([i915#7742])
   [15]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@drm_fdinfo@most-busy-check-all@rcs0.html
   [16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@drm_fdinfo@most-busy-check-all@rcs0.html

  * igt@drm_read@short-buffer-nonblock:
    - shard-rkl:          [PASS][17] -> [SKIP][18] ([i915#4098]) +2 other tests skip
   [17]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-7/igt@drm_read@short-buffer-nonblock.html
   [18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@drm_read@short-buffer-nonblock.html

  * igt@gem_ccs@block-copy-uncompressed:
    - shard-rkl:          NOTRUN -> [SKIP][19] ([i915#7957])
   [19]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_ccs@block-copy-uncompressed.html

  * igt@gem_ccs@block-multicopy-compressed:
    - shard-rkl:          NOTRUN -> [SKIP][20] ([i915#9323])
   [20]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_ccs@block-multicopy-compressed.html

  * igt@gem_ccs@ctrl-surf-copy-new-ctx:
    - shard-rkl:          NOTRUN -> [SKIP][21] ([i915#4098] / [i915#9323])
   [21]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_ccs@ctrl-surf-copy-new-ctx.html

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

  * igt@gem_create@create-ext-set-pat:
    - shard-rkl:          NOTRUN -> [SKIP][23] ([i915#8562])
   [23]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_create@create-ext-set-pat.html

  * igt@gem_ctx_param@set-priority-not-supported:
    - shard-rkl:          NOTRUN -> [SKIP][24] ([fdo#109314])
   [24]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_ctx_param@set-priority-not-supported.html

  * igt@gem_ctx_persistence@engines-hostile:
    - shard-snb:          NOTRUN -> [SKIP][25] ([fdo#109271] / [i915#1099])
   [25]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb1/igt@gem_ctx_persistence@engines-hostile.html

  * igt@gem_ctx_persistence@heartbeat-hang:
    - shard-dg2:          NOTRUN -> [SKIP][26] ([i915#8555])
   [26]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_ctx_persistence@heartbeat-hang.html

  * igt@gem_ctx_persistence@saturated-hostile-nopreempt@ccs0:
    - shard-dg2:          NOTRUN -> [SKIP][27] ([i915#5882]) +9 other tests skip
   [27]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_ctx_persistence@saturated-hostile-nopreempt@ccs0.html

  * igt@gem_ctx_sseu@invalid-args:
    - shard-dg2:          NOTRUN -> [SKIP][28] ([i915#280])
   [28]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-5/igt@gem_ctx_sseu@invalid-args.html
    - shard-rkl:          NOTRUN -> [SKIP][29] ([i915#280])
   [29]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_ctx_sseu@invalid-args.html

  * igt@gem_exec_balancer@bonded-dual:
    - shard-mtlp:         NOTRUN -> [SKIP][30] ([i915#4771])
   [30]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@gem_exec_balancer@bonded-dual.html

  * igt@gem_exec_balancer@bonded-sync:
    - shard-dg2:          NOTRUN -> [SKIP][31] ([i915#4771])
   [31]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@gem_exec_balancer@bonded-sync.html

  * igt@gem_exec_balancer@parallel-balancer:
    - shard-rkl:          NOTRUN -> [SKIP][32] ([i915#4525]) +2 other tests skip
   [32]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_exec_balancer@parallel-balancer.html
    - shard-snb:          NOTRUN -> [SKIP][33] ([fdo#109271]) +50 other tests skip
   [33]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb6/igt@gem_exec_balancer@parallel-balancer.html

  * igt@gem_exec_balancer@sliced:
    - shard-dg2:          NOTRUN -> [SKIP][34] ([i915#4812]) +1 other test skip
   [34]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@gem_exec_balancer@sliced.html

  * igt@gem_exec_capture@many-4k-incremental:
    - shard-rkl:          NOTRUN -> [FAIL][35] ([i915#9606])
   [35]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_exec_capture@many-4k-incremental.html

  * igt@gem_exec_fair@basic-none-solo:
    - shard-mtlp:         NOTRUN -> [SKIP][36] ([i915#4473])
   [36]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@gem_exec_fair@basic-none-solo.html

  * igt@gem_exec_fair@basic-none@bcs0:
    - shard-rkl:          NOTRUN -> [FAIL][37] ([i915#2842]) +4 other tests fail
   [37]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_exec_fair@basic-none@bcs0.html

  * igt@gem_exec_fair@basic-pace-solo@rcs0:
    - shard-glk:          [PASS][38] -> [FAIL][39] ([i915#2842])
   [38]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-glk1/igt@gem_exec_fair@basic-pace-solo@rcs0.html
   [39]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk9/igt@gem_exec_fair@basic-pace-solo@rcs0.html

  * igt@gem_exec_fair@basic-pace@vcs1:
    - shard-tglu:         NOTRUN -> [FAIL][40] ([i915#2842]) +4 other tests fail
   [40]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-4/igt@gem_exec_fair@basic-pace@vcs1.html

  * igt@gem_exec_fair@basic-pace@vecs0:
    - shard-rkl:          [PASS][41] -> [FAIL][42] ([i915#2842]) +2 other tests fail
   [41]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_exec_fair@basic-pace@vecs0.html
   [42]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_exec_fair@basic-pace@vecs0.html

  * igt@gem_exec_fair@basic-sync:
    - shard-dg2:          NOTRUN -> [SKIP][43] ([i915#3539])
   [43]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@gem_exec_fair@basic-sync.html

  * igt@gem_exec_flush@basic-uc-pro-default:
    - shard-dg2:          NOTRUN -> [SKIP][44] ([i915#3539] / [i915#4852]) +3 other tests skip
   [44]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@gem_exec_flush@basic-uc-pro-default.html

  * igt@gem_exec_params@secure-non-master:
    - shard-dg2:          NOTRUN -> [SKIP][45] ([fdo#112283]) +1 other test skip
   [45]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@gem_exec_params@secure-non-master.html

  * igt@gem_exec_params@secure-non-root:
    - shard-mtlp:         NOTRUN -> [SKIP][46] ([fdo#112283])
   [46]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@gem_exec_params@secure-non-root.html

  * igt@gem_exec_reloc@basic-gtt-cpu:
    - shard-rkl:          NOTRUN -> [SKIP][47] ([i915#3281]) +12 other tests skip
   [47]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_exec_reloc@basic-gtt-cpu.html

  * igt@gem_exec_reloc@basic-gtt-read:
    - shard-dg2:          NOTRUN -> [SKIP][48] ([i915#3281]) +13 other tests skip
   [48]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_exec_reloc@basic-gtt-read.html

  * igt@gem_exec_reloc@basic-softpin:
    - shard-mtlp:         NOTRUN -> [SKIP][49] ([i915#3281])
   [49]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@gem_exec_reloc@basic-softpin.html

  * igt@gem_exec_schedule@preempt-queue-contexts:
    - shard-dg2:          NOTRUN -> [SKIP][50] ([i915#4537] / [i915#4812])
   [50]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_exec_schedule@preempt-queue-contexts.html

  * igt@gem_exec_suspend@basic-s3@smem:
    - shard-mtlp:         [PASS][51] -> [ABORT][52] ([i915#8213] / [i915#9414]) +1 other test abort
   [51]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-mtlp-7/igt@gem_exec_suspend@basic-s3@smem.html
   [52]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@gem_exec_suspend@basic-s3@smem.html

  * igt@gem_exec_suspend@basic-s4-devices@smem:
    - shard-rkl:          NOTRUN -> [ABORT][53] ([i915#7975] / [i915#8213])
   [53]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_exec_suspend@basic-s4-devices@smem.html

  * igt@gem_fenced_exec_thrash@no-spare-fences-busy-interruptible:
    - shard-dg2:          NOTRUN -> [SKIP][54] ([i915#4860])
   [54]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@gem_fenced_exec_thrash@no-spare-fences-busy-interruptible.html

  * igt@gem_lmem_swapping@heavy-random:
    - shard-rkl:          NOTRUN -> [SKIP][55] ([i915#4613]) +2 other tests skip
   [55]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_lmem_swapping@heavy-random.html

  * igt@gem_lmem_swapping@heavy-verify-multi:
    - shard-glk:          NOTRUN -> [SKIP][56] ([fdo#109271] / [i915#4613]) +1 other test skip
   [56]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk3/igt@gem_lmem_swapping@heavy-verify-multi.html

  * igt@gem_lmem_swapping@smem-oom:
    - shard-mtlp:         NOTRUN -> [SKIP][57] ([i915#4613]) +2 other tests skip
   [57]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-3/igt@gem_lmem_swapping@smem-oom.html

  * igt@gem_lmem_swapping@verify:
    - shard-apl:          NOTRUN -> [SKIP][58] ([fdo#109271] / [i915#4613]) +1 other test skip
   [58]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl2/igt@gem_lmem_swapping@verify.html

  * igt@gem_lmem_swapping@verify-random-ccs:
    - shard-tglu:         NOTRUN -> [SKIP][59] ([i915#4613])
   [59]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-10/igt@gem_lmem_swapping@verify-random-ccs.html

  * igt@gem_madvise@dontneed-before-pwrite:
    - shard-dg1:          NOTRUN -> [SKIP][60] ([i915#3282])
   [60]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-18/igt@gem_madvise@dontneed-before-pwrite.html

  * igt@gem_mmap@short-mmap:
    - shard-dg2:          NOTRUN -> [SKIP][61] ([i915#4083]) +10 other tests skip
   [61]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_mmap@short-mmap.html

  * igt@gem_mmap_gtt@isolation:
    - shard-mtlp:         NOTRUN -> [SKIP][62] ([i915#4077])
   [62]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@gem_mmap_gtt@isolation.html

  * igt@gem_partial_pwrite_pread@reads-uncached:
    - shard-dg2:          NOTRUN -> [SKIP][63] ([i915#3282]) +7 other tests skip
   [63]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_partial_pwrite_pread@reads-uncached.html

  * igt@gem_partial_pwrite_pread@writes-after-reads-uncached:
    - shard-rkl:          NOTRUN -> [SKIP][64] ([i915#3282]) +7 other tests skip
   [64]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_partial_pwrite_pread@writes-after-reads-uncached.html

  * igt@gem_pwrite@basic-random:
    - shard-rkl:          [PASS][65] -> [SKIP][66] ([i915#3282]) +9 other tests skip
   [65]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_pwrite@basic-random.html
   [66]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_pwrite@basic-random.html

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

  * igt@gem_pxp@reject-modify-context-protection-off-1:
    - shard-tglu:         NOTRUN -> [SKIP][68] ([i915#4270]) +1 other test skip
   [68]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-7/igt@gem_pxp@reject-modify-context-protection-off-1.html

  * igt@gem_pxp@verify-pxp-execution-after-suspend-resume:
    - shard-dg2:          NOTRUN -> [SKIP][69] ([i915#4270]) +5 other tests skip
   [69]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@gem_pxp@verify-pxp-execution-after-suspend-resume.html

  * igt@gem_readwrite@write-bad-handle:
    - shard-mtlp:         NOTRUN -> [SKIP][70] ([i915#3282]) +1 other test skip
   [70]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@gem_readwrite@write-bad-handle.html

  * igt@gem_render_copy@y-tiled-mc-ccs-to-y-tiled-ccs:
    - shard-rkl:          NOTRUN -> [SKIP][71] ([i915#768])
   [71]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_render_copy@y-tiled-mc-ccs-to-y-tiled-ccs.html

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

  * igt@gem_set_tiling_vs_blt@tiled-to-tiled:
    - shard-rkl:          NOTRUN -> [SKIP][73] ([i915#8411])
   [73]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_set_tiling_vs_blt@tiled-to-tiled.html

  * igt@gem_set_tiling_vs_blt@tiled-to-untiled:
    - shard-dg2:          NOTRUN -> [SKIP][74] ([i915#4079]) +3 other tests skip
   [74]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_set_tiling_vs_blt@tiled-to-untiled.html
    - shard-mtlp:         NOTRUN -> [SKIP][75] ([i915#4079])
   [75]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@gem_set_tiling_vs_blt@tiled-to-untiled.html

  * igt@gem_set_tiling_vs_pwrite:
    - shard-dg1:          NOTRUN -> [SKIP][76] ([i915#4079])
   [76]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-13/igt@gem_set_tiling_vs_pwrite.html

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

  * igt@gem_spin_batch@spin-all-new:
    - shard-dg2:          NOTRUN -> [FAIL][78] ([i915#5889])
   [78]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@gem_spin_batch@spin-all-new.html

  * igt@gem_unfence_active_buffers:
    - shard-dg2:          NOTRUN -> [SKIP][79] ([i915#4879])
   [79]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@gem_unfence_active_buffers.html

  * igt@gem_userptr_blits@dmabuf-sync:
    - shard-rkl:          NOTRUN -> [SKIP][80] ([i915#3323])
   [80]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_userptr_blits@dmabuf-sync.html

  * igt@gem_userptr_blits@dmabuf-unsync:
    - shard-mtlp:         NOTRUN -> [SKIP][81] ([i915#3297])
   [81]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@gem_userptr_blits@dmabuf-unsync.html

  * igt@gem_userptr_blits@invalid-mmap-offset-unsync:
    - shard-dg2:          NOTRUN -> [SKIP][82] ([i915#3297]) +2 other tests skip
   [82]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gem_userptr_blits@invalid-mmap-offset-unsync.html
    - shard-rkl:          NOTRUN -> [SKIP][83] ([i915#3297]) +1 other test skip
   [83]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_userptr_blits@invalid-mmap-offset-unsync.html

  * igt@gem_userptr_blits@relocations:
    - shard-rkl:          [PASS][84] -> [SKIP][85] ([i915#3281]) +7 other tests skip
   [84]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_userptr_blits@relocations.html
   [85]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_userptr_blits@relocations.html

  * igt@gem_userptr_blits@vma-merge:
    - shard-rkl:          NOTRUN -> [FAIL][86] ([i915#3318])
   [86]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@gem_userptr_blits@vma-merge.html

  * igt@gen7_exec_parse@chained-batch:
    - shard-dg2:          NOTRUN -> [SKIP][87] ([fdo#109289]) +4 other tests skip
   [87]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@gen7_exec_parse@chained-batch.html

  * igt@gen9_exec_parse@secure-batches:
    - shard-dg2:          NOTRUN -> [SKIP][88] ([i915#2856]) +5 other tests skip
   [88]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@gen9_exec_parse@secure-batches.html
    - shard-rkl:          [PASS][89] -> [SKIP][90] ([i915#2527]) +1 other test skip
   [89]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gen9_exec_parse@secure-batches.html
   [90]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gen9_exec_parse@secure-batches.html

  * igt@gen9_exec_parse@shadow-peek:
    - shard-dg1:          NOTRUN -> [SKIP][91] ([i915#2527])
   [91]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-18/igt@gen9_exec_parse@shadow-peek.html

  * igt@gen9_exec_parse@valid-registers:
    - shard-rkl:          NOTRUN -> [SKIP][92] ([i915#2527]) +3 other tests skip
   [92]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gen9_exec_parse@valid-registers.html

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-mtlp:         [PASS][93] -> [ABORT][94] ([i915#8489] / [i915#8668])
   [93]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-mtlp-5/igt@i915_module_load@reload-with-fault-injection.html
   [94]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-3/igt@i915_module_load@reload-with-fault-injection.html

  * igt@i915_module_load@resize-bar:
    - shard-rkl:          NOTRUN -> [SKIP][95] ([i915#6412])
   [95]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@i915_module_load@resize-bar.html

  * igt@i915_pm_freq_api@freq-suspend:
    - shard-rkl:          NOTRUN -> [SKIP][96] ([i915#8399]) +1 other test skip
   [96]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@i915_pm_freq_api@freq-suspend.html

  * igt@i915_pm_rc6_residency@rc6-idle@rcs0:
    - shard-dg1:          [PASS][97] -> [FAIL][98] ([i915#3591])
   [97]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-13/igt@i915_pm_rc6_residency@rc6-idle@rcs0.html
   [98]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-17/igt@i915_pm_rc6_residency@rc6-idle@rcs0.html

  * igt@i915_pm_rps@thresholds@gt0:
    - shard-dg2:          NOTRUN -> [SKIP][99] ([i915#8925])
   [99]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@i915_pm_rps@thresholds@gt0.html

  * igt@i915_power@sanity:
    - shard-rkl:          [PASS][100] -> [SKIP][101] ([i915#7984])
   [100]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@i915_power@sanity.html
   [101]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@i915_power@sanity.html

  * igt@i915_query@hwconfig_table:
    - shard-rkl:          NOTRUN -> [SKIP][102] ([i915#6245])
   [102]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@i915_query@hwconfig_table.html

  * igt@i915_query@query-topology-known-pci-ids:
    - shard-dg2:          NOTRUN -> [SKIP][103] ([fdo#109303])
   [103]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@i915_query@query-topology-known-pci-ids.html

  * igt@i915_query@query-topology-unsupported:
    - shard-rkl:          NOTRUN -> [SKIP][104] ([fdo#109302])
   [104]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@i915_query@query-topology-unsupported.html

  * igt@i915_query@test-query-geometry-subslices:
    - shard-rkl:          NOTRUN -> [SKIP][105] ([i915#5723])
   [105]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@i915_query@test-query-geometry-subslices.html

  * igt@i915_selftest@live@gt_heartbeat:
    - shard-apl:          NOTRUN -> [DMESG-FAIL][106] ([i915#5334])
   [106]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl1/igt@i915_selftest@live@gt_heartbeat.html

  * igt@i915_suspend@fence-restore-untiled:
    - shard-dg2:          NOTRUN -> [SKIP][107] ([i915#4077]) +17 other tests skip
   [107]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@i915_suspend@fence-restore-untiled.html

  * igt@kms_addfb_basic@addfb25-x-tiled-legacy:
    - shard-mtlp:         NOTRUN -> [SKIP][108] ([i915#4212]) +1 other test skip
   [108]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_addfb_basic@addfb25-x-tiled-legacy.html
    - shard-dg2:          NOTRUN -> [SKIP][109] ([i915#4212])
   [109]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_addfb_basic@addfb25-x-tiled-legacy.html

  * igt@kms_addfb_basic@tile-pitch-mismatch:
    - shard-dg2:          NOTRUN -> [SKIP][110] ([i915#4212] / [i915#5608])
   [110]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_addfb_basic@tile-pitch-mismatch.html

  * igt@kms_async_flips@invalid-async-flip:
    - shard-dg2:          NOTRUN -> [SKIP][111] ([i915#6228])
   [111]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@kms_async_flips@invalid-async-flip.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels:
    - shard-dg2:          NOTRUN -> [SKIP][112] ([i915#1769] / [i915#3555]) +1 other test skip
   [112]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-7/igt@kms_atomic_transition@plane-all-modeset-transition-fencing-internal-panels.html

  * igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels:
    - shard-apl:          NOTRUN -> [SKIP][113] ([fdo#109271] / [i915#1769])
   [113]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl3/igt@kms_atomic_transition@plane-all-modeset-transition-internal-panels.html

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

  * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0:
    - shard-dg1:          NOTRUN -> [SKIP][115] ([i915#4538] / [i915#5286])
   [115]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-15/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0.html

  * igt@kms_big_fb@linear-16bpp-rotate-90:
    - shard-dg2:          NOTRUN -> [SKIP][116] ([fdo#111614]) +8 other tests skip
   [116]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_big_fb@linear-16bpp-rotate-90.html

  * igt@kms_big_fb@x-tiled-16bpp-rotate-270:
    - shard-rkl:          NOTRUN -> [SKIP][117] ([fdo#111614] / [i915#3638]) +3 other tests skip
   [117]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_big_fb@x-tiled-16bpp-rotate-270.html

  * igt@kms_big_fb@x-tiled-64bpp-rotate-90:
    - shard-mtlp:         NOTRUN -> [SKIP][118] ([fdo#111614]) +2 other tests skip
   [118]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-3/igt@kms_big_fb@x-tiled-64bpp-rotate-90.html

  * igt@kms_big_fb@x-tiled-max-hw-stride-32bpp-rotate-180-async-flip:
    - shard-tglu:         [PASS][119] -> [FAIL][120] ([i915#3743]) +1 other test fail
   [119]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-tglu-4/igt@kms_big_fb@x-tiled-max-hw-stride-32bpp-rotate-180-async-flip.html
   [120]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-2/igt@kms_big_fb@x-tiled-max-hw-stride-32bpp-rotate-180-async-flip.html

  * igt@kms_big_fb@y-tiled-addfb-size-offset-overflow:
    - shard-dg2:          NOTRUN -> [SKIP][121] ([i915#5190]) +24 other tests skip
   [121]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@kms_big_fb@y-tiled-addfb-size-offset-overflow.html
    - shard-rkl:          NOTRUN -> [SKIP][122] ([i915#1845] / [i915#4098]) +8 other tests skip
   [122]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_big_fb@y-tiled-addfb-size-offset-overflow.html

  * igt@kms_big_fb@yf-tiled-32bpp-rotate-0:
    - shard-mtlp:         NOTRUN -> [SKIP][123] ([fdo#111615]) +3 other tests skip
   [123]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@kms_big_fb@yf-tiled-32bpp-rotate-0.html

  * igt@kms_big_fb@yf-tiled-64bpp-rotate-0:
    - shard-dg2:          NOTRUN -> [SKIP][124] ([i915#4538] / [i915#5190]) +6 other tests skip
   [124]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_big_fb@yf-tiled-64bpp-rotate-0.html

  * igt@kms_big_fb@yf-tiled-64bpp-rotate-90:
    - shard-rkl:          NOTRUN -> [SKIP][125] ([fdo#110723]) +4 other tests skip
   [125]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_big_fb@yf-tiled-64bpp-rotate-90.html

  * igt@kms_big_fb@yf-tiled-addfb:
    - shard-rkl:          NOTRUN -> [SKIP][126] ([fdo#111615])
   [126]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_big_fb@yf-tiled-addfb.html

  * igt@kms_big_joiner@invalid-modeset:
    - shard-mtlp:         NOTRUN -> [SKIP][127] ([i915#2705])
   [127]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_big_joiner@invalid-modeset.html

  * igt@kms_cdclk@mode-transition-all-outputs:
    - shard-dg2:          NOTRUN -> [SKIP][128] ([i915#4087] / [i915#7213])
   [128]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_cdclk@mode-transition-all-outputs.html

  * igt@kms_cdclk@mode-transition@pipe-b-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][129] ([i915#7213] / [i915#9010]) +3 other tests skip
   [129]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@kms_cdclk@mode-transition@pipe-b-edp-1.html

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

  * igt@kms_chamelium_color@ctm-green-to-red:
    - shard-dg2:          NOTRUN -> [SKIP][131] ([fdo#111827]) +4 other tests skip
   [131]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-7/igt@kms_chamelium_color@ctm-green-to-red.html

  * igt@kms_chamelium_color@ctm-negative:
    - shard-rkl:          NOTRUN -> [SKIP][132] ([fdo#111827])
   [132]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_chamelium_color@ctm-negative.html

  * igt@kms_chamelium_edid@dp-edid-change-during-suspend:
    - shard-dg2:          NOTRUN -> [SKIP][133] ([i915#7828]) +10 other tests skip
   [133]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-5/igt@kms_chamelium_edid@dp-edid-change-during-suspend.html

  * igt@kms_chamelium_edid@hdmi-edid-read:
    - shard-rkl:          NOTRUN -> [SKIP][134] ([i915#7828]) +8 other tests skip
   [134]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_chamelium_edid@hdmi-edid-read.html

  * igt@kms_chamelium_hpd@vga-hpd:
    - shard-mtlp:         NOTRUN -> [SKIP][135] ([i915#7828]) +4 other tests skip
   [135]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-1/igt@kms_chamelium_hpd@vga-hpd.html

  * igt@kms_color@ctm-0-50@pipe-c:
    - shard-rkl:          NOTRUN -> [SKIP][136] ([i915#4098]) +8 other tests skip
   [136]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_color@ctm-0-50@pipe-c.html

  * igt@kms_color@deep-color@pipe-a-hdmi-a-2-gamma:
    - shard-rkl:          NOTRUN -> [FAIL][137] ([i915#6892]) +1 other test fail
   [137]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_color@deep-color@pipe-a-hdmi-a-2-gamma.html

  * igt@kms_content_protection@atomic:
    - shard-mtlp:         NOTRUN -> [SKIP][138] ([i915#6944])
   [138]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@kms_content_protection@atomic.html

  * igt@kms_content_protection@atomic-dpms:
    - shard-dg2:          NOTRUN -> [SKIP][139] ([i915#7118])
   [139]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_content_protection@atomic-dpms.html

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

  * igt@kms_content_protection@lic@pipe-a-dp-1:
    - shard-apl:          NOTRUN -> [TIMEOUT][141] ([i915#7173]) +1 other test timeout
   [141]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl6/igt@kms_content_protection@lic@pipe-a-dp-1.html

  * igt@kms_content_protection@srm@pipe-a-dp-4:
    - shard-dg2:          NOTRUN -> [TIMEOUT][142] ([i915#7173])
   [142]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_content_protection@srm@pipe-a-dp-4.html

  * igt@kms_content_protection@type1:
    - shard-rkl:          NOTRUN -> [SKIP][143] ([i915#7118])
   [143]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_content_protection@type1.html

  * igt@kms_cursor_crc@cursor-random-32x10:
    - shard-dg1:          NOTRUN -> [SKIP][144] ([i915#3555])
   [144]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-13/igt@kms_cursor_crc@cursor-random-32x10.html

  * igt@kms_cursor_crc@cursor-random-512x170:
    - shard-dg2:          NOTRUN -> [SKIP][145] ([i915#3359]) +1 other test skip
   [145]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_cursor_crc@cursor-random-512x170.html

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

  * igt@kms_cursor_crc@cursor-rapid-movement-32x32:
    - shard-dg2:          NOTRUN -> [SKIP][147] ([i915#3555]) +8 other tests skip
   [147]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_cursor_crc@cursor-rapid-movement-32x32.html

  * igt@kms_cursor_legacy@2x-cursor-vs-flip-legacy:
    - shard-dg2:          NOTRUN -> [SKIP][148] ([fdo#109274] / [i915#5354]) +3 other tests skip
   [148]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_cursor_legacy@2x-cursor-vs-flip-legacy.html

  * igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic:
    - shard-dg2:          NOTRUN -> [SKIP][149] ([fdo#109274] / [fdo#111767] / [i915#5354]) +1 other test skip
   [149]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html
    - shard-rkl:          NOTRUN -> [SKIP][150] ([fdo#111767] / [fdo#111825])
   [150]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_cursor_legacy@2x-flip-vs-cursor-atomic.html

  * igt@kms_cursor_legacy@2x-flip-vs-cursor-legacy:
    - shard-dg1:          NOTRUN -> [SKIP][151] ([fdo#111825])
   [151]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-16/igt@kms_cursor_legacy@2x-flip-vs-cursor-legacy.html

  * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy:
    - shard-dg2:          NOTRUN -> [SKIP][152] ([i915#4103] / [i915#4213] / [i915#5608])
   [152]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-legacy.html

  * igt@kms_cursor_legacy@basic-busy-flip-before-cursor-varying-size:
    - shard-rkl:          NOTRUN -> [SKIP][153] ([i915#4103]) +3 other tests skip
   [153]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_cursor_legacy@basic-busy-flip-before-cursor-varying-size.html

  * igt@kms_cursor_legacy@cursora-vs-flipb-legacy:
    - shard-mtlp:         NOTRUN -> [SKIP][154] ([i915#3546]) +1 other test skip
   [154]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@kms_cursor_legacy@cursora-vs-flipb-legacy.html

  * igt@kms_cursor_legacy@flip-vs-cursor-atomic:
    - shard-rkl:          [PASS][155] -> [SKIP][156] ([i915#1845] / [i915#4098]) +3 other tests skip
   [155]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_cursor_legacy@flip-vs-cursor-atomic.html
   [156]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_cursor_legacy@flip-vs-cursor-atomic.html

  * igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions:
    - shard-glk:          [PASS][157] -> [FAIL][158] ([i915#2346])
   [157]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-glk9/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions.html
   [158]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk2/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions.html

  * igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions-varying-size:
    - shard-apl:          [PASS][159] -> [FAIL][160] ([i915#2346])
   [159]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-apl1/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions-varying-size.html
   [160]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl2/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions-varying-size.html

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

  * igt@kms_dirtyfb@dirtyfb-ioctl@drrs-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][162] ([i915#9226] / [i915#9261]) +1 other test skip
   [162]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_dirtyfb@dirtyfb-ioctl@drrs-hdmi-a-2.html

  * igt@kms_dirtyfb@dirtyfb-ioctl@fbc-hdmi-a-1:
    - shard-dg1:          NOTRUN -> [SKIP][163] ([i915#9227])
   [163]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-19/igt@kms_dirtyfb@dirtyfb-ioctl@fbc-hdmi-a-1.html

  * igt@kms_dirtyfb@dirtyfb-ioctl@fbc-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][164] ([i915#9227])
   [164]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_dirtyfb@dirtyfb-ioctl@fbc-hdmi-a-2.html

  * igt@kms_dirtyfb@dirtyfb-ioctl@psr-hdmi-a-1:
    - shard-dg1:          NOTRUN -> [SKIP][165] ([i915#9226] / [i915#9261]) +1 other test skip
   [165]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-19/igt@kms_dirtyfb@dirtyfb-ioctl@psr-hdmi-a-1.html

  * igt@kms_dp_aux_dev:
    - shard-rkl:          NOTRUN -> [SKIP][166] ([i915#1257])
   [166]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_dp_aux_dev.html

  * igt@kms_draw_crc@draw-method-mmap-wc:
    - shard-dg2:          NOTRUN -> [SKIP][167] ([i915#8812])
   [167]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_draw_crc@draw-method-mmap-wc.html

  * igt@kms_dsc@dsc-basic:
    - shard-rkl:          NOTRUN -> [SKIP][168] ([i915#3555] / [i915#3840])
   [168]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_dsc@dsc-basic.html

  * igt@kms_dsc@dsc-with-bpc:
    - shard-dg2:          NOTRUN -> [SKIP][169] ([i915#3555] / [i915#3840]) +1 other test skip
   [169]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_dsc@dsc-with-bpc.html

  * igt@kms_dsc@dsc-with-bpc-formats:
    - shard-mtlp:         NOTRUN -> [SKIP][170] ([i915#3555] / [i915#3840])
   [170]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_dsc@dsc-with-bpc-formats.html

  * igt@kms_flip@2x-flip-vs-fences:
    - shard-dg2:          NOTRUN -> [SKIP][171] ([i915#8381]) +1 other test skip
   [171]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_flip@2x-flip-vs-fences.html

  * igt@kms_flip@2x-flip-vs-panning-vs-hang:
    - shard-rkl:          NOTRUN -> [SKIP][172] ([fdo#111825]) +7 other tests skip
   [172]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@kms_flip@2x-flip-vs-panning-vs-hang.html

  * igt@kms_flip@2x-flip-vs-rmfb:
    - shard-mtlp:         NOTRUN -> [SKIP][173] ([i915#3637]) +1 other test skip
   [173]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_flip@2x-flip-vs-rmfb.html

  * igt@kms_flip@2x-modeset-vs-vblank-race:
    - shard-dg2:          NOTRUN -> [SKIP][174] ([fdo#109274]) +10 other tests skip
   [174]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_flip@2x-modeset-vs-vblank-race.html

  * igt@kms_flip@flip-vs-suspend-interruptible@b-hdmi-a1:
    - shard-snb:          NOTRUN -> [DMESG-WARN][175] ([i915#8841]) +1 other test dmesg-warn
   [175]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb1/igt@kms_flip@flip-vs-suspend-interruptible@b-hdmi-a1.html

  * igt@kms_flip@wf_vblank-ts-check:
    - shard-rkl:          NOTRUN -> [SKIP][176] ([i915#3637] / [i915#4098]) +2 other tests skip
   [176]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_flip@wf_vblank-ts-check.html

  * igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode:
    - shard-rkl:          NOTRUN -> [SKIP][177] ([i915#2672]) +5 other tests skip
   [177]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_flip_scaled_crc@flip-32bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][178] ([i915#3555] / [i915#8810])
   [178]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_flip_scaled_crc@flip-32bpp-xtile-to-64bpp-xtile-downscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling@pipe-a-valid-mode:
    - shard-dg1:          NOTRUN -> [SKIP][179] ([i915#2587] / [i915#2672])
   [179]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-19/igt@kms_flip_scaled_crc@flip-32bpp-yftile-to-64bpp-yftile-upscaling@pipe-a-valid-mode.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling:
    - shard-rkl:          NOTRUN -> [SKIP][180] ([i915#3555]) +5 other tests skip
   [180]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_flip_scaled_crc@flip-32bpp-ytile-to-32bpp-ytilegen12rcccs-upscaling.html

  * igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][181] ([i915#2672] / [i915#3555])
   [181]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-1/igt@kms_flip_scaled_crc@flip-32bpp-ytileccs-to-64bpp-ytile-downscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-default-mode:
    - shard-mtlp:         NOTRUN -> [SKIP][182] ([i915#2672])
   [182]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-1/igt@kms_flip_scaled_crc@flip-64bpp-4tile-to-32bpp-4tiledg2rcccs-upscaling@pipe-a-default-mode.html

  * igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-upscaling@pipe-a-valid-mode:
    - shard-dg2:          NOTRUN -> [SKIP][183] ([i915#2672]) +8 other tests skip
   [183]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_flip_scaled_crc@flip-64bpp-ytile-to-32bpp-ytile-upscaling@pipe-a-valid-mode.html

  * igt@kms_force_connector_basic@force-load-detect:
    - shard-dg2:          NOTRUN -> [SKIP][184] ([fdo#109285])
   [184]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_force_connector_basic@force-load-detect.html
    - shard-mtlp:         NOTRUN -> [SKIP][185] ([fdo#109285])
   [185]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@kms_force_connector_basic@force-load-detect.html

  * igt@kms_force_connector_basic@prune-stale-modes:
    - shard-dg2:          NOTRUN -> [SKIP][186] ([i915#5274])
   [186]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@kms_force_connector_basic@prune-stale-modes.html

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

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-draw-blt:
    - shard-dg2:          NOTRUN -> [SKIP][188] ([i915#5354]) +44 other tests skip
   [188]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-onoff:
    - shard-tglu:         NOTRUN -> [SKIP][189] ([fdo#109280]) +1 other test skip
   [189]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-7/igt@kms_frontbuffer_tracking@fbc-2p-primscrn-spr-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbc-rgb101010-draw-blt:
    - shard-rkl:          [PASS][190] -> [SKIP][191] ([i915#1849] / [i915#4098]) +3 other tests skip
   [190]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_frontbuffer_tracking@fbc-rgb101010-draw-blt.html
   [191]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-rgb101010-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-gtt:
    - shard-mtlp:         NOTRUN -> [SKIP][192] ([i915#8708]) +1 other test skip
   [192]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_frontbuffer_tracking@fbc-rgb565-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-shrfb-scaledprimary:
    - shard-rkl:          NOTRUN -> [SKIP][193] ([i915#1849] / [i915#4098]) +7 other tests skip
   [193]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-shrfb-scaledprimary.html

  * igt@kms_frontbuffer_tracking@fbcpsr-1p-rte:
    - shard-rkl:          NOTRUN -> [SKIP][194] ([i915#3023]) +18 other tests skip
   [194]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_frontbuffer_tracking@fbcpsr-1p-rte.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-shrfb-draw-mmap-wc:
    - shard-mtlp:         NOTRUN -> [SKIP][195] ([i915#1825]) +11 other tests skip
   [195]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-pri-shrfb-draw-mmap-wc.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-onoff:
    - shard-rkl:          NOTRUN -> [SKIP][196] ([fdo#111825] / [i915#1825]) +36 other tests skip
   [196]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-onoff.html

  * igt@kms_frontbuffer_tracking@fbcpsr-stridechange:
    - shard-tglu:         NOTRUN -> [SKIP][197] ([fdo#110189]) +2 other tests skip
   [197]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-10/igt@kms_frontbuffer_tracking@fbcpsr-stridechange.html

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

  * igt@kms_frontbuffer_tracking@fbcpsr-tiling-y:
    - shard-dg2:          NOTRUN -> [SKIP][199] ([i915#5460])
   [199]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_frontbuffer_tracking@fbcpsr-tiling-y.html

  * igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-shrfb-draw-mmap-cpu:
    - shard-dg2:          NOTRUN -> [SKIP][200] ([i915#3458]) +24 other tests skip
   [200]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_frontbuffer_tracking@psr-1p-offscren-pri-shrfb-draw-mmap-cpu.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-spr-indfb-draw-pwrite:
    - shard-dg1:          NOTRUN -> [SKIP][201] ([i915#3458]) +1 other test skip
   [201]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-17/igt@kms_frontbuffer_tracking@psr-1p-primscrn-spr-indfb-draw-pwrite.html

  * igt@kms_getfb@getfb-reject-ccs:
    - shard-dg2:          NOTRUN -> [SKIP][202] ([i915#6118])
   [202]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_getfb@getfb-reject-ccs.html

  * igt@kms_panel_fitting@legacy:
    - shard-dg2:          NOTRUN -> [SKIP][203] ([i915#6301])
   [203]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_panel_fitting@legacy.html

  * igt@kms_pipe_b_c_ivb@pipe-b-double-modeset-then-modeset-pipe-c:
    - shard-mtlp:         NOTRUN -> [SKIP][204] ([fdo#109289]) +1 other test skip
   [204]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-3/igt@kms_pipe_b_c_ivb@pipe-b-double-modeset-then-modeset-pipe-c.html

  * igt@kms_pipe_b_c_ivb@pipe-b-dpms-off-modeset-pipe-c:
    - shard-tglu:         NOTRUN -> [SKIP][205] ([fdo#109289]) +1 other test skip
   [205]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-10/igt@kms_pipe_b_c_ivb@pipe-b-dpms-off-modeset-pipe-c.html

  * igt@kms_plane@pixel-format:
    - shard-rkl:          NOTRUN -> [SKIP][206] ([i915#4098] / [i915#8825])
   [206]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_plane@pixel-format.html

  * igt@kms_plane_alpha_blend@constant-alpha-max@pipe-c-hdmi-a-1:
    - shard-glk:          NOTRUN -> [FAIL][207] ([i915#4573]) +1 other test fail
   [207]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk4/igt@kms_plane_alpha_blend@constant-alpha-max@pipe-c-hdmi-a-1.html

  * igt@kms_plane_scaling@intel-max-src-size:
    - shard-rkl:          NOTRUN -> [SKIP][208] ([i915#6953] / [i915#8152])
   [208]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_plane_scaling@intel-max-src-size.html

  * igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-4:
    - shard-dg1:          NOTRUN -> [FAIL][209] ([i915#8292])
   [209]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-18/igt@kms_plane_scaling@intel-max-src-size@pipe-a-hdmi-a-4.html

  * igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][210] ([i915#5176] / [i915#9423]) +1 other test skip
   [210]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_plane_scaling@plane-scaler-with-clipping-clamping-rotation@pipe-b-hdmi-a-2.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-hdmi-a-2:
    - shard-rkl:          NOTRUN -> [SKIP][211] ([i915#5235]) +5 other tests skip
   [211]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-b-hdmi-a-2.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-c-hdmi-a-4:
    - shard-dg1:          NOTRUN -> [SKIP][212] ([i915#5235]) +7 other tests skip
   [212]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-18/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-c-hdmi-a-4.html

  * igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-d-dp-4:
    - shard-dg2:          NOTRUN -> [SKIP][213] ([i915#5235]) +7 other tests skip
   [213]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_plane_scaling@planes-downscale-factor-0-25-upscale-factor-0-25@pipe-d-dp-4.html

  * igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-75:
    - shard-rkl:          NOTRUN -> [SKIP][214] ([i915#3555] / [i915#4098] / [i915#6953] / [i915#8152])
   [214]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_plane_scaling@planes-unity-scaling-downscale-factor-0-75.html

  * igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-75@pipe-c-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][215] ([i915#5235]) +2 other tests skip
   [215]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-1/igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-75@pipe-c-edp-1.html

  * igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-75@pipe-d-edp-1:
    - shard-mtlp:         NOTRUN -> [SKIP][216] ([i915#3555] / [i915#5235])
   [216]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-1/igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-75@pipe-d-edp-1.html

  * igt@kms_prime@basic-crc-hybrid:
    - shard-dg2:          NOTRUN -> [SKIP][217] ([i915#6524] / [i915#6805]) +2 other tests skip
   [217]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@kms_prime@basic-crc-hybrid.html

  * igt@kms_prime@d3hot:
    - shard-rkl:          NOTRUN -> [SKIP][218] ([i915#6524])
   [218]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_prime@d3hot.html

  * igt@kms_psr2_sf@cursor-plane-move-continuous-exceed-fully-sf:
    - shard-rkl:          NOTRUN -> [SKIP][219] ([i915#658])
   [219]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_psr2_sf@cursor-plane-move-continuous-exceed-fully-sf.html

  * igt@kms_psr2_sf@overlay-plane-move-continuous-exceed-sf:
    - shard-glk:          NOTRUN -> [SKIP][220] ([fdo#109271] / [i915#658])
   [220]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk2/igt@kms_psr2_sf@overlay-plane-move-continuous-exceed-sf.html

  * igt@kms_psr2_sf@overlay-plane-update-continuous-sf:
    - shard-mtlp:         NOTRUN -> [SKIP][221] ([i915#2920])
   [221]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@kms_psr2_sf@overlay-plane-update-continuous-sf.html

  * igt@kms_psr2_sf@plane-move-sf-dmg-area:
    - shard-apl:          NOTRUN -> [SKIP][222] ([fdo#109271] / [i915#658]) +2 other tests skip
   [222]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl7/igt@kms_psr2_sf@plane-move-sf-dmg-area.html

  * igt@kms_psr2_su@page_flip-nv12:
    - shard-dg2:          NOTRUN -> [SKIP][223] ([i915#658]) +6 other tests skip
   [223]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@kms_psr2_su@page_flip-nv12.html

  * igt@kms_psr2_su@page_flip-p010:
    - shard-rkl:          NOTRUN -> [SKIP][224] ([fdo#111068] / [i915#658]) +1 other test skip
   [224]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_psr2_su@page_flip-p010.html

  * igt@kms_psr@primary_mmap_cpu:
    - shard-rkl:          NOTRUN -> [SKIP][225] ([i915#1072]) +8 other tests skip
   [225]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_psr@primary_mmap_cpu.html

  * igt@kms_psr@psr2_cursor_mmap_gtt:
    - shard-glk:          NOTRUN -> [SKIP][226] ([fdo#109271]) +37 other tests skip
   [226]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk2/igt@kms_psr@psr2_cursor_mmap_gtt.html

  * igt@kms_psr@psr2_sprite_blt:
    - shard-dg2:          NOTRUN -> [SKIP][227] ([i915#1072]) +4 other tests skip
   [227]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-1/igt@kms_psr@psr2_sprite_blt.html

  * igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
    - shard-rkl:          NOTRUN -> [SKIP][228] ([i915#5461] / [i915#658])
   [228]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@kms_psr_stress_test@flip-primary-invalidate-overlay.html

  * igt@kms_rotation_crc@multiplane-rotation-cropping-top:
    - shard-rkl:          [PASS][229] -> [INCOMPLETE][230] ([i915#8875] / [i915#9475] / [i915#9569])
   [229]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-2/igt@kms_rotation_crc@multiplane-rotation-cropping-top.html
   [230]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_rotation_crc@multiplane-rotation-cropping-top.html

  * igt@kms_rotation_crc@primary-rotation-90:
    - shard-dg2:          NOTRUN -> [SKIP][231] ([i915#4235])
   [231]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-10/igt@kms_rotation_crc@primary-rotation-90.html

  * igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270:
    - shard-dg2:          NOTRUN -> [SKIP][232] ([i915#4235] / [i915#5190])
   [232]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html
    - shard-rkl:          NOTRUN -> [SKIP][233] ([fdo#111615] / [i915#5289])
   [233]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_rotation_crc@primary-yf-tiled-reflect-x-270.html

  * igt@kms_rotation_crc@sprite-rotation-90-pos-100-0:
    - shard-mtlp:         NOTRUN -> [SKIP][234] ([i915#4235]) +1 other test skip
   [234]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-5/igt@kms_rotation_crc@sprite-rotation-90-pos-100-0.html

  * igt@kms_setmode@clone-exclusive-crtc:
    - shard-mtlp:         NOTRUN -> [SKIP][235] ([i915#3555] / [i915#8809])
   [235]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@kms_setmode@clone-exclusive-crtc.html

  * igt@kms_sysfs_edid_timing:
    - shard-dg2:          NOTRUN -> [FAIL][236] ([IGT#2])
   [236]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@kms_sysfs_edid_timing.html

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

  * igt@kms_universal_plane@cursor-fb-leak@pipe-d-edp-1:
    - shard-mtlp:         [PASS][238] -> [FAIL][239] ([i915#9196])
   [238]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-mtlp-3/igt@kms_universal_plane@cursor-fb-leak@pipe-d-edp-1.html
   [239]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@kms_universal_plane@cursor-fb-leak@pipe-d-edp-1.html

  * igt@kms_writeback@writeback-check-output:
    - shard-mtlp:         NOTRUN -> [SKIP][240] ([i915#2437])
   [240]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@kms_writeback@writeback-check-output.html

  * igt@kms_writeback@writeback-fb-id:
    - shard-rkl:          NOTRUN -> [SKIP][241] ([i915#2437])
   [241]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@kms_writeback@writeback-fb-id.html

  * igt@kms_writeback@writeback-pixel-formats:
    - shard-dg2:          NOTRUN -> [SKIP][242] ([i915#2437])
   [242]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@kms_writeback@writeback-pixel-formats.html

  * igt@perf@enable-disable@0-rcs0:
    - shard-dg2:          NOTRUN -> [FAIL][243] ([i915#8724])
   [243]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@perf@enable-disable@0-rcs0.html

  * igt@perf@gen12-unprivileged-single-ctx-counters:
    - shard-rkl:          NOTRUN -> [SKIP][244] ([fdo#109289]) +1 other test skip
   [244]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@perf@gen12-unprivileged-single-ctx-counters.html

  * igt@perf@gen8-unprivileged-single-ctx-counters:
    - shard-rkl:          [PASS][245] -> [SKIP][246] ([i915#2436])
   [245]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@perf@gen8-unprivileged-single-ctx-counters.html
   [246]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@perf@gen8-unprivileged-single-ctx-counters.html

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

  * igt@perf_pmu@busy-double-start@rcs0:
    - shard-mtlp:         [PASS][248] -> [FAIL][249] ([i915#4349])
   [248]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-mtlp-8/igt@perf_pmu@busy-double-start@rcs0.html
   [249]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@perf_pmu@busy-double-start@rcs0.html

  * igt@perf_pmu@cpu-hotplug:
    - shard-rkl:          NOTRUN -> [SKIP][250] ([i915#8850])
   [250]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@perf_pmu@cpu-hotplug.html

  * igt@perf_pmu@frequency@gt0:
    - shard-dg2:          NOTRUN -> [FAIL][251] ([i915#6806])
   [251]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@perf_pmu@frequency@gt0.html

  * igt@perf_pmu@rc6@other-idle-gt0:
    - shard-dg2:          NOTRUN -> [SKIP][252] ([i915#8516])
   [252]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@perf_pmu@rc6@other-idle-gt0.html

  * igt@prime_udl:
    - shard-dg2:          NOTRUN -> [SKIP][253] ([fdo#109291])
   [253]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@prime_udl.html

  * igt@prime_vgem@basic-fence-flip:
    - shard-rkl:          [PASS][254] -> [SKIP][255] ([fdo#109295] / [i915#3708] / [i915#4098])
   [254]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-2/igt@prime_vgem@basic-fence-flip.html
   [255]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@prime_vgem@basic-fence-flip.html

  * igt@prime_vgem@basic-fence-mmap:
    - shard-mtlp:         NOTRUN -> [SKIP][256] ([i915#3708] / [i915#4077])
   [256]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@prime_vgem@basic-fence-mmap.html

  * igt@prime_vgem@basic-gtt:
    - shard-dg2:          NOTRUN -> [SKIP][257] ([i915#3708] / [i915#4077])
   [257]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@prime_vgem@basic-gtt.html

  * igt@prime_vgem@basic-write:
    - shard-dg2:          NOTRUN -> [SKIP][258] ([i915#3291] / [i915#3708])
   [258]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@prime_vgem@basic-write.html

  * igt@prime_vgem@fence-read-hang:
    - shard-rkl:          NOTRUN -> [SKIP][259] ([fdo#109295] / [i915#3708])
   [259]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@prime_vgem@fence-read-hang.html

  * igt@syncobj_timeline@invalid-multi-wait-all-available-unsubmitted-signaled:
    - shard-rkl:          NOTRUN -> [FAIL][260] ([i915#9583]) +3 other tests fail
   [260]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@syncobj_timeline@invalid-multi-wait-all-available-unsubmitted-signaled.html

  * igt@syncobj_timeline@invalid-multi-wait-available-unsubmitted:
    - shard-dg2:          NOTRUN -> [FAIL][261] ([i915#9583]) +2 other tests fail
   [261]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@syncobj_timeline@invalid-multi-wait-available-unsubmitted.html

  * igt@syncobj_timeline@invalid-multi-wait-available-unsubmitted-submitted:
    - shard-snb:          NOTRUN -> [FAIL][262] ([i915#9583])
   [262]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb7/igt@syncobj_timeline@invalid-multi-wait-available-unsubmitted-submitted.html

  * igt@v3d/v3d_submit_cl@multiple-job-submission:
    - shard-apl:          NOTRUN -> [SKIP][263] ([fdo#109271]) +144 other tests skip
   [263]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl3/igt@v3d/v3d_submit_cl@multiple-job-submission.html

  * igt@v3d/v3d_submit_cl@simple-flush-cache:
    - shard-mtlp:         NOTRUN -> [SKIP][264] ([i915#2575]) +4 other tests skip
   [264]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-2/igt@v3d/v3d_submit_cl@simple-flush-cache.html

  * igt@v3d/v3d_submit_csd@bad-multisync-extension:
    - shard-rkl:          NOTRUN -> [SKIP][265] ([fdo#109315]) +10 other tests skip
   [265]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@v3d/v3d_submit_csd@bad-multisync-extension.html

  * igt@v3d/v3d_submit_csd@bad-multisync-pad:
    - shard-dg1:          NOTRUN -> [SKIP][266] ([i915#2575]) +1 other test skip
   [266]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-15/igt@v3d/v3d_submit_csd@bad-multisync-pad.html

  * igt@v3d/v3d_submit_csd@single-out-sync:
    - shard-dg2:          NOTRUN -> [SKIP][267] ([i915#2575]) +20 other tests skip
   [267]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@v3d/v3d_submit_csd@single-out-sync.html

  * igt@v3d/v3d_wait_bo@unused-bo-0ns:
    - shard-tglu:         NOTRUN -> [SKIP][268] ([fdo#109315] / [i915#2575]) +1 other test skip
   [268]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-3/igt@v3d/v3d_wait_bo@unused-bo-0ns.html

  * igt@vc4/vc4_mmap@mmap-bo:
    - shard-dg2:          NOTRUN -> [SKIP][269] ([i915#7711]) +12 other tests skip
   [269]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-6/igt@vc4/vc4_mmap@mmap-bo.html

  * igt@vc4/vc4_tiling@get-bad-handle:
    - shard-rkl:          NOTRUN -> [SKIP][270] ([i915#7711]) +7 other tests skip
   [270]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@vc4/vc4_tiling@get-bad-handle.html

  * igt@vc4/vc4_tiling@get-bad-modifier:
    - shard-mtlp:         NOTRUN -> [SKIP][271] ([i915#7711]) +3 other tests skip
   [271]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-7/igt@vc4/vc4_tiling@get-bad-modifier.html

  * igt@vc4/vc4_tiling@set-bad-handle:
    - shard-tglu:         NOTRUN -> [SKIP][272] ([i915#2575])
   [272]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-3/igt@vc4/vc4_tiling@set-bad-handle.html

  
#### Possible fixes ####

  * igt@drm_fdinfo@most-busy-idle-check-all@rcs0:
    - shard-rkl:          [FAIL][273] ([i915#7742]) -> [PASS][274]
   [273]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@drm_fdinfo@most-busy-idle-check-all@rcs0.html
   [274]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@drm_fdinfo@most-busy-idle-check-all@rcs0.html

  * igt@fbdev@read:
    - shard-rkl:          [SKIP][275] ([i915#2582]) -> [PASS][276]
   [275]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@fbdev@read.html
   [276]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@fbdev@read.html

  * igt@gem_ctx_persistence@engines-hang@bcs0:
    - shard-rkl:          [SKIP][277] ([i915#6252]) -> [PASS][278]
   [277]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_ctx_persistence@engines-hang@bcs0.html
   [278]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_ctx_persistence@engines-hang@bcs0.html

  * igt@gem_eio@hibernate:
    - shard-dg2:          [ABORT][279] ([i915#7975] / [i915#8213]) -> [PASS][280]
   [279]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-1/igt@gem_eio@hibernate.html
   [280]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@gem_eio@hibernate.html

  * igt@gem_eio@in-flight-contexts-10ms:
    - shard-mtlp:         [ABORT][281] ([i915#9414]) -> [PASS][282]
   [281]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-mtlp-5/igt@gem_eio@in-flight-contexts-10ms.html
   [282]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-mtlp-8/igt@gem_eio@in-flight-contexts-10ms.html

  * igt@gem_eio@kms:
    - shard-dg2:          [FAIL][283] ([i915#5784]) -> [PASS][284]
   [283]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-2/igt@gem_eio@kms.html
   [284]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@gem_eio@kms.html

  * igt@gem_eio@unwedge-stress:
    - shard-dg1:          [FAIL][285] ([i915#5784]) -> [PASS][286]
   [285]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-15/igt@gem_eio@unwedge-stress.html
   [286]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-13/igt@gem_eio@unwedge-stress.html

  * igt@gem_exec_balancer@fairslice:
    - shard-rkl:          [SKIP][287] ([Intel XE#874]) -> [PASS][288]
   [287]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_exec_balancer@fairslice.html
   [288]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@gem_exec_balancer@fairslice.html

  * igt@gem_exec_fair@basic-deadline:
    - shard-rkl:          [FAIL][289] ([i915#2846]) -> [PASS][290]
   [289]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@gem_exec_fair@basic-deadline.html
   [290]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_exec_fair@basic-deadline.html

  * igt@gem_exec_fair@basic-pace-share@rcs0:
    - shard-glk:          [FAIL][291] ([i915#2842]) -> [PASS][292]
   [291]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-glk2/igt@gem_exec_fair@basic-pace-share@rcs0.html
   [292]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-glk1/igt@gem_exec_fair@basic-pace-share@rcs0.html

  * igt@gem_exec_reloc@basic-cpu-gtt-noreloc:
    - shard-rkl:          [SKIP][293] ([i915#3281]) -> [PASS][294] +3 other tests pass
   [293]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-1/igt@gem_exec_reloc@basic-cpu-gtt-noreloc.html
   [294]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_exec_reloc@basic-cpu-gtt-noreloc.html

  * igt@gem_lmem_swapping@smem-oom@lmem0:
    - shard-dg1:          [TIMEOUT][295] ([i915#5493]) -> [PASS][296]
   [295]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-17/igt@gem_lmem_swapping@smem-oom@lmem0.html
   [296]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-17/igt@gem_lmem_swapping@smem-oom@lmem0.html

  * igt@i915_module_load@reload-with-fault-injection:
    - shard-dg2:          [DMESG-WARN][297] ([i915#9559]) -> [PASS][298]
   [297]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-6/igt@i915_module_load@reload-with-fault-injection.html
   [298]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-2/igt@i915_module_load@reload-with-fault-injection.html

  * igt@i915_pm_rc6_residency@rc6-idle@bcs0:
    - shard-dg1:          [FAIL][299] ([i915#3591]) -> [PASS][300]
   [299]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-13/igt@i915_pm_rc6_residency@rc6-idle@bcs0.html
   [300]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-17/igt@i915_pm_rc6_residency@rc6-idle@bcs0.html

  * igt@i915_pm_rpm@system-suspend-execbuf:
    - shard-dg2:          [FAIL][301] ([fdo#103375]) -> [PASS][302]
   [301]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-5/igt@i915_pm_rpm@system-suspend-execbuf.html
   [302]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-7/igt@i915_pm_rpm@system-suspend-execbuf.html

  * igt@i915_pm_rps@reset:
    - shard-snb:          [INCOMPLETE][303] ([i915#7790]) -> [PASS][304]
   [303]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-snb7/igt@i915_pm_rps@reset.html
   [304]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb2/igt@i915_pm_rps@reset.html

  * igt@kms_big_fb@x-tiled-32bpp-rotate-0:
    - shard-rkl:          [SKIP][305] ([i915#1845] / [i915#4098]) -> [PASS][306] +26 other tests pass
   [305]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_big_fb@x-tiled-32bpp-rotate-0.html
   [306]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_big_fb@x-tiled-32bpp-rotate-0.html

  * {igt@kms_ccs@pipe-b-bad-pixel-format-y-tiled-gen12-rc-ccs}:
    - shard-rkl:          [SKIP][307] ([i915#4098]) -> [PASS][308] +13 other tests pass
   [307]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_ccs@pipe-b-bad-pixel-format-y-tiled-gen12-rc-ccs.html
   [308]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@kms_ccs@pipe-b-bad-pixel-format-y-tiled-gen12-rc-ccs.html

  * igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions:
    - shard-apl:          [FAIL][309] ([i915#2346]) -> [PASS][310]
   [309]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-apl1/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions.html
   [310]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-apl7/igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions.html

  * igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-mmap-wc:
    - shard-rkl:          [SKIP][311] ([i915#1849] / [i915#4098]) -> [PASS][312] +9 other tests pass
   [311]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-mmap-wc.html
   [312]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_frontbuffer_tracking@fbc-1p-primscrn-pri-shrfb-draw-mmap-wc.html

  * {igt@kms_pm_rpm@i2c}:
    - shard-dg2:          [FAIL][313] ([i915#8717]) -> [PASS][314]
   [313]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-2/igt@kms_pm_rpm@i2c.html
   [314]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-11/igt@kms_pm_rpm@i2c.html

  * {igt@kms_pm_rpm@modeset-lpsp}:
    - shard-dg1:          [SKIP][315] ([i915#9519]) -> [PASS][316]
   [315]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-13/igt@kms_pm_rpm@modeset-lpsp.html
   [316]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-19/igt@kms_pm_rpm@modeset-lpsp.html

  * {igt@kms_pm_rpm@modeset-non-lpsp}:
    - shard-rkl:          [SKIP][317] ([i915#9519]) -> [PASS][318] +2 other tests pass
   [317]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_pm_rpm@modeset-non-lpsp.html
   [318]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_pm_rpm@modeset-non-lpsp.html

  * igt@kms_properties@plane-properties-atomic:
    - shard-rkl:          [SKIP][319] ([i915#1849]) -> [PASS][320]
   [319]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_properties@plane-properties-atomic.html
   [320]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@kms_properties@plane-properties-atomic.html

  * igt@kms_rotation_crc@bad-pixel-format:
    - shard-rkl:          [INCOMPLETE][321] ([i915#8875] / [i915#9569]) -> [PASS][322]
   [321]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_rotation_crc@bad-pixel-format.html
   [322]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_rotation_crc@bad-pixel-format.html

  * igt@kms_universal_plane@cursor-fb-leak@pipe-d-hdmi-a-1:
    - shard-tglu:         [FAIL][323] ([i915#9196]) -> [PASS][324]
   [323]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-tglu-7/igt@kms_universal_plane@cursor-fb-leak@pipe-d-hdmi-a-1.html
   [324]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-tglu-9/igt@kms_universal_plane@cursor-fb-leak@pipe-d-hdmi-a-1.html

  * igt@perf@non-zero-reason@0-rcs0:
    - shard-dg2:          [FAIL][325] ([i915#7484]) -> [PASS][326]
   [325]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg2-7/igt@perf@non-zero-reason@0-rcs0.html
   [326]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg2-7/igt@perf@non-zero-reason@0-rcs0.html

  
#### Warnings ####

  * igt@gem_ccs@ctrl-surf-copy:
    - shard-rkl:          [SKIP][327] ([i915#3555]) -> [SKIP][328] ([i915#7957])
   [327]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@gem_ccs@ctrl-surf-copy.html
   [328]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_ccs@ctrl-surf-copy.html

  * igt@gem_ccs@suspend-resume:
    - shard-rkl:          [SKIP][329] ([i915#7957]) -> [SKIP][330] ([i915#9323])
   [329]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_ccs@suspend-resume.html
   [330]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@gem_ccs@suspend-resume.html

  * igt@gem_exec_fair@basic-pace@bcs0:
    - shard-rkl:          [SKIP][331] ([i915#9591]) -> [FAIL][332] ([i915#2842])
   [331]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@gem_exec_fair@basic-pace@bcs0.html
   [332]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@gem_exec_fair@basic-pace@bcs0.html

  * igt@gem_lmem_swapping@heavy-verify-multi-ccs@lmem0:
    - shard-dg1:          [SKIP][333] ([i915#4423] / [i915#4565]) -> [SKIP][334] ([i915#4565])
   [333]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-16/igt@gem_lmem_swapping@heavy-verify-multi-ccs@lmem0.html
   [334]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-17/igt@gem_lmem_swapping@heavy-verify-multi-ccs@lmem0.html

  * igt@gem_pwrite@basic-exhaustion:
    - shard-rkl:          [SKIP][335] ([i915#3282]) -> [WARN][336] ([i915#2658])
   [335]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@gem_pwrite@basic-exhaustion.html
   [336]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@gem_pwrite@basic-exhaustion.html

  * igt@gen9_exec_parse@bb-secure:
    - shard-dg1:          [SKIP][337] ([i915#2527] / [i915#4423]) -> [SKIP][338] ([i915#2527])
   [337]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-dg1-16/igt@gen9_exec_parse@bb-secure.html
   [338]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-dg1-18/igt@gen9_exec_parse@bb-secure.html

  * igt@i915_suspend@basic-s3-without-i915:
    - shard-snb:          [INCOMPLETE][339] ([i915#4528]) -> [DMESG-WARN][340] ([i915#8841])
   [339]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-snb4/igt@i915_suspend@basic-s3-without-i915.html
   [340]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-snb7/igt@i915_suspend@basic-s3-without-i915.html

  * igt@kms_big_fb@4-tiled-addfb-size-overflow:
    - shard-rkl:          [SKIP][341] ([i915#4098]) -> [SKIP][342] ([i915#5286]) +5 other tests skip
   [341]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_big_fb@4-tiled-addfb-size-overflow.html
   [342]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_big_fb@4-tiled-addfb-size-overflow.html

  * igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-hflip:
    - shard-rkl:          [SKIP][343] ([i915#5286]) -> [SKIP][344] ([i915#4098]) +1 other test skip
   [343]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-hflip.html
   [344]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_big_fb@4-tiled-max-hw-stride-32bpp-rotate-0-hflip.html

  * igt@kms_big_fb@linear-32bpp-rotate-90:
    - shard-rkl:          [SKIP][345] ([fdo#111614] / [i915#3638]) -> [SKIP][346] ([i915#1845] / [i915#4098])
   [345]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_big_fb@linear-32bpp-rotate-90.html
   [346]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_big_fb@linear-32bpp-rotate-90.html

  * igt@kms_big_fb@linear-64bpp-rotate-90:
    - shard-rkl:          [SKIP][347] ([i915#1845] / [i915#4098]) -> [SKIP][348] ([fdo#111614] / [i915#3638]) +3 other tests skip
   [347]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_big_fb@linear-64bpp-rotate-90.html
   [348]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-6/igt@kms_big_fb@linear-64bpp-rotate-90.html

  * igt@kms_big_fb@yf-tiled-8bpp-rotate-0:
    - shard-rkl:          [SKIP][349] ([fdo#110723]) -> [SKIP][350] ([i915#1845] / [i915#4098])
   [349]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-1/igt@kms_big_fb@yf-tiled-8bpp-rotate-0.html
   [350]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_big_fb@yf-tiled-8bpp-rotate-0.html

  * igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180:
    - shard-rkl:          [SKIP][351] ([i915#1845] / [i915#4098]) -> [SKIP][352] ([fdo#110723]) +6 other tests skip
   [351]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180.html
   [352]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_big_fb@yf-tiled-max-hw-stride-32bpp-rotate-180.html

  * igt@kms_content_protection@dp-mst-lic-type-0:
    - shard-rkl:          [SKIP][353] ([i915#1845] / [i915#4098]) -> [SKIP][354] ([i915#3116])
   [353]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_content_protection@dp-mst-lic-type-0.html
   [354]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_content_protection@dp-mst-lic-type-0.html

  * igt@kms_cursor_crc@cursor-onscreen-32x32:
    - shard-rkl:          [SKIP][355] ([i915#4098]) -> [SKIP][356] ([i915#3555]) +4 other tests skip
   [355]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_cursor_crc@cursor-onscreen-32x32.html
   [356]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_cursor_crc@cursor-onscreen-32x32.html

  * igt@kms_cursor_crc@cursor-random-512x512:
    - shard-rkl:          [SKIP][357] ([i915#3359]) -> [SKIP][358] ([i915#4098])
   [357]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-7/igt@kms_cursor_crc@cursor-random-512x512.html
   [358]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_cursor_crc@cursor-random-512x512.html

  * igt@kms_cursor_legacy@2x-cursor-vs-flip-legacy:
    - shard-rkl:          [SKIP][359] ([i915#1845] / [i915#4098]) -> [SKIP][360] ([fdo#111825]) +1 other test skip
   [359]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_cursor_legacy@2x-cursor-vs-flip-legacy.html
   [360]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_cursor_legacy@2x-cursor-vs-flip-legacy.html

  * igt@kms_cursor_legacy@cursorb-vs-flipb-toggle:
    - shard-rkl:          [SKIP][361] ([i915#1845] / [i915#4098]) -> [SKIP][362] ([fdo#111767] / [fdo#111825]) +1 other test skip
   [361]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_cursor_legacy@cursorb-vs-flipb-toggle.html
   [362]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_cursor_legacy@cursorb-vs-flipb-toggle.html

  * igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle:
    - shard-rkl:          [SKIP][363] ([i915#1845] / [i915#4098]) -> [SKIP][364] ([i915#4103])
   [363]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html
   [364]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_cursor_legacy@short-busy-flip-before-cursor-toggle.html

  * igt@kms_dsc@dsc-with-bpc:
    - shard-rkl:          [SKIP][365] ([i915#3555] / [i915#3840]) -> [SKIP][366] ([i915#4098])
   [365]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-4/igt@kms_dsc@dsc-with-bpc.html
   [366]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_dsc@dsc-with-bpc.html

  * igt@kms_fbcon_fbt@psr:
    - shard-rkl:          [SKIP][367] ([i915#3955]) -> [SKIP][368] ([fdo#110189] / [i915#3955])
   [367]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-6/igt@kms_fbcon_fbt@psr.html
   [368]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@kms_fbcon_fbt@psr.html

  * igt@kms_frontbuffer_tracking@fbc-2p-indfb-fliptrack-mmap-gtt:
    - shard-rkl:          [SKIP][369] ([i915#1849] / [i915#4098]) -> [SKIP][370] ([fdo#111825])
   [369]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-2p-indfb-fliptrack-mmap-gtt.html
   [370]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-1/igt@kms_frontbuffer_tracking@fbc-2p-indfb-fliptrack-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-gtt:
    - shard-rkl:          [SKIP][371] ([i915#1849] / [i915#4098]) -> [SKIP][372] ([fdo#111825] / [i915#1825]) +45 other tests skip
   [371]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-gtt.html
   [372]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-2/igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-pri-shrfb-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@fbc-tiling-4:
    - shard-rkl:          [SKIP][373] ([i915#1849] / [i915#4098]) -> [SKIP][374] ([i915#5439])
   [373]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_frontbuffer_tracking@fbc-tiling-4.html
   [374]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-7/igt@kms_frontbuffer_tracking@fbc-tiling-4.html

  * igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-draw-blt:
    - shard-rkl:          [SKIP][375] ([fdo#111825] / [i915#1825]) -> [SKIP][376] ([i915#1849] / [i915#4098]) +12 other tests skip
   [375]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-1/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-draw-blt.html
   [376]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_frontbuffer_tracking@fbcpsr-2p-scndscrn-spr-indfb-draw-blt.html

  * igt@kms_frontbuffer_tracking@fbcpsr-rgb565-draw-mmap-gtt:
    - shard-rkl:          [SKIP][377] ([i915#1849] / [i915#4098]) -> [SKIP][378] ([i915#3023]) +29 other tests skip
   [377]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_frontbuffer_tracking@fbcpsr-rgb565-draw-mmap-gtt.html
   [378]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_frontbuffer_tracking@fbcpsr-rgb565-draw-mmap-gtt.html

  * igt@kms_frontbuffer_tracking@psr-1p-primscrn-shrfb-pgflip-blt:
    - shard-rkl:          [SKIP][379] ([i915#3023]) -> [SKIP][380] ([i915#1849] / [i915#4098]) +6 other tests skip
   [379]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-7/igt@kms_frontbuffer_tracking@psr-1p-primscrn-shrfb-pgflip-blt.html
   [380]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_frontbuffer_tracking@psr-1p-primscrn-shrfb-pgflip-blt.html

  * igt@kms_hdr@static-toggle-dpms:
    - shard-rkl:          [SKIP][381] ([i915#1845] / [i915#4098]) -> [SKIP][382] ([i915#3555] / [i915#8228])
   [381]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_hdr@static-toggle-dpms.html
   [382]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_hdr@static-toggle-dpms.html

  * igt@kms_hdr@static-toggle-suspend:
    - shard-rkl:          [SKIP][383] ([i915#3555] / [i915#8228]) -> [SKIP][384] ([i915#1845] / [i915#4098])
   [383]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-7/igt@kms_hdr@static-toggle-suspend.html
   [384]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-5/igt@kms_hdr@static-toggle-suspend.html

  * igt@kms_multipipe_modeset@basic-max-pipe-crc-check:
    - shard-rkl:          [SKIP][385] ([i915#4070] / [i915#4816]) -> [SKIP][386] ([i915#4816])
   [385]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-6/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html
   [386]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_multipipe_modeset@basic-max-pipe-crc-check.html

  * igt@kms_panel_fitting@legacy:
    - shard-rkl:          [SKIP][387] ([i915#1845] / [i915#4098]) -> [SKIP][388] ([i915#6301])
   [387]: https://intel-gfx-ci.01.org/tree/drm-tip/CI_DRM_13844/shard-rkl-5/igt@kms_panel_fitting@legacy.html
   [388]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_10122/shard-rkl-4/igt@kms_panel_fitting@legacy.html

  
  {name}: This element is suppressed. This means it is ignored when computing
          the status of the difference (SUCCESS, WARNING, or FAILURE).

  [IGT#2]: https://gitlab.freedesktop.org/drm/igt-gpu-tools/issues/2
  [Intel XE#874]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/874
  [fdo#103375]: https://bugs.freedesktop.org/show_bug.cgi?id=103375
  [fdo#109271]: https://bugs.freedesktop.org/show_bug.cgi?id=109271
  [fdo#109274]: https://bugs.freedesktop.org/show_bug.cgi?id=109274
  [fdo#109280]: https://bugs.freedesktop.org/show_bug.cgi?id=109280
  [fdo#109285]: https://bugs.freedesktop.org/show_bug.cgi?id=109285
  [fdo#109289]: https://bugs.freedesktop.org/show_bug.cgi?id=109289
  [fdo#109291]: https://bugs.freedesktop.org/show_bug.cgi?id=109291
  [fdo#109295]: https://bugs.freedesktop.org/show_bug.cgi?id=109295
  [fdo#109302]: https://bugs.freedesktop.org/show_bug.cgi?id=109302
  [fdo#109303]: https://bugs.freedesktop.org/show_bug.cgi?id=109303
  [fdo#109308]: https://bugs.freedesktop.org/show_bug.cgi?id=109308
  [fdo#109314]: https://bugs.freedesktop.org/show_bug.cgi?id=109314
  [fdo#109315]: https://bugs.freedesktop.org/show_bug.cgi?id=109315
  [fdo#110189]: https://bugs.freedesktop.org/show_bug.cgi?id=110189
  [fdo#110723]: https://bugs.freedesktop.org/show_bug.cgi?id=110723
  [fdo#111068]: https://bugs.freedesktop.org/show_bug.cgi?id=111068
  [fdo#111614]: https://bugs.freedesktop.org/show_bug.cgi?id=111614
  [fdo#111615]: https://bugs.freedesktop.org/show_bug.cgi?id=111615
  [fdo#111767]: https://bugs.freedesktop.org/show_bug.cgi?id=111767
  [fdo#111825]: https://bugs.freedesktop.org/show_bug.cgi?id=111825
  [fdo#111827]: https://bugs.freedesktop.org/show_bug.cgi?id=111827
  [fdo#112283]: https://bugs.freedesktop.org/show_bug.cgi?id=112283
  [i915#1072]: https://gitlab.freedesktop.org/drm/intel/issues/1072
  [i915#1099]: https://gitlab.freedesktop.org/drm/intel/issues/1099
  [i915#1257]: https://gitlab.freedesktop.org/drm/intel/issues/1257
  [i915#1769]: https://gitlab.freedesktop.org/drm/intel/issues/1769
  [i915#1825]: https://gitlab.freedesktop.org/drm/intel/issues/1825
  [i915#1839]: https://gitlab.freedesktop.org/drm/intel/issues/1839
  [i915#1845]: https://gitlab.freedesktop.org/drm/intel/issues/1845
  [i915#1849]: https://gitlab.freedesktop.org/drm/intel/issues/1849
  [i915#2346]: https://gitlab.freedesktop.org/drm/intel/issues/2346
  [i915#2436]: https://gitlab.freedesktop.org/drm/intel/issues/2436
  [i915#2437]: https://gitlab.freedesktop.org/drm/intel/issues/2437
  [i915#2527]: https://gitlab.freedesktop.org/drm/intel/issues/2527
  [i915#2575]: https://gitlab.freedesktop.org/drm/intel/issues/2575
  [i915#2582]: https://gitlab.freedesktop.org/drm/intel/issues/2582
  [i915#2587]: https://gitlab.freedesktop.org/drm/intel/issues/2587
  [i915#2658]: https://gitlab.freedesktop.org/drm/intel/issues/2658
  [i915#2672]: https://gitlab.freedesktop.org/drm/intel/issues/2672
  [i915#2705]: https://gitlab.freedesktop.org/drm/intel/issues/2705
  [i915#280]: https://gitlab.freedesktop.org/drm/intel/issues/280
  [i915#2842]: https://gitlab.freedesktop.org/drm/intel/issues/2842
  [i915#2846]: https://gitlab.freedesktop.org/drm/intel/issues/2846
  [i915#2856]: https://gitlab.freedesktop.org/drm/intel/issues/2856
  [i915#2920]: https://gitlab.freedesktop.org/drm/intel/issues/2920
  [i915#3023]: https://gitlab.freedesktop.org/drm/intel/issues/3023
  [i915#3116]: https://gitlab.freedesktop.org/drm/intel/issues/3116
  [i915#3281]: https://gitlab.freedesktop.org/drm/intel/issues/3281
  [i915#3282]: https://gitlab.freedesktop.org/drm/intel/issues/3282
  [i915#3291]: https://gitlab.freedesktop.org/drm/intel/issues/3291
  [i915#3297]: https://gitlab.freedesktop.org/drm/intel/issues/3297
  [i915#3318]: https://gitlab.freedesktop.org/drm/intel/issues/3318
  [i915#3323]: https://gitlab.freedesktop.org/drm/intel/issues/3323
  [i915#3359]: https://gitlab.freedesktop.org/drm/intel/issues/3359
  [i915#3458]: https://gitlab.freedesktop.org/drm/intel/issues/3458
  [i915#3539]: https://gitlab.freedesktop.org/drm/intel/issues/3539
  [i915#3546]: https://gitlab.freedesktop.org/drm/intel/issues/3546
  [i915#3555]: https://gitlab.freedesktop.org/drm/intel/issues/3555
  [i915#3591]: https://gitlab.freedesktop.org/drm/intel/issues/3591
  [i915#3637]: https://gitlab.freedesktop.org/drm/intel/issues/3637
  [i915#3638]: https://gitlab.freedesktop.org/drm/intel/issues/3638
  [i915#3708]: https://gitlab.freedesktop.org/drm/intel/issues/3708
  [i915#3743]: https://gitlab.freedesktop.org/drm/intel/issues/3743
  [i915#3840]: https://gitlab.freedesktop.org/drm/intel/issues/3840
  [i915#3955]: https://gitlab.freedesktop.org/drm/intel/issues/3955
  [i915#4070]: https://gitlab.freedesktop.org/drm/intel/issues/4070
  [i915#4077]: https://gitlab.freedesktop.org/drm/intel/issues/4077
  [i915#4079]: https://gitlab.freedesktop.org/drm/intel/issues/4079
  [i915#4083]: https://gitlab.freedesktop.org/drm/intel/issues/4083
  [i915#4087]: https://gitlab.freedesktop.org/drm/intel/issues/4087
  [i915#4098]: https://gitlab.freedesktop.org/drm/intel/issues/4098
  [i915#4103]: https://gitlab.freedesktop.org/drm/intel/issues/4103
  [i915#4212]: https://gitlab.freedesktop.org/drm/intel/issues/4212
  [i915#4213]: https://gitlab.freedesktop.org/drm/intel/issues/4213
  [i915#4235]: https://gitlab.freedesktop.org/drm/intel/issues/4235
  [i915#4270]: https://gitlab.freedesktop.org/drm/intel/issues/4270
  [i915#4281]: https://gitlab.freedesktop.org/drm/intel/issues/4281
  [i915#4349]: https://gitlab.freedesktop.org/drm/intel/issues/4349
  [i915#4423]: https://gitlab.freedesktop.org/drm/intel/issues/4423
  [i915#4473]: https://gitlab.freedesktop.org/drm/intel/issues/4473
  [i915#4525]: https://gitlab.freedesktop.org/drm/intel/issues/4525
  [i915#4528]: https://gitlab.freedesktop.org/drm/intel/issues/4528
  [i915#4537]: https://gitlab.freedesktop.org/drm/intel/issues/4537
  [i915#4538]: https://gitlab.freedesktop.org/drm/intel/issues/4538
  [i915#4565]: https://gitlab.freedesktop.org/drm/intel/issues/4565
  [i915#4573]: https://gitlab.freedesktop.org/drm/intel/issues/4573
  [i915#4613]: https://gitlab.freedesktop.org/drm/intel/issues/4613
  [i915#4771]: https://gitlab.freedesktop.org/drm/intel/issues/4771
  [i915#4812]: https://gitlab.freedesktop.org/drm/intel/issues/4812
  [i915#4816]: https://gitlab.freedesktop.org/drm/intel/issues/4816
  [i915#4852]: https://gitlab.freedesktop.org/drm/intel/issues/4852
  [i915#4854]: https://gitlab.freedesktop.org/drm/intel/issues/4854
  [i915#4860]: https://gitlab.freedesktop.org/drm/intel/issues/4860
  [i915#4879]: https://gitlab.freedesktop.org/drm/intel/issues/4879
  [i915#4885]: https://gitlab.freedesktop.org/drm/intel/issues/4885
  [i915#5176]: https://gitlab.freedesktop.org/drm/intel/issues/5176
  [i915#5190]: https://gitlab.freedesktop.org/drm/intel/issues/5190
  [i915#5235]: https://gitlab.freedesktop.org/drm/intel/issues/5235
  [i915#5274]: https://gitlab.freedesktop.org/drm/intel/issues/5274
  [i915#5286]: https://gitlab.freedesktop.org/drm/intel/issues/5286
  [i915#5289]: https://gitlab.freedesktop.org/drm/intel/issues/5289
  [i915#5334]: https://gitlab.freedesktop.org/drm/intel/issues/5334
  [i915#5354]: https://gitlab.freedesktop.org/drm/intel/issues/5354
  [i915#5439]: https://gitlab.freedesktop.org/drm/intel/issues/5439
  [i915#5460]: https://gitlab.freedesktop.org/drm/intel/issues/5460
  [i915#5461]: https://gitlab.freedesktop.org/drm/intel/issues/5461
  [i915#5493]: https://gitlab.freedesktop.org/drm/intel/issues/5493
  [i915#5608]: https://gitlab.freedesktop.org/drm/intel/issues/5608
  [i915#5723]: https://gitlab.freedesktop.org/drm/intel/issues/5723
  [i915#5784]: https://gitlab.freedesktop.org/drm/intel/issues/5784
  [i915#5882]: https://gitlab.freedesktop.org/drm/intel/issues/5882
  [i915#5889]: https://gitlab.freedesktop.org/drm/intel/issues/5889
  [i915#6095]: https://gitlab.freedesktop.org/drm/intel/issues/6095
  [i915#6118]: https://gitlab.freedesktop.org/drm/intel/issues/6118
  [i915#6228]: https://gitlab.freedesktop.org/drm/intel/issues/6228
  [i915#6245]: https://gitlab.freedesktop.org/drm/intel/issues/6245
  [i915#6252]: https://gitlab.freedesktop.org/drm/intel/issues/6252
  [i915#6301]: https://gitlab.freedesktop.org/drm/intel/issues/6301
  [i915#6412]: https://gitlab.freedesktop.org/drm/intel/issues/6412
  [i915#6524]: https://gitlab.freedesktop.org/drm/intel/issues/6524
  [i915#658]: https://gitlab.freedesktop.org/drm/intel/issues/658
  [i915#6805]: https://gitlab.freedesktop.org/drm/intel/issues/6805
  [i915#6806]: https://gitlab.freedesktop.org/drm/intel/issues/6806
  [i915#6892]: https://gitlab.freedesktop.org/drm/intel/issues/6892
  [i915#6944]: https://gitlab.freedesktop.org/drm/intel/issues/6944
  [i915#6953]: https://gitlab.freedesktop.org/drm/intel/issues/6953
  [i915#7118]: https://gitlab.freedesktop.org/drm/intel/issues/7118
  [i915#7173]: https://gitlab.freedesktop.org/drm/intel/issues/7173
  [i915#7213]: https://gitlab.freedesktop.org/drm/intel/issues/7213
  [i915#7387]: https://gitlab.freedesktop.org/drm/intel/issues/7387
  [i915#7484]: https://gitlab.freedesktop.org/drm/intel/issues/7484
  [i915#768]: https://gitlab.freedesktop.org/drm/intel/issues/768
  [i915#7697]: https://gitlab.freedesktop.org/drm/intel/issues/7697
  [i915#7711]: https://gitlab.freedesktop.org/drm/intel/issues/7711
  [i915#7742]: https://gitlab.freedesktop.org/drm/intel/issues/7742
  [i915#7790]: https://gitlab.freedesktop.org/drm/intel/issues/7790
  [i915#7828]: https://gitlab.freedesktop.org/drm/intel/issues/7828
  [i915#7957]: https://gitlab.freedesktop.org/drm/intel/issues/7957
  [i915#7975]: https://gitlab.freedesktop.org/drm/intel/issues/7975
  [i915#7984]: https://gitlab.freedesktop.org/drm/intel/issues/7984
  [i915#8152]: https://gitlab.freedesktop.org/drm/intel/issues/8152
  [i915#8213]: https://gitlab.freedesktop.org/drm/intel/issues/8213
  [i915#8228]: https://gitlab.freedesktop.org/drm/intel/issues/8228
  [i915#8292]: https://gitlab.freedesktop.org/drm/intel/issues/8292
  [i915#8381]: https://gitlab.freedesktop.org/drm/intel/issues/8381
  [i915#8399]: https://gitlab.freedesktop.org/drm/intel/issues/8399
  [i915#8411]: https://gitlab.freedesktop.org/drm/intel/issues/8411
  [i915#8414]: https://gitlab.freedesktop.org/drm/intel/issues/8414
  [i915#8428]: https://gitlab.freedesktop.org/drm/intel/issues/8428
  [i915#8489]: https://gitlab.freedesktop.org/drm/intel/issues/8489
  [i915#8516]: https://gitlab.freedesktop.org/drm/intel/issues/8516
  [i915#8555]: https://gitlab.freedesktop.org/drm/intel/issues/8555
  [i915#8562]: https://gitlab.freedesktop.org/drm/intel/issues/8562
  [i915#8623]: https://gitlab.freedesktop.org/drm/intel/issues/8623
  [i915#8668]: https://gitlab.freedesktop.org/drm/intel/issues/8668
  [i915#8708]: https://gitlab.freedesktop.org/drm/intel/issues/8708
  [i915#8709]: https://gitlab.freedesktop.org/drm/intel/issues/8709
  [i915#8717]: https://gitlab.freedesktop.org/drm/intel/issues/8717
  [i915#8724]: https://gitlab.freedesktop.org/drm/intel/issues/8724
  [i915#8809]: https://gitlab.freedesktop.org/drm/intel/issues/8809
  [i915#8810]: https://gitlab.freedesktop.org/drm/intel/issues/8810
  [i915#8812]: https://gitlab.freedesktop.org/drm/intel/issues/8812
  [i915#8814]: https://gitlab.freedesktop.org/drm/intel/issues/8814
  [i915#8825]: https://gitlab.freedesktop.org/drm/intel/issues/8825
  [i915#8841]: https://gitlab.freedesktop.org/drm/intel/issues/8841
  [i915#8850]: https://gitlab.freedesktop.org/drm/intel/issues/8850
  [i915#8875]: https://gitlab.freedesktop.org/drm/intel/issues/8875
  [i915#8925]: https://gitlab.freedesktop.org/drm/intel/issues/8925
  [i915#9010]: https://gitlab.freedesktop.org/drm/intel/issues/9010
  [i915#9053]: https://gitlab.freedesktop.org/drm/intel/issues/9053
  [i915#9196]: https://gitlab.freedesktop.org/drm/intel/issues/9196
  [i915#9226]: https://gitlab.freedesktop.org/drm/intel/issues/9226
  [i915#9227]: https://gitlab.freedesktop.org/drm/intel/issues/9227
  [i915#9261]: https://gitlab.freedesktop.org/drm/intel/issues/9261
  [i915#9295]: https://gitlab.freedesktop.org/drm/intel/issues/9295
  [i915#9323]: https://gitlab.freedesktop.org/drm/intel/issues/9323
  [i915#9340]: https://gitlab.freedesktop.org/drm/intel/issues/9340
  [i915#9414]: https://git

== Logs ==

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

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

[igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Test enables VFs in range <1..totalvfs>, bind driver to all of them and
then unbind driver from all of them.

Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
---
 tests/sriov_basic.c | 48 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index 8717d2186..a10b7a290 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -59,6 +59,35 @@ static void enable_vfs_autoprobe_on(int pf_fd, unsigned int num_vfs)
 	igt_assert(!err);
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-all-unbind-all
+ * Description:
+ *   Verify VFs enabling, binding the driver and then unbinding it from all of them
+ */
+static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Testing %u VFs\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+
+	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_assert(igt_sriov_disable_vfs(pf_fd));
+}
+
 igt_main
 {
 	int pf_fd;
@@ -111,6 +140,25 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0

Re: [igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Laguna, Lukasz]

On 11/6/2023 23:07, Michal Wajdeczko wrote:
>
> On 06.11.2023 20:59, Lukasz Laguna wrote:
>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>
>> Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.
>>
>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>> ---
>>   lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
>>   lib/igt_sriov_device.h |  20 +++++
>>   lib/meson.build        |   1 +
>>   3 files changed, 195 insertions(+)
>>   create mode 100644 lib/igt_sriov_device.c
>>   create mode 100644 lib/igt_sriov_device.h
>>
>> diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
>> new file mode 100644
>> index 000000000..7d53c2045
>> --- /dev/null
>> +++ b/lib/igt_sriov_device.c
>> @@ -0,0 +1,174 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>> + */
>> +
>> +#include "igt_core.h"
>> +#include "igt_sriov_device.h"
>> +#include "igt_sysfs.h"
>> +
>> +/**
>> + * igt_sriov_is_pf:
> nit: short function description missing, not required anymore?
Most of the IGT helpers don't have it and from what I see it's not added 
for new helpers.
>
>> + * @device: device file descriptor
>> + *
>> + * Check if device is PF by checking existence of sriov_totalvfs file
>> + * and non-zero value read from that file.
> just to clarify/be precise, do you want to check here "device"
> capability or "driver" capability ?
>
> IIRC the PCI subsystem will set these attributes on the "PF device" even
> if attached "PF driver" does not provide required hook to enable VFs
> (and this is main purpose of being a "PF", no?)
Helper is for checking device capability. If device is not PF test will 
skip, if driver doesn't provide required hook to enable VFstest will fail.
>
>> + *
>> + * Returns:
>> + * True if device is PF, false otherwise.
>> + */
>> +bool igt_sriov_is_pf(int device)
>> +{
>> +	int sysfs;
>> +	bool ret;
>> +	uint32_t totalvfs;
> nit: we shouldn't specify width if not needed, maybe plain unsigned int
> will just work ? shame that there are no __igt_sysfs_get_uint()
>
>> +
>> +	sysfs = igt_sysfs_open(device);
>> +	igt_assert_fd(sysfs);
>> +
>> +	ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs", &totalvfs);
>> +	close(sysfs);
>> +
>> +	if (!ret)
>> +		return false;
>> +
>> +	return totalvfs > 0;
>> +}
>> +
>> +static uint32_t __pf_attr_get_u32(int pf, const char *attr)
>> +{
>> +	int sysfs;
>> +	uint32_t value;
>> +
>> +	igt_assert(igt_sriov_is_pf(pf));
>> +
>> +	sysfs = igt_sysfs_open(pf);
>> +	igt_assert_fd(sysfs);
>> +
>> +	value = igt_sysfs_get_u32(sysfs, attr);
>> +	close(sysfs);
>> +
>> +	return value;
>> +}
>> +
>> +static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
>> +{
>> +	int sysfs;
>> +	bool ret;
>> +
>> +	igt_assert(igt_sriov_is_pf(pf));
>> +
>> +	sysfs = igt_sysfs_open(pf);
>> +	igt_assert_fd(sysfs);
>> +
>> +	ret = __igt_sysfs_set_u32(sysfs, attr, value);
>> +	close(sysfs);
>> +
>> +	return ret;
>> +}
>> +
>> +/**
>> + * igt_sriov_get_totalvfs:
>> + * @pf: PF device file descriptor
>> + *
>> + * Get maximum number of VFs that can be enabled.
>> + *
>> + * Returns:
>> + * Maximum number of VFs that could be associated with given PF.
>> + */
>> +unsigned int igt_sriov_get_total_vfs(int pf)
>> +{
>> +	return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
>> +}
>> +
>> +/**
>> + * igt_sriov_get_numvfs:
>> + * @pf: PF device file descriptor
>> + *
>> + * Get number of enabled VFs.
>> + *
>> + * Returns:
>> + * Number of VFs enabled by given PF.
>> + */
>> +unsigned int igt_sriov_get_enabled_vfs(int pf)
>> +{
>> +	return __pf_attr_get_u32(pf, "device/sriov_numvfs");
>> +}
>> +
>> +/**
>> + * igt_sriov_enable_vfs:
> Helper for VFs enabling
>
>> + * @pf: PF device file descriptor
>> + * @num_vfs: Number of virtual functions to be enabled
>> + *
>> + * Helper for VFs enabling.
> "This will try to enable VFs by writing @num_vfs to ...
Done
>
>> + *
>> + * Returns:
>> + * True on success and false on failure.
>> + */
>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
>> +{
>> +	igt_assert(num_vfs > 0);
>> +	igt_debug("Enabling %u VFs\n", num_vfs);
>> +	return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
>> +}
>> +
>> +/**
>> + * igt_sriov_disable_vfs:
> Helper for VFs disabling
>
>> + * @pf: PF device file descriptor
>> + *
>> + * Set 0 in sriov_numvfs file to disable VFs.
> "This will try to disable already enabled VFs by writing 0 to ...
Done
>
>> + *
>> + * Returns:
>> + * True on success and false on failure.
>> + */
>> +bool igt_sriov_disable_vfs(int pf)
>> +{
>> +	igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));
> this will trigger unnecessary "read" operation just for debug purposes,
> while in log you should already see "Enabling N VFs", so we know the N.
Done
>
>> +	return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
>> +}
>> +
>> +/**
>> + * igt_sriov_is_driver_autoprobe_enabled:
>> + * @pf: PF device file descriptor
>> + *
>> + * Get current driver autoprobe setting.
> hmm, this is SRIOV driver autoprobe (or VF driver autoprobe for
> short/clarity)
Done
>
>> + *
>> + * Returns:
>> + * True if autoprobe is enabled, false otherwise.
>> + */
>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf)
>> +{
>> +	return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
>> +}
>> +
>> +/**
>> + * igt_sriov_enable_driver_autoprobe:
>> + * @pf: PF device file descriptor
>> + *
>> + * Set driver autoprobe to true.
>> + *
>> + * During VFs enabling driver will be bound to VFs.
> "If successful, then kernel will automatically bind VFs to a compatible
> driver immediately after they are enabled.
Done
>
>> + *
>> + * Return:
>> + * True if setting driver autoprobe succeed, otherwise false.
>> + */
>> +bool igt_sriov_enable_driver_autoprobe(int pf)
>> +{
>> +	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", true);
>> +}
>> +
>> +/**
>> + * igt_sriov_disable_driver_autoprobe:
>> + * @pf: PF device file descriptor
>> + *
>> + * Set driver autoprobe to false.
>> + *
>> + * During VFs enabling driver won't be bound to VFs.
>> + *
>> + * Return:
>> + * True if setting driver autoprobe succeed, otherwise false.
>> + */
>> +bool igt_sriov_disable_driver_autoprobe(int pf)
>> +{
>> +	return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe", false);
>> +}
>> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
>> new file mode 100644
>> index 000000000..f2c5c44fa
>> --- /dev/null
>> +++ b/lib/igt_sriov_device.h
>> @@ -0,0 +1,20 @@
>> +/* SPDX-License-Identifier: MIT */
>> +/*
>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>> + */
>> +
>> +#ifndef __IGT_SRIOV_DEVICE_H__
>> +#define __IGT_SRIOV_DEVICE_H__
>> +
>> +#include <stdint.h>
>> +
>> +bool igt_sriov_is_pf(int device);
>> +unsigned int igt_sriov_get_total_vfs(int pf);
>> +unsigned int igt_sriov_get_enabled_vfs(int pf);
>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
>> +bool igt_sriov_disable_vfs(int pf);
>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf);
>> +bool igt_sriov_enable_driver_autoprobe(int pf);
>> +bool igt_sriov_disable_driver_autoprobe(int pf);
> nit: I'm wondering if there is any pattern to have:
>
> a) void function that has igt_assert() inside
> b) bool function that has no igt_assert() inside
>
> then for writing scenario you just use a) without need to check
> and use b) only when doing lower level testing and use dedicated checks
Maybe we could use __ prefix for b), but I don't see a need for such 
split TBH.
>
>> +
>> +#endif /* __IGT_SRIOV_DEVICE_H__ */
>> diff --git a/lib/meson.build b/lib/meson.build
>> index a7bccafc3..083baa68a 100644
>> --- a/lib/meson.build
>> +++ b/lib/meson.build
>> @@ -38,6 +38,7 @@ lib_sources = [
>>   	'igt_primes.c',
>>   	'igt_pci.c',
>>   	'igt_rand.c',
>> +	'igt_sriov_device.c',
>>   	'igt_stats.c',
>>   	'igt_syncobj.c',
>>   	'igt_sysfs.c',

Re: [igt-dev] [PATCH i-g-t 4/8] lib/igt_sriov_device: add helpers for operations in different VFs scenarios

[Laguna, Lukasz]

On 11/6/2023 23:13, Michal Wajdeczko wrote:
>
> On 06.11.2023 20:59, Lukasz Laguna wrote:
>> Added helpers:
>> - for_each_vf and for_each_num_vfs
>> - for_random_vf and for_random_num_vfs
>> - for_last_vf and for_max_num_vfs
>>
>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>> ---
>>   lib/igt_sriov_device.h | 18 ++++++++++++++++++
>>   1 file changed, 18 insertions(+)
>>
>> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
>> index be4e56cf3..78cb0e73b 100644
>> --- a/lib/igt_sriov_device.h
>> +++ b/lib/igt_sriov_device.h
>> @@ -19,4 +19,22 @@ bool igt_sriov_disable_driver_autoprobe(int pf);
>>   int igt_sriov_open_vf_drm_device(int pf, unsigned int vf_num);
>>   bool igt_sriov_is_vf_drm_driver_probed(int pf, unsigned int vf_num);
>>   
> please document macros and their params
Done
>
>> +#define for_each_vf(__pf_fd, __vf_num) \
>> +	for (unsigned int __vf_num = 1, __total_vfs = igt_sriov_get_total_vfs(__pf_fd); \
>> +	     __vf_num <= __total_vfs; \
>> +	     ++__vf_num)
>> +#define for_each_num_vfs for_each_vf
> why do you need this alias ?
If test operates on ranges of VFs, not on specific VFs then code it's 
more readable and clear with this alias.
>
>> +
>> +#define for_random_vf(__pf_fd, __vf_num) \
>> +	for (unsigned int __vf_num = 1 + random() % igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
>> +	     __tmp < 1; \
>> +	     ++__tmp)
>> +#define for_random_num_vfs for_random_vf
>> +
>> +#define for_last_vf(__pf_fd, __vf_num) \
>> +	for (unsigned int __vf_num = igt_sriov_get_total_vfs(__pf_fd), __tmp = 0; \
>> +	     __tmp < 1; \
>> +	     ++__tmp)
>> +#define for_max_num_vfs for_last_vf
>> +
>>   #endif /* __IGT_SRIOV_DEVICE_H__ */

Re: [igt-dev] [PATCH i-g-t 5/8] tests/sriov_basic: add basic tests for enabling SR-IOV VFs

[Laguna, Lukasz]

On 11/6/2023 23:46, Michal Wajdeczko wrote:
>
> On 06.11.2023 20:59, Lukasz Laguna wrote:
>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>
>> Add subtests that validate SR-IOV VFs enabling in two variants: with
>> autoprobe disabled and enabled.
>>
>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>> ---
>>   tests/meson.build   |   1 +
>>   tests/sriov_basic.c | 126 ++++++++++++++++++++++++++++++++++++++++++++
>>   2 files changed, 127 insertions(+)
>>   create mode 100644 tests/sriov_basic.c
>>
>> diff --git a/tests/meson.build b/tests/meson.build
>> index 62721157d..7413d978c 100644
>> --- a/tests/meson.build
>> +++ b/tests/meson.build
>> @@ -71,6 +71,7 @@ test_progs = [
>>   	'panfrost_submit',
>>   	'prime_udl',
>>   	'prime_vgem',
>> +	'sriov_basic',
>>   	'syncobj_basic',
>>   	'syncobj_eventfd',
>>   	'syncobj_wait',
>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>> new file mode 100644
>> index 000000000..fc0914962
>> --- /dev/null
>> +++ b/tests/sriov_basic.c
>> @@ -0,0 +1,126 @@
>> +// SPDX-License-Identifier: MIT
>> +/*
>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>> + */
>> +
>> +#include "drmtest.h"
>> +#include "igt_core.h"
>> +#include "igt_sriov_device.h"
>> +
>> +IGT_TEST_DESCRIPTION("Basic tests for enabling SR-IOV Virtual Functions");
>> +
>> +/**
>> + * TEST: sriov_basic
>> + * Category: Software building block
>> + * Mega feature: SR-IOV
>> + * Sub-category: VFs enabling
>> + * Run type: BAT
>> + * Description: Validate SR-IOV VFs enabling
>> + */
>> +
>> +/**
>> + * SUBTEST: enable-vfs-autoprobe-off
>> + * Description:
>> + *   Verify VFs enabling without probing VF driver
>> + */
>> +static void enable_disable_vfs(int pf_fd, unsigned int num_vfs)
> 	"enable-vfs-autoprobe-off"
> and
> 	"enable_disable_vfs"
> are different
> shouldn't they match somehow ?
Done
>
>> +{
>> +	igt_debug("Using num_vfs=%u\n", num_vfs);
>> +
>> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
> this seems to duplicate first fixture, do we really need to repeat that
> over and over ?
It's not the same. First fixtureis not executed between dynamic subtests.
>
>> +	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
>> +	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> this seems crazy and unrelated to test scope - we are not checking here
> the behavior of the "driver_autoprobe" attribute, we should just trust
> that 'disable' above worked since it returned true and we already
> asserted that
Done
>
>> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
> this should be "expect" type of check, as we still want to disable VFs
VFs will be disabled in exit fixture. VFs disabling in subtest is needed 
between dynamic subtests.
>
>> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
> maybe assert here that enabled_vfs == num_vfs ?
Some time ago we've got a sugesstion that we should have seperate test 
for VFs disabling. We can check
     igt_assert_eq(0, igt_sriov_get_enabled_vfs(pf_fd));
there,  when implemented.
>
>> +}
>> +
>> +/**
>> + * SUBTEST: enable-vfs-autoprobe-on
>> + * Description:
>> + *   Verify VFs enabling and auto-probing VF driver
>> + */
>> +static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
> here is even more different
>
> 	"enable-vfs-autoprobe-on"
> vs
> 	"probe_disable_vfs"
>
> also "probe" here may clash with future test that will "probe" just
> selected VF
Done
>
>> +{
>> +	bool err = false;
>> +
>> +	igt_debug("Using num_vfs=%u\n", num_vfs);
>> +
>> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
> ditto
>
>> +	igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
>> +	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> ditto
>
>> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
> ditto
>
>> +	for (int vf_num = 1; vf_num <= num_vfs; ++vf_num) {
>> +		if (!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num)) {
>> +			igt_debug("VF%u probe failed\n", vf_num);
>> +			err = true;
>> +		}
>> +	}
>> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
> disabling VFs immediately after enabling could be treated as a "stress"
> test - shouldn't we have some grace period for a "basic" class test ?
I can add some sleep before VFs disabling. Do you have some specific 
value we should use in mind? 2s?
> stress loop with probe/unload could be different test case
Yeah, it's in another patch from this series
>
>> +	igt_assert(!err);
>> +}
>> +
>> +igt_main
>> +{
>> +	int pf_fd;
>> +	bool autoprobe;
>> +
>> +	igt_fixture {
>> +		pf_fd = drm_open_driver(DRIVER_ANY);
>> +		igt_require(igt_sriov_is_pf(pf_fd));
>> +		igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>> +		autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
>> +
>> +		igt_srandom();
> shouldn't this be part of the main() or something ?
Probably it could be, but no one has implemented it yet. There are many 
other tests that initializes seed in fixture.
>> +	}
>> +
>> +	igt_describe("Verify VFs enabling without probing VF driver");
>> +	igt_subtest_with_dynamic("enable-vfs-autoprobe-off") {
>> +		for_each_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-%u", num_vfs) {
>> +				enable_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_random_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-random") {
>> +				enable_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_max_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-all") {
>> +				enable_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +	}
>> +
>> +	igt_describe("Verify VFs enabling and auto-probing VF driver");
>> +	igt_subtest_with_dynamic("enable-vfs-autoprobe-on") {
>> +		for_each_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-%u", num_vfs) {
>> +				probe_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_random_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-random") {
>> +				probe_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_max_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-all") {
>> +				probe_disable_vfs(pf_fd, num_vfs);
>> +			}
>> +		}
>> +	}
>> +
>> +	igt_fixture {
>> +		igt_sriov_disable_vfs(pf_fd);
>> +		/* abort to avoid execution of next tests with enabled VFs */
>> +		igt_abort_on_f(igt_sriov_get_enabled_vfs(pf_fd) > 0, "Failed to disable VF(s)");
> can't this be just:
>
> 	igt_abort_on_f(!igt_sriov_disable_vfs(pf_fd), "");
> 	igt_abort_on_f(!igt_sriov_set_driver_autoprobe(autoprobe), "");
It's for case when helper e.g. igt_sriov_disable_vfsdoesn't return 
error, but VFs are still enabled.
>> +		autoprobe ? igt_sriov_enable_driver_autoprobe(pf_fd) :
>> +			    igt_sriov_disable_driver_autoprobe(pf_fd);
>> +		igt_abort_on_f(autoprobe != igt_sriov_is_driver_autoprobe_enabled(pf_fd),
>> +			       "Failed to restore sriov_drivers_autoprobe value\n");
>> +		close(pf_fd);
>> +	}
>> +}

Re: [igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Laguna, Lukasz]

On 11/6/2023 23:59, Michal Wajdeczko wrote:
>
> On 06.11.2023 20:59, Lukasz Laguna wrote:
>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>
>> Test enables VFs in range <1..totalvfs>, bind driver to all of them and
>> then unbind driver from all of them.
> commit message seems outdated
What do you mean? I don't see anything wrong
>
>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>> ---
>>   tests/sriov_basic.c | 51 +++++++++++++++++++++++++++++++++++++++++++++
>>   1 file changed, 51 insertions(+)
>>
>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>> index fc0914962..179731daf 100644
>> --- a/tests/sriov_basic.c
>> +++ b/tests/sriov_basic.c
>> @@ -61,6 +61,38 @@ static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
>>   	igt_assert(!err);
>>   }
>>   
>> +/**
>> + * SUBTEST: enable-vfs-bind-all-unbind-all
>> + * Description:
>> + *   Verify VFs enabling, binding the driver and then unbinding it from all of them
>> + */
>> +static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
>> +{
>> +	igt_debug("Using num_vfs=%u\n", num_vfs);
> nit: "Testing %u VFs" ?
Done
>
>> +
>> +	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
> duplicates main fixture
As already answered in different patch - first fixtureis not executed 
between dynamic subtests.
>
>> +	igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
>> +	igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> why do we need warn/skip here ?
> can't we just assert that 'disable' worked ?
Done
>
>> +
>> +	igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));
> can't we just assert ?
Done
>
>> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
> why we care here ? if not all are enabled then we fail just later
> and this is not a test for "enable VFs" that enabled==requested
Done
>
>> +	igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
>> +	igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> can't we just warn ?
> if that we fail to enable then probe below will fail anyway
Done
>
>> +
>> +	for (int i = 1; i <= num_vfs; i++) {
>> +		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>> +		igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
>> +		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
> shouldn't we just "expect" to make sure to call "disable VFs" ?
VFs will be disabled in exit fixture. VFs disabling in subtest is needed 
between dynamic subtests.
>
>> +	}
>> +
>> +	for (int i = 1; i <= num_vfs; i++) {
>> +		igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
>> +		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
> do we need to have all VFs loaded ?
> maybe for BAT test we can just bind/unload one VF at the time ?
We have such test as well:
[PATCH i-g-t 8/8] tests/sriov_basic: add more tests for VF driver binding
     SUBTEST: enable-vfs-bind-unbind-each
     SUBTEST: bind-unbind-vf
>
> otherwise it will be almost the same level of stress as in
> "enable-vfs-autoprobe-on" but with 'manual probe' loop of all VFs
>
>> +	}
>> +
>> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
>> +}
>> +
>>   igt_main
>>   {
>>   	int pf_fd;
>> @@ -113,6 +145,25 @@ igt_main
>>   		}
>>   	}
>>   
>> +	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
>> +	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
>> +		for_each_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-%u", num_vfs) {
>> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_random_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-random") {
>> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>> +			}
>> +		}
>> +		for_max_num_vfs(pf_fd, num_vfs) {
>> +			igt_dynamic_f("numvfs-all") {
>> +				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>> +			}
>> +		}
>> +	}
>> +
>>   	igt_fixture {
>>   		igt_sriov_disable_vfs(pf_fd);
>>   		/* abort to avoid execution of next tests with enabled VFs */

Re: [igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Michal Wajdeczko]

On 09.11.2023 07:55, Laguna, Lukasz wrote:
> 
> On 11/6/2023 23:07, Michal Wajdeczko wrote:
>>
>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>
>>> Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.
>>>
>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>> ---
>>>   lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
>>>   lib/igt_sriov_device.h |  20 +++++
>>>   lib/meson.build        |   1 +
>>>   3 files changed, 195 insertions(+)
>>>   create mode 100644 lib/igt_sriov_device.c
>>>   create mode 100644 lib/igt_sriov_device.h
>>>
>>> diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
>>> new file mode 100644
>>> index 000000000..7d53c2045
>>> --- /dev/null
>>> +++ b/lib/igt_sriov_device.c
>>> @@ -0,0 +1,174 @@
>>> +// SPDX-License-Identifier: MIT
>>> +/*
>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>> + */
>>> +
>>> +#include "igt_core.h"
>>> +#include "igt_sriov_device.h"
>>> +#include "igt_sysfs.h"
>>> +
>>> +/**
>>> + * igt_sriov_is_pf:
>> nit: short function description missing, not required anymore?
> Most of the IGT helpers don't have it and from what I see it's not added
> for new helpers.

so will ask in a different way: what documentation rules IGT is trying
to follow ? is it kernel style [1] or something else ?

for me it looks like a former, but maybe I'm missing something

[1]
https://www.kernel.org/doc/html/latest/doc-guide/kernel-doc.html#function-documentation

>>
>>> + * @device: device file descriptor
>>> + *
>>> + * Check if device is PF by checking existence of sriov_totalvfs file
>>> + * and non-zero value read from that file.
>> just to clarify/be precise, do you want to check here "device"
>> capability or "driver" capability ?
>>
>> IIRC the PCI subsystem will set these attributes on the "PF device" even
>> if attached "PF driver" does not provide required hook to enable VFs
>> (and this is main purpose of being a "PF", no?)
> Helper is for checking device capability. If device is not PF test will
> skip, if driver doesn't provide required hook to enable VFstest will fail.

so if device is a PF but driver decides to not support VFs and decrease
sriov_totalvfs back to 0, what would this function tell us ?

>>
>>> + *
>>> + * Returns:
>>> + * True if device is PF, false otherwise.
>>> + */
>>> +bool igt_sriov_is_pf(int device)
>>> +{
>>> +    int sysfs;
>>> +    bool ret;
>>> +    uint32_t totalvfs;
>> nit: we shouldn't specify width if not needed, maybe plain unsigned int
>> will just work ? shame that there are no __igt_sysfs_get_uint()
>>
>>> +
>>> +    sysfs = igt_sysfs_open(device);
>>> +    igt_assert_fd(sysfs);
>>> +
>>> +    ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs",
>>> &totalvfs);
>>> +    close(sysfs);
>>> +
>>> +    if (!ret)
>>> +        return false;
>>> +
>>> +    return totalvfs > 0;
>>> +}
>>> +
>>> +static uint32_t __pf_attr_get_u32(int pf, const char *attr)
>>> +{
>>> +    int sysfs;
>>> +    uint32_t value;
>>> +
>>> +    igt_assert(igt_sriov_is_pf(pf));
>>> +
>>> +    sysfs = igt_sysfs_open(pf);
>>> +    igt_assert_fd(sysfs);
>>> +
>>> +    value = igt_sysfs_get_u32(sysfs, attr);
>>> +    close(sysfs);
>>> +
>>> +    return value;
>>> +}
>>> +
>>> +static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
>>> +{
>>> +    int sysfs;
>>> +    bool ret;
>>> +
>>> +    igt_assert(igt_sriov_is_pf(pf));
>>> +
>>> +    sysfs = igt_sysfs_open(pf);
>>> +    igt_assert_fd(sysfs);
>>> +
>>> +    ret = __igt_sysfs_set_u32(sysfs, attr, value);
>>> +    close(sysfs);
>>> +
>>> +    return ret;
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_get_totalvfs:
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Get maximum number of VFs that can be enabled.
>>> + *
>>> + * Returns:
>>> + * Maximum number of VFs that could be associated with given PF.
>>> + */
>>> +unsigned int igt_sriov_get_total_vfs(int pf)
>>> +{
>>> +    return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_get_numvfs:
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Get number of enabled VFs.
>>> + *
>>> + * Returns:
>>> + * Number of VFs enabled by given PF.
>>> + */
>>> +unsigned int igt_sriov_get_enabled_vfs(int pf)
>>> +{
>>> +    return __pf_attr_get_u32(pf, "device/sriov_numvfs");
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_enable_vfs:
>> Helper for VFs enabling
>>
>>> + * @pf: PF device file descriptor
>>> + * @num_vfs: Number of virtual functions to be enabled
>>> + *
>>> + * Helper for VFs enabling.
>> "This will try to enable VFs by writing @num_vfs to ...
> Done
>>
>>> + *
>>> + * Returns:
>>> + * True on success and false on failure.
>>> + */
>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
>>> +{
>>> +    igt_assert(num_vfs > 0);
>>> +    igt_debug("Enabling %u VFs\n", num_vfs);
>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_disable_vfs:
>> Helper for VFs disabling
>>
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Set 0 in sriov_numvfs file to disable VFs.
>> "This will try to disable already enabled VFs by writing 0 to ...
> Done
>>
>>> + *
>>> + * Returns:
>>> + * True on success and false on failure.
>>> + */
>>> +bool igt_sriov_disable_vfs(int pf)
>>> +{
>>> +    igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));
>> this will trigger unnecessary "read" operation just for debug purposes,
>> while in log you should already see "Enabling N VFs", so we know the N.
> Done
>>
>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_is_driver_autoprobe_enabled:
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Get current driver autoprobe setting.
>> hmm, this is SRIOV driver autoprobe (or VF driver autoprobe for
>> short/clarity)
> Done
>>
>>> + *
>>> + * Returns:
>>> + * True if autoprobe is enabled, false otherwise.
>>> + */
>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf)
>>> +{
>>> +    return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_enable_driver_autoprobe:
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Set driver autoprobe to true.
>>> + *
>>> + * During VFs enabling driver will be bound to VFs.
>> "If successful, then kernel will automatically bind VFs to a compatible
>> driver immediately after they are enabled.
> Done
>>
>>> + *
>>> + * Return:
>>> + * True if setting driver autoprobe succeed, otherwise false.
>>> + */
>>> +bool igt_sriov_enable_driver_autoprobe(int pf)
>>> +{
>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>> true);
>>> +}
>>> +
>>> +/**
>>> + * igt_sriov_disable_driver_autoprobe:
>>> + * @pf: PF device file descriptor
>>> + *
>>> + * Set driver autoprobe to false.
>>> + *
>>> + * During VFs enabling driver won't be bound to VFs.
>>> + *
>>> + * Return:
>>> + * True if setting driver autoprobe succeed, otherwise false.
>>> + */
>>> +bool igt_sriov_disable_driver_autoprobe(int pf)
>>> +{
>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>> false);
>>> +}
>>> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
>>> new file mode 100644
>>> index 000000000..f2c5c44fa
>>> --- /dev/null
>>> +++ b/lib/igt_sriov_device.h
>>> @@ -0,0 +1,20 @@
>>> +/* SPDX-License-Identifier: MIT */
>>> +/*
>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>> + */
>>> +
>>> +#ifndef __IGT_SRIOV_DEVICE_H__
>>> +#define __IGT_SRIOV_DEVICE_H__
>>> +
>>> +#include <stdint.h>
>>> +
>>> +bool igt_sriov_is_pf(int device);
>>> +unsigned int igt_sriov_get_total_vfs(int pf);
>>> +unsigned int igt_sriov_get_enabled_vfs(int pf);
>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
>>> +bool igt_sriov_disable_vfs(int pf);
>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf);
>>> +bool igt_sriov_enable_driver_autoprobe(int pf);
>>> +bool igt_sriov_disable_driver_autoprobe(int pf);
>> nit: I'm wondering if there is any pattern to have:
>>
>> a) void function that has igt_assert() inside
>> b) bool function that has no igt_assert() inside
>>
>> then for writing scenario you just use a) without need to check
>> and use b) only when doing lower level testing and use dedicated checks
> Maybe we could use __ prefix for b), but I don't see a need for such
> split TBH.

instead of repeating the code like:

+	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
+	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
+	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
+	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
+	igt_assert(igt_sriov_disable_vfs(pf_fd));

you will just write:

+	igt_sriov_disable_driver_autoprobe(pf_fd);
+	igt_sriov_enable_vfs(pf_fd, num_vfs);
+	igt_sriov_disable_vfs(pf_fd);

as asserts with required checks will be already inside

>>
>>> +
>>> +#endif /* __IGT_SRIOV_DEVICE_H__ */
>>> diff --git a/lib/meson.build b/lib/meson.build
>>> index a7bccafc3..083baa68a 100644
>>> --- a/lib/meson.build
>>> +++ b/lib/meson.build
>>> @@ -38,6 +38,7 @@ lib_sources = [
>>>       'igt_primes.c',
>>>       'igt_pci.c',
>>>       'igt_rand.c',
>>> +    'igt_sriov_device.c',
>>>       'igt_stats.c',
>>>       'igt_syncobj.c',
>>>       'igt_sysfs.c',

Re: [igt-dev] [PATCH i-g-t 5/8] tests/sriov_basic: add basic tests for enabling SR-IOV VFs

[Michal Wajdeczko]

On 09.11.2023 08:04, Laguna, Lukasz wrote:
> 
> On 11/6/2023 23:46, Michal Wajdeczko wrote:
>>
>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>
>>> Add subtests that validate SR-IOV VFs enabling in two variants: with
>>> autoprobe disabled and enabled.
>>>
>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>> ---
>>>   tests/meson.build   |   1 +
>>>   tests/sriov_basic.c | 126 ++++++++++++++++++++++++++++++++++++++++++++
>>>   2 files changed, 127 insertions(+)
>>>   create mode 100644 tests/sriov_basic.c
>>>
>>> diff --git a/tests/meson.build b/tests/meson.build
>>> index 62721157d..7413d978c 100644
>>> --- a/tests/meson.build
>>> +++ b/tests/meson.build
>>> @@ -71,6 +71,7 @@ test_progs = [
>>>       'panfrost_submit',
>>>       'prime_udl',
>>>       'prime_vgem',
>>> +    'sriov_basic',
>>>       'syncobj_basic',
>>>       'syncobj_eventfd',
>>>       'syncobj_wait',
>>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>>> new file mode 100644
>>> index 000000000..fc0914962
>>> --- /dev/null
>>> +++ b/tests/sriov_basic.c
>>> @@ -0,0 +1,126 @@
>>> +// SPDX-License-Identifier: MIT
>>> +/*
>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>> + */
>>> +
>>> +#include "drmtest.h"
>>> +#include "igt_core.h"
>>> +#include "igt_sriov_device.h"
>>> +
>>> +IGT_TEST_DESCRIPTION("Basic tests for enabling SR-IOV Virtual
>>> Functions");
>>> +
>>> +/**
>>> + * TEST: sriov_basic
>>> + * Category: Software building block
>>> + * Mega feature: SR-IOV
>>> + * Sub-category: VFs enabling
>>> + * Run type: BAT
>>> + * Description: Validate SR-IOV VFs enabling
>>> + */
>>> +
>>> +/**
>>> + * SUBTEST: enable-vfs-autoprobe-off
>>> + * Description:
>>> + *   Verify VFs enabling without probing VF driver
>>> + */
>>> +static void enable_disable_vfs(int pf_fd, unsigned int num_vfs)
>>     "enable-vfs-autoprobe-off"
>> and
>>     "enable_disable_vfs"
>> are different
>> shouldn't they match somehow ?
> Done
>>
>>> +{
>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>>> +
>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>> this seems to duplicate first fixture, do we really need to repeat that
>> over and over ?
> It's not the same. First fixtureis not executed between dynamic subtests.

hmm, I'm not an igt expert, but this seems to be little broken

>>
>>> +    igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
>>> +    igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>> this seems crazy and unrelated to test scope - we are not checking here
>> the behavior of the "driver_autoprobe" attribute, we should just trust
>> that 'disable' above worked since it returned true and we already
>> asserted that
> Done
>>
>>> +    igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>> this should be "expect" type of check, as we still want to disable VFs
> VFs will be disabled in exit fixture. VFs disabling in subtest is needed
> between dynamic subtests.
>>
>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>> maybe assert here that enabled_vfs == num_vfs ?
> Some time ago we've got a sugesstion that we should have seperate test
> for VFs disabling. We can check
>     igt_assert_eq(0, igt_sriov_get_enabled_vfs(pf_fd));
> there,  when implemented.
>>
>>> +}
>>> +
>>> +/**
>>> + * SUBTEST: enable-vfs-autoprobe-on
>>> + * Description:
>>> + *   Verify VFs enabling and auto-probing VF driver
>>> + */
>>> +static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
>> here is even more different
>>
>>     "enable-vfs-autoprobe-on"
>> vs
>>     "probe_disable_vfs"
>>
>> also "probe" here may clash with future test that will "probe" just
>> selected VF
> Done
>>
>>> +{
>>> +    bool err = false;
>>> +
>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>>> +
>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>> ditto
>>
>>> +    igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
>>> +    igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>> ditto
>>
>>> +    igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>> ditto
>>
>>> +    for (int vf_num = 1; vf_num <= num_vfs; ++vf_num) {
>>> +        if (!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num)) {
>>> +            igt_debug("VF%u probe failed\n", vf_num);
>>> +            err = true;
>>> +        }
>>> +    }
>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>> disabling VFs immediately after enabling could be treated as a "stress"
>> test - shouldn't we have some grace period for a "basic" class test ?
> I can add some sleep before VFs disabling. Do you have some specific
> value we should use in mind? 2s?

dunno

but I still doubt that enabling all VFs in autoprobe mode is a good test
for "basic" scenario (the only argument for being 'basic' is that is is
1-liner from test point-of-view, but definitely it is not 'basic' from
the system and driver POV)

in basic tests we should just try enable 1 VF at the time, unload it,
then try with next one

"autoprobe all" shouldn't be "Run type: BAT"

>> stress loop with probe/unload could be different test case
> Yeah, it's in another patch from this series
>>
>>> +    igt_assert(!err);
>>> +}
>>> +
>>> +igt_main
>>> +{
>>> +    int pf_fd;
>>> +    bool autoprobe;
>>> +
>>> +    igt_fixture {
>>> +        pf_fd = drm_open_driver(DRIVER_ANY);
>>> +        igt_require(igt_sriov_is_pf(pf_fd));
>>> +        igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>>> +        autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
>>> +
>>> +        igt_srandom();
>> shouldn't this be part of the main() or something ?
> Probably it could be, but no one has implemented it yet. There are many
> other tests that initializes seed in fixture.

but why follow bad design/pattern ?

>>> +    }
>>> +
>>> +    igt_describe("Verify VFs enabling without probing VF driver");
>>> +    igt_subtest_with_dynamic("enable-vfs-autoprobe-off") {
>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-random") {
>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-all") {
>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +    }
>>> +
>>> +    igt_describe("Verify VFs enabling and auto-probing VF driver");
>>> +    igt_subtest_with_dynamic("enable-vfs-autoprobe-on") {
>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-random") {
>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-all") {
>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +    }
>>> +
>>> +    igt_fixture {
>>> +        igt_sriov_disable_vfs(pf_fd);
>>> +        /* abort to avoid execution of next tests with enabled VFs */
>>> +        igt_abort_on_f(igt_sriov_get_enabled_vfs(pf_fd) > 0, "Failed
>>> to disable VF(s)");
>> can't this be just:
>>
>>     igt_abort_on_f(!igt_sriov_disable_vfs(pf_fd), "");
>>     igt_abort_on_f(!igt_sriov_set_driver_autoprobe(autoprobe), "");
> It's for case when helper e.g. igt_sriov_disable_vfsdoesn't return
> error, but VFs are still enabled.

but do we care here ?

I'm not sure that we should add test code to test other test code, as
then you will just write code and miss what was the original goal of the
test.


>>> +        autoprobe ? igt_sriov_enable_driver_autoprobe(pf_fd) :
>>> +                igt_sriov_disable_driver_autoprobe(pf_fd);
>>> +        igt_abort_on_f(autoprobe !=
>>> igt_sriov_is_driver_autoprobe_enabled(pf_fd),
>>> +                   "Failed to restore sriov_drivers_autoprobe
>>> value\n");
>>> +        close(pf_fd);
>>> +    }
>>> +}

Re: [igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Michal Wajdeczko]

On 09.11.2023 08:06, Laguna, Lukasz wrote:
> 
> On 11/6/2023 23:59, Michal Wajdeczko wrote:
>>
>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>
>>> Test enables VFs in range <1..totalvfs>, bind driver to all of them and
>>> then unbind driver from all of them.
>> commit message seems outdated
> What do you mean? I don't see anything wrong
>>
>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>> ---
>>>   tests/sriov_basic.c | 51 +++++++++++++++++++++++++++++++++++++++++++++
>>>   1 file changed, 51 insertions(+)
>>>
>>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>>> index fc0914962..179731daf 100644
>>> --- a/tests/sriov_basic.c
>>> +++ b/tests/sriov_basic.c
>>> @@ -61,6 +61,38 @@ static void probe_disable_vfs(int pf_fd, unsigned
>>> int num_vfs)
>>>       igt_assert(!err);
>>>   }
>>>   +/**
>>> + * SUBTEST: enable-vfs-bind-all-unbind-all
>>> + * Description:
>>> + *   Verify VFs enabling, binding the driver and then unbinding it
>>> from all of them
>>> + */
>>> +static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int
>>> num_vfs)
>>> +{
>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>> nit: "Testing %u VFs" ?
> Done
>>
>>> +
>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>> duplicates main fixture
> As already answered in different patch - first fixtureis not executed
> between dynamic subtests.
>>
>>> +    igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
>>> +    igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>> why do we need warn/skip here ?
>> can't we just assert that 'disable' worked ?
> Done
>>
>>> +
>>> +    igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));
>> can't we just assert ?
> Done
>>
>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>> why we care here ? if not all are enabled then we fail just later
>> and this is not a test for "enable VFs" that enabled==requested
> Done
>>
>>> +    igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
>>> +    igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>> can't we just warn ?
>> if that we fail to enable then probe below will fail anyway
> Done
>>
>>> +
>>> +    for (int i = 1; i <= num_vfs; i++) {
>>> +        igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>>> +        igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
>>> +        igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>> shouldn't we just "expect" to make sure to call "disable VFs" ?
> VFs will be disabled in exit fixture. VFs disabling in subtest is needed
> between dynamic subtests.

but if test passed, then it should do a proper cleanup

maybe problem is that if something went wrong, your igt_assert() aborts
current test which doesn't have a chance to do proper cleanup ?

or maybe that cleanup should be in some mid-test fixture ?

anyway, just seems broken that we need to duplicate the code/logic every
time

>>
>>> +    }
>>> +
>>> +    for (int i = 1; i <= num_vfs; i++) {
>>> +        igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
>>> +        igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>> do we need to have all VFs loaded ?
>> maybe for BAT test we can just bind/unload one VF at the time ?
> We have such test as well:
> [PATCH i-g-t 8/8] tests/sriov_basic: add more tests for VF driver binding
>     SUBTEST: enable-vfs-bind-unbind-each
>     SUBTEST: bind-unbind-vf

that's good

but the question is still open?
what the benefit of having this test which just open-coded the VF probe
loop that would be otherwise done by the PCI subsystem ?

and again, like autoprobe-on, this doesn't seem good candidate for "BAT"
runs, more like a "STRESS"

>>
>> otherwise it will be almost the same level of stress as in
>> "enable-vfs-autoprobe-on" but with 'manual probe' loop of all VFs
>>
>>> +    }
>>> +
>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>>> +}
>>> +
>>>   igt_main
>>>   {
>>>       int pf_fd;
>>> @@ -113,6 +145,25 @@ igt_main
>>>           }
>>>       }
>>>   +    igt_describe("Verify VFs enabling, binding the driver and then
>>> unbinding it from all of them");
>>> +    igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-random") {
>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>> +            igt_dynamic_f("numvfs-all") {
>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>> +            }
>>> +        }
>>> +    }
>>> +
>>>       igt_fixture {
>>>           igt_sriov_disable_vfs(pf_fd);
>>>           /* abort to avoid execution of next tests with enabled VFs */

Re: [igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Laguna, Lukasz]

On 11/10/2023 20:22, Michal Wajdeczko wrote:
>
> On 09.11.2023 07:55, Laguna, Lukasz wrote:
>> On 11/6/2023 23:07, Michal Wajdeczko wrote:
>>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>>
>>>> Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.
>>>>
>>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>>> ---
>>>>    lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
>>>>    lib/igt_sriov_device.h |  20 +++++
>>>>    lib/meson.build        |   1 +
>>>>    3 files changed, 195 insertions(+)
>>>>    create mode 100644 lib/igt_sriov_device.c
>>>>    create mode 100644 lib/igt_sriov_device.h
>>>>
>>>> diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
>>>> new file mode 100644
>>>> index 000000000..7d53c2045
>>>> --- /dev/null
>>>> +++ b/lib/igt_sriov_device.c
>>>> @@ -0,0 +1,174 @@
>>>> +// SPDX-License-Identifier: MIT
>>>> +/*
>>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>>> + */
>>>> +
>>>> +#include "igt_core.h"
>>>> +#include "igt_sriov_device.h"
>>>> +#include "igt_sysfs.h"
>>>> +
>>>> +/**
>>>> + * igt_sriov_is_pf:
>>> nit: short function description missing, not required anymore?
>> Most of the IGT helpers don't have it and from what I see it's not added
>> for new helpers.
> so will ask in a different way: what documentation rules IGT is trying
> to follow ? is it kernel style [1] or something else ?
>
> for me it looks like a former, but maybe I'm missing something
>
> [1]
> https://www.kernel.org/doc/html/latest/doc-guide/kernel-doc.html#function-documentation
>
>>>> + * @device: device file descriptor
>>>> + *
>>>> + * Check if device is PF by checking existence of sriov_totalvfs file
>>>> + * and non-zero value read from that file.
>>> just to clarify/be precise, do you want to check here "device"
>>> capability or "driver" capability ?
>>>
>>> IIRC the PCI subsystem will set these attributes on the "PF device" even
>>> if attached "PF driver" does not provide required hook to enable VFs
>>> (and this is main purpose of being a "PF", no?)
>> Helper is for checking device capability. If device is not PF test will
>> skip, if driver doesn't provide required hook to enable VFstest will fail.
> so if device is a PF but driver decides to not support VFs and decrease
> sriov_totalvfs back to 0, what would this function tell us ?
If we consider such case then I can rename this helper to 
igt_sriov_vfs_supported() and create separate one igt_sriov_is_pf() that 
only checks if sriov_totalvfs exists. What do you think?
>
>>>> + *
>>>> + * Returns:
>>>> + * True if device is PF, false otherwise.
>>>> + */
>>>> +bool igt_sriov_is_pf(int device)
>>>> +{
>>>> +    int sysfs;
>>>> +    bool ret;
>>>> +    uint32_t totalvfs;
>>> nit: we shouldn't specify width if not needed, maybe plain unsigned int
>>> will just work ? shame that there are no __igt_sysfs_get_uint()
>>>
>>>> +
>>>> +    sysfs = igt_sysfs_open(device);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs",
>>>> &totalvfs);
>>>> +    close(sysfs);
>>>> +
>>>> +    if (!ret)
>>>> +        return false;
>>>> +
>>>> +    return totalvfs > 0;
>>>> +}
>>>> +
>>>> +static uint32_t __pf_attr_get_u32(int pf, const char *attr)
>>>> +{
>>>> +    int sysfs;
>>>> +    uint32_t value;
>>>> +
>>>> +    igt_assert(igt_sriov_is_pf(pf));
>>>> +
>>>> +    sysfs = igt_sysfs_open(pf);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    value = igt_sysfs_get_u32(sysfs, attr);
>>>> +    close(sysfs);
>>>> +
>>>> +    return value;
>>>> +}
>>>> +
>>>> +static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
>>>> +{
>>>> +    int sysfs;
>>>> +    bool ret;
>>>> +
>>>> +    igt_assert(igt_sriov_is_pf(pf));
>>>> +
>>>> +    sysfs = igt_sysfs_open(pf);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    ret = __igt_sysfs_set_u32(sysfs, attr, value);
>>>> +    close(sysfs);
>>>> +
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_get_totalvfs:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get maximum number of VFs that can be enabled.
>>>> + *
>>>> + * Returns:
>>>> + * Maximum number of VFs that could be associated with given PF.
>>>> + */
>>>> +unsigned int igt_sriov_get_total_vfs(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_get_numvfs:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get number of enabled VFs.
>>>> + *
>>>> + * Returns:
>>>> + * Number of VFs enabled by given PF.
>>>> + */
>>>> +unsigned int igt_sriov_get_enabled_vfs(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_numvfs");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_enable_vfs:
>>> Helper for VFs enabling
>>>
>>>> + * @pf: PF device file descriptor
>>>> + * @num_vfs: Number of virtual functions to be enabled
>>>> + *
>>>> + * Helper for VFs enabling.
>>> "This will try to enable VFs by writing @num_vfs to ...
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True on success and false on failure.
>>>> + */
>>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
>>>> +{
>>>> +    igt_assert(num_vfs > 0);
>>>> +    igt_debug("Enabling %u VFs\n", num_vfs);
>>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_disable_vfs:
>>> Helper for VFs disabling
>>>
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set 0 in sriov_numvfs file to disable VFs.
>>> "This will try to disable already enabled VFs by writing 0 to ...
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True on success and false on failure.
>>>> + */
>>>> +bool igt_sriov_disable_vfs(int pf)
>>>> +{
>>>> +    igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));
>>> this will trigger unnecessary "read" operation just for debug purposes,
>>> while in log you should already see "Enabling N VFs", so we know the N.
>> Done
>>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_is_driver_autoprobe_enabled:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get current driver autoprobe setting.
>>> hmm, this is SRIOV driver autoprobe (or VF driver autoprobe for
>>> short/clarity)
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True if autoprobe is enabled, false otherwise.
>>>> + */
>>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_enable_driver_autoprobe:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set driver autoprobe to true.
>>>> + *
>>>> + * During VFs enabling driver will be bound to VFs.
>>> "If successful, then kernel will automatically bind VFs to a compatible
>>> driver immediately after they are enabled.
>> Done
>>>> + *
>>>> + * Return:
>>>> + * True if setting driver autoprobe succeed, otherwise false.
>>>> + */
>>>> +bool igt_sriov_enable_driver_autoprobe(int pf)
>>>> +{
>>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>>> true);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_disable_driver_autoprobe:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set driver autoprobe to false.
>>>> + *
>>>> + * During VFs enabling driver won't be bound to VFs.
>>>> + *
>>>> + * Return:
>>>> + * True if setting driver autoprobe succeed, otherwise false.
>>>> + */
>>>> +bool igt_sriov_disable_driver_autoprobe(int pf)
>>>> +{
>>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>>> false);
>>>> +}
>>>> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
>>>> new file mode 100644
>>>> index 000000000..f2c5c44fa
>>>> --- /dev/null
>>>> +++ b/lib/igt_sriov_device.h
>>>> @@ -0,0 +1,20 @@
>>>> +/* SPDX-License-Identifier: MIT */
>>>> +/*
>>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>>> + */
>>>> +
>>>> +#ifndef __IGT_SRIOV_DEVICE_H__
>>>> +#define __IGT_SRIOV_DEVICE_H__
>>>> +
>>>> +#include <stdint.h>
>>>> +
>>>> +bool igt_sriov_is_pf(int device);
>>>> +unsigned int igt_sriov_get_total_vfs(int pf);
>>>> +unsigned int igt_sriov_get_enabled_vfs(int pf);
>>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
>>>> +bool igt_sriov_disable_vfs(int pf);
>>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf);
>>>> +bool igt_sriov_enable_driver_autoprobe(int pf);
>>>> +bool igt_sriov_disable_driver_autoprobe(int pf);
>>> nit: I'm wondering if there is any pattern to have:
>>>
>>> a) void function that has igt_assert() inside
>>> b) bool function that has no igt_assert() inside
>>>
>>> then for writing scenario you just use a) without need to check
>>> and use b) only when doing lower level testing and use dedicated checks
>> Maybe we could use __ prefix for b), but I don't see a need for such
>> split TBH.
> instead of repeating the code like:
>
> +	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
> +	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
>
> you will just write:
>
> +	igt_sriov_disable_driver_autoprobe(pf_fd);
> +	igt_sriov_enable_vfs(pf_fd, num_vfs);
> +	igt_sriov_disable_vfs(pf_fd);
>
> as asserts with required checks will be already inside
>
>>>> +
>>>> +#endif /* __IGT_SRIOV_DEVICE_H__ */
>>>> diff --git a/lib/meson.build b/lib/meson.build
>>>> index a7bccafc3..083baa68a 100644
>>>> --- a/lib/meson.build
>>>> +++ b/lib/meson.build
>>>> @@ -38,6 +38,7 @@ lib_sources = [
>>>>        'igt_primes.c',
>>>>        'igt_pci.c',
>>>>        'igt_rand.c',
>>>> +    'igt_sriov_device.c',
>>>>        'igt_stats.c',
>>>>        'igt_syncobj.c',
>>>>        'igt_sysfs.c',

[igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Test enables VFs in range <1..totalvfs>, bind driver to all of them and
then unbind driver from all of them.

v2:
 - remove checks that are outside the scope of the test (Michal)
 - change subtest run type (Michal)

Cc: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
---
 tests/sriov_basic.c | 49 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index ce75f4198..866bb88e4 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -60,6 +60,36 @@ static void enable_vfs_autoprobe_on(int pf_fd, unsigned int num_vfs)
 	igt_assert(!err);
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-all-unbind-all
+ * Description:
+ *   Verify VFs enabling, binding the driver and then unbinding it from all of them
+ * Run type: FULL
+ */
+static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Testing %u VFs\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+
+	igt_sriov_disable_driver_autoprobe(pf_fd);
+	igt_sriov_enable_vfs(pf_fd, num_vfs);
+	igt_sriov_enable_driver_autoprobe(pf_fd);
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_sriov_bind_vf_drm_driver(pf_fd, i);
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_sriov_unbind_vf_drm_driver(pf_fd, i);
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_sriov_disable_vfs(pf_fd);
+}
+
 igt_main
 {
 	int pf_fd;
@@ -110,6 +140,25 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0

Re: [igt-dev] [PATCH i-g-t 1/8] lib/igt_sriov_device: add core SR-IOV helpers

[Laguna, Lukasz]

On 11/10/2023 20:22, Michal Wajdeczko wrote:
>
> On 09.11.2023 07:55, Laguna, Lukasz wrote:
>> On 11/6/2023 23:07, Michal Wajdeczko wrote:
>>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>>
>>>> Create lib for core SR-IOV helpers that allow to manage SR-IOV devices.
>>>>
>>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>>> ---
>>>>    lib/igt_sriov_device.c | 174 +++++++++++++++++++++++++++++++++++++++++
>>>>    lib/igt_sriov_device.h |  20 +++++
>>>>    lib/meson.build        |   1 +
>>>>    3 files changed, 195 insertions(+)
>>>>    create mode 100644 lib/igt_sriov_device.c
>>>>    create mode 100644 lib/igt_sriov_device.h
>>>>
>>>> diff --git a/lib/igt_sriov_device.c b/lib/igt_sriov_device.c
>>>> new file mode 100644
>>>> index 000000000..7d53c2045
>>>> --- /dev/null
>>>> +++ b/lib/igt_sriov_device.c
>>>> @@ -0,0 +1,174 @@
>>>> +// SPDX-License-Identifier: MIT
>>>> +/*
>>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>>> + */
>>>> +
>>>> +#include "igt_core.h"
>>>> +#include "igt_sriov_device.h"
>>>> +#include "igt_sysfs.h"
>>>> +
>>>> +/**
>>>> + * igt_sriov_is_pf:
>>> nit: short function description missing, not required anymore?
>> Most of the IGT helpers don't have it and from what I see it's not added
>> for new helpers.
> so will ask in a different way: what documentation rules IGT is trying
> to follow ? is it kernel style [1] or something else ?
>
> for me it looks like a former, but maybe I'm missing something
>
> [1]
> https://www.kernel.org/doc/html/latest/doc-guide/kernel-doc.html#function-documentation
Done
>
>>>> + * @device: device file descriptor
>>>> + *
>>>> + * Check if device is PF by checking existence of sriov_totalvfs file
>>>> + * and non-zero value read from that file.
>>> just to clarify/be precise, do you want to check here "device"
>>> capability or "driver" capability ?
>>>
>>> IIRC the PCI subsystem will set these attributes on the "PF device" even
>>> if attached "PF driver" does not provide required hook to enable VFs
>>> (and this is main purpose of being a "PF", no?)
>> Helper is for checking device capability. If device is not PF test will
>> skip, if driver doesn't provide required hook to enable VFstest will fail.
> so if device is a PF but driver decides to not support VFs and decrease
> sriov_totalvfs back to 0, what would this function tell us ?
Done
>
>>>> + *
>>>> + * Returns:
>>>> + * True if device is PF, false otherwise.
>>>> + */
>>>> +bool igt_sriov_is_pf(int device)
>>>> +{
>>>> +    int sysfs;
>>>> +    bool ret;
>>>> +    uint32_t totalvfs;
>>> nit: we shouldn't specify width if not needed, maybe plain unsigned int
>>> will just work ? shame that there are no __igt_sysfs_get_uint()
>>>
>>>> +
>>>> +    sysfs = igt_sysfs_open(device);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    ret = __igt_sysfs_get_u32(sysfs, "device/sriov_totalvfs",
>>>> &totalvfs);
>>>> +    close(sysfs);
>>>> +
>>>> +    if (!ret)
>>>> +        return false;
>>>> +
>>>> +    return totalvfs > 0;
>>>> +}
>>>> +
>>>> +static uint32_t __pf_attr_get_u32(int pf, const char *attr)
>>>> +{
>>>> +    int sysfs;
>>>> +    uint32_t value;
>>>> +
>>>> +    igt_assert(igt_sriov_is_pf(pf));
>>>> +
>>>> +    sysfs = igt_sysfs_open(pf);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    value = igt_sysfs_get_u32(sysfs, attr);
>>>> +    close(sysfs);
>>>> +
>>>> +    return value;
>>>> +}
>>>> +
>>>> +static bool __pf_attr_set_u32(int pf, const char *attr, uint32_t value)
>>>> +{
>>>> +    int sysfs;
>>>> +    bool ret;
>>>> +
>>>> +    igt_assert(igt_sriov_is_pf(pf));
>>>> +
>>>> +    sysfs = igt_sysfs_open(pf);
>>>> +    igt_assert_fd(sysfs);
>>>> +
>>>> +    ret = __igt_sysfs_set_u32(sysfs, attr, value);
>>>> +    close(sysfs);
>>>> +
>>>> +    return ret;
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_get_totalvfs:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get maximum number of VFs that can be enabled.
>>>> + *
>>>> + * Returns:
>>>> + * Maximum number of VFs that could be associated with given PF.
>>>> + */
>>>> +unsigned int igt_sriov_get_total_vfs(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_totalvfs");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_get_numvfs:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get number of enabled VFs.
>>>> + *
>>>> + * Returns:
>>>> + * Number of VFs enabled by given PF.
>>>> + */
>>>> +unsigned int igt_sriov_get_enabled_vfs(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_numvfs");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_enable_vfs:
>>> Helper for VFs enabling
>>>
>>>> + * @pf: PF device file descriptor
>>>> + * @num_vfs: Number of virtual functions to be enabled
>>>> + *
>>>> + * Helper for VFs enabling.
>>> "This will try to enable VFs by writing @num_vfs to ...
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True on success and false on failure.
>>>> + */
>>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs)
>>>> +{
>>>> +    igt_assert(num_vfs > 0);
>>>> +    igt_debug("Enabling %u VFs\n", num_vfs);
>>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", num_vfs);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_disable_vfs:
>>> Helper for VFs disabling
>>>
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set 0 in sriov_numvfs file to disable VFs.
>>> "This will try to disable already enabled VFs by writing 0 to ...
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True on success and false on failure.
>>>> + */
>>>> +bool igt_sriov_disable_vfs(int pf)
>>>> +{
>>>> +    igt_debug("Disabling %u VFs\n", igt_sriov_get_enabled_vfs(pf));
>>> this will trigger unnecessary "read" operation just for debug purposes,
>>> while in log you should already see "Enabling N VFs", so we know the N.
>> Done
>>>> +    return __pf_attr_set_u32(pf, "device/sriov_numvfs", 0);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_is_driver_autoprobe_enabled:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Get current driver autoprobe setting.
>>> hmm, this is SRIOV driver autoprobe (or VF driver autoprobe for
>>> short/clarity)
>> Done
>>>> + *
>>>> + * Returns:
>>>> + * True if autoprobe is enabled, false otherwise.
>>>> + */
>>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf)
>>>> +{
>>>> +    return __pf_attr_get_u32(pf, "device/sriov_drivers_autoprobe");
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_enable_driver_autoprobe:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set driver autoprobe to true.
>>>> + *
>>>> + * During VFs enabling driver will be bound to VFs.
>>> "If successful, then kernel will automatically bind VFs to a compatible
>>> driver immediately after they are enabled.
>> Done
>>>> + *
>>>> + * Return:
>>>> + * True if setting driver autoprobe succeed, otherwise false.
>>>> + */
>>>> +bool igt_sriov_enable_driver_autoprobe(int pf)
>>>> +{
>>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>>> true);
>>>> +}
>>>> +
>>>> +/**
>>>> + * igt_sriov_disable_driver_autoprobe:
>>>> + * @pf: PF device file descriptor
>>>> + *
>>>> + * Set driver autoprobe to false.
>>>> + *
>>>> + * During VFs enabling driver won't be bound to VFs.
>>>> + *
>>>> + * Return:
>>>> + * True if setting driver autoprobe succeed, otherwise false.
>>>> + */
>>>> +bool igt_sriov_disable_driver_autoprobe(int pf)
>>>> +{
>>>> +    return __pf_attr_set_u32(pf,  "device/sriov_drivers_autoprobe",
>>>> false);
>>>> +}
>>>> diff --git a/lib/igt_sriov_device.h b/lib/igt_sriov_device.h
>>>> new file mode 100644
>>>> index 000000000..f2c5c44fa
>>>> --- /dev/null
>>>> +++ b/lib/igt_sriov_device.h
>>>> @@ -0,0 +1,20 @@
>>>> +/* SPDX-License-Identifier: MIT */
>>>> +/*
>>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>>> + */
>>>> +
>>>> +#ifndef __IGT_SRIOV_DEVICE_H__
>>>> +#define __IGT_SRIOV_DEVICE_H__
>>>> +
>>>> +#include <stdint.h>
>>>> +
>>>> +bool igt_sriov_is_pf(int device);
>>>> +unsigned int igt_sriov_get_total_vfs(int pf);
>>>> +unsigned int igt_sriov_get_enabled_vfs(int pf);
>>>> +bool igt_sriov_enable_vfs(int pf, unsigned int num_vfs);
>>>> +bool igt_sriov_disable_vfs(int pf);
>>>> +bool igt_sriov_is_driver_autoprobe_enabled(int pf);
>>>> +bool igt_sriov_enable_driver_autoprobe(int pf);
>>>> +bool igt_sriov_disable_driver_autoprobe(int pf);
>>> nit: I'm wondering if there is any pattern to have:
>>>
>>> a) void function that has igt_assert() inside
>>> b) bool function that has no igt_assert() inside
>>>
>>> then for writing scenario you just use a) without need to check
>>> and use b) only when doing lower level testing and use dedicated checks
>> Maybe we could use __ prefix for b), but I don't see a need for such
>> split TBH.
> instead of repeating the code like:
>
> +	igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
> +	igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
> +	igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
> +	igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
> +	igt_assert(igt_sriov_disable_vfs(pf_fd));
>
> you will just write:
>
> +	igt_sriov_disable_driver_autoprobe(pf_fd);
> +	igt_sriov_enable_vfs(pf_fd, num_vfs);
> +	igt_sriov_disable_vfs(pf_fd);
>
> as asserts with required checks will be already inside
Done. I added asserts to helpers. Non-asserting helpers can be added to 
librarary when needed.
>
>>>> +
>>>> +#endif /* __IGT_SRIOV_DEVICE_H__ */
>>>> diff --git a/lib/meson.build b/lib/meson.build
>>>> index a7bccafc3..083baa68a 100644
>>>> --- a/lib/meson.build
>>>> +++ b/lib/meson.build
>>>> @@ -38,6 +38,7 @@ lib_sources = [
>>>>        'igt_primes.c',
>>>>        'igt_pci.c',
>>>>        'igt_rand.c',
>>>> +    'igt_sriov_device.c',
>>>>        'igt_stats.c',
>>>>        'igt_syncobj.c',
>>>>        'igt_sysfs.c',

Re: [igt-dev] [PATCH i-g-t 5/8] tests/sriov_basic: add basic tests for enabling SR-IOV VFs

[Laguna, Lukasz]

On 11/10/2023 20:37, Michal Wajdeczko wrote:
>
> On 09.11.2023 08:04, Laguna, Lukasz wrote:
>> On 11/6/2023 23:46, Michal Wajdeczko wrote:
>>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>>
>>>> Add subtests that validate SR-IOV VFs enabling in two variants: with
>>>> autoprobe disabled and enabled.
>>>>
>>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>>> ---
>>>>    tests/meson.build   |   1 +
>>>>    tests/sriov_basic.c | 126 ++++++++++++++++++++++++++++++++++++++++++++
>>>>    2 files changed, 127 insertions(+)
>>>>    create mode 100644 tests/sriov_basic.c
>>>>
>>>> diff --git a/tests/meson.build b/tests/meson.build
>>>> index 62721157d..7413d978c 100644
>>>> --- a/tests/meson.build
>>>> +++ b/tests/meson.build
>>>> @@ -71,6 +71,7 @@ test_progs = [
>>>>        'panfrost_submit',
>>>>        'prime_udl',
>>>>        'prime_vgem',
>>>> +    'sriov_basic',
>>>>        'syncobj_basic',
>>>>        'syncobj_eventfd',
>>>>        'syncobj_wait',
>>>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>>>> new file mode 100644
>>>> index 000000000..fc0914962
>>>> --- /dev/null
>>>> +++ b/tests/sriov_basic.c
>>>> @@ -0,0 +1,126 @@
>>>> +// SPDX-License-Identifier: MIT
>>>> +/*
>>>> + * Copyright(c) 2023 Intel Corporation. All rights reserved.
>>>> + */
>>>> +
>>>> +#include "drmtest.h"
>>>> +#include "igt_core.h"
>>>> +#include "igt_sriov_device.h"
>>>> +
>>>> +IGT_TEST_DESCRIPTION("Basic tests for enabling SR-IOV Virtual
>>>> Functions");
>>>> +
>>>> +/**
>>>> + * TEST: sriov_basic
>>>> + * Category: Software building block
>>>> + * Mega feature: SR-IOV
>>>> + * Sub-category: VFs enabling
>>>> + * Run type: BAT
>>>> + * Description: Validate SR-IOV VFs enabling
>>>> + */
>>>> +
>>>> +/**
>>>> + * SUBTEST: enable-vfs-autoprobe-off
>>>> + * Description:
>>>> + *   Verify VFs enabling without probing VF driver
>>>> + */
>>>> +static void enable_disable_vfs(int pf_fd, unsigned int num_vfs)
>>>      "enable-vfs-autoprobe-off"
>>> and
>>>      "enable_disable_vfs"
>>> are different
>>> shouldn't they match somehow ?
>> Done
>>>> +{
>>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>>>> +
>>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>>> this seems to duplicate first fixture, do we really need to repeat that
>>> over and over ?
>> It's not the same. First fixtureis not executed between dynamic subtests.
> hmm, I'm not an igt expert, but this seems to be little broken
>
>>>> +    igt_assert(igt_sriov_disable_driver_autoprobe(pf_fd));
>>>> +    igt_assert(!igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>>> this seems crazy and unrelated to test scope - we are not checking here
>>> the behavior of the "driver_autoprobe" attribute, we should just trust
>>> that 'disable' above worked since it returned true and we already
>>> asserted that
>> Done
>>>> +    igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>>> this should be "expect" type of check, as we still want to disable VFs
>> VFs will be disabled in exit fixture. VFs disabling in subtest is needed
>> between dynamic subtests.
>>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>>> maybe assert here that enabled_vfs == num_vfs ?
>> Some time ago we've got a sugesstion that we should have seperate test
>> for VFs disabling. We can check
>>      igt_assert_eq(0, igt_sriov_get_enabled_vfs(pf_fd));
>> there,  when implemented.
>>>> +}
>>>> +
>>>> +/**
>>>> + * SUBTEST: enable-vfs-autoprobe-on
>>>> + * Description:
>>>> + *   Verify VFs enabling and auto-probing VF driver
>>>> + */
>>>> +static void probe_disable_vfs(int pf_fd, unsigned int num_vfs)
>>> here is even more different
>>>
>>>      "enable-vfs-autoprobe-on"
>>> vs
>>>      "probe_disable_vfs"
>>>
>>> also "probe" here may clash with future test that will "probe" just
>>> selected VF
>> Done
>>>> +{
>>>> +    bool err = false;
>>>> +
>>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>>>> +
>>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>>> ditto
>>>
>>>> +    igt_assert(igt_sriov_enable_driver_autoprobe(pf_fd));
>>>> +    igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>>> ditto
>>>
>>>> +    igt_assert(igt_sriov_enable_vfs(pf_fd, num_vfs));
>>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>>> ditto
>>>
>>>> +    for (int vf_num = 1; vf_num <= num_vfs; ++vf_num) {
>>>> +        if (!igt_sriov_is_vf_drm_driver_probed(pf_fd, vf_num)) {
>>>> +            igt_debug("VF%u probe failed\n", vf_num);
>>>> +            err = true;
>>>> +        }
>>>> +    }
>>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>>> disabling VFs immediately after enabling could be treated as a "stress"
>>> test - shouldn't we have some grace period for a "basic" class test ?
>> I can add some sleep before VFs disabling. Do you have some specific
>> value we should use in mind? 2s?
> dunno
>
> but I still doubt that enabling all VFs in autoprobe mode is a good test
> for "basic" scenario (the only argument for being 'basic' is that is is
> 1-liner from test point-of-view, but definitely it is not 'basic' from
> the system and driver POV)
>
> in basic tests we should just try enable 1 VF at the time, unload it,
> then try with next one
>
> "autoprobe all" shouldn't be "Run type: BAT"

Done

>
>>> stress loop with probe/unload could be different test case
>> Yeah, it's in another patch from this series
>>>> +    igt_assert(!err);
>>>> +}
>>>> +
>>>> +igt_main
>>>> +{
>>>> +    int pf_fd;
>>>> +    bool autoprobe;
>>>> +
>>>> +    igt_fixture {
>>>> +        pf_fd = drm_open_driver(DRIVER_ANY);
>>>> +        igt_require(igt_sriov_is_pf(pf_fd));
>>>> +        igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>>>> +        autoprobe = igt_sriov_is_driver_autoprobe_enabled(pf_fd);
>>>> +
>>>> +        igt_srandom();
>>> shouldn't this be part of the main() or something ?
>> Probably it could be, but no one has implemented it yet. There are many
>> other tests that initializes seed in fixture.
> but why follow bad design/pattern ?
Ok, I removed seed initialization from the test code. Will move 
igt_srandom to main in seperate series.
>
>>>> +    }
>>>> +
>>>> +    igt_describe("Verify VFs enabling without probing VF driver");
>>>> +    igt_subtest_with_dynamic("enable-vfs-autoprobe-off") {
>>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-random") {
>>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-all") {
>>>> +                enable_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +    }
>>>> +
>>>> +    igt_describe("Verify VFs enabling and auto-probing VF driver");
>>>> +    igt_subtest_with_dynamic("enable-vfs-autoprobe-on") {
>>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-random") {
>>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-all") {
>>>> +                probe_disable_vfs(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +    }
>>>> +
>>>> +    igt_fixture {
>>>> +        igt_sriov_disable_vfs(pf_fd);
>>>> +        /* abort to avoid execution of next tests with enabled VFs */
>>>> +        igt_abort_on_f(igt_sriov_get_enabled_vfs(pf_fd) > 0, "Failed
>>>> to disable VF(s)");
>>> can't this be just:
>>>
>>>      igt_abort_on_f(!igt_sriov_disable_vfs(pf_fd), "");
>>>      igt_abort_on_f(!igt_sriov_set_driver_autoprobe(autoprobe), "");
>> It's for case when helper e.g. igt_sriov_disable_vfsdoesn't return
>> error, but VFs are still enabled.
> but do we care here ?
>
> I'm not sure that we should add test code to test other test code, as
> then you will just write code and miss what was the original goal of the
> test.
Test shouldn't leave the environment in the bad shape, so here we want 
to clean it up.
>
>>>> +        autoprobe ? igt_sriov_enable_driver_autoprobe(pf_fd) :
>>>> +                igt_sriov_disable_driver_autoprobe(pf_fd);
>>>> +        igt_abort_on_f(autoprobe !=
>>>> igt_sriov_is_driver_autoprobe_enabled(pf_fd),
>>>> +                   "Failed to restore sriov_drivers_autoprobe
>>>> value\n");
>>>> +        close(pf_fd);
>>>> +    }
>>>> +}

Re: [igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Laguna, Lukasz]

On 11/10/2023 20:44, Michal Wajdeczko wrote:
>
> On 09.11.2023 08:06, Laguna, Lukasz wrote:
>> On 11/6/2023 23:59, Michal Wajdeczko wrote:
>>> On 06.11.2023 20:59, Lukasz Laguna wrote:
>>>> From: Katarzyna Dec <katarzyna.dec@intel.com>
>>>>
>>>> Test enables VFs in range <1..totalvfs>, bind driver to all of them and
>>>> then unbind driver from all of them.
>>> commit message seems outdated
>> What do you mean? I don't see anything wrong
>>>> Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
>>>> Reviewed-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
>>>> Reviewed-by: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
>>>> ---
>>>>    tests/sriov_basic.c | 51 +++++++++++++++++++++++++++++++++++++++++++++
>>>>    1 file changed, 51 insertions(+)
>>>>
>>>> diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
>>>> index fc0914962..179731daf 100644
>>>> --- a/tests/sriov_basic.c
>>>> +++ b/tests/sriov_basic.c
>>>> @@ -61,6 +61,38 @@ static void probe_disable_vfs(int pf_fd, unsigned
>>>> int num_vfs)
>>>>        igt_assert(!err);
>>>>    }
>>>>    +/**
>>>> + * SUBTEST: enable-vfs-bind-all-unbind-all
>>>> + * Description:
>>>> + *   Verify VFs enabling, binding the driver and then unbinding it
>>>> from all of them
>>>> + */
>>>> +static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int
>>>> num_vfs)
>>>> +{
>>>> +    igt_debug("Using num_vfs=%u\n", num_vfs);
>>> nit: "Testing %u VFs" ?
>> Done
>>>> +
>>>> +    igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
>>> duplicates main fixture
>> As already answered in different patch - first fixtureis not executed
>> between dynamic subtests.
>>>> +    igt_warn_on(!igt_sriov_disable_driver_autoprobe(pf_fd));
>>>> +    igt_skip_on(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>>> why do we need warn/skip here ?
>>> can't we just assert that 'disable' worked ?
>> Done
>>>> +
>>>> +    igt_warn_on(!igt_sriov_enable_vfs(pf_fd, num_vfs));
>>> can't we just assert ?
>> Done
>>>> +    igt_assert_eq(num_vfs, igt_sriov_get_enabled_vfs(pf_fd));
>>> why we care here ? if not all are enabled then we fail just later
>>> and this is not a test for "enable VFs" that enabled==requested
>> Done
>>>> +    igt_warn_on(!igt_sriov_enable_driver_autoprobe(pf_fd));
>>>> +    igt_assert(igt_sriov_is_driver_autoprobe_enabled(pf_fd));
>>> can't we just warn ?
>>> if that we fail to enable then probe below will fail anyway
>> Done
>>>> +
>>>> +    for (int i = 1; i <= num_vfs; i++) {
>>>> +        igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>>>> +        igt_assert(igt_sriov_bind_vf_drm_driver(pf_fd, i));
>>>> +        igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>>> shouldn't we just "expect" to make sure to call "disable VFs" ?
>> VFs will be disabled in exit fixture. VFs disabling in subtest is needed
>> between dynamic subtests.
> but if test passed, then it should do a proper cleanup
>
> maybe problem is that if something went wrong, your igt_assert() aborts
> current test which doesn't have a chance to do proper cleanup ?
>
> or maybe that cleanup should be in some mid-test fixture ?
>
> anyway, just seems broken that we need to duplicate the code/logic every
> time
>
>>>> +    }
>>>> +
>>>> +    for (int i = 1; i <= num_vfs; i++) {
>>>> +        igt_assert(igt_sriov_unbind_vf_drm_driver(pf_fd, i));
>>>> +        igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
>>> do we need to have all VFs loaded ?
>>> maybe for BAT test we can just bind/unload one VF at the time ?
>> We have such test as well:
>> [PATCH i-g-t 8/8] tests/sriov_basic: add more tests for VF driver binding
>>      SUBTEST: enable-vfs-bind-unbind-each
>>      SUBTEST: bind-unbind-vf
> that's good
>
> but the question is still open?
> what the benefit of having this test which just open-coded the VF probe
> loop that would be otherwise done by the PCI subsystem ?
>
> and again, like autoprobe-on, this doesn't seem good candidate for "BAT"
> runs, more like a "STRESS"
Done
>>> otherwise it will be almost the same level of stress as in
>>> "enable-vfs-autoprobe-on" but with 'manual probe' loop of all VFs
>>>
>>>> +    }
>>>> +
>>>> +    igt_assert(igt_sriov_disable_vfs(pf_fd));
>>>> +}
>>>> +
>>>>    igt_main
>>>>    {
>>>>        int pf_fd;
>>>> @@ -113,6 +145,25 @@ igt_main
>>>>            }
>>>>        }
>>>>    +    igt_describe("Verify VFs enabling, binding the driver and then
>>>> unbinding it from all of them");
>>>> +    igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
>>>> +        for_each_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-%u", num_vfs) {
>>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_random_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-random") {
>>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +        for_max_num_vfs(pf_fd, num_vfs) {
>>>> +            igt_dynamic_f("numvfs-all") {
>>>> +                enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
>>>> +            }
>>>> +        }
>>>> +    }
>>>> +
>>>>        igt_fixture {
>>>>            igt_sriov_disable_vfs(pf_fd);
>>>>            /* abort to avoid execution of next tests with enabled VFs */

[igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Test enables VFs in range <1..totalvfs>, bind driver to all of them and
then unbind driver from all of them.

v2:
 - remove checks that are outside the scope of the test (Michal)
 - change subtest run type (Michal)

Cc: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
---
 tests/sriov_basic.c | 49 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index ce75f4198..866bb88e4 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -60,6 +60,36 @@ static void enable_vfs_autoprobe_on(int pf_fd, unsigned int num_vfs)
 	igt_assert(!err);
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-all-unbind-all
+ * Description:
+ *   Verify VFs enabling, binding the driver and then unbinding it from all of them
+ * Run type: FULL
+ */
+static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Testing %u VFs\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+
+	igt_sriov_disable_driver_autoprobe(pf_fd);
+	igt_sriov_enable_vfs(pf_fd, num_vfs);
+	igt_sriov_enable_driver_autoprobe(pf_fd);
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_sriov_bind_vf_drm_driver(pf_fd, i);
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_sriov_unbind_vf_drm_driver(pf_fd, i);
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_sriov_disable_vfs(pf_fd);
+}
+
 igt_main
 {
 	int pf_fd;
@@ -110,6 +140,25 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0

[igt-dev] [PATCH i-g-t 7/8] tests/sriov_basic: validate driver binding to VFs

[Lukasz Laguna]

From: Katarzyna Dec <katarzyna.dec@intel.com>

Test enables VFs in range <1..totalvfs>, bind driver to all of them and
then unbind driver from all of them.

v2:
 - remove checks that are outside the scope of the test (Michal)
 - change subtest run type (Michal)

Cc: Marcin Bernatowicz <marcin.bernatowicz@linux.intel.com>
Cc: Michal Wajdeczko <michal.wajdeczko@intel.com>
Signed-off-by: Katarzyna Dec <katarzyna.dec@intel.com>
Signed-off-by: Lukasz Laguna <lukasz.laguna@intel.com>
---
 tests/sriov_basic.c | 49 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/tests/sriov_basic.c b/tests/sriov_basic.c
index ce75f4198..866bb88e4 100644
--- a/tests/sriov_basic.c
+++ b/tests/sriov_basic.c
@@ -60,6 +60,36 @@ static void enable_vfs_autoprobe_on(int pf_fd, unsigned int num_vfs)
 	igt_assert(!err);
 }
 
+/**
+ * SUBTEST: enable-vfs-bind-all-unbind-all
+ * Description:
+ *   Verify VFs enabling, binding the driver and then unbinding it from all of them
+ * Run type: FULL
+ */
+static void enable_vfs_bind_all_unbind_all(int pf_fd, unsigned int num_vfs)
+{
+	igt_debug("Testing %u VFs\n", num_vfs);
+
+	igt_require(igt_sriov_get_enabled_vfs(pf_fd) == 0);
+
+	igt_sriov_disable_driver_autoprobe(pf_fd);
+	igt_sriov_enable_vfs(pf_fd, num_vfs);
+	igt_sriov_enable_driver_autoprobe(pf_fd);
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+		igt_sriov_bind_vf_drm_driver(pf_fd, i);
+		igt_assert(igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	for (int i = 1; i <= num_vfs; i++) {
+		igt_sriov_unbind_vf_drm_driver(pf_fd, i);
+		igt_assert(!igt_sriov_is_vf_drm_driver_probed(pf_fd, i));
+	}
+
+	igt_sriov_disable_vfs(pf_fd);
+}
+
 igt_main
 {
 	int pf_fd;
@@ -110,6 +140,25 @@ igt_main
 		}
 	}
 
+	igt_describe("Verify VFs enabling, binding the driver and then unbinding it from all of them");
+	igt_subtest_with_dynamic("enable-vfs-bind-all-unbind-all") {
+		for_each_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-%u", num_vfs) {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_random_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-random") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+		for_max_num_vfs(pf_fd, num_vfs) {
+			igt_dynamic_f("numvfs-all") {
+				enable_vfs_bind_all_unbind_all(pf_fd, num_vfs);
+			}
+		}
+	}
+
 	igt_fixture {
 		igt_sriov_disable_vfs(pf_fd);
 		/* abort to avoid execution of next tests with enabled VFs */
-- 
2.40.0