[PATCH v5 3/3] tests/intel/xe_sysfs_timeslice_duration: Restore preempt timeout

[Jonathan Cavitt]

The subtests of sysfs_timeslice_duration modify the preempt_timeout_us
and timeslice_duration_us values.  However, while the test does restore
the timeslice_duration_us value at the end of execution, it does not do
the same for preempt_timeout_us.  Because the value is not properly
restored, future tests can end up using the unexpected preempt timeout
value and thus have unexpected behavior.

Save and restore the preempt_timeout_us value during the test.

This fix does not apply to xe_sysfs_preempt_timeout because only the
preempt_timeout_us is modified during those tests, and the value is
correcty restored before the tests end.

v2: Also restore preempt_timeout_us on test failure (Kamil)

v3: Abort on restore failure (Kamil)

Closes: https://gitlab.freedesktop.org/drm/xe/kernel/-/issues/2976
Signed-off-by: Jonathan Cavitt <jonathan.cavitt at intel.com>
CC: Vinay Belgaumkar <vinay.belgaumkar at intel.com>
CC: Kamil Konieczny <kamil.konieczny at linux.intel.com>
Reviewed-by: Kamil Konieczny <kamil.konieczny at linux.intel.com>
---
 tests/intel/xe_sysfs_timeslice_duration.c | 23 ++++++++++++++++++++---
 1 file changed, 20 insertions(+), 3 deletions(-)

diff --git a/tests/intel/xe_sysfs_timeslice_duration.c b/tests/intel/xe_sysfs_timeslice_duration.c
index 6518086225..c4efd9e11b 100644
--- a/tests/intel/xe_sysfs_timeslice_duration.c
+++ b/tests/intel/xe_sysfs_timeslice_duration.c
@@ -115,10 +115,11 @@ static uint64_t __test_timeout(int fd, int engine, unsigned int timeout, uint16_
 static void test_timeout(int fd, int engine, const char **property, uint16_t class, int gt)
 {
 	uint64_t delays[] = { 1000, 50000, 100000, 500000 };
-	unsigned int saved;
+	unsigned int saved, old_pt;
 	uint64_t elapsed;
 	uint64_t epsilon;
 
+	igt_assert(igt_sysfs_scanf(engine, "preempt_timeout_us", "%u", &old_pt) == 1);
 	igt_require(igt_sysfs_printf(engine, "preempt_timeout_us", "%u", 1) == 1);
 	igt_assert(igt_sysfs_scanf(engine, property[0], "%u", &saved) == 1);
 	igt_debug("Initial %s:%u\n", property[0], saved);
@@ -140,6 +141,9 @@ static void test_timeout(int fd, int engine, const char **property, uint16_t cla
 	}
 
 	set_timeslice_duration(engine, saved);
+	igt_assert_lte(0, igt_sysfs_printf(engine, "preempt_timeout_us", "%u", old_pt));
+	igt_sysfs_scanf(engine, "preempt_timeout_us", "%u", &saved);
+	igt_assert_eq(saved, old_pt);
 }
 
 #define	MAX_GTS	8
@@ -159,6 +163,7 @@ igt_main
 	int gt_count = 0;
 	int fd = -1, sys_fd, gt;
 	int engines_fd[MAX_GTS], gt_fd[MAX_GTS];
+	unsigned int pts[MAX_GTS][XE_MAX_ENGINE_INSTANCE];
 	unsigned int tds[MAX_GTS][XE_MAX_ENGINE_INSTANCE];
 
 	igt_fixture {
@@ -177,9 +182,14 @@ igt_main
 			engines_fd[gt_count] = openat(gt_fd[gt_count], "engines", O_RDONLY);
 			igt_require(engines_fd[gt_count] != -1);
 
-			while (igt_sysfs_get_next_engine(engines_fd[gt_count], &engine))
+			while (igt_sysfs_get_next_engine(engines_fd[gt_count], &engine)) {
 				igt_require(igt_sysfs_scanf(engine, "timeslice_duration_us", "%u",
-							    &tds[gt_count][e_count++]) == 1);
+							    &tds[gt_count][e_count]) == 1);
+				igt_require(igt_sysfs_scanf(engine, "preempt_timeout_us", "%u",
+							    &pts[gt_count][e_count]) == 1);
+
+				e_count++;
+			}
 
 			igt_require(e_count > 0);
 			gt_count++;
@@ -206,6 +216,13 @@ igt_main
 			while (igt_sysfs_get_next_engine(engines_fd[i], &engine)) {
 				unsigned int store = UINT_MAX;
 
+				igt_assert_lte(0, igt_sysfs_printf(engine, "preempt_timeout_us",
+								   "%u", pts[i][e_count]));
+				igt_sysfs_scanf(engine, "preempt_timeout_us", "%u", &store);
+				igt_abort_on_f(store != pts[i][e_count],
+					       "preempt_timeout_us not restored!\n");
+
+				store = UINT_MAX;
 				igt_assert_lte(0, igt_sysfs_printf(engine, "timeslice_duration_us",
 								   "%u", tds[i][e_count]));
 				igt_sysfs_scanf(engine, "timeslice_duration_us", "%u", &store);
-- 
2.43.0