2 * SPDX-License-Identifier: GPL-2.0
4 * Copyright © 2019 Intel Corporation
7 #include "i915_selftest.h"
8 #include "intel_engine_heartbeat.h"
9 #include "intel_engine_pm.h"
12 #include "gem/selftests/mock_context.h"
13 #include "selftests/igt_flush_test.h"
14 #include "selftests/mock_drm.h"
16 static int request_sync(struct i915_request
*rq
)
18 struct intel_timeline
*tl
= i915_request_timeline(rq
);
22 intel_timeline_get(tl
);
25 /* Opencode i915_request_add() so we can keep the timeline locked. */
26 __i915_request_commit(rq
);
27 rq
->sched
.attr
.priority
= I915_PRIORITY_BARRIER
;
28 __i915_request_queue(rq
, NULL
);
30 timeout
= i915_request_wait(rq
, 0, HZ
/ 10);
34 i915_request_retire_upto(rq
);
36 lockdep_unpin_lock(&tl
->mutex
, rq
->cookie
);
37 mutex_unlock(&tl
->mutex
);
40 intel_timeline_put(tl
);
45 static int context_sync(struct intel_context
*ce
)
47 struct intel_timeline
*tl
= ce
->timeline
;
50 mutex_lock(&tl
->mutex
);
52 struct i915_request
*rq
;
55 if (list_empty(&tl
->requests
))
58 rq
= list_last_entry(&tl
->requests
, typeof(*rq
), link
);
61 timeout
= i915_request_wait(rq
, 0, HZ
/ 10);
65 i915_request_retire_upto(rq
);
69 mutex_unlock(&tl
->mutex
);
71 /* Wait for all barriers to complete (remote CPU) before we check */
72 i915_active_unlock_wait(&ce
->active
);
76 static int __live_context_size(struct intel_engine_cs
*engine
)
78 struct intel_context
*ce
;
79 struct i915_request
*rq
;
83 ce
= intel_context_create(engine
);
87 err
= intel_context_pin(ce
);
91 vaddr
= i915_gem_object_pin_map(ce
->state
->obj
,
92 i915_coherent_map_type(engine
->i915
));
95 intel_context_unpin(ce
);
100 * Note that execlists also applies a redzone which it checks on
101 * context unpin when debugging. We are using the same location
102 * and same poison value so that our checks overlap. Despite the
103 * redundancy, we want to keep this little selftest so that we
104 * get coverage of any and all submission backends, and we can
105 * always extend this test to ensure we trick the HW into a
106 * compromising position wrt to the various sections that need
107 * to be written into the context state.
109 * TLDR; this overlaps with the execlists redzone.
111 vaddr
+= engine
->context_size
- I915_GTT_PAGE_SIZE
;
112 memset(vaddr
, POISON_INUSE
, I915_GTT_PAGE_SIZE
);
114 rq
= intel_context_create_request(ce
);
115 intel_context_unpin(ce
);
121 err
= request_sync(rq
);
125 /* Force the context switch */
126 rq
= intel_engine_create_kernel_request(engine
);
131 err
= request_sync(rq
);
135 if (memchr_inv(vaddr
, POISON_INUSE
, I915_GTT_PAGE_SIZE
)) {
136 pr_err("%s context overwrote trailing red-zone!", engine
->name
);
141 i915_gem_object_unpin_map(ce
->state
->obj
);
143 intel_context_put(ce
);
147 static int live_context_size(void *arg
)
149 struct intel_gt
*gt
= arg
;
150 struct intel_engine_cs
*engine
;
151 enum intel_engine_id id
;
155 * Check that our context sizes are correct by seeing if the
156 * HW tries to write past the end of one.
159 for_each_engine(engine
, gt
, id
) {
162 if (!engine
->context_size
)
165 intel_engine_pm_get(engine
);
168 * Hide the old default state -- we lie about the context size
169 * and get confused when the default state is smaller than
170 * expected. For our do nothing request, inheriting the
171 * active state is sufficient, we are only checking that we
172 * don't use more than we planned.
174 saved
= fetch_and_zero(&engine
->default_state
);
176 /* Overlaps with the execlists redzone */
177 engine
->context_size
+= I915_GTT_PAGE_SIZE
;
179 err
= __live_context_size(engine
);
181 engine
->context_size
-= I915_GTT_PAGE_SIZE
;
183 engine
->default_state
= saved
;
185 intel_engine_pm_put(engine
);
194 static int __live_active_context(struct intel_engine_cs
*engine
)
196 unsigned long saved_heartbeat
;
197 struct intel_context
*ce
;
202 * We keep active contexts alive until after a subsequent context
203 * switch as the final write from the context-save will be after
204 * we retire the final request. We track when we unpin the context,
205 * under the presumption that the final pin is from the last request,
206 * and instead of immediately unpinning the context, we add a task
207 * to unpin the context from the next idle-barrier.
209 * This test makes sure that the context is kept alive until a
210 * subsequent idle-barrier (emitted when the engine wakeref hits 0
211 * with no more outstanding requests).
214 if (intel_engine_pm_is_awake(engine
)) {
215 pr_err("%s is awake before starting %s!\n",
216 engine
->name
, __func__
);
220 ce
= intel_context_create(engine
);
224 saved_heartbeat
= engine
->props
.heartbeat_interval_ms
;
225 engine
->props
.heartbeat_interval_ms
= 0;
227 for (pass
= 0; pass
<= 2; pass
++) {
228 struct i915_request
*rq
;
230 intel_engine_pm_get(engine
);
232 rq
= intel_context_create_request(ce
);
238 err
= request_sync(rq
);
242 /* Context will be kept active until after an idle-barrier. */
243 if (i915_active_is_idle(&ce
->active
)) {
244 pr_err("context is not active; expected idle-barrier (%s pass %d)\n",
250 if (!intel_engine_pm_is_awake(engine
)) {
251 pr_err("%s is asleep before idle-barrier\n",
258 intel_engine_pm_put(engine
);
263 /* Now make sure our idle-barriers are flushed */
264 err
= intel_engine_flush_barriers(engine
);
268 /* Wait for the barrier and in the process wait for engine to park */
269 err
= context_sync(engine
->kernel_context
);
273 if (!i915_active_is_idle(&ce
->active
)) {
274 pr_err("context is still active!");
278 intel_engine_pm_flush(engine
);
280 if (intel_engine_pm_is_awake(engine
)) {
281 struct drm_printer p
= drm_debug_printer(__func__
);
283 intel_engine_dump(engine
, &p
,
284 "%s is still awake:%d after idle-barriers\n",
286 atomic_read(&engine
->wakeref
.count
));
294 engine
->props
.heartbeat_interval_ms
= saved_heartbeat
;
295 intel_context_put(ce
);
299 static int live_active_context(void *arg
)
301 struct intel_gt
*gt
= arg
;
302 struct intel_engine_cs
*engine
;
303 enum intel_engine_id id
;
306 for_each_engine(engine
, gt
, id
) {
307 err
= __live_active_context(engine
);
311 err
= igt_flush_test(gt
->i915
);
319 static int __remote_sync(struct intel_context
*ce
, struct intel_context
*remote
)
321 struct i915_request
*rq
;
324 err
= intel_context_pin(remote
);
328 rq
= intel_context_create_request(ce
);
334 err
= intel_context_prepare_remote_request(remote
, rq
);
336 i915_request_add(rq
);
340 err
= request_sync(rq
);
343 intel_context_unpin(remote
);
347 static int __live_remote_context(struct intel_engine_cs
*engine
)
349 struct intel_context
*local
, *remote
;
350 unsigned long saved_heartbeat
;
355 * Check that our idle barriers do not interfere with normal
356 * activity tracking. In particular, check that operating
357 * on the context image remotely (intel_context_prepare_remote_request),
358 * which inserts foreign fences into intel_context.active, does not
359 * clobber the idle-barrier.
362 if (intel_engine_pm_is_awake(engine
)) {
363 pr_err("%s is awake before starting %s!\n",
364 engine
->name
, __func__
);
368 remote
= intel_context_create(engine
);
370 return PTR_ERR(remote
);
372 local
= intel_context_create(engine
);
374 err
= PTR_ERR(local
);
378 saved_heartbeat
= engine
->props
.heartbeat_interval_ms
;
379 engine
->props
.heartbeat_interval_ms
= 0;
380 intel_engine_pm_get(engine
);
382 for (pass
= 0; pass
<= 2; pass
++) {
383 err
= __remote_sync(local
, remote
);
387 err
= __remote_sync(engine
->kernel_context
, remote
);
391 if (i915_active_is_idle(&remote
->active
)) {
392 pr_err("remote context is not active; expected idle-barrier (%s pass %d)\n",
399 intel_engine_pm_put(engine
);
400 engine
->props
.heartbeat_interval_ms
= saved_heartbeat
;
402 intel_context_put(local
);
404 intel_context_put(remote
);
408 static int live_remote_context(void *arg
)
410 struct intel_gt
*gt
= arg
;
411 struct intel_engine_cs
*engine
;
412 enum intel_engine_id id
;
415 for_each_engine(engine
, gt
, id
) {
416 err
= __live_remote_context(engine
);
420 err
= igt_flush_test(gt
->i915
);
428 int intel_context_live_selftests(struct drm_i915_private
*i915
)
430 static const struct i915_subtest tests
[] = {
431 SUBTEST(live_context_size
),
432 SUBTEST(live_active_context
),
433 SUBTEST(live_remote_context
),
435 struct intel_gt
*gt
= &i915
->gt
;
437 if (intel_gt_is_wedged(gt
))
440 return intel_gt_live_subtests(tests
, gt
);