Skip to contentSkip to conversation

drm/xe/rtp: Miscellaneous improvements to rule matching

PATCH Superseded Gustavo Sousa 4 participants 20 messages Apr 30 – May 14

Subsystems (2)

v2 of 3 Superseded Latest is v3 →

lore
Share & tools
lore
#0 lore raw

v2 cover drm/xe/rtp: Miscellaneous improvements to rule matching

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.

---
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/[email protected]

---
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,

Signature · 1 line
Gustavo Sousa <[email protected]>
#1 lore raw

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

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>.

---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp.c new file +38 -0
new file mode 100644
index 000000000000..b3a8b75936d1
@@ -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);
drivers/gpu/drm/xe/tests/xe_rtp_test.c +141 -0

171 lines not on this page · raw message

drivers/gpu/drm/xe/tests/xe_rtp_test.h new file +23 -0
new file mode 100644
index 000000000000..26becc1e2af0
@@ -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
drivers/gpu/drm/xe/xe_rtp.c +40 -17

143 lines not on this page · raw message

Signature · 1 line
2.53.0
#2 lore raw

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

In reply to 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.

---
 drivers/gpu/drm/xe/tests/xe_rtp_test.c | 122 ++-------------------------------
 1 file changed, 6 insertions(+), 116 deletions(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +6 -116
index 7df8f7857c49..7dce699991a1 100644
@@ -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)),
 			},
Signature · 1 line
2.53.0
#3 lore raw

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

In reply to 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.

---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +40 -2
index 7dce699991a1..5e0afde9eab4 100644
@@ -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)
drivers/gpu/drm/xe/xe_rtp.c +10 -5
index 0e1adf07e4e7..299fa4209a26 100644
@@ -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;
 
Signature · 1 line
2.53.0
Reviewed-by on v2 3/7
#4 lore raw

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

Quoted 19 lines · 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.

Quoted 7 lines

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.

Quoted 100 lines
---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +40 -2
index 7dce699991a1..5e0afde9eab4 100644
@@ -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)
drivers/gpu/drm/xe/xe_rtp.c +10 -5
index 0e1adf07e4e7..299fa4209a26 100644
@@ -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;
 
Signature · 2 lines
-- 
2.53.0
Signature · 2 lines
--
Violet Monti
Reviewed-by on v2 3/7
#5 lore raw

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

In reply to Gustavo Sousa
Quoted 19 lines · 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.

Quoted 7 lines

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.

Quoted 100 lines
---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +40 -2
index 7dce699991a1..5e0afde9eab4 100644
@@ -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)
drivers/gpu/drm/xe/xe_rtp.c +10 -5
index 0e1adf07e4e7..299fa4209a26 100644
@@ -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;
 
Signature · 2 lines
-- 
2.53.0
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
#6 lore raw

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

In reply to 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.

---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +28 -0
index 5e0afde9eab4..e009c1243b7c 100644
@@ -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)
drivers/gpu/drm/xe/xe_rtp.c +44 -22

125 lines not on this page · raw message

Signature · 1 line
2.53.0
#7 lore raw

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

In reply to 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().

---
 drivers/gpu/drm/xe/xe_rtp.c | 219 +++++++++++++++++++-------------------------
 1 file changed, 94 insertions(+), 125 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +94 -125
index df72b456ab16..c49f80f398af 100644
@@ -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++;
 		}
 	}
 
Signature · 1 line
2.53.0
#8 lore raw

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

In reply to 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)

---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +2 -4
index e009c1243b7c..3429c5d1b5b6 100644
@@ -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)),
 	},
 	{
drivers/gpu/drm/xe/xe_rtp.c +13 -13
index c49f80f398af..976a2e1f5592 100644
@@ -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,
Signature · 1 line
2.53.0
Reviewed-by on v2 6/7
#9 lore raw

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

Quoted 21 lines · 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.

Quoted 5 lines

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

Quoted 88 lines
---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +2 -4
index e009c1243b7c..3429c5d1b5b6 100644
@@ -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)),
 	},
 	{
drivers/gpu/drm/xe/xe_rtp.c +13 -13
index c49f80f398af..976a2e1f5592 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 2 lines
--
Violet Monti
Reviewed-by on v2 6/7
#10 lore raw

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

In reply to Gustavo Sousa
Quoted 21 lines · 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.

Quoted 5 lines

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

Quoted 88 lines
---
 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(-)
drivers/gpu/drm/xe/tests/xe_rtp_test.c +2 -4
index e009c1243b7c..3429c5d1b5b6 100644
@@ -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)),
 	},
 	{
drivers/gpu/drm/xe/xe_rtp.c +13 -13
index c49f80f398af..976a2e1f5592 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
#11 lore raw

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

In reply to 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.

---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +88 -50
index 976a2e1f5592..dec9d94e6fb0 100644
@@ -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,
Signature · 1 line
2.53.0
Reviewed-by on v2 7/7
#12 lore raw

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

Quoted 13 lines · 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.

Quoted 5 lines

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.

Quoted 175 lines
---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +88 -50
index 976a2e1f5592..dec9d94e6fb0 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 2 lines
--
Violet Monti
Reviewed-by on v2 7/7
#13 lore raw

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

In reply to Gustavo Sousa
Quoted 8 lines · 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 ?;

We should probably add this grammar BNF to the DOC: section at the top of the file too. Then it won't be "unwritten" anymore. :-)

Quoted 10 lines

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.

Aside adding the kerneldoc, this looks good to me. It will definitely make it easier to define and implement additions to the grammar in the future, if necessary.

Quoted 175 lines
---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +88 -50
index 976a2e1f5592..dec9d94e6fb0 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
#14 lore raw

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

Quoted 10 lines · Matt Roper
Quoted 8 lines · 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 ?;
Quoted 2 lines

We should probably add this grammar BNF to the DOC: section at the top of the file too. Then it won't be "unwritten" anymore. :-)

Cool. It could be on the kernel-doc for XE_RTP_RULES(). Ack on incrementing this patch with the following then?

diff --git a/drivers/gpu/drm/xe/xe_rtp.h b/drivers/gpu/drm/xe/xe_rtp.h index 562082b18d7b..2a8e536eaa5d 100644
--- a/drivers/gpu/drm/xe/xe_rtp.h
+++ b/drivers/gpu/drm/xe/xe_rtp.h
@@ -394,18 +394,39 @@ struct xe_reg_sr;
* XE_RTP_RULES - Helper to set multiple rules to a struct xe_rtp_entry_sr entry
* @...: Rules
*
- * At least one rule is needed and up to 12 are supported. Multiple rules are
- * AND'ed together, i.e. all the rules must evaluate to true for the entry to
- * be processed. See XE_RTP_MATCH_* for the possible match rules. Example:
+ * When an RTP table is being processed, the rules of each entry are evaluated
+ * to check if they match the target entity (platform, gt or hwe, depending on
+ * the specific RTP table).
+ *
+ * The sequence of arguments of this macro must follow the following eBNF
+ * grammar::
+ *
+ * rules = disjunction;
+ * disjunction = conjunction, { "OR" conjunction };
+ * conjunction = single_rule, { single_rule };
+ * (* the AND operator is implicit *)
+ * single_rule = ? GRAPHICS_VERSION(...), MEDIA_VERSION(...),
+ * FUNC(...), etc ?
+ *
+ * Examples:
*
* .. code-block:: c
*
* const struct xe_rtp_entry_sr wa_entries[] = {
* ...
- * { XE_RTP_NAME("test-entry"),
+ * { XE_RTP_NAME("entry-a"),
+ * // Match DG2-G10 with graphics steppings A0 up-to B0
+ * // (exclusive).
* XE_RTP_RULES(SUBPLATFORM(DG2, G10), GRAPHICS_STEP(A0, B0)),
* ...
* },
+ * { XE_RTP_NAME("entry-b"),
+ * // Match graphics version 20 (all steppings) or graphics
+ * // version 30 steppings A0 up-to B0 (exclusive).
+ * XE_RTP_RULES(GRAPHICS_VERSION(2000), OR,
+ * GRAPHICS_VERSION(3000), GRAPHICS_STEP(A0, B0))
+ * ...
+ * },
* ...
* };
*/

--
Gustavo Sousa

Quoted 200 lines
Quoted 11 lines

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.

Aside adding the kerneldoc, this looks good to me. It will definitely make it easier to define and implement additions to the grammar in the future, if necessary.

Quoted 175 lines
---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +88 -50
index 976a2e1f5592..dec9d94e6fb0 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
#15 lore raw

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

Quoted 12 lines · Gustavo Sousa
Quoted 10 lines · Matt Roper
Quoted 8 lines · 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 ?;
Quoted 5 lines
Quoted 2 lines

We should probably add this grammar BNF to the DOC: section at the top of the file too. Then it won't be "unwritten" anymore. :-)

Cool. It could be on the kernel-doc for XE_RTP_RULES(). Ack on incrementing this patch with the following then?

Ack, looks good to me.

Matt

Quoted 253 lines

diff --git a/drivers/gpu/drm/xe/xe_rtp.h b/drivers/gpu/drm/xe/xe_rtp.h index 562082b18d7b..2a8e536eaa5d 100644
--- a/drivers/gpu/drm/xe/xe_rtp.h
+++ b/drivers/gpu/drm/xe/xe_rtp.h
@@ -394,18 +394,39 @@ struct xe_reg_sr;
* XE_RTP_RULES - Helper to set multiple rules to a struct xe_rtp_entry_sr entry
* @...: Rules
*
- * At least one rule is needed and up to 12 are supported. Multiple rules are
- * AND'ed together, i.e. all the rules must evaluate to true for the entry to
- * be processed. See XE_RTP_MATCH_* for the possible match rules. Example:
+ * When an RTP table is being processed, the rules of each entry are evaluated
+ * to check if they match the target entity (platform, gt or hwe, depending on
+ * the specific RTP table).
+ *
+ * The sequence of arguments of this macro must follow the following eBNF
+ * grammar::
+ *
+ * rules = disjunction;
+ * disjunction = conjunction, { "OR" conjunction };
+ * conjunction = single_rule, { single_rule };
+ * (* the AND operator is implicit *)
+ * single_rule = ? GRAPHICS_VERSION(...), MEDIA_VERSION(...),
+ * FUNC(...), etc ?
+ *
+ * Examples:
*
* .. code-block:: c
*
* const struct xe_rtp_entry_sr wa_entries[] = {
* ...
- * { XE_RTP_NAME("test-entry"),
+ * { XE_RTP_NAME("entry-a"),
+ * // Match DG2-G10 with graphics steppings A0 up-to B0
+ * // (exclusive).
* XE_RTP_RULES(SUBPLATFORM(DG2, G10), GRAPHICS_STEP(A0, B0)),
* ...
* },
+ * { XE_RTP_NAME("entry-b"),
+ * // Match graphics version 20 (all steppings) or graphics
+ * // version 30 steppings A0 up-to B0 (exclusive).
+ * XE_RTP_RULES(GRAPHICS_VERSION(2000), OR,
+ * GRAPHICS_VERSION(3000), GRAPHICS_STEP(A0, B0))
+ * ...
+ * },
* ...
* };
*/

--
Gustavo Sousa

Quoted 200 lines
Quoted 11 lines

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.

Aside adding the kerneldoc, this looks good to me. It will definitely make it easier to define and implement additions to the grammar in the future, if necessary.

Quoted 175 lines
---
 drivers/gpu/drm/xe/xe_rtp.c | 138 ++++++++++++++++++++++++++++----------------
 1 file changed, 88 insertions(+), 50 deletions(-)
drivers/gpu/drm/xe/xe_rtp.c +88 -50
index 976a2e1f5592..dec9d94e6fb0 100644
@@ -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,
Signature · 2 lines
-- 
2.53.0
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
Signature · 4 lines
Matt Roper
Graphics Software Engineer
Linux GPU Platform Enablement
Intel Corporation
#16 lore raw

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

In reply to Gustavo Sousa
== Series Details ==

== 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 <[email protected]>
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.

+ /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

#17 lore raw

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

In reply to Gustavo Sousa
== Series Details ==

== 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

#18 lore raw

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

In reply to Gustavo Sousa
== Series Details ==

== 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

#19 lore raw

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

In reply to Gustavo Sousa
== Series Details ==

== 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 ([email protected]) 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@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-2/igt@kms_sharpness_filter@[email protected]

* 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@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-7/igt@[email protected]

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@[email protected]
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@[email protected]

* 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@[email protected]
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_async_flips@[email protected]

* 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@[email protected]
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-5/igt@[email protected]

* 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@[email protected]
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@[email protected]

* 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@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-3/igt@kms_flip@[email protected]

#### 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@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-4/igt@kms_cursor_edge_walk@[email protected]

* 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@[email protected]
[20]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-lnl-1/igt@[email protected]

* 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@[email protected]
[22]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-8/igt@[email protected]

#### 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@[email protected]
[24]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-7/igt@[email protected]

* 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@[email protected]
[26]: https://intel-gfx-ci.01.org/tree/intel-xe/xe-pw-160111v2/shard-bmg-8/igt@[email protected]

[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