Skip to contentSkip to conversation

s/gem_mmap/gem_mmap__gtt/

PATCH In review [email protected] 2 participants 8 messages Oct 9, 2015 Library code

lore
Share & tools
lore
#0 lore raw

PATCH 1/7 s/gem_mmap/gem_mmap__gtt/

From: Ville Syrjälä <[email protected]>

Get rid of the gem_mmap() alias of gem_mmap__gtt(). I don't see any point in having it.

---
 demos/intel_sprite_on.c            |  4 ++--
 lib/igt_fb.c                       |  2 +-
 lib/ioctl_wrappers.h               | 16 ----------------
 tests/drv_suspend.c                |  6 +++---
 tests/gem_exec_faulting_reloc.c    |  2 +-
 tests/gem_fence_thrash.c           |  2 +-
 tests/gem_fence_upload.c           |  6 +++---
 tests/gem_gtt_cpu_tlb.c            |  4 ++--
 tests/gem_gtt_hog.c                |  4 ++--
 tests/gem_gtt_speed.c              | 12 ++++++------
 tests/gem_madvise.c                |  4 ++--
 tests/gem_mmap_gtt.c               | 10 +++++-----
 tests/gem_mmap_offset_exhaustion.c |  2 +-
 tests/gem_persistent_relocs.c      |  2 +-
 tests/gem_reloc_overflow.c         |  2 +-
 tests/gem_reloc_vs_gpu.c           |  2 +-
 tests/gem_set_tiling_vs_gtt.c      |  2 +-
 tests/gem_set_tiling_vs_pwrite.c   |  2 +-
 tests/gem_tiled_pread_basic.c      |  2 +-
 tests/gem_tiled_pread_pwrite.c     |  4 ++--
 tests/gem_tiled_swapping.c         |  6 +++---
 tests/gem_tiling_max_stride.c      |  2 +-
 tests/gem_userptr_blits.c          |  2 +-
 tests/gen3_mixed_blits.c           |  4 ++--
 tests/gen3_render_mixed_blits.c    |  4 ++--
 tests/gen3_render_tiledx_blits.c   |  4 ++--
 tests/gen3_render_tiledy_blits.c   |  4 ++--
 tests/gen7_forcewake_mt.c          |  2 +-
 tests/prime_self_import.c          |  4 ++--
 tests/testdisplay.c                |  2 +-
 30 files changed, 54 insertions(+), 70 deletions(-)
demos/intel_sprite_on.c +2 -2
index 23fc56c..4083070 100644
@@ -359,7 +359,7 @@ static int prepare_primary_surface(int fd, int prim_width, int prim_height,
 	if (tiled)
 		gem_set_tiling(fd, *prim_handle, I915_TILING_X, *prim_stride);
 
-	prim_fb_ptr = gem_mmap(fd, *prim_handle, *prim_size, PROT_READ | PROT_WRITE);
+	prim_fb_ptr = gem_mmap__gtt(fd, *prim_handle, *prim_size, PROT_READ | PROT_WRITE);
 
 	if (prim_fb_ptr != NULL) {
 		// Write primary surface with gray background
@@ -454,7 +454,7 @@ static int prepare_sprite_surfaces(int fd, int sprite_width, int sprite_height,
 			gem_set_tiling(fd, sprite_handles[i], I915_TILING_X, *sprite_stride);
 
 		// Get pointer to the surface
-		sprite_fb_ptr = gem_mmap(fd,
+		sprite_fb_ptr = gem_mmap__gtt(fd,
 				sprite_handles[i], *sprite_size,
 				PROT_READ | PROT_WRITE);
 
lib/igt_fb.c +1 -1
index d04f02c..713bd50 100644
@@ -775,7 +775,7 @@ static void destroy_cairo_surface__gtt(void *arg)
 static void create_cairo_surface__gtt(int fd, struct igt_fb *fb)
 {
 	fb->cairo_surface =
-		cairo_image_surface_create_for_data(gem_mmap(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE),
+		cairo_image_surface_create_for_data(gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE),
 						    drm_format_to_cairo(fb->drm_format),
 						    fb->width, fb->height, fb->stride);
 
lib/ioctl_wrappers.h +0 -16
index f4deca6..7c607a2 100644
@@ -76,22 +76,6 @@ void *gem_mmap__wc(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsi
  */
 #define gem_require_mmap_wc(fd) igt_require(gem_mmap__has_wc(fd))
 
-/**
- * gem_mmap:
- * @fd: open i915 drm file descriptor
- * @handle: gem buffer object handle
- * @size: size of the gem buffer
- * @prot: memory protection bits as used by mmap()
- *
- * This functions wraps up procedure to establish a memory mapping through the
- * GTT.
- *
- * This is a simple convenience alias to gem_mmap__gtt()
- *
- * Returns: A pointer to the created memory mapping.
- */
-#define gem_mmap(fd, handle, size, prot) gem_mmap__gtt(fd, handle, size, prot)
-
 int gem_madvise(int fd, uint32_t handle, int state);
 
 uint32_t gem_context_create(int fd);
tests/drv_suspend.c +3 -3
index c8af46b..4014241 100644
@@ -56,19 +56,19 @@ test_fence_restore(int fd, bool tiled2untiled, bool hibernate)
 	handle_tiled = gem_create(fd, OBJECT_SIZE);
 
 	/* Access the buffer objects in the order we want to have the laid out. */
-	ptr1 = gem_mmap(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr1 = gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr1 != MAP_FAILED);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr1[i] = i;
 
-	ptr_tiled = gem_mmap(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr_tiled = gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr_tiled != MAP_FAILED);
 	if (tiled2untiled)
 		gem_set_tiling(fd, handle_tiled, I915_TILING_X, 2048);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr_tiled[i] = i;
 
-	ptr2 = gem_mmap(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr2 = gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr2 != MAP_FAILED);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr2[i] = i;
tests/gem_exec_faulting_reloc.c +1 -1
index 623b7e5..e16b580 100644
@@ -200,7 +200,7 @@ static void run(int object_size)
 
 	handle_relocs = gem_create(fd, 4096);
 	gem_write(fd, handle_relocs, 0, reloc, sizeof(reloc));
-	gtt_relocs = gem_mmap(fd, handle_relocs, 4096,
+	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
 			      PROT_READ | PROT_WRITE);
 	igt_assert(gtt_relocs);
 
tests/gem_fence_thrash.c +1 -1
index 6f3d768..1b828b8 100644
@@ -74,7 +74,7 @@ bo_create (int fd, int tiling)
 
 	gem_set_tiling(fd, handle, tiling, 1024);
 
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
tests/gem_fence_upload.c +3 -3
index ab13925..047b783 100644
@@ -68,7 +68,7 @@ static void performance(void)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = gem_mmap(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
+			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 			igt_assert(ptr[n]);
 		}
 
@@ -176,7 +176,7 @@ static void thread_performance(unsigned mask)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = gem_mmap(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
+			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 			igt_assert(ptr[n]);
 
 			if (mask & READ) {
@@ -257,7 +257,7 @@ static void *no_contention(void *closure)
 	int n;
 
 	for (n = 0; n < t->loops; n++) {
-		uint32_t *ptr = gem_mmap(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		uint32_t *ptr = gem_mmap__gtt(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(ptr);
 		memset(ptr + (rand() % 256) * 4096 / 4, 0, 4096);
 		munmap(ptr, OBJECT_SIZE);
tests/gem_gtt_cpu_tlb.c +2 -2
index 027d5cf..8ceef44 100644
@@ -59,7 +59,7 @@ create_bo(int fd)
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	data = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < OBJ_SIZE/4; i++)
 		data[i] = i;
 	munmap(data, OBJ_SIZE);
@@ -82,7 +82,7 @@ igt_simple_main
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* touch one page */
-	ptr = gem_mmap(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	*ptr = 0xdeadbeef;
 	munmap(ptr, OBJ_SIZE);
 
tests/gem_gtt_hog.c +2 -2
index 43cb0fb..b0673a4 100644
@@ -140,10 +140,10 @@ static void run(data_t *data, int child)
 	 * set-to-gtt-domain within the fault handler.
 	 */
 	if (write) {
-		ptr = gem_mmap(data->fd, handle, size, PROT_READ | PROT_WRITE);
+		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ | PROT_WRITE);
 		ptr[rand() % (size / 4)] = canary;
 	} else
-		ptr = gem_mmap(data->fd, handle, size, PROT_READ);
+		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ);
 	x = ptr[rand() % (size / 4)];
 	munmap(ptr, size);
 
tests/gem_gtt_speed.c +6 -6
index e71da84..bcca1f4 100644
@@ -174,7 +174,7 @@ int main(int argc, char **argv)
 
 		/* prefault into gtt */
 		{
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
@@ -189,7 +189,7 @@ int main(int argc, char **argv)
 		/* mmap read */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
@@ -229,7 +229,7 @@ int main(int argc, char **argv)
 		/* mmap write */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 
 			for (i = 0; i < size/sizeof(*ptr); i++)
@@ -261,7 +261,7 @@ int main(int argc, char **argv)
 		/* mmap clear */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			memset(base, 0, size);
 			munmap(base, size);
 		}
@@ -283,7 +283,7 @@ int main(int argc, char **argv)
 		}
 
 		gettimeofday(&start, NULL);{
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			for (loop = 0; loop < 1000; loop++)
 				memset(base, 0, size);
 			munmap(base, size);
@@ -305,7 +305,7 @@ int main(int argc, char **argv)
 		/* mmap read */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
tests/gem_madvise.c +2 -2
index a991ea3..359f490 100644
@@ -63,7 +63,7 @@ dontneed_before_mmap(void)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 	gem_madvise(fd, handle, I915_MADV_DONTNEED);
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr == NULL);
 	igt_assert(errno == EFAULT);
 	close(fd);
@@ -77,7 +77,7 @@ dontneed_after_mmap(void)
 	char *ptr;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr != NULL);
 	gem_madvise(fd, handle, I915_MADV_DONTNEED);
 	close(fd);
tests/gem_mmap_gtt.c +5 -5
index 8c26c22..1624a6b 100644
@@ -56,7 +56,7 @@ mmap_bo(int fd, uint32_t handle)
 {
 	void *ptr;
 
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr != MAP_FAILED);
 
 	return ptr;
@@ -179,7 +179,7 @@ test_read_write(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr != MAP_FAILED);
 
 	if (order == READ_BEFORE_WRITE) {
@@ -203,10 +203,10 @@ test_read_write2(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	r = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ);
+	r = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 	igt_assert(r != MAP_FAILED);
 
-	w = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	w = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(w != MAP_FAILED);
 
 	if (order == READ_BEFORE_WRITE) {
@@ -440,7 +440,7 @@ test_write_cpu_read_gtt(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	dst = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ);
+	dst = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst != (uint32_t *)MAP_FAILED);
 
 	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
tests/gem_mmap_offset_exhaustion.c +1 -1
index 6c51762..3ce60f3 100644
@@ -60,7 +60,7 @@ create_and_map_bo(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	/* touch it to force it into the gtt */
tests/gem_persistent_relocs.c +1 -1
index 9867652..57024fc 100644
@@ -225,7 +225,7 @@ static void do_test(int fd, bool faulting_reloc)
 
 		relocs_bo_handle[i] = gem_create(fd, 4096);
 		gem_write(fd, relocs_bo_handle[i], 0, reloc, sizeof(reloc));
-		gtt_relocs_ptr[i] = gem_mmap(fd, relocs_bo_handle[i], 4096,
+		gtt_relocs_ptr[i] = gem_mmap__gtt(fd, relocs_bo_handle[i], 4096,
 				      PROT_READ | PROT_WRITE);
 		igt_assert(gtt_relocs_ptr[i]);
 
tests/gem_reloc_overflow.c +1 -1
index 304e3d8..5d794cd 100644
@@ -85,7 +85,7 @@ static void source_offset_tests(int devid, bool reloc_gtt)
 		execbuf.buffer_count = 2;
 
 		if (reloc_gtt) {
-			dst_gtt = gem_mmap(fd, handle, 8192, PROT_READ | PROT_WRITE);
+			dst_gtt = gem_mmap__gtt(fd, handle, 8192, PROT_READ | PROT_WRITE);
 			igt_assert(dst_gtt != MAP_FAILED);
 			gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 			memset(dst_gtt, 0, 8192);
tests/gem_reloc_vs_gpu.c +1 -1
index bfd9367..e31928e 100644
@@ -162,7 +162,7 @@ static void reloc_and_emit(int fd, drm_intel_bo *target_bo, bool faulting_reloc)
 
 	handle_relocs = gem_create(fd, 4096);
 	gem_write(fd, handle_relocs, 0, reloc, sizeof(reloc));
-	gtt_relocs = gem_mmap(fd, handle_relocs, 4096,
+	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
 			      PROT_READ | PROT_WRITE);
 	igt_assert(gtt_relocs);
 
tests/gem_set_tiling_vs_gtt.c +1 -1
index 487556a..619bd1d 100644
@@ -66,7 +66,7 @@ igt_simple_main
 		tile_height = 8;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	/* gtt coherency is done with set_domain in libdrm, don't break that */
tests/gem_set_tiling_vs_pwrite.c +1 -1
index 9b2263a..ed6d763 100644
@@ -62,7 +62,7 @@ igt_simple_main
 		data[i] = i;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	gem_set_tiling(fd, handle, I915_TILING_X, TEST_STRIDE);
tests/gem_tiled_pread_basic.c +1 -1
index 421e35e..407808b 100644
@@ -72,7 +72,7 @@ create_bo(int fd)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
tests/gem_tiled_pread_pwrite.c +2 -2
index ff27e04..c952ce7 100644
@@ -79,7 +79,7 @@ create_bo_and_fill(int fd)
 	gem_set_tiling(fd, handle, current_tiling_mode, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
@@ -122,7 +122,7 @@ igt_simple_main
 		gem_write(fd, handle_target, 0, linear, sizeof(linear));
 
 		/* Check the target bo's contents. */
-		data = gem_mmap(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
+		data = gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
 		for (j = 0; j < WIDTH*HEIGHT; j++)
 			igt_assert_f(data[j] == j,
 				     "mismatch at %i: %i\n",
tests/gem_tiled_swapping.c +3 -3
index d232aee..b50fa7f 100644
@@ -78,7 +78,7 @@ create_bo(int fd)
 	handle = gem_create(fd, LINEAR_DWORDS);
 	gem_set_tiling(fd, handle, current_tiling_mode, WIDTH * sizeof(uint32_t));
 
-	data = gem_mmap(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
+	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
 	if (data == NULL) {
 		gem_close(fd, handle);
 		return 0;
@@ -94,7 +94,7 @@ fill_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int i;
 
-	data = gem_mmap(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
+	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
 	igt_assert(data);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
@@ -109,7 +109,7 @@ check_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int j;
 
-	data = gem_mmap(fd, handle, LINEAR_DWORDS, PROT_READ);
+	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
 	j = rand() % (WIDTH * HEIGHT);
 	igt_assert_f(data[j] == j, "mismatch at %i: %i\n", j, data[j]);
tests/gem_tiling_max_stride.c +1 -1
index 62fa4fe..02c4ed2 100644
@@ -97,7 +97,7 @@ igt_simple_main
 
 	handle = gem_create(fd, size);
 
-	ptr = gem_mmap(fd, handle, size, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	test_invalid_tiling(fd, handle, 0);
tests/gem_userptr_blits.c +1 -1
index c9e35ed..d161b6c 100644
@@ -688,7 +688,7 @@ static void *umap(int fd, uint32_t handle)
 	void *ptr;
 
 	if (gem_has_llc(fd)) {
-		ptr = gem_mmap(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+		ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	} else {
 		uint32_t tmp = gem_create(fd, sizeof(linear));
 		copy(fd, tmp, handle, 0);
tests/gen3_mixed_blits.c +2 -2
index 40a1f0a..40b8e1e 100644
@@ -426,7 +426,7 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -441,7 +441,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_mixed_blits.c +2 -2
index c03cb3b..cc2757b 100644
@@ -314,7 +314,7 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -329,7 +329,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_tiledx_blits.c +2 -2
index eb6c4ea..9a243d8 100644
@@ -301,7 +301,7 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -316,7 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_tiledy_blits.c +2 -2
index e3e0abf..11fb002 100644
@@ -301,7 +301,7 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_Y, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -316,7 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen7_forcewake_mt.c +1 -1
index 4cf0902..dea1e8a 100644
@@ -190,7 +190,7 @@ igt_simple_main
 		gem_execbuf(t[0].fd, &execbuf);
 		gem_sync(t[0].fd, exec[1].handle);
 
-		p = gem_mmap(t[0].fd, exec[0].handle, 4096, PROT_READ);
+		p = gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
 
 		igt_info("[%d]={ %08x %08x }\n", i, p[0], p[1]);
 		igt_assert(p[0] & 2);
tests/prime_self_import.c +2 -2
index 6c09cb0..eb9ab06 100644
@@ -60,8 +60,8 @@ check_bo(int fd1, uint32_t handle1, int fd2, uint32_t handle2)
 	char *ptr1, *ptr2;
 	int i;
 
-	ptr1 = gem_mmap(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
-	ptr2 = gem_mmap(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
+	ptr1 = gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
+	ptr2 = gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
 
 	igt_assert(ptr1);
 
tests/testdisplay.c +1 -1
index 5f7ab1d..af2c5b5 100644
@@ -221,7 +221,7 @@ paint_color_key(struct igt_fb *fb_info)
 	int i, j;
 	uint32_t *fb_ptr;
 
-	fb_ptr = gem_mmap(drm_fd, fb_info->gem_handle,
+	fb_ptr = gem_mmap__gtt(drm_fd, fb_info->gem_handle,
 			  fb_info->size, PROT_READ | PROT_WRITE);
 	igt_assert(fb_ptr);
 
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#1 lore raw

PATCH 2/7 lib: Document that gem_mmap__{cpu, gtt, wc} return NULL on failure

From: Ville Syrjälä <[email protected]>

---
 lib/ioctl_wrappers.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/ioctl_wrappers.c +3 -3
index 80e1ec6..eb745bc 100644
@@ -456,7 +456,7 @@ void gem_execbuf(int fd, struct drm_i915_gem_execbuffer2 *execbuf)
  * This functions wraps up procedure to establish a memory mapping through the
  * GTT.
  *
- * Returns: A pointer to the created memory mapping.
+ * Returns: A pointer to the created memory mapping, NULL on failure.
  */
 void *gem_mmap__gtt(int fd, uint32_t handle, uint64_t size, unsigned prot)
 {
@@ -535,7 +535,7 @@ bool gem_mmap__has_wc(int fd)
  * bypassing the GTT system agent (i.e. there is no automatic tiling of
  * the mmapping through the fence registers).
  *
- * Returns: A pointer to the created memory mapping.
+ * Returns: A pointer to the created memory mapping, NULL on failure.
  */
 void *gem_mmap__wc(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsigned prot)
 {
@@ -569,7 +569,7 @@ void *gem_mmap__wc(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsi
  * This functions wraps up procedure to establish a memory mapping through
  * direct cpu access, bypassing the gpu completely.
  *
- * Returns: A pointer to the created memory mapping.
+ * Returns: A pointer to the created memory mapping, NULL on failure.
  */
 void *gem_mmap__cpu(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsigned prot)
 {
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#2 lore raw

PATCH 3/7 Remove gem_mmap__{cpu, gtt, wc} return value MAP_FAILED asserts

In reply to [email protected]

From: Ville Syrjälä <[email protected]>

gem_mmap__{cpu,gtt,wc} never return MAP_FAILED, it gets converted to NULL internally. So don't go asserting that the returned value is not MAP_FAILED.

Done with coccinelle:
@@
type T;
identifier I;
@@
(
I = gem_mmap__gtt(...);
|
I = gem_mmap__cpu(...);
|
I = gem_mmap__wc(...);
)
...
(
- igt_assert(I != MAP_FAILED);
+ igt_assert(I);
|
- igt_assert(I && I != MAP_FAILED);
+ igt_assert(I);
|
- igt_assert(I != (T *) MAP_FAILED);
+ igt_assert(I);
|
- igt_assert(I != NULL);
+ igt_assert(I);
)

---
 tests/drv_suspend.c        |  6 +++---
 tests/gem_concurrent_all.c | 12 ++++++------
 tests/gem_madvise.c        |  2 +-
 tests/gem_mmap_gtt.c       | 12 ++++++------
 tests/gem_mmap_wc.c        | 14 +++++++-------
 tests/gem_userptr_blits.c  |  2 +-
 6 files changed, 24 insertions(+), 24 deletions(-)
tests/drv_suspend.c +3 -3
index 4014241..4e84d1c 100644
@@ -57,19 +57,19 @@ test_fence_restore(int fd, bool tiled2untiled, bool hibernate)
 
 	/* Access the buffer objects in the order we want to have the laid out. */
 	ptr1 = gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr1 != MAP_FAILED);
+	igt_assert(ptr1);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr1[i] = i;
 
 	ptr_tiled = gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr_tiled != MAP_FAILED);
+	igt_assert(ptr_tiled);
 	if (tiled2untiled)
 		gem_set_tiling(fd, handle_tiled, I915_TILING_X, 2048);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr_tiled[i] = i;
 
 	ptr2 = gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr2 != MAP_FAILED);
+	igt_assert(ptr2);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr2[i] = i;
 
tests/gem_concurrent_all.c +6 -6
index 167f383..6efb977 100644
@@ -472,9 +472,9 @@ static void cpu_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_CPU, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 	s = gem_mmap__cpu(fd, src->handle, 0, size, PROT_READ);
-	igt_assert(s != NULL);
+	igt_assert(s);
 	d = gem_mmap__cpu(fd, dst->handle, 0, size, PROT_WRITE);
-	igt_assert(d != NULL);
+	igt_assert(d);
 
 	memcpy(d, s, size);
 
@@ -491,9 +491,9 @@ static void gtt_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
 	s = gem_mmap__gtt(fd, src->handle, size, PROT_READ);
-	igt_assert(s != NULL);
+	igt_assert(s);
 	d = gem_mmap__gtt(fd, dst->handle, size, PROT_WRITE);
-	igt_assert(d != NULL);
+	igt_assert(d);
 
 	memcpy(d, s, size);
 
@@ -510,9 +510,9 @@ static void wc_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
 	s = gem_mmap__wc(fd, src->handle, 0, size, PROT_READ);
-	igt_assert(s != NULL);
+	igt_assert(s);
 	d = gem_mmap__wc(fd, dst->handle, 0, size, PROT_WRITE);
-	igt_assert(d != NULL);
+	igt_assert(d);
 
 	memcpy(d, s, size);
 
tests/gem_madvise.c +1 -1
index 359f490..d0f378e 100644
@@ -78,7 +78,7 @@ dontneed_after_mmap(void)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr != NULL);
+	igt_assert(ptr);
 	gem_madvise(fd, handle, I915_MADV_DONTNEED);
 	close(fd);
 
tests/gem_mmap_gtt.c +6 -6
index 1624a6b..5b782c9 100644
@@ -57,7 +57,7 @@ mmap_bo(int fd, uint32_t handle)
 	void *ptr;
 
 	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr != MAP_FAILED);
+	igt_assert(ptr);
 
 	return ptr;
 }
@@ -180,7 +180,7 @@ test_read_write(int fd, enum test_read_write order)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr != MAP_FAILED);
+	igt_assert(ptr);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)ptr;
@@ -204,10 +204,10 @@ test_read_write2(int fd, enum test_read_write order)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	r = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
-	igt_assert(r != MAP_FAILED);
+	igt_assert(r);
 
 	w = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(w != MAP_FAILED);
+	igt_assert(w);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)r;
@@ -441,10 +441,10 @@ test_write_cpu_read_gtt(int fd)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	dst = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst != (uint32_t *)MAP_FAILED);
+	igt_assert(dst);
 
 	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src != (uint32_t *)MAP_FAILED);
+	igt_assert(src);
 
 	gem_close(fd, handle);
 
tests/gem_mmap_wc.c +7 -7
index e312805..11463ca 100644
@@ -63,7 +63,7 @@ mmap_bo(int fd, uint32_t handle)
 	void *ptr;
 
 	ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr && ptr != MAP_FAILED);
+	igt_assert(ptr);
 
 	return ptr;
 }
@@ -184,10 +184,10 @@ test_read_write2(int fd, enum test_read_write order)
 	set_domain(fd, handle);
 
 	r = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(r != MAP_FAILED);
+	igt_assert(r);
 
 	w = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(w != MAP_FAILED);
+	igt_assert(w);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)r;
@@ -289,10 +289,10 @@ test_write_cpu_read_wc(int fd, int force_domain)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst != (uint32_t *)MAP_FAILED);
+	igt_assert(dst);
 
 	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src != (uint32_t *)MAP_FAILED);
+	igt_assert(src);
 
 	memset(src, 0xaa, OBJECT_SIZE);
 	if (force_domain)
@@ -316,10 +316,10 @@ test_write_gtt_read_wc(int fd)
 	set_domain(fd, handle);
 
 	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst != (uint32_t *)MAP_FAILED);
+	igt_assert(dst);
 
 	src = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src != (uint32_t *)MAP_FAILED);
+	igt_assert(src);
 
 	memset(src, 0xaa, OBJECT_SIZE);
 	igt_assert(memcmp(dst, src, OBJECT_SIZE) == 0);
tests/gem_userptr_blits.c +1 -1
index d161b6c..6fff3a9 100644
@@ -546,7 +546,7 @@ static int test_invalid_gtt_mapping(int fd)
 	handle = create_bo(fd, 0);
 	ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	gem_close(fd, handle);
-	igt_assert(ptr != NULL);
+	igt_assert(ptr);
 	igt_assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
 	igt_assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0);
 
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#3 lore raw

PATCH 4/7 Sprinkle igt_assert(ptr) after gem_mmap__{cpu, gtt, wc}

In reply to [email protected]

From: Ville Syrjälä <[email protected]>

Do the following
ptr = gem_mmap__{cpu,gtt,wc}()
+igt_assert(ptr);

whenever the code doesn't handle the NULL ptr in any kind of specific way.

Makes it easier to move the assert into gem_mmap__{cpu,gtt,wc}() itself.

Mostly done with coccinelle, with some manual cleanups:
@@
identifier I;
@@
<... when != igt_assert(I)

     when != igt_require(I)
     when != igt_require_f(I, ...)
     when != I != NULL
     when != I == NULL

(
I = gem_mmap__gtt(...);
+ igt_assert(I);
|
I = gem_mmap__cpu(...);
+ igt_assert(I);
|
I = gem_mmap__wc(...);
+ igt_assert(I);
)
...>

---
 benchmarks/gem_blt.c           |  1 +
 benchmarks/gem_mmap.c          |  3 +++
 tests/gem_cs_tlb.c             |  1 +
 tests/gem_exec_lut_handle.c    |  1 +
 tests/gem_gtt_cpu_tlb.c        |  2 ++
 tests/gem_gtt_hog.c            |  5 ++++-
 tests/gem_gtt_speed.c          | 18 ++++++++++++++++++
 tests/gem_largeobject.c        |  1 +
 tests/gem_mmap.c               |  1 +
 tests/gem_pwrite_pread.c       |  8 ++++++++
 tests/gem_streaming_writes.c   |  8 ++++++--
 tests/gem_tiled_pread_basic.c  |  1 +
 tests/gem_tiled_pread_pwrite.c |  2 ++
 tests/gem_tiled_swapping.c     |  1 +
 tests/gem_tiled_wb.c           |  1 +
 tests/gem_tiled_wc.c           |  1 +
 tests/gem_userptr_blits.c      |  2 ++
 tests/gen7_forcewake_mt.c      |  1 +
 tests/kms_fbc_crc.c            |  2 ++
 tests/kms_fence_pin_leak.c     |  1 +
 tests/kms_psr_sink_crc.c       |  3 +++
 tests/pm_rpm.c                 | 18 ++++++++++++++----
 tests/prime_self_import.c      |  4 ++--
 23 files changed, 77 insertions(+), 9 deletions(-)
benchmarks/gem_blt.c +1 -0
index 181a5f1..3ed2300 100644
@@ -178,6 +178,7 @@ static int run(int object, int batch, int count, int reps)
 	fd = drm_open_driver(DRIVER_INTEL);
 	handle = gem_create(fd, size);
 	buf = gem_mmap__cpu(fd, handle, 0, size, PROT_WRITE);
+	igt_assert(buf);
 
 	gen = intel_gen(intel_get_drm_devid(fd));
 	has_64bit_reloc = gen >= 8;
benchmarks/gem_mmap.c +3 -0
index bc26d31..6bf7fd3 100644
@@ -116,14 +116,17 @@ int main(int argc, char **argv)
 	switch (map) {
 	case CPU:
 		ptr = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 		break;
 	case GTT:
 		ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
 	case WC:
 		ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
 	default:
tests/gem_cs_tlb.c +1 -0
index 8b640fa..a647ddf 100644
@@ -117,6 +117,7 @@ static void run_on_ring(int fd, unsigned ring_id, const char *ring_name)
 		handle_new = gem_create(fd, BATCH_SIZE);
 		batch_ptr = gem_mmap__cpu(fd, handle_new, 0, BATCH_SIZE,
 					  PROT_READ | PROT_WRITE);
+		igt_assert(batch_ptr);
 		batch_ptr[split*2] = MI_BATCH_BUFFER_END;
 
 		for (i = split*2 + 2; i < BATCH_SIZE/8; i++)
tests/gem_exec_lut_handle.c +1 -0
index 875fea2..282fccf 100644
@@ -124,6 +124,7 @@ igt_simple_main
 	size = ALIGN(sizeof(mem_reloc), 4096);
 	reloc_handle = gem_create(fd, size);
 	reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+	igt_assert(reloc);
 	for (n = 0; n < MAX_NUM_RELOC; n++) {
 		reloc[n].offset = 1024;
 		reloc[n].read_domains = I915_GEM_DOMAIN_RENDER;
tests/gem_gtt_cpu_tlb.c +2 -0
index 8ceef44..75c3d04 100644
@@ -60,6 +60,7 @@ create_bo(int fd)
 
 	/* Fill the BO with dwords starting at start_val */
 	data = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(data);
 	for (i = 0; i < OBJ_SIZE/4; i++)
 		data[i] = i;
 	munmap(data, OBJ_SIZE);
@@ -83,6 +84,7 @@ igt_simple_main
 
 	/* touch one page */
 	ptr = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(ptr);
 	*ptr = 0xdeadbeef;
 	munmap(ptr, OBJ_SIZE);
 
tests/gem_gtt_hog.c +4 -1
index b0673a4..cbb7016 100644
@@ -141,9 +141,12 @@ static void run(data_t *data, int child)
 	 */
 	if (write) {
 		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ | PROT_WRITE);
+		igt_assert(ptr);
 		ptr[rand() % (size / 4)] = canary;
-	} else
+	} else {
 		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ);
+		igt_assert(ptr);
+	}
 	x = ptr[rand() % (size / 4)];
 	munmap(ptr, size);
 
tests/gem_gtt_speed.c +18 -0
index bcca1f4..ed45bba 100644
@@ -93,6 +93,8 @@ int main(int argc, char **argv)
 				volatile uint32_t *ptr = base;
 				int x = 0;
 
+				igt_assert(base);
+
 				for (i = 0; i < size/sizeof(*ptr); i++)
 					x += ptr[i];
 
@@ -108,6 +110,8 @@ int main(int argc, char **argv)
 					ptr = base;
 					x = 0;
 
+					igt_assert(base);
+
 					for (i = 0; i < size/sizeof(*ptr); i++)
 						x += ptr[i];
 
@@ -126,6 +130,8 @@ int main(int argc, char **argv)
 					base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 					ptr = base;
 
+					igt_assert(base);
+
 					for (i = 0; i < size/sizeof(*ptr); i++)
 						ptr[i] = i;
 
@@ -138,6 +144,7 @@ int main(int argc, char **argv)
 				gettimeofday(&start, NULL);
 				for (loop = 0; loop < 1000; loop++) {
 					base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+					igt_assert(base);
 					memset(base, 0, size);
 					munmap(base, size);
 				}
@@ -147,6 +154,7 @@ int main(int argc, char **argv)
 
 				gettimeofday(&start, NULL);
 				base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				igt_assert(base);
 				for (loop = 0; loop < 1000; loop++)
 					memset(base, 0, size);
 				munmap(base, size);
@@ -178,6 +186,8 @@ int main(int argc, char **argv)
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
+			igt_assert(base);
+
 			for (i = 0; i < size/sizeof(*ptr); i++)
 				x += ptr[i];
 
@@ -193,6 +203,8 @@ int main(int argc, char **argv)
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
+			igt_assert(base);
+
 			for (i = 0; i < size/sizeof(*ptr); i++)
 				x += ptr[i];
 
@@ -212,6 +224,8 @@ int main(int argc, char **argv)
 				volatile uint32_t *ptr = base;
 				int x = 0;
 
+				igt_assert(base);
+
 				for (i = 0; i < size/sizeof(*ptr); i++)
 					x += ptr[i];
 
@@ -232,6 +246,8 @@ int main(int argc, char **argv)
 			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 
+			igt_assert(base);
+
 			for (i = 0; i < size/sizeof(*ptr); i++)
 				ptr[i] = i;
 
@@ -248,6 +264,8 @@ int main(int argc, char **argv)
 				uint32_t *base = gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				volatile uint32_t *ptr = base;
 
+				igt_assert(base);
+
 				for (i = 0; i < size/sizeof(*ptr); i++)
 					ptr[i] = i;
 
tests/gem_largeobject.c +1 -0
index 2f0ec93..d261939 100644
@@ -65,6 +65,7 @@ test_large_object(int fd)
 
 	/* prefault */
 	ptr = gem_mmap__gtt(fd, create.handle, obj_size, PROT_WRITE | PROT_READ);
+	igt_assert(ptr);
 	*ptr = 0;
 
 	gem_write(fd, create.handle, 0, data, obj_size);
tests/gem_mmap.c +1 -0
index 49e7259..4188429 100644
@@ -167,6 +167,7 @@ igt_main
 		igt_assert(OBJECT_SIZE > 4096);
 		arg.handle = gem_create(fd, OBJECT_SIZE);
 		addr = gem_mmap__cpu(fd, arg.handle, 0, 4096, PROT_WRITE);
+		igt_assert(addr);
 		memset(addr, 0, 4096);
 		munmap(addr, 4096);
 		gem_close(fd, arg.handle);
tests/gem_pwrite_pread.c +8 -0
index ef8890e..1e8f5be 100644
@@ -113,7 +113,9 @@ static void as_gtt_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	BUILD_EXEC;
 
 	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	igt_assert(src_ptr);
 	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
+	igt_assert(dst_ptr);
 
 	while (loops--) {
 		gem_set_domain(fd, src,
@@ -138,7 +140,9 @@ static void as_cpu_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	BUILD_EXEC;
 
 	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	igt_assert(src_ptr);
 	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	igt_assert(dst_ptr);
 
 	while (loops--) {
 		gem_set_domain(fd, src,
@@ -183,7 +187,9 @@ static void test_as_gtt_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	BUILD_EXEC;
 
 	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	igt_assert(src_ptr);
 	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
+	igt_assert(dst_ptr);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 	for (i = 0; i < len/4; i++)
@@ -207,7 +213,9 @@ static void test_as_cpu_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	BUILD_EXEC;
 
 	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	igt_assert(src_ptr);
 	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	igt_assert(dst_ptr);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 	for (i = 0; i < len/4; i++)
tests/gem_streaming_writes.c +6 -2
index 39cb88d..3f7ed95 100644
@@ -89,15 +89,17 @@ static void test_streaming(int fd, int mode, int sync)
 	case 0: /* cpu/snoop */
 		gem_set_caching(fd, src, I915_CACHING_CACHED);
 		s = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		igt_assert(s);
 		break;
 	case 1: /* gtt */
 		s = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		igt_assert(s);
 		break;
 	case 2: /* wc */
 		s = gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		igt_assert(s);
 		break;
 	}
-	igt_assert(s);
 	*s = 0; /* fault the object into the mappable range first (for GTT) */
 
 	d = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
@@ -284,15 +286,17 @@ static void test_batch(int fd, int mode, int reverse)
 	case 0: /* cpu/snoop */
 		igt_require(gem_has_llc(fd));
 		base = gem_mmap__cpu(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
+		igt_assert(base);
 		break;
 	case 1: /* gtt */
 		base = gem_mmap__gtt(fd, exec[BATCH].handle, batch_size, PROT_READ | PROT_WRITE);
+		igt_assert(base);
 		break;
 	case 2: /* wc */
 		base = gem_mmap__wc(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
+		igt_assert(base);
 		break;
 	}
-	igt_assert(base);
 	*base = 0; /* fault the object into the mappable range first */
 
 	gem_write(fd, exec[BATCH].handle, 0, tmp, sizeof(tmp));
tests/gem_tiled_pread_basic.c +1 -0
index 407808b..e1844b0 100644
@@ -73,6 +73,7 @@ create_bo(int fd)
 
 	/* Fill the BO with dwords starting at start_val */
 	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
tests/gem_tiled_pread_pwrite.c +2 -0
index c952ce7..6e048db 100644
@@ -80,6 +80,7 @@ create_bo_and_fill(int fd)
 
 	/* Fill the BO with dwords starting at start_val */
 	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
@@ -123,6 +124,7 @@ igt_simple_main
 
 		/* Check the target bo's contents. */
 		data = gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
+		igt_assert(data);
 		for (j = 0; j < WIDTH*HEIGHT; j++)
 			igt_assert_f(data[j] == j,
 				     "mismatch at %i: %i\n",
tests/gem_tiled_swapping.c +1 -0
index b50fa7f..a66523b 100644
@@ -110,6 +110,7 @@ check_bo(int fd, uint32_t handle)
 	int j;
 
 	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
+	igt_assert(data);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
 	j = rand() % (WIDTH * HEIGHT);
 	igt_assert_f(data[j] == j, "mismatch at %i: %i\n", j, data[j]);
tests/gem_tiled_wb.c +1 -0
index f52588d..654628e 100644
@@ -72,6 +72,7 @@ create_bo(int fd)
 	 * We then manually detile on reading back through the mmap(wc).
 	 */
 	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, SIZE);
tests/gem_tiled_wc.c +1 -0
index 0f74223..3eee796 100644
@@ -66,6 +66,7 @@ create_bo(int fd)
 
 	/* Fill the BO with dwords starting at start_val */
 	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, SIZE);
tests/gem_userptr_blits.c +2 -0
index 6fff3a9..e6830f6 100644
@@ -689,10 +689,12 @@ static void *umap(int fd, uint32_t handle)
 
 	if (gem_has_llc(fd)) {
 		ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+		igt_assert(ptr);
 	} else {
 		uint32_t tmp = gem_create(fd, sizeof(linear));
 		copy(fd, tmp, handle, 0);
 		ptr = gem_mmap__cpu(fd, tmp, 0, sizeof(linear), PROT_READ);
+		igt_assert(ptr);
 		gem_close(fd, tmp);
 	}
 
tests/gen7_forcewake_mt.c +1 -0
index dea1e8a..640fb82 100644
@@ -191,6 +191,7 @@ igt_simple_main
 		gem_sync(t[0].fd, exec[1].handle);
 
 		p = gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
+		igt_assert(p);
 
 		igt_info("[%d]={ %08x %08x }\n", i, p[0], p[1]);
 		igt_assert(p[0] & 2);
tests/kms_fbc_crc.c +2 -0
index d580a94..c1af5e6 100644
@@ -189,6 +189,7 @@ static void fill_mmap_cpu(data_t *data, uint32_t handle, unsigned char color)
 	void *ptr;
 
 	ptr = gem_mmap__cpu(data->drm_fd, handle, 0, 4096, PROT_WRITE);
+	igt_assert(ptr);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_CPU,
 		       I915_GEM_DOMAIN_CPU);
 	memset(ptr, color, 4);
@@ -201,6 +202,7 @@ static void fill_mmap_gtt(data_t *data, uint32_t handle, unsigned char color)
 	void *ptr;
 
 	ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
+	igt_assert(ptr);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT,
 		       I915_GEM_DOMAIN_GTT);
 	memset(ptr, color, 4);
tests/kms_fence_pin_leak.c +1 -0
index 7d4ffbc..0f5d364 100644
@@ -90,6 +90,7 @@ static void touch_fences(data_t *data)
 		void *ptr;
 
 		ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		memset(ptr, 0, 4);
 		munmap(ptr, 4096);
tests/kms_psr_sink_crc.c +3 -0
index 77c92d3..720472f 100644
@@ -381,6 +381,7 @@ static void run_test(data_t *data)
 	case MMAP_GTT:
 		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		memset(ptr, 0xcc, data->mod_size);
@@ -390,6 +391,7 @@ static void run_test(data_t *data)
 	case MMAP_GTT_WAITING:
 		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
@@ -412,6 +414,7 @@ static void run_test(data_t *data)
 		break;
 	case MMAP_CPU:
 		ptr = gem_mmap__cpu(data->drm_fd, handle, 0, data->mod_size, PROT_WRITE);
+		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 		memset(ptr, 0, data->mod_size);
tests/pm_rpm.c +14 -4
index 3364157..026220b 100644
@@ -972,11 +972,15 @@ static void gem_mmap_subtest(bool gtt_mmap)
 
 	handle = gem_create(drm_fd, buf_size);
 
-	if (gtt_mmap)
+	if (gtt_mmap) {
 		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
-	else
+		igt_assert(gem_buf);
+	}
+	else {
 		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
+		igt_assert(gem_buf);
+	}
 
 
 	for (i = 0; i < buf_size; i++)
@@ -1007,11 +1011,15 @@ static void gem_mmap_subtest(bool gtt_mmap)
 	 * suspended. */
 	disable_all_screens_and_wait(&ms_data);
 
-	if (gtt_mmap)
+	if (gtt_mmap) {
 		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
-	else
+		igt_assert(gem_buf);
+	}
+	else {
 		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
+		igt_assert(gem_buf);
+	}
 
 	igt_assert(wait_for_suspended());
 
@@ -1467,6 +1475,7 @@ static void fill_igt_fb(struct igt_fb *fb, uint32_t color)
 	uint32_t *ptr;
 
 	ptr = gem_mmap__gtt(drm_fd, fb->gem_handle, fb->size, PROT_WRITE);
+	igt_assert(ptr);
 	for (i = 0; i < fb->size/sizeof(uint32_t); i++)
 		ptr[i] = color;
 	igt_assert(munmap(ptr, fb->size) == 0);
@@ -1749,6 +1758,7 @@ static void fences_subtest(bool dpms)
 
 	buf_ptr = gem_mmap__gtt(drm_fd, params.fb.gem_handle,
 				params.fb.size, PROT_WRITE | PROT_READ);
+	igt_assert(buf_ptr);
 	for (i = 0; i < params.fb.size/sizeof(uint32_t); i++)
 		buf_ptr[i] = i;
 
tests/prime_self_import.c +2 -2
index eb9ab06..582c375 100644
@@ -61,9 +61,9 @@ check_bo(int fd1, uint32_t handle1, int fd2, uint32_t handle2)
 	int i;
 
 	ptr1 = gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
-	ptr2 = gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
-
 	igt_assert(ptr1);
+	ptr2 = gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
+	igt_assert(ptr2);
 
 	/* check whether it's still our old object first. */
 	for (i = 0; i < BO_SIZE; i++) {
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#4 lore raw

PATCH 5/7 lib: Die if framebuffer GTT mapping fails

In reply to [email protected]

From: Ville Syrjälä <[email protected]>

Cairo helpfully allocates a new buffer for us when cairo_image_surface_create_for_data() is called with a NULL ptr. That means if gem_mmap__gtt() fails, we get a totally silent failure and nothing ever drawn into the framebuffer. Very confusing.

Put in an igt_assert() to make sure we managed to mmap something.

---
 lib/igt_fb.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
lib/igt_fb.c +4 -1
index 713bd50..e225f8a 100644
@@ -774,8 +774,11 @@ static void destroy_cairo_surface__gtt(void *arg)
 
 static void create_cairo_surface__gtt(int fd, struct igt_fb *fb)
 {
+	void *ptr = gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE);
+	igt_assert(ptr);
+
 	fb->cairo_surface =
-		cairo_image_surface_create_for_data(gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE),
+		cairo_image_surface_create_for_data(ptr,
 						    drm_format_to_cairo(fb->drm_format),
 						    fb->width, fb->height, fb->stride);
 
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#5 lore raw

PATCH 6/7 Make gem_mmap__{cpu, gtt, wc}() assert on failure

In reply to [email protected]

From: Ville Syrjälä <[email protected]>

Rename the current gem_mmap__{cpu,gtt,wc}() functions into __gem_mmap__{cpu,gtt,wc}(), and add back wrappers with the original name that assert that the pointer is valid. Most callers will expect a valid pointer and shouldn't have to bother with failures.

To avoid changing anything (yet), sed 's/gem_mmap__/__gem_mmap__/g' over the entire codebase.

---
 benchmarks/gem_blt.c               |  2 +-
 benchmarks/gem_exec_reloc.c        |  6 ++--
 benchmarks/gem_mmap.c              |  6 ++--
 demos/intel_sprite_on.c            |  4 +--
 lib/igt_draw.c                     |  6 ++--
 lib/igt_fb.c                       |  4 +--
 lib/ioctl_wrappers.c               | 68 ++++++++++++++++++++++++++++++++++----
 lib/ioctl_wrappers.h               |  4 +++
 tests/drv_suspend.c                |  6 ++--
 tests/gem_concurrent_all.c         | 14 ++++----
 tests/gem_cs_tlb.c                 |  2 +-
 tests/gem_evict_everything.c       |  2 +-
 tests/gem_exec_big.c               |  4 +--
 tests/gem_exec_faulting_reloc.c    |  2 +-
 tests/gem_exec_lut_handle.c        |  8 ++---
 tests/gem_fence_thrash.c           |  4 +--
 tests/gem_fence_upload.c           |  8 ++---
 tests/gem_gtt_cpu_tlb.c            |  4 +--
 tests/gem_gtt_hog.c                |  4 +--
 tests/gem_gtt_speed.c              | 30 ++++++++---------
 tests/gem_largeobject.c            |  2 +-
 tests/gem_madvise.c                |  4 +--
 tests/gem_mmap.c                   |  4 +--
 tests/gem_mmap_gtt.c               | 24 +++++++-------
 tests/gem_mmap_offset_exhaustion.c |  2 +-
 tests/gem_mmap_wc.c                | 14 ++++----
 tests/gem_persistent_relocs.c      |  2 +-
 tests/gem_pwrite.c                 |  2 +-
 tests/gem_pwrite_pread.c           | 16 ++++-----
 tests/gem_reloc_overflow.c         |  2 +-
 tests/gem_reloc_vs_gpu.c           |  2 +-
 tests/gem_set_tiling_vs_gtt.c      |  2 +-
 tests/gem_set_tiling_vs_pwrite.c   |  2 +-
 tests/gem_streaming_writes.c       | 20 +++++------
 tests/gem_tiled_pread_basic.c      |  2 +-
 tests/gem_tiled_pread_pwrite.c     |  4 +--
 tests/gem_tiled_swapping.c         |  6 ++--
 tests/gem_tiled_wb.c               |  4 +--
 tests/gem_tiled_wc.c               |  4 +--
 tests/gem_tiling_max_stride.c      |  2 +-
 tests/gem_userptr_blits.c          |  8 ++---
 tests/gen3_mixed_blits.c           |  4 +--
 tests/gen3_render_mixed_blits.c    |  4 +--
 tests/gen3_render_tiledx_blits.c   |  4 +--
 tests/gen3_render_tiledy_blits.c   |  4 +--
 tests/gen7_forcewake_mt.c          |  2 +-
 tests/kms_fbc_crc.c                |  4 +--
 tests/kms_fence_pin_leak.c         |  2 +-
 tests/kms_psr_sink_crc.c           |  6 ++--
 tests/pm_rpm.c                     | 12 +++----
 tests/prime_self_import.c          |  4 +--
 tests/testdisplay.c                |  2 +-
 52 files changed, 212 insertions(+), 152 deletions(-)
benchmarks/gem_blt.c +1 -1
index 3ed2300..e722541 100644
@@ -177,7 +177,7 @@ static int run(int object, int batch, int count, int reps)
 
 	fd = drm_open_driver(DRIVER_INTEL);
 	handle = gem_create(fd, size);
-	buf = gem_mmap__cpu(fd, handle, 0, size, PROT_WRITE);
+	buf = __gem_mmap__cpu(fd, handle, 0, size, PROT_WRITE);
 	igt_assert(buf);
 
 	gen = intel_gen(intel_get_drm_devid(fd));
benchmarks/gem_exec_reloc.c +3 -3
index 274ce41..5be482a 100644
@@ -115,13 +115,13 @@ static int run(unsigned batch_size,
 	if (num_relocs) {
 		size = ALIGN(sizeof(*mem_reloc)*num_relocs, 4096);
 		reloc_handle = gem_create(fd, size);
-		reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+		reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 		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);
+			reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 		} else
 			reloc = mem_reloc;
 	}
@@ -162,7 +162,7 @@ static int run(unsigned batch_size,
 			}
 			if (flags & FAULT && reloc) {
 				munmap(reloc, size);
-				reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+				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);
benchmarks/gem_mmap.c +3 -3
index 6bf7fd3..571f757 100644
@@ -115,17 +115,17 @@ int main(int argc, char **argv)
 	handle = gem_create(fd, OBJECT_SIZE);
 	switch (map) {
 	case CPU:
-		ptr = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+		ptr = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 		break;
 	case GTT:
-		ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
+		ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
 	case WC:
-		ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+		ptr = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
demos/intel_sprite_on.c +2 -2
index 4083070..6dddded 100644
@@ -359,7 +359,7 @@ static int prepare_primary_surface(int fd, int prim_width, int prim_height,
 	if (tiled)
 		gem_set_tiling(fd, *prim_handle, I915_TILING_X, *prim_stride);
 
-	prim_fb_ptr = gem_mmap__gtt(fd, *prim_handle, *prim_size, PROT_READ | PROT_WRITE);
+	prim_fb_ptr = __gem_mmap__gtt(fd, *prim_handle, *prim_size, PROT_READ | PROT_WRITE);
 
 	if (prim_fb_ptr != NULL) {
 		// Write primary surface with gray background
@@ -454,7 +454,7 @@ static int prepare_sprite_surfaces(int fd, int sprite_width, int sprite_height,
 			gem_set_tiling(fd, sprite_handles[i], I915_TILING_X, *sprite_stride);
 
 		// Get pointer to the surface
-		sprite_fb_ptr = gem_mmap__gtt(fd,
+		sprite_fb_ptr = __gem_mmap__gtt(fd,
 				sprite_handles[i], *sprite_size,
 				PROT_READ | PROT_WRITE);
 
lib/igt_draw.c +3 -3
index 38ecae0..07aa812 100644
@@ -252,7 +252,7 @@ static void draw_rect_mmap_cpu(int fd, struct buf_data *buf, struct rect *rect,
 	if (tiling != I915_TILING_NONE)
 		igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
 
-	ptr = gem_mmap__cpu(fd, buf->handle, 0, buf->size, 0);
+	ptr = __gem_mmap__cpu(fd, buf->handle, 0, buf->size, 0);
 	igt_assert(ptr);
 
 	switch (tiling) {
@@ -281,7 +281,7 @@ static void draw_rect_mmap_gtt(int fd, struct buf_data *buf, struct rect *rect,
 	gem_set_domain(fd, buf->handle, I915_GEM_DOMAIN_GTT,
 		       I915_GEM_DOMAIN_GTT);
 
-	ptr = gem_mmap__gtt(fd, buf->handle, buf->size, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, buf->handle, buf->size, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	draw_rect_ptr_linear(ptr, buf->stride, rect, color, buf->bpp);
@@ -303,7 +303,7 @@ static void draw_rect_mmap_wc(int fd, struct buf_data *buf, struct rect *rect,
 	if (tiling != I915_TILING_NONE)
 		igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
 
-	ptr = gem_mmap__wc(fd, buf->handle, 0, buf->size,
+	ptr = __gem_mmap__wc(fd, buf->handle, 0, buf->size,
 			   PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
lib/igt_fb.c +2 -2
index e225f8a..5ab063f 100644
@@ -745,7 +745,7 @@ static void create_cairo_surface__blit(int fd, struct igt_fb *fb)
 		       I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 
 	/* Setup cairo context */
-	blit->linear.map = gem_mmap__cpu(fd,
+	blit->linear.map = __gem_mmap__cpu(fd,
 					 blit->linear.handle,
 					 0,
 					 blit->linear.size,
@@ -774,7 +774,7 @@ static void destroy_cairo_surface__gtt(void *arg)
 
 static void create_cairo_surface__gtt(int fd, struct igt_fb *fb)
 {
-	void *ptr = gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE);
+	void *ptr = __gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	fb->cairo_surface =
lib/ioctl_wrappers.c +62 -6

116 lines not on this page · raw message

lib/ioctl_wrappers.h +4 -0
index 7c607a2..7505acb 100644
@@ -66,6 +66,10 @@ void *gem_mmap__cpu(int fd, uint32_t handle, uint64_t offset, uint64_t size, uns
 bool gem_mmap__has_wc(int fd);
 void *gem_mmap__wc(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsigned prot);
 
+void *__gem_mmap__gtt(int fd, uint32_t handle, uint64_t size, unsigned prot);
+void *__gem_mmap__cpu(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsigned prot);
+void *__gem_mmap__wc(int fd, uint32_t handle, uint64_t offset, uint64_t size, unsigned prot);
+
 /**
  * gem_require_mmap_wc:
  * @fd: open i915 drm file descriptor
tests/drv_suspend.c +3 -3
index 4e84d1c..b85dd2f 100644
@@ -56,19 +56,19 @@ test_fence_restore(int fd, bool tiled2untiled, bool hibernate)
 	handle_tiled = gem_create(fd, OBJECT_SIZE);
 
 	/* Access the buffer objects in the order we want to have the laid out. */
-	ptr1 = gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr1 = __gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr1);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr1[i] = i;
 
-	ptr_tiled = gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr_tiled = __gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr_tiled);
 	if (tiled2untiled)
 		gem_set_tiling(fd, handle_tiled, I915_TILING_X, 2048);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr_tiled[i] = i;
 
-	ptr2 = gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr2 = __gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr2);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr2[i] = i;
tests/gem_concurrent_all.c +7 -7
index 6efb977..5b8c3f0 100644
@@ -171,7 +171,7 @@ wc_create_bo(drm_intel_bufmgr *bufmgr, int width, int height)
 	gem_require_mmap_wc(fd);
 
 	bo = unmapped_create_bo(bufmgr, width, height);
-	bo->virtual = gem_mmap__wc(fd, bo->handle, 0, bo->size, PROT_READ | PROT_WRITE);
+	bo->virtual = __gem_mmap__wc(fd, bo->handle, 0, bo->size, PROT_READ | PROT_WRITE);
 	return bo;
 }
 
@@ -471,9 +471,9 @@ static void cpu_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_CPU, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
-	s = gem_mmap__cpu(fd, src->handle, 0, size, PROT_READ);
+	s = __gem_mmap__cpu(fd, src->handle, 0, size, PROT_READ);
 	igt_assert(s);
-	d = gem_mmap__cpu(fd, dst->handle, 0, size, PROT_WRITE);
+	d = __gem_mmap__cpu(fd, dst->handle, 0, size, PROT_WRITE);
 	igt_assert(d);
 
 	memcpy(d, s, size);
@@ -490,9 +490,9 @@ static void gtt_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_GTT, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	s = gem_mmap__gtt(fd, src->handle, size, PROT_READ);
+	s = __gem_mmap__gtt(fd, src->handle, size, PROT_READ);
 	igt_assert(s);
-	d = gem_mmap__gtt(fd, dst->handle, size, PROT_WRITE);
+	d = __gem_mmap__gtt(fd, dst->handle, size, PROT_WRITE);
 	igt_assert(d);
 
 	memcpy(d, s, size);
@@ -509,9 +509,9 @@ static void wc_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_GTT, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	s = gem_mmap__wc(fd, src->handle, 0, size, PROT_READ);
+	s = __gem_mmap__wc(fd, src->handle, 0, size, PROT_READ);
 	igt_assert(s);
-	d = gem_mmap__wc(fd, dst->handle, 0, size, PROT_WRITE);
+	d = __gem_mmap__wc(fd, dst->handle, 0, size, PROT_WRITE);
 	igt_assert(d);
 
 	memcpy(d, s, size);
tests/gem_cs_tlb.c +1 -1
index a647ddf..71e5996 100644
@@ -115,7 +115,7 @@ static void run_on_ring(int fd, unsigned ring_id, const char *ring_name)
 		igt_progress(buf, split, BATCH_SIZE/8 - 1);
 
 		handle_new = gem_create(fd, BATCH_SIZE);
-		batch_ptr = gem_mmap__cpu(fd, handle_new, 0, BATCH_SIZE,
+		batch_ptr = __gem_mmap__cpu(fd, handle_new, 0, BATCH_SIZE,
 					  PROT_READ | PROT_WRITE);
 		igt_assert(batch_ptr);
 		batch_ptr[split*2] = MI_BATCH_BUFFER_END;
tests/gem_evict_everything.c +1 -1
index 12ad6df..93ec7a5 100644
@@ -132,7 +132,7 @@ copy(int fd, uint32_t dst, uint32_t src, uint32_t *all_bo, int n_bo)
 
 static void clear(int fd, uint32_t handle, int size)
 {
-	void *base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+	void *base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 
 	igt_assert(base != NULL);
 	memset(base, 0, size);
tests/gem_exec_big.c +2 -2
index 1cc7da6..4ea1943 100644
@@ -203,9 +203,9 @@ igt_simple_main
 		gem_write(fd, handle, 0, batch, sizeof(batch));
 
 		if (!FORCE_PREAD_PWRITE && gem_has_llc(fd))
-			ptr = gem_mmap__cpu(fd, handle, 0, batch_size, PROT_READ);
+			ptr = __gem_mmap__cpu(fd, handle, 0, batch_size, PROT_READ);
 		else if (!FORCE_PREAD_PWRITE && gem_mmap__has_wc(fd))
-			ptr = gem_mmap__wc(fd, handle, 0, batch_size, PROT_READ);
+			ptr = __gem_mmap__wc(fd, handle, 0, batch_size, PROT_READ);
 		else
 			ptr = NULL;
 
tests/gem_exec_faulting_reloc.c +1 -1
index e16b580..67fc410 100644
@@ -200,7 +200,7 @@ static void run(int object_size)
 
 	handle_relocs = gem_create(fd, 4096);
 	gem_write(fd, handle_relocs, 0, reloc, sizeof(reloc));
-	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
+	gtt_relocs = __gem_mmap__gtt(fd, handle_relocs, 4096,
 			      PROT_READ | PROT_WRITE);
 	igt_assert(gtt_relocs);
 
tests/gem_exec_lut_handle.c +4 -4
index 282fccf..0af27bb 100644
@@ -123,7 +123,7 @@ igt_simple_main
 
 	size = ALIGN(sizeof(mem_reloc), 4096);
 	reloc_handle = gem_create(fd, size);
-	reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+	reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 	igt_assert(reloc);
 	for (n = 0; n < MAX_NUM_RELOC; n++) {
 		reloc[n].offset = 1024;
@@ -148,7 +148,7 @@ igt_simple_main
 				struct timeval start, end;
 
 				if (p->flags & FAULT)
-					reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+					reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 				else
 					reloc = mem_reloc;
 
@@ -182,7 +182,7 @@ igt_simple_main
 					}
 					if (p->flags & FAULT) {
 						munmap(reloc, size);
-						reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+						reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 						gem_exec[MAX_NUM_EXEC].relocs_ptr = (uintptr_t)reloc;
 					}
 					gem_execbuf(fd, &execbuf);
@@ -212,7 +212,7 @@ igt_simple_main
 					}
 					if (p->flags & FAULT) {
 						munmap(reloc, size);
-						reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
+						reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 						gem_exec[MAX_NUM_EXEC].relocs_ptr = (uintptr_t)reloc;
 					}
 					gem_execbuf(fd, &execbuf);
tests/gem_fence_thrash.c +2 -2
index 1b828b8..1161e73 100644
@@ -67,14 +67,14 @@ bo_create (int fd, int tiling)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	/* dirty cpu caches a bit ... */
-	ptr = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 	memset(ptr, 0, OBJECT_SIZE);
 	munmap(ptr, OBJECT_SIZE);
 
 	gem_set_tiling(fd, handle, tiling, 1024);
 
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
tests/gem_fence_upload.c +4 -4
index 047b783..d2cbc30 100644
@@ -68,7 +68,7 @@ static void performance(void)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
+			ptr[n] = __gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 			igt_assert(ptr[n]);
 		}
 
@@ -176,7 +176,7 @@ static void thread_performance(unsigned mask)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
+			ptr[n] = __gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 			igt_assert(ptr[n]);
 
 			if (mask & READ) {
@@ -257,7 +257,7 @@ static void *no_contention(void *closure)
 	int n;
 
 	for (n = 0; n < t->loops; n++) {
-		uint32_t *ptr = gem_mmap__gtt(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		uint32_t *ptr = __gem_mmap__gtt(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(ptr);
 		memset(ptr + (rand() % 256) * 4096 / 4, 0, 4096);
 		munmap(ptr, OBJECT_SIZE);
@@ -272,7 +272,7 @@ static void *wc_mmap(void *closure)
 	int n;
 
 	for (n = 0; n < t->loops; n++) {
-		uint32_t *ptr = gem_mmap__wc(t->fd, t->handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		uint32_t *ptr = __gem_mmap__wc(t->fd, t->handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(ptr);
 		memset(ptr + (rand() % 256) * 4096 / 4, 0, 4096);
 		munmap(ptr, OBJECT_SIZE);
tests/gem_gtt_cpu_tlb.c +2 -2
index 75c3d04..9125c34 100644
@@ -59,7 +59,7 @@ create_bo(int fd)
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(data);
 	for (i = 0; i < OBJ_SIZE/4; i++)
 		data[i] = i;
@@ -83,7 +83,7 @@ igt_simple_main
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* touch one page */
-	ptr = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 	*ptr = 0xdeadbeef;
 	munmap(ptr, OBJ_SIZE);
tests/gem_gtt_hog.c +2 -2
index cbb7016..28df7a7 100644
@@ -140,11 +140,11 @@ static void run(data_t *data, int child)
 	 * set-to-gtt-domain within the fault handler.
 	 */
 	if (write) {
-		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ | PROT_WRITE);
+		ptr = __gem_mmap__gtt(data->fd, handle, size, PROT_READ | PROT_WRITE);
 		igt_assert(ptr);
 		ptr[rand() % (size / 4)] = canary;
 	} else {
-		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ);
+		ptr = __gem_mmap__gtt(data->fd, handle, size, PROT_READ);
 		igt_assert(ptr);
 	}
 	x = ptr[rand() % (size / 4)];
tests/gem_gtt_speed.c +15 -15
index ed45bba..7228718 100644
@@ -89,7 +89,7 @@ int main(int argc, char **argv)
 				       I915_GEM_DOMAIN_CPU);
 
 			{
-				uint32_t *base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				uint32_t *base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				volatile uint32_t *ptr = base;
 				int x = 0;
 
@@ -106,7 +106,7 @@ int main(int argc, char **argv)
 				/* mmap read */
 				gettimeofday(&start, NULL);
 				for (loop = 0; loop < 1000; loop++) {
-					base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+					base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 					ptr = base;
 					x = 0;
 
@@ -127,7 +127,7 @@ int main(int argc, char **argv)
 				/* mmap write */
 				gettimeofday(&start, NULL);
 				for (loop = 0; loop < 1000; loop++) {
-					base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+					base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 					ptr = base;
 
 					igt_assert(base);
@@ -143,7 +143,7 @@ int main(int argc, char **argv)
 
 				gettimeofday(&start, NULL);
 				for (loop = 0; loop < 1000; loop++) {
-					base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+					base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 					igt_assert(base);
 					memset(base, 0, size);
 					munmap(base, size);
@@ -153,7 +153,7 @@ int main(int argc, char **argv)
 					 size/1024, elapsed(&start, &end, loop));
 
 				gettimeofday(&start, NULL);
-				base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				igt_assert(base);
 				for (loop = 0; loop < 1000; loop++)
 					memset(base, 0, size);
@@ -182,7 +182,7 @@ int main(int argc, char **argv)
 
 		/* prefault into gtt */
 		{
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
@@ -199,7 +199,7 @@ int main(int argc, char **argv)
 		/* mmap read */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
@@ -220,7 +220,7 @@ int main(int argc, char **argv)
 		if (gem_mmap__has_wc(fd)) {
 			gettimeofday(&start, NULL);
 			for (loop = 0; loop < 1000; loop++) {
-				uint32_t *base = gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				uint32_t *base = __gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				volatile uint32_t *ptr = base;
 				int x = 0;
 
@@ -243,7 +243,7 @@ int main(int argc, char **argv)
 		/* mmap write */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 
 			igt_assert(base);
@@ -261,7 +261,7 @@ int main(int argc, char **argv)
 			/* mmap write */
 			gettimeofday(&start, NULL);
 			for (loop = 0; loop < 1000; loop++) {
-				uint32_t *base = gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				uint32_t *base = __gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				volatile uint32_t *ptr = base;
 
 				igt_assert(base);
@@ -279,7 +279,7 @@ int main(int argc, char **argv)
 		/* mmap clear */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			memset(base, 0, size);
 			munmap(base, size);
 		}
@@ -291,7 +291,7 @@ int main(int argc, char **argv)
 			/* mmap clear */
 			gettimeofday(&start, NULL);
 			for (loop = 0; loop < 1000; loop++) {
-				uint32_t *base = gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				uint32_t *base = __gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				memset(base, 0, size);
 				munmap(base, size);
 			}
@@ -301,7 +301,7 @@ int main(int argc, char **argv)
 		}
 
 		gettimeofday(&start, NULL);{
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			for (loop = 0; loop < 1000; loop++)
 				memset(base, 0, size);
 			munmap(base, size);
@@ -311,7 +311,7 @@ int main(int argc, char **argv)
 
 		if (gem_mmap__has_wc(fd)) {
 			gettimeofday(&start, NULL);{
-				uint32_t *base = gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+				uint32_t *base = __gem_mmap__wc(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 				for (loop = 0; loop < 1000; loop++)
 					memset(base, 0, size);
 				munmap(base, size);
@@ -323,7 +323,7 @@ int main(int argc, char **argv)
 		/* mmap read */
 		gettimeofday(&start, NULL);
 		for (loop = 0; loop < 1000; loop++) {
-			uint32_t *base = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+			uint32_t *base = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 			volatile uint32_t *ptr = base;
 			int x = 0;
 
tests/gem_largeobject.c +1 -1
index d261939..0da8205 100644
@@ -64,7 +64,7 @@ test_large_object(int fd)
 	igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create) == 0);
 
 	/* prefault */
-	ptr = gem_mmap__gtt(fd, create.handle, obj_size, PROT_WRITE | PROT_READ);
+	ptr = __gem_mmap__gtt(fd, create.handle, obj_size, PROT_WRITE | PROT_READ);
 	igt_assert(ptr);
 	*ptr = 0;
 
tests/gem_madvise.c +2 -2
index d0f378e..093d78a 100644
@@ -63,7 +63,7 @@ dontneed_before_mmap(void)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 	gem_madvise(fd, handle, I915_MADV_DONTNEED);
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr == NULL);
 	igt_assert(errno == EFAULT);
 	close(fd);
@@ -77,7 +77,7 @@ dontneed_after_mmap(void)
 	char *ptr;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 	gem_madvise(fd, handle, I915_MADV_DONTNEED);
 	close(fd);
tests/gem_mmap.c +2 -2
index 4188429..37d0933 100644
@@ -80,7 +80,7 @@ test_huge_bo(int huge)
 	bo = gem_create(fd, huge_object_size);
 
 	/* Obtain CPU mapping for the object. */
-	ptr_cpu = gem_mmap__cpu(fd, bo, 0, huge_object_size,
+	ptr_cpu = __gem_mmap__cpu(fd, bo, 0, huge_object_size,
 				PROT_READ | PROT_WRITE);
 	igt_require(ptr_cpu);
 	gem_set_domain(fd, bo, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
@@ -166,7 +166,7 @@ igt_main
 	igt_subtest("short-mmap") {
 		igt_assert(OBJECT_SIZE > 4096);
 		arg.handle = gem_create(fd, OBJECT_SIZE);
-		addr = gem_mmap__cpu(fd, arg.handle, 0, 4096, PROT_WRITE);
+		addr = __gem_mmap__cpu(fd, arg.handle, 0, 4096, PROT_WRITE);
 		igt_assert(addr);
 		memset(addr, 0, 4096);
 		munmap(addr, 4096);
tests/gem_mmap_gtt.c +12 -12
index 5b782c9..0cfb6f6 100644
@@ -56,7 +56,7 @@ mmap_bo(int fd, uint32_t handle)
 {
 	void *ptr;
 
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	return ptr;
@@ -179,7 +179,7 @@ test_read_write(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	if (order == READ_BEFORE_WRITE) {
@@ -203,10 +203,10 @@ test_read_write2(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	r = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
+	r = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 	igt_assert(r);
 
-	w = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	w = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(w);
 
 	if (order == READ_BEFORE_WRITE) {
@@ -291,12 +291,12 @@ test_huge_bo(int fd, int huge, int tiling)
 	bo = gem_create(fd, PAGE_SIZE);
 	if (tiling)
 		gem_set_tiling(fd, bo, tiling, pitch);
-	linear_pattern = gem_mmap__gtt(fd, bo, PAGE_SIZE,
+	linear_pattern = __gem_mmap__gtt(fd, bo, PAGE_SIZE,
 				       PROT_READ | PROT_WRITE);
 	igt_assert(linear_pattern);
 	for (i = 0; i < PAGE_SIZE; i++)
 		linear_pattern[i] = i;
-	tiled_pattern = gem_mmap__cpu(fd, bo, 0, PAGE_SIZE, PROT_READ);
+	tiled_pattern = __gem_mmap__cpu(fd, bo, 0, PAGE_SIZE, PROT_READ);
 	igt_assert(tiled_pattern);
 
 	gem_set_domain(fd, bo, I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT, 0);
@@ -307,13 +307,13 @@ test_huge_bo(int fd, int huge, int tiling)
 		gem_set_tiling(fd, bo, tiling, pitch);
 
 	/* Initialise first/last page through CPU mmap */
-	ptr = gem_mmap__cpu(fd, bo, 0, size, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__cpu(fd, bo, 0, size, PROT_READ | PROT_WRITE);
 	memcpy(ptr, tiled_pattern, PAGE_SIZE);
 	memcpy(ptr + last_offset, tiled_pattern, PAGE_SIZE);
 	munmap(ptr, size);
 
 	/* Obtain mapping for the object through GTT. */
-	ptr = gem_mmap__gtt(fd, bo, size, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, bo, size, PROT_READ | PROT_WRITE);
 	igt_require_f(ptr, "Huge BO GTT mapping not supported.\n");
 
 	set_domain_gtt(fd, bo);
@@ -369,7 +369,7 @@ test_huge_copy(int fd, int huge, int tiling_a, int tiling_b)
 	if (tiling_a)
 		gem_set_tiling(fd, bo, tiling_a,
 			       tiling_a == I915_TILING_Y ? 128 : 512);
-	a = gem_mmap__gtt(fd, bo, huge_object_size, PROT_READ | PROT_WRITE);
+	a = __gem_mmap__gtt(fd, bo, huge_object_size, PROT_READ | PROT_WRITE);
 	igt_require(a);
 	gem_close(fd, bo);
 
@@ -380,7 +380,7 @@ test_huge_copy(int fd, int huge, int tiling_a, int tiling_b)
 	if (tiling_b)
 		gem_set_tiling(fd, bo, tiling_b, 
 			       tiling_b == I915_TILING_Y ? 128 : 512);
-	b = gem_mmap__gtt(fd, bo, huge_object_size, PROT_READ | PROT_WRITE);
+	b = __gem_mmap__gtt(fd, bo, huge_object_size, PROT_READ | PROT_WRITE);
 	igt_require(b);
 	gem_close(fd, bo);
 
@@ -440,10 +440,10 @@ test_write_cpu_read_gtt(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	dst = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
+	dst = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst);
 
-	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+	src = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src);
 
 	gem_close(fd, handle);
tests/gem_mmap_offset_exhaustion.c +1 -1
index 3ce60f3..50153cc 100644
@@ -60,7 +60,7 @@ create_and_map_bo(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	/* touch it to force it into the gtt */
tests/gem_mmap_wc.c +7 -7
index 11463ca..377749c 100644
@@ -62,7 +62,7 @@ mmap_bo(int fd, uint32_t handle)
 {
 	void *ptr;
 
-	ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	return ptr;
@@ -183,10 +183,10 @@ test_read_write2(int fd, enum test_read_write order)
 	handle = gem_create(fd, OBJECT_SIZE);
 	set_domain(fd, handle);
 
-	r = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
+	r = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(r);
 
-	w = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	w = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(w);
 
 	if (order == READ_BEFORE_WRITE) {
@@ -288,10 +288,10 @@ test_write_cpu_read_wc(int fd, int force_domain)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
+	dst = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst);
 
-	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
+	src = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src);
 
 	memset(src, 0xaa, OBJECT_SIZE);
@@ -315,10 +315,10 @@ test_write_gtt_read_wc(int fd)
 	handle = gem_create(fd, OBJECT_SIZE);
 	set_domain(fd, handle);
 
-	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
+	dst = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst);
 
-	src = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
+	src = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src);
 
 	memset(src, 0xaa, OBJECT_SIZE);
tests/gem_persistent_relocs.c +1 -1
index 57024fc..db69f3a 100644
@@ -225,7 +225,7 @@ static void do_test(int fd, bool faulting_reloc)
 
 		relocs_bo_handle[i] = gem_create(fd, 4096);
 		gem_write(fd, relocs_bo_handle[i], 0, reloc, sizeof(reloc));
-		gtt_relocs_ptr[i] = gem_mmap__gtt(fd, relocs_bo_handle[i], 4096,
+		gtt_relocs_ptr[i] = __gem_mmap__gtt(fd, relocs_bo_handle[i], 4096,
 				      PROT_READ | PROT_WRITE);
 		igt_assert(gtt_relocs_ptr[i]);
 
tests/gem_pwrite.c +1 -1
index fce71c7..8080981 100644
@@ -118,7 +118,7 @@ static void test_big_gtt(int fd, int scale)
 	handle = gem_create(fd, size);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	ptr = gem_mmap__wc(fd, handle, 0, size, PROT_READ);
+	ptr = __gem_mmap__wc(fd, handle, 0, size, PROT_READ);
 	igt_assert(ptr);
 
 	for (offset = 0; offset < size; offset += 4096) {
tests/gem_pwrite_pread.c +8 -8
index 1e8f5be..5408140 100644
@@ -112,9 +112,9 @@ static void as_gtt_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	uint32_t *src_ptr, *dst_ptr;
 	BUILD_EXEC;
 
-	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	src_ptr = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src_ptr);
-	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
+	dst_ptr = __gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst_ptr);
 
 	while (loops--) {
@@ -139,9 +139,9 @@ static void as_cpu_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	uint32_t *src_ptr, *dst_ptr;
 	BUILD_EXEC;
 
-	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	src_ptr = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src_ptr);
-	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	dst_ptr = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst_ptr);
 
 	while (loops--) {
@@ -186,9 +186,9 @@ static void test_as_gtt_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	int i;
 	BUILD_EXEC;
 
-	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	src_ptr = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src_ptr);
-	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
+	dst_ptr = __gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst_ptr);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
@@ -212,9 +212,9 @@ static void test_as_cpu_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	int i;
 	BUILD_EXEC;
 
-	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	src_ptr = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
 	igt_assert(src_ptr);
-	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	dst_ptr = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(dst_ptr);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
tests/gem_reloc_overflow.c +1 -1
index 5d794cd..662e88c 100644
@@ -85,7 +85,7 @@ static void source_offset_tests(int devid, bool reloc_gtt)
 		execbuf.buffer_count = 2;
 
 		if (reloc_gtt) {
-			dst_gtt = gem_mmap__gtt(fd, handle, 8192, PROT_READ | PROT_WRITE);
+			dst_gtt = __gem_mmap__gtt(fd, handle, 8192, PROT_READ | PROT_WRITE);
 			igt_assert(dst_gtt != MAP_FAILED);
 			gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 			memset(dst_gtt, 0, 8192);
tests/gem_reloc_vs_gpu.c +1 -1
index e31928e..59ba8c0 100644
@@ -162,7 +162,7 @@ static void reloc_and_emit(int fd, drm_intel_bo *target_bo, bool faulting_reloc)
 
 	handle_relocs = gem_create(fd, 4096);
 	gem_write(fd, handle_relocs, 0, reloc, sizeof(reloc));
-	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
+	gtt_relocs = __gem_mmap__gtt(fd, handle_relocs, 4096,
 			      PROT_READ | PROT_WRITE);
 	igt_assert(gtt_relocs);
 
tests/gem_set_tiling_vs_gtt.c +1 -1
index 619bd1d..6f04735 100644
@@ -66,7 +66,7 @@ igt_simple_main
 		tile_height = 8;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	/* gtt coherency is done with set_domain in libdrm, don't break that */
tests/gem_set_tiling_vs_pwrite.c +1 -1
index ed6d763..5c2e93a 100644
@@ -62,7 +62,7 @@ igt_simple_main
 		data[i] = i;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	gem_set_tiling(fd, handle, I915_TILING_X, TEST_STRIDE);
tests/gem_streaming_writes.c +10 -10
index 3f7ed95..6664582 100644
@@ -88,21 +88,21 @@ static void test_streaming(int fd, int mode, int sync)
 	switch (mode) {
 	case 0: /* cpu/snoop */
 		gem_set_caching(fd, src, I915_CACHING_CACHED);
-		s = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		s = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(s);
 		break;
 	case 1: /* gtt */
-		s = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		s = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(s);
 		break;
 	case 2: /* wc */
-		s = gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+		s = __gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		igt_assert(s);
 		break;
 	}
 	*s = 0; /* fault the object into the mappable range first (for GTT) */
 
-	d = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	d = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(d);
 
 	gem_write(fd, dst, 0, tmp, sizeof(tmp));
@@ -154,7 +154,7 @@ static void test_streaming(int fd, int mode, int sync)
 		batch[i].handle = gem_create(fd, 4096);
 		batch[i].offset = 0;
 
-		base = gem_mmap__cpu(fd, batch[i].handle, 0, 4096, PROT_WRITE);
+		base = __gem_mmap__cpu(fd, batch[i].handle, 0, 4096, PROT_WRITE);
 		igt_assert(base);
 
 		for (int j = 0; j < 64; j++) {
@@ -254,10 +254,10 @@ static void test_batch(int fd, int mode, int reverse)
 	exec[DST].handle = gem_create(fd, OBJECT_SIZE);
 	exec[SRC].handle = gem_create(fd, OBJECT_SIZE);
 
-	s = gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
+	s = __gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(s);
 
-	d = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
+	d = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 	igt_assert(d);
 
 	memset(reloc, 0, sizeof(reloc));
@@ -285,15 +285,15 @@ static void test_batch(int fd, int mode, int reverse)
 	switch (mode) {
 	case 0: /* cpu/snoop */
 		igt_require(gem_has_llc(fd));
-		base = gem_mmap__cpu(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
+		base = __gem_mmap__cpu(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
 		igt_assert(base);
 		break;
 	case 1: /* gtt */
-		base = gem_mmap__gtt(fd, exec[BATCH].handle, batch_size, PROT_READ | PROT_WRITE);
+		base = __gem_mmap__gtt(fd, exec[BATCH].handle, batch_size, PROT_READ | PROT_WRITE);
 		igt_assert(base);
 		break;
 	case 2: /* wc */
-		base = gem_mmap__wc(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
+		base = __gem_mmap__wc(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
 		igt_assert(base);
 		break;
 	}
tests/gem_tiled_pread_basic.c +1 -1
index e1844b0..14a3706 100644
@@ -72,7 +72,7 @@ create_bo(int fd)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
tests/gem_tiled_pread_pwrite.c +2 -2
index 6e048db..8ae23e3 100644
@@ -79,7 +79,7 @@ create_bo_and_fill(int fd)
 	gem_set_tiling(fd, handle, current_tiling_mode, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
@@ -123,7 +123,7 @@ igt_simple_main
 		gem_write(fd, handle_target, 0, linear, sizeof(linear));
 
 		/* Check the target bo's contents. */
-		data = gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
+		data = __gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
 		igt_assert(data);
 		for (j = 0; j < WIDTH*HEIGHT; j++)
 			igt_assert_f(data[j] == j,
tests/gem_tiled_swapping.c +3 -3
index a66523b..730e625 100644
@@ -78,7 +78,7 @@ create_bo(int fd)
 	handle = gem_create(fd, LINEAR_DWORDS);
 	gem_set_tiling(fd, handle, current_tiling_mode, WIDTH * sizeof(uint32_t));
 
-	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
 	if (data == NULL) {
 		gem_close(fd, handle);
 		return 0;
@@ -94,7 +94,7 @@ fill_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int i;
 
-	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
 	igt_assert(data);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
@@ -109,7 +109,7 @@ check_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int j;
 
-	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
+	data = __gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
 	igt_assert(data);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
 	j = rand() % (WIDTH * HEIGHT);
tests/gem_tiled_wb.c +2 -2
index 654628e..0a30a48 100644
@@ -71,7 +71,7 @@ create_bo(int fd)
 	/* Write throught the fence to tiled the data.
 	 * We then manually detile on reading back through the mmap(wc).
 	 */
-	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
@@ -179,7 +179,7 @@ igt_simple_main
 		last_page = (offset + len + PAGE_SIZE) & ~(PAGE_SIZE-1);
 		offset -= first_page;
 
-		linear = gem_mmap__cpu(fd, handle, first_page, last_page - first_page, PROT_READ);
+		linear = __gem_mmap__cpu(fd, handle, first_page, last_page - first_page, PROT_READ);
 		igt_assert(linear);
 
 
tests/gem_tiled_wc.c +2 -2
index 3eee796..66b35c8 100644
@@ -65,7 +65,7 @@ create_bo(int fd)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
+	data = __gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(data);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
@@ -174,7 +174,7 @@ igt_simple_main
 		first_page = offset & ~(PAGE_SIZE-1);
 		last_page = (offset + len + PAGE_SIZE) & ~(PAGE_SIZE-1);
 
-		linear = gem_mmap__wc(fd, handle, first_page, last_page - first_page, PROT_READ);
+		linear = __gem_mmap__wc(fd, handle, first_page, last_page - first_page, PROT_READ);
 		igt_assert(linear);
 
 		/* Translate from offsets in the read buffer to the swizzled
tests/gem_tiling_max_stride.c +1 -1
index 02c4ed2..0867335 100644
@@ -97,7 +97,7 @@ igt_simple_main
 
 	handle = gem_create(fd, size);
 
-	ptr = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 	igt_assert(ptr);
 
 	test_invalid_tiling(fd, handle, 0);
tests/gem_userptr_blits.c +4 -4
index e6830f6..93461c2 100644
@@ -544,7 +544,7 @@ static int test_invalid_gtt_mapping(int fd)
 
 	/* GTT mapping */
 	handle = create_bo(fd, 0);
-	ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	ptr = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 	gem_close(fd, handle);
 	igt_assert(ptr);
 	igt_assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
@@ -573,7 +573,7 @@ static void test_process_exit(int fd, int flags)
 		handle = create_userptr_bo(fd, sizeof(linear));
 
 		if (flags & PE_GTT_MAP) {
-			uint32_t *ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+			uint32_t *ptr = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 			if (ptr)
 				*ptr = 0;
 		}
@@ -688,12 +688,12 @@ static void *umap(int fd, uint32_t handle)
 	void *ptr;
 
 	if (gem_has_llc(fd)) {
-		ptr = gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+		ptr = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
 		igt_assert(ptr);
 	} else {
 		uint32_t tmp = gem_create(fd, sizeof(linear));
 		copy(fd, tmp, handle, 0);
-		ptr = gem_mmap__cpu(fd, tmp, 0, sizeof(linear), PROT_READ);
+		ptr = __gem_mmap__cpu(fd, tmp, 0, sizeof(linear), PROT_READ);
 		igt_assert(ptr);
 		gem_close(fd, tmp);
 	}
tests/gen3_mixed_blits.c +2 -2
index 40b8e1e..0089eb3 100644
@@ -426,7 +426,7 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -441,7 +441,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_mixed_blits.c +2 -2
index cc2757b..6dd728d 100644
@@ -314,7 +314,7 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -329,7 +329,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_tiledx_blits.c +2 -2
index 9a243d8..1abcaaa 100644
@@ -301,7 +301,7 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -316,7 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen3_render_tiledy_blits.c +2 -2
index 11fb002..e90645a 100644
@@ -301,7 +301,7 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_Y, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
@@ -316,7 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
+	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
 	igt_assert(v);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
tests/gen7_forcewake_mt.c +1 -1
index 640fb82..f7a5aa1 100644
@@ -190,7 +190,7 @@ igt_simple_main
 		gem_execbuf(t[0].fd, &execbuf);
 		gem_sync(t[0].fd, exec[1].handle);
 
-		p = gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
+		p = __gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
 		igt_assert(p);
 
 		igt_info("[%d]={ %08x %08x }\n", i, p[0], p[1]);
tests/kms_fbc_crc.c +2 -2
index c1af5e6..c31dbdd 100644
@@ -188,7 +188,7 @@ static void fill_mmap_cpu(data_t *data, uint32_t handle, unsigned char color)
 {
 	void *ptr;
 
-	ptr = gem_mmap__cpu(data->drm_fd, handle, 0, 4096, PROT_WRITE);
+	ptr = __gem_mmap__cpu(data->drm_fd, handle, 0, 4096, PROT_WRITE);
 	igt_assert(ptr);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_CPU,
 		       I915_GEM_DOMAIN_CPU);
@@ -201,7 +201,7 @@ static void fill_mmap_gtt(data_t *data, uint32_t handle, unsigned char color)
 {
 	void *ptr;
 
-	ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
+	ptr = __gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
 	igt_assert(ptr);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT,
 		       I915_GEM_DOMAIN_GTT);
tests/kms_fence_pin_leak.c +1 -1
index 0f5d364..41ce084 100644
@@ -89,7 +89,7 @@ static void touch_fences(data_t *data)
 		uint32_t handle = data->bos[i]->handle;
 		void *ptr;
 
-		ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
+		ptr = __gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		memset(ptr, 0, 4);
tests/kms_psr_sink_crc.c +3 -3
index 720472f..2da2a61 100644
@@ -379,7 +379,7 @@ static void run_test(data_t *data)
 		expected = "still GREEN";
 		break;
 	case MMAP_GTT:
-		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
+		ptr = __gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
@@ -389,7 +389,7 @@ static void run_test(data_t *data)
 		expected = "BLACK or TRANSPARENT mark on top of plane in test";
 		break;
 	case MMAP_GTT_WAITING:
-		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
+		ptr = __gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
@@ -413,7 +413,7 @@ static void run_test(data_t *data)
 		expected = "BLACK or TRANSPARENT mark on top of plane in test";
 		break;
 	case MMAP_CPU:
-		ptr = gem_mmap__cpu(data->drm_fd, handle, 0, data->mod_size, PROT_WRITE);
+		ptr = __gem_mmap__cpu(data->drm_fd, handle, 0, data->mod_size, PROT_WRITE);
 		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
tests/pm_rpm.c +6 -6
index 026220b..7c3e7ca 100644
@@ -973,12 +973,12 @@ static void gem_mmap_subtest(bool gtt_mmap)
 	handle = gem_create(drm_fd, buf_size);
 
 	if (gtt_mmap) {
-		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
+		gem_buf = __gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
 		igt_assert(gem_buf);
 	}
 	else {
-		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
+		gem_buf = __gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
 		igt_assert(gem_buf);
 	}
 
@@ -1012,12 +1012,12 @@ static void gem_mmap_subtest(bool gtt_mmap)
 	disable_all_screens_and_wait(&ms_data);
 
 	if (gtt_mmap) {
-		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
+		gem_buf = __gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
 		igt_assert(gem_buf);
 	}
 	else {
-		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
+		gem_buf = __gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
 		igt_assert(gem_buf);
 	}
 
@@ -1474,7 +1474,7 @@ static void fill_igt_fb(struct igt_fb *fb, uint32_t color)
 	int i;
 	uint32_t *ptr;
 
-	ptr = gem_mmap__gtt(drm_fd, fb->gem_handle, fb->size, PROT_WRITE);
+	ptr = __gem_mmap__gtt(drm_fd, fb->gem_handle, fb->size, PROT_WRITE);
 	igt_assert(ptr);
 	for (i = 0; i < fb->size/sizeof(uint32_t); i++)
 		ptr[i] = color;
@@ -1756,7 +1756,7 @@ static void fences_subtest(bool dpms)
 	gem_get_tiling(drm_fd, params.fb.gem_handle, &tiling, &swizzle);
 	igt_assert(tiling);
 
-	buf_ptr = gem_mmap__gtt(drm_fd, params.fb.gem_handle,
+	buf_ptr = __gem_mmap__gtt(drm_fd, params.fb.gem_handle,
 				params.fb.size, PROT_WRITE | PROT_READ);
 	igt_assert(buf_ptr);
 	for (i = 0; i < params.fb.size/sizeof(uint32_t); i++)
tests/prime_self_import.c +2 -2
index 582c375..23d349e 100644
@@ -60,9 +60,9 @@ check_bo(int fd1, uint32_t handle1, int fd2, uint32_t handle2)
 	char *ptr1, *ptr2;
 	int i;
 
-	ptr1 = gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
+	ptr1 = __gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr1);
-	ptr2 = gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
+	ptr2 = __gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
 	igt_assert(ptr2);
 
 	/* check whether it's still our old object first. */
tests/testdisplay.c +1 -1
index af2c5b5..6d206e3 100644
@@ -221,7 +221,7 @@ paint_color_key(struct igt_fb *fb_info)
 	int i, j;
 	uint32_t *fb_ptr;
 
-	fb_ptr = gem_mmap__gtt(drm_fd, fb_info->gem_handle,
+	fb_ptr = __gem_mmap__gtt(drm_fd, fb_info->gem_handle,
 			  fb_info->size, PROT_READ | PROT_WRITE);
 	igt_assert(fb_ptr);
 
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#6 lore raw

PATCH 7/7 Replace __gem_mmap__{cpu, gtt, wc}() + igt_assert() with gem_mmap__{cpu, gtt, wc}()

In reply to [email protected]

From: Ville Syrjälä <[email protected]>

gem_mmap__{cpu,gtt,wc}() already has the assert built in, so replace
__gem_mmap__{cpu,gtt,wc}() + igt_assert() with it.

Mostly done with coccinelle, with some manual help:
@@
identifier I;
expression E1, E2, E3, E4, E5, E6;
@@
(
- I = __gem_mmap__gtt(E1, E2, E3, E4);
+ I = gem_mmap__gtt(E1, E2, E3, E4);
...
- igt_assert(I);
|
- I = __gem_mmap__cpu(E1, E2, E3, E4, E5);
+ I = gem_mmap__cpu(E1, E2, E3, E4, E5);
...
- igt_assert(I);
|
- I = __gem_mmap__wc(E1, E2, E3, E4, E5);
+ I = gem_mmap__wc(E1, E2, E3, E4, E5);
...
- igt_assert(I);
)

---
 benchmarks/gem_blt.c               |  3 +--
 benchmarks/gem_mmap.c              |  9 +++----
 lib/igt_draw.c                     |  9 +++----
 lib/igt_fb.c                       |  6 ++---
 tests/drv_suspend.c                | 10 +++----
 tests/gem_concurrent_all.c         | 18 +++++--------
 tests/gem_cs_tlb.c                 |  3 +--
 tests/gem_evict_everything.c       |  3 +--
 tests/gem_exec_faulting_reloc.c    |  5 ++--
 tests/gem_exec_lut_handle.c        |  3 +--
 tests/gem_fence_thrash.c           |  7 +++--
 tests/gem_fence_upload.c           | 12 +++------
 tests/gem_gtt_cpu_tlb.c            |  6 ++---
 tests/gem_gtt_hog.c                |  7 +++--
 tests/gem_gtt_speed.c              | 55 +++++++++++++++-----------------------
 tests/gem_largeobject.c            |  4 +--
 tests/gem_mmap.c                   |  3 +--
 tests/gem_mmap_gtt.c               | 26 +++++++-----------
 tests/gem_mmap_offset_exhaustion.c |  3 +--
 tests/gem_mmap_wc.c                | 21 +++++----------
 tests/gem_persistent_relocs.c      |  6 ++---
 tests/gem_pwrite.c                 |  3 +--
 tests/gem_pwrite_pread.c           | 24 ++++++-----------
 tests/gem_reloc_vs_gpu.c           |  5 ++--
 tests/gem_set_tiling_vs_gtt.c      |  3 +--
 tests/gem_set_tiling_vs_pwrite.c   |  3 +--
 tests/gem_streaming_writes.c       | 36 +++++++++++--------------
 tests/gem_tiled_pread_basic.c      |  4 +--
 tests/gem_tiled_pread_pwrite.c     |  7 +++--
 tests/gem_tiled_swapping.c         |  7 +++--
 tests/gem_tiled_wb.c               |  7 ++---
 tests/gem_tiled_wc.c               |  6 ++---
 tests/gem_tiling_max_stride.c      |  3 +--
 tests/gem_userptr_blits.c          | 11 ++++----
 tests/gen3_mixed_blits.c           |  7 +++--
 tests/gen3_render_mixed_blits.c    |  7 +++--
 tests/gen3_render_tiledx_blits.c   |  7 +++--
 tests/gen3_render_tiledy_blits.c   |  7 +++--
 tests/gen7_forcewake_mt.c          |  3 +--
 tests/kms_fbc_crc.c                |  6 ++---
 tests/kms_fence_pin_leak.c         |  3 +--
 tests/kms_psr_sink_crc.c           | 10 +++----
 tests/pm_rpm.c                     | 20 +++++---------
 tests/prime_self_import.c          |  6 ++---
 tests/testdisplay.c                |  5 ++--
 45 files changed, 158 insertions(+), 261 deletions(-)
benchmarks/gem_blt.c +1 -2
index e722541..181a5f1 100644
@@ -177,8 +177,7 @@ static int run(int object, int batch, int count, int reps)
 
 	fd = drm_open_driver(DRIVER_INTEL);
 	handle = gem_create(fd, size);
-	buf = __gem_mmap__cpu(fd, handle, 0, size, PROT_WRITE);
-	igt_assert(buf);
+	buf = gem_mmap__cpu(fd, handle, 0, size, PROT_WRITE);
 
 	gen = intel_gen(intel_get_drm_devid(fd));
 	has_64bit_reloc = gen >= 8;
benchmarks/gem_mmap.c +3 -6
index 571f757..bc26d31 100644
@@ -115,18 +115,15 @@ int main(int argc, char **argv)
 	handle = gem_create(fd, OBJECT_SIZE);
 	switch (map) {
 	case CPU:
-		ptr = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 		break;
 	case GTT:
-		ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
 	case WC:
-		ptr = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 		gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		break;
 	default:
lib/igt_draw.c +3 -6
index 07aa812..f85e376 100644
@@ -252,8 +252,7 @@ static void draw_rect_mmap_cpu(int fd, struct buf_data *buf, struct rect *rect,
 	if (tiling != I915_TILING_NONE)
 		igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
 
-	ptr = __gem_mmap__cpu(fd, buf->handle, 0, buf->size, 0);
-	igt_assert(ptr);
+	ptr = gem_mmap__cpu(fd, buf->handle, 0, buf->size, 0);
 
 	switch (tiling) {
 	case I915_TILING_NONE:
@@ -281,8 +280,7 @@ static void draw_rect_mmap_gtt(int fd, struct buf_data *buf, struct rect *rect,
 	gem_set_domain(fd, buf->handle, I915_GEM_DOMAIN_GTT,
 		       I915_GEM_DOMAIN_GTT);
 
-	ptr = __gem_mmap__gtt(fd, buf->handle, buf->size, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, buf->handle, buf->size, PROT_READ | PROT_WRITE);
 
 	draw_rect_ptr_linear(ptr, buf->stride, rect, color, buf->bpp);
 
@@ -303,9 +301,8 @@ static void draw_rect_mmap_wc(int fd, struct buf_data *buf, struct rect *rect,
 	if (tiling != I915_TILING_NONE)
 		igt_require(intel_gen(intel_get_drm_devid(fd)) >= 5);
 
-	ptr = __gem_mmap__wc(fd, buf->handle, 0, buf->size,
+	ptr = gem_mmap__wc(fd, buf->handle, 0, buf->size,
 			   PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
 
 	switch (tiling) {
 	case I915_TILING_NONE:
lib/igt_fb.c +2 -4
index 5ab063f..13a6a34 100644
@@ -745,12 +745,11 @@ static void create_cairo_surface__blit(int fd, struct igt_fb *fb)
 		       I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 
 	/* Setup cairo context */
-	blit->linear.map = __gem_mmap__cpu(fd,
+	blit->linear.map = gem_mmap__cpu(fd,
 					 blit->linear.handle,
 					 0,
 					 blit->linear.size,
 					 PROT_READ | PROT_WRITE);
-	igt_assert(blit->linear.map);
 
 	cairo_format = drm_format_to_cairo(fb->drm_format);
 	fb->cairo_surface =
@@ -774,8 +773,7 @@ static void destroy_cairo_surface__gtt(void *arg)
 
 static void create_cairo_surface__gtt(int fd, struct igt_fb *fb)
 {
-	void *ptr = __gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	void *ptr = gem_mmap__gtt(fd, fb->gem_handle, fb->size, PROT_READ | PROT_WRITE);
 
 	fb->cairo_surface =
 		cairo_image_surface_create_for_data(ptr,
tests/drv_suspend.c +4 -6
index b85dd2f..601a32e 100644
@@ -56,20 +56,18 @@ test_fence_restore(int fd, bool tiled2untiled, bool hibernate)
 	handle_tiled = gem_create(fd, OBJECT_SIZE);
 
 	/* Access the buffer objects in the order we want to have the laid out. */
-	ptr1 = __gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr1);
+	ptr1 = gem_mmap__gtt(fd, handle1, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr1[i] = i;
 
-	ptr_tiled = __gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr_tiled);
+	ptr_tiled = gem_mmap__gtt(fd, handle_tiled, OBJECT_SIZE,
+				  PROT_READ | PROT_WRITE);
 	if (tiled2untiled)
 		gem_set_tiling(fd, handle_tiled, I915_TILING_X, 2048);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr_tiled[i] = i;
 
-	ptr2 = __gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr2);
+	ptr2 = gem_mmap__gtt(fd, handle2, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < OBJECT_SIZE/sizeof(uint32_t); i++)
 		ptr2[i] = i;
 
tests/gem_concurrent_all.c +6 -12
index 5b8c3f0..80a8697 100644
@@ -471,10 +471,8 @@ static void cpu_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_CPU, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
-	s = __gem_mmap__cpu(fd, src->handle, 0, size, PROT_READ);
-	igt_assert(s);
-	d = __gem_mmap__cpu(fd, dst->handle, 0, size, PROT_WRITE);
-	igt_assert(d);
+	s = gem_mmap__cpu(fd, src->handle, 0, size, PROT_READ);
+	d = gem_mmap__cpu(fd, dst->handle, 0, size, PROT_WRITE);
 
 	memcpy(d, s, size);
 
@@ -490,10 +488,8 @@ static void gtt_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_GTT, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	s = __gem_mmap__gtt(fd, src->handle, size, PROT_READ);
-	igt_assert(s);
-	d = __gem_mmap__gtt(fd, dst->handle, size, PROT_WRITE);
-	igt_assert(d);
+	s = gem_mmap__gtt(fd, src->handle, size, PROT_READ);
+	d = gem_mmap__gtt(fd, dst->handle, size, PROT_WRITE);
 
 	memcpy(d, s, size);
 
@@ -509,10 +505,8 @@ static void wc_copy_bo(drm_intel_bo *dst, drm_intel_bo *src)
 	gem_set_domain(fd, src->handle, I915_GEM_DOMAIN_GTT, 0);
 	gem_set_domain(fd, dst->handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	s = __gem_mmap__wc(fd, src->handle, 0, size, PROT_READ);
-	igt_assert(s);
-	d = __gem_mmap__wc(fd, dst->handle, 0, size, PROT_WRITE);
-	igt_assert(d);
+	s = gem_mmap__wc(fd, src->handle, 0, size, PROT_READ);
+	d = gem_mmap__wc(fd, dst->handle, 0, size, PROT_WRITE);
 
 	memcpy(d, s, size);
 
tests/gem_cs_tlb.c +1 -2
index 71e5996..8b640fa 100644
@@ -115,9 +115,8 @@ static void run_on_ring(int fd, unsigned ring_id, const char *ring_name)
 		igt_progress(buf, split, BATCH_SIZE/8 - 1);
 
 		handle_new = gem_create(fd, BATCH_SIZE);
-		batch_ptr = __gem_mmap__cpu(fd, handle_new, 0, BATCH_SIZE,
+		batch_ptr = gem_mmap__cpu(fd, handle_new, 0, BATCH_SIZE,
 					  PROT_READ | PROT_WRITE);
-		igt_assert(batch_ptr);
 		batch_ptr[split*2] = MI_BATCH_BUFFER_END;
 
 		for (i = split*2 + 2; i < BATCH_SIZE/8; i++)
tests/gem_evict_everything.c +1 -2
index 93ec7a5..ebf59f9 100644
@@ -132,9 +132,8 @@ copy(int fd, uint32_t dst, uint32_t src, uint32_t *all_bo, int n_bo)
 
 static void clear(int fd, uint32_t handle, int size)
 {
-	void *base = __gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
+	void *base = gem_mmap__cpu(fd, handle, 0, size, PROT_READ | PROT_WRITE);
 
-	igt_assert(base != NULL);
 	memset(base, 0, size);
 	munmap(base, size);
 }
tests/gem_exec_faulting_reloc.c +2 -3
index 67fc410..dcd3734 100644
@@ -200,9 +200,8 @@ static void run(int object_size)
 
 	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);
-	igt_assert(gtt_relocs);
+	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
+				   PROT_READ | PROT_WRITE);
 
 	exec[2].handle = handle;
 	if (intel_gen(devid) >= 8)
tests/gem_exec_lut_handle.c +1 -2
index 0af27bb..672635c 100644
@@ -123,8 +123,7 @@ igt_simple_main
 
 	size = ALIGN(sizeof(mem_reloc), 4096);
 	reloc_handle = gem_create(fd, size);
-	reloc = __gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
-	igt_assert(reloc);
+	reloc = gem_mmap__cpu(fd, reloc_handle, 0, size, PROT_READ | PROT_WRITE);
 	for (n = 0; n < MAX_NUM_RELOC; n++) {
 		reloc[n].offset = 1024;
 		reloc[n].read_domains = I915_GEM_DOMAIN_RENDER;
tests/gem_fence_thrash.c +3 -4
index 1161e73..52095f2 100644
@@ -67,15 +67,14 @@ bo_create (int fd, int tiling)
 	handle = gem_create(fd, OBJECT_SIZE);
 
 	/* dirty cpu caches a bit ... */
-	ptr = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE,
+			    PROT_READ | PROT_WRITE);
 	memset(ptr, 0, OBJECT_SIZE);
 	munmap(ptr, OBJECT_SIZE);
 
 	gem_set_tiling(fd, handle, tiling, 1024);
 
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 	gem_close(fd, handle);
tests/gem_fence_upload.c +4 -8
index d2cbc30..7d9acdc 100644
@@ -68,8 +68,7 @@ static void performance(void)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = __gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
-			igt_assert(ptr[n]);
+			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		}
 
 		gettimeofday(&start, NULL);
@@ -176,8 +175,7 @@ static void thread_performance(unsigned mask)
 
 		for (n = 0; n < count; n++) {
 			handle[n] = gem_create(fd, OBJECT_SIZE);
-			ptr[n] = __gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
-			igt_assert(ptr[n]);
+			ptr[n] = gem_mmap__gtt(fd, handle[n], OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 			if (mask & READ) {
 				readers[n].id = n;
@@ -257,8 +255,7 @@ static void *no_contention(void *closure)
 	int n;
 
 	for (n = 0; n < t->loops; n++) {
-		uint32_t *ptr = __gem_mmap__gtt(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-		igt_assert(ptr);
+		uint32_t *ptr = gem_mmap__gtt(t->fd, t->handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		memset(ptr + (rand() % 256) * 4096 / 4, 0, 4096);
 		munmap(ptr, OBJECT_SIZE);
 	}
@@ -272,8 +269,7 @@ static void *wc_mmap(void *closure)
 	int n;
 
 	for (n = 0; n < t->loops; n++) {
-		uint32_t *ptr = __gem_mmap__wc(t->fd, t->handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-		igt_assert(ptr);
+		uint32_t *ptr = gem_mmap__wc(t->fd, t->handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 		memset(ptr + (rand() % 256) * 4096 / 4, 0, 4096);
 		munmap(ptr, OBJECT_SIZE);
 	}
tests/gem_gtt_cpu_tlb.c +2 -4
index 9125c34..8ceef44 100644
@@ -59,8 +59,7 @@ create_bo(int fd)
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* Fill the BO with dwords starting at start_val */
-	data = __gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < OBJ_SIZE/4; i++)
 		data[i] = i;
 	munmap(data, OBJ_SIZE);
@@ -83,8 +82,7 @@ igt_simple_main
 	handle = gem_create(fd, OBJ_SIZE);
 
 	/* touch one page */
-	ptr = __gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJ_SIZE, PROT_READ | PROT_WRITE);
 	*ptr = 0xdeadbeef;
 	munmap(ptr, OBJ_SIZE);
 
tests/gem_gtt_hog.c +3 -4
index 28df7a7..7ca7d12 100644
@@ -140,12 +140,11 @@ static void run(data_t *data, int child)
 	 * set-to-gtt-domain within the fault handler.
 	 */
 	if (write) {
-		ptr = __gem_mmap__gtt(data->fd, handle, size, PROT_READ | PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__gtt(data->fd, handle, size,
+				    PROT_READ | PROT_WRITE);
 		ptr[rand() % (size / 4)] = canary;
 	} else {
-		ptr = __gem_mmap__gtt(data->fd, handle, size, PROT_READ);
-		igt_assert(ptr);
+		ptr = gem_mmap__gtt(data->fd, handle, size, PROT_READ);
 	}
 	x = ptr[rand() % (size / 4)];
 	munmap(ptr, size);
tests/gem_gtt_speed.c +22 -33

166 lines not on this page · raw message

tests/gem_largeobject.c +2 -2
index 0da8205..c001c17 100644
@@ -64,8 +64,8 @@ test_large_object(int fd)
 	igt_assert(ioctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create) == 0);
 
 	/* prefault */
-	ptr = __gem_mmap__gtt(fd, create.handle, obj_size, PROT_WRITE | PROT_READ);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, create.handle, obj_size,
+			    PROT_WRITE | PROT_READ);
 	*ptr = 0;
 
 	gem_write(fd, create.handle, 0, data, obj_size);
tests/gem_mmap.c +1 -2
index 37d0933..2e0d725 100644
@@ -166,8 +166,7 @@ igt_main
 	igt_subtest("short-mmap") {
 		igt_assert(OBJECT_SIZE > 4096);
 		arg.handle = gem_create(fd, OBJECT_SIZE);
-		addr = __gem_mmap__cpu(fd, arg.handle, 0, 4096, PROT_WRITE);
-		igt_assert(addr);
+		addr = gem_mmap__cpu(fd, arg.handle, 0, 4096, PROT_WRITE);
 		memset(addr, 0, 4096);
 		munmap(addr, 4096);
 		gem_close(fd, arg.handle);
tests/gem_mmap_gtt.c +9 -17
index 0cfb6f6..62ba35f 100644
@@ -56,8 +56,7 @@ mmap_bo(int fd, uint32_t handle)
 {
 	void *ptr;
 
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	return ptr;
 }
@@ -179,8 +178,7 @@ test_read_write(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)ptr;
@@ -203,11 +201,9 @@ test_read_write2(int fd, enum test_read_write order)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	r = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
-	igt_assert(r);
+	r = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 
-	w = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(w);
+	w = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)r;
@@ -291,13 +287,11 @@ test_huge_bo(int fd, int huge, int tiling)
 	bo = gem_create(fd, PAGE_SIZE);
 	if (tiling)
 		gem_set_tiling(fd, bo, tiling, pitch);
-	linear_pattern = __gem_mmap__gtt(fd, bo, PAGE_SIZE,
+	linear_pattern = gem_mmap__gtt(fd, bo, PAGE_SIZE,
 				       PROT_READ | PROT_WRITE);
-	igt_assert(linear_pattern);
 	for (i = 0; i < PAGE_SIZE; i++)
 		linear_pattern[i] = i;
-	tiled_pattern = __gem_mmap__cpu(fd, bo, 0, PAGE_SIZE, PROT_READ);
-	igt_assert(tiled_pattern);
+	tiled_pattern = gem_mmap__cpu(fd, bo, 0, PAGE_SIZE, PROT_READ);
 
 	gem_set_domain(fd, bo, I915_GEM_DOMAIN_CPU | I915_GEM_DOMAIN_GTT, 0);
 	gem_close(fd, bo);
@@ -307,7 +301,7 @@ test_huge_bo(int fd, int huge, int tiling)
 		gem_set_tiling(fd, bo, tiling, pitch);
 
 	/* Initialise first/last page through CPU mmap */
-	ptr = __gem_mmap__cpu(fd, bo, 0, size, PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__cpu(fd, bo, 0, size, PROT_READ | PROT_WRITE);
 	memcpy(ptr, tiled_pattern, PAGE_SIZE);
 	memcpy(ptr + last_offset, tiled_pattern, PAGE_SIZE);
 	munmap(ptr, size);
@@ -440,11 +434,9 @@ test_write_cpu_read_gtt(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	dst = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst);
+	dst = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ);
 
-	src = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src);
+	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 
 	gem_close(fd, handle);
 
tests/gem_mmap_offset_exhaustion.c +1 -2
index 50153cc..8c8e3fa 100644
@@ -60,8 +60,7 @@ create_and_map_bo(int fd)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	/* touch it to force it into the gtt */
 	*ptr = 0;
tests/gem_mmap_wc.c +7 -14
index 377749c..91588a4 100644
@@ -62,8 +62,7 @@ mmap_bo(int fd, uint32_t handle)
 {
 	void *ptr;
 
-	ptr = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	return ptr;
 }
@@ -183,11 +182,9 @@ test_read_write2(int fd, enum test_read_write order)
 	handle = gem_create(fd, OBJECT_SIZE);
 	set_domain(fd, handle);
 
-	r = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(r);
+	r = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 
-	w = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(w);
+	w = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	if (order == READ_BEFORE_WRITE) {
 		val = *(uint32_t *)r;
@@ -288,11 +285,9 @@ test_write_cpu_read_wc(int fd, int force_domain)
 
 	handle = gem_create(fd, OBJECT_SIZE);
 
-	dst = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst);
+	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 
-	src = __gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src);
+	src = gem_mmap__cpu(fd, handle, 0, OBJECT_SIZE, PROT_WRITE);
 
 	memset(src, 0xaa, OBJECT_SIZE);
 	if (force_domain)
@@ -315,11 +310,9 @@ test_write_gtt_read_wc(int fd)
 	handle = gem_create(fd, OBJECT_SIZE);
 	set_domain(fd, handle);
 
-	dst = __gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst);
+	dst = gem_mmap__wc(fd, handle, 0, OBJECT_SIZE, PROT_READ);
 
-	src = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src);
+	src = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_WRITE);
 
 	memset(src, 0xaa, OBJECT_SIZE);
 	igt_assert(memcmp(dst, src, OBJECT_SIZE) == 0);
tests/gem_persistent_relocs.c +2 -4
index db69f3a..509c812 100644
@@ -225,10 +225,8 @@ static void do_test(int fd, bool faulting_reloc)
 
 		relocs_bo_handle[i] = gem_create(fd, 4096);
 		gem_write(fd, relocs_bo_handle[i], 0, reloc, sizeof(reloc));
-		gtt_relocs_ptr[i] = __gem_mmap__gtt(fd, relocs_bo_handle[i], 4096,
-				      PROT_READ | PROT_WRITE);
-		igt_assert(gtt_relocs_ptr[i]);
-
+		gtt_relocs_ptr[i] = gem_mmap__gtt(fd, relocs_bo_handle[i], 4096,
+						  PROT_READ | PROT_WRITE);
 	}
 
 	/* repeat must be smaller than 4096/small_pitch */
tests/gem_pwrite.c +1 -2
index 8080981..3a913f9 100644
@@ -118,8 +118,7 @@ static void test_big_gtt(int fd, int scale)
 	handle = gem_create(fd, size);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
-	ptr = __gem_mmap__wc(fd, handle, 0, size, PROT_READ);
-	igt_assert(ptr);
+	ptr = gem_mmap__wc(fd, handle, 0, size, PROT_READ);
 
 	for (offset = 0; offset < size; offset += 4096) {
 		int suboffset = (offset >> 12) % (4096 / sizeof(offset) - 1) * sizeof(offset);
tests/gem_pwrite_pread.c +8 -16
index 5408140..ef8890e 100644
@@ -112,10 +112,8 @@ static void as_gtt_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	uint32_t *src_ptr, *dst_ptr;
 	BUILD_EXEC;
 
-	src_ptr = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src_ptr);
-	dst_ptr = __gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst_ptr);
+	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 
 	while (loops--) {
 		gem_set_domain(fd, src,
@@ -139,10 +137,8 @@ static void as_cpu_mmap(int fd, uint32_t src, uint32_t dst, void *buf, int len,
 	uint32_t *src_ptr, *dst_ptr;
 	BUILD_EXEC;
 
-	src_ptr = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src_ptr);
-	dst_ptr = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst_ptr);
+	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 
 	while (loops--) {
 		gem_set_domain(fd, src,
@@ -186,10 +182,8 @@ static void test_as_gtt_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	int i;
 	BUILD_EXEC;
 
-	src_ptr = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src_ptr);
-	dst_ptr = __gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst_ptr);
+	src_ptr = gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_WRITE);
+	dst_ptr = gem_mmap__gtt(fd, dst, OBJECT_SIZE, PROT_READ);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 	for (i = 0; i < len/4; i++)
@@ -212,10 +206,8 @@ static void test_as_cpu_mmap(int fd, uint32_t src, uint32_t dst, int len)
 	int i;
 	BUILD_EXEC;
 
-	src_ptr = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
-	igt_assert(src_ptr);
-	dst_ptr = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(dst_ptr);
+	src_ptr = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_WRITE);
+	dst_ptr = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 
 	gem_set_domain(fd, src, I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 	for (i = 0; i < len/4; i++)
tests/gem_reloc_vs_gpu.c +2 -3
index 59ba8c0..e06b98a 100644
@@ -162,9 +162,8 @@ static void reloc_and_emit(int fd, drm_intel_bo *target_bo, bool faulting_reloc)
 
 	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);
-	igt_assert(gtt_relocs);
+	gtt_relocs = gem_mmap__gtt(fd, handle_relocs, 4096,
+				   PROT_READ | PROT_WRITE);
 
 	exec[1].handle = special_bo->handle;
 	exec[1].relocation_count = 1;
tests/gem_set_tiling_vs_gtt.c +1 -2
index 6f04735..2611ec5 100644
@@ -66,8 +66,7 @@ igt_simple_main
 		tile_height = 8;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	/* gtt coherency is done with set_domain in libdrm, don't break that */
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
tests/gem_set_tiling_vs_pwrite.c +1 -2
index 5c2e93a..006edfe 100644
@@ -62,8 +62,7 @@ igt_simple_main
 		data[i] = i;
 
 	handle = gem_create(fd, OBJECT_SIZE);
-	ptr = __gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
 	gem_set_tiling(fd, handle, I915_TILING_X, TEST_STRIDE);
 
tests/gem_streaming_writes.c +16 -20
index 6664582..5b365c9 100644
@@ -88,22 +88,21 @@ static void test_streaming(int fd, int mode, int sync)
 	switch (mode) {
 	case 0: /* cpu/snoop */
 		gem_set_caching(fd, src, I915_CACHING_CACHED);
-		s = __gem_mmap__cpu(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-		igt_assert(s);
+		s = gem_mmap__cpu(fd, src, 0, OBJECT_SIZE,
+				  PROT_READ | PROT_WRITE);
 		break;
 	case 1: /* gtt */
-		s = __gem_mmap__gtt(fd, src, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-		igt_assert(s);
+		s = gem_mmap__gtt(fd, src, OBJECT_SIZE,
+				  PROT_READ | PROT_WRITE);
 		break;
 	case 2: /* wc */
-		s = __gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-		igt_assert(s);
+		s = gem_mmap__wc(fd, src, 0, OBJECT_SIZE,
+				 PROT_READ | PROT_WRITE);
 		break;
 	}
 	*s = 0; /* fault the object into the mappable range first (for GTT) */
 
-	d = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(d);
+	d = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 
 	gem_write(fd, dst, 0, tmp, sizeof(tmp));
 	memset(&execbuf, 0, sizeof(execbuf));
@@ -154,8 +153,7 @@ static void test_streaming(int fd, int mode, int sync)
 		batch[i].handle = gem_create(fd, 4096);
 		batch[i].offset = 0;
 
-		base = __gem_mmap__cpu(fd, batch[i].handle, 0, 4096, PROT_WRITE);
-		igt_assert(base);
+		base = gem_mmap__cpu(fd, batch[i].handle, 0, 4096, PROT_WRITE);
 
 		for (int j = 0; j < 64; j++) {
 			unsigned x = (n * CHUNK_SIZE) % 4096 >> 2;
@@ -254,11 +252,9 @@ static void test_batch(int fd, int mode, int reverse)
 	exec[DST].handle = gem_create(fd, OBJECT_SIZE);
 	exec[SRC].handle = gem_create(fd, OBJECT_SIZE);
 
-	s = __gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(s);
+	s = gem_mmap__wc(fd, src, 0, OBJECT_SIZE, PROT_READ | PROT_WRITE);
 
-	d = __gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
-	igt_assert(d);
+	d = gem_mmap__cpu(fd, dst, 0, OBJECT_SIZE, PROT_READ);
 
 	memset(reloc, 0, sizeof(reloc));
 	reloc[0].offset =  4 * sizeof(uint32_t);
@@ -285,16 +281,16 @@ static void test_batch(int fd, int mode, int reverse)
 	switch (mode) {
 	case 0: /* cpu/snoop */
 		igt_require(gem_has_llc(fd));
-		base = __gem_mmap__cpu(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
-		igt_assert(base);
+		base = gem_mmap__cpu(fd, exec[BATCH].handle, 0, batch_size,
+				     PROT_READ | PROT_WRITE);
 		break;
 	case 1: /* gtt */
-		base = __gem_mmap__gtt(fd, exec[BATCH].handle, batch_size, PROT_READ | PROT_WRITE);
-		igt_assert(base);
+		base = gem_mmap__gtt(fd, exec[BATCH].handle, batch_size,
+				     PROT_READ | PROT_WRITE);
 		break;
 	case 2: /* wc */
-		base = __gem_mmap__wc(fd, exec[BATCH].handle, 0, batch_size, PROT_READ | PROT_WRITE);
-		igt_assert(base);
+		base = gem_mmap__wc(fd, exec[BATCH].handle, 0, batch_size,
+				    PROT_READ | PROT_WRITE);
 		break;
 	}
 	*base = 0; /* fault the object into the mappable range first */
tests/gem_tiled_pread_basic.c +2 -2
index 14a3706..1dfd87c 100644
@@ -72,8 +72,8 @@ create_bo(int fd)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, sizeof(linear),
+			     PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
tests/gem_tiled_pread_pwrite.c +3 -4
index 8ae23e3..a1d6ed5 100644
@@ -79,8 +79,8 @@ create_bo_and_fill(int fd)
 	gem_set_tiling(fd, handle, current_tiling_mode, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, sizeof(linear),
+			     PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, sizeof(linear));
@@ -123,8 +123,7 @@ igt_simple_main
 		gem_write(fd, handle_target, 0, linear, sizeof(linear));
 
 		/* Check the target bo's contents. */
-		data = __gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
-		igt_assert(data);
+		data = gem_mmap__gtt(fd, handle_target, sizeof(linear), PROT_READ | PROT_WRITE);
 		for (j = 0; j < WIDTH*HEIGHT; j++)
 			igt_assert_f(data[j] == j,
 				     "mismatch at %i: %i\n",
tests/gem_tiled_swapping.c +3 -4
index 730e625..f45244b 100644
@@ -94,8 +94,8 @@ fill_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int i;
 
-	data = __gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS,
+			     PROT_READ | PROT_WRITE);
 
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
@@ -109,8 +109,7 @@ check_bo(int fd, uint32_t handle)
 	uint32_t *data;
 	int j;
 
-	data = __gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, LINEAR_DWORDS, PROT_READ);
 	gem_set_domain(fd, handle, I915_GEM_DOMAIN_GTT, 0);
 	j = rand() % (WIDTH * HEIGHT);
 	igt_assert_f(data[j] == j, "mismatch at %i: %i\n", j, data[j]);
tests/gem_tiled_wb.c +2 -5
index 0a30a48..227ebde 100644
@@ -71,8 +71,7 @@ create_bo(int fd)
 	/* Write throught the fence to tiled the data.
 	 * We then manually detile on reading back through the mmap(wc).
 	 */
-	data = __gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, SIZE);
@@ -179,9 +178,7 @@ igt_simple_main
 		last_page = (offset + len + PAGE_SIZE) & ~(PAGE_SIZE-1);
 		offset -= first_page;
 
-		linear = __gem_mmap__cpu(fd, handle, first_page, last_page - first_page, PROT_READ);
-		igt_assert(linear);
-
+		linear = gem_mmap__cpu(fd, handle, first_page, last_page - first_page, PROT_READ);
 
 		/* Translate from offsets in the read buffer to the swizzled
 		 * address that it corresponds to.  This is the opposite of
tests/gem_tiled_wc.c +2 -4
index 66b35c8..a6316cc 100644
@@ -65,8 +65,7 @@ create_bo(int fd)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH * sizeof(uint32_t));
 
 	/* Fill the BO with dwords starting at start_val */
-	data = __gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(data);
+	data = gem_mmap__gtt(fd, handle, SIZE, PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		data[i] = i;
 	munmap(data, SIZE);
@@ -174,8 +173,7 @@ igt_simple_main
 		first_page = offset & ~(PAGE_SIZE-1);
 		last_page = (offset + len + PAGE_SIZE) & ~(PAGE_SIZE-1);
 
-		linear = __gem_mmap__wc(fd, handle, first_page, last_page - first_page, PROT_READ);
-		igt_assert(linear);
+		linear = gem_mmap__wc(fd, handle, first_page, last_page - first_page, PROT_READ);
 
 		/* Translate from offsets in the read buffer to the swizzled
 		 * address that it corresponds to.  This is the opposite of
tests/gem_tiling_max_stride.c +1 -2
index 0867335..a6f97a9 100644
@@ -97,8 +97,7 @@ igt_simple_main
 
 	handle = gem_create(fd, size);
 
-	ptr = __gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(fd, handle, size, PROT_READ | PROT_WRITE);
 
 	test_invalid_tiling(fd, handle, 0);
 	test_invalid_tiling(fd, handle, 64);
tests/gem_userptr_blits.c +5 -6
index 93461c2..6a6d5bf 100644
@@ -544,9 +544,9 @@ static int test_invalid_gtt_mapping(int fd)
 
 	/* GTT mapping */
 	handle = create_bo(fd, 0);
-	ptr = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
+	ptr = gem_mmap__gtt(fd, handle, sizeof(linear),
+			    PROT_READ | PROT_WRITE);
 	gem_close(fd, handle);
-	igt_assert(ptr);
 	igt_assert(((unsigned long)ptr & (PAGE_SIZE - 1)) == 0);
 	igt_assert((sizeof(linear) & (PAGE_SIZE - 1)) == 0);
 
@@ -688,13 +688,12 @@ static void *umap(int fd, uint32_t handle)
 	void *ptr;
 
 	if (gem_has_llc(fd)) {
-		ptr = __gem_mmap__gtt(fd, handle, sizeof(linear), PROT_READ | PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__gtt(fd, handle, sizeof(linear),
+				    PROT_READ | PROT_WRITE);
 	} else {
 		uint32_t tmp = gem_create(fd, sizeof(linear));
 		copy(fd, tmp, handle, 0);
-		ptr = __gem_mmap__cpu(fd, tmp, 0, sizeof(linear), PROT_READ);
-		igt_assert(ptr);
+		ptr = gem_mmap__cpu(fd, tmp, 0, sizeof(linear), PROT_READ);
 		gem_close(fd, tmp);
 	}
 
tests/gen3_mixed_blits.c +3 -4
index 0089eb3..dce92b0 100644
@@ -426,8 +426,8 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4,
+			  PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
 	munmap(v, WIDTH*HEIGHT*4);
@@ -441,8 +441,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4, PROT_READ);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
 			     "Expected 0x%08x, found 0x%08x "
tests/gen3_render_mixed_blits.c +3 -4
index 6dd728d..6cc8d05 100644
@@ -314,8 +314,8 @@ create_bo(int fd, uint32_t val, int tiling)
 	gem_set_tiling(fd, handle, tiling, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4,
+			  PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
 	munmap(v, WIDTH*HEIGHT*4);
@@ -329,8 +329,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4, PROT_READ);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
 			     "Expected 0x%08x, found 0x%08x "
tests/gen3_render_tiledx_blits.c +3 -4
index 1abcaaa..6706d3a 100644
@@ -301,8 +301,8 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_X, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4,
+			  PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
 	munmap(v, WIDTH*HEIGHT*4);
@@ -316,8 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4, PROT_READ);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
 			     "Expected 0x%08x, found 0x%08x "
tests/gen3_render_tiledy_blits.c +3 -4
index e90645a..44e88d4 100644
@@ -301,8 +301,8 @@ create_bo(int fd, uint32_t val)
 	gem_set_tiling(fd, handle, I915_TILING_Y, WIDTH*4);
 
 	/* Fill the BO with dwords starting at val */
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ | PROT_WRITE);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4,
+			  PROT_READ | PROT_WRITE);
 	for (i = 0; i < WIDTH*HEIGHT; i++)
 		v[i] = val++;
 	munmap(v, WIDTH*HEIGHT*4);
@@ -316,8 +316,7 @@ check_bo(int fd, uint32_t handle, uint32_t val)
 	uint32_t *v;
 	int i;
 
-	v = __gem_mmap__gtt(fd, handle, WIDTH*HEIGHT*4, PROT_READ);
-	igt_assert(v);
+	v = gem_mmap__gtt(fd, handle, WIDTH * HEIGHT * 4, PROT_READ);
 	for (i = 0; i < WIDTH*HEIGHT; i++) {
 		igt_assert_f(v[i] == val,
 			     "Expected 0x%08x, found 0x%08x "
tests/gen7_forcewake_mt.c +1 -2
index f7a5aa1..dea1e8a 100644
@@ -190,8 +190,7 @@ igt_simple_main
 		gem_execbuf(t[0].fd, &execbuf);
 		gem_sync(t[0].fd, exec[1].handle);
 
-		p = __gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
-		igt_assert(p);
+		p = gem_mmap__gtt(t[0].fd, exec[0].handle, 4096, PROT_READ);
 
 		igt_info("[%d]={ %08x %08x }\n", i, p[0], p[1]);
 		igt_assert(p[0] & 2);
tests/kms_fbc_crc.c +2 -4
index c31dbdd..d580a94 100644
@@ -188,8 +188,7 @@ static void fill_mmap_cpu(data_t *data, uint32_t handle, unsigned char color)
 {
 	void *ptr;
 
-	ptr = __gem_mmap__cpu(data->drm_fd, handle, 0, 4096, PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__cpu(data->drm_fd, handle, 0, 4096, PROT_WRITE);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_CPU,
 		       I915_GEM_DOMAIN_CPU);
 	memset(ptr, color, 4);
@@ -201,8 +200,7 @@ static void fill_mmap_gtt(data_t *data, uint32_t handle, unsigned char color)
 {
 	void *ptr;
 
-	ptr = __gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
 	gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT,
 		       I915_GEM_DOMAIN_GTT);
 	memset(ptr, color, 4);
tests/kms_fence_pin_leak.c +1 -2
index 41ce084..7d4ffbc 100644
@@ -89,8 +89,7 @@ static void touch_fences(data_t *data)
 		uint32_t handle = data->bos[i]->handle;
 		void *ptr;
 
-		ptr = __gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__gtt(data->drm_fd, handle, 4096, PROT_WRITE);
 		gem_set_domain(data->drm_fd, handle, I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		memset(ptr, 0, 4);
 		munmap(ptr, 4096);
tests/kms_psr_sink_crc.c +4 -6
index 2da2a61..387c615 100644
@@ -379,9 +379,8 @@ static void run_test(data_t *data)
 		expected = "still GREEN";
 		break;
 	case MMAP_GTT:
-		ptr = __gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
+		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
-		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 		memset(ptr, 0xcc, data->mod_size);
@@ -389,9 +388,8 @@ static void run_test(data_t *data)
 		expected = "BLACK or TRANSPARENT mark on top of plane in test";
 		break;
 	case MMAP_GTT_WAITING:
-		ptr = __gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
+		ptr = gem_mmap__gtt(data->drm_fd, handle, data->mod_size,
 				    PROT_WRITE);
-		igt_assert(ptr);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_GTT, I915_GEM_DOMAIN_GTT);
 
@@ -413,8 +411,8 @@ static void run_test(data_t *data)
 		expected = "BLACK or TRANSPARENT mark on top of plane in test";
 		break;
 	case MMAP_CPU:
-		ptr = __gem_mmap__cpu(data->drm_fd, handle, 0, data->mod_size, PROT_WRITE);
-		igt_assert(ptr);
+		ptr = gem_mmap__cpu(data->drm_fd, handle, 0, data->mod_size,
+				    PROT_WRITE);
 		gem_set_domain(data->drm_fd, handle,
 			       I915_GEM_DOMAIN_CPU, I915_GEM_DOMAIN_CPU);
 		memset(ptr, 0, data->mod_size);
tests/pm_rpm.c +7 -13
index 7c3e7ca..d43cc06 100644
@@ -973,13 +973,11 @@ static void gem_mmap_subtest(bool gtt_mmap)
 	handle = gem_create(drm_fd, buf_size);
 
 	if (gtt_mmap) {
-		gem_buf = __gem_mmap__gtt(drm_fd, handle, buf_size,
+		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
-		igt_assert(gem_buf);
 	}
 	else {
-		gem_buf = __gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
-		igt_assert(gem_buf);
+		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
 	}
 
 
@@ -1012,13 +1010,11 @@ static void gem_mmap_subtest(bool gtt_mmap)
 	disable_all_screens_and_wait(&ms_data);
 
 	if (gtt_mmap) {
-		gem_buf = __gem_mmap__gtt(drm_fd, handle, buf_size,
+		gem_buf = gem_mmap__gtt(drm_fd, handle, buf_size,
 					PROT_READ | PROT_WRITE);
-		igt_assert(gem_buf);
 	}
 	else {
-		gem_buf = __gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
-		igt_assert(gem_buf);
+		gem_buf = gem_mmap__cpu(drm_fd, handle, 0, buf_size, 0);
 	}
 
 	igt_assert(wait_for_suspended());
@@ -1474,8 +1470,7 @@ static void fill_igt_fb(struct igt_fb *fb, uint32_t color)
 	int i;
 	uint32_t *ptr;
 
-	ptr = __gem_mmap__gtt(drm_fd, fb->gem_handle, fb->size, PROT_WRITE);
-	igt_assert(ptr);
+	ptr = gem_mmap__gtt(drm_fd, fb->gem_handle, fb->size, PROT_WRITE);
 	for (i = 0; i < fb->size/sizeof(uint32_t); i++)
 		ptr[i] = color;
 	igt_assert(munmap(ptr, fb->size) == 0);
@@ -1756,9 +1751,8 @@ static void fences_subtest(bool dpms)
 	gem_get_tiling(drm_fd, params.fb.gem_handle, &tiling, &swizzle);
 	igt_assert(tiling);
 
-	buf_ptr = __gem_mmap__gtt(drm_fd, params.fb.gem_handle,
-				params.fb.size, PROT_WRITE | PROT_READ);
-	igt_assert(buf_ptr);
+	buf_ptr = gem_mmap__gtt(drm_fd, params.fb.gem_handle, params.fb.size,
+				PROT_WRITE | PROT_READ);
 	for (i = 0; i < params.fb.size/sizeof(uint32_t); i++)
 		buf_ptr[i] = i;
 
tests/prime_self_import.c +2 -4
index 23d349e..91fe231 100644
@@ -60,10 +60,8 @@ check_bo(int fd1, uint32_t handle1, int fd2, uint32_t handle2)
 	char *ptr1, *ptr2;
 	int i;
 
-	ptr1 = __gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr1);
-	ptr2 = __gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
-	igt_assert(ptr2);
+	ptr1 = gem_mmap__gtt(fd1, handle1, BO_SIZE, PROT_READ | PROT_WRITE);
+	ptr2 = gem_mmap__gtt(fd2, handle2, BO_SIZE, PROT_READ | PROT_WRITE);
 
 	/* check whether it's still our old object first. */
 	for (i = 0; i < BO_SIZE; i++) {
tests/testdisplay.c +2 -3
index 6d206e3..4efcb59 100644
@@ -221,9 +221,8 @@ paint_color_key(struct igt_fb *fb_info)
 	int i, j;
 	uint32_t *fb_ptr;
 
-	fb_ptr = __gem_mmap__gtt(drm_fd, fb_info->gem_handle,
-			  fb_info->size, PROT_READ | PROT_WRITE);
-	igt_assert(fb_ptr);
+	fb_ptr = gem_mmap__gtt(drm_fd, fb_info->gem_handle, fb_info->size,
+			       PROT_READ | PROT_WRITE);
 
 	for (i = crtc_y; i < crtc_y + crtc_h; i++)
 		for (j = crtc_x; j < crtc_x + crtc_w; j++) {
Signature · 6 lines
2.4.9

_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
#7 lore raw

Re: [PATCH i-g-t 7/7] Replace __gem_mmap__{cpu, gtt, wc}() + igt_assert() with gem_mmap__{cpu, gtt, wc}()

Quoted 27 lines · On Fri, Oct 09, 2015 at 07:19:16PM +0300, [email protected] wrote:

From: Ville Syrjälä <[email protected]>

gem_mmap__{cpu,gtt,wc}() already has the assert built in, so replace
__gem_mmap__{cpu,gtt,wc}() + igt_assert() with it.

Mostly done with coccinelle, with some manual help:
@@
identifier I;
expression E1, E2, E3, E4, E5, E6;
@@
(

(quoted diff) +1 -2
-  I = __gem_mmap__gtt(E1, E2, E3, E4);
+  I = gem_mmap__gtt(E1, E2, E3, E4);
...
-  igt_assert(I);

|

(quoted diff) +1 -2
-  I = __gem_mmap__cpu(E1, E2, E3, E4, E5);
+  I = gem_mmap__cpu(E1, E2, E3, E4, E5);
...
-  igt_assert(I);

|

(quoted diff) +1 -2
-  I = __gem_mmap__wc(E1, E2, E3, E4, E5);
+  I = gem_mmap__wc(E1, E2, E3, E4, E5);
...
-  igt_assert(I);

)

Quoted 1 line

Looks like by the end we miss a few asserts (a few too many __gem_mmap left over), but that is just a continuation of the state of affairs.

Series lgtm,

Stochastically-reviwewed-by Chris Wilson <[email protected]>

-Chris

Signature · 5 lines
Chris Wilson, Intel Open Source Technology Centre
_______________________________________________
Intel-gfx mailing list
[email protected]
http://lists.freedesktop.org/mailman/listinfo/intel-gfx