From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DE5BDC433E0 for ; Tue, 9 Jun 2020 12:29:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C082F207ED for ; Tue, 9 Jun 2020 12:29:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727795AbgFIM3D (ORCPT ); Tue, 9 Jun 2020 08:29:03 -0400 Received: from mail.fireflyinternet.com ([109.228.58.192]:61145 "EHLO fireflyinternet.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726903AbgFIM3D (ORCPT ); Tue, 9 Jun 2020 08:29:03 -0400 X-Default-Received-SPF: pass (skip=forwardok (res=PASS)) x-ip-name=78.156.65.138; Received: from build.alporthouse.com (unverified [78.156.65.138]) by fireflyinternet.com (Firefly Internet (M1)) with ESMTP id 21442285-1500050 for multiple; Tue, 09 Jun 2020 13:28:57 +0100 From: Chris Wilson To: intel-gfx@lists.freedesktop.org Cc: Chris Wilson , Mika Kuoppala , stable@vger.kernel.org Subject: [PATCH] drm/i915/gt: Incrementally check for rewinding Date: Tue, 9 Jun 2020 13:28:56 +0100 Message-Id: <20200609122856.10207-1-chris@chris-wilson.co.uk> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: stable@vger.kernel.org In commit 5ba32c7be81e ("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: 5ba32c7be81e ("drm/i915/execlists: Always force a context reload when rewinding RING_TAIL") Signed-off-by: Chris Wilson Cc: Mika Kuoppala Cc: # v5.4+ --- drivers/gpu/drm/i915/gt/intel_engine_cs.c | 4 +- drivers/gpu/drm/i915/gt/intel_lrc.c | 21 +++- drivers/gpu/drm/i915/gt/intel_ring.c | 4 + drivers/gpu/drm/i915/gt/selftest_mocs.c | 18 ++- drivers/gpu/drm/i915/gt/selftest_ring.c | 110 ++++++++++++++++++ .../drm/i915/selftests/i915_mock_selftests.h | 1 + 6 files changed, 154 insertions(+), 4 deletions(-) create mode 100644 drivers/gpu/drm/i915/gt/selftest_ring.c diff --git a/drivers/gpu/drm/i915/gt/intel_engine_cs.c b/drivers/gpu/drm/i915/gt/intel_engine_cs.c index e5141a897786..0a05301e00fb 100644 --- a/drivers/gpu/drm/i915/gt/intel_engine_cs.c +++ b/drivers/gpu/drm/i915/gt/intel_engine_cs.c @@ -646,7 +646,7 @@ static int engine_setup_common(struct intel_engine_cs *engine) struct measure_breadcrumb { struct i915_request rq; struct intel_ring ring; - u32 cs[1024]; + u32 cs[2048]; }; static int measure_breadcrumb_dw(struct intel_context *ce) @@ -667,6 +667,8 @@ static int measure_breadcrumb_dw(struct intel_context *ce) frame->ring.vaddr = frame->cs; frame->ring.size = sizeof(frame->cs); + frame->ring.wrap = + BITS_PER_TYPE(frame->ring.size) - ilog2(frame->ring.size); frame->ring.effective_size = frame->ring.size; intel_ring_update_space(&frame->ring); frame->rq.ring = &frame->ring; diff --git a/drivers/gpu/drm/i915/gt/intel_lrc.c b/drivers/gpu/drm/i915/gt/intel_lrc.c index a057f7a2a521..f66274e60bb6 100644 --- a/drivers/gpu/drm/i915/gt/intel_lrc.c +++ b/drivers/gpu/drm/i915/gt/intel_lrc.c @@ -1137,6 +1137,13 @@ __unwind_incomplete_requests(struct intel_engine_cs *engine) list_move(&rq->sched.link, pl); set_bit(I915_FENCE_FLAG_PQUEUE, &rq->fence.flags); + /* Check for rollback incrementally */ + if (intel_ring_direction(rq->ring, + intel_ring_wrap(rq->ring, + rq->tail), + rq->ring->tail) <= 0) + rq->context->lrc.desc |= CTX_DESC_FORCE_RESTORE; + active = rq; } else { struct intel_engine_cs *owner = rq->context->engine; @@ -1505,8 +1512,9 @@ static u64 execlists_update_context(struct i915_request *rq) * HW has a tendency to ignore us rewinding the TAIL to the end of * an earlier request. */ + GEM_BUG_ON(ce->lrc_reg_state[CTX_RING_TAIL] != rq->ring->tail); + prev = rq->ring->tail; tail = intel_ring_set_tail(rq->ring, rq->tail); - prev = ce->lrc_reg_state[CTX_RING_TAIL]; if (unlikely(intel_ring_direction(rq->ring, tail, prev) <= 0)) desc |= CTX_DESC_FORCE_RESTORE; ce->lrc_reg_state[CTX_RING_TAIL] = tail; @@ -4758,6 +4766,14 @@ static int gen12_emit_flush(struct i915_request *request, u32 mode) return 0; } +static void assert_request_valid(struct i915_request *rq) +{ + struct intel_ring *ring __maybe_unused = rq->ring; + + /* Can we unwind this request without appearing to go forwards? */ + GEM_BUG_ON(intel_ring_direction(ring, rq->wa_tail, rq->head) <= 0); +} + /* * Reserve space for 2 NOOPs at the end of each request to be * used as a workaround for not being allowed to do lite @@ -4770,6 +4786,9 @@ static u32 *gen8_emit_wa_tail(struct i915_request *request, u32 *cs) *cs++ = MI_NOOP; request->wa_tail = intel_ring_offset(request, cs); + /* Check that entire request is less than half the ring */ + assert_request_valid(request); + return cs; } diff --git a/drivers/gpu/drm/i915/gt/intel_ring.c b/drivers/gpu/drm/i915/gt/intel_ring.c index 8cda1b7e17ba..bdb324167ef3 100644 --- a/drivers/gpu/drm/i915/gt/intel_ring.c +++ b/drivers/gpu/drm/i915/gt/intel_ring.c @@ -315,3 +315,7 @@ int intel_ring_cacheline_align(struct i915_request *rq) GEM_BUG_ON(rq->ring->emit & (CACHELINE_BYTES - 1)); return 0; } + +#if IS_ENABLED(CONFIG_DRM_I915_SELFTEST) +#include "selftest_ring.c" +#endif diff --git a/drivers/gpu/drm/i915/gt/selftest_mocs.c b/drivers/gpu/drm/i915/gt/selftest_mocs.c index 7bae64018ad9..b25eba50c88e 100644 --- a/drivers/gpu/drm/i915/gt/selftest_mocs.c +++ b/drivers/gpu/drm/i915/gt/selftest_mocs.c @@ -18,6 +18,20 @@ struct live_mocs { void *vaddr; }; +static struct intel_context *mocs_context_create(struct intel_engine_cs *engine) +{ + struct intel_context *ce; + + ce = intel_context_create(engine); + if (IS_ERR(ce)) + return ce; + + /* We build large requests to read the registers from the ring */ + ce->ring = __intel_context_ring_size(SZ_16K); + + return ce; +} + static int request_add_sync(struct i915_request *rq, int err) { i915_request_get(rq); @@ -301,7 +315,7 @@ static int live_mocs_clean(void *arg) for_each_engine(engine, gt, id) { struct intel_context *ce; - ce = intel_context_create(engine); + ce = mocs_context_create(engine); if (IS_ERR(ce)) { err = PTR_ERR(ce); break; @@ -395,7 +409,7 @@ static int live_mocs_reset(void *arg) for_each_engine(engine, gt, id) { struct intel_context *ce; - ce = intel_context_create(engine); + ce = mocs_context_create(engine); if (IS_ERR(ce)) { err = PTR_ERR(ce); break; diff --git a/drivers/gpu/drm/i915/gt/selftest_ring.c b/drivers/gpu/drm/i915/gt/selftest_ring.c new file mode 100644 index 000000000000..2a8c534dc125 --- /dev/null +++ b/drivers/gpu/drm/i915/gt/selftest_ring.c @@ -0,0 +1,110 @@ +// 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); +} diff --git a/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h b/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h index 1929feba4e8e..3db34d3eea58 100644 --- a/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_mock_selftests.h @@ -21,6 +21,7 @@ selftest(fence, i915_sw_fence_mock_selftests) selftest(scatterlist, scatterlist_mock_selftests) selftest(syncmap, i915_syncmap_mock_selftests) selftest(uncore, intel_uncore_mock_selftests) +selftest(ring, intel_ring_mock_selftests) selftest(engine, intel_engine_cs_mock_selftests) selftest(timelines, intel_timeline_mock_selftests) selftest(requests, i915_request_mock_selftests) -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.7 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BA7DBC433E0 for ; Tue, 9 Jun 2020 12:29:50 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 461E2207ED for ; Tue, 9 Jun 2020 12:29:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 461E2207ED Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=chris-wilson.co.uk Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id DCEA56E28E; Tue, 9 Jun 2020 12:29:46 +0000 (UTC) Received: from fireflyinternet.com (mail.fireflyinternet.com [109.228.58.192]) by gabe.freedesktop.org (Postfix) with ESMTPS id 245CE6E28E for ; Tue, 9 Jun 2020 12:29:44 +0000 (UTC) X-Default-Received-SPF: pass (skip=forwardok (res=PASS)) x-ip-name=78.156.65.138; Received: from build.alporthouse.com (unverified [78.156.65.138]) by fireflyinternet.com (Firefly Internet (M1)) with ESMTP id 21442285-1500050 for multiple; Tue, 09 Jun 2020 13:28:57 +0100 From: Chris Wilson To: intel-gfx@lists.freedesktop.org Date: Tue, 9 Jun 2020 13:28:56 +0100 Message-Id: <20200609122856.10207-1-chris@chris-wilson.co.uk> X-Mailer: git-send-email 2.20.1 MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH] drm/i915/gt: Incrementally check for rewinding X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: stable@vger.kernel.org, Chris Wilson Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" SW4gY29tbWl0IDViYTMyYzdiZTgxZSAoImRybS9pOTE1L2V4ZWNsaXN0czogQWx3YXlzIGZvcmNl IGEgY29udGV4dApyZWxvYWQgd2hlbiByZXdpbmRpbmcgUklOR19UQUlMIiksIHdlIHBsYWNlZCB0 aGUgY2hlY2sgZm9yIHJld2luZGluZyBhCmNvbnRleHQgb24gYWN0dWFsbHkgc3VibWl0dGluZyB0 aGUgbmV4dCByZXF1ZXN0IGluIHRoYXQgY29udGV4dC4gVGhpcwp3YXMgc28gdGhhdCB3ZSBvbmx5 IGhhZCB0byBjaGVjayBvbmNlLCBhbmQgY291bGQgZG8gc28gd2l0aCBwcmVjaXNpb24KYXZvaWRp bmcgYXMgbWFueSBmb3JjZWQgcmVzdG9yZXMgYXMgcG9zc2libGUuIEZvciBleGFtcGxlLCB0byBl bnN1cmUKdGhhdCB3ZSBjYW4gcmVzdWJtaXQgdGhlIHNhbWUgcmVxdWVzdCBhIGNvdXBsZSBvZiB0 aW1lcywgd2UgaW5jbHVkZSBhCnNtYWxsIHdhX3RhaWwgc3VjaCB0aGF0IG9uIHRoZSBuZXh0IHN1 Ym1pc3Npb24sIHRoZSByaW5nLT50YWlsIHdpbGwKYXBwZWFyIHRvIG1vdmUgZm9yd2FyZHMgd2hl biByZXN1Ym1pdHRpbmcgdGhlIHNhbWUgcmVxdWVzdC4gVGhpcyBpcyB2ZXJ5CmNvbW1vbiBhcyBp dCB3aWxsIGhhcHBlbiBmb3IgZXZlcnkgbGl0ZS1yZXN0b3JlIHRvIGZpbGwgdGhlIHNlY29uZCBw b3J0CmFmdGVyIGEgY29udGV4dCBzd2l0Y2guCgpIb3dldmVyLCBpbnRlbF9yaW5nX2RpcmVjdGlv bigpIGlzIGxpbWl0ZWQgaW4gcHJlY2lzaW9uIHRvIG1vdmVtZW50cyBvZgp1cHRvIGhhbGYgdGhl IHJpbmcgc2l6ZS4gVGhlIGNvbnNlcXVlbmNlIGJlaW5nIHRoYXQgaWYgd2UgdHJpZWQgdG8KdW53 aW5kIG1hbnkgcmVxdWVzdHMsIHdlIGNvdWxkIGV4Y2VlZCBoYWxmIHRoZSByaW5nIGFuZCBmbGlw IHRoZSBzZW5zZQpvZiB0aGUgZGlyZWN0aW9uLCBzbyBtaXNzaW5nIGEgZm9yY2UgcmVzdG9yZS4g QXMgbm8gcmVxdWVzdCBjYW4gYmUKZ3JlYXRlciB0aGFuIGhhbGYgdGhlIHJpbmcgKGkuZS4gMjA0 OCBieXRlcyBpbiB0aGUgc21hbGxlc3QgY2FzZSksIHdlCmNhbiBjaGVjayBmb3Igcm9sbGJhY2sg aW5jcmVtZW50YWxseS4gQXMgd2UgY2hlY2sgYWdhaW5zdCB0aGUgdGFpbCB0aGF0CndvdWxkIGJl IHN1Ym1pdHRlZCwgd2UgZG8gbm90IGxvc2UgYW55IHNlbnNpdGl2aXR5IGFuZCBhbGxvdyBsaXRl CnJlc3RvcmVzIGZvciB0aGUgc2ltcGxlIGNhc2UuIFdlIHN0aWxsIG5lZWQgdG8gZG91YmxlIGNo ZWNrIHVwb24Kc3VibWl0dGluZyB0aGUgY29udGV4dCwgdG8gYWxsb3cgZm9yIG11bHRpcGxlIHBy ZWVtcHRpb25zIGFuZApyZXN1Ym1pc3Npb25zLgoKRml4ZXM6IDViYTMyYzdiZTgxZSAoImRybS9p OTE1L2V4ZWNsaXN0czogQWx3YXlzIGZvcmNlIGEgY29udGV4dCByZWxvYWQgd2hlbiByZXdpbmRp bmcgUklOR19UQUlMIikKU2lnbmVkLW9mZi1ieTogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13 aWxzb24uY28udWs+CkNjOiBNaWthIEt1b3BwYWxhIDxtaWthLmt1b3BwYWxhQGxpbnV4LmludGVs LmNvbT4KQ2M6IDxzdGFibGVAdmdlci5rZXJuZWwub3JnPiAjIHY1LjQrCi0tLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX2NzLmMgICAgIHwgICA0ICstCiBkcml2ZXJzL2dw dS9kcm0vaTkxNS9ndC9pbnRlbF9scmMuYyAgICAgICAgICAgfCAgMjEgKysrLQogZHJpdmVycy9n cHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZy5jICAgICAgICAgIHwgICA0ICsKIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21vY3MuYyAgICAgICB8ICAxOCArKy0KIGRyaXZlcnMvZ3B1 L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X3JpbmcuYyAgICAgICB8IDExMCArKysrKysrKysrKysrKysr KysKIC4uLi9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9tb2NrX3NlbGZ0ZXN0cy5oICB8ICAgMSAr CiA2IGZpbGVzIGNoYW5nZWQsIDE1NCBpbnNlcnRpb25zKCspLCA0IGRlbGV0aW9ucygtKQogY3Jl YXRlIG1vZGUgMTAwNjQ0IGRyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X3JpbmcuYwoK ZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2luZV9jcy5jIGIv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZW5naW5lX2NzLmMKaW5kZXggZTUxNDFhODk3 Nzg2Li4wYTA1MzAxZTAwZmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2lu dGVsX2VuZ2luZV9jcy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2VuZ2lu ZV9jcy5jCkBAIC02NDYsNyArNjQ2LDcgQEAgc3RhdGljIGludCBlbmdpbmVfc2V0dXBfY29tbW9u KHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKIHN0cnVjdCBtZWFzdXJlX2JyZWFkY3J1 bWIgewogCXN0cnVjdCBpOTE1X3JlcXVlc3QgcnE7CiAJc3RydWN0IGludGVsX3JpbmcgcmluZzsK LQl1MzIgY3NbMTAyNF07CisJdTMyIGNzWzIwNDhdOwogfTsKIAogc3RhdGljIGludCBtZWFzdXJl X2JyZWFkY3J1bWJfZHcoc3RydWN0IGludGVsX2NvbnRleHQgKmNlKQpAQCAtNjY3LDYgKzY2Nyw4 IEBAIHN0YXRpYyBpbnQgbWVhc3VyZV9icmVhZGNydW1iX2R3KHN0cnVjdCBpbnRlbF9jb250ZXh0 ICpjZSkKIAogCWZyYW1lLT5yaW5nLnZhZGRyID0gZnJhbWUtPmNzOwogCWZyYW1lLT5yaW5nLnNp emUgPSBzaXplb2YoZnJhbWUtPmNzKTsKKwlmcmFtZS0+cmluZy53cmFwID0KKwkJQklUU19QRVJf VFlQRShmcmFtZS0+cmluZy5zaXplKSAtIGlsb2cyKGZyYW1lLT5yaW5nLnNpemUpOwogCWZyYW1l LT5yaW5nLmVmZmVjdGl2ZV9zaXplID0gZnJhbWUtPnJpbmcuc2l6ZTsKIAlpbnRlbF9yaW5nX3Vw ZGF0ZV9zcGFjZSgmZnJhbWUtPnJpbmcpOwogCWZyYW1lLT5ycS5yaW5nID0gJmZyYW1lLT5yaW5n OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbHJjLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9scmMuYwppbmRleCBhMDU3ZjdhMmE1MjEuLmY2NjI3 NGU2MGJiNiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbHJjLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbHJjLmMKQEAgLTExMzcsNiArMTEz NywxMyBAQCBfX3Vud2luZF9pbmNvbXBsZXRlX3JlcXVlc3RzKHN0cnVjdCBpbnRlbF9lbmdpbmVf Y3MgKmVuZ2luZSkKIAkJCWxpc3RfbW92ZSgmcnEtPnNjaGVkLmxpbmssIHBsKTsKIAkJCXNldF9i aXQoSTkxNV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJxLT5mZW5jZS5mbGFncyk7CiAKKwkJCS8qIENo ZWNrIGZvciByb2xsYmFjayBpbmNyZW1lbnRhbGx5ICovCisJCQlpZiAoaW50ZWxfcmluZ19kaXJl Y3Rpb24ocnEtPnJpbmcsCisJCQkJCQkgaW50ZWxfcmluZ193cmFwKHJxLT5yaW5nLAorCQkJCQkJ CQkgcnEtPnRhaWwpLAorCQkJCQkJIHJxLT5yaW5nLT50YWlsKSA8PSAwKQorCQkJCXJxLT5jb250 ZXh0LT5scmMuZGVzYyB8PSBDVFhfREVTQ19GT1JDRV9SRVNUT1JFOworCiAJCQlhY3RpdmUgPSBy cTsKIAkJfSBlbHNlIHsKIAkJCXN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKm93bmVyID0gcnEtPmNv bnRleHQtPmVuZ2luZTsKQEAgLTE1MDUsOCArMTUxMiw5IEBAIHN0YXRpYyB1NjQgZXhlY2xpc3Rz X3VwZGF0ZV9jb250ZXh0KHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQogCSAqIEhXIGhhcyBhIHRl bmRlbmN5IHRvIGlnbm9yZSB1cyByZXdpbmRpbmcgdGhlIFRBSUwgdG8gdGhlIGVuZCBvZgogCSAq IGFuIGVhcmxpZXIgcmVxdWVzdC4KIAkgKi8KKwlHRU1fQlVHX09OKGNlLT5scmNfcmVnX3N0YXRl W0NUWF9SSU5HX1RBSUxdICE9IHJxLT5yaW5nLT50YWlsKTsKKwlwcmV2ID0gcnEtPnJpbmctPnRh aWw7CiAJdGFpbCA9IGludGVsX3Jpbmdfc2V0X3RhaWwocnEtPnJpbmcsIHJxLT50YWlsKTsKLQlw cmV2ID0gY2UtPmxyY19yZWdfc3RhdGVbQ1RYX1JJTkdfVEFJTF07CiAJaWYgKHVubGlrZWx5KGlu dGVsX3JpbmdfZGlyZWN0aW9uKHJxLT5yaW5nLCB0YWlsLCBwcmV2KSA8PSAwKSkKIAkJZGVzYyB8 PSBDVFhfREVTQ19GT1JDRV9SRVNUT1JFOwogCWNlLT5scmNfcmVnX3N0YXRlW0NUWF9SSU5HX1RB SUxdID0gdGFpbDsKQEAgLTQ3NTgsNiArNDc2NiwxNCBAQCBzdGF0aWMgaW50IGdlbjEyX2VtaXRf Zmx1c2goc3RydWN0IGk5MTVfcmVxdWVzdCAqcmVxdWVzdCwgdTMyIG1vZGUpCiAJcmV0dXJuIDA7 CiB9CiAKK3N0YXRpYyB2b2lkIGFzc2VydF9yZXF1ZXN0X3ZhbGlkKHN0cnVjdCBpOTE1X3JlcXVl c3QgKnJxKQoreworCXN0cnVjdCBpbnRlbF9yaW5nICpyaW5nIF9fbWF5YmVfdW51c2VkID0gcnEt PnJpbmc7CisKKwkvKiBDYW4gd2UgdW53aW5kIHRoaXMgcmVxdWVzdCB3aXRob3V0IGFwcGVhcmlu ZyB0byBnbyBmb3J3YXJkcz8gKi8KKwlHRU1fQlVHX09OKGludGVsX3JpbmdfZGlyZWN0aW9uKHJp bmcsIHJxLT53YV90YWlsLCBycS0+aGVhZCkgPD0gMCk7Cit9CisKIC8qCiAgKiBSZXNlcnZlIHNw YWNlIGZvciAyIE5PT1BzIGF0IHRoZSBlbmQgb2YgZWFjaCByZXF1ZXN0IHRvIGJlCiAgKiB1c2Vk IGFzIGEgd29ya2Fyb3VuZCBmb3Igbm90IGJlaW5nIGFsbG93ZWQgdG8gZG8gbGl0ZQpAQCAtNDc3 MCw2ICs0Nzg2LDkgQEAgc3RhdGljIHUzMiAqZ2VuOF9lbWl0X3dhX3RhaWwoc3RydWN0IGk5MTVf cmVxdWVzdCAqcmVxdWVzdCwgdTMyICpjcykKIAkqY3MrKyA9IE1JX05PT1A7CiAJcmVxdWVzdC0+ d2FfdGFpbCA9IGludGVsX3Jpbmdfb2Zmc2V0KHJlcXVlc3QsIGNzKTsKIAorCS8qIENoZWNrIHRo YXQgZW50aXJlIHJlcXVlc3QgaXMgbGVzcyB0aGFuIGhhbGYgdGhlIHJpbmcgKi8KKwlhc3NlcnRf cmVxdWVzdF92YWxpZChyZXF1ZXN0KTsKKwogCXJldHVybiBjczsKIH0KIApkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZy5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvZ3QvaW50ZWxfcmluZy5jCmluZGV4IDhjZGExYjdlMTdiYS4uYmRiMzI0MTY3ZWYzIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nLmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfcmluZy5jCkBAIC0zMTUsMyArMzE1LDcgQEAgaW50IGlu dGVsX3JpbmdfY2FjaGVsaW5lX2FsaWduKHN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxKQogCUdFTV9C VUdfT04ocnEtPnJpbmctPmVtaXQgJiAoQ0FDSEVMSU5FX0JZVEVTIC0gMSkpOwogCXJldHVybiAw OwogfQorCisjaWYgSVNfRU5BQkxFRChDT05GSUdfRFJNX0k5MTVfU0VMRlRFU1QpCisjaW5jbHVk ZSAic2VsZnRlc3RfcmluZy5jIgorI2VuZGlmCmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9zZWxmdGVzdF9tb2NzLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9zZWxmdGVz dF9tb2NzLmMKaW5kZXggN2JhZTY0MDE4YWQ5Li5iMjVlYmE1MGM4OGUgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21vY3MuYworKysgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9ndC9zZWxmdGVzdF9tb2NzLmMKQEAgLTE4LDYgKzE4LDIwIEBAIHN0cnVjdCBsaXZl X21vY3MgewogCXZvaWQgKnZhZGRyOwogfTsKIAorc3RhdGljIHN0cnVjdCBpbnRlbF9jb250ZXh0 ICptb2NzX2NvbnRleHRfY3JlYXRlKHN0cnVjdCBpbnRlbF9lbmdpbmVfY3MgKmVuZ2luZSkKK3sK KwlzdHJ1Y3QgaW50ZWxfY29udGV4dCAqY2U7CisKKwljZSA9IGludGVsX2NvbnRleHRfY3JlYXRl KGVuZ2luZSk7CisJaWYgKElTX0VSUihjZSkpCisJCXJldHVybiBjZTsKKworCS8qIFdlIGJ1aWxk IGxhcmdlIHJlcXVlc3RzIHRvIHJlYWQgdGhlIHJlZ2lzdGVycyBmcm9tIHRoZSByaW5nICovCisJ Y2UtPnJpbmcgPSBfX2ludGVsX2NvbnRleHRfcmluZ19zaXplKFNaXzE2Syk7CisKKwlyZXR1cm4g Y2U7Cit9CisKIHN0YXRpYyBpbnQgcmVxdWVzdF9hZGRfc3luYyhzdHJ1Y3QgaTkxNV9yZXF1ZXN0 ICpycSwgaW50IGVycikKIHsKIAlpOTE1X3JlcXVlc3RfZ2V0KHJxKTsKQEAgLTMwMSw3ICszMTUs NyBAQCBzdGF0aWMgaW50IGxpdmVfbW9jc19jbGVhbih2b2lkICphcmcpCiAJZm9yX2VhY2hfZW5n aW5lKGVuZ2luZSwgZ3QsIGlkKSB7CiAJCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKIAotCQlj ZSA9IGludGVsX2NvbnRleHRfY3JlYXRlKGVuZ2luZSk7CisJCWNlID0gbW9jc19jb250ZXh0X2Ny ZWF0ZShlbmdpbmUpOwogCQlpZiAoSVNfRVJSKGNlKSkgewogCQkJZXJyID0gUFRSX0VSUihjZSk7 CiAJCQlicmVhazsKQEAgLTM5NSw3ICs0MDksNyBAQCBzdGF0aWMgaW50IGxpdmVfbW9jc19yZXNl dCh2b2lkICphcmcpCiAJZm9yX2VhY2hfZW5naW5lKGVuZ2luZSwgZ3QsIGlkKSB7CiAJCXN0cnVj dCBpbnRlbF9jb250ZXh0ICpjZTsKIAotCQljZSA9IGludGVsX2NvbnRleHRfY3JlYXRlKGVuZ2lu ZSk7CisJCWNlID0gbW9jc19jb250ZXh0X2NyZWF0ZShlbmdpbmUpOwogCQlpZiAoSVNfRVJSKGNl KSkgewogCQkJZXJyID0gUFRSX0VSUihjZSk7CiAJCQlicmVhazsKZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X3JpbmcuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3NlbGZ0ZXN0X3JpbmcuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAuLjJhOGM1MzRkYzEyNQotLS0gL2Rldi9udWxsCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2d0L3NlbGZ0ZXN0X3JpbmcuYwpAQCAtMCwwICsxLDExMCBAQAorLy8gU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBDb3B5cmlnaHQgwqkgMjAyMCBJbnRlbCBDb3Jwb3Jh dGlvbgorICovCisKK3N0YXRpYyBzdHJ1Y3QgaW50ZWxfcmluZyAqbW9ja19yaW5nKHVuc2lnbmVk IGxvbmcgc3opCit7CisJc3RydWN0IGludGVsX3JpbmcgKnJpbmc7CisKKwlyaW5nID0ga3phbGxv YyhzaXplb2YoKnJpbmcpICsgc3osIEdGUF9LRVJORUwpOworCWlmICghcmluZykKKwkJcmV0dXJu IE5VTEw7CisKKwlrcmVmX2luaXQoJnJpbmctPnJlZik7CisJcmluZy0+c2l6ZSA9IHN6OworCXJp bmctPndyYXAgPSBCSVRTX1BFUl9UWVBFKHJpbmctPnNpemUpIC0gaWxvZzIoc3opOworCXJpbmct PmVmZmVjdGl2ZV9zaXplID0gc3o7CisJcmluZy0+dmFkZHIgPSAodm9pZCAqKShyaW5nICsgMSk7 CisJYXRvbWljX3NldCgmcmluZy0+cGluX2NvdW50LCAxKTsKKworCWludGVsX3JpbmdfdXBkYXRl X3NwYWNlKHJpbmcpOworCisJcmV0dXJuIHJpbmc7Cit9CisKK3N0YXRpYyB2b2lkIG1vY2tfcmlu Z19mcmVlKHN0cnVjdCBpbnRlbF9yaW5nICpyaW5nKQoreworCWtmcmVlKHJpbmcpOworfQorCitz dGF0aWMgaW50IGNoZWNrX3JpbmdfZGlyZWN0aW9uKHN0cnVjdCBpbnRlbF9yaW5nICpyaW5nLAor CQkJCXUzMiBuZXh0LCB1MzIgcHJldiwKKwkJCQlpbnQgZXhwZWN0ZWQpCit7CisJaW50IHJlc3Vs dDsKKworCXJlc3VsdCA9IGludGVsX3JpbmdfZGlyZWN0aW9uKHJpbmcsIG5leHQsIHByZXYpOwor CWlmIChyZXN1bHQgPCAwKQorCQlyZXN1bHQgPSAtMTsKKwllbHNlIGlmIChyZXN1bHQgPiAwKQor CQlyZXN1bHQgPSAxOworCisJaWYgKHJlc3VsdCAhPSBleHBlY3RlZCkgeworCQlwcl9lcnIoImlu dGVsX3JpbmdfZGlyZWN0aW9uKCV1LCAldSk6JWQgIT0gJWRcbiIsCisJCSAgICAgICBuZXh0LCBw cmV2LCByZXN1bHQsIGV4cGVjdGVkKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgY2hlY2tfcmluZ19zdGVwKHN0cnVjdCBpbnRlbF9yaW5nICpy aW5nLCB1MzIgeCwgdTMyIHN0ZXApCit7CisJdTMyIHByZXYgPSB4LCBuZXh0ID0gaW50ZWxfcmlu Z193cmFwKHJpbmcsIHggKyBzdGVwKTsKKwlpbnQgZXJyID0gMDsKKworCWVyciB8PSBjaGVja19y aW5nX2RpcmVjdGlvbihyaW5nLCBuZXh0LCBuZXh0LCAgMCk7CisJZXJyIHw9IGNoZWNrX3Jpbmdf ZGlyZWN0aW9uKHJpbmcsIHByZXYsIHByZXYsICAwKTsKKwllcnIgfD0gY2hlY2tfcmluZ19kaXJl Y3Rpb24ocmluZywgbmV4dCwgcHJldiwgIDEpOworCWVyciB8PSBjaGVja19yaW5nX2RpcmVjdGlv bihyaW5nLCBwcmV2LCBuZXh0LCAtMSk7CisKKwlyZXR1cm4gZXJyOworfQorCitzdGF0aWMgaW50 IGNoZWNrX3Jpbmdfb2Zmc2V0KHN0cnVjdCBpbnRlbF9yaW5nICpyaW5nLCB1MzIgeCwgdTMyIHN0 ZXApCit7CisJaW50IGVyciA9IDA7CisKKwllcnIgfD0gY2hlY2tfcmluZ19zdGVwKHJpbmcsIHgs IHN0ZXApOworCWVyciB8PSBjaGVja19yaW5nX3N0ZXAocmluZywgaW50ZWxfcmluZ193cmFwKHJp bmcsIHggKyAxKSwgc3RlcCk7CisJZXJyIHw9IGNoZWNrX3Jpbmdfc3RlcChyaW5nLCBpbnRlbF9y aW5nX3dyYXAocmluZywgeCAtIDEpLCBzdGVwKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRp YyBpbnQgaWd0X3JpbmdfZGlyZWN0aW9uKHZvaWQgKmR1bW15KQoreworCXN0cnVjdCBpbnRlbF9y aW5nICpyaW5nOworCXVuc2lnbmVkIGludCBoYWxmID0gMjA0ODsKKwlpbnQgc3RlcCwgZXJyID0g MDsKKworCXJpbmcgPSBtb2NrX3JpbmcoMiAqIGhhbGYpOworCWlmICghcmluZykKKwkJcmV0dXJu IC1FTk9NRU07CisKKwlHRU1fQlVHX09OKHJpbmctPnNpemUgIT0gMiAqIGhhbGYpOworCisJLyog UHJlY2lzaW9uIG9mIHdyYXAgZGV0ZWN0aW9uIGlzIGxpbWl0ZWQgdG8gcmluZy0+c2l6ZSAvIDIg Ki8KKwlmb3IgKHN0ZXAgPSAxOyBzdGVwIDwgaGFsZjsgc3RlcCA8PD0gMSkgeworCQllcnIgfD0g Y2hlY2tfcmluZ19vZmZzZXQocmluZywgMCwgc3RlcCk7CisJCWVyciB8PSBjaGVja19yaW5nX29m ZnNldChyaW5nLCBoYWxmLCBzdGVwKTsKKwl9CisJZXJyIHw9IGNoZWNrX3Jpbmdfc3RlcChyaW5n LCAwLCBoYWxmIC0gNjQpOworCisJLyogQW5kIGNoZWNrIHVud3JhcHBlZCBoYW5kbGluZyBmb3Ig Z29vZCBtZWFzdXJlICovCisJZXJyIHw9IGNoZWNrX3Jpbmdfb2Zmc2V0KHJpbmcsIDAsIDIgKiBo YWxmICsgNjQpOworCWVyciB8PSBjaGVja19yaW5nX29mZnNldChyaW5nLCAzICogaGFsZiwgMSk7 CisKKwltb2NrX3JpbmdfZnJlZShyaW5nKTsKKwlyZXR1cm4gZXJyOworfQorCitpbnQgaW50ZWxf cmluZ19tb2NrX3NlbGZ0ZXN0cyh2b2lkKQoreworCXN0YXRpYyBjb25zdCBzdHJ1Y3QgaTkxNV9z dWJ0ZXN0IHRlc3RzW10gPSB7CisJCVNVQlRFU1QoaWd0X3JpbmdfZGlyZWN0aW9uKSwKKwl9Owor CisJcmV0dXJuIGk5MTVfc3VidGVzdHModGVzdHMsIE5VTEwpOworfQpkaWZmIC0tZ2l0IGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaCBiL2RyaXZl cnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X21vY2tfc2VsZnRlc3RzLmgKaW5kZXggMTky OWZlYmE0ZThlLi4zZGIzNGQzZWVhNTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L3NlbGZ0ZXN0cy9pOTE1X21vY2tfc2VsZnRlc3RzLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvc2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaApAQCAtMjEsNiArMjEsNyBAQCBzZWxm dGVzdChmZW5jZSwgaTkxNV9zd19mZW5jZV9tb2NrX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHNjYXR0 ZXJsaXN0LCBzY2F0dGVybGlzdF9tb2NrX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHN5bmNtYXAsIGk5 MTVfc3luY21hcF9tb2NrX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0KHVuY29yZSwgaW50ZWxfdW5jb3Jl X21vY2tfc2VsZnRlc3RzKQorc2VsZnRlc3QocmluZywgaW50ZWxfcmluZ19tb2NrX3NlbGZ0ZXN0 cykKIHNlbGZ0ZXN0KGVuZ2luZSwgaW50ZWxfZW5naW5lX2NzX21vY2tfc2VsZnRlc3RzKQogc2Vs ZnRlc3QodGltZWxpbmVzLCBpbnRlbF90aW1lbGluZV9tb2NrX3NlbGZ0ZXN0cykKIHNlbGZ0ZXN0 KHJlcXVlc3RzLCBpOTE1X3JlcXVlc3RfbW9ja19zZWxmdGVzdHMpCi0tIAoyLjIwLjEKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWls aW5nIGxpc3QKSW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=