Sprinkle igt_assert(ptr) after gem_mmap__{cpu,gtt,wc}

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

Signed-off-by: Ville Syrjälä <ville.syrjala@linux.intel.com>
Stochastically-reviwewed-by: Chris Wilson <chris@chris-wilson.co.uk>

benchmarks/gem_blt.c

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -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++) {