Signed-off-by: Chris Wilson <ch...@chris-wilson.co.uk>
---
tests/gem_reset_stats.c | 488 +++++++++++++++---------------------------------
1 file changed, 147 insertions(+), 341 deletions(-)
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
--
2.6.3
_______________________________________________
Intel-gfx mailing list
Intel-gfx@lists.freedesktop.org
http://lists.freedesktop.org/mailman/listinfo/intel-gfx
