tests/gem_reset_stats.c

   1 /*
   2  * Copyright (c) 2013 Intel Corporation
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * Authors:
  24  *  Mika Kuoppala <mika.kuoppala@intel.com>
  25  *
  26  */
  27
  28 #define _GNU_SOURCE
  29 #include <unistd.h>
  30 #include <stdlib.h>
  31 #include <stdio.h>
  32 #include <string.h>
  33 #include <fcntl.h>
  34 #include <inttypes.h>
  35 #include <errno.h>
  36 #include <sys/stat.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/mman.h>
  39 #include <time.h>
  40 #include <signal.h>
  41
  42 #include "i915_drm.h"
  43 #include "intel_bufmgr.h"
  44 #include "intel_batchbuffer.h"
  45 #include "intel_gpu_tools.h"
  46 #include "rendercopy.h"
  47 #include "igt_debugfs.h"
  48
  49 #define RS_NO_ERROR      0
  50 #define RS_BATCH_ACTIVE  (1 << 0)
  51 #define RS_BATCH_PENDING (1 << 1)
  52 #define RS_UNKNOWN       (1 << 2)
  53
  54 struct local_drm_i915_reset_stats {
  55         __u32 ctx_id;
  56         __u32 flags;
  57         __u32 reset_count;
  58         __u32 batch_active;
  59         __u32 batch_pending;
  60         __u32 pad;
  61 };
  62
  63 struct local_drm_i915_gem_context_create {
  64         __u32 ctx_id;
  65         __u32 pad;
  66 };
  67
  68 struct local_drm_i915_gem_context_destroy {
  69         __u32 ctx_id;
  70         __u32 pad;
  71 };
  72
  73 #define MAX_FD 32
  74
  75 #define CONTEXT_CREATE_IOCTL DRM_IOWR(DRM_COMMAND_BASE + 0x2d, struct local_drm_i915_gem_context_create)
  76 #define CONTEXT_DESTROY_IOCTL DRM_IOWR(DRM_COMMAND_BASE + 0x2e, struct local_drm_i915_gem_context_destroy)
  77 #define GET_RESET_STATS_IOCTL DRM_IOWR(DRM_COMMAND_BASE + 0x32, struct local_drm_i915_reset_stats)
  78
  79 static igt_debugfs_t dfs;
  80
  81 static uint32_t context_create(int fd)
  82 {
  83         struct local_drm_i915_gem_context_create create;
  84         int ret;
  85
  86         create.ctx_id = rand();
  87         create.pad = rand();
  88
  89         ret = drmIoctl(fd, CONTEXT_CREATE_IOCTL, &create);
  90         igt_assert(ret == 0);
  91
  92         return create.ctx_id;
  93 }
  94
  95 static int context_destroy(int fd, uint32_t ctx_id)
  96 {
  97         int ret;
  98         struct local_drm_i915_gem_context_destroy destroy;
  99
 100         destroy.ctx_id = ctx_id;
 101         destroy.pad = rand();
 102
 103         ret = drmIoctl(fd, CONTEXT_DESTROY_IOCTL, &destroy);
 104         if (ret != 0)
 105                 return -errno;
 106
 107         return 0;
 108 }
 109
 110 static int gem_reset_stats(int fd, int ctx_id,
 111                            struct local_drm_i915_reset_stats *rs)
 112 {
 113         int ret;
 114
 115         rs->ctx_id = ctx_id;
 116         rs->flags = 0;
 117         rs->reset_count = rand();
 118         rs->batch_active = rand();
 119         rs->batch_pending = rand();
 120         rs->pad = 0;
 121
 122         do {
 123                 ret = ioctl(fd, GET_RESET_STATS_IOCTL, rs);
 124         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 125
 126         if (ret < 0)
 127                 return -errno;
 128
 129         return 0;
 130 }
 131
 132 static int gem_reset_status(int fd, int ctx_id)
 133 {
 134         int ret;
 135         struct local_drm_i915_reset_stats rs;
 136
 137         ret = gem_reset_stats(fd, ctx_id, &rs);
 138         if (ret)
 139                 return ret;
 140
 141         if (rs.batch_active)
 142                 return RS_BATCH_ACTIVE;
 143         if (rs.batch_pending)
 144                 return RS_BATCH_PENDING;
 145
 146         return RS_NO_ERROR;
 147 }
 148
 149 static int gem_exec(int fd, struct drm_i915_gem_execbuffer2 *execbuf)
 150 {
 151         int ret;
 152
 153         ret = ioctl(fd,
 154                     DRM_IOCTL_I915_GEM_EXECBUFFER2,
 155                     execbuf);
 156
 157         if (ret < 0)
 158                 return -errno;
 159
 160         return 0;
 161 }
 162
 163 static int exec_valid(int fd, int ctx)
 164 {
 165         struct drm_i915_gem_execbuffer2 execbuf;
 166         struct drm_i915_gem_exec_object2 exec;
 167         int ret;
 168
 169         uint32_t buf[2] = { MI_BATCH_BUFFER_END, 0 };
 170
 171         exec.handle = gem_create(fd, 4096);
 172         gem_write(fd, exec.handle, 0, buf, sizeof(buf));
 173         exec.relocation_count = 0;
 174         exec.relocs_ptr = 0;
 175         exec.alignment = 0;
 176         exec.offset = 0;
 177         exec.flags = 0;
 178         exec.rsvd1 = 0;
 179         exec.rsvd2 = 0;
 180
 181         execbuf.buffers_ptr = (uintptr_t)&exec;
 182         execbuf.buffer_count = 1;
 183         execbuf.batch_start_offset = 0;
 184         execbuf.batch_len = sizeof(buf);
 185         execbuf.cliprects_ptr = 0;
 186         execbuf.num_cliprects = 0;
 187         execbuf.DR1 = 0;
 188         execbuf.DR4 = 0;
 189         execbuf.flags = 0;
 190         i915_execbuffer2_set_context_id(execbuf, ctx);
 191         execbuf.rsvd2 = 0;
 192
 193         ret = gem_exec(fd, &execbuf);
 194         if (ret < 0)
 195                 return ret;
 196
 197         return exec.handle;
 198 }
 199
 200 static void stop_rings(void)
 201 {
 202         int fd;
 203
 204         fd = igt_debugfs_open(&dfs, "i915_ring_stop", O_WRONLY);
 205         igt_assert(fd >= 0);
 206
 207         igt_assert(write(fd, "0xff", 4) == 4);
 208         close(fd);
 209 }
 210
 211 #define BUFSIZE (4 * 1024)
 212 #define ITEMS   (BUFSIZE >> 2)
 213
 214 static int inject_hang(int fd, int ctx)
 215 {
 216         struct drm_i915_gem_execbuffer2 execbuf;
 217         struct drm_i915_gem_exec_object2 exec;
 218         uint64_t gtt_off;
 219         uint32_t *buf;
 220         int roff, i;
 221         unsigned cmd_len = 2;
 222
 223         srandom(time(NULL));
 224
 225         if (intel_gen(intel_get_drm_devid(fd)) >= 8)
 226                 cmd_len = 3;
 227
 228         buf = malloc(BUFSIZE);
 229         igt_assert(buf != NULL);
 230
 231         buf[0] = MI_BATCH_BUFFER_END;
 232         buf[1] = MI_NOOP;
 233
 234         exec.handle = gem_create(fd, BUFSIZE);
 235         gem_write(fd, exec.handle, 0, buf, BUFSIZE);
 236         exec.relocation_count = 0;
 237         exec.relocs_ptr = 0;
 238         exec.alignment = 0;
 239         exec.offset = 0;
 240         exec.flags = 0;
 241         exec.rsvd1 = 0;
 242         exec.rsvd2 = 0;
 243
 244         execbuf.buffers_ptr = (uintptr_t)&exec;
 245         execbuf.buffer_count = 1;
 246         execbuf.batch_start_offset = 0;
 247         execbuf.batch_len = BUFSIZE;
 248         execbuf.cliprects_ptr = 0;
 249         execbuf.num_cliprects = 0;
 250         execbuf.DR1 = 0;
 251         execbuf.DR4 = 0;
 252         execbuf.flags = 0;
 253         i915_execbuffer2_set_context_id(execbuf, ctx);
 254         execbuf.rsvd2 = 0;
 255
 256         igt_assert(gem_exec(fd, &execbuf) == 0);
 257
 258         gtt_off = exec.offset;
 259
 260         for (i = 0; i < ITEMS; i++)
 261                 buf[i] = MI_NOOP;
 262
 263         roff = random() % (ITEMS - cmd_len);
 264         buf[roff] = MI_BATCH_BUFFER_START | (cmd_len - 2);
 265         buf[roff + 1] = (gtt_off & 0xfffffffc) + (roff << 2);
 266         if (cmd_len == 3)
 267                 buf[roff + 2] = gtt_off & 0xffffffff00000000ull;
 268
 269 #ifdef VERBOSE
 270         printf("loop injected at 0x%lx (off 0x%x, bo_start 0x%lx, bo_end 0x%lx)\n",
 271                (long unsigned int)((roff << 2) + gtt_off),
 272                roff << 2, (long unsigned int)gtt_off,
 273                (long unsigned int)(gtt_off + BUFSIZE - 1));
 274 #endif
 275         gem_write(fd, exec.handle, 0, buf, BUFSIZE);
 276
 277         exec.relocation_count = 0;
 278         exec.relocs_ptr = 0;
 279         exec.alignment = 0;
 280         exec.offset = 0;
 281         exec.flags = 0;
 282         exec.rsvd1 = 0;
 283         exec.rsvd2 = 0;
 284
 285         execbuf.buffers_ptr = (uintptr_t)&exec;
 286         execbuf.buffer_count = 1;
 287         execbuf.batch_start_offset = 0;
 288         execbuf.batch_len = BUFSIZE;
 289         execbuf.cliprects_ptr = 0;
 290         execbuf.num_cliprects = 0;
 291         execbuf.DR1 = 0;
 292         execbuf.DR4 = 0;
 293         execbuf.flags = 0;
 294         i915_execbuffer2_set_context_id(execbuf, ctx);
 295         execbuf.rsvd2 = 0;
 296
 297         igt_assert(gem_exec(fd, &execbuf) == 0);
 298
 299         igt_assert(gtt_off == exec.offset);
 300
 301         free(buf);
 302
 303         stop_rings();
 304
 305         return exec.handle;
 306 }
 307
 308 static int _assert_reset_status(int fd, int ctx, int status)
 309 {
 310         int rs;
 311
 312         rs = gem_reset_status(fd, ctx);
 313         if (rs < 0) {
 314                 printf("reset status for %d ctx %d returned %d\n",
 315                        fd, ctx, rs);
 316                 return rs;
 317         }
 318
 319         if (rs != status) {
 320                 printf("%d:%d reset status %d differs from assumed %d\n",
 321                        fd, ctx, rs, status);
 322
 323                 return 1;
 324         }
 325
 326         return 0;
 327 }
 328
 329 #define assert_reset_status(fd, ctx, status) \
 330         igt_assert(_assert_reset_status(fd, ctx, status) == 0)
 331
 332 static void test_rs(int num_fds, int hang_index, int rs_assumed_no_hang)
 333 {
 334         int i;
 335         int fd[MAX_FD];
 336         int h[MAX_FD];
 337
 338         igt_assert (num_fds <= MAX_FD);
 339         igt_assert (hang_index < MAX_FD);
 340
 341         for (i = 0; i < num_fds; i++) {
 342                 fd[i] = drm_open_any();
 343                 igt_assert(fd[i]);
 344         }
 345
 346         for (i = 0; i < num_fds; i++)
 347                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 348
 349         for (i = 0; i < num_fds; i++) {
 350                 if (i == hang_index)
 351                         h[i] = inject_hang(fd[i], 0);
 352                 else
 353                         h[i] = exec_valid(fd[i], 0);
 354         }
 355
 356         gem_sync(fd[num_fds - 1], h[num_fds - 1]);
 357
 358         for (i = 0; i < num_fds; i++) {
 359                 if (hang_index < 0) {
 360                         assert_reset_status(fd[i], 0, rs_assumed_no_hang);
 361                         continue;
 362                 }
 363
 364                 if (i < hang_index)
 365                         assert_reset_status(fd[i], 0, RS_NO_ERROR);
 366                 if (i == hang_index)
 367                         assert_reset_status(fd[i], 0, RS_BATCH_ACTIVE);
 368                 if (i > hang_index)
 369                         assert_reset_status(fd[i], 0, RS_BATCH_PENDING);
 370         }
 371
 372         for (i = 0; i < num_fds; i++) {
 373                 gem_close(fd[i], h[i]);
 374                 close(fd[i]);
 375         }
 376 }
 377
 378 #define MAX_CTX 100
 379 static void test_rs_ctx(int num_fds, int num_ctx, int hang_index,
 380                         int hang_context)
 381 {
 382         int i, j;
 383         int fd[MAX_FD];
 384         int h[MAX_FD][MAX_CTX];
 385         int ctx[MAX_FD][MAX_CTX];
 386
 387         igt_assert (num_fds <= MAX_FD);
 388         igt_assert (hang_index < MAX_FD);
 389
 390         igt_assert (num_ctx <= MAX_CTX);
 391         igt_assert (hang_context < MAX_CTX);
 392
 393         test_rs(num_fds, -1, RS_NO_ERROR);
 394
 395         for (i = 0; i < num_fds; i++) {
 396                 fd[i] = drm_open_any();
 397                 igt_assert(fd[i]);
 398                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 399
 400                 for (j = 0; j < num_ctx; j++) {
 401                         ctx[i][j] = context_create(fd[i]);
 402
 403                 }
 404
 405                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 406         }
 407
 408         for (i = 0; i < num_fds; i++) {
 409
 410                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 411
 412                 for (j = 0; j < num_ctx; j++)
 413                         assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
 414
 415                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 416         }
 417
 418         for (i = 0; i < num_fds; i++) {
 419                 for (j = 0; j < num_ctx; j++) {
 420                         if (i == hang_index && j == hang_context)
 421                                 h[i][j] = inject_hang(fd[i], ctx[i][j]);
 422                         else
 423                                 h[i][j] = exec_valid(fd[i], ctx[i][j]);
 424                 }
 425         }
 426
 427         gem_sync(fd[num_fds - 1], ctx[num_fds - 1][num_ctx - 1]);
 428
 429         for (i = 0; i < num_fds; i++)
 430                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 431
 432         for (i = 0; i < num_fds; i++) {
 433                 for (j = 0; j < num_ctx; j++) {
 434                         if (i < hang_index)
 435                                 assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
 436                         if (i == hang_index && j < hang_context)
 437                                 assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
 438                         if (i == hang_index && j == hang_context)
 439                                 assert_reset_status(fd[i], ctx[i][j],
 440                                                     RS_BATCH_ACTIVE);
 441                         if (i == hang_index && j > hang_context)
 442                                 assert_reset_status(fd[i], ctx[i][j],
 443                                                     RS_BATCH_PENDING);
 444                         if (i > hang_index)
 445                                 assert_reset_status(fd[i], ctx[i][j],
 446                                                     RS_BATCH_PENDING);
 447                 }
 448         }
 449
 450         for (i = 0; i < num_fds; i++) {
 451                 for (j = 0; j < num_ctx; j++) {
 452                         gem_close(fd[i], h[i][j]);
 453                         igt_assert(context_destroy(fd[i], ctx[i][j]) == 0);
 454                 }
 455
 456                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
 457
 458                 close(fd[i]);
 459         }
 460 }
 461
 462 static void test_ban(void)
 463 {
 464         int h1,h2,h3,h4,h5,h6,h7;
 465         int ctx_good, ctx_bad;
 466         int fd;
 467         int retry = 10;
 468         int active_count = 0, pending_count = 0;
 469         struct local_drm_i915_reset_stats rs_bad, rs_good;
 470
 471         fd = drm_open_any();
 472         igt_assert(fd >= 0);
 473
 474         assert_reset_status(fd, 0, RS_NO_ERROR);
 475
 476         ctx_good = context_create(fd);
 477         ctx_bad = context_create(fd);
 478
 479         assert_reset_status(fd, 0, RS_NO_ERROR);
 480         assert_reset_status(fd, ctx_good, RS_NO_ERROR);
 481         assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
 482
 483         h1 = exec_valid(fd, ctx_bad);
 484         igt_assert(h1 >= 0);
 485         h5 = exec_valid(fd, ctx_good);
 486         igt_assert(h5 >= 0);
 487
 488         assert_reset_status(fd, ctx_good, RS_NO_ERROR);
 489         assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
 490
 491         h2 = inject_hang(fd, ctx_bad);
 492         igt_assert(h2 >= 0);
 493         active_count++;
 494         /* Second hang will be pending for this */
 495         pending_count++;
 496
 497         h6 = exec_valid(fd, ctx_good);
 498         h7 = exec_valid(fd, ctx_good);
 499
 500         while (retry--) {
 501                 h3 = inject_hang(fd, ctx_bad);
 502                 igt_assert(h3 >= 0);
 503                 gem_sync(fd, h3);
 504                 active_count++;
 505                 /* This second hand will count as pending */
 506                 assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
 507
 508                 h4 = exec_valid(fd, ctx_bad);
 509                 if (h4 == -EIO) {
 510                         gem_close(fd, h3);
 511                         break;
 512                 }
 513
 514                 /* Should not happen often but sometimes hang is declared too slow
 515                  * due to our way of faking hang using loop */
 516
 517                 igt_assert(h4 >= 0);
 518                 gem_close(fd, h3);
 519                 gem_close(fd, h4);
 520
 521                 printf("retrying for ban (%d)\n", retry);
 522         }
 523
 524         igt_assert(h4 == -EIO);
 525         assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
 526
 527         gem_sync(fd, h7);
 528         assert_reset_status(fd, ctx_good, RS_BATCH_PENDING);
 529
 530         igt_assert(gem_reset_stats(fd, ctx_good, &rs_good) == 0);
 531         igt_assert(gem_reset_stats(fd, ctx_bad, &rs_bad) == 0);
 532
 533         igt_assert(rs_bad.batch_active == active_count);
 534         igt_assert(rs_bad.batch_pending == pending_count);
 535         igt_assert(rs_good.batch_active == 0);
 536         igt_assert(rs_good.batch_pending == 2);
 537
 538         gem_close(fd, h1);
 539         gem_close(fd, h2);
 540         gem_close(fd, h6);
 541         gem_close(fd, h7);
 542
 543         h1 = exec_valid(fd, ctx_good);
 544         igt_assert(h1 >= 0);
 545         gem_close(fd, h1);
 546
 547         igt_assert(context_destroy(fd, ctx_good) == 0);
 548         igt_assert(context_destroy(fd, ctx_bad) == 0);
 549         igt_assert(gem_reset_status(fd, ctx_good) < 0);
 550         igt_assert(gem_reset_status(fd, ctx_bad) < 0);
 551         igt_assert(exec_valid(fd, ctx_good) < 0);
 552         igt_assert(exec_valid(fd, ctx_bad) < 0);
 553
 554         close(fd);
 555 }
 556
 557 static void test_nonrelated_hang(void)
 558 {
 559         int h1,h2;
 560         int fd1,fd2;
 561         int ctx_guilty, ctx_unrelated;
 562
 563         fd1 = drm_open_any();
 564         fd2 = drm_open_any();
 565         assert_reset_status(fd1, 0, RS_NO_ERROR);
 566         assert_reset_status(fd2, 0, RS_NO_ERROR);
 567         ctx_guilty = context_create(fd1);
 568         ctx_unrelated = context_create(fd2);
 569
 570         assert_reset_status(fd1, ctx_guilty, RS_NO_ERROR);
 571         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
 572
 573         h1 = inject_hang(fd1, ctx_guilty);
 574         igt_assert(h1 >= 0);
 575         gem_sync(fd1, h1);
 576         assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
 577         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
 578
 579         h2 = exec_valid(fd2, ctx_unrelated);
 580         igt_assert(h2 >= 0);
 581         gem_sync(fd2, h2);
 582         assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
 583         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
 584         gem_close(fd1, h1);
 585         gem_close(fd2, h2);
 586
 587         igt_assert(context_destroy(fd1, ctx_guilty) == 0);
 588         igt_assert(context_destroy(fd2, ctx_unrelated) == 0);
 589
 590         close(fd1);
 591         close(fd2);
 592 }
 593
 594 static int get_reset_count(int fd, int ctx)
 595 {
 596         int ret;
 597         struct local_drm_i915_reset_stats rs;
 598
 599         ret = gem_reset_stats(fd, ctx, &rs);
 600         if (ret)
 601                 return ret;
 602
 603         return rs.reset_count;
 604 }
 605
 606 static void test_double_destroy_pending(void)
 607 {
 608         int fd, h;
 609         uint32_t ctx;
 610
 611         fd = drm_open_any();
 612         igt_assert(fd >= 0);
 613         ctx = context_create(fd);
 614
 615         assert_reset_status(fd, ctx, RS_NO_ERROR);
 616
 617         h = inject_hang(fd, ctx);
 618         igt_assert(h >= 0);
 619         igt_assert(context_destroy(fd, ctx) == 0);
 620         igt_assert(context_destroy(fd, ctx) == -ENOENT);
 621
 622         gem_close(fd, h);
 623         close(fd);
 624 }
 625
 626 static void test_close_pending(void)
 627 {
 628         int fd, h;
 629
 630         fd = drm_open_any();
 631         igt_assert(fd >= 0);
 632
 633         assert_reset_status(fd, 0, RS_NO_ERROR);
 634
 635         h = inject_hang(fd, 0);
 636         igt_assert(h >= 0);
 637
 638         gem_close(fd, h);
 639         close(fd);
 640 }
 641
 642 static void test_close_pending_fork(void)
 643 {
 644         int pid;
 645         int fd, h;
 646
 647         fd = drm_open_any();
 648         igt_assert(fd >= 0);
 649
 650         assert_reset_status(fd, 0, RS_NO_ERROR);
 651
 652         h = inject_hang(fd, 0);
 653         igt_assert(h >= 0);
 654
 655         sleep(1);
 656
 657         /* Avoid helpers as we need to kill the child
 658          * without any extra signal handling on behalf of
 659          * lib/drmtest.c
 660          */
 661         pid = fork();
 662         if (pid == 0) {
 663                 /*
 664                  * Not first drm_open_any() so we need to do
 665                  * gem_quiescent_gpu() explicitly, as it is the
 666                  * key component to trigger the oops
 667                  *
 668                  * The crucial component is that we schedule the same noop batch
 669                  * on each ring. If gem_quiescent_gpu ever changes that we need
 670                  * to update this testcase.
 671                  */
 672                 const int fd2 = drm_open_any();
 673                 igt_assert(fd2 >= 0);
 674
 675                 /* This adds same batch on each ring */
 676                 gem_quiescent_gpu(fd2);
 677
 678                 close(fd2);
 679                 return;
 680         } else {
 681                 igt_assert(pid > 0);
 682                 sleep(1);
 683
 684                 /* Kill the child to reduce refcounts on
 685                    batch_objs */
 686                 kill(pid, SIGKILL);
 687         }
 688
 689         gem_close(fd, h);
 690         close(fd);
 691
 692         /* Then we just wait on hang to happen */
 693         fd = drm_open_any();
 694         igt_assert(fd >= 0);
 695
 696         h = exec_valid(fd, 0);
 697         igt_assert(h >= 0);
 698
 699         gem_sync(fd, h);
 700         gem_close(fd, h);
 701         close(fd);
 702 }
 703
 704 static void drop_root(void)
 705 {
 706         igt_assert(getuid() == 0);
 707
 708         igt_assert(setgid(2) == 0);
 709         igt_assert(setuid(2) == 0);
 710
 711         igt_assert(getgid() == 2);
 712         igt_assert(getuid() == 2);
 713 }
 714
 715 static void __test_count(const bool create_ctx)
 716 {
 717         int fd, h, ctx;
 718         long c1, c2;
 719
 720         fd = drm_open_any();
 721         igt_assert(fd >= 0);
 722         if (create_ctx)
 723                 ctx = context_create(fd);
 724         else
 725                 ctx = 0;
 726
 727         assert_reset_status(fd, ctx, RS_NO_ERROR);
 728
 729         c1 = get_reset_count(fd, ctx);
 730         igt_assert(c1 >= 0);
 731
 732         h = inject_hang(fd, ctx);
 733         igt_assert (h >= 0);
 734         gem_sync(fd, h);
 735
 736         assert_reset_status(fd, ctx, RS_BATCH_ACTIVE);
 737         c2 = get_reset_count(fd, ctx);
 738         igt_assert(c2 >= 0);
 739         igt_assert(c2 == (c1 + 1));
 740
 741         igt_fork(child, 1) {
 742                 drop_root();
 743
 744                 c2 = get_reset_count(fd, ctx);
 745
 746                 if (ctx == 0)
 747                         igt_assert(c2 == -EPERM);
 748                 else
 749                         igt_assert(c2 == 0);
 750         }
 751
 752         igt_waitchildren();
 753
 754         gem_close(fd, h);
 755
 756         if (create_ctx)
 757                 context_destroy(fd, ctx);
 758
 759         close(fd);
 760 }
 761
 762 static void test_count(void)
 763 {
 764         return __test_count(false);
 765 }
 766
 767 static void test_count_context(void)
 768 {
 769         return __test_count(true);
 770 }
 771
 772 static void test_global_reset_count(void)
 773 {
 774         test_count();
 775         test_count_context();
 776 }
 777
 778 static int _test_params(int fd, int ctx, uint32_t flags, uint32_t pad)
 779 {
 780         struct local_drm_i915_reset_stats rs;
 781         int ret;
 782
 783         rs.ctx_id = ctx;
 784         rs.flags = flags;
 785         rs.reset_count = rand();
 786         rs.batch_active = rand();
 787         rs.batch_pending = rand();
 788         rs.pad = pad;
 789
 790         do {
 791                 ret = ioctl(fd, GET_RESET_STATS_IOCTL, &rs);
 792         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 793
 794         if (ret < 0)
 795                 return -errno;
 796
 797         return 0;
 798 }
 799
 800 typedef enum { root = 0, user } cap_t;
 801
 802 static void test_param_ctx(const int fd, const int ctx, const cap_t cap)
 803 {
 804         const uint32_t bad = rand() + 1;
 805
 806         if (ctx == 0) {
 807                 if (cap == root)
 808                         igt_assert(_test_params(fd, ctx, 0, 0) == 0);
 809                 else
 810                         igt_assert(_test_params(fd, ctx, 0, 0) == -EPERM);
 811         }
 812
 813         igt_assert(_test_params(fd, ctx, 0, bad) == -EINVAL);
 814         igt_assert(_test_params(fd, ctx, bad, 0) == -EINVAL);
 815         igt_assert(_test_params(fd, ctx, bad, bad) == -EINVAL);
 816 }
 817
 818 static void check_params(const int fd, const int ctx, cap_t cap)
 819 {
 820         igt_assert(ioctl(fd, GET_RESET_STATS_IOCTL, 0) == -1);
 821         igt_assert(_test_params(fd, 0xbadbad, 0, 0) == -ENOENT);
 822
 823         test_param_ctx(fd, 0, cap);
 824         test_param_ctx(fd, ctx, cap);
 825 }
 826
 827 static void _test_param(const int fd, const int ctx)
 828 {
 829         check_params(fd, ctx, root);
 830
 831         igt_fork(child, 1) {
 832                 check_params(fd, ctx, root);
 833
 834                 drop_root();
 835
 836                 check_params(fd, ctx, user);
 837         }
 838
 839         check_params(fd, ctx, root);
 840
 841         igt_waitchildren();
 842 }
 843
 844 static void test_params(void)
 845 {
 846         int fd, ctx;
 847
 848         fd = drm_open_any();
 849         igt_assert(fd >= 0);
 850         ctx = context_create(fd);
 851
 852         _test_param(fd, ctx);
 853
 854         close(fd);
 855 }
 856
 857
 858 igt_main
 859 {
 860         struct local_drm_i915_gem_context_create create;
 861         uint32_t devid;
 862         int fd;
 863         int ret;
 864
 865         igt_skip_on_simulation();
 866
 867         igt_fixture {
 868                 fd = drm_open_any();
 869                 devid = intel_get_drm_devid(fd);
 870                 igt_require_f(intel_gen(devid) >= 4,
 871                               "Architecture %d too old\n", intel_gen(devid));
 872
 873                 ret = drmIoctl(fd, CONTEXT_CREATE_IOCTL, &create);
 874                 igt_skip_on_f(ret != 0 && (errno == ENODEV || errno == EINVAL),
 875                               "Kernel is too old, or contexts not supported: %s\n",
 876                               strerror(errno));
 877
 878                 assert(igt_debugfs_init(&dfs) == 0);
 879
 880                 close(fd);
 881         }
 882
 883         igt_subtest("basic-reset-status")
 884                 test_rs(4, 1, 0);
 885
 886         igt_subtest("context-reset-status")
 887                 test_rs_ctx(4, 4, 1, 2);
 888
 889         igt_subtest("ban")
 890                 test_ban();
 891
 892         igt_subtest("ctx-unrelated")
 893                 test_nonrelated_hang();
 894
 895         igt_subtest("global-count")
 896                 test_global_reset_count();
 897
 898         igt_subtest("double-destroy-pending")
 899                 test_double_destroy_pending();
 900
 901         igt_subtest("close-pending")
 902                 test_close_pending();
 903
 904         igt_subtest("close-pending-fork")
 905                 test_close_pending_fork();
 906
 907         igt_subtest("params")
 908                 test_params();
 909 }