diff --git a/tests/gem_reset_stats.c b/tests/gem_reset_stats.c
index 4cbbb4e..da4aae3 100644
--- a/tests/gem_reset_stats.c
+++ b/tests/gem_reset_stats.c
@@ -47,6 +47,7 @@
 #define RS_BATCH_PENDING (1 << 1)
 #define RS_UNKNOWN       (1 << 2)
 
+
 static uint32_t devid;
 
 struct local_drm_i915_reset_stats {
@@ -71,6 +72,13 @@ static bool gem_has_render(int fd)
 	return true;
 }
 
+static void sync_gpu(void)
+{
+	int fd = drm_open_driver(DRIVER_INTEL);
+	gem_quiescent_gpu(fd);
+	close(fd);
+}
+
 static const struct target_ring {
 	uint32_t exec;
 	bool (*present)(int fd);
@@ -100,29 +108,21 @@ static const struct target_ring *current_ring;
 static int gem_reset_stats(int fd, int ctx_id,
 			   struct local_drm_i915_reset_stats *rs)
 {
-	int ret;
-
+	memset(rs, 0, sizeof(*rs));
 	rs->ctx_id = ctx_id;
-	rs->flags = 0;
-	rs->reset_count = rand();
-	rs->batch_active = rand();
-	rs->batch_pending = rand();
-	rs->pad = 0;
+	rs->reset_count = -1;
 
-	do {
-		ret = ioctl(fd, GET_RESET_STATS_IOCTL, rs);
-	} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
-
-	if (ret < 0)
+	if (drmIoctl(fd, GET_RESET_STATS_IOCTL, rs))
 		return -errno;
 
+	igt_assert(rs->reset_count != -1);
 	return 0;
 }
 
 static int gem_reset_status(int fd, int ctx_id)
 {
-	int ret;
 	struct local_drm_i915_reset_stats rs;
+	int ret;
 
 	ret = gem_reset_stats(fd, ctx_id, &rs);
 	if (ret)
@@ -136,15 +136,9 @@ static int gem_reset_status(int fd, int ctx_id)
 	return RS_NO_ERROR;
 }
 
-static int gem_exec(int fd, struct drm_i915_gem_execbuffer2 *execbuf)
+static int __gem_execbuf(int fd, struct drm_i915_gem_execbuffer2 *execbuf)
 {
-	int ret;
-
-	ret = ioctl(fd,
-		    DRM_IOCTL_I915_GEM_EXECBUFFER2,
-		    execbuf);
-
-	if (ret < 0)
+	if (drmIoctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, execbuf))
 		return -errno;
 
 	return 0;
@@ -158,29 +152,19 @@ static int exec_valid_ring(int fd, int ctx, int ring)
 
 	uint32_t buf[2] = { MI_BATCH_BUFFER_END, 0 };
 
+	memset(&exec, 0, sizeof(exec));
 	exec.handle = gem_create(fd, 4096);
+	igt_assert((int)exec.handle > 0);
 	gem_write(fd, exec.handle, 0, buf, sizeof(buf));
-	exec.relocation_count = 0;
-	exec.relocs_ptr = 0;
-	exec.alignment = 0;
-	exec.offset = 0;
-	exec.flags = 0;
-	exec.rsvd1 = 0;
-	exec.rsvd2 = 0;
 
+	memset(&execbuf, 0, sizeof(execbuf));
 	execbuf.buffers_ptr = (uintptr_t)&exec;
 	execbuf.buffer_count = 1;
-	execbuf.batch_start_offset = 0;
 	execbuf.batch_len = sizeof(buf);
-	execbuf.cliprects_ptr = 0;
-	execbuf.num_cliprects = 0;
-	execbuf.DR1 = 0;
-	execbuf.DR4 = 0;
 	execbuf.flags = ring;
 	i915_execbuffer2_set_context_id(execbuf, ctx);
-	execbuf.rsvd2 = 0;
 
-	ret = gem_exec(fd, &execbuf);
+	ret = __gem_execbuf(fd, &execbuf);
 	if (ret < 0)
 		return ret;
 
@@ -192,135 +176,45 @@ static int exec_valid(int fd, int ctx)
 	return exec_valid_ring(fd, ctx, current_ring->exec);
 }
 
-#define BUFSIZE (4 * 1024)
-#define ITEMS   (BUFSIZE >> 2)
-
-static int inject_hang_ring(int fd, int ctx, int ring, bool ignore_ban_error)
+#define BAN HANG_ALLOW_BAN
+#define ASYNC 2
+static void inject_hang(int fd, int ctx, unsigned flags)
 {
-	struct drm_i915_gem_execbuffer2 execbuf;
-	struct drm_i915_gem_exec_object2 exec;
-	uint64_t gtt_off;
-	uint32_t *buf;
-	int roff, i;
-	unsigned cmd_len = 2;
-	enum stop_ring_flags flags;
-
-	srandom(time(NULL));
-
-	if (intel_gen(devid) >= 8)
-		cmd_len = 3;
-
-	buf = malloc(BUFSIZE);
-	igt_assert(buf != NULL);
-
-	buf[0] = MI_BATCH_BUFFER_END;
-	buf[1] = MI_NOOP;
-
-	exec.handle = gem_create(fd, BUFSIZE);
-	gem_write(fd, exec.handle, 0, buf, BUFSIZE);
-	exec.relocation_count = 0;
-	exec.relocs_ptr = 0;
-	exec.alignment = 0;
-	exec.offset = 0;
-	exec.flags = 0;
-	exec.rsvd1 = 0;
-	exec.rsvd2 = 0;
-
-	execbuf.buffers_ptr = (uintptr_t)&exec;
-	execbuf.buffer_count = 1;
-	execbuf.batch_start_offset = 0;
-	execbuf.batch_len = BUFSIZE;
-	execbuf.cliprects_ptr = 0;
-	execbuf.num_cliprects = 0;
-	execbuf.DR1 = 0;
-	execbuf.DR4 = 0;
-	execbuf.flags = ring;
-	i915_execbuffer2_set_context_id(execbuf, ctx);
-	execbuf.rsvd2 = 0;
-
-	igt_assert_eq(gem_exec(fd, &execbuf), 0);
-
-	gtt_off = exec.offset;
-
-	for (i = 0; i < ITEMS; i++)
-		buf[i] = MI_NOOP;
-
-	roff = random() % (ITEMS - cmd_len - 1);
-	buf[roff] = MI_BATCH_BUFFER_START | (cmd_len - 2);
-	buf[roff + 1] = (gtt_off & 0xfffffffc) + (roff << 2);
-	if (cmd_len == 3)
-		buf[roff + 2] = (gtt_off & 0xffffffff00000000ull) >> 32;
-
-	buf[roff + cmd_len] = MI_BATCH_BUFFER_END;
-
-	igt_debug("loop injected at 0x%lx (off 0x%x, bo_start 0x%lx, bo_end 0x%lx)\n",
-		  (long unsigned int)((roff << 2) + gtt_off),
-		  roff << 2, (long unsigned int)gtt_off,
-		  (long unsigned int)(gtt_off + BUFSIZE - 1));
-	gem_write(fd, exec.handle, 0, buf, BUFSIZE);
-
-	exec.relocation_count = 0;
-	exec.relocs_ptr = 0;
-	exec.alignment = 0;
-	exec.offset = 0;
-	exec.flags = 0;
-	exec.rsvd1 = 0;
-	exec.rsvd2 = 0;
-
-	execbuf.buffers_ptr = (uintptr_t)&exec;
-	execbuf.buffer_count = 1;
-	execbuf.batch_start_offset = 0;
-	execbuf.batch_len = BUFSIZE;
-	execbuf.cliprects_ptr = 0;
-	execbuf.num_cliprects = 0;
-	execbuf.DR1 = 0;
-	execbuf.DR4 = 0;
-	execbuf.flags = ring;
-	i915_execbuffer2_set_context_id(execbuf, ctx);
-	execbuf.rsvd2 = 0;
-
-	igt_assert_eq(gem_exec(fd, &execbuf), 0);
-
-	igt_assert(gtt_off == exec.offset);
-
-	free(buf);
-
-	flags = igt_to_stop_ring_flag(ring);
-
-	flags |= STOP_RING_ALLOW_BAN;
-
-	if (!ignore_ban_error)
-		flags |= STOP_RING_ALLOW_ERRORS;
-
-	igt_set_stop_rings(flags);
-
-	return exec.handle;
-}
+	igt_hang_ring_t hang;
 
-static int inject_hang(int fd, int ctx)
-{
-	return inject_hang_ring(fd, ctx, current_ring->exec, false);
+	hang = igt_hang_ctx(fd, ctx, current_ring->exec, flags & BAN, NULL);
+	if ((flags & ASYNC) == 0)
+		igt_post_hang_ring(fd, hang);
 }
 
-static int inject_hang_no_ban_error(int fd, int ctx)
+static const char *status_to_string(int x)
 {
-	return inject_hang_ring(fd, ctx, current_ring->exec, true);
+	const char *strings[] = {
+		"No error",
+		"Guilty",
+		"Pending",
+	};
+	if (x >= ARRAY_SIZE(strings))
+		return "Unknown";
+	return strings[x];
 }
 
-static int _assert_reset_status(int fd, int ctx, int status)
+static int _assert_reset_status(int idx, int fd, int ctx, int status)
 {
 	int rs;
 
 	rs = gem_reset_status(fd, ctx);
 	if (rs < 0) {
 		igt_info("reset status for %d ctx %d returned %d\n",
-			 fd, ctx, rs);
+			 idx, ctx, rs);
 		return rs;
 	}
 
 	if (rs != status) {
-		igt_info("%d:%d reset status %d differs from assumed %d\n",
-			 fd, ctx, rs, status);
+		igt_info("%d:%d expected '%s' [%d], found '%s' [%d]\n",
+			 idx, ctx,
+			 status_to_string(status), status,
+			 status_to_string(rs), rs);
 
 		return 1;
 	}
@@ -328,53 +222,49 @@ static int _assert_reset_status(int fd, int ctx, int status)
 	return 0;
 }
 
-#define assert_reset_status(fd, ctx, status) \
-	igt_assert(_assert_reset_status(fd, ctx, status) == 0)
+#define assert_reset_status(idx, fd, ctx, status) \
+	igt_assert(_assert_reset_status(idx, fd, ctx, status) == 0)
 
 static void test_rs(int num_fds, int hang_index, int rs_assumed_no_hang)
 {
-	int i;
 	int fd[MAX_FD];
-	int h[MAX_FD];
+	int i;
 
 	igt_assert_lte(num_fds, MAX_FD);
 	igt_assert_lt(hang_index, MAX_FD);
 
+	igt_debug("num fds=%d, hang index=%d\n", num_fds, hang_index);
+
 	for (i = 0; i < num_fds; i++) {
 		fd[i] = drm_open_driver(DRIVER_INTEL);
-		igt_assert(fd[i]);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 	}
 
-	for (i = 0; i < num_fds; i++)
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
-
+	sync_gpu();
 	for (i = 0; i < num_fds; i++) {
 		if (i == hang_index)
-			h[i] = inject_hang(fd[i], 0);
+			inject_hang(fd[i], 0, ASYNC);
 		else
-			h[i] = exec_valid(fd[i], 0);
+			igt_assert(exec_valid(fd[i], 0) > 0);
 	}
-
-	gem_sync(fd[num_fds - 1], h[num_fds - 1]);
+	sync_gpu();
 
 	for (i = 0; i < num_fds; i++) {
 		if (hang_index < 0) {
-			assert_reset_status(fd[i], 0, rs_assumed_no_hang);
+			assert_reset_status(i, fd[i], 0, rs_assumed_no_hang);
 			continue;
 		}
 
 		if (i < hang_index)
-			assert_reset_status(fd[i], 0, RS_NO_ERROR);
+			assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 		if (i == hang_index)
-			assert_reset_status(fd[i], 0, RS_BATCH_ACTIVE);
+			assert_reset_status(i, fd[i], 0, RS_BATCH_ACTIVE);
 		if (i > hang_index)
-			assert_reset_status(fd[i], 0, RS_BATCH_PENDING);
+			assert_reset_status(i, fd[i], 0, RS_BATCH_PENDING);
 	}
 
-	for (i = 0; i < num_fds; i++) {
-		gem_close(fd[i], h[i]);
+	for (i = 0; i < num_fds; i++)
 		close(fd[i]);
-	}
 }
 
 #define MAX_CTX 100
@@ -383,7 +273,6 @@ static void test_rs_ctx(int num_fds, int num_ctx, int hang_index,
 {
 	int i, j;
 	int fd[MAX_FD];
-	int h[MAX_FD][MAX_CTX];
 	int ctx[MAX_FD][MAX_CTX];
 
 	igt_assert_lte(num_fds, MAX_FD);
@@ -397,73 +286,65 @@ static void test_rs_ctx(int num_fds, int num_ctx, int hang_index,
 	for (i = 0; i < num_fds; i++) {
 		fd[i] = drm_open_driver(DRIVER_INTEL);
 		igt_assert(fd[i]);
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 
 		for (j = 0; j < num_ctx; j++) {
 			ctx[i][j] = gem_context_create(fd[i]);
 
 		}
 
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 	}
 
 	for (i = 0; i < num_fds; i++) {
-
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 
 		for (j = 0; j < num_ctx; j++)
-			assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
+			assert_reset_status(i, fd[i], ctx[i][j], RS_NO_ERROR);
 
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 	}
 
 	for (i = 0; i < num_fds; i++) {
 		for (j = 0; j < num_ctx; j++) {
 			if (i == hang_index && j == hang_context)
-				h[i][j] = inject_hang(fd[i], ctx[i][j]);
+				inject_hang(fd[i], ctx[i][j], ASYNC);
 			else
-				h[i][j] = exec_valid(fd[i], ctx[i][j]);
+				igt_assert(exec_valid(fd[i], ctx[i][j]) > 0);
 		}
 	}
-
-	gem_sync(fd[num_fds - 1], ctx[num_fds - 1][num_ctx - 1]);
+	sync_gpu();
 
 	for (i = 0; i < num_fds; i++)
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 
 	for (i = 0; i < num_fds; i++) {
 		for (j = 0; j < num_ctx; j++) {
 			if (i < hang_index)
-				assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
+				assert_reset_status(i, fd[i], ctx[i][j], RS_NO_ERROR);
 			if (i == hang_index && j < hang_context)
-				assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
+				assert_reset_status(i, fd[i], ctx[i][j], RS_NO_ERROR);
 			if (i == hang_index && j == hang_context)
-				assert_reset_status(fd[i], ctx[i][j],
+				assert_reset_status(i, fd[i], ctx[i][j],
 						    RS_BATCH_ACTIVE);
 			if (i == hang_index && j > hang_context)
-				assert_reset_status(fd[i], ctx[i][j],
+				assert_reset_status(i, fd[i], ctx[i][j],
 						    RS_BATCH_PENDING);
 			if (i > hang_index)
-				assert_reset_status(fd[i], ctx[i][j],
+				assert_reset_status(i, fd[i], ctx[i][j],
 						    RS_BATCH_PENDING);
 		}
 	}
 
 	for (i = 0; i < num_fds; i++) {
-		for (j = 0; j < num_ctx; j++) {
-			gem_close(fd[i], h[i][j]);
-			gem_context_destroy(fd[i], ctx[i][j]);
-		}
-
-		assert_reset_status(fd[i], 0, RS_NO_ERROR);
-
+		assert_reset_status(i, fd[i], 0, RS_NO_ERROR);
 		close(fd[i]);
 	}
 }
 
 static void test_ban(void)
 {
-	int h1,h2,h3,h4,h5,h6,h7;
+	int h1,h4,h5,h6,h7;
 	int fd_bad, fd_good;
 	int retry = 10;
 	int active_count = 0, pending_count = 0;
@@ -473,72 +354,63 @@ static void test_ban(void)
 
 	fd_good = drm_open_driver(DRIVER_INTEL);
 
-	assert_reset_status(fd_bad, 0, RS_NO_ERROR);
-	assert_reset_status(fd_good, 0, RS_NO_ERROR);
+	assert_reset_status(fd_bad, fd_bad, 0, RS_NO_ERROR);
+	assert_reset_status(fd_good, fd_good, 0, RS_NO_ERROR);
 
 	h1 = exec_valid(fd_bad, 0);
 	igt_assert_lte(0, h1);
 	h5 = exec_valid(fd_good, 0);
 	igt_assert_lte(0, h5);
 
-	assert_reset_status(fd_bad, 0, RS_NO_ERROR);
-	assert_reset_status(fd_good, 0, RS_NO_ERROR);
+	assert_reset_status(fd_bad, fd_bad, 0, RS_NO_ERROR);
+	assert_reset_status(fd_good, fd_good, 0, RS_NO_ERROR);
 
-	h2 = inject_hang_no_ban_error(fd_bad, 0);
-	igt_assert_lte(0, h2);
+	inject_hang(fd_bad, 0, BAN | ASYNC);
 	active_count++;
-	/* Second hang will be pending for this */
+	/* The second hang will count as pending and be discarded */
 	pending_count++;
+	active_count--;
 
 	h6 = exec_valid(fd_good, 0);
 	h7 = exec_valid(fd_good, 0);
 
-        while (retry--) {
-                h3 = inject_hang_no_ban_error(fd_bad, 0);
-                igt_assert_lte(0, h3);
-                gem_sync(fd_bad, h3);
+	while (retry--) {
+		inject_hang(fd_bad, 0, BAN);
 		active_count++;
-		/* This second hand will count as pending */
-                assert_reset_status(fd_bad, 0, RS_BATCH_ACTIVE);
+		assert_reset_status(fd_bad, fd_bad, 0, RS_BATCH_ACTIVE);
 
-                h4 = exec_valid(fd_bad, 0);
-                if (h4 == -EIO) {
-                        gem_close(fd_bad, h3);
-                        break;
-                }
+		h4 = exec_valid(fd_bad, 0);
+		if (h4 == -EIO)
+			break;
 
-                /* Should not happen often but sometimes hang is declared too slow
-                 * due to our way of faking hang using loop */
+		/* Should not happen often but sometimes hang is declared too slow
+		 * due to our way of faking hang using loop */
 
-                igt_assert_lte(0, h4);
-                gem_close(fd_bad, h3);
-                gem_close(fd_bad, h4);
+		igt_assert_lte(0, h4);
+		gem_close(fd_bad, h4);
 
-                igt_info("retrying for ban (%d)\n", retry);
-        }
+		igt_info("retrying for ban (%d)\n", retry);
+	}
 
 	igt_assert_eq(h4, -EIO);
-	assert_reset_status(fd_bad, 0, RS_BATCH_ACTIVE);
+	assert_reset_status(fd_bad, fd_bad, 0, RS_BATCH_ACTIVE);
 
 	gem_sync(fd_good, h7);
-	assert_reset_status(fd_good, 0, RS_BATCH_PENDING);
+	assert_reset_status(fd_good, fd_good, 0, RS_BATCH_PENDING);
 
 	igt_assert_eq(gem_reset_stats(fd_good, 0, &rs_good), 0);
 	igt_assert_eq(gem_reset_stats(fd_bad, 0, &rs_bad), 0);
 
-	igt_assert(rs_bad.batch_active == active_count);
-	igt_assert(rs_bad.batch_pending == pending_count);
-	igt_assert(rs_good.batch_active == 0);
-	igt_assert(rs_good.batch_pending == 2);
+	igt_assert_eq(rs_bad.batch_active, active_count);
+	igt_assert_eq(rs_bad.batch_pending, pending_count);
+	igt_assert_eq(rs_good.batch_active, 0);
+	igt_assert_eq(rs_good.batch_pending, 2);
 
 	gem_close(fd_bad, h1);
-	gem_close(fd_bad, h2);
 	gem_close(fd_good, h6);
 	gem_close(fd_good, h7);
 
-	h1 = exec_valid(fd_good, 0);
-	igt_assert_lte(0, h1);
-	gem_close(fd_good, h1);
+	gem_close(fd_good, exec_valid(fd_good, 0));
 
 	close(fd_bad);
 	close(fd_good);
@@ -549,7 +421,7 @@ static void test_ban(void)
 
 static void test_ban_ctx(void)
 {
-	int h1,h2,h3,h4,h5,h6,h7;
+	int h1,h4,h5,h6,h7;
 	int ctx_good, ctx_bad;
 	int fd;
 	int retry = 10;
@@ -558,72 +430,65 @@ static void test_ban_ctx(void)
 
 	fd = drm_open_driver(DRIVER_INTEL);
 
-	assert_reset_status(fd, 0, RS_NO_ERROR);
+	assert_reset_status(fd, fd, 0, RS_NO_ERROR);
 
 	ctx_good = gem_context_create(fd);
 	ctx_bad = gem_context_create(fd);
 
-	assert_reset_status(fd, 0, RS_NO_ERROR);
-	assert_reset_status(fd, ctx_good, RS_NO_ERROR);
-	assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
+	assert_reset_status(fd, fd, 0, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx_good, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx_bad, RS_NO_ERROR);
 
 	h1 = exec_valid(fd, ctx_bad);
 	igt_assert_lte(0, h1);
 	h5 = exec_valid(fd, ctx_good);
 	igt_assert_lte(0, h5);
 
-	assert_reset_status(fd, ctx_good, RS_NO_ERROR);
-	assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx_good, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx_bad, RS_NO_ERROR);
 
-	h2 = inject_hang_no_ban_error(fd, ctx_bad);
-	igt_assert_lte(0, h2);
+	inject_hang(fd, ctx_bad, BAN | ASYNC);
 	active_count++;
-	/* Second hang will be pending for this */
+	/* This second hang will count as pending and be reset */
 	pending_count++;
+	active_count--;
 
 	h6 = exec_valid(fd, ctx_good);
 	h7 = exec_valid(fd, ctx_good);
 
         while (retry--) {
-                h3 = inject_hang_no_ban_error(fd, ctx_bad);
-                igt_assert_lte(0, h3);
-                gem_sync(fd, h3);
+                inject_hang(fd, ctx_bad, BAN);
 		active_count++;
-		/* This second hand will count as pending */
-                assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
+                assert_reset_status(fd, fd, ctx_bad, RS_BATCH_ACTIVE);
 
                 h4 = exec_valid(fd, ctx_bad);
-                if (h4 == -EIO) {
-                        gem_close(fd, h3);
+                if (h4 == -EIO)
                         break;
-                }
 
                 /* Should not happen often but sometimes hang is declared too slow
                  * due to our way of faking hang using loop */
 
                 igt_assert_lte(0, h4);
-                gem_close(fd, h3);
                 gem_close(fd, h4);
 
                 igt_info("retrying for ban (%d)\n", retry);
         }
 
 	igt_assert_eq(h4, -EIO);
-	assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
+	assert_reset_status(fd, fd, ctx_bad, RS_BATCH_ACTIVE);
 
 	gem_sync(fd, h7);
-	assert_reset_status(fd, ctx_good, RS_BATCH_PENDING);
+	assert_reset_status(fd, fd, ctx_good, RS_BATCH_PENDING);
 
 	igt_assert_eq(gem_reset_stats(fd, ctx_good, &rs_good), 0);
 	igt_assert_eq(gem_reset_stats(fd, ctx_bad, &rs_bad), 0);
 
-	igt_assert(rs_bad.batch_active == active_count);
-	igt_assert(rs_bad.batch_pending == pending_count);
-	igt_assert(rs_good.batch_active == 0);
-	igt_assert(rs_good.batch_pending == 2);
+	igt_assert_eq(rs_bad.batch_active, active_count);
+	igt_assert_eq(rs_bad.batch_pending, pending_count);
+	igt_assert_eq(rs_good.batch_active, 0);
+	igt_assert_eq(rs_good.batch_pending, 2);
 
 	gem_close(fd, h1);
-	gem_close(fd, h2);
 	gem_close(fd, h6);
 	gem_close(fd, h7);
 
@@ -643,36 +508,26 @@ static void test_ban_ctx(void)
 
 static void test_unrelated_ctx(void)
 {
-	int h1,h2;
 	int fd1,fd2;
 	int ctx_guilty, ctx_unrelated;
 
 	fd1 = drm_open_driver(DRIVER_INTEL);
 	fd2 = drm_open_driver(DRIVER_INTEL);
-	assert_reset_status(fd1, 0, RS_NO_ERROR);
-	assert_reset_status(fd2, 0, RS_NO_ERROR);
+	assert_reset_status(0, fd1, 0, RS_NO_ERROR);
+	assert_reset_status(1, fd2, 0, RS_NO_ERROR);
 	ctx_guilty = gem_context_create(fd1);
 	ctx_unrelated = gem_context_create(fd2);
 
-	assert_reset_status(fd1, ctx_guilty, RS_NO_ERROR);
-	assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
-
-	h1 = inject_hang(fd1, ctx_guilty);
-	igt_assert_lte(0, h1);
-	gem_sync(fd1, h1);
-	assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
-	assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
+	assert_reset_status(0, fd1, ctx_guilty, RS_NO_ERROR);
+	assert_reset_status(1, fd2, ctx_unrelated, RS_NO_ERROR);
 
-	h2 = exec_valid(fd2, ctx_unrelated);
-	igt_assert_lte(0, h2);
-	gem_sync(fd2, h2);
-	assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
-	assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
-	gem_close(fd1, h1);
-	gem_close(fd2, h2);
+	inject_hang(fd1, ctx_guilty, 0);
+	assert_reset_status(0, fd1, ctx_guilty, RS_BATCH_ACTIVE);
+	assert_reset_status(1, fd2, ctx_unrelated, RS_NO_ERROR);
 
-	gem_context_destroy(fd1, ctx_guilty);
-	gem_context_destroy(fd2, ctx_unrelated);
+	gem_sync(fd2, exec_valid(fd2, ctx_unrelated));
+	assert_reset_status(0, fd1, ctx_guilty, RS_BATCH_ACTIVE);
+	assert_reset_status(1, fd2, ctx_unrelated, RS_NO_ERROR);
 
 	close(fd1);
 	close(fd2);
@@ -692,35 +547,25 @@ static int get_reset_count(int fd, int ctx)
 
 static void test_close_pending_ctx(void)
 {
-	int fd, h;
-	uint32_t ctx;
-
-	fd = drm_open_driver(DRIVER_INTEL);
-	ctx = gem_context_create(fd);
+	int fd = drm_open_driver(DRIVER_INTEL);
+	uint32_t ctx = gem_context_create(fd);
 
-	assert_reset_status(fd, ctx, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx, RS_NO_ERROR);
 
-	h = inject_hang(fd, ctx);
-	igt_assert_lte(0, h);
+	inject_hang(fd, ctx, 0);
 	gem_context_destroy(fd, ctx);
-	igt_assert(__gem_context_destroy(fd, ctx) == -ENOENT);
+	igt_assert_eq(__gem_context_destroy(fd, ctx), -ENOENT);
 
-	gem_close(fd, h);
 	close(fd);
 }
 
 static void test_close_pending(void)
 {
-	int fd, h;
-
-	fd = drm_open_driver(DRIVER_INTEL);
-
-	assert_reset_status(fd, 0, RS_NO_ERROR);
+	int fd = drm_open_driver(DRIVER_INTEL);
 
-	h = inject_hang(fd, 0);
-	igt_assert_lte(0, h);
+	assert_reset_status(fd, fd, 0, RS_NO_ERROR);
 
-	gem_close(fd, h);
+	inject_hang(fd, 0, 0);
 	close(fd);
 }
 
@@ -772,16 +617,12 @@ static void exec_noop_on_each_ring(int fd, const bool reverse)
 
 static void test_close_pending_fork(const bool reverse)
 {
-	int pid;
-	int fd, h;
-
-	fd = drm_open_driver(DRIVER_INTEL);
-
-	assert_reset_status(fd, 0, RS_NO_ERROR);
+	int fd = drm_open_driver(DRIVER_INTEL);
+	int pid, h;
 
-	h = inject_hang(fd, 0);
-	igt_assert_lte(0, h);
+	assert_reset_status(fd, fd, 0, RS_NO_ERROR);
 
+	inject_hang(fd, 0, 0);
 	sleep(1);
 
 	/* Avoid helpers as we need to kill the child
@@ -810,7 +651,6 @@ static void test_close_pending_fork(const bool reverse)
 		kill(pid, SIGKILL);
 	}
 
-	gem_close(fd, h);
 	close(fd);
 
 	/* Then we just wait on hang to happen */
@@ -826,25 +666,23 @@ static void test_close_pending_fork(const bool reverse)
 
 static void test_reset_count(const bool create_ctx)
 {
-	int fd, h, ctx;
+	int fd = drm_open_driver(DRIVER_INTEL);
+       	int ctx;
 	long c1, c2;
 
-	fd = drm_open_driver(DRIVER_INTEL);
 	if (create_ctx)
 		ctx = gem_context_create(fd);
 	else
 		ctx = 0;
 
-	assert_reset_status(fd, ctx, RS_NO_ERROR);
+	assert_reset_status(fd, fd, ctx, RS_NO_ERROR);
 
 	c1 = get_reset_count(fd, ctx);
 	igt_assert(c1 >= 0);
 
-	h = inject_hang(fd, ctx);
-	igt_assert_lte(0, h);
-	gem_sync(fd, h);
+	inject_hang(fd, ctx, 0);
 
-	assert_reset_status(fd, ctx, RS_BATCH_ACTIVE);
+	assert_reset_status(fd, fd, ctx, RS_BATCH_ACTIVE);
 	c2 = get_reset_count(fd, ctx);
 	igt_assert(c2 >= 0);
 	igt_assert(c2 == (c1 + 1));
@@ -862,8 +700,6 @@ static void test_reset_count(const bool create_ctx)
 
 	igt_waitchildren();
 
-	gem_close(fd, h);
-
 	if (create_ctx)
 		gem_context_destroy(fd, ctx);
 
@@ -979,9 +815,9 @@ static void defer_hangcheck(int ring_num)
 	count_start = get_reset_count(fd, 0);
 	igt_assert_lte(0, count_start);
 
-	igt_assert(inject_hang_ring(fd, 0, current_ring->exec, true));
+	inject_hang(fd, 0, 0);
 	while (--seconds) {
-		igt_assert(exec_valid_ring(fd, 0, next_ring->exec));
+		exec_valid_ring(fd, 0, next_ring->exec);
 
 		count_end = get_reset_count(fd, 0);
 		igt_assert_lte(0, count_end);
@@ -1019,37 +855,7 @@ static bool gem_has_reset_stats(int fd)
 	return false;
 }
 
-static void check_gpu_ok(void)
-{
-	int retry_count = 30;
-	enum stop_ring_flags flags;
-	int fd;
-
-	igt_debug("checking gpu state\n");
-
-	while (retry_count--) {
-		flags = igt_get_stop_rings() & STOP_RING_ALL;
-		if (flags == 0)
-			break;
-
-		igt_debug("waiting previous hang to clear\n");
-		sleep(1);
-	}
-
-	igt_assert(flags == 0);
-
-	/*
-	 * Clear the _ALLOW_ERRORS and _ALLOW_BAN flags;
-	 * these are not cleared by individual ring reset.
-	 */
-	igt_set_stop_rings(0);
-
-	fd = drm_open_driver(DRIVER_INTEL);
-	gem_quiescent_gpu(fd);
-	close(fd);
-}
-
-#define RUN_TEST(...) do { check_gpu_ok(); __VA_ARGS__; check_gpu_ok(); } while (0)
+#define RUN_TEST(...) do { sync_gpu(); __VA_ARGS__; sync_gpu(); } while (0)
 #define RUN_CTX_TEST(...) do { check_context(current_ring); RUN_TEST(__VA_ARGS__); } while (0)
 
 igt_main
