drivers/gpu/drm/i915/selftests/i915_gem.c

   1 /*
   2  * SPDX-License-Identifier: MIT
   3  *
   4  * Copyright © 2018 Intel Corporation
   5  */
   6
   7 #include <linux/prandom.h>
   8
   9 #include "gem/i915_gem_internal.h"
  10 #include "gem/i915_gem_pm.h"
  11 #include "gem/selftests/igt_gem_utils.h"
  12 #include "gem/selftests/mock_context.h"
  13 #include "gt/intel_gt.h"
  14 #include "gt/intel_gt_pm.h"
  15
  16 #include "i915_selftest.h"
  17
  18 #include "igt_flush_test.h"
  19 #include "mock_drm.h"
  20
  21 static int switch_to_context(struct i915_gem_context *ctx)
  22 {
  23         struct i915_gem_engines_iter it;
  24         struct intel_context *ce;
  25         int err = 0;
  26
  27         for_each_gem_engine(ce, i915_gem_context_lock_engines(ctx), it) {
  28                 struct i915_request *rq;
  29
  30                 rq = intel_context_create_request(ce);
  31                 if (IS_ERR(rq)) {
  32                         err = PTR_ERR(rq);
  33                         break;
  34                 }
  35
  36                 i915_request_add(rq);
  37         }
  38         i915_gem_context_unlock_engines(ctx);
  39
  40         return err;
  41 }
  42
  43 static void trash_stolen(struct drm_i915_private *i915)
  44 {
  45         struct i915_ggtt *ggtt = to_gt(i915)->ggtt;
  46         const u64 slot = ggtt->error_capture.start;
  47         const resource_size_t size = resource_size(&i915->dsm.stolen);
  48         unsigned long page;
  49         u32 prng = 0x12345678;
  50
  51         /* XXX: fsck. needs some more thought... */
  52         if (!i915_ggtt_has_aperture(ggtt))
  53                 return;
  54
  55         for (page = 0; page < size; page += PAGE_SIZE) {
  56                 const dma_addr_t dma = i915->dsm.stolen.start + page;
  57                 u32 __iomem *s;
  58                 int x;
  59
  60                 ggtt->vm.insert_page(&ggtt->vm, dma, slot,
  61                                      i915_gem_get_pat_index(i915,
  62                                                             I915_CACHE_NONE),
  63                                      0);
  64
  65                 s = io_mapping_map_atomic_wc(&ggtt->iomap, slot);
  66                 for (x = 0; x < PAGE_SIZE / sizeof(u32); x++) {
  67                         prng = next_pseudo_random32(prng);
  68                         iowrite32(prng, &s[x]);
  69                 }
  70                 io_mapping_unmap_atomic(s);
  71         }
  72
  73         ggtt->vm.clear_range(&ggtt->vm, slot, PAGE_SIZE);
  74 }
  75
  76 static void simulate_hibernate(struct drm_i915_private *i915)
  77 {
  78         intel_wakeref_t wakeref;
  79
  80         wakeref = intel_runtime_pm_get(&i915->runtime_pm);
  81
  82         /*
  83          * As a final sting in the tail, invalidate stolen. Under a real S4,
  84          * stolen is lost and needs to be refilled on resume. However, under
  85          * CI we merely do S4-device testing (as full S4 is too unreliable
  86          * for automated testing across a cluster), so to simulate the effect
  87          * of stolen being trashed across S4, we trash it ourselves.
  88          */
  89         trash_stolen(i915);
  90
  91         intel_runtime_pm_put(&i915->runtime_pm, wakeref);
  92 }
  93
  94 static int igt_pm_prepare(struct drm_i915_private *i915)
  95 {
  96         i915_gem_suspend(i915);
  97
  98         return 0;
  99 }
 100
 101 static void igt_pm_suspend(struct drm_i915_private *i915)
 102 {
 103         intel_wakeref_t wakeref;
 104
 105         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 106                 i915_ggtt_suspend(to_gt(i915)->ggtt);
 107                 i915_gem_suspend_late(i915);
 108         }
 109 }
 110
 111 static void igt_pm_hibernate(struct drm_i915_private *i915)
 112 {
 113         intel_wakeref_t wakeref;
 114
 115         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 116                 i915_ggtt_suspend(to_gt(i915)->ggtt);
 117
 118                 i915_gem_freeze(i915);
 119                 i915_gem_freeze_late(i915);
 120         }
 121 }
 122
 123 static void igt_pm_resume(struct drm_i915_private *i915)
 124 {
 125         intel_wakeref_t wakeref;
 126
 127         /*
 128          * Both suspend and hibernate follow the same wakeup path and assume
 129          * that runtime-pm just works.
 130          */
 131         with_intel_runtime_pm(&i915->runtime_pm, wakeref) {
 132                 i915_ggtt_resume(to_gt(i915)->ggtt);
 133                 if (GRAPHICS_VER(i915) >= 8)
 134                         setup_private_pat(to_gt(i915));
 135                 i915_gem_resume(i915);
 136         }
 137 }
 138
 139 static int igt_gem_suspend(void *arg)
 140 {
 141         struct drm_i915_private *i915 = arg;
 142         struct i915_gem_context *ctx;
 143         struct file *file;
 144         int err;
 145
 146         file = mock_file(i915);
 147         if (IS_ERR(file))
 148                 return PTR_ERR(file);
 149
 150         err = -ENOMEM;
 151         ctx = live_context(i915, file);
 152         if (!IS_ERR(ctx))
 153                 err = switch_to_context(ctx);
 154         if (err)
 155                 goto out;
 156
 157         err = igt_pm_prepare(i915);
 158         if (err)
 159                 goto out;
 160
 161         igt_pm_suspend(i915);
 162
 163         /* Here be dragons! Note that with S3RST any S3 may become S4! */
 164         simulate_hibernate(i915);
 165
 166         igt_pm_resume(i915);
 167
 168         err = switch_to_context(ctx);
 169 out:
 170         fput(file);
 171         return err;
 172 }
 173
 174 static int igt_gem_hibernate(void *arg)
 175 {
 176         struct drm_i915_private *i915 = arg;
 177         struct i915_gem_context *ctx;
 178         struct file *file;
 179         int err;
 180
 181         file = mock_file(i915);
 182         if (IS_ERR(file))
 183                 return PTR_ERR(file);
 184
 185         err = -ENOMEM;
 186         ctx = live_context(i915, file);
 187         if (!IS_ERR(ctx))
 188                 err = switch_to_context(ctx);
 189         if (err)
 190                 goto out;
 191
 192         err = igt_pm_prepare(i915);
 193         if (err)
 194                 goto out;
 195
 196         igt_pm_hibernate(i915);
 197
 198         /* Here be dragons! */
 199         simulate_hibernate(i915);
 200
 201         igt_pm_resume(i915);
 202
 203         err = switch_to_context(ctx);
 204 out:
 205         fput(file);
 206         return err;
 207 }
 208
 209 static int igt_gem_ww_ctx(void *arg)
 210 {
 211         struct drm_i915_private *i915 = arg;
 212         struct drm_i915_gem_object *obj, *obj2;
 213         struct i915_gem_ww_ctx ww;
 214         int err = 0;
 215
 216         obj = i915_gem_object_create_internal(i915, PAGE_SIZE);
 217         if (IS_ERR(obj))
 218                 return PTR_ERR(obj);
 219
 220         obj2 = i915_gem_object_create_internal(i915, PAGE_SIZE);
 221         if (IS_ERR(obj2)) {
 222                 err = PTR_ERR(obj2);
 223                 goto put1;
 224         }
 225
 226         i915_gem_ww_ctx_init(&ww, true);
 227 retry:
 228         /* Lock the objects, twice for good measure (-EALREADY handling) */
 229         err = i915_gem_object_lock(obj, &ww);
 230         if (!err)
 231                 err = i915_gem_object_lock_interruptible(obj, &ww);
 232         if (!err)
 233                 err = i915_gem_object_lock_interruptible(obj2, &ww);
 234         if (!err)
 235                 err = i915_gem_object_lock(obj2, &ww);
 236
 237         if (err == -EDEADLK) {
 238                 err = i915_gem_ww_ctx_backoff(&ww);
 239                 if (!err)
 240                         goto retry;
 241         }
 242         i915_gem_ww_ctx_fini(&ww);
 243         i915_gem_object_put(obj2);
 244 put1:
 245         i915_gem_object_put(obj);
 246         return err;
 247 }
 248
 249 int i915_gem_live_selftests(struct drm_i915_private *i915)
 250 {
 251         static const struct i915_subtest tests[] = {
 252                 SUBTEST(igt_gem_suspend),
 253                 SUBTEST(igt_gem_hibernate),
 254                 SUBTEST(igt_gem_ww_ctx),
 255         };
 256
 257         if (intel_gt_is_wedged(to_gt(i915)))
 258                 return 0;
 259
 260         return i915_live_subtests(tests, i915);
 261 }