[PATCH v2 0/7] drm/xe/rtp: Miscellaneous improvements to rule matching

[PATCH v2 0/7] drm/xe/rtp: Miscellaneous improvements to rule matching

[Gustavo Sousa]

This series adds several improvements to RTP code around rule matching
logic.

It first starts with making sure there is a cleaner separation of
responsibilities when it comes to the generic kunit testing for RTP.
Then it goes on to improve rule matching code by making the parsing
logic more robust and restructuring the code to resemble a formal
grammar and make it easier to add future extensions.

Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
Changes in v2:
- Incorporated review feedback. See individual patches for the
  changelog.
- Incorporated the addition of the match type XE_RTP_MATCH_PLATFORM_STEP
  after rebasing on latest drm-tip, which is reflected in some of the
  patches.
- Link to v1: https://patch.msgid.link/20260114-rtp-rule-parser-v1-0-fa9029586bff@intel.com

---
Gustavo Sousa (7):
      drm/xe/rtp: Write kunit test cases specific for rule matching
      drm/xe/rtp: Drop rule matching cases from rtp_to_sr_cases and rtp_cases
      drm/xe/rtp: Don't short-circuit to false in or-yes case
      drm/xe/rtp: Do not break parsing when missing context
      drm/xe/rtp: Extract rule_match_item()
      drm/xe/rtp: Fully parse the ruleset
      drm/xe/rtp: Implement a structured parser for rule matching

 drivers/gpu/drm/xe/tests/xe_rtp.c      |  38 ++++
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 327 +++++++++++++++++++++------------
 drivers/gpu/drm/xe/tests/xe_rtp_test.h |  23 +++
 drivers/gpu/drm/xe/xe_rtp.c            | 321 +++++++++++++++++++-------------
 4 files changed, 461 insertions(+), 248 deletions(-)
---
base-commit: f3b0eacc6be937779388c8412909b66717926980
change-id: 20260114-rtp-rule-parser-ac01472acdeb

Best regards,
--  
Gustavo Sousa <gustavo.sousa@intel.com>

[PATCH v2 1/7] drm/xe/rtp: Write kunit test cases specific for rule matching

[Gustavo Sousa]

The kunit test cases for the RTP framework are currently separated into
those that validate xe_rtp_process_to_sr() and those that validate
xe_rtp_process().  In both of them, we also have mixed stuff to validate
rule matching functionality, which should rather be done in a separate
test case group.

Let's create such a group, specific for validating rule matching, and
also add an initial set of cases.  In an upcoming change, we will do a
cleanup of the other groups by migrating those cases intended for rule
matching to this new group.

v2:
  - s/no-yes-or-no-yes/no-yes-or-yes-no/ (Matt)
  - Drop leftover include of <kunit/test.h>.

Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp.c      |  38 +++++++++
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 141 +++++++++++++++++++++++++++++++++
 drivers/gpu/drm/xe/tests/xe_rtp_test.h |  23 ++++++
 drivers/gpu/drm/xe/xe_rtp.c            |  57 +++++++++----
 4 files changed, 242 insertions(+), 17 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp.c b/drivers/gpu/drm/xe/tests/xe_rtp.c
new file mode 100644
index 000000000000..b3a8b75936d1
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp.c
@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: GPL-2.0 AND MIT
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#include "tests/xe_rtp_test.h"
+
+#include <kunit/visibility.h>
+
+/**
+ * xe_rtp_rule_matches - Check if a set of RTP rule set match against the
+ *			 device/GT/hwe
+ * @xe: The xe device
+ * @gt: The GT struct (may be NULL)
+ * @hwe: The hw_engine  (may be NULL)
+ * @rules: The array of rules to match against
+ * @n_rules: Number of items in @rules
+ * @err: Pointer (may be NULL) to set error number.
+ *
+ * This parses the set of rules and check if they match against the passed
+ * parameters.
+ *
+ * If passed, @err is updated with a non-zero negative error number or zero if
+ * no errors were found during the parsing/evaluation of rules.
+ *
+ * Returns true if there is a match and false if there is no match or if an
+ * error was found.
+ */
+bool xe_rtp_rule_matches(const struct xe_device *xe,
+			 struct xe_gt *gt,
+			 struct xe_hw_engine *hwe,
+			 const struct xe_rtp_rule *rules,
+			 unsigned int n_rules,
+			 int *err)
+{
+	return rule_matches_with_err(xe, gt, hwe, rules, n_rules, err);
+}
+EXPORT_SYMBOL_IF_KUNIT(xe_rtp_rule_matches);
diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index e5a0f985a700..7df8f7857c49 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -19,6 +19,7 @@
 #include "xe_pci_test.h"
 #include "xe_reg_sr.h"
 #include "xe_rtp.h"
+#include "xe_rtp_test.h"
 
 #define REGULAR_REG1	XE_REG(1)
 #define REGULAR_REG2	XE_REG(2)
@@ -31,6 +32,14 @@
 #undef XE_REG_MCR
 #define XE_REG_MCR(...)     XE_REG(__VA_ARGS__, .mcr = 1)
 
+struct rtp_rules_test_case {
+	const char *name;
+	bool expected_match;
+	int expected_err;
+	const struct xe_rtp_rule *rules;
+	u8 n_rules;
+};
+
 struct rtp_to_sr_test_case {
 	const char *name;
 	struct xe_reg expected_reg;
@@ -60,6 +69,130 @@ static bool match_no(const struct xe_device *xe, const struct xe_gt *gt,
 	return false;
 }
 
+static const struct rtp_rules_test_case rtp_rules_cases[] = {
+	/*
+	 * Single rules.
+	 *
+	 * TODO: Include other types of rules as well: GRAPHICS_VERSION(),
+	 * MEDIA_VERSION(), etc.
+	 */
+	{
+		.name = "no",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_no)),
+	},
+	{
+		.name = "yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes)),
+	},
+
+	/* Conjunctions with 2 operands. */
+	{
+		.name = "no-and-no",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_no), FUNC(match_no)),
+	},
+	{
+		.name = "no-and-yes",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_no), FUNC(match_yes)),
+	},
+	{
+		.name = "yes-and-no",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_yes), FUNC(match_no)),
+	},
+	{
+		.name = "yes-and-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes)),
+	},
+
+	/* Disjunctions with 2 operands. */
+	{
+		.name = "no-or-no",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_no)),
+	},
+	{
+		.name = "no-or-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_yes)),
+	},
+	{
+		.name = "yes-or-no",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_no)),
+	},
+	{
+		.name = "yes-or-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_yes)),
+	},
+
+	/* Conjunction and disjunctions. */
+	{
+		.name = "no-yes-or-yes-no",
+		.expected_match = false,
+		XE_RTP_RULES(FUNC(match_no), FUNC(match_yes), OR,
+			     FUNC(match_yes), FUNC(match_no)),
+	},
+	{
+		.name = "no-yes-or-yes-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_no), FUNC(match_yes), OR,
+			     FUNC(match_yes), FUNC(match_yes)),
+	},
+	{
+		.name = "yes-yes-or-no-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes), OR,
+			     FUNC(match_no), FUNC(match_yes)),
+	},
+	{
+		.name = "yes-yes-or-yes-yes",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_yes), FUNC(match_yes), OR,
+			     FUNC(match_yes), FUNC(match_yes)),
+	},
+	{
+		.name = "no-no-or-yes-or-no",
+		.expected_match = true,
+		XE_RTP_RULES(FUNC(match_no), FUNC(match_no), OR,
+			     FUNC(match_yes), OR,
+			     FUNC(match_no)),
+	},
+
+	/* Syntax errors. */
+	{
+		.name = "or",
+		.expected_match = false,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(OR),
+	},
+	{
+		.name = "or-anything",
+		.expected_match = false,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(OR, FUNC(match_yes)),
+	},
+};
+
+static void xe_rtp_rules_tests(struct kunit *test)
+{
+	const struct rtp_rules_test_case *param = test->param_value;
+	struct xe_device *xe = test->priv;
+	struct xe_gt *gt = xe_device_get_root_tile(xe)->primary_gt;
+	int err;
+	bool match;
+
+	match = xe_rtp_rule_matches(xe, gt, NULL, param->rules, param->n_rules, &err);
+
+	KUNIT_EXPECT_EQ(test, match, param->expected_match);
+	KUNIT_EXPECT_EQ(test, err, param->expected_err);
+}
+
 static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 	{
 		.name = "coalesce-same-reg",
@@ -489,6 +622,13 @@ static void xe_rtp_process_tests(struct kunit *test)
 	KUNIT_EXPECT_EQ(test, active, param->expected_active);
 }
 
+static void rtp_rules_desc(const struct rtp_rules_test_case *t, char *desc)
+{
+	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
+}
+
+KUNIT_ARRAY_PARAM(rtp_rules, rtp_rules_cases, rtp_rules_desc);
+
 static void rtp_to_sr_desc(const struct rtp_to_sr_test_case *t, char *desc)
 {
 	strscpy(desc, t->name, KUNIT_PARAM_DESC_SIZE);
@@ -534,6 +674,7 @@ static void xe_rtp_test_exit(struct kunit *test)
 }
 
 static struct kunit_case xe_rtp_tests[] = {
+	KUNIT_CASE_PARAM(xe_rtp_rules_tests, rtp_rules_gen_params),
 	KUNIT_CASE_PARAM(xe_rtp_process_to_sr_tests, rtp_to_sr_gen_params),
 	KUNIT_CASE_PARAM(xe_rtp_process_tests, rtp_gen_params),
 	{}
diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.h b/drivers/gpu/drm/xe/tests/xe_rtp_test.h
new file mode 100644
index 000000000000..26becc1e2af0
--- /dev/null
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.h
@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: GPL-2.0 AND MIT */
+/*
+ * Copyright © 2026 Intel Corporation
+ */
+
+#ifndef _XE_RTP_TEST_H_
+#define _XE_RTP_TEST_H_
+
+#include <linux/types.h>
+
+struct xe_device;
+struct xe_gt;
+struct xe_hw_engine;
+struct xe_rtp_rule;
+
+bool xe_rtp_rule_matches(const struct xe_device *xe,
+			 struct xe_gt *gt,
+			 struct xe_hw_engine *hwe,
+			 const struct xe_rtp_rule *rules,
+			 unsigned int n_rules,
+			 int *err);
+
+#endif
diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 1a4dcbbbc176..0e1adf07e4e7 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -30,16 +30,20 @@ static bool has_samedia(const struct xe_device *xe)
 	return xe->info.media_verx100 >= 1300;
 }
 
-static bool rule_matches(const struct xe_device *xe,
-			 struct xe_gt *gt,
-			 struct xe_hw_engine *hwe,
-			 const struct xe_rtp_rule *rules,
-			 unsigned int n_rules)
+static bool rule_matches_with_err(const struct xe_device *xe,
+				  struct xe_gt *gt,
+				  struct xe_hw_engine *hwe,
+				  const struct xe_rtp_rule *rules,
+				  unsigned int n_rules,
+				  int *err)
 {
 	const struct xe_rtp_rule *r;
 	unsigned int i, rcount = 0;
 	bool match;
 
+	if (err)
+		*err = 0;
+
 	for (r = rules, i = 0; i < n_rules; r = &rules[++i]) {
 		switch (r->match_type) {
 		case XE_RTP_MATCH_OR:
@@ -58,21 +62,21 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_PLATFORM_STEP:
 			if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE))
-				return false;
+				goto error;
 
 			match = xe->info.step.platform >= r->step_start &&
 				xe->info.step.platform < r->step_end;
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.graphics_verx100 == r->ver_start &&
 				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION_RANGE:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.graphics_verx100 >= r->ver_start &&
 				xe->info.graphics_verx100 <= r->ver_end &&
@@ -80,13 +84,13 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.graphics_verx100 == r->ver_start;
 			break;
 		case XE_RTP_MATCH_GRAPHICS_STEP:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.step.graphics >= r->step_start &&
 				xe->info.step.graphics < r->step_end &&
@@ -94,14 +98,14 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.media_verx100 == r->ver_start &&
 				(!has_samedia(xe) || xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION_RANGE:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.media_verx100 >= r->ver_start &&
 				xe->info.media_verx100 <= r->ver_end &&
@@ -109,7 +113,7 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_MEDIA_STEP:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.step.media >= r->step_start &&
 				xe->info.step.media < r->step_end &&
@@ -117,7 +121,7 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION_ANY_GT:
 			if (drm_WARN_ON(&xe->drm, !gt))
-				return false;
+				goto error;
 
 			match = xe->info.media_verx100 == r->ver_start;
 			break;
@@ -129,13 +133,13 @@ static bool rule_matches(const struct xe_device *xe,
 			break;
 		case XE_RTP_MATCH_ENGINE_CLASS:
 			if (drm_WARN_ON(&xe->drm, !hwe))
-				return false;
+				goto error;
 
 			match = hwe->class == r->engine_class;
 			break;
 		case XE_RTP_MATCH_NOT_ENGINE_CLASS:
 			if (drm_WARN_ON(&xe->drm, !hwe))
-				return false;
+				goto error;
 
 			match = hwe->class != r->engine_class;
 			break;
@@ -167,9 +171,24 @@ static bool rule_matches(const struct xe_device *xe,
 
 done:
 	if (drm_WARN_ON(&xe->drm, !rcount))
-		return false;
+		goto error;
 
 	return true;
+
+error:
+	if (err)
+		*err = -EINVAL;
+
+	return false;
+}
+
+static bool rule_matches(const struct xe_device *xe,
+			 struct xe_gt *gt,
+			 struct xe_hw_engine *hwe,
+			 const struct xe_rtp_rule *rules,
+			 unsigned int n_rules)
+{
+	return rule_matches_with_err(xe, gt, hwe, rules, n_rules, NULL);
 }
 
 static void rtp_add_sr_entry(const struct xe_rtp_action *action,
@@ -412,3 +431,7 @@ bool xe_rtp_match_has_msix(const struct xe_device *xe,
 {
 	return xe_device_has_msix(xe);
 }
+
+#if IS_ENABLED(CONFIG_DRM_XE_KUNIT_TEST)
+#include "tests/xe_rtp.c"
+#endif

-- 
2.53.0

[PATCH v2 2/7] drm/xe/rtp: Drop rule matching cases from rtp_to_sr_cases and rtp_cases

[Gustavo Sousa]

The kunit test cases for the RTP framework are currently separated into
three groups:

(1) rtp_rules_cases:
    Those to verify rule matching logic.

(2) rtp_to_sr_cases:
    Those to verify generation of save/restore tables from RTP tables.

(3) rtp_cases
    Those to verify processing of RTP tables without save/restore action
    associated, which are used for OOB workarounds.

Today we have some cases in (2) and (3) that are actually meant to
verify rule matching logic.  Now that we have (1), let's cleanup (2)
and (3) so that they become focused on their main objectives.

Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 122 ++-------------------------------
 1 file changed, 6 insertions(+), 116 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index 7df8f7857c49..7dce699991a1 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -234,80 +234,6 @@ static const struct rtp_to_sr_test_case rtp_to_sr_cases[] = {
 			{}
 		},
 	},
-	{
-		.name = "match-or",
-		.expected_reg = REGULAR_REG1,
-		.expected_set_bits = REG_BIT(0) | REG_BIT(1) | REG_BIT(2),
-		.expected_clr_bits = REG_BIT(0) | REG_BIT(1) | REG_BIT(2),
-		.expected_active = BIT(0) | BIT(1) | BIT(2),
-		.expected_count_sr_entries = 1,
-		.entries = (const struct xe_rtp_entry_sr[]) {
-			{ XE_RTP_NAME("first"),
-			  XE_RTP_RULES(FUNC(match_yes), OR, FUNC(match_no)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-			},
-			{ XE_RTP_NAME("middle"),
-			  XE_RTP_RULES(FUNC(match_no), FUNC(match_no), OR,
-				       FUNC(match_yes), OR,
-				       FUNC(match_no)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-			},
-			{ XE_RTP_NAME("last"),
-			  XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_yes)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(2)))
-			},
-			{ XE_RTP_NAME("no-match"),
-			  XE_RTP_RULES(FUNC(match_no), OR, FUNC(match_no)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(3)))
-			},
-			{}
-		},
-	},
-	{
-		.name = "match-or-xfail",
-		.expected_reg = REGULAR_REG1,
-		.expected_count_sr_entries = 0,
-		.entries = (const struct xe_rtp_entry_sr[]) {
-			{ XE_RTP_NAME("leading-or"),
-			  XE_RTP_RULES(OR, FUNC(match_yes)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-			},
-			{ XE_RTP_NAME("trailing-or"),
-			  /*
-			   * First condition is match_no, otherwise the failure
-			   * wouldn't really trigger as RTP stops processing as
-			   * soon as it has a matching set of rules
-			   */
-			  XE_RTP_RULES(FUNC(match_no), OR),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-			},
-			{ XE_RTP_NAME("no-or-or-yes"),
-			  XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_yes)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(2)))
-			},
-			{}
-		},
-	},
-	{
-		.name = "no-match-no-add-multiple-rules",
-		.expected_reg = REGULAR_REG1,
-		.expected_set_bits = REG_BIT(0),
-		.expected_clr_bits = REG_BIT(0),
-		.expected_active = BIT(0),
-		.expected_count_sr_entries = 1,
-		/* Don't coalesce second entry due to one of the rules */
-		.entries = (const struct xe_rtp_entry_sr[]) {
-			{ XE_RTP_NAME("basic-1"),
-			  XE_RTP_RULES(FUNC(match_yes)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(0)))
-			},
-			{ XE_RTP_NAME("basic-2"),
-			  XE_RTP_RULES(FUNC(match_yes), FUNC(match_no)),
-			  XE_RTP_ACTIONS(SET(REGULAR_REG1, REG_BIT(1)))
-			},
-			{}
-		},
-	},
 	{
 		.name = "two-regs-two-entries",
 		.expected_reg = REGULAR_REG1,
@@ -536,33 +462,15 @@ static const struct rtp_test_case rtp_cases[] = {
 		},
 	},
 	{
-		.name = "inactive-1st_or_active-inactive",
+		.name = "inactive-active-inactive",
 		.expected_active = BIT(1),
 		.entries = (const struct xe_rtp_entry[]) {
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{ XE_RTP_NAME("r2_or_conditions"),
-			  XE_RTP_RULES(FUNC(match_yes), OR,
-				       FUNC(match_no), OR,
-				       FUNC(match_no)) },
-			{ XE_RTP_NAME("r3"),
-			  XE_RTP_RULES(FUNC(match_no)),
-			},
-			{}
-		},
-	},
-	{
-		.name = "inactive-2nd_or_active-inactive",
-		.expected_active = BIT(1),
-		.entries = (const struct xe_rtp_entry[]) {
-			{ XE_RTP_NAME("r1"),
-			  XE_RTP_RULES(FUNC(match_no)),
+			{ XE_RTP_NAME("r2"),
+			  XE_RTP_RULES(FUNC(match_yes)),
 			},
-			{ XE_RTP_NAME("r2_or_conditions"),
-			  XE_RTP_RULES(FUNC(match_no), OR,
-				       FUNC(match_yes), OR,
-				       FUNC(match_no)) },
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
@@ -570,33 +478,15 @@ static const struct rtp_test_case rtp_cases[] = {
 		},
 	},
 	{
-		.name = "inactive-last_or_active-inactive",
-		.expected_active = BIT(1),
+		.name = "inactive-inactive-inactive",
+		.expected_active = 0,
 		.entries = (const struct xe_rtp_entry[]) {
 			{ XE_RTP_NAME("r1"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{ XE_RTP_NAME("r2_or_conditions"),
-			  XE_RTP_RULES(FUNC(match_no), OR,
-				       FUNC(match_no), OR,
-				       FUNC(match_yes)) },
-			{ XE_RTP_NAME("r3"),
-			  XE_RTP_RULES(FUNC(match_no)),
-			},
-			{}
-		},
-	},
-	{
-		.name = "inactive-no_or_active-inactive",
-		.expected_active = 0,
-		.entries = (const struct xe_rtp_entry[]) {
-			{ XE_RTP_NAME("r1"),
+			{ XE_RTP_NAME("r2"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},
-			{ XE_RTP_NAME("r2_or_conditions"),
-			  XE_RTP_RULES(FUNC(match_no), OR,
-				       FUNC(match_no), OR,
-				       FUNC(match_no)) },
 			{ XE_RTP_NAME("r3"),
 			  XE_RTP_RULES(FUNC(match_no)),
 			},

-- 
2.53.0

[PATCH v2 3/7] drm/xe/rtp: Don't short-circuit to false in or-yes case

[Gustavo Sousa]

While RTP processing evaluates true on the "yes-or" case (i.e. a
conjunction of rules that evaluate to true followed by an "OR" without
the right hand operand), it does not on the "or-yes" one.

Both cases are considered malformed and could be a result of someone
dropping checks deemed not necessary anymore and forgetting to drop the
superfluous "OR".  Nevertheless, we should aim for consistency, and
having the "or-yes" case also evaluating to true while also causing a
warning seems reasonable.  So let's do that.

The "or-yes" pattern being evaluated to false comes from the fact that
that we unconditionally short-circuit upon finding XE_RTP_MATCH_OR on
the outer loop.  We should only do that if the preceding conjunction of
rules evaluated to true (meaning that rcount must be non-zero) and
continue the evaluation otherwise.

Do that and also add extra test cases to validate the short-circuiting
behavior.

Notice that some of the new test cases have a "FIXME" comment, which
comes from the fact that we are unable to detect syntax errors after the
short-circuit point.  That is going to be fixed in a follow-up change.

Link: https://lore.kernel.org/intel-xe/871pfw4lo9.fsf@intel.com/
Cc: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 42 ++++++++++++++++++++++++++++++++--
 drivers/gpu/drm/xe/xe_rtp.c            | 15 ++++++++----
 2 files changed, 50 insertions(+), 7 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index 7dce699991a1..5e0afde9eab4 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -172,11 +172,49 @@ static const struct rtp_rules_test_case rtp_rules_cases[] = {
 		XE_RTP_RULES(OR),
 	},
 	{
-		.name = "or-anything",
-		.expected_match = false,
+		.name = "or-yes",
+		.expected_match = true,
 		.expected_err = -EINVAL,
 		XE_RTP_RULES(OR, FUNC(match_yes)),
 	},
+	{
+		.name = "or-no",
+		.expected_match = false,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(OR, FUNC(match_no)),
+	},
+	{
+		.name = "yes-or",
+		.expected_match = true,
+		/* FIXME: The parser should raise an error here. */
+		.expected_err = 0,
+		XE_RTP_RULES(FUNC(match_yes), OR),
+	},
+	{
+		.name = "no-or",
+		.expected_match = false,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(FUNC(match_no), OR),
+	},
+	{
+		.name = "no-or-or-yes",
+		.expected_match = true,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_yes)),
+	},
+	{
+		.name = "yes-or-or-no",
+		.expected_match = true,
+		/* FIXME: The parser should raise an error here. */
+		.expected_err = 0,
+		XE_RTP_RULES(FUNC(match_yes), OR, OR, FUNC(match_no)),
+	},
+	{
+		.name = "no-or-or-no",
+		.expected_match = false,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_no)),
+	},
 };
 
 static void xe_rtp_rules_tests(struct kunit *test)
diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 0e1adf07e4e7..299fa4209a26 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -47,12 +47,18 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 	for (r = rules, i = 0; i < n_rules; r = &rules[++i]) {
 		switch (r->match_type) {
 		case XE_RTP_MATCH_OR:
+			if (drm_WARN_ON(&xe->drm, !rcount)) {
+				if (err)
+					*err = -EINVAL;
+				continue;
+			}
+
 			/*
-			 * This is only reached if a complete set of
-			 * rules passed or none were evaluated. For both cases,
-			 * shortcut the other rules and return the proper value.
+			 * This is only reached if a complete conjunction of
+			 * rules passed, in which case we shortcut the other
+			 * rules and return true.
 			 */
-			goto done;
+			return true;
 		case XE_RTP_MATCH_PLATFORM:
 			match = xe->info.platform == r->platform;
 			break;
@@ -169,7 +175,6 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 		}
 	}
 
-done:
 	if (drm_WARN_ON(&xe->drm, !rcount))
 		goto error;
 

-- 
2.53.0

[PATCH v2 4/7] drm/xe/rtp: Do not break parsing when missing context

[Gustavo Sousa]

With the current implementation, the RTP framework will cause parsing of
the rule set to be interrupted if one rule requires a context item (gt
or hwe) that is missing (i.e. when the value is NULL).

This is arguably a semantic error instead of a syntactic one, meaning
that RTP should not interrupt parsing the rules.  With the current
behavior, we would miss detecting other errors that could appear in the
remaining rules and could also prevent valid rules joined by "OR" from
being evaluated.

Make sure that we do not stop parsing the rule set when detecting
missing context and let's add rtp_rules_test_cases to reflect that.

v2:
  - Add "missing-context" in the test case names to indicate that those
    are about rules that are missing the necessary context. (Matt)
  - Rebase: treat the new match type XE_RTP_MATCH_PLATFORM_STEP in the
    same way when the platform is missing step information.

Reviewed-by: Matt Roper <matthew.d.roper@intel.com> # v1
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 28 +++++++++++++++
 drivers/gpu/drm/xe/xe_rtp.c            | 66 ++++++++++++++++++++++------------
 2 files changed, 72 insertions(+), 22 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index 5e0afde9eab4..e009c1243b7c 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -215,6 +215,34 @@ static const struct rtp_rules_test_case rtp_rules_cases[] = {
 		.expected_err = -EINVAL,
 		XE_RTP_RULES(FUNC(match_no), OR, OR, FUNC(match_no)),
 	},
+
+	/* No match because hwe is NULL. */
+	{
+		.name = "missing-context-engine-class",
+		.expected_match = false,
+		XE_RTP_RULES(ENGINE_CLASS(RENDER)),
+	},
+
+	/*
+	 * Missing context (hwe==NULL) does not cause parsing to stop, hence we
+	 * expect a match.
+	 */
+	{
+		.name = "missing-context-engine-class-or-yes",
+		.expected_match = true,
+		XE_RTP_RULES(ENGINE_CLASS(RENDER), OR, FUNC(match_yes)),
+	},
+
+	/*
+	 * Missing context (hwe==NULL) does not cause parsing to stop, hence we
+	 * expect a syntax error.
+	 */
+	{
+		.name = "missing-context-engine-class-or-or-yes",
+		.expected_match = true,
+		.expected_err = -EINVAL,
+		XE_RTP_RULES(ENGINE_CLASS(RENDER), OR, OR, FUNC(match_yes)),
+	},
 };
 
 static void xe_rtp_rules_tests(struct kunit *test)
diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 299fa4209a26..df72b456ab16 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -67,67 +67,85 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 				xe->info.subplatform == r->subplatform;
 			break;
 		case XE_RTP_MATCH_PLATFORM_STEP:
-			if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.step.platform >= r->step_start &&
 				xe->info.step.platform < r->step_end;
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.graphics_verx100 == r->ver_start &&
 				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION_RANGE:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.graphics_verx100 >= r->ver_start &&
 				xe->info.graphics_verx100 <= r->ver_end &&
 				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.graphics_verx100 == r->ver_start;
 			break;
 		case XE_RTP_MATCH_GRAPHICS_STEP:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.step.graphics >= r->step_start &&
 				xe->info.step.graphics < r->step_end &&
 				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.media_verx100 == r->ver_start &&
 				(!has_samedia(xe) || xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION_RANGE:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.media_verx100 >= r->ver_start &&
 				xe->info.media_verx100 <= r->ver_end &&
 				(!has_samedia(xe) || xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_MEDIA_STEP:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.step.media >= r->step_start &&
 				xe->info.step.media < r->step_end &&
 				(!has_samedia(xe) || xe_gt_is_media_type(gt));
 			break;
 		case XE_RTP_MATCH_MEDIA_VERSION_ANY_GT:
-			if (drm_WARN_ON(&xe->drm, !gt))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !gt)) {
+				match = false;
+				break;
+			}
 
 			match = xe->info.media_verx100 == r->ver_start;
 			break;
@@ -138,14 +156,18 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 			match = xe->info.is_dgfx;
 			break;
 		case XE_RTP_MATCH_ENGINE_CLASS:
-			if (drm_WARN_ON(&xe->drm, !hwe))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !hwe)) {
+				match = false;
+				break;
+			}
 
 			match = hwe->class == r->engine_class;
 			break;
 		case XE_RTP_MATCH_NOT_ENGINE_CLASS:
-			if (drm_WARN_ON(&xe->drm, !hwe))
-				goto error;
+			if (drm_WARN_ON(&xe->drm, !hwe)) {
+				match = false;
+				break;
+			}
 
 			match = hwe->class != r->engine_class;
 			break;

-- 
2.53.0

[PATCH v2 5/7] drm/xe/rtp: Extract rule_match_item()

[Gustavo Sousa]

The current logic in rule_matches() mixes individual rule matching
with the logic necessary for handling OR operations.  Let's simplify
rule_matches() to focus on the latter by extracting individual rule
matching into a separate function called rule_match_item().

Reviewed-by: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/xe_rtp.c | 219 +++++++++++++++++++-------------------------
 1 file changed, 94 insertions(+), 125 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index df72b456ab16..c49f80f398af 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -30,6 +30,96 @@ static bool has_samedia(const struct xe_device *xe)
 	return xe->info.media_verx100 >= 1300;
 }
 
+static bool rule_match_item(const struct xe_device *xe,
+			    struct xe_gt *gt,
+			    struct xe_hw_engine *hwe,
+			    const struct xe_rtp_rule *r)
+{
+	switch (r->match_type) {
+	case XE_RTP_MATCH_PLATFORM:
+		return xe->info.platform == r->platform;
+	case XE_RTP_MATCH_SUBPLATFORM:
+		return xe->info.platform == r->platform &&
+			xe->info.subplatform == r->subplatform;
+	case XE_RTP_MATCH_PLATFORM_STEP:
+		if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE))
+			return false;
+
+		return xe->info.step.platform >= r->step_start &&
+			xe->info.step.platform < r->step_end;
+	case XE_RTP_MATCH_GRAPHICS_VERSION:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.graphics_verx100 == r->ver_start &&
+			(!has_samedia(xe) || !xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_GRAPHICS_VERSION_RANGE:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.graphics_verx100 >= r->ver_start &&
+			xe->info.graphics_verx100 <= r->ver_end &&
+			(!has_samedia(xe) || !xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.graphics_verx100 == r->ver_start;
+	case XE_RTP_MATCH_GRAPHICS_STEP:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.step.graphics >= r->step_start &&
+			xe->info.step.graphics < r->step_end &&
+			(!has_samedia(xe) || !xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_MEDIA_VERSION:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.media_verx100 == r->ver_start &&
+			(!has_samedia(xe) || xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_MEDIA_VERSION_RANGE:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.media_verx100 >= r->ver_start &&
+			xe->info.media_verx100 <= r->ver_end &&
+			(!has_samedia(xe) || xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_MEDIA_STEP:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.step.media >= r->step_start &&
+			xe->info.step.media < r->step_end &&
+			(!has_samedia(xe) || xe_gt_is_media_type(gt));
+	case XE_RTP_MATCH_MEDIA_VERSION_ANY_GT:
+		if (drm_WARN_ON(&xe->drm, !gt))
+			return false;
+
+		return xe->info.media_verx100 == r->ver_start;
+	case XE_RTP_MATCH_INTEGRATED:
+		return !xe->info.is_dgfx;
+	case XE_RTP_MATCH_DISCRETE:
+		return xe->info.is_dgfx;
+	case XE_RTP_MATCH_ENGINE_CLASS:
+		if (drm_WARN_ON(&xe->drm, !hwe))
+			return false;
+
+		return hwe->class == r->engine_class;
+	case XE_RTP_MATCH_NOT_ENGINE_CLASS:
+		if (drm_WARN_ON(&xe->drm, !hwe))
+			return false;
+
+		return hwe->class != r->engine_class;
+	case XE_RTP_MATCH_FUNC:
+		return r->match_func(xe, gt, hwe);
+	default:
+		drm_warn(&xe->drm, "Invalid RTP match %u\n",
+			 r->match_type);
+		return false;
+	}
+}
+
 static bool rule_matches_with_err(const struct xe_device *xe,
 				  struct xe_gt *gt,
 				  struct xe_hw_engine *hwe,
@@ -39,14 +129,12 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 {
 	const struct xe_rtp_rule *r;
 	unsigned int i, rcount = 0;
-	bool match;
 
 	if (err)
 		*err = 0;
 
 	for (r = rules, i = 0; i < n_rules; r = &rules[++i]) {
-		switch (r->match_type) {
-		case XE_RTP_MATCH_OR:
+		if (r->match_type == XE_RTP_MATCH_OR) {
 			if (drm_WARN_ON(&xe->drm, !rcount)) {
 				if (err)
 					*err = -EINVAL;
@@ -59,128 +147,11 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 			 * rules and return true.
 			 */
 			return true;
-		case XE_RTP_MATCH_PLATFORM:
-			match = xe->info.platform == r->platform;
-			break;
-		case XE_RTP_MATCH_SUBPLATFORM:
-			match = xe->info.platform == r->platform &&
-				xe->info.subplatform == r->subplatform;
-			break;
-		case XE_RTP_MATCH_PLATFORM_STEP:
-			if (drm_WARN_ON(&xe->drm, xe->info.step.platform == STEP_NONE)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.step.platform >= r->step_start &&
-				xe->info.step.platform < r->step_end;
-			break;
-		case XE_RTP_MATCH_GRAPHICS_VERSION:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.graphics_verx100 == r->ver_start &&
-				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_GRAPHICS_VERSION_RANGE:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.graphics_verx100 >= r->ver_start &&
-				xe->info.graphics_verx100 <= r->ver_end &&
-				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_GRAPHICS_VERSION_ANY_GT:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.graphics_verx100 == r->ver_start;
-			break;
-		case XE_RTP_MATCH_GRAPHICS_STEP:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.step.graphics >= r->step_start &&
-				xe->info.step.graphics < r->step_end &&
-				(!has_samedia(xe) || !xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_MEDIA_VERSION:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.media_verx100 == r->ver_start &&
-				(!has_samedia(xe) || xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_MEDIA_VERSION_RANGE:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.media_verx100 >= r->ver_start &&
-				xe->info.media_verx100 <= r->ver_end &&
-				(!has_samedia(xe) || xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_MEDIA_STEP:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.step.media >= r->step_start &&
-				xe->info.step.media < r->step_end &&
-				(!has_samedia(xe) || xe_gt_is_media_type(gt));
-			break;
-		case XE_RTP_MATCH_MEDIA_VERSION_ANY_GT:
-			if (drm_WARN_ON(&xe->drm, !gt)) {
-				match = false;
-				break;
-			}
-
-			match = xe->info.media_verx100 == r->ver_start;
-			break;
-		case XE_RTP_MATCH_INTEGRATED:
-			match = !xe->info.is_dgfx;
-			break;
-		case XE_RTP_MATCH_DISCRETE:
-			match = xe->info.is_dgfx;
-			break;
-		case XE_RTP_MATCH_ENGINE_CLASS:
-			if (drm_WARN_ON(&xe->drm, !hwe)) {
-				match = false;
-				break;
-			}
-
-			match = hwe->class == r->engine_class;
-			break;
-		case XE_RTP_MATCH_NOT_ENGINE_CLASS:
-			if (drm_WARN_ON(&xe->drm, !hwe)) {
-				match = false;
-				break;
-			}
-
-			match = hwe->class != r->engine_class;
-			break;
-		case XE_RTP_MATCH_FUNC:
-			match = r->match_func(xe, gt, hwe);
-			break;
-		default:
-			drm_warn(&xe->drm, "Invalid RTP match %u\n",
-				 r->match_type);
-			match = false;
 		}
 
-		if (!match) {
+		if (rule_match_item(xe, gt, hwe, r)) {
+			rcount++;
+		} else {
 			/*
 			 * Advance rules until we find XE_RTP_MATCH_OR to check
 			 * if there's another set of conditions to check
@@ -192,8 +163,6 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 				return false;
 
 			rcount = 0;
-		} else {
-			rcount++;
 		}
 	}
 

-- 
2.53.0

[PATCH v2 6/7] drm/xe/rtp: Fully parse the ruleset

[Gustavo Sousa]

The function rule_matches() short-circuits evaluation of the implicit
conjunctions (each substring of rules not containing OR) and the
explicit disjunctions (implicit conjunctions joined by OR). In other
words:

  - in a conjunction, once a rule evaluate to false, we skip to the next
    OR (if any) to evaluate the next conjunction;
  - in a disjunction, once a conjunction evaluates to true, we return
    true and skip evaluating all the remaining rules.

While this behavior results in a correct logical value, due to how the
"OR" short-circuiting is implemented, it has the side-effect that rule
set does not get fully "parsed", allowing incomplete constructs like
(rule1, OR) to evaluate to true when rule1 is true.  We should treat
such constructs as invalid and treat them the same way we do for stuff
like (OR, rule1).

As such, update rule_matches() to "parse" the whole rule set, and that
while keeping the short-circuit aspect of evaluation.  With that, we can
fix the FIXME test cases that cover that behavior.

v2:
  - Do not change short-circuit *evaluation* behavior. (Matt)

Cc: Matt Roper <matthew.d.roper@intel.com>
Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c |  6 ++----
 drivers/gpu/drm/xe/xe_rtp.c            | 26 +++++++++++++-------------
 2 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/drivers/gpu/drm/xe/tests/xe_rtp_test.c b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
index e009c1243b7c..3429c5d1b5b6 100644
--- a/drivers/gpu/drm/xe/tests/xe_rtp_test.c
+++ b/drivers/gpu/drm/xe/tests/xe_rtp_test.c
@@ -186,8 +186,7 @@ static const struct rtp_rules_test_case rtp_rules_cases[] = {
 	{
 		.name = "yes-or",
 		.expected_match = true,
-		/* FIXME: The parser should raise an error here. */
-		.expected_err = 0,
+		.expected_err = -EINVAL,
 		XE_RTP_RULES(FUNC(match_yes), OR),
 	},
 	{
@@ -205,8 +204,7 @@ static const struct rtp_rules_test_case rtp_rules_cases[] = {
 	{
 		.name = "yes-or-or-no",
 		.expected_match = true,
-		/* FIXME: The parser should raise an error here. */
-		.expected_err = 0,
+		.expected_err = -EINVAL,
 		XE_RTP_RULES(FUNC(match_yes), OR, OR, FUNC(match_no)),
 	},
 	{
diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index c49f80f398af..976a2e1f5592 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -129,6 +129,7 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 {
 	const struct xe_rtp_rule *r;
 	unsigned int i, rcount = 0;
+	bool short_circuit_or = false;
 
 	if (err)
 		*err = 0;
@@ -143,13 +144,16 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 
 			/*
 			 * This is only reached if a complete conjunction of
-			 * rules passed, in which case we shortcut the other
-			 * rules and return true.
+			 * rules passed, in which case we short-circuit rule
+			 * evaluation, but still keep parsing to find any syntax
+			 * errors.
 			 */
-			return true;
+			short_circuit_or = true;
+			rcount = 0;
+			continue;
 		}
 
-		if (rule_match_item(xe, gt, hwe, r)) {
+		if (short_circuit_or || rule_match_item(xe, gt, hwe, r)) {
 			rcount++;
 		} else {
 			/*
@@ -166,16 +170,12 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 		}
 	}
 
-	if (drm_WARN_ON(&xe->drm, !rcount))
-		goto error;
-
-	return true;
-
-error:
-	if (err)
-		*err = -EINVAL;
+	if (drm_WARN_ON(&xe->drm, !rcount)) {
+		if (err)
+			*err = -EINVAL;
+	}
 
-	return false;
+	return short_circuit_or || rcount;
 }
 
 static bool rule_matches(const struct xe_device *xe,

-- 
2.53.0

[PATCH v2 7/7] drm/xe/rtp: Implement a structured parser for rule matching

[Gustavo Sousa]

The current unwritten grammar for RTP rules is as follows:

          rules = disjunction;
    disjunction = conjunction { "OR" conjunction };
    conjunction = single_rule { single_rule }
                              /* AND operator is implicit */;
    single_rule = ? GRAPHICS_VERSION(...), MEDIA_VERSION(...),
                     FUNC(...), etc ?;

While rule_matches() currently works for the grammar above, it doesn't
easily resemble it.  Let's replace it with an implementation that is
structured in a way to resemble the grammar.

Such a new implementation, although a bit more verbose, is arguably
easier to reason about and to adapt to any extension we do to the
grammer in the future.

Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)

diff --git a/drivers/gpu/drm/xe/xe_rtp.c b/drivers/gpu/drm/xe/xe_rtp.c
index 976a2e1f5592..dec9d94e6fb0 100644
--- a/drivers/gpu/drm/xe/xe_rtp.c
+++ b/drivers/gpu/drm/xe/xe_rtp.c
@@ -30,11 +30,28 @@ static bool has_samedia(const struct xe_device *xe)
 	return xe->info.media_verx100 >= 1300;
 }
 
-static bool rule_match_item(const struct xe_device *xe,
-			    struct xe_gt *gt,
-			    struct xe_hw_engine *hwe,
-			    const struct xe_rtp_rule *r)
+struct rule_match_ctx {
+	const struct xe_device *xe;
+	struct xe_gt *gt;
+	struct xe_hw_engine *hwe;
+	const struct xe_rtp_rule *rules;
+	const unsigned int n_rules;
+	unsigned int head;
+	int err;
+};
+
+static bool rule_is_item(const struct xe_rtp_rule *r)
+{
+	return r->match_type != XE_RTP_MATCH_OR;
+}
+
+static bool rule_match_item(struct rule_match_ctx *match_ctx)
 {
+	const struct xe_device *xe = match_ctx->xe;
+	struct xe_gt *gt = match_ctx->gt;
+	struct xe_hw_engine *hwe = match_ctx->hwe;
+	const struct xe_rtp_rule *r = &match_ctx->rules[match_ctx->head];
+
 	switch (r->match_type) {
 	case XE_RTP_MATCH_PLATFORM:
 		return xe->info.platform == r->platform;
@@ -120,6 +137,63 @@ static bool rule_match_item(const struct xe_device *xe,
 	}
 }
 
+/*
+ * Match a conjunctive set of rules (rules joined by an implicit "AND").
+ *
+ * Once one item evaluates to false, the remaining items are not evaluated
+ * anymore.  Nevetheless, all rules are consumed to allow detecting syntax
+ * errors.
+ */
+static bool rule_match_and(struct rule_match_ctx *match_ctx, bool parse_only)
+{
+	bool match = true;
+	unsigned int count = 0;
+
+	while (match_ctx->head < match_ctx->n_rules &&
+	       rule_is_item(&match_ctx->rules[match_ctx->head])) {
+		if (!parse_only)
+			match = rule_match_item(match_ctx);
+
+		if (!match)
+			parse_only = true;
+
+		match_ctx->head++;
+		count++;
+	}
+
+	if (drm_WARN_ON(&match_ctx->xe->drm, !count)) {
+		match_ctx->err = -EINVAL;
+
+		if (!parse_only)
+			match = false;
+	}
+
+	return match;
+}
+
+/*
+ * Match a disjunctive set of rules (subset of rules joined by
+ * "XE_RTP_MATCH_OR").
+ *
+ * Once one subset evaluates to true, the remaining items are not evaluated
+ * anymore. Nevetheless, all rules are consumed to allow detecting syntax
+ * errors.
+ */
+static bool rule_match_or(struct rule_match_ctx *match_ctx)
+{
+	bool match = rule_match_and(match_ctx, false);
+
+	while (match_ctx->head < match_ctx->n_rules &&
+	       match_ctx->rules[match_ctx->head].match_type == XE_RTP_MATCH_OR) {
+		/* Consume XE_RTP_MATCH_OR. */
+		match_ctx->head++;
+
+		match = rule_match_and(match_ctx, match);
+	}
+
+	return match;
+}
+
 static bool rule_matches_with_err(const struct xe_device *xe,
 				  struct xe_gt *gt,
 				  struct xe_hw_engine *hwe,
@@ -127,55 +201,19 @@ static bool rule_matches_with_err(const struct xe_device *xe,
 				  unsigned int n_rules,
 				  int *err)
 {
-	const struct xe_rtp_rule *r;
-	unsigned int i, rcount = 0;
-	bool short_circuit_or = false;
+	struct rule_match_ctx match_ctx = {
+		.xe = xe,
+		.gt = gt,
+		.hwe = hwe,
+		.rules = rules,
+		.n_rules = n_rules,
+	};
+	bool match = rule_match_or(&match_ctx);
 
 	if (err)
-		*err = 0;
-
-	for (r = rules, i = 0; i < n_rules; r = &rules[++i]) {
-		if (r->match_type == XE_RTP_MATCH_OR) {
-			if (drm_WARN_ON(&xe->drm, !rcount)) {
-				if (err)
-					*err = -EINVAL;
-				continue;
-			}
-
-			/*
-			 * This is only reached if a complete conjunction of
-			 * rules passed, in which case we short-circuit rule
-			 * evaluation, but still keep parsing to find any syntax
-			 * errors.
-			 */
-			short_circuit_or = true;
-			rcount = 0;
-			continue;
-		}
-
-		if (short_circuit_or || rule_match_item(xe, gt, hwe, r)) {
-			rcount++;
-		} else {
-			/*
-			 * Advance rules until we find XE_RTP_MATCH_OR to check
-			 * if there's another set of conditions to check
-			 */
-			while (++i < n_rules && rules[i].match_type != XE_RTP_MATCH_OR)
-				;
-
-			if (i >= n_rules)
-				return false;
-
-			rcount = 0;
-		}
-	}
-
-	if (drm_WARN_ON(&xe->drm, !rcount)) {
-		if (err)
-			*err = -EINVAL;
-	}
+		*err = match_ctx.err;
 
-	return short_circuit_or || rcount;
+	return match;
 }
 
 static bool rule_matches(const struct xe_device *xe,

-- 
2.53.0

✗ CI.checkpatch: warning for drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)

[Patchwork]

== Series Details ==

Series: drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)
URL   : https://patchwork.freedesktop.org/series/160111/
State : warning

== Summary ==

+ KERNEL=/kernel
+ git clone https://gitlab.freedesktop.org/drm/maintainer-tools mt
Cloning into 'mt'...
warning: redirecting to https://gitlab.freedesktop.org/drm/maintainer-tools.git/
+ git -C mt rev-list -n1 origin/master
c8c12e558adaef7a4d125d83b6e1f8824bc13b82
+ cd /kernel
+ git config --global --add safe.directory /kernel
+ git log -n1
commit 13cc1b21faaa3125e44ce269a527ee8bbe0857c5
Author: Gustavo Sousa <gustavo.sousa@intel.com>
Date:   Thu Apr 30 17:20:08 2026 -0300

    drm/xe/rtp: Implement a structured parser for rule matching
    
    The current unwritten grammar for RTP rules is as follows:
    
              rules = disjunction;
        disjunction = conjunction { "OR" conjunction };
        conjunction = single_rule { single_rule }
                                  /* AND operator is implicit */;
        single_rule = ? GRAPHICS_VERSION(...), MEDIA_VERSION(...),
                         FUNC(...), etc ?;
    
    While rule_matches() currently works for the grammar above, it doesn't
    easily resemble it.  Let's replace it with an implementation that is
    structured in a way to resemble the grammar.
    
    Such a new implementation, although a bit more verbose, is arguably
    easier to reason about and to adapt to any extension we do to the
    grammer in the future.
    
    Signed-off-by: Gustavo Sousa <gustavo.sousa@intel.com>
+ /mt/dim checkpatch 6472756e8384e3945f12b6726dd9dc1ac12f3bb4 drm-intel
cb48f6472499 drm/xe/rtp: Write kunit test cases specific for rule matching
-:25: WARNING:FILE_PATH_CHANGES: added, moved or deleted file(s), does MAINTAINERS need updating?
#25: 
new file mode 100644

total: 0 errors, 1 warnings, 0 checks, 375 lines checked
4ee58c896b2c drm/xe/rtp: Drop rule matching cases from rtp_to_sr_cases and rtp_cases
92c7ed729a91 drm/xe/rtp: Don't short-circuit to false in or-yes case
98e7bebf82e4 drm/xe/rtp: Do not break parsing when missing context
d0834eae65c7 drm/xe/rtp: Extract rule_match_item()
65a8e6a31912 drm/xe/rtp: Fully parse the ruleset
13cc1b21faaa drm/xe/rtp: Implement a structured parser for rule matching

✓ CI.KUnit: success for drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)

[Patchwork]

== Series Details ==

Series: drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)
URL   : https://patchwork.freedesktop.org/series/160111/
State : success

== Summary ==

+ trap cleanup EXIT
+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/xe/.kunitconfig
[21:02:23] Configuring KUnit Kernel ...
Generating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:02:27] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[21:02:58] Starting KUnit Kernel (1/1)...
[21:02:58] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:02:59] ================== guc_buf (11 subtests) ===================
[21:02:59] [PASSED] test_smallest
[21:02:59] [PASSED] test_largest
[21:02:59] [PASSED] test_granular
[21:02:59] [PASSED] test_unique
[21:02:59] [PASSED] test_overlap
[21:02:59] [PASSED] test_reusable
[21:02:59] [PASSED] test_too_big
[21:02:59] [PASSED] test_flush
[21:02:59] [PASSED] test_lookup
[21:02:59] [PASSED] test_data
[21:02:59] [PASSED] test_class
[21:02:59] ===================== [PASSED] guc_buf =====================
[21:02:59] =================== guc_dbm (7 subtests) ===================
[21:02:59] [PASSED] test_empty
[21:02:59] [PASSED] test_default
[21:02:59] ======================== test_size  ========================
[21:02:59] [PASSED] 4
[21:02:59] [PASSED] 8
[21:02:59] [PASSED] 32
[21:02:59] [PASSED] 256
[21:02:59] ==================== [PASSED] test_size ====================
[21:02:59] ======================= test_reuse  ========================
[21:02:59] [PASSED] 4
[21:02:59] [PASSED] 8
[21:02:59] [PASSED] 32
[21:02:59] [PASSED] 256
[21:02:59] =================== [PASSED] test_reuse ====================
[21:02:59] =================== test_range_overlap  ====================
[21:02:59] [PASSED] 4
[21:02:59] [PASSED] 8
[21:02:59] [PASSED] 32
[21:02:59] [PASSED] 256
[21:02:59] =============== [PASSED] test_range_overlap ================
[21:02:59] =================== test_range_compact  ====================
[21:02:59] [PASSED] 4
[21:02:59] [PASSED] 8
[21:02:59] [PASSED] 32
[21:02:59] [PASSED] 256
[21:02:59] =============== [PASSED] test_range_compact ================
[21:02:59] ==================== test_range_spare  =====================
[21:02:59] [PASSED] 4
[21:02:59] [PASSED] 8
[21:02:59] [PASSED] 32
[21:02:59] [PASSED] 256
[21:02:59] ================ [PASSED] test_range_spare =================
[21:02:59] ===================== [PASSED] guc_dbm =====================
[21:02:59] =================== guc_idm (6 subtests) ===================
[21:02:59] [PASSED] bad_init
[21:02:59] [PASSED] no_init
[21:02:59] [PASSED] init_fini
[21:02:59] [PASSED] check_used
[21:02:59] [PASSED] check_quota
[21:02:59] [PASSED] check_all
[21:02:59] ===================== [PASSED] guc_idm =====================
[21:02:59] ================== no_relay (3 subtests) ===================
[21:02:59] [PASSED] xe_drops_guc2pf_if_not_ready
[21:02:59] [PASSED] xe_drops_guc2vf_if_not_ready
[21:02:59] [PASSED] xe_rejects_send_if_not_ready
[21:02:59] ==================== [PASSED] no_relay =====================
[21:02:59] ================== pf_relay (14 subtests) ==================
[21:02:59] [PASSED] pf_rejects_guc2pf_too_short
[21:02:59] [PASSED] pf_rejects_guc2pf_too_long
[21:02:59] [PASSED] pf_rejects_guc2pf_no_payload
[21:02:59] [PASSED] pf_fails_no_payload
[21:02:59] [PASSED] pf_fails_bad_origin
[21:02:59] [PASSED] pf_fails_bad_type
[21:02:59] [PASSED] pf_txn_reports_error
[21:02:59] [PASSED] pf_txn_sends_pf2guc
[21:02:59] [PASSED] pf_sends_pf2guc
[21:02:59] [SKIPPED] pf_loopback_nop
[21:02:59] [SKIPPED] pf_loopback_echo
[21:02:59] [SKIPPED] pf_loopback_fail
[21:02:59] [SKIPPED] pf_loopback_busy
[21:02:59] [SKIPPED] pf_loopback_retry
[21:02:59] ==================== [PASSED] pf_relay =====================
[21:02:59] ================== vf_relay (3 subtests) ===================
[21:02:59] [PASSED] vf_rejects_guc2vf_too_short
[21:02:59] [PASSED] vf_rejects_guc2vf_too_long
[21:02:59] [PASSED] vf_rejects_guc2vf_no_payload
[21:02:59] ==================== [PASSED] vf_relay =====================
[21:02:59] ================ pf_gt_config (9 subtests) =================
[21:02:59] [PASSED] fair_contexts_1vf
[21:02:59] [PASSED] fair_doorbells_1vf
[21:02:59] [PASSED] fair_ggtt_1vf
[21:02:59] ====================== fair_vram_1vf  ======================
[21:02:59] [PASSED] 3.50 GiB
[21:02:59] [PASSED] 11.5 GiB
[21:02:59] [PASSED] 15.5 GiB
[21:02:59] [PASSED] 31.5 GiB
[21:02:59] [PASSED] 63.5 GiB
[21:02:59] [PASSED] 1.91 GiB
[21:02:59] ================== [PASSED] fair_vram_1vf ==================
[21:02:59] ================ fair_vram_1vf_admin_only  =================
[21:02:59] [PASSED] 3.50 GiB
[21:02:59] [PASSED] 11.5 GiB
[21:02:59] [PASSED] 15.5 GiB
[21:02:59] [PASSED] 31.5 GiB
[21:02:59] [PASSED] 63.5 GiB
[21:02:59] [PASSED] 1.91 GiB
[21:02:59] ============ [PASSED] fair_vram_1vf_admin_only =============
[21:02:59] ====================== fair_contexts  ======================
[21:02:59] [PASSED] 1 VF
[21:02:59] [PASSED] 2 VFs
[21:02:59] [PASSED] 3 VFs
[21:02:59] [PASSED] 4 VFs
[21:02:59] [PASSED] 5 VFs
[21:02:59] [PASSED] 6 VFs
[21:02:59] [PASSED] 7 VFs
[21:02:59] [PASSED] 8 VFs
[21:02:59] [PASSED] 9 VFs
[21:02:59] [PASSED] 10 VFs
[21:02:59] [PASSED] 11 VFs
[21:02:59] [PASSED] 12 VFs
[21:02:59] [PASSED] 13 VFs
[21:02:59] [PASSED] 14 VFs
[21:02:59] [PASSED] 15 VFs
[21:02:59] [PASSED] 16 VFs
[21:02:59] [PASSED] 17 VFs
[21:02:59] [PASSED] 18 VFs
[21:02:59] [PASSED] 19 VFs
[21:02:59] [PASSED] 20 VFs
[21:02:59] [PASSED] 21 VFs
[21:02:59] [PASSED] 22 VFs
[21:02:59] [PASSED] 23 VFs
[21:02:59] [PASSED] 24 VFs
[21:02:59] [PASSED] 25 VFs
[21:02:59] [PASSED] 26 VFs
[21:02:59] [PASSED] 27 VFs
[21:02:59] [PASSED] 28 VFs
[21:02:59] [PASSED] 29 VFs
[21:02:59] [PASSED] 30 VFs
[21:02:59] [PASSED] 31 VFs
[21:02:59] [PASSED] 32 VFs
[21:02:59] [PASSED] 33 VFs
[21:02:59] [PASSED] 34 VFs
[21:02:59] [PASSED] 35 VFs
[21:02:59] [PASSED] 36 VFs
[21:02:59] [PASSED] 37 VFs
[21:02:59] [PASSED] 38 VFs
[21:02:59] [PASSED] 39 VFs
[21:02:59] [PASSED] 40 VFs
[21:02:59] [PASSED] 41 VFs
[21:02:59] [PASSED] 42 VFs
[21:02:59] [PASSED] 43 VFs
[21:02:59] [PASSED] 44 VFs
[21:02:59] [PASSED] 45 VFs
[21:02:59] [PASSED] 46 VFs
[21:02:59] [PASSED] 47 VFs
[21:02:59] [PASSED] 48 VFs
[21:02:59] [PASSED] 49 VFs
[21:02:59] [PASSED] 50 VFs
[21:02:59] [PASSED] 51 VFs
[21:02:59] [PASSED] 52 VFs
[21:02:59] [PASSED] 53 VFs
[21:02:59] [PASSED] 54 VFs
[21:02:59] [PASSED] 55 VFs
[21:02:59] [PASSED] 56 VFs
[21:02:59] [PASSED] 57 VFs
[21:02:59] [PASSED] 58 VFs
[21:02:59] [PASSED] 59 VFs
[21:02:59] [PASSED] 60 VFs
[21:02:59] [PASSED] 61 VFs
[21:02:59] [PASSED] 62 VFs
[21:02:59] [PASSED] 63 VFs
[21:02:59] ================== [PASSED] fair_contexts ==================
[21:02:59] ===================== fair_doorbells  ======================
[21:02:59] [PASSED] 1 VF
[21:02:59] [PASSED] 2 VFs
[21:02:59] [PASSED] 3 VFs
[21:02:59] [PASSED] 4 VFs
[21:02:59] [PASSED] 5 VFs
[21:02:59] [PASSED] 6 VFs
[21:02:59] [PASSED] 7 VFs
[21:02:59] [PASSED] 8 VFs
[21:02:59] [PASSED] 9 VFs
[21:02:59] [PASSED] 10 VFs
[21:02:59] [PASSED] 11 VFs
[21:02:59] [PASSED] 12 VFs
[21:02:59] [PASSED] 13 VFs
[21:02:59] [PASSED] 14 VFs
[21:02:59] [PASSED] 15 VFs
[21:02:59] [PASSED] 16 VFs
[21:02:59] [PASSED] 17 VFs
[21:02:59] [PASSED] 18 VFs
[21:02:59] [PASSED] 19 VFs
[21:02:59] [PASSED] 20 VFs
[21:02:59] [PASSED] 21 VFs
[21:02:59] [PASSED] 22 VFs
[21:02:59] [PASSED] 23 VFs
[21:02:59] [PASSED] 24 VFs
[21:02:59] [PASSED] 25 VFs
[21:02:59] [PASSED] 26 VFs
[21:02:59] [PASSED] 27 VFs
[21:02:59] [PASSED] 28 VFs
[21:02:59] [PASSED] 29 VFs
[21:02:59] [PASSED] 30 VFs
[21:02:59] [PASSED] 31 VFs
[21:02:59] [PASSED] 32 VFs
[21:02:59] [PASSED] 33 VFs
[21:02:59] [PASSED] 34 VFs
[21:02:59] [PASSED] 35 VFs
[21:02:59] [PASSED] 36 VFs
[21:02:59] [PASSED] 37 VFs
[21:02:59] [PASSED] 38 VFs
[21:02:59] [PASSED] 39 VFs
[21:02:59] [PASSED] 40 VFs
[21:02:59] [PASSED] 41 VFs
[21:02:59] [PASSED] 42 VFs
[21:02:59] [PASSED] 43 VFs
[21:02:59] [PASSED] 44 VFs
[21:02:59] [PASSED] 45 VFs
[21:02:59] [PASSED] 46 VFs
[21:02:59] [PASSED] 47 VFs
[21:02:59] [PASSED] 48 VFs
[21:02:59] [PASSED] 49 VFs
[21:02:59] [PASSED] 50 VFs
[21:02:59] [PASSED] 51 VFs
[21:02:59] [PASSED] 52 VFs
[21:02:59] [PASSED] 53 VFs
[21:02:59] [PASSED] 54 VFs
[21:02:59] [PASSED] 55 VFs
[21:02:59] [PASSED] 56 VFs
[21:02:59] [PASSED] 57 VFs
[21:02:59] [PASSED] 58 VFs
[21:02:59] [PASSED] 59 VFs
[21:02:59] [PASSED] 60 VFs
[21:02:59] [PASSED] 61 VFs
[21:02:59] [PASSED] 62 VFs
[21:02:59] [PASSED] 63 VFs
[21:02:59] ================= [PASSED] fair_doorbells ==================
[21:02:59] ======================== fair_ggtt  ========================
[21:02:59] [PASSED] 1 VF
[21:02:59] [PASSED] 2 VFs
[21:02:59] [PASSED] 3 VFs
[21:02:59] [PASSED] 4 VFs
[21:02:59] [PASSED] 5 VFs
[21:02:59] [PASSED] 6 VFs
[21:02:59] [PASSED] 7 VFs
[21:02:59] [PASSED] 8 VFs
[21:02:59] [PASSED] 9 VFs
[21:02:59] [PASSED] 10 VFs
[21:02:59] [PASSED] 11 VFs
[21:02:59] [PASSED] 12 VFs
[21:02:59] [PASSED] 13 VFs
[21:02:59] [PASSED] 14 VFs
[21:02:59] [PASSED] 15 VFs
[21:02:59] [PASSED] 16 VFs
[21:02:59] [PASSED] 17 VFs
[21:02:59] [PASSED] 18 VFs
[21:02:59] [PASSED] 19 VFs
[21:02:59] [PASSED] 20 VFs
[21:02:59] [PASSED] 21 VFs
[21:02:59] [PASSED] 22 VFs
[21:02:59] [PASSED] 23 VFs
[21:02:59] [PASSED] 24 VFs
[21:02:59] [PASSED] 25 VFs
[21:02:59] [PASSED] 26 VFs
[21:02:59] [PASSED] 27 VFs
[21:02:59] [PASSED] 28 VFs
[21:02:59] [PASSED] 29 VFs
[21:02:59] [PASSED] 30 VFs
[21:02:59] [PASSED] 31 VFs
[21:02:59] [PASSED] 32 VFs
[21:02:59] [PASSED] 33 VFs
[21:02:59] [PASSED] 34 VFs
[21:02:59] [PASSED] 35 VFs
[21:02:59] [PASSED] 36 VFs
[21:02:59] [PASSED] 37 VFs
[21:02:59] [PASSED] 38 VFs
[21:02:59] [PASSED] 39 VFs
[21:02:59] [PASSED] 40 VFs
[21:02:59] [PASSED] 41 VFs
[21:02:59] [PASSED] 42 VFs
[21:02:59] [PASSED] 43 VFs
[21:02:59] [PASSED] 44 VFs
[21:02:59] [PASSED] 45 VFs
[21:02:59] [PASSED] 46 VFs
[21:02:59] [PASSED] 47 VFs
[21:02:59] [PASSED] 48 VFs
[21:02:59] [PASSED] 49 VFs
[21:02:59] [PASSED] 50 VFs
[21:02:59] [PASSED] 51 VFs
[21:02:59] [PASSED] 52 VFs
[21:02:59] [PASSED] 53 VFs
[21:02:59] [PASSED] 54 VFs
[21:02:59] [PASSED] 55 VFs
[21:02:59] [PASSED] 56 VFs
[21:02:59] [PASSED] 57 VFs
[21:02:59] [PASSED] 58 VFs
[21:02:59] [PASSED] 59 VFs
[21:02:59] [PASSED] 60 VFs
[21:02:59] [PASSED] 61 VFs
[21:02:59] [PASSED] 62 VFs
[21:02:59] [PASSED] 63 VFs
[21:02:59] ==================== [PASSED] fair_ggtt ====================
[21:02:59] ======================== fair_vram  ========================
[21:02:59] [PASSED] 1 VF
[21:02:59] [PASSED] 2 VFs
[21:02:59] [PASSED] 3 VFs
[21:02:59] [PASSED] 4 VFs
[21:02:59] [PASSED] 5 VFs
[21:02:59] [PASSED] 6 VFs
[21:02:59] [PASSED] 7 VFs
[21:02:59] [PASSED] 8 VFs
[21:02:59] [PASSED] 9 VFs
[21:02:59] [PASSED] 10 VFs
[21:02:59] [PASSED] 11 VFs
[21:02:59] [PASSED] 12 VFs
[21:02:59] [PASSED] 13 VFs
[21:02:59] [PASSED] 14 VFs
[21:02:59] [PASSED] 15 VFs
[21:02:59] [PASSED] 16 VFs
[21:02:59] [PASSED] 17 VFs
[21:02:59] [PASSED] 18 VFs
[21:02:59] [PASSED] 19 VFs
[21:02:59] [PASSED] 20 VFs
[21:02:59] [PASSED] 21 VFs
[21:02:59] [PASSED] 22 VFs
[21:02:59] [PASSED] 23 VFs
[21:02:59] [PASSED] 24 VFs
[21:02:59] [PASSED] 25 VFs
[21:02:59] [PASSED] 26 VFs
[21:02:59] [PASSED] 27 VFs
[21:02:59] [PASSED] 28 VFs
[21:02:59] [PASSED] 29 VFs
[21:02:59] [PASSED] 30 VFs
[21:02:59] [PASSED] 31 VFs
[21:02:59] [PASSED] 32 VFs
[21:02:59] [PASSED] 33 VFs
[21:02:59] [PASSED] 34 VFs
[21:02:59] [PASSED] 35 VFs
[21:02:59] [PASSED] 36 VFs
[21:02:59] [PASSED] 37 VFs
[21:02:59] [PASSED] 38 VFs
[21:02:59] [PASSED] 39 VFs
[21:02:59] [PASSED] 40 VFs
[21:02:59] [PASSED] 41 VFs
[21:02:59] [PASSED] 42 VFs
[21:02:59] [PASSED] 43 VFs
[21:02:59] [PASSED] 44 VFs
[21:02:59] [PASSED] 45 VFs
[21:02:59] [PASSED] 46 VFs
[21:02:59] [PASSED] 47 VFs
[21:02:59] [PASSED] 48 VFs
[21:02:59] [PASSED] 49 VFs
[21:02:59] [PASSED] 50 VFs
[21:02:59] [PASSED] 51 VFs
[21:02:59] [PASSED] 52 VFs
[21:02:59] [PASSED] 53 VFs
[21:02:59] [PASSED] 54 VFs
[21:02:59] [PASSED] 55 VFs
[21:02:59] [PASSED] 56 VFs
[21:02:59] [PASSED] 57 VFs
[21:02:59] [PASSED] 58 VFs
[21:02:59] [PASSED] 59 VFs
[21:02:59] [PASSED] 60 VFs
[21:02:59] [PASSED] 61 VFs
[21:02:59] [PASSED] 62 VFs
[21:02:59] [PASSED] 63 VFs
[21:02:59] ==================== [PASSED] fair_vram ====================
[21:02:59] ================== [PASSED] pf_gt_config ===================
[21:02:59] ===================== lmtt (1 subtest) =====================
[21:02:59] ======================== test_ops  =========================
[21:02:59] [PASSED] 2-level
[21:02:59] [PASSED] multi-level
[21:02:59] ==================== [PASSED] test_ops =====================
[21:02:59] ====================== [PASSED] lmtt =======================
[21:02:59] ================= pf_service (11 subtests) =================
[21:02:59] [PASSED] pf_negotiate_any
[21:02:59] [PASSED] pf_negotiate_base_match
[21:02:59] [PASSED] pf_negotiate_base_newer
[21:02:59] [PASSED] pf_negotiate_base_next
[21:02:59] [SKIPPED] pf_negotiate_base_older
[21:02:59] [PASSED] pf_negotiate_base_prev
[21:02:59] [PASSED] pf_negotiate_latest_match
[21:02:59] [PASSED] pf_negotiate_latest_newer
[21:02:59] [PASSED] pf_negotiate_latest_next
[21:02:59] [SKIPPED] pf_negotiate_latest_older
[21:02:59] [SKIPPED] pf_negotiate_latest_prev
[21:02:59] =================== [PASSED] pf_service ====================
[21:02:59] ================= xe_guc_g2g (2 subtests) ==================
[21:02:59] ============== xe_live_guc_g2g_kunit_default  ==============
[21:02:59] ========= [SKIPPED] xe_live_guc_g2g_kunit_default ==========
[21:02:59] ============== xe_live_guc_g2g_kunit_allmem  ===============
[21:02:59] ========== [SKIPPED] xe_live_guc_g2g_kunit_allmem ==========
[21:02:59] =================== [SKIPPED] xe_guc_g2g ===================
[21:02:59] =================== xe_mocs (2 subtests) ===================
[21:02:59] ================ xe_live_mocs_kernel_kunit  ================
[21:02:59] =========== [SKIPPED] xe_live_mocs_kernel_kunit ============
[21:02:59] ================ xe_live_mocs_reset_kunit  =================
[21:02:59] ============ [SKIPPED] xe_live_mocs_reset_kunit ============
[21:02:59] ==================== [SKIPPED] xe_mocs =====================
[21:02:59] ================= xe_migrate (2 subtests) ==================
[21:02:59] ================= xe_migrate_sanity_kunit  =================
[21:02:59] ============ [SKIPPED] xe_migrate_sanity_kunit =============
[21:02:59] ================== xe_validate_ccs_kunit  ==================
[21:02:59] ============= [SKIPPED] xe_validate_ccs_kunit ==============
[21:02:59] =================== [SKIPPED] xe_migrate ===================
[21:02:59] ================== xe_dma_buf (1 subtest) ==================
[21:02:59] ==================== xe_dma_buf_kunit  =====================
[21:02:59] ================ [SKIPPED] xe_dma_buf_kunit ================
[21:02:59] =================== [SKIPPED] xe_dma_buf ===================
[21:02:59] ================= xe_bo_shrink (1 subtest) =================
[21:02:59] =================== xe_bo_shrink_kunit  ====================
[21:02:59] =============== [SKIPPED] xe_bo_shrink_kunit ===============
[21:02:59] ================== [SKIPPED] xe_bo_shrink ==================
[21:02:59] ==================== xe_bo (2 subtests) ====================
[21:02:59] ================== xe_ccs_migrate_kunit  ===================
[21:02:59] ============== [SKIPPED] xe_ccs_migrate_kunit ==============
[21:02:59] ==================== xe_bo_evict_kunit  ====================
[21:02:59] =============== [SKIPPED] xe_bo_evict_kunit ================
[21:02:59] ===================== [SKIPPED] xe_bo ======================
[21:02:59] ==================== args (13 subtests) ====================
[21:02:59] [PASSED] count_args_test
[21:02:59] [PASSED] call_args_example
[21:02:59] [PASSED] call_args_test
[21:02:59] [PASSED] drop_first_arg_example
[21:02:59] [PASSED] drop_first_arg_test
[21:02:59] [PASSED] first_arg_example
[21:02:59] [PASSED] first_arg_test
[21:02:59] [PASSED] last_arg_example
[21:02:59] [PASSED] last_arg_test
[21:02:59] [PASSED] pick_arg_example
[21:02:59] [PASSED] if_args_example
[21:02:59] [PASSED] if_args_test
[21:02:59] [PASSED] sep_comma_example
[21:02:59] ====================== [PASSED] args =======================
[21:02:59] =================== xe_pci (3 subtests) ====================
[21:02:59] ==================== check_graphics_ip  ====================
[21:02:59] [PASSED] 12.00 Xe_LP
[21:02:59] [PASSED] 12.10 Xe_LP+
[21:02:59] [PASSED] 12.55 Xe_HPG
[21:02:59] [PASSED] 12.60 Xe_HPC
[21:02:59] [PASSED] 12.70 Xe_LPG
[21:02:59] [PASSED] 12.71 Xe_LPG
[21:02:59] [PASSED] 12.74 Xe_LPG+
[21:02:59] [PASSED] 20.01 Xe2_HPG
[21:02:59] [PASSED] 20.02 Xe2_HPG
[21:02:59] [PASSED] 20.04 Xe2_LPG
[21:02:59] [PASSED] 30.00 Xe3_LPG
[21:02:59] [PASSED] 30.01 Xe3_LPG
[21:02:59] [PASSED] 30.03 Xe3_LPG
[21:02:59] [PASSED] 30.04 Xe3_LPG
[21:02:59] [PASSED] 30.05 Xe3_LPG
[21:02:59] [PASSED] 35.10 Xe3p_LPG
[21:02:59] [PASSED] 35.11 Xe3p_XPC
[21:02:59] ================ [PASSED] check_graphics_ip ================
[21:02:59] ===================== check_media_ip  ======================
[21:02:59] [PASSED] 12.00 Xe_M
[21:02:59] [PASSED] 12.55 Xe_HPM
[21:02:59] [PASSED] 13.00 Xe_LPM+
[21:02:59] [PASSED] 13.01 Xe2_HPM
[21:02:59] [PASSED] 20.00 Xe2_LPM
[21:02:59] [PASSED] 30.00 Xe3_LPM
[21:02:59] [PASSED] 30.02 Xe3_LPM
[21:02:59] [PASSED] 35.00 Xe3p_LPM
[21:02:59] [PASSED] 35.03 Xe3p_HPM
[21:02:59] ================= [PASSED] check_media_ip ==================
[21:02:59] =================== check_platform_desc  ===================
[21:02:59] [PASSED] 0x9A60 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A68 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A70 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A40 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A49 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A59 (TIGERLAKE)
[21:02:59] [PASSED] 0x9A78 (TIGERLAKE)
[21:02:59] [PASSED] 0x9AC0 (TIGERLAKE)
[21:02:59] [PASSED] 0x9AC9 (TIGERLAKE)
[21:02:59] [PASSED] 0x9AD9 (TIGERLAKE)
[21:02:59] [PASSED] 0x9AF8 (TIGERLAKE)
[21:02:59] [PASSED] 0x4C80 (ROCKETLAKE)
[21:02:59] [PASSED] 0x4C8A (ROCKETLAKE)
[21:02:59] [PASSED] 0x4C8B (ROCKETLAKE)
[21:02:59] [PASSED] 0x4C8C (ROCKETLAKE)
[21:02:59] [PASSED] 0x4C90 (ROCKETLAKE)
[21:02:59] [PASSED] 0x4C9A (ROCKETLAKE)
[21:02:59] [PASSED] 0x4680 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4682 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4688 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x468A (ALDERLAKE_S)
[21:02:59] [PASSED] 0x468B (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4690 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4692 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4693 (ALDERLAKE_S)
[21:02:59] [PASSED] 0x46A0 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46A1 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46A2 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46A3 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46A6 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46A8 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46AA (ALDERLAKE_P)
[21:02:59] [PASSED] 0x462A (ALDERLAKE_P)
[21:02:59] [PASSED] 0x4626 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x4628 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46B0 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46B1 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46B2 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46B3 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46C0 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46C1 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46C2 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46C3 (ALDERLAKE_P)
[21:02:59] [PASSED] 0x46D0 (ALDERLAKE_N)
[21:02:59] [PASSED] 0x46D1 (ALDERLAKE_N)
[21:02:59] [PASSED] 0x46D2 (ALDERLAKE_N)
[21:02:59] [PASSED] 0x46D3 (ALDERLAKE_N)
[21:02:59] [PASSED] 0x46D4 (ALDERLAKE_N)
[21:02:59] [PASSED] 0xA721 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7A1 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7A9 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7AC (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7AD (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA720 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7A0 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7A8 (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7AA (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA7AB (ALDERLAKE_P)
[21:02:59] [PASSED] 0xA780 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA781 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA782 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA783 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA788 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA789 (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA78A (ALDERLAKE_S)
[21:02:59] [PASSED] 0xA78B (ALDERLAKE_S)
[21:02:59] [PASSED] 0x4905 (DG1)
[21:02:59] [PASSED] 0x4906 (DG1)
[21:02:59] [PASSED] 0x4907 (DG1)
[21:02:59] [PASSED] 0x4908 (DG1)
[21:02:59] [PASSED] 0x4909 (DG1)
[21:02:59] [PASSED] 0x56C0 (DG2)
[21:02:59] [PASSED] 0x56C2 (DG2)
[21:02:59] [PASSED] 0x56C1 (DG2)
[21:02:59] [PASSED] 0x7D51 (METEORLAKE)
[21:02:59] [PASSED] 0x7DD1 (METEORLAKE)
[21:02:59] [PASSED] 0x7D41 (METEORLAKE)
[21:02:59] [PASSED] 0x7D67 (METEORLAKE)
[21:02:59] [PASSED] 0xB640 (METEORLAKE)
[21:02:59] [PASSED] 0x56A0 (DG2)
[21:02:59] [PASSED] 0x56A1 (DG2)
[21:02:59] [PASSED] 0x56A2 (DG2)
[21:02:59] [PASSED] 0x56BE (DG2)
[21:02:59] [PASSED] 0x56BF (DG2)
[21:02:59] [PASSED] 0x5690 (DG2)
[21:02:59] [PASSED] 0x5691 (DG2)
[21:02:59] [PASSED] 0x5692 (DG2)
[21:02:59] [PASSED] 0x56A5 (DG2)
[21:02:59] [PASSED] 0x56A6 (DG2)
[21:02:59] [PASSED] 0x56B0 (DG2)
[21:02:59] [PASSED] 0x56B1 (DG2)
[21:02:59] [PASSED] 0x56BA (DG2)
[21:02:59] [PASSED] 0x56BB (DG2)
[21:02:59] [PASSED] 0x56BC (DG2)
[21:02:59] [PASSED] 0x56BD (DG2)
[21:02:59] [PASSED] 0x5693 (DG2)
[21:02:59] [PASSED] 0x5694 (DG2)
[21:02:59] [PASSED] 0x5695 (DG2)
[21:02:59] [PASSED] 0x56A3 (DG2)
[21:02:59] [PASSED] 0x56A4 (DG2)
[21:02:59] [PASSED] 0x56B2 (DG2)
[21:02:59] [PASSED] 0x56B3 (DG2)
[21:02:59] [PASSED] 0x5696 (DG2)
[21:02:59] [PASSED] 0x5697 (DG2)
[21:02:59] [PASSED] 0xB69 (PVC)
[21:02:59] [PASSED] 0xB6E (PVC)
[21:02:59] [PASSED] 0xBD4 (PVC)
[21:02:59] [PASSED] 0xBD5 (PVC)
[21:02:59] [PASSED] 0xBD6 (PVC)
[21:02:59] [PASSED] 0xBD7 (PVC)
[21:02:59] [PASSED] 0xBD8 (PVC)
[21:02:59] [PASSED] 0xBD9 (PVC)
[21:02:59] [PASSED] 0xBDA (PVC)
[21:02:59] [PASSED] 0xBDB (PVC)
[21:02:59] [PASSED] 0xBE0 (PVC)
[21:02:59] [PASSED] 0xBE1 (PVC)
[21:02:59] [PASSED] 0xBE5 (PVC)
[21:02:59] [PASSED] 0x7D40 (METEORLAKE)
[21:02:59] [PASSED] 0x7D45 (METEORLAKE)
[21:02:59] [PASSED] 0x7D55 (METEORLAKE)
[21:02:59] [PASSED] 0x7D60 (METEORLAKE)
[21:02:59] [PASSED] 0x7DD5 (METEORLAKE)
[21:02:59] [PASSED] 0x6420 (LUNARLAKE)
[21:02:59] [PASSED] 0x64A0 (LUNARLAKE)
[21:02:59] [PASSED] 0x64B0 (LUNARLAKE)
[21:02:59] [PASSED] 0xE202 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE209 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE20B (BATTLEMAGE)
[21:02:59] [PASSED] 0xE20C (BATTLEMAGE)
[21:02:59] [PASSED] 0xE20D (BATTLEMAGE)
[21:02:59] [PASSED] 0xE210 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE211 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE212 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE216 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE220 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE221 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE222 (BATTLEMAGE)
[21:02:59] [PASSED] 0xE223 (BATTLEMAGE)
[21:02:59] [PASSED] 0xB080 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB081 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB082 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB083 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB084 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB085 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB086 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB087 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB08F (PANTHERLAKE)
[21:02:59] [PASSED] 0xB090 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB0A0 (PANTHERLAKE)
[21:02:59] [PASSED] 0xB0B0 (PANTHERLAKE)
[21:02:59] [PASSED] 0xFD80 (PANTHERLAKE)
[21:02:59] [PASSED] 0xFD81 (PANTHERLAKE)
[21:02:59] [PASSED] 0xD740 (NOVALAKE_S)
[21:02:59] [PASSED] 0xD741 (NOVALAKE_S)
[21:02:59] [PASSED] 0xD742 (NOVALAKE_S)
[21:02:59] [PASSED] 0xD743 (NOVALAKE_S)
[21:02:59] [PASSED] 0xD744 (NOVALAKE_S)
[21:02:59] [PASSED] 0xD745 (NOVALAKE_S)
[21:02:59] [PASSED] 0x674C (CRESCENTISLAND)
[21:02:59] [PASSED] 0xD750 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD751 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD752 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD753 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD754 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD755 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD756 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD757 (NOVALAKE_P)
[21:02:59] [PASSED] 0xD75F (NOVALAKE_P)
[21:02:59] =============== [PASSED] check_platform_desc ===============
[21:02:59] ===================== [PASSED] xe_pci ======================
[21:02:59] =================== xe_rtp (3 subtests) ====================
[21:02:59] =================== xe_rtp_rules_tests  ====================
[21:02:59] [PASSED] no
[21:02:59] [PASSED] yes
[21:02:59] [PASSED] no-and-no
[21:02:59] [PASSED] no-and-yes
[21:02:59] [PASSED] yes-and-no
[21:02:59] [PASSED] yes-and-yes
[21:02:59] [PASSED] no-or-no
[21:02:59] [PASSED] no-or-yes
[21:02:59] [PASSED] yes-or-no
[21:02:59] [PASSED] yes-or-yes
[21:02:59] [PASSED] no-yes-or-yes-no
[21:02:59] [PASSED] no-yes-or-yes-yes
[21:02:59] [PASSED] yes-yes-or-no-yes
[21:02:59] [PASSED] yes-yes-or-yes-yes
[21:02:59] [PASSED] no-no-or-yes-or-no
[21:02:59] [PASSED] or
[21:02:59] [PASSED] or-yes
[21:02:59] [PASSED] or-no
[21:02:59] [PASSED] yes-or
[21:02:59] [PASSED] no-or
[21:02:59] [PASSED] no-or-or-yes
[21:02:59] [PASSED] yes-or-or-no
[21:02:59] [PASSED] no-or-or-no
[21:02:59] [PASSED] missing-context-engine-class
[21:02:59] [PASSED] missing-context-engine-class-or-yes
[21:02:59] [PASSED] missing-context-engine-class-or-or-yes
[21:02:59] =============== [PASSED] xe_rtp_rules_tests ================
[21:02:59] =============== xe_rtp_process_to_sr_tests  ================
[21:02:59] [PASSED] coalesce-same-reg
[21:02:59] [PASSED] no-match-no-add
[21:02:59] [PASSED] two-regs-two-entries
[21:02:59] [PASSED] clr-one-set-other
[21:02:59] [PASSED] set-field
[21:02:59] [PASSED] conflict-duplicate
[21:02:59] [PASSED] conflict-not-disjoint
[21:02:59] [PASSED] conflict-reg-type
[21:02:59] =========== [PASSED] xe_rtp_process_to_sr_tests ============
[21:02:59] ================== xe_rtp_process_tests  ===================
[21:02:59] [PASSED] active1
[21:02:59] [PASSED] active2
[21:02:59] [PASSED] active-inactive
[21:02:59] [PASSED] inactive-active
[21:02:59] [PASSED] inactive-active-inactive
[21:02:59] [PASSED] inactive-inactive-inactive
[21:02:59] ============== [PASSED] xe_rtp_process_tests ===============
[21:02:59] ===================== [PASSED] xe_rtp ======================
[21:02:59] ==================== xe_wa (1 subtest) =====================
[21:02:59] ======================== xe_wa_gt  =========================
[21:02:59] [PASSED] TIGERLAKE B0
[21:02:59] [PASSED] DG1 A0
[21:02:59] [PASSED] DG1 B0
[21:02:59] [PASSED] ALDERLAKE_S A0
[21:02:59] [PASSED] ALDERLAKE_S B0
[21:02:59] [PASSED] ALDERLAKE_S C0
[21:02:59] [PASSED] ALDERLAKE_S D0
[21:02:59] [PASSED] ALDERLAKE_P A0
[21:02:59] [PASSED] ALDERLAKE_P B0
[21:02:59] [PASSED] ALDERLAKE_P C0
[21:02:59] [PASSED] ALDERLAKE_S RPLS D0
[21:02:59] [PASSED] ALDERLAKE_P RPLU E0
[21:02:59] [PASSED] DG2 G10 C0
[21:02:59] [PASSED] DG2 G11 B1
[21:02:59] [PASSED] DG2 G12 A1
[21:02:59] [PASSED] METEORLAKE 12.70(Xe_LPG) A0 13.00(Xe_LPM+) A0
[21:02:59] [PASSED] METEORLAKE 12.71(Xe_LPG) A0 13.00(Xe_LPM+) A0
[21:02:59] [PASSED] METEORLAKE 12.74(Xe_LPG+) A0 13.00(Xe_LPM+) A0
[21:02:59] [PASSED] LUNARLAKE 20.04(Xe2_LPG) A0 20.00(Xe2_LPM) A0
[21:02:59] [PASSED] LUNARLAKE 20.04(Xe2_LPG) B0 20.00(Xe2_LPM) A0
[21:02:59] [PASSED] BATTLEMAGE 20.01(Xe2_HPG) A0 13.01(Xe2_HPM) A1
[21:02:59] [PASSED] PANTHERLAKE 30.00(Xe3_LPG) A0 30.00(Xe3_LPM) A0
[21:02:59] ==================== [PASSED] xe_wa_gt =====================
[21:02:59] ====================== [PASSED] xe_wa ======================
[21:02:59] ============================================================
[21:02:59] Testing complete. Ran 618 tests: passed: 600, skipped: 18
[21:02:59] Elapsed time: 36.224s total, 4.334s configuring, 31.225s building, 0.617s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/tests/.kunitconfig
[21:02:59] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:03:01] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[21:03:25] Starting KUnit Kernel (1/1)...
[21:03:25] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:03:25] ============ drm_test_pick_cmdline (2 subtests) ============
[21:03:25] [PASSED] drm_test_pick_cmdline_res_1920_1080_60
[21:03:25] =============== drm_test_pick_cmdline_named  ===============
[21:03:25] [PASSED] NTSC
[21:03:25] [PASSED] NTSC-J
[21:03:25] [PASSED] PAL
[21:03:25] [PASSED] PAL-M
[21:03:25] =========== [PASSED] drm_test_pick_cmdline_named ===========
[21:03:25] ============== [PASSED] drm_test_pick_cmdline ==============
[21:03:25] == drm_test_atomic_get_connector_for_encoder (1 subtest) ===
[21:03:25] [PASSED] drm_test_drm_atomic_get_connector_for_encoder
[21:03:25] ==== [PASSED] drm_test_atomic_get_connector_for_encoder ====
[21:03:25] =========== drm_validate_clone_mode (2 subtests) ===========
[21:03:25] ============== drm_test_check_in_clone_mode  ===============
[21:03:25] [PASSED] in_clone_mode
[21:03:25] [PASSED] not_in_clone_mode
[21:03:25] ========== [PASSED] drm_test_check_in_clone_mode ===========
[21:03:25] =============== drm_test_check_valid_clones  ===============
[21:03:25] [PASSED] not_in_clone_mode
[21:03:25] [PASSED] valid_clone
[21:03:25] [PASSED] invalid_clone
[21:03:25] =========== [PASSED] drm_test_check_valid_clones ===========
[21:03:25] ============= [PASSED] drm_validate_clone_mode =============
[21:03:25] ============= drm_validate_modeset (1 subtest) =============
[21:03:25] [PASSED] drm_test_check_connector_changed_modeset
[21:03:25] ============== [PASSED] drm_validate_modeset ===============
[21:03:25] ====== drm_test_bridge_get_current_state (2 subtests) ======
[21:03:25] [PASSED] drm_test_drm_bridge_get_current_state_atomic
[21:03:25] [PASSED] drm_test_drm_bridge_get_current_state_legacy
[21:03:25] ======== [PASSED] drm_test_bridge_get_current_state ========
[21:03:25] ====== drm_test_bridge_helper_reset_crtc (3 subtests) ======
[21:03:25] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic
[21:03:25] [PASSED] drm_test_drm_bridge_helper_reset_crtc_atomic_disabled
[21:03:25] [PASSED] drm_test_drm_bridge_helper_reset_crtc_legacy
[21:03:25] ======== [PASSED] drm_test_bridge_helper_reset_crtc ========
[21:03:25] ============== drm_bridge_alloc (2 subtests) ===============
[21:03:25] [PASSED] drm_test_drm_bridge_alloc_basic
[21:03:25] [PASSED] drm_test_drm_bridge_alloc_get_put
[21:03:25] ================ [PASSED] drm_bridge_alloc =================
[21:03:25] ============= drm_cmdline_parser (40 subtests) =============
[21:03:25] [PASSED] drm_test_cmdline_force_d_only
[21:03:25] [PASSED] drm_test_cmdline_force_D_only_dvi
[21:03:25] [PASSED] drm_test_cmdline_force_D_only_hdmi
[21:03:25] [PASSED] drm_test_cmdline_force_D_only_not_digital
[21:03:25] [PASSED] drm_test_cmdline_force_e_only
[21:03:25] [PASSED] drm_test_cmdline_res
[21:03:25] [PASSED] drm_test_cmdline_res_vesa
[21:03:25] [PASSED] drm_test_cmdline_res_vesa_rblank
[21:03:25] [PASSED] drm_test_cmdline_res_rblank
[21:03:25] [PASSED] drm_test_cmdline_res_bpp
[21:03:25] [PASSED] drm_test_cmdline_res_refresh
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_margins
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_force_off
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_analog
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_force_on_digital
[21:03:25] [PASSED] drm_test_cmdline_res_bpp_refresh_interlaced_margins_force_on
[21:03:25] [PASSED] drm_test_cmdline_res_margins_force_on
[21:03:25] [PASSED] drm_test_cmdline_res_vesa_margins
[21:03:25] [PASSED] drm_test_cmdline_name
[21:03:25] [PASSED] drm_test_cmdline_name_bpp
[21:03:25] [PASSED] drm_test_cmdline_name_option
[21:03:25] [PASSED] drm_test_cmdline_name_bpp_option
[21:03:25] [PASSED] drm_test_cmdline_rotate_0
[21:03:25] [PASSED] drm_test_cmdline_rotate_90
[21:03:25] [PASSED] drm_test_cmdline_rotate_180
[21:03:25] [PASSED] drm_test_cmdline_rotate_270
[21:03:25] [PASSED] drm_test_cmdline_hmirror
[21:03:25] [PASSED] drm_test_cmdline_vmirror
[21:03:25] [PASSED] drm_test_cmdline_margin_options
[21:03:25] [PASSED] drm_test_cmdline_multiple_options
[21:03:25] [PASSED] drm_test_cmdline_bpp_extra_and_option
[21:03:25] [PASSED] drm_test_cmdline_extra_and_option
[21:03:25] [PASSED] drm_test_cmdline_freestanding_options
[21:03:25] [PASSED] drm_test_cmdline_freestanding_force_e_and_options
[21:03:25] [PASSED] drm_test_cmdline_panel_orientation
[21:03:25] ================ drm_test_cmdline_invalid  =================
[21:03:25] [PASSED] margin_only
[21:03:25] [PASSED] interlace_only
[21:03:25] [PASSED] res_missing_x
[21:03:25] [PASSED] res_missing_y
[21:03:25] [PASSED] res_bad_y
[21:03:25] [PASSED] res_missing_y_bpp
[21:03:25] [PASSED] res_bad_bpp
[21:03:25] [PASSED] res_bad_refresh
[21:03:25] [PASSED] res_bpp_refresh_force_on_off
[21:03:25] [PASSED] res_invalid_mode
[21:03:25] [PASSED] res_bpp_wrong_place_mode
[21:03:25] [PASSED] name_bpp_refresh
[21:03:25] [PASSED] name_refresh
[21:03:25] [PASSED] name_refresh_wrong_mode
[21:03:25] [PASSED] name_refresh_invalid_mode
[21:03:25] [PASSED] rotate_multiple
[21:03:25] [PASSED] rotate_invalid_val
[21:03:25] [PASSED] rotate_truncated
[21:03:25] [PASSED] invalid_option
[21:03:25] [PASSED] invalid_tv_option
[21:03:25] [PASSED] truncated_tv_option
[21:03:25] ============ [PASSED] drm_test_cmdline_invalid =============
[21:03:25] =============== drm_test_cmdline_tv_options  ===============
[21:03:25] [PASSED] NTSC
[21:03:25] [PASSED] NTSC_443
[21:03:25] [PASSED] NTSC_J
[21:03:25] [PASSED] PAL
[21:03:25] [PASSED] PAL_M
[21:03:25] [PASSED] PAL_N
[21:03:25] [PASSED] SECAM
[21:03:25] [PASSED] MONO_525
[21:03:25] [PASSED] MONO_625
[21:03:25] =========== [PASSED] drm_test_cmdline_tv_options ===========
[21:03:25] =============== [PASSED] drm_cmdline_parser ================
[21:03:25] ========== drmm_connector_hdmi_init (20 subtests) ==========
[21:03:25] [PASSED] drm_test_connector_hdmi_init_valid
[21:03:25] [PASSED] drm_test_connector_hdmi_init_bpc_8
[21:03:25] [PASSED] drm_test_connector_hdmi_init_bpc_10
[21:03:25] [PASSED] drm_test_connector_hdmi_init_bpc_12
[21:03:25] [PASSED] drm_test_connector_hdmi_init_bpc_invalid
[21:03:25] [PASSED] drm_test_connector_hdmi_init_bpc_null
[21:03:25] [PASSED] drm_test_connector_hdmi_init_formats_empty
[21:03:25] [PASSED] drm_test_connector_hdmi_init_formats_no_rgb
[21:03:25] === drm_test_connector_hdmi_init_formats_yuv420_allowed  ===
[21:03:25] [PASSED] supported_formats=0x9 yuv420_allowed=1
[21:03:25] [PASSED] supported_formats=0x9 yuv420_allowed=0
[21:03:25] [PASSED] supported_formats=0x5 yuv420_allowed=1
[21:03:25] [PASSED] supported_formats=0x5 yuv420_allowed=0
[21:03:25] === [PASSED] drm_test_connector_hdmi_init_formats_yuv420_allowed ===
[21:03:25] [PASSED] drm_test_connector_hdmi_init_null_ddc
[21:03:25] [PASSED] drm_test_connector_hdmi_init_null_product
[21:03:25] [PASSED] drm_test_connector_hdmi_init_null_vendor
[21:03:25] [PASSED] drm_test_connector_hdmi_init_product_length_exact
[21:03:25] [PASSED] drm_test_connector_hdmi_init_product_length_too_long
[21:03:25] [PASSED] drm_test_connector_hdmi_init_product_valid
[21:03:25] [PASSED] drm_test_connector_hdmi_init_vendor_length_exact
[21:03:25] [PASSED] drm_test_connector_hdmi_init_vendor_length_too_long
[21:03:25] [PASSED] drm_test_connector_hdmi_init_vendor_valid
[21:03:25] ========= drm_test_connector_hdmi_init_type_valid  =========
[21:03:25] [PASSED] HDMI-A
[21:03:25] [PASSED] HDMI-B
[21:03:25] ===== [PASSED] drm_test_connector_hdmi_init_type_valid =====
[21:03:25] ======== drm_test_connector_hdmi_init_type_invalid  ========
[21:03:25] [PASSED] Unknown
[21:03:25] [PASSED] VGA
[21:03:25] [PASSED] DVI-I
[21:03:25] [PASSED] DVI-D
[21:03:25] [PASSED] DVI-A
[21:03:25] [PASSED] Composite
[21:03:25] [PASSED] SVIDEO
[21:03:25] [PASSED] LVDS
[21:03:25] [PASSED] Component
[21:03:25] [PASSED] DIN
[21:03:25] [PASSED] DP
[21:03:25] [PASSED] TV
[21:03:25] [PASSED] eDP
[21:03:25] [PASSED] Virtual
[21:03:25] [PASSED] DSI
[21:03:25] [PASSED] DPI
[21:03:25] [PASSED] Writeback
[21:03:25] [PASSED] SPI
[21:03:25] [PASSED] USB
[21:03:25] ==== [PASSED] drm_test_connector_hdmi_init_type_invalid ====
[21:03:25] ============ [PASSED] drmm_connector_hdmi_init =============
[21:03:25] ============= drmm_connector_init (3 subtests) =============
[21:03:25] [PASSED] drm_test_drmm_connector_init
[21:03:25] [PASSED] drm_test_drmm_connector_init_null_ddc
[21:03:25] ========= drm_test_drmm_connector_init_type_valid  =========
[21:03:25] [PASSED] Unknown
[21:03:25] [PASSED] VGA
[21:03:25] [PASSED] DVI-I
[21:03:25] [PASSED] DVI-D
[21:03:25] [PASSED] DVI-A
[21:03:25] [PASSED] Composite
[21:03:25] [PASSED] SVIDEO
[21:03:25] [PASSED] LVDS
[21:03:25] [PASSED] Component
[21:03:25] [PASSED] DIN
[21:03:25] [PASSED] DP
[21:03:25] [PASSED] HDMI-A
[21:03:25] [PASSED] HDMI-B
[21:03:25] [PASSED] TV
[21:03:25] [PASSED] eDP
[21:03:25] [PASSED] Virtual
[21:03:25] [PASSED] DSI
[21:03:25] [PASSED] DPI
[21:03:25] [PASSED] Writeback
[21:03:25] [PASSED] SPI
[21:03:25] [PASSED] USB
[21:03:25] ===== [PASSED] drm_test_drmm_connector_init_type_valid =====
[21:03:25] =============== [PASSED] drmm_connector_init ===============
[21:03:25] ========= drm_connector_dynamic_init (6 subtests) ==========
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_init
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_init_null_ddc
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_init_not_added
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_init_properties
[21:03:25] ===== drm_test_drm_connector_dynamic_init_type_valid  ======
[21:03:25] [PASSED] Unknown
[21:03:25] [PASSED] VGA
[21:03:25] [PASSED] DVI-I
[21:03:25] [PASSED] DVI-D
[21:03:25] [PASSED] DVI-A
[21:03:25] [PASSED] Composite
[21:03:25] [PASSED] SVIDEO
[21:03:25] [PASSED] LVDS
[21:03:25] [PASSED] Component
[21:03:25] [PASSED] DIN
[21:03:25] [PASSED] DP
[21:03:25] [PASSED] HDMI-A
[21:03:25] [PASSED] HDMI-B
[21:03:25] [PASSED] TV
[21:03:25] [PASSED] eDP
[21:03:25] [PASSED] Virtual
[21:03:25] [PASSED] DSI
[21:03:25] [PASSED] DPI
[21:03:25] [PASSED] Writeback
[21:03:25] [PASSED] SPI
[21:03:25] [PASSED] USB
[21:03:25] = [PASSED] drm_test_drm_connector_dynamic_init_type_valid ==
[21:03:25] ======== drm_test_drm_connector_dynamic_init_name  =========
[21:03:25] [PASSED] Unknown
[21:03:25] [PASSED] VGA
[21:03:25] [PASSED] DVI-I
[21:03:25] [PASSED] DVI-D
[21:03:25] [PASSED] DVI-A
[21:03:25] [PASSED] Composite
[21:03:25] [PASSED] SVIDEO
[21:03:25] [PASSED] LVDS
[21:03:25] [PASSED] Component
[21:03:25] [PASSED] DIN
[21:03:25] [PASSED] DP
[21:03:25] [PASSED] HDMI-A
[21:03:25] [PASSED] HDMI-B
[21:03:25] [PASSED] TV
[21:03:25] [PASSED] eDP
[21:03:25] [PASSED] Virtual
[21:03:25] [PASSED] DSI
[21:03:25] [PASSED] DPI
[21:03:25] [PASSED] Writeback
[21:03:25] [PASSED] SPI
[21:03:25] [PASSED] USB
[21:03:25] ==== [PASSED] drm_test_drm_connector_dynamic_init_name =====
[21:03:25] =========== [PASSED] drm_connector_dynamic_init ============
[21:03:25] ==== drm_connector_dynamic_register_early (4 subtests) =====
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_early_on_list
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_early_defer
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_early_no_init
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_early_no_mode_object
[21:03:25] ====== [PASSED] drm_connector_dynamic_register_early =======
[21:03:25] ======= drm_connector_dynamic_register (7 subtests) ========
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_on_list
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_no_defer
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_no_init
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_mode_object
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_sysfs
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_sysfs_name
[21:03:25] [PASSED] drm_test_drm_connector_dynamic_register_debugfs
[21:03:25] ========= [PASSED] drm_connector_dynamic_register ==========
[21:03:25] = drm_connector_attach_broadcast_rgb_property (2 subtests) =
[21:03:25] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property
[21:03:25] [PASSED] drm_test_drm_connector_attach_broadcast_rgb_property_hdmi_connector
[21:03:25] === [PASSED] drm_connector_attach_broadcast_rgb_property ===
[21:03:25] ========== drm_get_tv_mode_from_name (2 subtests) ==========
[21:03:25] ========== drm_test_get_tv_mode_from_name_valid  ===========
[21:03:25] [PASSED] NTSC
[21:03:25] [PASSED] NTSC-443
[21:03:25] [PASSED] NTSC-J
[21:03:25] [PASSED] PAL
[21:03:25] [PASSED] PAL-M
[21:03:25] [PASSED] PAL-N
[21:03:25] [PASSED] SECAM
[21:03:25] [PASSED] Mono
[21:03:25] ====== [PASSED] drm_test_get_tv_mode_from_name_valid =======
[21:03:25] [PASSED] drm_test_get_tv_mode_from_name_truncated
[21:03:25] ============ [PASSED] drm_get_tv_mode_from_name ============
[21:03:25] = drm_test_connector_hdmi_compute_mode_clock (12 subtests) =
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_10bpc_vic_1
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_12bpc_vic_1
[21:03:25] [PASSED] drm_test_drm_hdmi_compute_mode_clock_rgb_double
[21:03:25] = drm_test_connector_hdmi_compute_mode_clock_yuv420_valid  =
[21:03:25] [PASSED] VIC 96
[21:03:25] [PASSED] VIC 97
[21:03:25] [PASSED] VIC 101
[21:03:25] [PASSED] VIC 102
[21:03:25] [PASSED] VIC 106
[21:03:25] [PASSED] VIC 107
[21:03:25] === [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_valid ===
[21:03:25] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_10_bpc
[21:03:25] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv420_12_bpc
[21:03:25] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_8_bpc
[21:03:25] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_10_bpc
[21:03:25] [PASSED] drm_test_connector_hdmi_compute_mode_clock_yuv422_12_bpc
[21:03:25] === [PASSED] drm_test_connector_hdmi_compute_mode_clock ====
[21:03:25] == drm_hdmi_connector_get_broadcast_rgb_name (2 subtests) ==
[21:03:25] === drm_test_drm_hdmi_connector_get_broadcast_rgb_name  ====
[21:03:25] [PASSED] Automatic
[21:03:25] [PASSED] Full
[21:03:25] [PASSED] Limited 16:235
[21:03:25] === [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name ===
[21:03:25] [PASSED] drm_test_drm_hdmi_connector_get_broadcast_rgb_name_invalid
[21:03:25] ==== [PASSED] drm_hdmi_connector_get_broadcast_rgb_name ====
[21:03:25] == drm_hdmi_connector_get_output_format_name (2 subtests) ==
[21:03:25] === drm_test_drm_hdmi_connector_get_output_format_name  ====
[21:03:25] [PASSED] RGB
[21:03:25] [PASSED] YUV 4:2:0
[21:03:25] [PASSED] YUV 4:2:2
[21:03:25] [PASSED] YUV 4:4:4
[21:03:25] === [PASSED] drm_test_drm_hdmi_connector_get_output_format_name ===
[21:03:25] [PASSED] drm_test_drm_hdmi_connector_get_output_format_name_invalid
[21:03:25] ==== [PASSED] drm_hdmi_connector_get_output_format_name ====
[21:03:25] ============= drm_damage_helper (21 subtests) ==============
[21:03:25] [PASSED] drm_test_damage_iter_no_damage
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_fractional_src
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_src_moved
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_fractional_src_moved
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_not_visible
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_no_crtc
[21:03:25] [PASSED] drm_test_damage_iter_no_damage_no_fb
[21:03:25] [PASSED] drm_test_damage_iter_simple_damage
[21:03:25] [PASSED] drm_test_damage_iter_single_damage
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_intersect_src
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_outside_src
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_fractional_src
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_intersect_fractional_src
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_outside_fractional_src
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_src_moved
[21:03:25] [PASSED] drm_test_damage_iter_single_damage_fractional_src_moved
[21:03:25] [PASSED] drm_test_damage_iter_damage
[21:03:25] [PASSED] drm_test_damage_iter_damage_one_intersect
[21:03:25] [PASSED] drm_test_damage_iter_damage_one_outside
[21:03:25] [PASSED] drm_test_damage_iter_damage_src_moved
[21:03:25] [PASSED] drm_test_damage_iter_damage_not_visible
[21:03:25] ================ [PASSED] drm_damage_helper ================
[21:03:25] ============== drm_dp_mst_helper (3 subtests) ==============
[21:03:25] ============== drm_test_dp_mst_calc_pbn_mode  ==============
[21:03:25] [PASSED] Clock 154000 BPP 30 DSC disabled
[21:03:25] [PASSED] Clock 234000 BPP 30 DSC disabled
[21:03:25] [PASSED] Clock 297000 BPP 24 DSC disabled
[21:03:25] [PASSED] Clock 332880 BPP 24 DSC enabled
[21:03:25] [PASSED] Clock 324540 BPP 24 DSC enabled
[21:03:25] ========== [PASSED] drm_test_dp_mst_calc_pbn_mode ==========
[21:03:25] ============== drm_test_dp_mst_calc_pbn_div  ===============
[21:03:25] [PASSED] Link rate 2000000 lane count 4
[21:03:25] [PASSED] Link rate 2000000 lane count 2
[21:03:25] [PASSED] Link rate 2000000 lane count 1
[21:03:25] [PASSED] Link rate 1350000 lane count 4
[21:03:25] [PASSED] Link rate 1350000 lane count 2
[21:03:25] [PASSED] Link rate 1350000 lane count 1
[21:03:25] [PASSED] Link rate 1000000 lane count 4
[21:03:25] [PASSED] Link rate 1000000 lane count 2
[21:03:25] [PASSED] Link rate 1000000 lane count 1
[21:03:25] [PASSED] Link rate 810000 lane count 4
[21:03:25] [PASSED] Link rate 810000 lane count 2
[21:03:25] [PASSED] Link rate 810000 lane count 1
[21:03:25] [PASSED] Link rate 540000 lane count 4
[21:03:25] [PASSED] Link rate 540000 lane count 2
[21:03:25] [PASSED] Link rate 540000 lane count 1
[21:03:25] [PASSED] Link rate 270000 lane count 4
[21:03:25] [PASSED] Link rate 270000 lane count 2
[21:03:25] [PASSED] Link rate 270000 lane count 1
[21:03:25] [PASSED] Link rate 162000 lane count 4
[21:03:25] [PASSED] Link rate 162000 lane count 2
[21:03:25] [PASSED] Link rate 162000 lane count 1
[21:03:25] ========== [PASSED] drm_test_dp_mst_calc_pbn_div ===========
[21:03:25] ========= drm_test_dp_mst_sideband_msg_req_decode  =========
[21:03:25] [PASSED] DP_ENUM_PATH_RESOURCES with port number
[21:03:25] [PASSED] DP_POWER_UP_PHY with port number
[21:03:25] [PASSED] DP_POWER_DOWN_PHY with port number
[21:03:25] [PASSED] DP_ALLOCATE_PAYLOAD with SDP stream sinks
[21:03:25] [PASSED] DP_ALLOCATE_PAYLOAD with port number
[21:03:25] [PASSED] DP_ALLOCATE_PAYLOAD with VCPI
[21:03:25] [PASSED] DP_ALLOCATE_PAYLOAD with PBN
[21:03:25] [PASSED] DP_QUERY_PAYLOAD with port number
[21:03:25] [PASSED] DP_QUERY_PAYLOAD with VCPI
[21:03:25] [PASSED] DP_REMOTE_DPCD_READ with port number
[21:03:25] [PASSED] DP_REMOTE_DPCD_READ with DPCD address
[21:03:25] [PASSED] DP_REMOTE_DPCD_READ with max number of bytes
[21:03:25] [PASSED] DP_REMOTE_DPCD_WRITE with port number
[21:03:25] [PASSED] DP_REMOTE_DPCD_WRITE with DPCD address
[21:03:25] [PASSED] DP_REMOTE_DPCD_WRITE with data array
[21:03:25] [PASSED] DP_REMOTE_I2C_READ with port number
[21:03:25] [PASSED] DP_REMOTE_I2C_READ with I2C device ID
[21:03:25] [PASSED] DP_REMOTE_I2C_READ with transactions array
[21:03:25] [PASSED] DP_REMOTE_I2C_WRITE with port number
[21:03:25] [PASSED] DP_REMOTE_I2C_WRITE with I2C device ID
[21:03:25] [PASSED] DP_REMOTE_I2C_WRITE with data array
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream ID
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with client ID
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream event
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with valid stream event
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with stream behavior
[21:03:25] [PASSED] DP_QUERY_STREAM_ENC_STATUS with a valid stream behavior
[21:03:25] ===== [PASSED] drm_test_dp_mst_sideband_msg_req_decode =====
[21:03:25] ================ [PASSED] drm_dp_mst_helper ================
[21:03:25] ================== drm_exec (7 subtests) ===================
[21:03:25] [PASSED] sanitycheck
[21:03:25] [PASSED] test_lock
[21:03:25] [PASSED] test_lock_unlock
[21:03:25] [PASSED] test_duplicates
[21:03:25] [PASSED] test_prepare
[21:03:25] [PASSED] test_prepare_array
[21:03:25] [PASSED] test_multiple_loops
[21:03:25] ==================== [PASSED] drm_exec =====================
[21:03:25] =========== drm_format_helper_test (17 subtests) ===========
[21:03:25] ============== drm_test_fb_xrgb8888_to_gray8  ==============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========== [PASSED] drm_test_fb_xrgb8888_to_gray8 ==========
[21:03:25] ============= drm_test_fb_xrgb8888_to_rgb332  ==============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb332 ==========
[21:03:25] ============= drm_test_fb_xrgb8888_to_rgb565  ==============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb565 ==========
[21:03:25] ============ drm_test_fb_xrgb8888_to_xrgb1555  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_xrgb1555 =========
[21:03:25] ============ drm_test_fb_xrgb8888_to_argb1555  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_argb1555 =========
[21:03:25] ============ drm_test_fb_xrgb8888_to_rgba5551  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_rgba5551 =========
[21:03:25] ============= drm_test_fb_xrgb8888_to_rgb888  ==============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========= [PASSED] drm_test_fb_xrgb8888_to_rgb888 ==========
[21:03:25] ============= drm_test_fb_xrgb8888_to_bgr888  ==============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========= [PASSED] drm_test_fb_xrgb8888_to_bgr888 ==========
[21:03:25] ============ drm_test_fb_xrgb8888_to_argb8888  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_argb8888 =========
[21:03:25] =========== drm_test_fb_xrgb8888_to_xrgb2101010  ===========
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======= [PASSED] drm_test_fb_xrgb8888_to_xrgb2101010 =======
[21:03:25] =========== drm_test_fb_xrgb8888_to_argb2101010  ===========
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======= [PASSED] drm_test_fb_xrgb8888_to_argb2101010 =======
[21:03:25] ============== drm_test_fb_xrgb8888_to_mono  ===============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ========== [PASSED] drm_test_fb_xrgb8888_to_mono ===========
[21:03:25] ==================== drm_test_fb_swab  =====================
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ================ [PASSED] drm_test_fb_swab =================
[21:03:25] ============ drm_test_fb_xrgb8888_to_xbgr8888  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_xbgr8888 =========
[21:03:25] ============ drm_test_fb_xrgb8888_to_abgr8888  =============
[21:03:25] [PASSED] single_pixel_source_buffer
[21:03:25] [PASSED] single_pixel_clip_rectangle
[21:03:25] [PASSED] well_known_colors
[21:03:25] [PASSED] destination_pitch
[21:03:25] ======== [PASSED] drm_test_fb_xrgb8888_to_abgr8888 =========
[21:03:25] ================= drm_test_fb_clip_offset  =================
[21:03:25] [PASSED] pass through
[21:03:25] [PASSED] horizontal offset
[21:03:25] [PASSED] vertical offset
[21:03:25] [PASSED] horizontal and vertical offset
[21:03:25] [PASSED] horizontal offset (custom pitch)
[21:03:25] [PASSED] vertical offset (custom pitch)
[21:03:25] [PASSED] horizontal and vertical offset (custom pitch)
[21:03:25] ============= [PASSED] drm_test_fb_clip_offset =============
[21:03:25] =================== drm_test_fb_memcpy  ====================
[21:03:25] [PASSED] single_pixel_source_buffer: XR24 little-endian (0x34325258)
[21:03:25] [PASSED] single_pixel_source_buffer: XRA8 little-endian (0x38415258)
[21:03:25] [PASSED] single_pixel_source_buffer: YU24 little-endian (0x34325559)
[21:03:25] [PASSED] single_pixel_clip_rectangle: XB24 little-endian (0x34324258)
[21:03:25] [PASSED] single_pixel_clip_rectangle: XRA8 little-endian (0x38415258)
[21:03:25] [PASSED] single_pixel_clip_rectangle: YU24 little-endian (0x34325559)
[21:03:25] [PASSED] well_known_colors: XB24 little-endian (0x34324258)
[21:03:25] [PASSED] well_known_colors: XRA8 little-endian (0x38415258)
[21:03:25] [PASSED] well_known_colors: YU24 little-endian (0x34325559)
[21:03:25] [PASSED] destination_pitch: XB24 little-endian (0x34324258)
[21:03:25] [PASSED] destination_pitch: XRA8 little-endian (0x38415258)
[21:03:25] [PASSED] destination_pitch: YU24 little-endian (0x34325559)
[21:03:25] =============== [PASSED] drm_test_fb_memcpy ================
[21:03:25] ============= [PASSED] drm_format_helper_test ==============
[21:03:25] ================= drm_format (18 subtests) =================
[21:03:25] [PASSED] drm_test_format_block_width_invalid
[21:03:25] [PASSED] drm_test_format_block_width_one_plane
[21:03:25] [PASSED] drm_test_format_block_width_two_plane
[21:03:25] [PASSED] drm_test_format_block_width_three_plane
[21:03:25] [PASSED] drm_test_format_block_width_tiled
[21:03:25] [PASSED] drm_test_format_block_height_invalid
[21:03:25] [PASSED] drm_test_format_block_height_one_plane
[21:03:25] [PASSED] drm_test_format_block_height_two_plane
[21:03:25] [PASSED] drm_test_format_block_height_three_plane
[21:03:25] [PASSED] drm_test_format_block_height_tiled
[21:03:25] [PASSED] drm_test_format_min_pitch_invalid
[21:03:25] [PASSED] drm_test_format_min_pitch_one_plane_8bpp
[21:03:25] [PASSED] drm_test_format_min_pitch_one_plane_16bpp
[21:03:25] [PASSED] drm_test_format_min_pitch_one_plane_24bpp
[21:03:25] [PASSED] drm_test_format_min_pitch_one_plane_32bpp
[21:03:25] [PASSED] drm_test_format_min_pitch_two_plane
[21:03:25] [PASSED] drm_test_format_min_pitch_three_plane_8bpp
[21:03:25] [PASSED] drm_test_format_min_pitch_tiled
[21:03:25] =================== [PASSED] drm_format ====================
[21:03:25] ============== drm_framebuffer (10 subtests) ===============
[21:03:25] ========== drm_test_framebuffer_check_src_coords  ==========
[21:03:25] [PASSED] Success: source fits into fb
[21:03:25] [PASSED] Fail: overflowing fb with x-axis coordinate
[21:03:25] [PASSED] Fail: overflowing fb with y-axis coordinate
[21:03:25] [PASSED] Fail: overflowing fb with source width
[21:03:25] [PASSED] Fail: overflowing fb with source height
[21:03:25] ====== [PASSED] drm_test_framebuffer_check_src_coords ======
[21:03:25] [PASSED] drm_test_framebuffer_cleanup
[21:03:25] =============== drm_test_framebuffer_create  ===============
[21:03:25] [PASSED] ABGR8888 normal sizes
[21:03:25] [PASSED] ABGR8888 max sizes
[21:03:25] [PASSED] ABGR8888 pitch greater than min required
[21:03:25] [PASSED] ABGR8888 pitch less than min required
[21:03:25] [PASSED] ABGR8888 Invalid width
[21:03:25] [PASSED] ABGR8888 Invalid buffer handle
[21:03:25] [PASSED] No pixel format
[21:03:25] [PASSED] ABGR8888 Width 0
[21:03:25] [PASSED] ABGR8888 Height 0
[21:03:25] [PASSED] ABGR8888 Out of bound height * pitch combination
[21:03:25] [PASSED] ABGR8888 Large buffer offset
[21:03:25] [PASSED] ABGR8888 Buffer offset for inexistent plane
[21:03:25] [PASSED] ABGR8888 Invalid flag
[21:03:25] [PASSED] ABGR8888 Set DRM_MODE_FB_MODIFIERS without modifiers
[21:03:25] [PASSED] ABGR8888 Valid buffer modifier
[21:03:25] [PASSED] ABGR8888 Invalid buffer modifier(DRM_FORMAT_MOD_SAMSUNG_64_32_TILE)
[21:03:25] [PASSED] ABGR8888 Extra pitches without DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] ABGR8888 Extra pitches with DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] NV12 Normal sizes
[21:03:25] [PASSED] NV12 Max sizes
[21:03:25] [PASSED] NV12 Invalid pitch
[21:03:25] [PASSED] NV12 Invalid modifier/missing DRM_MODE_FB_MODIFIERS flag
[21:03:25] [PASSED] NV12 different  modifier per-plane
[21:03:25] [PASSED] NV12 with DRM_FORMAT_MOD_SAMSUNG_64_32_TILE
[21:03:25] [PASSED] NV12 Valid modifiers without DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] NV12 Modifier for inexistent plane
[21:03:25] [PASSED] NV12 Handle for inexistent plane
[21:03:25] [PASSED] NV12 Handle for inexistent plane without DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] YVU420 DRM_MODE_FB_MODIFIERS set without modifier
[21:03:25] [PASSED] YVU420 Normal sizes
[21:03:25] [PASSED] YVU420 Max sizes
[21:03:25] [PASSED] YVU420 Invalid pitch
[21:03:25] [PASSED] YVU420 Different pitches
[21:03:25] [PASSED] YVU420 Different buffer offsets/pitches
[21:03:25] [PASSED] YVU420 Modifier set just for plane 0, without DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] YVU420 Modifier set just for planes 0, 1, without DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] YVU420 Modifier set just for plane 0, 1, with DRM_MODE_FB_MODIFIERS
[21:03:25] [PASSED] YVU420 Valid modifier
[21:03:25] [PASSED] YVU420 Different modifiers per plane
[21:03:25] [PASSED] YVU420 Modifier for inexistent plane
[21:03:25] [PASSED] YUV420_10BIT Invalid modifier(DRM_FORMAT_MOD_LINEAR)
[21:03:25] [PASSED] X0L2 Normal sizes
[21:03:25] [PASSED] X0L2 Max sizes
[21:03:25] [PASSED] X0L2 Invalid pitch
[21:03:25] [PASSED] X0L2 Pitch greater than minimum required
[21:03:25] [PASSED] X0L2 Handle for inexistent plane
[21:03:25] [PASSED] X0L2 Offset for inexistent plane, without DRM_MODE_FB_MODIFIERS set
[21:03:25] [PASSED] X0L2 Modifier without DRM_MODE_FB_MODIFIERS set
[21:03:25] [PASSED] X0L2 Valid modifier
[21:03:25] [PASSED] X0L2 Modifier for inexistent plane
[21:03:25] =========== [PASSED] drm_test_framebuffer_create ===========
[21:03:25] [PASSED] drm_test_framebuffer_free
[21:03:25] [PASSED] drm_test_framebuffer_init
[21:03:25] [PASSED] drm_test_framebuffer_init_bad_format
[21:03:25] [PASSED] drm_test_framebuffer_init_dev_mismatch
[21:03:25] [PASSED] drm_test_framebuffer_lookup
[21:03:25] [PASSED] drm_test_framebuffer_lookup_inexistent
[21:03:25] [PASSED] drm_test_framebuffer_modifiers_not_supported
[21:03:25] ================= [PASSED] drm_framebuffer =================
[21:03:25] ================ drm_gem_shmem (8 subtests) ================
[21:03:25] [PASSED] drm_gem_shmem_test_obj_create
[21:03:25] [PASSED] drm_gem_shmem_test_obj_create_private
[21:03:25] [PASSED] drm_gem_shmem_test_pin_pages
[21:03:25] [PASSED] drm_gem_shmem_test_vmap
[21:03:25] [PASSED] drm_gem_shmem_test_get_sg_table
[21:03:25] [PASSED] drm_gem_shmem_test_get_pages_sgt
[21:03:25] [PASSED] drm_gem_shmem_test_madvise
[21:03:25] [PASSED] drm_gem_shmem_test_purge
[21:03:25] ================== [PASSED] drm_gem_shmem ==================
[21:03:25] === drm_atomic_helper_connector_hdmi_check (27 subtests) ===
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_auto_cea_mode_vic_1
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_full_cea_mode_vic_1
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_limited_cea_mode_vic_1
[21:03:25] ====== drm_test_check_broadcast_rgb_cea_mode_yuv420  =======
[21:03:25] [PASSED] Automatic
[21:03:25] [PASSED] Full
[21:03:25] [PASSED] Limited 16:235
[21:03:25] == [PASSED] drm_test_check_broadcast_rgb_cea_mode_yuv420 ===
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_changed
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_crtc_mode_not_changed
[21:03:25] [PASSED] drm_test_check_disable_connector
[21:03:25] [PASSED] drm_test_check_hdmi_funcs_reject_rate
[21:03:25] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_rgb
[21:03:25] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_yuv420
[21:03:25] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv422
[21:03:25] [PASSED] drm_test_check_max_tmds_rate_bpc_fallback_ignore_yuv420
[21:03:25] [PASSED] drm_test_check_driver_unsupported_fallback_yuv420
[21:03:25] [PASSED] drm_test_check_output_bpc_crtc_mode_changed
[21:03:25] [PASSED] drm_test_check_output_bpc_crtc_mode_not_changed
[21:03:25] [PASSED] drm_test_check_output_bpc_dvi
[21:03:25] [PASSED] drm_test_check_output_bpc_format_vic_1
[21:03:25] [PASSED] drm_test_check_output_bpc_format_display_8bpc_only
[21:03:25] [PASSED] drm_test_check_output_bpc_format_display_rgb_only
[21:03:25] [PASSED] drm_test_check_output_bpc_format_driver_8bpc_only
[21:03:25] [PASSED] drm_test_check_output_bpc_format_driver_rgb_only
[21:03:25] [PASSED] drm_test_check_tmds_char_rate_rgb_8bpc
[21:03:25] [PASSED] drm_test_check_tmds_char_rate_rgb_10bpc
[21:03:25] [PASSED] drm_test_check_tmds_char_rate_rgb_12bpc
[21:03:25] ===== [PASSED] drm_atomic_helper_connector_hdmi_check ======
[21:03:25] === drm_atomic_helper_connector_hdmi_reset (6 subtests) ====
[21:03:25] [PASSED] drm_test_check_broadcast_rgb_value
[21:03:25] [PASSED] drm_test_check_bpc_8_value
[21:03:25] [PASSED] drm_test_check_bpc_10_value
[21:03:25] [PASSED] drm_test_check_bpc_12_value
[21:03:25] [PASSED] drm_test_check_format_value
[21:03:25] [PASSED] drm_test_check_tmds_char_value
[21:03:25] ===== [PASSED] drm_atomic_helper_connector_hdmi_reset ======
[21:03:25] = drm_atomic_helper_connector_hdmi_mode_valid (4 subtests) =
[21:03:25] [PASSED] drm_test_check_mode_valid
[21:03:25] [PASSED] drm_test_check_mode_valid_reject
[21:03:25] [PASSED] drm_test_check_mode_valid_reject_rate
[21:03:25] [PASSED] drm_test_check_mode_valid_reject_max_clock
[21:03:25] === [PASSED] drm_atomic_helper_connector_hdmi_mode_valid ===
[21:03:25] = drm_atomic_helper_connector_hdmi_infoframes (5 subtests) =
[21:03:25] [PASSED] drm_test_check_infoframes
[21:03:25] [PASSED] drm_test_check_reject_avi_infoframe
[21:03:25] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_8
[21:03:25] [PASSED] drm_test_check_reject_hdr_infoframe_bpc_10
[21:03:25] [PASSED] drm_test_check_reject_audio_infoframe
[21:03:25] === [PASSED] drm_atomic_helper_connector_hdmi_infoframes ===
[21:03:25] ================= drm_managed (2 subtests) =================
[21:03:25] [PASSED] drm_test_managed_release_action
[21:03:25] [PASSED] drm_test_managed_run_action
[21:03:25] =================== [PASSED] drm_managed ===================
[21:03:25] =================== drm_mm (6 subtests) ====================
[21:03:25] [PASSED] drm_test_mm_init
[21:03:25] [PASSED] drm_test_mm_debug
[21:03:25] [PASSED] drm_test_mm_align32
[21:03:25] [PASSED] drm_test_mm_align64
[21:03:25] [PASSED] drm_test_mm_lowest
[21:03:25] [PASSED] drm_test_mm_highest
[21:03:25] ===================== [PASSED] drm_mm ======================
[21:03:25] ============= drm_modes_analog_tv (5 subtests) =============
[21:03:25] [PASSED] drm_test_modes_analog_tv_mono_576i
[21:03:25] [PASSED] drm_test_modes_analog_tv_ntsc_480i
[21:03:25] [PASSED] drm_test_modes_analog_tv_ntsc_480i_inlined
[21:03:25] [PASSED] drm_test_modes_analog_tv_pal_576i
[21:03:25] [PASSED] drm_test_modes_analog_tv_pal_576i_inlined
[21:03:25] =============== [PASSED] drm_modes_analog_tv ===============
[21:03:25] ============== drm_plane_helper (2 subtests) ===============
[21:03:25] =============== drm_test_check_plane_state  ================
[21:03:25] [PASSED] clipping_simple
[21:03:25] [PASSED] clipping_rotate_reflect
[21:03:25] [PASSED] positioning_simple
[21:03:25] [PASSED] upscaling
[21:03:25] [PASSED] downscaling
[21:03:25] [PASSED] rounding1
[21:03:25] [PASSED] rounding2
[21:03:25] [PASSED] rounding3
[21:03:25] [PASSED] rounding4
[21:03:25] =========== [PASSED] drm_test_check_plane_state ============
[21:03:25] =========== drm_test_check_invalid_plane_state  ============
[21:03:25] [PASSED] positioning_invalid
[21:03:25] [PASSED] upscaling_invalid
[21:03:25] [PASSED] downscaling_invalid
[21:03:25] ======= [PASSED] drm_test_check_invalid_plane_state ========
[21:03:25] ================ [PASSED] drm_plane_helper =================
[21:03:25] ====== drm_connector_helper_tv_get_modes (1 subtest) =======
[21:03:25] ====== drm_test_connector_helper_tv_get_modes_check  =======
[21:03:25] [PASSED] None
[21:03:25] [PASSED] PAL
[21:03:25] [PASSED] NTSC
[21:03:25] [PASSED] Both, NTSC Default
[21:03:25] [PASSED] Both, PAL Default
[21:03:25] [PASSED] Both, NTSC Default, with PAL on command-line
[21:03:25] [PASSED] Both, PAL Default, with NTSC on command-line
[21:03:25] == [PASSED] drm_test_connector_helper_tv_get_modes_check ===
[21:03:25] ======== [PASSED] drm_connector_helper_tv_get_modes ========
[21:03:25] ================== drm_rect (9 subtests) ===================
[21:03:25] [PASSED] drm_test_rect_clip_scaled_div_by_zero
[21:03:25] [PASSED] drm_test_rect_clip_scaled_not_clipped
[21:03:25] [PASSED] drm_test_rect_clip_scaled_clipped
[21:03:25] [PASSED] drm_test_rect_clip_scaled_signed_vs_unsigned
[21:03:25] ================= drm_test_rect_intersect  =================
[21:03:25] [PASSED] top-left x bottom-right: 2x2+1+1 x 2x2+0+0
[21:03:25] [PASSED] top-right x bottom-left: 2x2+0+0 x 2x2+1-1
[21:03:25] [PASSED] bottom-left x top-right: 2x2+1-1 x 2x2+0+0
[21:03:25] [PASSED] bottom-right x top-left: 2x2+0+0 x 2x2+1+1
[21:03:25] [PASSED] right x left: 2x1+0+0 x 3x1+1+0
[21:03:25] [PASSED] left x right: 3x1+1+0 x 2x1+0+0
[21:03:25] [PASSED] up x bottom: 1x2+0+0 x 1x3+0-1
[21:03:25] [PASSED] bottom x up: 1x3+0-1 x 1x2+0+0
[21:03:25] [PASSED] touching corner: 1x1+0+0 x 2x2+1+1
[21:03:25] [PASSED] touching side: 1x1+0+0 x 1x1+1+0
[21:03:25] [PASSED] equal rects: 2x2+0+0 x 2x2+0+0
[21:03:25] [PASSED] inside another: 2x2+0+0 x 1x1+1+1
[21:03:25] [PASSED] far away: 1x1+0+0 x 1x1+3+6
[21:03:25] [PASSED] points intersecting: 0x0+5+10 x 0x0+5+10
[21:03:25] [PASSED] points not intersecting: 0x0+0+0 x 0x0+5+10
[21:03:25] ============= [PASSED] drm_test_rect_intersect =============
[21:03:25] ================ drm_test_rect_calc_hscale  ================
[21:03:25] [PASSED] normal use
[21:03:25] [PASSED] out of max range
[21:03:25] [PASSED] out of min range
[21:03:25] [PASSED] zero dst
[21:03:25] [PASSED] negative src
[21:03:25] [PASSED] negative dst
[21:03:25] ============ [PASSED] drm_test_rect_calc_hscale ============
[21:03:25] ================ drm_test_rect_calc_vscale  ================
[21:03:25] [PASSED] normal use
[21:03:25] [PASSED] out of max range
[21:03:25] [PASSED] out of min range
[21:03:25] [PASSED] zero dst
[21:03:25] [PASSED] negative src
[21:03:25] [PASSED] negative dst
[21:03:25] ============ [PASSED] drm_test_rect_calc_vscale ============
[21:03:25] ================== drm_test_rect_rotate  ===================
[21:03:25] [PASSED] reflect-x
[21:03:25] [PASSED] reflect-y
[21:03:25] [PASSED] rotate-0
[21:03:25] [PASSED] rotate-90
[21:03:25] [PASSED] rotate-180
[21:03:25] [PASSED] rotate-270
[21:03:25] ============== [PASSED] drm_test_rect_rotate ===============
[21:03:25] ================ drm_test_rect_rotate_inv  =================
[21:03:25] [PASSED] reflect-x
[21:03:25] [PASSED] reflect-y
[21:03:25] [PASSED] rotate-0
[21:03:25] [PASSED] rotate-90
[21:03:25] [PASSED] rotate-180
[21:03:25] [PASSED] rotate-270
[21:03:25] ============ [PASSED] drm_test_rect_rotate_inv =============
[21:03:25] ==================== [PASSED] drm_rect =====================
[21:03:25] ============ drm_sysfb_modeset_test (1 subtest) ============
[21:03:25] ============ drm_test_sysfb_build_fourcc_list  =============
[21:03:25] [PASSED] no native formats
[21:03:25] [PASSED] XRGB8888 as native format
[21:03:25] [PASSED] remove duplicates
[21:03:25] [PASSED] convert alpha formats
[21:03:25] [PASSED] random formats
[21:03:25] ======== [PASSED] drm_test_sysfb_build_fourcc_list =========
[21:03:25] ============= [PASSED] drm_sysfb_modeset_test ==============
[21:03:25] ================== drm_fixp (2 subtests) ===================
[21:03:25] [PASSED] drm_test_int2fixp
[21:03:25] [PASSED] drm_test_sm2fixp
[21:03:25] ==================== [PASSED] drm_fixp =====================
[21:03:25] ============================================================
[21:03:25] Testing complete. Ran 621 tests: passed: 621
[21:03:25] Elapsed time: 25.769s total, 1.688s configuring, 23.905s building, 0.175s running

+ /kernel/tools/testing/kunit/kunit.py run --kunitconfig /kernel/drivers/gpu/drm/ttm/tests/.kunitconfig
[21:03:25] Configuring KUnit Kernel ...
Regenerating .config ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
[21:03:27] Building KUnit Kernel ...
Populating config with:
$ make ARCH=um O=.kunit olddefconfig
Building with:
$ make all compile_commands.json scripts_gdb ARCH=um O=.kunit --jobs=48
[21:03:36] Starting KUnit Kernel (1/1)...
[21:03:36] ============================================================
Running tests with:
$ .kunit/linux kunit.enable=1 mem=1G console=tty kunit_shutdown=halt
[21:03:36] ================= ttm_device (5 subtests) ==================
[21:03:36] [PASSED] ttm_device_init_basic
[21:03:36] [PASSED] ttm_device_init_multiple
[21:03:36] [PASSED] ttm_device_fini_basic
[21:03:36] [PASSED] ttm_device_init_no_vma_man
[21:03:36] ================== ttm_device_init_pools  ==================
[21:03:36] [PASSED] No DMA allocations, no DMA32 required
[21:03:36] [PASSED] DMA allocations, DMA32 required
[21:03:36] [PASSED] No DMA allocations, DMA32 required
[21:03:36] [PASSED] DMA allocations, no DMA32 required
[21:03:36] ============== [PASSED] ttm_device_init_pools ==============
[21:03:36] =================== [PASSED] ttm_device ====================
[21:03:36] ================== ttm_pool (8 subtests) ===================
[21:03:36] ================== ttm_pool_alloc_basic  ===================
[21:03:36] [PASSED] One page
[21:03:36] [PASSED] More than one page
[21:03:36] [PASSED] Above the allocation limit
[21:03:36] [PASSED] One page, with coherent DMA mappings enabled
[21:03:36] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[21:03:36] ============== [PASSED] ttm_pool_alloc_basic ===============
[21:03:36] ============== ttm_pool_alloc_basic_dma_addr  ==============
[21:03:36] [PASSED] One page
[21:03:36] [PASSED] More than one page
[21:03:36] [PASSED] Above the allocation limit
[21:03:36] [PASSED] One page, with coherent DMA mappings enabled
[21:03:36] [PASSED] Above the allocation limit, with coherent DMA mappings enabled
[21:03:36] ========== [PASSED] ttm_pool_alloc_basic_dma_addr ==========
[21:03:36] [PASSED] ttm_pool_alloc_order_caching_match
[21:03:36] [PASSED] ttm_pool_alloc_caching_mismatch
[21:03:36] [PASSED] ttm_pool_alloc_order_mismatch
[21:03:36] [PASSED] ttm_pool_free_dma_alloc
[21:03:36] [PASSED] ttm_pool_free_no_dma_alloc
[21:03:36] [PASSED] ttm_pool_fini_basic
[21:03:36] ==================== [PASSED] ttm_pool =====================
[21:03:36] ================ ttm_resource (8 subtests) =================
[21:03:36] ================= ttm_resource_init_basic  =================
[21:03:36] [PASSED] Init resource in TTM_PL_SYSTEM
[21:03:36] [PASSED] Init resource in TTM_PL_VRAM
[21:03:36] [PASSED] Init resource in a private placement
[21:03:36] [PASSED] Init resource in TTM_PL_SYSTEM, set placement flags
[21:03:36] ============= [PASSED] ttm_resource_init_basic =============
[21:03:36] [PASSED] ttm_resource_init_pinned
[21:03:36] [PASSED] ttm_resource_fini_basic
[21:03:36] [PASSED] ttm_resource_manager_init_basic
[21:03:36] [PASSED] ttm_resource_manager_usage_basic
[21:03:36] [PASSED] ttm_resource_manager_set_used_basic
[21:03:36] [PASSED] ttm_sys_man_alloc_basic
[21:03:36] [PASSED] ttm_sys_man_free_basic
[21:03:36] ================== [PASSED] ttm_resource ===================
[21:03:36] =================== ttm_tt (15 subtests) ===================
[21:03:36] ==================== ttm_tt_init_basic  ====================
[21:03:36] [PASSED] Page-aligned size
[21:03:36] [PASSED] Extra pages requested
[21:03:36] ================ [PASSED] ttm_tt_init_basic ================
[21:03:36] [PASSED] ttm_tt_init_misaligned
[21:03:36] [PASSED] ttm_tt_fini_basic
[21:03:36] [PASSED] ttm_tt_fini_sg
[21:03:36] [PASSED] ttm_tt_fini_shmem
[21:03:36] [PASSED] ttm_tt_create_basic
[21:03:36] [PASSED] ttm_tt_create_invalid_bo_type
[21:03:36] [PASSED] ttm_tt_create_ttm_exists
[21:03:36] [PASSED] ttm_tt_create_failed
[21:03:36] [PASSED] ttm_tt_destroy_basic
[21:03:36] [PASSED] ttm_tt_populate_null_ttm
[21:03:36] [PASSED] ttm_tt_populate_populated_ttm
[21:03:36] [PASSED] ttm_tt_unpopulate_basic
[21:03:36] [PASSED] ttm_tt_unpopulate_empty_ttm
[21:03:36] [PASSED] ttm_tt_swapin_basic
[21:03:36] ===================== [PASSED] ttm_tt ======================
[21:03:36] =================== ttm_bo (14 subtests) ===================
[21:03:36] =========== ttm_bo_reserve_optimistic_no_ticket  ===========
[21:03:36] [PASSED] Cannot be interrupted and sleeps
[21:03:36] [PASSED] Cannot be interrupted, locks straight away
[21:03:36] [PASSED] Can be interrupted, sleeps
[21:03:36] ======= [PASSED] ttm_bo_reserve_optimistic_no_ticket =======
[21:03:36] [PASSED] ttm_bo_reserve_locked_no_sleep
[21:03:36] [PASSED] ttm_bo_reserve_no_wait_ticket
[21:03:36] [PASSED] ttm_bo_reserve_double_resv
[21:03:36] [PASSED] ttm_bo_reserve_interrupted
[21:03:36] [PASSED] ttm_bo_reserve_deadlock
[21:03:36] [PASSED] ttm_bo_unreserve_basic
[21:03:36] [PASSED] ttm_bo_unreserve_pinned
[21:03:36] [PASSED] ttm_bo_unreserve_bulk
[21:03:36] [PASSED] ttm_bo_fini_basic
[21:03:36] [PASSED] ttm_bo_fini_shared_resv
[21:03:36] [PASSED] ttm_bo_pin_basic
[21:03:36] [PASSED] ttm_bo_pin_unpin_resource
[21:03:36] [PASSED] ttm_bo_multiple_pin_one_unpin
[21:03:36] ===================== [PASSED] ttm_bo ======================
[21:03:36] ============== ttm_bo_validate (22 subtests) ===============
[21:03:36] ============== ttm_bo_init_reserved_sys_man  ===============
[21:03:36] [PASSED] Buffer object for userspace
[21:03:36] [PASSED] Kernel buffer object
[21:03:36] [PASSED] Shared buffer object
[21:03:36] ========== [PASSED] ttm_bo_init_reserved_sys_man ===========
[21:03:36] ============== ttm_bo_init_reserved_mock_man  ==============
[21:03:36] [PASSED] Buffer object for userspace
[21:03:36] [PASSED] Kernel buffer object
[21:03:36] [PASSED] Shared buffer object
[21:03:36] ========== [PASSED] ttm_bo_init_reserved_mock_man ==========
[21:03:36] [PASSED] ttm_bo_init_reserved_resv
[21:03:36] ================== ttm_bo_validate_basic  ==================
[21:03:36] [PASSED] Buffer object for userspace
[21:03:36] [PASSED] Kernel buffer object
[21:03:36] [PASSED] Shared buffer object
[21:03:36] ============== [PASSED] ttm_bo_validate_basic ==============
[21:03:36] [PASSED] ttm_bo_validate_invalid_placement
[21:03:36] ============= ttm_bo_validate_same_placement  ==============
[21:03:36] [PASSED] System manager
[21:03:36] [PASSED] VRAM manager
[21:03:36] ========= [PASSED] ttm_bo_validate_same_placement ==========
[21:03:36] [PASSED] ttm_bo_validate_failed_alloc
[21:03:36] [PASSED] ttm_bo_validate_pinned
[21:03:36] [PASSED] ttm_bo_validate_busy_placement
[21:03:36] ================ ttm_bo_validate_multihop  =================
[21:03:36] [PASSED] Buffer object for userspace
[21:03:36] [PASSED] Kernel buffer object
[21:03:36] [PASSED] Shared buffer object
[21:03:36] ============ [PASSED] ttm_bo_validate_multihop =============
[21:03:36] ========== ttm_bo_validate_no_placement_signaled  ==========
[21:03:36] [PASSED] Buffer object in system domain, no page vector
[21:03:36] [PASSED] Buffer object in system domain with an existing page vector
[21:03:36] ====== [PASSED] ttm_bo_validate_no_placement_signaled ======
[21:03:36] ======== ttm_bo_validate_no_placement_not_signaled  ========
[21:03:36] [PASSED] Buffer object for userspace
[21:03:36] [PASSED] Kernel buffer object
[21:03:36] [PASSED] Shared buffer object
[21:03:36] ==== [PASSED] ttm_bo_validate_no_placement_not_signaled ====
[21:03:36] [PASSED] ttm_bo_validate_move_fence_signaled
[21:03:36] ========= ttm_bo_validate_move_fence_not_signaled  =========
[21:03:36] [PASSED] Waits for GPU
[21:03:36] [PASSED] Tries to lock straight away
[21:03:36] ===== [PASSED] ttm_bo_validate_move_fence_not_signaled =====
[21:03:36] [PASSED] ttm_bo_validate_swapout
[21:03:36] [PASSED] ttm_bo_validate_happy_evict
[21:03:36] [PASSED] ttm_bo_validate_all_pinned_evict
[21:03:36] [PASSED] ttm_bo_validate_allowed_only_evict
[21:03:36] [PASSED] ttm_bo_validate_deleted_evict
[21:03:36] [PASSED] ttm_bo_validate_busy_domain_evict
[21:03:36] [PASSED] ttm_bo_validate_evict_gutting
[21:03:36] [PASSED] ttm_bo_validate_recrusive_evict
[21:03:36] ================= [PASSED] ttm_bo_validate =================
[21:03:36] ============================================================
[21:03:36] Testing complete. Ran 102 tests: passed: 102
[21:03:37] Elapsed time: 11.436s total, 1.752s configuring, 9.470s building, 0.172s running

+ cleanup
++ stat -c %u:%g /kernel
+ chown -R 1003:1003 /kernel

✓ Xe.CI.BAT: success for drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)

[Patchwork]

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

== Series Details ==

Series: drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)
URL   : https://patchwork.freedesktop.org/series/160111/
State : success

== Summary ==

CI Bug Log - changes from xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4_BAT -> xe-pw-160111v2_BAT
====================================================

Summary
-------

  **SUCCESS**

  No regressions found.

  

Participating hosts (13 -> 13)
------------------------------

  No changes in participating hosts


Changes
-------

  No changes found


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

  * Linux: xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4 -> xe-pw-160111v2

  IGT_8881: aa5853ef5b379b1e4558218c21ef4caeae112184 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4: 6472756e8384e3945f12b6726dd9dc1ac12f3bb4
  xe-pw-160111v2: 160111v2

== Logs ==

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

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

✗ Xe.CI.FULL: failure for drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)

[Patchwork]

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

== Series Details ==

Series: drm/xe/rtp: Miscellaneous improvements to rule matching (rev2)
URL   : https://patchwork.freedesktop.org/series/160111/
State : failure

== Summary ==

CI Bug Log - changes from xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4_FULL -> xe-pw-160111v2_FULL
====================================================

Summary
-------

  **FAILURE**

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

  

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

  No changes in participating hosts

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

  Here are the unknown changes that may have been introduced in xe-pw-160111v2_FULL:

### IGT changes ###

#### Possible regressions ####

  * igt@kms_sharpness_filter@filter-formats@pipe-a-edp-1-nv12:
    - shard-lnl:          [PASS][1] -> [DMESG-WARN][2] +1 other test dmesg-warn
   [1]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-lnl-7/igt@kms_sharpness_filter@filter-formats@pipe-a-edp-1-nv12.html
   [2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-2/igt@kms_sharpness_filter@filter-formats@pipe-a-edp-1-nv12.html

  * igt@xe_evict@evict-threads-large:
    - shard-bmg:          [PASS][3] -> [TIMEOUT][4]
   [3]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-6/igt@xe_evict@evict-threads-large.html
   [4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-7/igt@xe_evict@evict-threads-large.html

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

  Here are the changes found in xe-pw-160111v2_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

  * igt@kms_async_flips@alternate-sync-async-flip-atomic:
    - shard-bmg:          [PASS][5] -> [FAIL][6] ([Intel XE#3718] / [Intel XE#6078])
   [5]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-1/igt@kms_async_flips@alternate-sync-async-flip-atomic.html
   [6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_async_flips@alternate-sync-async-flip-atomic.html

  * igt@kms_async_flips@alternate-sync-async-flip-atomic@pipe-b-dp-2:
    - shard-bmg:          [PASS][7] -> [FAIL][8] ([Intel XE#6078])
   [7]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-1/igt@kms_async_flips@alternate-sync-async-flip-atomic@pipe-b-dp-2.html
   [8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_async_flips@alternate-sync-async-flip-atomic@pipe-b-dp-2.html

  * igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs:
    - shard-bmg:          [PASS][9] -> [INCOMPLETE][10] ([Intel XE#7084]) +1 other test incomplete
   [9]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-10/igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs.html
   [10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-5/igt@kms_ccs@crc-primary-suspend-4-tiled-bmg-ccs.html

  * igt@kms_cursor_legacy@flip-vs-cursor-legacy:
    - shard-bmg:          [PASS][11] -> [FAIL][12] ([Intel XE#7809])
   [11]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-2/igt@kms_cursor_legacy@flip-vs-cursor-legacy.html
   [12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_cursor_legacy@flip-vs-cursor-legacy.html

  * igt@kms_flip@flip-vs-expired-vblank@a-edp1:
    - shard-lnl:          [PASS][13] -> [FAIL][14] ([Intel XE#301]) +1 other test fail
   [13]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-lnl-7/igt@kms_flip@flip-vs-expired-vblank@a-edp1.html
   [14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-3/igt@kms_flip@flip-vs-expired-vblank@a-edp1.html

  
#### Possible fixes ####

  * igt@kms_cursor_edge_walk@256x256-top-edge@pipe-d-dp-2:
    - shard-bmg:          [FAIL][15] ([Intel XE#6841]) -> [PASS][16] +1 other test pass
   [15]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-2/igt@kms_cursor_edge_walk@256x256-top-edge@pipe-d-dp-2.html
   [16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_cursor_edge_walk@256x256-top-edge@pipe-d-dp-2.html

  * igt@kms_cursor_legacy@cursora-vs-flipa-atomic-transitions-varying-size:
    - shard-bmg:          [DMESG-WARN][17] ([Intel XE#5354]) -> [PASS][18]
   [17]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-6/igt@kms_cursor_legacy@cursora-vs-flipa-atomic-transitions-varying-size.html
   [18]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-5/igt@kms_cursor_legacy@cursora-vs-flipa-atomic-transitions-varying-size.html

  * igt@kms_flip@flip-vs-expired-vblank-interruptible:
    - shard-lnl:          [FAIL][19] ([Intel XE#301] / [Intel XE#3149]) -> [PASS][20] +1 other test pass
   [19]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-lnl-5/igt@kms_flip@flip-vs-expired-vblank-interruptible.html
   [20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-1/igt@kms_flip@flip-vs-expired-vblank-interruptible.html

  * igt@kms_hdr@invalid-hdr:
    - shard-bmg:          [SKIP][21] ([Intel XE#1503]) -> [PASS][22]
   [21]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-5/igt@kms_hdr@invalid-hdr.html
   [22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-8/igt@kms_hdr@invalid-hdr.html

  
#### Warnings ####

  * igt@kms_hdr@brightness-with-hdr:
    - shard-bmg:          [SKIP][23] ([Intel XE#3544]) -> [SKIP][24] ([Intel XE#3374] / [Intel XE#3544])
   [23]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-6/igt@kms_hdr@brightness-with-hdr.html
   [24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-7/igt@kms_hdr@brightness-with-hdr.html

  * igt@kms_tiled_display@basic-test-pattern:
    - shard-bmg:          [FAIL][25] ([Intel XE#1729] / [Intel XE#7424]) -> [SKIP][26] ([Intel XE#2426] / [Intel XE#5848])
   [25]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4/shard-bmg-5/igt@kms_tiled_display@basic-test-pattern.html
   [26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-8/igt@kms_tiled_display@basic-test-pattern.html

  
  [Intel XE#1503]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1503
  [Intel XE#1729]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1729
  [Intel XE#2426]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2426
  [Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
  [Intel XE#3149]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3149
  [Intel XE#3374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3374
  [Intel XE#3544]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3544
  [Intel XE#3718]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3718
  [Intel XE#5354]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5354
  [Intel XE#5848]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5848
  [Intel XE#6078]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6078
  [Intel XE#6841]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6841
  [Intel XE#7084]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7084
  [Intel XE#7424]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7424
  [Intel XE#7809]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7809


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

  * Linux: xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4 -> xe-pw-160111v2

  IGT_8881: aa5853ef5b379b1e4558218c21ef4caeae112184 @ https://gitlab.freedesktop.org/drm/igt-gpu-tools.git
  xe-4960-6472756e8384e3945f12b6726dd9dc1ac12f3bb4: 6472756e8384e3945f12b6726dd9dc1ac12f3bb4
  xe-pw-160111v2: 160111v2

== Logs ==

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

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