lib: make igt_debugfs_open infallible
[platform/upstream/intel-gpu-tools.git] / 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 #define LOCAL_I915_EXEC_VEBOX   (4 << 0)
82
83 struct target_ring;
84
85 static bool gem_has_render(int fd)
86 {
87         return true;
88 }
89
90 static bool has_context(const struct target_ring *ring);
91
92 static const struct target_ring {
93         uint32_t exec;
94         bool (*present)(int fd);
95         bool (*contexts)(const struct target_ring *ring);
96         const char *name;
97 } rings[] = {
98         { I915_EXEC_RENDER, gem_has_render, has_context, "render" },
99         { I915_EXEC_BLT, gem_has_blt, has_context, "blt" },
100         { I915_EXEC_BSD, gem_has_bsd, has_context, "bsd" },
101         { LOCAL_I915_EXEC_VEBOX, gem_has_vebox, has_context, "vebox" },
102 };
103
104 static bool has_context(const struct target_ring *ring)
105 {
106         if(ring->exec == I915_EXEC_RENDER)
107                 return true;
108
109         return false;
110 }
111
112 #define NUM_RINGS (sizeof(rings)/sizeof(struct target_ring))
113
114 static const struct target_ring *current_ring;
115
116 static uint32_t context_create(int fd)
117 {
118         struct local_drm_i915_gem_context_create create;
119         int ret;
120
121         create.ctx_id = rand();
122         create.pad = rand();
123
124         ret = drmIoctl(fd, CONTEXT_CREATE_IOCTL, &create);
125         igt_assert(ret == 0);
126
127         return create.ctx_id;
128 }
129
130 static int context_destroy(int fd, uint32_t ctx_id)
131 {
132         int ret;
133         struct local_drm_i915_gem_context_destroy destroy;
134
135         destroy.ctx_id = ctx_id;
136         destroy.pad = rand();
137
138         ret = drmIoctl(fd, CONTEXT_DESTROY_IOCTL, &destroy);
139         if (ret != 0)
140                 return -errno;
141
142         return 0;
143 }
144
145 static int gem_reset_stats(int fd, int ctx_id,
146                            struct local_drm_i915_reset_stats *rs)
147 {
148         int ret;
149
150         rs->ctx_id = ctx_id;
151         rs->flags = 0;
152         rs->reset_count = rand();
153         rs->batch_active = rand();
154         rs->batch_pending = rand();
155         rs->pad = 0;
156
157         do {
158                 ret = ioctl(fd, GET_RESET_STATS_IOCTL, rs);
159         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
160
161         if (ret < 0)
162                 return -errno;
163
164         return 0;
165 }
166
167 static int gem_reset_status(int fd, int ctx_id)
168 {
169         int ret;
170         struct local_drm_i915_reset_stats rs;
171
172         ret = gem_reset_stats(fd, ctx_id, &rs);
173         if (ret)
174                 return ret;
175
176         if (rs.batch_active)
177                 return RS_BATCH_ACTIVE;
178         if (rs.batch_pending)
179                 return RS_BATCH_PENDING;
180
181         return RS_NO_ERROR;
182 }
183
184 static int gem_exec(int fd, struct drm_i915_gem_execbuffer2 *execbuf)
185 {
186         int ret;
187
188         ret = ioctl(fd,
189                     DRM_IOCTL_I915_GEM_EXECBUFFER2,
190                     execbuf);
191
192         if (ret < 0)
193                 return -errno;
194
195         return 0;
196 }
197
198 static int exec_valid_ring(int fd, int ctx, int ring)
199 {
200         struct drm_i915_gem_execbuffer2 execbuf;
201         struct drm_i915_gem_exec_object2 exec;
202         int ret;
203
204         uint32_t buf[2] = { MI_BATCH_BUFFER_END, 0 };
205
206         exec.handle = gem_create(fd, 4096);
207         gem_write(fd, exec.handle, 0, buf, sizeof(buf));
208         exec.relocation_count = 0;
209         exec.relocs_ptr = 0;
210         exec.alignment = 0;
211         exec.offset = 0;
212         exec.flags = 0;
213         exec.rsvd1 = 0;
214         exec.rsvd2 = 0;
215
216         execbuf.buffers_ptr = (uintptr_t)&exec;
217         execbuf.buffer_count = 1;
218         execbuf.batch_start_offset = 0;
219         execbuf.batch_len = sizeof(buf);
220         execbuf.cliprects_ptr = 0;
221         execbuf.num_cliprects = 0;
222         execbuf.DR1 = 0;
223         execbuf.DR4 = 0;
224         execbuf.flags = ring;
225         i915_execbuffer2_set_context_id(execbuf, ctx);
226         execbuf.rsvd2 = 0;
227
228         ret = gem_exec(fd, &execbuf);
229         if (ret < 0)
230                 return ret;
231
232         return exec.handle;
233 }
234
235 static int exec_valid(int fd, int ctx)
236 {
237         return exec_valid_ring(fd, ctx, current_ring->exec);
238 }
239
240 static void stop_rings(const int mask)
241 {
242         int fd;
243         char buf[80];
244
245         igt_assert((mask & ~((1 << NUM_RINGS) - 1)) == 0);
246         igt_assert(snprintf(buf, sizeof(buf), "0x%02x", mask) == 4);
247         fd = igt_debugfs_open(&dfs, "i915_ring_stop", O_WRONLY);
248         igt_assert(fd >= 0);
249
250         igt_assert(write(fd, buf, 4) == 4);
251         close(fd);
252 }
253
254 #define BUFSIZE (4 * 1024)
255 #define ITEMS   (BUFSIZE >> 2)
256
257 static int ring_to_mask(int ring)
258 {
259         for (unsigned i = 0; i < NUM_RINGS; i++) {
260                 const struct target_ring *r = &rings[i];
261
262                 if (r->exec == ring)
263                         return (1 << i);
264         }
265
266         igt_assert(0);
267
268         return -1;
269 }
270
271 static int inject_hang_ring(int fd, int ctx, int ring)
272 {
273         struct drm_i915_gem_execbuffer2 execbuf;
274         struct drm_i915_gem_exec_object2 exec;
275         uint64_t gtt_off;
276         uint32_t *buf;
277         int roff, i;
278         unsigned cmd_len = 2;
279
280         srandom(time(NULL));
281
282         if (intel_gen(intel_get_drm_devid(fd)) >= 8)
283                 cmd_len = 3;
284
285         buf = malloc(BUFSIZE);
286         igt_assert(buf != NULL);
287
288         buf[0] = MI_BATCH_BUFFER_END;
289         buf[1] = MI_NOOP;
290
291         exec.handle = gem_create(fd, BUFSIZE);
292         gem_write(fd, exec.handle, 0, buf, BUFSIZE);
293         exec.relocation_count = 0;
294         exec.relocs_ptr = 0;
295         exec.alignment = 0;
296         exec.offset = 0;
297         exec.flags = 0;
298         exec.rsvd1 = 0;
299         exec.rsvd2 = 0;
300
301         execbuf.buffers_ptr = (uintptr_t)&exec;
302         execbuf.buffer_count = 1;
303         execbuf.batch_start_offset = 0;
304         execbuf.batch_len = BUFSIZE;
305         execbuf.cliprects_ptr = 0;
306         execbuf.num_cliprects = 0;
307         execbuf.DR1 = 0;
308         execbuf.DR4 = 0;
309         execbuf.flags = ring;
310         i915_execbuffer2_set_context_id(execbuf, ctx);
311         execbuf.rsvd2 = 0;
312
313         igt_assert(gem_exec(fd, &execbuf) == 0);
314
315         gtt_off = exec.offset;
316
317         for (i = 0; i < ITEMS; i++)
318                 buf[i] = MI_NOOP;
319
320         roff = random() % (ITEMS - cmd_len);
321         buf[roff] = MI_BATCH_BUFFER_START | (cmd_len - 2);
322         buf[roff + 1] = (gtt_off & 0xfffffffc) + (roff << 2);
323         if (cmd_len == 3)
324                 buf[roff + 2] = gtt_off & 0xffffffff00000000ull;
325
326 #ifdef VERBOSE
327         printf("loop injected at 0x%lx (off 0x%x, bo_start 0x%lx, bo_end 0x%lx)\n",
328                (long unsigned int)((roff << 2) + gtt_off),
329                roff << 2, (long unsigned int)gtt_off,
330                (long unsigned int)(gtt_off + BUFSIZE - 1));
331 #endif
332         gem_write(fd, exec.handle, 0, buf, BUFSIZE);
333
334         exec.relocation_count = 0;
335         exec.relocs_ptr = 0;
336         exec.alignment = 0;
337         exec.offset = 0;
338         exec.flags = 0;
339         exec.rsvd1 = 0;
340         exec.rsvd2 = 0;
341
342         execbuf.buffers_ptr = (uintptr_t)&exec;
343         execbuf.buffer_count = 1;
344         execbuf.batch_start_offset = 0;
345         execbuf.batch_len = BUFSIZE;
346         execbuf.cliprects_ptr = 0;
347         execbuf.num_cliprects = 0;
348         execbuf.DR1 = 0;
349         execbuf.DR4 = 0;
350         execbuf.flags = ring;
351         i915_execbuffer2_set_context_id(execbuf, ctx);
352         execbuf.rsvd2 = 0;
353
354         igt_assert(gem_exec(fd, &execbuf) == 0);
355
356         igt_assert(gtt_off == exec.offset);
357
358         free(buf);
359
360         stop_rings(ring_to_mask(ring));
361
362         return exec.handle;
363 }
364
365 static int inject_hang(int fd, int ctx)
366 {
367         return inject_hang_ring(fd, ctx, current_ring->exec);
368 }
369
370 static int _assert_reset_status(int fd, int ctx, int status)
371 {
372         int rs;
373
374         rs = gem_reset_status(fd, ctx);
375         if (rs < 0) {
376                 printf("reset status for %d ctx %d returned %d\n",
377                        fd, ctx, rs);
378                 return rs;
379         }
380
381         if (rs != status) {
382                 printf("%d:%d reset status %d differs from assumed %d\n",
383                        fd, ctx, rs, status);
384
385                 return 1;
386         }
387
388         return 0;
389 }
390
391 #define assert_reset_status(fd, ctx, status) \
392         igt_assert(_assert_reset_status(fd, ctx, status) == 0)
393
394 static void test_rs(int num_fds, int hang_index, int rs_assumed_no_hang)
395 {
396         int i;
397         int fd[MAX_FD];
398         int h[MAX_FD];
399
400         igt_assert (num_fds <= MAX_FD);
401         igt_assert (hang_index < MAX_FD);
402
403         for (i = 0; i < num_fds; i++) {
404                 fd[i] = drm_open_any();
405                 igt_assert(fd[i]);
406         }
407
408         for (i = 0; i < num_fds; i++)
409                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
410
411         for (i = 0; i < num_fds; i++) {
412                 if (i == hang_index)
413                         h[i] = inject_hang(fd[i], 0);
414                 else
415                         h[i] = exec_valid(fd[i], 0);
416         }
417
418         gem_sync(fd[num_fds - 1], h[num_fds - 1]);
419
420         for (i = 0; i < num_fds; i++) {
421                 if (hang_index < 0) {
422                         assert_reset_status(fd[i], 0, rs_assumed_no_hang);
423                         continue;
424                 }
425
426                 if (i < hang_index)
427                         assert_reset_status(fd[i], 0, RS_NO_ERROR);
428                 if (i == hang_index)
429                         assert_reset_status(fd[i], 0, RS_BATCH_ACTIVE);
430                 if (i > hang_index)
431                         assert_reset_status(fd[i], 0, RS_BATCH_PENDING);
432         }
433
434         for (i = 0; i < num_fds; i++) {
435                 gem_close(fd[i], h[i]);
436                 close(fd[i]);
437         }
438 }
439
440 #define MAX_CTX 100
441 static void test_rs_ctx(int num_fds, int num_ctx, int hang_index,
442                         int hang_context)
443 {
444         int i, j;
445         int fd[MAX_FD];
446         int h[MAX_FD][MAX_CTX];
447         int ctx[MAX_FD][MAX_CTX];
448
449         igt_assert (num_fds <= MAX_FD);
450         igt_assert (hang_index < MAX_FD);
451
452         igt_assert (num_ctx <= MAX_CTX);
453         igt_assert (hang_context < MAX_CTX);
454
455         test_rs(num_fds, -1, RS_NO_ERROR);
456
457         for (i = 0; i < num_fds; i++) {
458                 fd[i] = drm_open_any();
459                 igt_assert(fd[i]);
460                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
461
462                 for (j = 0; j < num_ctx; j++) {
463                         ctx[i][j] = context_create(fd[i]);
464
465                 }
466
467                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
468         }
469
470         for (i = 0; i < num_fds; i++) {
471
472                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
473
474                 for (j = 0; j < num_ctx; j++)
475                         assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
476
477                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
478         }
479
480         for (i = 0; i < num_fds; i++) {
481                 for (j = 0; j < num_ctx; j++) {
482                         if (i == hang_index && j == hang_context)
483                                 h[i][j] = inject_hang(fd[i], ctx[i][j]);
484                         else
485                                 h[i][j] = exec_valid(fd[i], ctx[i][j]);
486                 }
487         }
488
489         gem_sync(fd[num_fds - 1], ctx[num_fds - 1][num_ctx - 1]);
490
491         for (i = 0; i < num_fds; i++)
492                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
493
494         for (i = 0; i < num_fds; i++) {
495                 for (j = 0; j < num_ctx; j++) {
496                         if (i < hang_index)
497                                 assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
498                         if (i == hang_index && j < hang_context)
499                                 assert_reset_status(fd[i], ctx[i][j], RS_NO_ERROR);
500                         if (i == hang_index && j == hang_context)
501                                 assert_reset_status(fd[i], ctx[i][j],
502                                                     RS_BATCH_ACTIVE);
503                         if (i == hang_index && j > hang_context)
504                                 assert_reset_status(fd[i], ctx[i][j],
505                                                     RS_BATCH_PENDING);
506                         if (i > hang_index)
507                                 assert_reset_status(fd[i], ctx[i][j],
508                                                     RS_BATCH_PENDING);
509                 }
510         }
511
512         for (i = 0; i < num_fds; i++) {
513                 for (j = 0; j < num_ctx; j++) {
514                         gem_close(fd[i], h[i][j]);
515                         igt_assert(context_destroy(fd[i], ctx[i][j]) == 0);
516                 }
517
518                 assert_reset_status(fd[i], 0, RS_NO_ERROR);
519
520                 close(fd[i]);
521         }
522 }
523
524 static void test_ban(void)
525 {
526         int h1,h2,h3,h4,h5,h6,h7;
527         int fd_bad, fd_good;
528         int retry = 10;
529         int active_count = 0, pending_count = 0;
530         struct local_drm_i915_reset_stats rs_bad, rs_good;
531
532         fd_bad = drm_open_any();
533         igt_assert(fd_bad >= 0);
534
535         fd_good = drm_open_any();
536         igt_assert(fd_good >= 0);
537
538         assert_reset_status(fd_bad, 0, RS_NO_ERROR);
539         assert_reset_status(fd_good, 0, RS_NO_ERROR);
540
541         h1 = exec_valid(fd_bad, 0);
542         igt_assert(h1 >= 0);
543         h5 = exec_valid(fd_good, 0);
544         igt_assert(h5 >= 0);
545
546         assert_reset_status(fd_bad, 0, RS_NO_ERROR);
547         assert_reset_status(fd_good, 0, RS_NO_ERROR);
548
549         h2 = inject_hang(fd_bad, 0);
550         igt_assert(h2 >= 0);
551         active_count++;
552         /* Second hang will be pending for this */
553         pending_count++;
554
555         h6 = exec_valid(fd_good, 0);
556         h7 = exec_valid(fd_good, 0);
557
558         while (retry--) {
559                 h3 = inject_hang(fd_bad, 0);
560                 igt_assert(h3 >= 0);
561                 gem_sync(fd_bad, h3);
562                 active_count++;
563                 /* This second hand will count as pending */
564                 assert_reset_status(fd_bad, 0, RS_BATCH_ACTIVE);
565
566                 h4 = exec_valid(fd_bad, 0);
567                 if (h4 == -EIO) {
568                         gem_close(fd_bad, h3);
569                         break;
570                 }
571
572                 /* Should not happen often but sometimes hang is declared too slow
573                  * due to our way of faking hang using loop */
574
575                 igt_assert(h4 >= 0);
576                 gem_close(fd_bad, h3);
577                 gem_close(fd_bad, h4);
578
579                 printf("retrying for ban (%d)\n", retry);
580         }
581
582         igt_assert(h4 == -EIO);
583         assert_reset_status(fd_bad, 0, RS_BATCH_ACTIVE);
584
585         gem_sync(fd_good, h7);
586         assert_reset_status(fd_good, 0, RS_BATCH_PENDING);
587
588         igt_assert(gem_reset_stats(fd_good, 0, &rs_good) == 0);
589         igt_assert(gem_reset_stats(fd_bad, 0, &rs_bad) == 0);
590
591         igt_assert(rs_bad.batch_active == active_count);
592         igt_assert(rs_bad.batch_pending == pending_count);
593         igt_assert(rs_good.batch_active == 0);
594         igt_assert(rs_good.batch_pending == 2);
595
596         gem_close(fd_bad, h1);
597         gem_close(fd_bad, h2);
598         gem_close(fd_good, h6);
599         gem_close(fd_good, h7);
600
601         h1 = exec_valid(fd_good, 0);
602         igt_assert(h1 >= 0);
603         gem_close(fd_good, h1);
604
605         close(fd_bad);
606         close(fd_good);
607
608         igt_assert(gem_reset_status(fd_bad, 0) < 0);
609         igt_assert(gem_reset_status(fd_good, 0) < 0);
610 }
611
612 static void test_ban_ctx(void)
613 {
614         int h1,h2,h3,h4,h5,h6,h7;
615         int ctx_good, ctx_bad;
616         int fd;
617         int retry = 10;
618         int active_count = 0, pending_count = 0;
619         struct local_drm_i915_reset_stats rs_bad, rs_good;
620
621         fd = drm_open_any();
622         igt_assert(fd >= 0);
623
624         assert_reset_status(fd, 0, RS_NO_ERROR);
625
626         ctx_good = context_create(fd);
627         ctx_bad = context_create(fd);
628
629         assert_reset_status(fd, 0, RS_NO_ERROR);
630         assert_reset_status(fd, ctx_good, RS_NO_ERROR);
631         assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
632
633         h1 = exec_valid(fd, ctx_bad);
634         igt_assert(h1 >= 0);
635         h5 = exec_valid(fd, ctx_good);
636         igt_assert(h5 >= 0);
637
638         assert_reset_status(fd, ctx_good, RS_NO_ERROR);
639         assert_reset_status(fd, ctx_bad, RS_NO_ERROR);
640
641         h2 = inject_hang(fd, ctx_bad);
642         igt_assert(h2 >= 0);
643         active_count++;
644         /* Second hang will be pending for this */
645         pending_count++;
646
647         h6 = exec_valid(fd, ctx_good);
648         h7 = exec_valid(fd, ctx_good);
649
650         while (retry--) {
651                 h3 = inject_hang(fd, ctx_bad);
652                 igt_assert(h3 >= 0);
653                 gem_sync(fd, h3);
654                 active_count++;
655                 /* This second hand will count as pending */
656                 assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
657
658                 h4 = exec_valid(fd, ctx_bad);
659                 if (h4 == -EIO) {
660                         gem_close(fd, h3);
661                         break;
662                 }
663
664                 /* Should not happen often but sometimes hang is declared too slow
665                  * due to our way of faking hang using loop */
666
667                 igt_assert(h4 >= 0);
668                 gem_close(fd, h3);
669                 gem_close(fd, h4);
670
671                 printf("retrying for ban (%d)\n", retry);
672         }
673
674         igt_assert(h4 == -EIO);
675         assert_reset_status(fd, ctx_bad, RS_BATCH_ACTIVE);
676
677         gem_sync(fd, h7);
678         assert_reset_status(fd, ctx_good, RS_BATCH_PENDING);
679
680         igt_assert(gem_reset_stats(fd, ctx_good, &rs_good) == 0);
681         igt_assert(gem_reset_stats(fd, ctx_bad, &rs_bad) == 0);
682
683         igt_assert(rs_bad.batch_active == active_count);
684         igt_assert(rs_bad.batch_pending == pending_count);
685         igt_assert(rs_good.batch_active == 0);
686         igt_assert(rs_good.batch_pending == 2);
687
688         gem_close(fd, h1);
689         gem_close(fd, h2);
690         gem_close(fd, h6);
691         gem_close(fd, h7);
692
693         h1 = exec_valid(fd, ctx_good);
694         igt_assert(h1 >= 0);
695         gem_close(fd, h1);
696
697         igt_assert(context_destroy(fd, ctx_good) == 0);
698         igt_assert(context_destroy(fd, ctx_bad) == 0);
699         igt_assert(gem_reset_status(fd, ctx_good) < 0);
700         igt_assert(gem_reset_status(fd, ctx_bad) < 0);
701         igt_assert(exec_valid(fd, ctx_good) < 0);
702         igt_assert(exec_valid(fd, ctx_bad) < 0);
703
704         close(fd);
705 }
706
707 static void test_unrelated_ctx(void)
708 {
709         int h1,h2;
710         int fd1,fd2;
711         int ctx_guilty, ctx_unrelated;
712
713         fd1 = drm_open_any();
714         fd2 = drm_open_any();
715         assert_reset_status(fd1, 0, RS_NO_ERROR);
716         assert_reset_status(fd2, 0, RS_NO_ERROR);
717         ctx_guilty = context_create(fd1);
718         ctx_unrelated = context_create(fd2);
719
720         assert_reset_status(fd1, ctx_guilty, RS_NO_ERROR);
721         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
722
723         h1 = inject_hang(fd1, ctx_guilty);
724         igt_assert(h1 >= 0);
725         gem_sync(fd1, h1);
726         assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
727         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
728
729         h2 = exec_valid(fd2, ctx_unrelated);
730         igt_assert(h2 >= 0);
731         gem_sync(fd2, h2);
732         assert_reset_status(fd1, ctx_guilty, RS_BATCH_ACTIVE);
733         assert_reset_status(fd2, ctx_unrelated, RS_NO_ERROR);
734         gem_close(fd1, h1);
735         gem_close(fd2, h2);
736
737         igt_assert(context_destroy(fd1, ctx_guilty) == 0);
738         igt_assert(context_destroy(fd2, ctx_unrelated) == 0);
739
740         close(fd1);
741         close(fd2);
742 }
743
744 static int get_reset_count(int fd, int ctx)
745 {
746         int ret;
747         struct local_drm_i915_reset_stats rs;
748
749         ret = gem_reset_stats(fd, ctx, &rs);
750         if (ret)
751                 return ret;
752
753         return rs.reset_count;
754 }
755
756 static void test_close_pending_ctx(void)
757 {
758         int fd, h;
759         uint32_t ctx;
760
761         fd = drm_open_any();
762         igt_assert(fd >= 0);
763         ctx = context_create(fd);
764
765         assert_reset_status(fd, ctx, RS_NO_ERROR);
766
767         h = inject_hang(fd, ctx);
768         igt_assert(h >= 0);
769         igt_assert(context_destroy(fd, ctx) == 0);
770         igt_assert(context_destroy(fd, ctx) == -ENOENT);
771
772         gem_close(fd, h);
773         close(fd);
774 }
775
776 static void test_close_pending(void)
777 {
778         int fd, h;
779
780         fd = drm_open_any();
781         igt_assert(fd >= 0);
782
783         assert_reset_status(fd, 0, RS_NO_ERROR);
784
785         h = inject_hang(fd, 0);
786         igt_assert(h >= 0);
787
788         gem_close(fd, h);
789         close(fd);
790 }
791
792 static void exec_noop_on_each_ring(int fd, const bool reverse)
793 {
794         uint32_t batch[2] = {MI_BATCH_BUFFER_END, 0};
795         uint32_t handle;
796         struct drm_i915_gem_execbuffer2 execbuf;
797         struct drm_i915_gem_exec_object2 exec[1];
798
799         handle = gem_create(fd, 4096);
800         gem_write(fd, handle, 0, batch, sizeof(batch));
801
802         exec[0].handle = handle;
803         exec[0].relocation_count = 0;
804         exec[0].relocs_ptr = 0;
805         exec[0].alignment = 0;
806         exec[0].offset = 0;
807         exec[0].flags = 0;
808         exec[0].rsvd1 = 0;
809         exec[0].rsvd2 = 0;
810
811         execbuf.buffers_ptr = (uintptr_t)exec;
812         execbuf.buffer_count = 1;
813         execbuf.batch_start_offset = 0;
814         execbuf.batch_len = 8;
815         execbuf.cliprects_ptr = 0;
816         execbuf.num_cliprects = 0;
817         execbuf.DR1 = 0;
818         execbuf.DR4 = 0;
819         execbuf.flags = 0;
820         i915_execbuffer2_set_context_id(execbuf, 0);
821         execbuf.rsvd2 = 0;
822
823         for (unsigned i = 0; i < NUM_RINGS; i++) {
824                 const struct target_ring *ring;
825
826                 ring = reverse ? &rings[NUM_RINGS - 1 - i] : &rings[i];
827
828                 if (ring->present(fd)) {
829                         execbuf.flags = ring->exec;
830                         do_ioctl(fd, DRM_IOCTL_I915_GEM_EXECBUFFER2, &execbuf);
831                 }
832         }
833
834         gem_sync(fd, handle);
835         gem_close(fd, handle);
836 }
837
838 static void test_close_pending_fork(const bool reverse)
839 {
840         int pid;
841         int fd, h;
842
843         fd = drm_open_any();
844         igt_assert(fd >= 0);
845
846         assert_reset_status(fd, 0, RS_NO_ERROR);
847
848         h = inject_hang(fd, 0);
849         igt_assert(h >= 0);
850
851         sleep(1);
852
853         /* Avoid helpers as we need to kill the child
854          * without any extra signal handling on behalf of
855          * lib/drmtest.c
856          */
857         pid = fork();
858         if (pid == 0) {
859                 const int fd2 = drm_open_any();
860                 igt_assert(fd2 >= 0);
861
862                 /* The crucial component is that we schedule the same noop batch
863                  * on each ring. This exercises batch_obj reference counting,
864                  * when gpu is reset and ring lists are cleared.
865                  */
866                 exec_noop_on_each_ring(fd2, reverse);
867
868                 close(fd2);
869                 return;
870         } else {
871                 igt_assert(pid > 0);
872                 sleep(1);
873
874                 /* Kill the child to reduce refcounts on
875                    batch_objs */
876                 kill(pid, SIGKILL);
877         }
878
879         gem_close(fd, h);
880         close(fd);
881
882         /* Then we just wait on hang to happen */
883         fd = drm_open_any();
884         igt_assert(fd >= 0);
885
886         h = exec_valid(fd, 0);
887         igt_assert(h >= 0);
888
889         gem_sync(fd, h);
890         gem_close(fd, h);
891         close(fd);
892 }
893
894 static void test_reset_count(const bool create_ctx)
895 {
896         int fd, h, ctx;
897         long c1, c2;
898
899         fd = drm_open_any();
900         igt_assert(fd >= 0);
901         if (create_ctx)
902                 ctx = context_create(fd);
903         else
904                 ctx = 0;
905
906         assert_reset_status(fd, ctx, RS_NO_ERROR);
907
908         c1 = get_reset_count(fd, ctx);
909         igt_assert(c1 >= 0);
910
911         h = inject_hang(fd, ctx);
912         igt_assert (h >= 0);
913         gem_sync(fd, h);
914
915         assert_reset_status(fd, ctx, RS_BATCH_ACTIVE);
916         c2 = get_reset_count(fd, ctx);
917         igt_assert(c2 >= 0);
918         igt_assert(c2 == (c1 + 1));
919
920         igt_fork(child, 1) {
921                 igt_drop_root();
922
923                 c2 = get_reset_count(fd, ctx);
924
925                 if (ctx == 0)
926                         igt_assert(c2 == -EPERM);
927                 else
928                         igt_assert(c2 == 0);
929         }
930
931         igt_waitchildren();
932
933         gem_close(fd, h);
934
935         if (create_ctx)
936                 context_destroy(fd, ctx);
937
938         close(fd);
939 }
940
941 static int _test_params(int fd, int ctx, uint32_t flags, uint32_t pad)
942 {
943         struct local_drm_i915_reset_stats rs;
944         int ret;
945
946         rs.ctx_id = ctx;
947         rs.flags = flags;
948         rs.reset_count = rand();
949         rs.batch_active = rand();
950         rs.batch_pending = rand();
951         rs.pad = pad;
952
953         do {
954                 ret = ioctl(fd, GET_RESET_STATS_IOCTL, &rs);
955         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
956
957         if (ret < 0)
958                 return -errno;
959
960         return 0;
961 }
962
963 typedef enum { root = 0, user } cap_t;
964
965 static void test_param_ctx(const int fd, const int ctx, const cap_t cap)
966 {
967         const uint32_t bad = rand() + 1;
968
969         if (ctx == 0) {
970                 if (cap == root)
971                         igt_assert(_test_params(fd, ctx, 0, 0) == 0);
972                 else
973                         igt_assert(_test_params(fd, ctx, 0, 0) == -EPERM);
974         }
975
976         igt_assert(_test_params(fd, ctx, 0, bad) == -EINVAL);
977         igt_assert(_test_params(fd, ctx, bad, 0) == -EINVAL);
978         igt_assert(_test_params(fd, ctx, bad, bad) == -EINVAL);
979 }
980
981 static void check_params(const int fd, const int ctx, cap_t cap)
982 {
983         igt_assert(ioctl(fd, GET_RESET_STATS_IOCTL, 0) == -1);
984         igt_assert(_test_params(fd, 0xbadbad, 0, 0) == -ENOENT);
985
986         test_param_ctx(fd, 0, cap);
987         test_param_ctx(fd, ctx, cap);
988 }
989
990 static void _test_param(const int fd, const int ctx)
991 {
992         check_params(fd, ctx, root);
993
994         igt_fork(child, 1) {
995                 check_params(fd, ctx, root);
996
997                 igt_drop_root();
998
999                 check_params(fd, ctx, user);
1000         }
1001
1002         check_params(fd, ctx, root);
1003
1004         igt_waitchildren();
1005 }
1006
1007 static void test_params(void)
1008 {
1009         int fd, ctx;
1010
1011         fd = drm_open_any();
1012         igt_assert(fd >= 0);
1013         ctx = context_create(fd);
1014
1015         _test_param(fd, ctx);
1016
1017         close(fd);
1018 }
1019
1020 #define RING_HAS_CONTEXTS current_ring->contexts(current_ring)
1021 #define RUN_CTX_TEST(...) do { igt_skip_on(RING_HAS_CONTEXTS == false); __VA_ARGS__; } while (0)
1022
1023 int fd;
1024
1025 igt_main
1026 {
1027         struct local_drm_i915_gem_context_create create;
1028         uint32_t devid;
1029         int ret;
1030
1031         igt_skip_on_simulation();
1032
1033         igt_fixture {
1034                 fd = drm_open_any();
1035                 devid = intel_get_drm_devid(fd);
1036                 igt_require_f(intel_gen(devid) >= 4,
1037                               "Architecture %d too old\n", intel_gen(devid));
1038
1039                 ret = drmIoctl(fd, CONTEXT_CREATE_IOCTL, &create);
1040                 igt_skip_on_f(ret != 0 && (errno == ENODEV || errno == EINVAL),
1041                               "Kernel is too old, or contexts not supported: %s\n",
1042                               strerror(errno));
1043
1044                 igt_debugfs_init(&dfs);
1045         }
1046
1047         igt_subtest("params")
1048                 test_params();
1049
1050         for (int i = 0; i < NUM_RINGS; i++) {
1051                 const char *name;
1052
1053                 current_ring = &rings[i];
1054                 name = current_ring->name;
1055
1056                 igt_fixture
1057                         gem_require_ring(fd, current_ring->exec);
1058
1059                 igt_subtest_f("reset-stats-%s", name)
1060                         test_rs(4, 1, 0);
1061
1062                 igt_subtest_f("reset-stats-ctx-%s", name)
1063                         RUN_CTX_TEST(test_rs_ctx(4, 4, 1, 2));
1064
1065                 igt_subtest_f("ban-%s", name)
1066                         test_ban();
1067
1068                 igt_subtest_f("ban-ctx-%s", name)
1069                         RUN_CTX_TEST(test_ban_ctx());
1070
1071                 igt_subtest_f("reset-count-%s", name)
1072                         test_reset_count(false);
1073
1074                 igt_subtest_f("reset-count-ctx-%s", name)
1075                         RUN_CTX_TEST(test_reset_count(true));
1076
1077                 igt_subtest_f("unrelated-ctx-%s", name)
1078                         RUN_CTX_TEST(test_unrelated_ctx());
1079
1080                 igt_subtest_f("close-pending-%s", name) {
1081                         test_close_pending();
1082                         gem_quiescent_gpu(fd);
1083                 }
1084
1085                 igt_subtest_f("close-pending-ctx-%s", name) {
1086                         RUN_CTX_TEST(test_close_pending_ctx());
1087                         gem_quiescent_gpu(fd);
1088                 }
1089
1090                 igt_subtest_f("close-pending-fork-%s", name) {
1091                         test_close_pending_fork(true);
1092                         test_close_pending_fork(false);
1093                 }
1094         }
1095
1096         igt_fixture
1097                 close(fd);
1098 }