mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-28 11:18:45 +07:00
8ab3a3812a
In commit5ba32c7be8("drm/i915/execlists: Always force a context reload when rewinding RING_TAIL"), we placed the check for rewinding a context on actually submitting the next request in that context. This was so that we only had to check once, and could do so with precision avoiding as many forced restores as possible. For example, to ensure that we can resubmit the same request a couple of times, we include a small wa_tail such that on the next submission, the ring->tail will appear to move forwards when resubmitting the same request. This is very common as it will happen for every lite-restore to fill the second port after a context switch. However, intel_ring_direction() is limited in precision to movements of upto half the ring size. The consequence being that if we tried to unwind many requests, we could exceed half the ring and flip the sense of the direction, so missing a force restore. As no request can be greater than half the ring (i.e. 2048 bytes in the smallest case), we can check for rollback incrementally. As we check against the tail that would be submitted, we do not lose any sensitivity and allow lite restores for the simple case. We still need to double check upon submitting the context, to allow for multiple preemptions and resubmissions. Fixes:5ba32c7be8("drm/i915/execlists: Always force a context reload when rewinding RING_TAIL") Signed-off-by: Chris Wilson <chris@chris-wilson.co.uk> Cc: Mika Kuoppala <mika.kuoppala@linux.intel.com> Cc: <stable@vger.kernel.org> # v5.4+ Reviewed-by: Bruce Chang <yu.bruce.chang@intel.com> Reviewed-by: Mika Kuoppala <mika.kuoppala@linux.intel.com> Link: https://patchwork.freedesktop.org/patch/msgid/20200609151723.12971-1-chris@chris-wilson.co.uk (cherry picked from commite36ba817fa) Signed-off-by: Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
111 lines
2.3 KiB
C
111 lines
2.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* Copyright © 2020 Intel Corporation
|
|
*/
|
|
|
|
static struct intel_ring *mock_ring(unsigned long sz)
|
|
{
|
|
struct intel_ring *ring;
|
|
|
|
ring = kzalloc(sizeof(*ring) + sz, GFP_KERNEL);
|
|
if (!ring)
|
|
return NULL;
|
|
|
|
kref_init(&ring->ref);
|
|
ring->size = sz;
|
|
ring->wrap = BITS_PER_TYPE(ring->size) - ilog2(sz);
|
|
ring->effective_size = sz;
|
|
ring->vaddr = (void *)(ring + 1);
|
|
atomic_set(&ring->pin_count, 1);
|
|
|
|
intel_ring_update_space(ring);
|
|
|
|
return ring;
|
|
}
|
|
|
|
static void mock_ring_free(struct intel_ring *ring)
|
|
{
|
|
kfree(ring);
|
|
}
|
|
|
|
static int check_ring_direction(struct intel_ring *ring,
|
|
u32 next, u32 prev,
|
|
int expected)
|
|
{
|
|
int result;
|
|
|
|
result = intel_ring_direction(ring, next, prev);
|
|
if (result < 0)
|
|
result = -1;
|
|
else if (result > 0)
|
|
result = 1;
|
|
|
|
if (result != expected) {
|
|
pr_err("intel_ring_direction(%u, %u):%d != %d\n",
|
|
next, prev, result, expected);
|
|
return -EINVAL;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int check_ring_step(struct intel_ring *ring, u32 x, u32 step)
|
|
{
|
|
u32 prev = x, next = intel_ring_wrap(ring, x + step);
|
|
int err = 0;
|
|
|
|
err |= check_ring_direction(ring, next, next, 0);
|
|
err |= check_ring_direction(ring, prev, prev, 0);
|
|
err |= check_ring_direction(ring, next, prev, 1);
|
|
err |= check_ring_direction(ring, prev, next, -1);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int check_ring_offset(struct intel_ring *ring, u32 x, u32 step)
|
|
{
|
|
int err = 0;
|
|
|
|
err |= check_ring_step(ring, x, step);
|
|
err |= check_ring_step(ring, intel_ring_wrap(ring, x + 1), step);
|
|
err |= check_ring_step(ring, intel_ring_wrap(ring, x - 1), step);
|
|
|
|
return err;
|
|
}
|
|
|
|
static int igt_ring_direction(void *dummy)
|
|
{
|
|
struct intel_ring *ring;
|
|
unsigned int half = 2048;
|
|
int step, err = 0;
|
|
|
|
ring = mock_ring(2 * half);
|
|
if (!ring)
|
|
return -ENOMEM;
|
|
|
|
GEM_BUG_ON(ring->size != 2 * half);
|
|
|
|
/* Precision of wrap detection is limited to ring->size / 2 */
|
|
for (step = 1; step < half; step <<= 1) {
|
|
err |= check_ring_offset(ring, 0, step);
|
|
err |= check_ring_offset(ring, half, step);
|
|
}
|
|
err |= check_ring_step(ring, 0, half - 64);
|
|
|
|
/* And check unwrapped handling for good measure */
|
|
err |= check_ring_offset(ring, 0, 2 * half + 64);
|
|
err |= check_ring_offset(ring, 3 * half, 1);
|
|
|
|
mock_ring_free(ring);
|
|
return err;
|
|
}
|
|
|
|
int intel_ring_mock_selftests(void)
|
|
{
|
|
static const struct i915_subtest tests[] = {
|
|
SUBTEST(igt_ring_direction),
|
|
};
|
|
|
|
return i915_subtests(tests, NULL);
|
|
}
|