[Intel-gfx] [PATCH i-g-t] i915: Drop prefault controls

Chris Wilson chris at chris-wilson.co.uk
Tue Jan 28 08:12:21 UTC 2020


They haven't been effective for a long time; so drop them.

Signed-off-by: Chris Wilson <chris at chris-wilson.co.uk>
---
 benchmarks/gem_exec_reloc.c          |  19 +-
 lib/igt_debugfs.c                    |  59 ----
 lib/igt_debugfs.h                    |   7 -
 tests/Makefile.sources               |   6 -
 tests/i915/gem_exec_faulting_reloc.c |   5 -
 tests/i915/gem_exec_lut_handle.c     |  24 +-
 tests/i915/gem_mmap_gtt.c            |  15 -
 tests/i915/gem_persistent_relocs.c   |  24 +-
 tests/i915/gem_reloc_overflow.c      | 436 ---------------------------
 tests/i915/gem_reloc_vs_gpu.c        | 352 ---------------------
 tests/meson.build                    |   2 -
 11 files changed, 10 insertions(+), 939 deletions(-)
 delete mode 100644 tests/i915/gem_reloc_overflow.c
 delete mode 100644 tests/i915/gem_reloc_vs_gpu.c

diff --git a/benchmarks/gem_exec_reloc.c b/benchmarks/gem_exec_reloc.c
index c734643c7..0a2454cb9 100644
--- a/benchmarks/gem_exec_reloc.c
+++ b/benchmarks/gem_exec_reloc.c
@@ -48,7 +48,6 @@
 #define SKIP_RELOC 0x1
 #define NO_RELOC 0x2
 #define CYCLE_BATCH 0x4
-#define FAULT 0x8
 #define LUT 0x10
 #define SEQUENTIAL_OFFSET 0x20
 #define REVERSE_OFFSET 0x40
@@ -121,11 +120,7 @@ static int run(unsigned batch_size,
 		memcpy(reloc, mem_reloc, sizeof(*mem_reloc)*num_relocs);
 		munmap(reloc, size);
 
-		if (flags & FAULT) {
-			igt_disable_prefault();
-			reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-		} else
-			reloc = mem_reloc;
+		reloc = mem_reloc;
 	}
 
 	gem_exec[num_objects].relocation_count = num_relocs;
@@ -162,22 +157,12 @@ static int run(unsigned batch_size,
 					gem_exec[num_objects].handle = cycle[c];
 				}
 			}
-			if (flags & FAULT && reloc) {
-				munmap(reloc, size);
-				reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-				gem_exec[num_objects].relocs_ptr = (uintptr_t)reloc;
-			}
 			gem_execbuf(fd, &execbuf);
 		}
 		gettimeofday(&end, NULL);
 		printf("%.3f\n", ELAPSED(&start, &end));
 	}
 
-	if (flags & FAULT && reloc) {
-		munmap(reloc, size);
-		igt_enable_prefault();
-	}
-
 	return 0;
 }
 
@@ -208,8 +193,6 @@ int main(int argc, char **argv)
 				flags |= 0;
 			} else if (strcmp(optarg, "cyclic") == 0) {
 				flags |= CYCLE_BATCH;
-			} else if (strcmp(optarg, "fault") == 0) {
-				flags |= FAULT;
 			} else if (strcmp(optarg, "skip") == 0) {
 				flags |= SKIP_RELOC;
 			} else if (strcmp(optarg, "none") == 0) {
diff --git a/lib/igt_debugfs.c b/lib/igt_debugfs.c
index 676884c85..8cac9d1e1 100644
--- a/lib/igt_debugfs.c
+++ b/lib/igt_debugfs.c
@@ -77,9 +77,6 @@
  *
  * - drm/i915 supports interfaces to evict certain classes of gem buffer
  *   objects, see igt_drop_caches_set().
- *
- * - drm/i915 supports an interface to disable prefaulting, useful to test
- *   slow paths in ioctls. See igt_disable_prefault().
  */
 
 /*
@@ -1061,62 +1058,6 @@ void igt_drop_caches_set(int drm_fd, uint64_t val)
 	close(dir);
 }
 
-/*
- * Prefault control
- */
-
-#define PREFAULT_DEBUGFS "/sys/module/i915/parameters/prefault_disable"
-static void igt_prefault_control(bool enable)
-{
-	const char *name = PREFAULT_DEBUGFS;
-	int fd;
-	char buf[2] = {'Y', 'N'};
-	int index;
-
-	fd = open(name, O_RDWR);
-	igt_require(fd >= 0);
-
-	if (enable)
-		index = 1;
-	else
-		index = 0;
-
-	igt_require(write(fd, &buf[index], 1) == 1);
-
-	close(fd);
-}
-
-static void enable_prefault_at_exit(int sig)
-{
-	igt_enable_prefault();
-}
-
-/**
- * igt_disable_prefault:
- *
- * Disable prefaulting in certain gem ioctls through the debugfs interface. As
- * usual this installs an exit handler to clean up and re-enable prefaulting
- * even when the test exited abnormally.
- *
- * igt_enable_prefault() will enable normale operation again.
- */
-void igt_disable_prefault(void)
-{
-	igt_prefault_control(false);
-
-	igt_install_exit_handler(enable_prefault_at_exit);
-}
-
-/**
- * igt_enable_prefault:
- *
- * Enable prefault (again) through the debugfs interface.
- */
-void igt_enable_prefault(void)
-{
-	igt_prefault_control(true);
-}
-
 static int get_object_count(int fd)
 {
 	int dir, ret, scanned;
diff --git a/lib/igt_debugfs.h b/lib/igt_debugfs.h
index 5f0ce492b..1e0cc108d 100644
--- a/lib/igt_debugfs.h
+++ b/lib/igt_debugfs.h
@@ -202,13 +202,6 @@ static inline void rcu_barrier(int fd)
 	igt_drop_caches_set(fd, DROP_RCU);
 }
 
-/*
- * Prefault control
- */
-
-void igt_disable_prefault(void);
-void igt_enable_prefault(void);
-
 /*
  * Put the driver into a stable (quiescent) state and get the current number of
  * gem buffer objects
diff --git a/tests/Makefile.sources b/tests/Makefile.sources
index 7c5693457..f20be1135 100644
--- a/tests/Makefile.sources
+++ b/tests/Makefile.sources
@@ -363,12 +363,6 @@ gem_readwrite_SOURCES = i915/gem_readwrite.c
 TESTS_progs += gem_reg_read
 gem_reg_read_SOURCES = i915/gem_reg_read.c
 
-TESTS_progs += gem_reloc_overflow
-gem_reloc_overflow_SOURCES = i915/gem_reloc_overflow.c
-
-TESTS_progs += gem_reloc_vs_gpu
-gem_reloc_vs_gpu_SOURCES = i915/gem_reloc_vs_gpu.c
-
 TESTS_progs += gem_render_copy
 gem_render_copy_SOURCES = i915/gem_render_copy.c
 
diff --git a/tests/i915/gem_exec_faulting_reloc.c b/tests/i915/gem_exec_faulting_reloc.c
index 0bb5fa91a..c2aea0393 100644
--- a/tests/i915/gem_exec_faulting_reloc.c
+++ b/tests/i915/gem_exec_faulting_reloc.c
@@ -247,9 +247,4 @@ igt_main
 {
 	igt_subtest("normal")
 		run(OBJECT_SIZE);
-	igt_subtest("no-prefault") {
-		igt_disable_prefault();
-		run(OBJECT_SIZE);
-		igt_enable_prefault();
-	}
 }
diff --git a/tests/i915/gem_exec_lut_handle.c b/tests/i915/gem_exec_lut_handle.c
index b7b691572..6f227628c 100644
--- a/tests/i915/gem_exec_lut_handle.c
+++ b/tests/i915/gem_exec_lut_handle.c
@@ -52,7 +52,6 @@ IGT_TEST_DESCRIPTION("Exercises the basic execbuffer using the handle LUT"
 #define SKIP_RELOC 0x1
 #define NO_RELOC 0x2
 #define CYCLE_BATCH 0x4
-#define FAULT 0x8
 
 int target[MAX_NUM_RELOC];
 struct drm_i915_gem_exec_object2 gem_exec[MAX_NUM_EXEC+1];
@@ -92,7 +91,6 @@ igt_simple_main
 	} pass[] = {
 		{ .name = "relocation", .flags = 0 },
 		{ .name = "cycle-relocation", .flags = CYCLE_BATCH },
-		{ .name = "fault-relocation", .flags = FAULT },
 		{ .name = "skip-relocs", .flags = SKIP_RELOC },
 		{ .name = "no-relocs", .flags = SKIP_RELOC | NO_RELOC },
 		{ .name = NULL },
@@ -132,8 +130,6 @@ igt_simple_main
 	igt_require(has_exec_lut(fd));
 
 	for (p = pass; p->name != NULL; p++) {
-		if (p->flags & FAULT)
-			igt_disable_prefault();
 		for (n = 1; n <= MAX_NUM_EXEC; n *= 2) {
 			double elapsed[16][2];
 			double s_x, s_y, s_xx, s_xy;
@@ -145,10 +141,7 @@ igt_simple_main
 				struct drm_i915_gem_exec_object2 *objects;
 				struct timeval start, end;
 
-				if (p->flags & FAULT)
-					reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-				else
-					reloc = mem_reloc;
+				reloc = mem_reloc;
 
 				gem_exec[MAX_NUM_EXEC].relocation_count = m;
 				gem_exec[MAX_NUM_EXEC].relocs_ptr = to_user_pointer(reloc);
@@ -178,11 +171,6 @@ igt_simple_main
 							gem_exec[MAX_NUM_EXEC].handle = cycle[c];
 						}
 					}
-					if (p->flags & FAULT) {
-						munmap(reloc, size);
-						reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-						gem_exec[MAX_NUM_EXEC].relocs_ptr = to_user_pointer(reloc);
-					}
 					gem_execbuf(fd, &execbuf);
 				}
 				gettimeofday(&end, NULL);
@@ -208,11 +196,6 @@ igt_simple_main
 							gem_exec[MAX_NUM_EXEC].handle = cycle[c];
 						}
 					}
-					if (p->flags & FAULT) {
-						munmap(reloc, size);
-						reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-						gem_exec[MAX_NUM_EXEC].relocs_ptr = to_user_pointer(reloc);
-					}
 					gem_execbuf(fd, &execbuf);
 				}
 				gettimeofday(&end, NULL);
@@ -222,9 +205,6 @@ igt_simple_main
 				while (c != 0);
 				gem_exec[MAX_NUM_EXEC].handle = cycle[c];
 				elapsed[i][0] = ELAPSED(&start, &end);
-
-				if (p->flags & FAULT)
-					munmap(reloc, size);
 			}
 
 			igt_info("%s: buffers=%4d:", p->name, n);
@@ -255,7 +235,5 @@ igt_simple_main
 
 			igt_info("\n");
 		}
-		if (p->flags & FAULT)
-			igt_enable_prefault();
 	}
 }
diff --git a/tests/i915/gem_mmap_gtt.c b/tests/i915/gem_mmap_gtt.c
index af87ebc38..1f4655af4 100644
--- a/tests/i915/gem_mmap_gtt.c
+++ b/tests/i915/gem_mmap_gtt.c
@@ -1022,15 +1022,6 @@ test_fault_concurrent(int fd)
 		munmap(ptr[n], *ptr[n] * sizeof(uint32_t));
 }
 
-static void
-run_without_prefault(int fd,
-			void (*func)(int fd))
-{
-	igt_disable_prefault();
-	func(fd);
-	igt_enable_prefault();
-}
-
 static int mmap_ioctl(int i915, struct drm_i915_gem_mmap_gtt *arg)
 {
 	int err = 0;
@@ -1109,12 +1100,6 @@ igt_main
 		test_read_write2(fd, READ_AFTER_WRITE);
 	igt_subtest("fault-concurrent")
 		test_fault_concurrent(fd);
-	igt_subtest("basic-read-no-prefault")
-		run_without_prefault(fd, test_read);
-	igt_subtest("basic-write-no-prefault")
-		run_without_prefault(fd, test_write);
-	igt_subtest("basic-write-gtt-no-prefault")
-		run_without_prefault(fd, test_write_gtt);
 	igt_subtest("basic-write-cpu-read-gtt")
 		test_write_cpu_read_gtt(fd);
 	igt_subtest("basic-wc")
diff --git a/tests/i915/gem_persistent_relocs.c b/tests/i915/gem_persistent_relocs.c
index 7c831aaaf..442f768e6 100644
--- a/tests/i915/gem_persistent_relocs.c
+++ b/tests/i915/gem_persistent_relocs.c
@@ -192,16 +192,13 @@ static void faulting_reloc_and_emit(int fd, drm_intel_bo *target_bo,
 	gem_execbuf(fd, &execbuf);
 }
 
-static void do_test(int fd, bool faulting_reloc)
+static void do_test(int fd)
 {
 	uint32_t tiling_mode = I915_TILING_X;
 	unsigned long pitch, act_size;
 	uint32_t test;
 	int i, repeat;
 
-	if (faulting_reloc)
-		igt_disable_prefault();
-
 	act_size = 2048;
 	dummy_bo = drm_intel_bo_alloc_tiled(bufmgr, "tiled dummy_bo", act_size, act_size,
 				      4, &tiling_mode, &pitch, 0);
@@ -268,16 +265,12 @@ static void do_test(int fd, bool faulting_reloc)
 	drm_intel_gem_bo_unmap_gtt(dummy_bo);
 
 	drm_intel_bo_unreference(dummy_bo);
-
-	if (faulting_reloc)
-		igt_enable_prefault();
 }
 
 #define INTERRUPT	(1 << 0)
-#define FAULTING	(1 << 1)
-#define THRASH		(1 << 2)
-#define THRASH_INACTIVE	(1 << 3)
-#define ALL_FLAGS	(INTERRUPT | FAULTING | THRASH | THRASH_INACTIVE)
+#define THRASH		(1 << 1)
+#define THRASH_INACTIVE	(1 << 2)
+#define ALL_FLAGS	(INTERRUPT | THRASH | THRASH_INACTIVE)
 static void do_forked_test(int fd, unsigned flags)
 {
 	int num_threads = sysconf(_SC_NPROCESSORS_ONLN);
@@ -306,7 +299,7 @@ static void do_forked_test(int fd, unsigned flags)
 		if (flags & INTERRUPT)
 			igt_fork_signal_helper();
 
-		do_test(fd, flags & FAULTING);
+		do_test(fd);
 
 		if (flags & INTERRUPT)
 			igt_stop_signal_helper();
@@ -337,20 +330,19 @@ igt_main
 	}
 
 	igt_subtest("normal")
-		do_test(fd, false);
+		do_test(fd);
 
 	igt_fork_signal_helper();
 	igt_subtest("interruptible")
-		do_test(fd, false);
+		do_test(fd);
 	igt_stop_signal_helper();
 
 	for (unsigned flags = 0; flags <= ALL_FLAGS; flags++) {
 		if ((flags & THRASH) && (flags & THRASH_INACTIVE))
 			continue;
 
-		igt_subtest_f("forked%s%s%s%s",
+		igt_subtest_f("forked%s%s%s",
 			      flags & INTERRUPT ? "-interruptible" : "",
-			      flags & FAULTING ? "-faulting-reloc" : "",
 			      flags & THRASH ? "-thrashing" : "",
 			      flags & THRASH_INACTIVE ? "-thrash-inactive" : "")
 			do_forked_test(fd, flags);
diff --git a/tests/i915/gem_reloc_overflow.c b/tests/i915/gem_reloc_overflow.c
deleted file mode 100644
index c9d1f2075..000000000
--- a/tests/i915/gem_reloc_overflow.c
+++ /dev/null
@@ -1,436 +0,0 @@
-/*
- * Copyright © 2013 Google
- * Copyright © 2013 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- * Authors:
- *    Kees Cook <keescook at chromium.org>
- *    Daniel Vetter <daniel.vetter at ffwll.ch>
- *    Rafael Barbalho <rafael.barbalho at intel.com>
- *
- */
-
-#include "igt.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <string.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <unistd.h>
-#include <malloc.h>
-#include <limits.h>
-#include <sys/ioctl.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <sys/types.h>
-#include "drm.h"
-
-IGT_TEST_DESCRIPTION("Check that kernel relocation overflows are caught.");
-
-/*
- * Testcase: Kernel relocation overflows are caught.
- */
-
-int fd, entries, num;
-struct drm_i915_gem_exec_object2 *obj;
-struct drm_i915_gem_execbuffer2 execbuf;
-struct drm_i915_gem_relocation_entry *reloc;
-
-static uint32_t target_handle(void)
-{
-	return execbuf.flags & I915_EXEC_HANDLE_LUT ? 0 : obj[0].handle;
-}
-
-static void source_offset_tests(int devid, bool reloc_gtt)
-{
-	struct drm_i915_gem_relocation_entry single_reloc;
-	const char *relocation_type;
-
-	if (reloc_gtt)
-		relocation_type = "reloc-gtt";
-	else
-		relocation_type = "reloc-cpu";
-
-	igt_fixture {
-		obj[1].relocation_count = 0;
-		obj[1].relocs_ptr = 0;
-
-		obj[0].relocation_count = 1;
-		obj[0].relocs_ptr = to_user_pointer(&single_reloc);
-		execbuf.buffer_count = 2;
-
-		if (reloc_gtt) {
-			gem_set_domain(fd, obj[0].handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
-			relocation_type = "reloc-gtt";
-		} else {
-			gem_set_domain(fd, obj[0].handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
-			relocation_type = "reloc-cpu";
-		}
-	}
-
-	/* Special tests for 64b relocs. */
-	igt_subtest_f("source-offset-page-stradle-gen8-%s", relocation_type) {
-		igt_require(intel_gen(devid) >= 8);
-		single_reloc.offset = 4096 - 4;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		gem_execbuf(fd, &execbuf);
-
-		single_reloc.delta = 1024;
-		gem_execbuf(fd, &execbuf);
-	}
-
-	igt_subtest_f("source-offset-end-gen8-%s", relocation_type) {
-		igt_require(intel_gen(devid) >= 8);
-		single_reloc.offset = 8192 - 8;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		gem_execbuf(fd, &execbuf);
-	}
-
-	igt_subtest_f("source-offset-overflow-gen8-%s", relocation_type) {
-		igt_require(intel_gen(devid) >= 8);
-		single_reloc.offset = 8192 - 4;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	/* Tests for old 4byte relocs on pre-gen8. */
-	igt_subtest_f("source-offset-end-%s", relocation_type) {
-		igt_require(intel_gen(devid) < 8);
-		single_reloc.offset = 8192 - 4;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		gem_execbuf(fd, &execbuf);
-	}
-
-	igt_subtest_f("source-offset-big-%s", relocation_type) {
-		single_reloc.offset = 8192;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	igt_subtest_f("source-offset-negative-%s", relocation_type) {
-		single_reloc.offset = (int64_t) -4;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	igt_subtest_f("source-offset-unaligned-%s", relocation_type) {
-		single_reloc.offset = 1;
-		single_reloc.delta = 0;
-		single_reloc.target_handle = target_handle();
-		single_reloc.read_domains = I915_GEM_DOMAIN_RENDER;
-		single_reloc.write_domain = I915_GEM_DOMAIN_RENDER;
-		single_reloc.presumed_offset = -1;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-}
-
-static void reloc_tests(const char *suffix)
-{
-	uint64_t max_relocations;
-	int i;
-
-	max_relocations = min(ULONG_MAX, SIZE_MAX);
-	max_relocations /= sizeof(struct drm_i915_gem_relocation_entry);
-	igt_debug("Maximum allocable relocations: %'llu\n",
-		  (long long)max_relocations);
-
-	igt_subtest_f("invalid-address%s", suffix) {
-		/* Attempt unmapped single entry. */
-		obj[0].relocation_count = 1;
-		obj[0].relocs_ptr = 0;
-		execbuf.buffer_count = 1;
-
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-	}
-
-	igt_subtest_f("single-fault%s", suffix) {
-		obj[0].relocation_count = entries + 1;
-		execbuf.buffer_count = 1;
-
-		/* out-of-bounds after */
-		obj[0].relocs_ptr = to_user_pointer(reloc);
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-
-		/* out-of-bounds before */
-		obj[0].relocs_ptr = to_user_pointer((reloc - 1));
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-	}
-
-	igt_fixture {
-		obj[0].relocation_count = 0;
-		obj[0].relocs_ptr = 0;
-
-		execbuf.buffer_count = 1;
-
-		/* Make sure the batch would succeed except for the thing we're
-		 * testing. */
-		igt_require(__gem_execbuf(fd, &execbuf) == 0);
-	}
-
-	igt_subtest_f("batch-start-unaligned%s", suffix) {
-		execbuf.batch_start_offset = 1;
-		execbuf.batch_len = 8;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	igt_subtest_f("batch-end-unaligned%s", suffix) {
-		execbuf.batch_start_offset = 0;
-		execbuf.batch_len = 7;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	igt_subtest_f("batch-both-unaligned%s", suffix) {
-		execbuf.batch_start_offset = 1;
-		execbuf.batch_len = 7;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-
-	igt_fixture {
-		/* Undo damage for next tests. */
-		execbuf.batch_start_offset = 0;
-		execbuf.batch_len = 0;
-		igt_require(__gem_execbuf(fd, &execbuf) == 0);
-	}
-
-	igt_subtest_f("single-overflow%s", suffix) {
-		if (*suffix) {
-			igt_require_f(intel_get_avail_ram_mb() >
-				      sizeof(struct drm_i915_gem_relocation_entry) * entries / (1024*1024),
-				      "Test requires at least %'llu MiB, but only %'llu MiB of RAM available\n",
-				      (long long)sizeof(struct drm_i915_gem_relocation_entry) * entries / (1024*1024),
-				      (long long)intel_get_avail_ram_mb());
-		}
-
-		obj[0].relocs_ptr = to_user_pointer(reloc);
-		obj[0].relocation_count = entries;
-		execbuf.buffer_count = 1;
-		gem_execbuf(fd, &execbuf);
-
-		/* Attempt single overflowed entry. */
-		obj[0].relocation_count = -1;
-		igt_debug("relocation_count=%u\n",
-				obj[0].relocation_count);
-		if (max_relocations <= obj[0].relocation_count)
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-		else
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-
-		if (max_relocations + 1 < obj[0].relocation_count) {
-			obj[0].relocation_count = max_relocations + 1;
-			igt_debug("relocation_count=%u\n",
-				  obj[0].relocation_count);
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-
-			obj[0].relocation_count = max_relocations - 1;
-			igt_debug("relocation_count=%u\n",
-				  obj[0].relocation_count);
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-		}
-	}
-
-	igt_subtest_f("wrapped-overflow%s", suffix) {
-		if (*suffix) {
-			igt_require_f(intel_get_avail_ram_mb() >
-				      sizeof(struct drm_i915_gem_relocation_entry) * entries * num / (1024*1024),
-				      "Test requires at least %'llu MiB, but only %'llu MiB of RAM available\n",
-				      (long long)sizeof(struct drm_i915_gem_relocation_entry) * entries * num / (1024*1024),
-				      (long long)intel_get_avail_ram_mb());
-		}
-
-		for (i = 0; i < num; i++) {
-			struct drm_i915_gem_exec_object2 *o = &obj[i];
-
-			o->relocs_ptr = to_user_pointer(reloc);
-			o->relocation_count = entries;
-		}
-		execbuf.buffer_count = i;
-		gem_execbuf(fd, &execbuf);
-
-		obj[i-1].relocation_count = -1;
-		igt_debug("relocation_count[%d]=%u\n",
-			  i-1, obj[i-1].relocation_count);
-                if (max_relocations <= obj[i-1].relocation_count)
-                        igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-		else
-                        igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-
-		if (max_relocations < obj[i-1].relocation_count) {
-			obj[i-1].relocation_count = max_relocations;
-			igt_debug("relocation_count[%d]=%u\n",
-				  i-1, obj[i-1].relocation_count);
-			/* Whether the kernel reports the EFAULT for the
-			 * invalid relocation array or EINVAL for the overflow
-			 * in array size depends upon the order of the
-			 * individual tests. From a consistency perspective
-			 * EFAULT is preferred (i.e. using that relocation
-			 * array by itself would cause EFAULT not EINVAL).
-			 */
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-
-			obj[i-1].relocation_count = max_relocations - 1;
-			igt_debug("relocation_count[%d]=%u\n",
-				  i-1, obj[i-1].relocation_count);
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-		}
-
-		obj[i-1].relocation_count = entries + 1;
-		igt_debug("relocation_count[%d]=%u\n",
-                          i-1, obj[i-1].relocation_count);
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-
-		obj[0].relocation_count = -1;
-		if (max_relocations < obj[0].relocation_count) {
-			execbuf.buffer_count = 1;
-			gem_execbuf(fd, &execbuf);
-
-			/* As outlined above, this is why EFAULT is preferred */
-			obj[0].relocation_count = max_relocations;
-			igt_debug("relocation_count[0]=%u\n",
-				  obj[0].relocation_count);
-			igt_assert_eq(__gem_execbuf(fd, &execbuf), -EFAULT);
-		}
-	}
-}
-
-static void buffer_count_tests(void)
-{
-	igt_subtest("buffercount-overflow") {
-		igt_skip_on(SIZE_MAX / sizeof(*obj) >= UINT_MAX);
-
-		for (int i = 0; i < num; i++) {
-			obj[i].relocation_count = 0;
-			obj[i].relocs_ptr = 0;
-		}
-
-		/* We only have num buffers actually, but the overflow will make
-		 * sure we blow up the kernel before we blow up userspace. */
-		execbuf.buffer_count = num;
-
-		/* Make sure the basic thing would work first ... */
-		gem_execbuf(fd, &execbuf);
-
-		/* ... then be evil: Overflow of the pointer table (which has a
-		 * bit of lead datastructures, so no + 1 needed to overflow). */
-		execbuf.buffer_count = INT_MAX / sizeof(void *);
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-
-		/* ... then be evil: Copying/allocating the array. */
-		execbuf.buffer_count = UINT_MAX / sizeof(obj[0]) + 1;
-		igt_assert_eq(__gem_execbuf(fd, &execbuf), -EINVAL);
-	}
-}
-
-igt_main
-{
-	int devid = 0;
-
-	igt_fixture {
-		uint32_t bbe = MI_BATCH_BUFFER_END;
-		size_t reloc_size;
-
-		fd = drm_open_driver(DRIVER_INTEL);
-		igt_require_gem(fd);
-		devid = intel_get_drm_devid(fd);
-
-		/* Create giant reloc buffer area. */
-		num = 257;
-		entries = ((1ULL << 32) / (num - 1));
-		reloc_size = entries * sizeof(struct drm_i915_gem_relocation_entry);
-		igt_assert((reloc_size & 4095) == 0);
-		reloc = mmap(NULL, reloc_size + 2*4096, PROT_READ | PROT_WRITE,
-			     MAP_PRIVATE | MAP_ANON, -1, 0);
-		igt_assert(reloc != MAP_FAILED);
-		igt_require_f(mlock(reloc, reloc_size) == 0,
-			      "Tests require at least %'llu MiB of available memory\n",
-			      (long long unsigned)reloc_size / (1024*1024));
-
-		/* disable access before + after */
-		mprotect(reloc, 4096, 0);
-		reloc = (struct drm_i915_gem_relocation_entry *)((char *)reloc + 4096);
-		mprotect(reloc + entries, 4096, 0);
-
-		/* Allocate the handles we'll need to wrap. */
-		intel_require_memory(num+1, 4096, CHECK_RAM);
-		obj = calloc(num, sizeof(*obj));
-		igt_assert(obj);
-
-		/* First object is used for page crossing tests */
-		obj[0].handle = gem_create(fd, 8192);
-		gem_write(fd, obj[0].handle, 0, &bbe, sizeof(bbe));
-		for (int i = 1; i < num; i++) {
-			obj[i].handle = gem_create(fd, 4096);
-			gem_write(fd, obj[i].handle, 0, &bbe, sizeof(bbe));
-		}
-
-		/* Create relocation objects. */
-		memset(&execbuf, 0, sizeof(execbuf));
-		execbuf.buffers_ptr = to_user_pointer(obj);
-		execbuf.buffer_count = 1;
-		execbuf.flags = I915_EXEC_HANDLE_LUT;
-		if (__gem_execbuf(fd, &execbuf))
-			execbuf.flags = 0;
-
-		for (int i = 0; i < entries; i++) {
-			reloc[i].target_handle = target_handle();
-			reloc[i].offset = 1024;
-			reloc[i].read_domains = I915_GEM_DOMAIN_INSTRUCTION;
-			reloc[i].write_domain = 0;
-		}
-	}
-
-	reloc_tests("");
-	igt_fixture
-		igt_disable_prefault();
-	reloc_tests("-noprefault");
-	igt_fixture
-		igt_enable_prefault();
-
-	source_offset_tests(devid, false);
-	source_offset_tests(devid, true);
-
-	buffer_count_tests();
-}
diff --git a/tests/i915/gem_reloc_vs_gpu.c b/tests/i915/gem_reloc_vs_gpu.c
deleted file mode 100644
index ebc71a68c..000000000
--- a/tests/i915/gem_reloc_vs_gpu.c
+++ /dev/null
@@ -1,352 +0,0 @@
-/*
- * Copyright © 2011,2013 Intel Corporation
- *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and associated documentation files (the "Software"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- *
- * Authors:
- *    Daniel Vetter <daniel.vetter at ffwll.ch>
- *
- */
-
-#include "igt.h"
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <inttypes.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/time.h>
-#include <signal.h>
-#include <sys/wait.h>
-
-#include <drm.h>
-
-
-IGT_TEST_DESCRIPTION("Test kernel relocations vs. gpu races.");
-
-/*
- * Testcase: Kernel relocations vs. gpu races
- *
- */
-
-static drm_intel_bufmgr *bufmgr;
-struct intel_batchbuffer *batch;
-
-uint32_t blob[2048*2048];
-#define NUM_TARGET_BOS 16
-drm_intel_bo *pc_target_bo[NUM_TARGET_BOS];
-drm_intel_bo *dummy_bo;
-drm_intel_bo *special_bo;
-uint32_t devid;
-int special_reloc_ofs;
-int special_batch_len;
-
-static void create_special_bo(void)
-{
-	uint32_t data[1024];
-	int len = 0;
-	int small_pitch = 64;
-#define BATCH(dw) data[len++] = (dw);
-
-	memset(data, 0, 4096);
-	special_bo = drm_intel_bo_alloc(bufmgr, "special batch", 4096, 4096);
-
-	if (intel_gen(devid) >= 8) {
-		BATCH(MI_NOOP);
-		BATCH(XY_COLOR_BLT_CMD_NOLEN | 5 |
-				COLOR_BLT_WRITE_ALPHA | XY_COLOR_BLT_WRITE_RGB);
-	} else {
-		BATCH(XY_COLOR_BLT_CMD_NOLEN | 4 |
-				COLOR_BLT_WRITE_ALPHA | XY_COLOR_BLT_WRITE_RGB);
-	}
-
-	BATCH((3 << 24) | (0xf0 << 16) | small_pitch);
-	BATCH(0);
-	BATCH(1 << 16 | 1);
-	special_reloc_ofs = 4*len;
-	BATCH(0);
-	if (intel_gen(devid) >= 8)
-		BATCH(0);
-	BATCH(0xdeadbeef);
-
-#define CMD_POLY_STIPPLE_OFFSET       0x7906
-	/* batchbuffer end */
-	if (IS_GEN5(batch->devid)) {
-		BATCH(CMD_POLY_STIPPLE_OFFSET << 16);
-		BATCH(0);
-	}
-	igt_assert_eq(len % 2, 0);
-	BATCH(MI_NOOP);
-	BATCH(MI_BATCH_BUFFER_END);
-
-	drm_intel_bo_subdata(special_bo, 0, 4096, data);
-	special_batch_len = len*4;
-}
-
-static void emit_dummy_load(int pitch)
-{
-	int i;
-	uint32_t tile_flags = 0;
-
-	if (IS_965(devid)) {
-		pitch /= 4;
-		tile_flags = XY_SRC_COPY_BLT_SRC_TILED |
-			XY_SRC_COPY_BLT_DST_TILED;
-	}
-
-	for (i = 0; i < 10; i++) {
-		BLIT_COPY_BATCH_START(tile_flags);
-		OUT_BATCH((3 << 24) | /* 32 bits */
-			  (0xcc << 16) | /* copy ROP */
-			  pitch);
-		OUT_BATCH(0 << 16 | 1024);
-		OUT_BATCH((2048) << 16 | (2048));
-		OUT_RELOC_FENCED(dummy_bo, I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER, 0);
-		OUT_BATCH(0 << 16 | 0);
-		OUT_BATCH(pitch);
-		OUT_RELOC_FENCED(dummy_bo, I915_GEM_DOMAIN_RENDER, 0, 0);
-		ADVANCE_BATCH();
-
-		if (batch->gen >= 6) {
-			BEGIN_BATCH(3, 0);
-			OUT_BATCH(XY_SETUP_CLIP_BLT_CMD);
-			OUT_BATCH(0);
-			OUT_BATCH(0);
-			ADVANCE_BATCH();
-		}
-	}
-	intel_batchbuffer_flush(batch);
-}
-
-static void reloc_and_emit(int fd, drm_intel_bo *target_bo, bool faulting_reloc)
-{
-	struct drm_i915_gem_execbuffer2 execbuf;
-	struct drm_i915_gem_exec_object2 exec[2];
-	struct drm_i915_gem_relocation_entry reloc[1];
-	uint32_t handle_relocs;
-	void *gtt_relocs;
-
-	memset(&execbuf, 0, sizeof(execbuf));
-	memset(exec, 0, sizeof(exec));
-	memset(reloc, 0, sizeof(reloc));
-
-	exec[0].handle = target_bo->handle;
-
-	reloc[0].offset = special_reloc_ofs;
-	reloc[0].target_handle = target_bo->handle;
-	reloc[0].read_domains = I915_GEM_DOMAIN_RENDER;
-	reloc[0].write_domain = I915_GEM_DOMAIN_RENDER;
-	/* We do not track the last patched value, so force the relocation
-	 * every time.
-	 */
-	reloc[0].presumed_offset = -1;
-
-	handle_relocs = gem_create(fd, 4096);
-	gem_write(fd, handle_relocs, 0, reloc, sizeof(reloc));
-	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
-				   PROT_READ | PROT_WRITE);
-
-	exec[1].handle = special_bo->handle;
-	exec[1].relocation_count = 1;
-	/* A newly mmap gtt bo will fault on first access. */
-	if (faulting_reloc)
-		exec[1].relocs_ptr = to_user_pointer(gtt_relocs);
-	else
-		exec[1].relocs_ptr = to_user_pointer(reloc);
-
-	execbuf.buffers_ptr = to_user_pointer(exec);
-	execbuf.buffer_count = 2;
-	execbuf.batch_len = special_batch_len;
-	if (intel_gen(devid) >= 6)
-		execbuf.flags |= I915_EXEC_BLT;
-
-	gem_execbuf(fd, &execbuf);
-
-	gem_close(fd, handle_relocs);
-}
-
-static igt_hang_t no_hang(int fd)
-{
-	return (igt_hang_t){0};
-}
-
-static igt_hang_t bcs_hang(int fd)
-{
-	return igt_hang_ring(fd, I915_EXEC_BLT);
-}
-
-static void do_test(int fd, bool faulting_reloc,
-		    igt_hang_t (*do_hang)(int fd))
-{
-	uint32_t tiling_mode = I915_TILING_X;
-	unsigned long pitch, act_size;
-	uint32_t test;
-	int i;
-
-	if (faulting_reloc)
-		igt_disable_prefault();
-
-	act_size = 2048;
-	dummy_bo = drm_intel_bo_alloc_tiled(bufmgr, "tiled dummy_bo", act_size, act_size,
-				      4, &tiling_mode, &pitch, 0);
-
-	drm_intel_bo_subdata(dummy_bo, 0, act_size*act_size*4, blob);
-
-	create_special_bo();
-
-	for (i = 0; i < NUM_TARGET_BOS; i++) {
-		igt_hang_t hang;
-
-		pc_target_bo[i] = drm_intel_bo_alloc(bufmgr, "special batch", 4096, 4096);
-		emit_dummy_load(pitch);
-		igt_assert(pc_target_bo[i]->offset == 0);
-		hang = do_hang(fd);
-
-		reloc_and_emit(fd, pc_target_bo[i], faulting_reloc);
-
-		igt_post_hang_ring(fd, hang);
-	}
-
-	/* Only check at the end to avoid unnecessary synchronous behaviour. */
-	for (i = 0; i < NUM_TARGET_BOS; i++) {
-		drm_intel_bo_get_subdata(pc_target_bo[i], 0, 4, &test);
-		igt_assert_f(test == 0xdeadbeef,
-			     "mismatch in buffer %i: 0x%08x instead of 0xdeadbeef\n", i, test);
-		drm_intel_bo_unreference(pc_target_bo[i]);
-	}
-
-	drm_intel_gem_bo_map_gtt(dummy_bo);
-	drm_intel_gem_bo_unmap_gtt(dummy_bo);
-
-	drm_intel_bo_unreference(special_bo);
-	drm_intel_bo_unreference(dummy_bo);
-
-	if (faulting_reloc)
-		igt_enable_prefault();
-}
-
-#define INTERRUPT	(1 << 0)
-#define FAULTING	(1 << 1)
-#define THRASH		(1 << 2)
-#define THRASH_INACTIVE	(1 << 3)
-#define HANG		(1 << 4)
-#define ALL_FLAGS	(HANG | INTERRUPT | FAULTING | THRASH | THRASH_INACTIVE)
-static void do_forked_test(int fd, unsigned flags)
-{
-	int num_threads = sysconf(_SC_NPROCESSORS_ONLN);
-	struct igt_helper_process thrasher = {};
-
-	if (flags & HANG)
-		igt_require_hang_ring(fd, I915_EXEC_BLT);
-
-	if (flags & (THRASH | THRASH_INACTIVE)) {
-		igt_fork_helper(&thrasher) {
-			uint64_t val;
-
-			val = DROP_RETIRE | DROP_BOUND | DROP_UNBOUND;
-			if (!(flags & THRASH_INACTIVE))
-				val |= DROP_ACTIVE | DROP_SHRINK_ALL;
-
-			while (1) {
-				usleep(1000);
-				igt_drop_caches_set(fd, val);
-			}
-		}
-	}
-
-	igt_fork(i, num_threads * 4) {
-		/* re-create process local data */
-		fd = drm_open_driver(DRIVER_INTEL);
-		bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
-		batch = intel_batchbuffer_alloc(bufmgr, devid);
-
-		if (flags & INTERRUPT)
-			igt_fork_signal_helper();
-
-		do_test(fd, flags & FAULTING, flags & HANG ? bcs_hang : no_hang);
-
-		if (flags & INTERRUPT)
-			igt_stop_signal_helper();
-	}
-
-	igt_waitchildren();
-	if (flags & (THRASH | THRASH_INACTIVE))
-		igt_stop_helper(&thrasher);
-}
-
-int fd;
-
-#define MAX_BLT_SIZE 128
-igt_main
-{
-	memset(blob, 'A', sizeof(blob));
-
-	igt_fixture {
-		fd = drm_open_driver(DRIVER_INTEL);
-		igt_require_gem(fd);
-		gem_require_blitter(fd);
-		bufmgr = drm_intel_bufmgr_gem_init(fd, 4096);
-		/* disable reuse, otherwise the test fails */
-		//drm_intel_bufmgr_gem_enable_reuse(bufmgr);
-		devid = intel_get_drm_devid(fd);
-		batch = intel_batchbuffer_alloc(bufmgr, devid);
-	}
-
-	igt_subtest("normal")
-		do_test(fd, false, no_hang);
-
-	igt_subtest("faulting-reloc")
-		do_test(fd, true, no_hang);
-
-	igt_fork_signal_helper();
-	igt_subtest("interruptible")
-		do_test(fd, false, no_hang);
-
-	igt_subtest("interruptible-hang")
-		do_test(fd, false, bcs_hang);
-
-	igt_subtest("faulting-reloc-interruptible")
-		do_test(fd, true, no_hang);
-
-	igt_subtest("faulting-reloc-interruptible-hang")
-		do_test(fd, true, bcs_hang);
-	igt_stop_signal_helper();
-
-	for (unsigned flags = 0; flags <= ALL_FLAGS; flags++) {
-		if ((flags & THRASH) && (flags & THRASH_INACTIVE))
-			continue;
-
-		igt_subtest_f("forked%s%s%s%s%s",
-			      flags & INTERRUPT ? "-interruptible" : "",
-			      flags & FAULTING ? "-faulting-reloc" : "",
-			      flags & THRASH ? "-thrashing" : "",
-			      flags & THRASH_INACTIVE ? "-thrash-inactive" : "",
-			      flags & HANG ? "-hang": "")
-			do_forked_test(fd, flags);
-	}
-
-	igt_fixture {
-		intel_batchbuffer_free(batch);
-		drm_intel_bufmgr_destroy(bufmgr);
-
-		close(fd);
-	}
-}
diff --git a/tests/meson.build b/tests/meson.build
index 62783e2cf..bc10b6550 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -186,8 +186,6 @@ i915_progs = [
 	'gem_read_read_speed',
 	'gem_readwrite',
 	'gem_reg_read',
-	'gem_reloc_overflow',
-	'gem_reloc_vs_gpu',
 	'gem_render_copy',
 	'gem_render_copy_redux',
 	'gem_render_linear_blits',
-- 
2.25.0



More information about the Intel-gfx mailing list