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 #define LOCAL_I915_EXEC_VEBOX   (4 << 0)
 643
 644 static const struct target_ring {
 645         uint32_t exec;
 646         bool (*avail)(int);
 647 } rings[] = {
 648         { 0, 0 },
 649         { I915_EXEC_BLT, gem_has_blt },
 650         { I915_EXEC_BSD, gem_has_bsd },
 651         { LOCAL_I915_EXEC_VEBOX, gem_has_vebox },
 652 };
 653
 654 #define NUM_RINGS (sizeof(rings)/sizeof(struct target_ring))
 655
 656 static void exec_noop_on_each_ring(int fd, const bool reverse)
 657 {
 658         uint32_t batch[2] = {MI_BATCH_BUFFER_END, 0};
 659         uint32_t handle;
 660         struct drm_i915_gem_execbuffer2 execbuf;
 661         struct drm_i915_gem_exec_object2 exec[1];
 662
 663         handle = gem_create(fd, 4096);
 664         gem_write(fd, handle, 0, batch, sizeof(batch));
 665
 666         exec[0].handle = handle;
 667         exec[0].relocation_count = 0;
 668         exec[0].relocs_ptr = 0;
 669         exec[0].alignment = 0;
 670         exec[0].offset = 0;
 671         exec[0].flags = 0;
 672         exec[0].rsvd1 = 0;
 673         exec[0].rsvd2 = 0;
 674
 675         execbuf.buffers_ptr = (uintptr_t)exec;
 676         execbuf.buffer_count = 1;
 677         execbuf.batch_start_offset = 0;
 678         execbuf.batch_len = 8;
 679         execbuf.cliprects_ptr = 0;
 680         execbuf.num_cliprects = 0;
 681         execbuf.DR1 = 0;
 682         execbuf.DR4 = 0;
 683         execbuf.flags = 0;
 684         i915_execbuffer2_set_context_id(execbuf, 0);
 685         execbuf.rsvd2 = 0;
 686
 687         for (unsigned i = 0; i < NUM_RINGS; i++) {
 688                 const struct target_ring *ring;
 689
 690                 ring = reverse ? &rings[NUM_RINGS - 1 - i] : &rings[i];
 691
 692                 if (!ring->avail || (ring->avail && ring->avail(fd))) {
 693                         execbuf.flags = ring->exec;
 694                         do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
 695                 }
 696         }
 697
 698         gem_sync(fd, handle);
 699         gem_close(fd, handle);
 700 }
 701
 702 static void test_close_pending_fork(const bool reverse)
 703 {
 704         int pid;
 705         int fd, h;
 706
 707         fd = drm_open_any();
 708         igt_assert(fd >= 0);
 709
 710         assert_reset_status(fd, 0, RS_NO_ERROR);
 711
 712         h = inject_hang(fd, 0);
 713         igt_assert(h >= 0);
 714
 715         sleep(1);
 716
 717         /* Avoid helpers as we need to kill the child
 718          * without any extra signal handling on behalf of
 719          * lib/drmtest.c
 720          */
 721         pid = fork();
 722         if (pid == 0) {
 723                 const int fd2 = drm_open_any();
 724                 igt_assert(fd2 >= 0);
 725
 726                 /* The crucial component is that we schedule the same noop batch
 727                  * on each ring. This exercises batch_obj reference counting,
 728                  * when gpu is reset and ring lists are cleared.
 729                  */
 730                 exec_noop_on_each_ring(fd2, reverse);
 731
 732                 close(fd2);
 733                 return;
 734         } else {
 735                 igt_assert(pid > 0);
 736                 sleep(1);
 737
 738                 /* Kill the child to reduce refcounts on
 739                    batch_objs */
 740                 kill(pid, SIGKILL);
 741         }
 742
 743         gem_close(fd, h);
 744         close(fd);
 745
 746         /* Then we just wait on hang to happen */
 747         fd = drm_open_any();
 748         igt_assert(fd >= 0);
 749
 750         h = exec_valid(fd, 0);
 751         igt_assert(h >= 0);
 752
 753         gem_sync(fd, h);
 754         gem_close(fd, h);
 755         close(fd);
 756 }
 757
 758 static void drop_root(void)
 759 {
 760         igt_assert(getuid() == 0);
 761
 762         igt_assert(setgid(2) == 0);
 763         igt_assert(setuid(2) == 0);
 764
 765         igt_assert(getgid() == 2);
 766         igt_assert(getuid() == 2);
 767 }
 768
 769 static void __test_count(const bool create_ctx)
 770 {
 771         int fd, h, ctx;
 772         long c1, c2;
 773
 774         fd = drm_open_any();
 775         igt_assert(fd >= 0);
 776         if (create_ctx)
 777                 ctx = context_create(fd);
 778         else
 779                 ctx = 0;
 780
 781         assert_reset_status(fd, ctx, RS_NO_ERROR);
 782
 783         c1 = get_reset_count(fd, ctx);
 784         igt_assert(c1 >= 0);
 785
 786         h = inject_hang(fd, ctx);
 787         igt_assert (h >= 0);
 788         gem_sync(fd, h);
 789
 790         assert_reset_status(fd, ctx, RS_BATCH_ACTIVE);
 791         c2 = get_reset_count(fd, ctx);
 792         igt_assert(c2 >= 0);
 793         igt_assert(c2 == (c1 + 1));
 794
 795         igt_fork(child, 1) {
 796                 drop_root();
 797
 798                 c2 = get_reset_count(fd, ctx);
 799
 800                 if (ctx == 0)
 801                         igt_assert(c2 == -EPERM);
 802                 else
 803                         igt_assert(c2 == 0);
 804         }
 805
 806         igt_waitchildren();
 807
 808         gem_close(fd, h);
 809
 810         if (create_ctx)
 811                 context_destroy(fd, ctx);
 812
 813         close(fd);
 814 }
 815
 816 static void test_count(void)
 817 {
 818         return __test_count(false);
 819 }
 820
 821 static void test_count_context(void)
 822 {
 823         return __test_count(true);
 824 }
 825
 826 static void test_global_reset_count(void)
 827 {
 828         test_count();
 829         test_count_context();
 830 }
 831
 832 static int _test_params(int fd, int ctx, uint32_t flags, uint32_t pad)
 833 {
 834         struct local_drm_i915_reset_stats rs;
 835         int ret;
 836
 837         rs.ctx_id = ctx;
 838         rs.flags = flags;
 839         rs.reset_count = rand();
 840         rs.batch_active = rand();
 841         rs.batch_pending = rand();
 842         rs.pad = pad;
 843
 844         do {
 845                 ret = ioctl(fd, GET_RESET_STATS_IOCTL, &rs);
 846         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 847
 848         if (ret < 0)
 849                 return -errno;
 850
 851         return 0;
 852 }
 853
 854 typedef enum { root = 0, user } cap_t;
 855
 856 static void test_param_ctx(const int fd, const int ctx, const cap_t cap)
 857 {
 858         const uint32_t bad = rand() + 1;
 859
 860         if (ctx == 0) {
 861                 if (cap == root)
 862                         igt_assert(_test_params(fd, ctx, 0, 0) == 0);
 863                 else
 864                         igt_assert(_test_params(fd, ctx, 0, 0) == -EPERM);
 865         }
 866
 867         igt_assert(_test_params(fd, ctx, 0, bad) == -EINVAL);
 868         igt_assert(_test_params(fd, ctx, bad, 0) == -EINVAL);
 869         igt_assert(_test_params(fd, ctx, bad, bad) == -EINVAL);
 870 }
 871
 872 static void check_params(const int fd, const int ctx, cap_t cap)
 873 {
 874         igt_assert(ioctl(fd, GET_RESET_STATS_IOCTL, 0) == -1);
 875         igt_assert(_test_params(fd, 0xbadbad, 0, 0) == -ENOENT);
 876
 877         test_param_ctx(fd, 0, cap);
 878         test_param_ctx(fd, ctx, cap);
 879 }
 880
 881 static void _test_param(const int fd, const int ctx)
 882 {
 883         check_params(fd, ctx, root);
 884
 885         igt_fork(child, 1) {
 886                 check_params(fd, ctx, root);
 887
 888                 drop_root();
 889
 890                 check_params(fd, ctx, user);
 891         }
 892
 893         check_params(fd, ctx, root);
 894
 895         igt_waitchildren();
 896 }
 897
 898 static void test_params(void)
 899 {
 900         int fd, ctx;
 901
 902         fd = drm_open_any();
 903         igt_assert(fd >= 0);
 904         ctx = context_create(fd);
 905
 906         _test_param(fd, ctx);
 907
 908         close(fd);
 909 }
 910
 911
 912 igt_main
 913 {
 914         struct local_drm_i915_gem_context_create create;
 915         uint32_t devid;
 916         int fd;
 917         int ret;
 918
 919         igt_skip_on_simulation();
 920
 921         igt_fixture {
 922                 fd = drm_open_any();
 923                 devid = intel_get_drm_devid(fd);
 924                 igt_require_f(intel_gen(devid) >= 4,
 925                               "Architecture %d too old\n", intel_gen(devid));
 926
 927                 ret = drmIoctl(fd, CONTEXT_CREATE_IOCTL, &create);
 928                 igt_skip_on_f(ret != 0 && (errno == ENODEV || errno == EINVAL),
 929                               "Kernel is too old, or contexts not supported: %s\n",
 930                               strerror(errno));
 931
 932                 assert(igt_debugfs_init(&dfs) == 0);
 933
 934                 close(fd);
 935         }
 936
 937         igt_subtest("basic-reset-status")
 938                 test_rs(4, 1, 0);
 939
 940         igt_subtest("context-reset-status")
 941                 test_rs_ctx(4, 4, 1, 2);
 942
 943         igt_subtest("ban")
 944                 test_ban();
 945
 946         igt_subtest("ctx-unrelated")
 947                 test_nonrelated_hang();
 948
 949         igt_subtest("global-count")
 950                 test_global_reset_count();
 951
 952         igt_subtest("double-destroy-pending")
 953                 test_double_destroy_pending();
 954
 955         igt_subtest("close-pending")
 956                 test_close_pending();
 957
 958         igt_subtest("close-pending-fork") {
 959                 test_close_pending_fork(true);
 960                 test_close_pending_fork(false);
 961         }
 962
 963         igt_subtest("params")
 964                 test_params();
 965 }