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 6B374C433E0 for ; Tue, 9 Jun 2020 15:17:29 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 3926D2074B for ; Tue, 9 Jun 2020 15:17:29 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1730640AbgFIPR2 (ORCPT ); Tue, 9 Jun 2020 11:17:28 -0400 Received: from mail.fireflyinternet.com ([109.228.58.192]:49869 "EHLO fireflyinternet.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1726395AbgFIPR2 (ORCPT ); Tue, 9 Jun 2020 11:17:28 -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 21444185-1500050 for multiple; Tue, 09 Jun 2020 16:17:23 +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 16:17:23 +0100 Message-Id: <20200609151723.12971-1-chris@chris-wilson.co.uk> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20200609122856.10207-1-chris@chris-wilson.co.uk> References: <20200609122856.10207-1-chris@chris-wilson.co.uk> 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..5f33342c15e2 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 in case rollback so far, we wrap [size/2] */ + 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 D1337C433DF for ; Tue, 9 Jun 2020 15:17:49 +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 AA9CA2074B for ; Tue, 9 Jun 2020 15:17:49 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AA9CA2074B 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 528CE6E2BD; Tue, 9 Jun 2020 15:17:49 +0000 (UTC) Received: from fireflyinternet.com (mail.fireflyinternet.com [109.228.58.192]) by gabe.freedesktop.org (Postfix) with ESMTPS id C8C7E6E2BD for ; Tue, 9 Jun 2020 15:17:47 +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 21444185-1500050 for multiple; Tue, 09 Jun 2020 16:17:23 +0100 From: Chris Wilson To: intel-gfx@lists.freedesktop.org Date: Tue, 9 Jun 2020 16:17:23 +0100 Message-Id: <20200609151723.12971-1-chris@chris-wilson.co.uk> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20200609122856.10207-1-chris@chris-wilson.co.uk> References: <20200609122856.10207-1-chris@chris-wilson.co.uk> 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 ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9scmMuYwppbmRleCBhMDU3ZjdhMmE1MjEuLjVmMzMz NDJjMTVlMiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbHJjLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbHJjLmMKQEAgLTExMzcsNiArMTEz NywxMyBAQCBfX3Vud2luZF9pbmNvbXBsZXRlX3JlcXVlc3RzKHN0cnVjdCBpbnRlbF9lbmdpbmVf Y3MgKmVuZ2luZSkKIAkJCWxpc3RfbW92ZSgmcnEtPnNjaGVkLmxpbmssIHBsKTsKIAkJCXNldF9i aXQoSTkxNV9GRU5DRV9GTEFHX1BRVUVVRSwgJnJxLT5mZW5jZS5mbGFncyk7CiAKKwkJCS8qIENo ZWNrIGluIGNhc2Ugcm9sbGJhY2sgc28gZmFyLCB3ZSB3cmFwIFtzaXplLzJdICovCisJCQlpZiAo aW50ZWxfcmluZ19kaXJlY3Rpb24ocnEtPnJpbmcsCisJCQkJCQkgaW50ZWxfcmluZ193cmFwKHJx LT5yaW5nLAorCQkJCQkJCQkgcnEtPnRhaWwpLAorCQkJCQkJIHJxLT5yaW5nLT50YWlsKSA+IDAp CisJCQkJcnEtPmNvbnRleHQtPmxyYy5kZXNjIHw9IENUWF9ERVNDX0ZPUkNFX1JFU1RPUkU7CisK IAkJCWFjdGl2ZSA9IHJxOwogCQl9IGVsc2UgewogCQkJc3RydWN0IGludGVsX2VuZ2luZV9jcyAq b3duZXIgPSBycS0+Y29udGV4dC0+ZW5naW5lOwpAQCAtMTUwNSw4ICsxNTEyLDkgQEAgc3RhdGlj IHU2NCBleGVjbGlzdHNfdXBkYXRlX2NvbnRleHQoc3RydWN0IGk5MTVfcmVxdWVzdCAqcnEpCiAJ ICogSFcgaGFzIGEgdGVuZGVuY3kgdG8gaWdub3JlIHVzIHJld2luZGluZyB0aGUgVEFJTCB0byB0 aGUgZW5kIG9mCiAJICogYW4gZWFybGllciByZXF1ZXN0LgogCSAqLworCUdFTV9CVUdfT04oY2Ut PmxyY19yZWdfc3RhdGVbQ1RYX1JJTkdfVEFJTF0gIT0gcnEtPnJpbmctPnRhaWwpOworCXByZXYg PSBycS0+cmluZy0+dGFpbDsKIAl0YWlsID0gaW50ZWxfcmluZ19zZXRfdGFpbChycS0+cmluZywg cnEtPnRhaWwpOwotCXByZXYgPSBjZS0+bHJjX3JlZ19zdGF0ZVtDVFhfUklOR19UQUlMXTsKIAlp ZiAodW5saWtlbHkoaW50ZWxfcmluZ19kaXJlY3Rpb24ocnEtPnJpbmcsIHRhaWwsIHByZXYpIDw9 IDApKQogCQlkZXNjIHw9IENUWF9ERVNDX0ZPUkNFX1JFU1RPUkU7CiAJY2UtPmxyY19yZWdfc3Rh dGVbQ1RYX1JJTkdfVEFJTF0gPSB0YWlsOwpAQCAtNDc1OCw2ICs0NzY2LDE0IEBAIHN0YXRpYyBp bnQgZ2VuMTJfZW1pdF9mbHVzaChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0LCB1MzIgbW9k ZSkKIAlyZXR1cm4gMDsKIH0KIAorc3RhdGljIHZvaWQgYXNzZXJ0X3JlcXVlc3RfdmFsaWQoc3Ry dWN0IGk5MTVfcmVxdWVzdCAqcnEpCit7CisJc3RydWN0IGludGVsX3JpbmcgKnJpbmcgX19tYXli ZV91bnVzZWQgPSBycS0+cmluZzsKKworCS8qIENhbiB3ZSB1bndpbmQgdGhpcyByZXF1ZXN0IHdp dGhvdXQgYXBwZWFyaW5nIHRvIGdvIGZvcndhcmRzPyAqLworCUdFTV9CVUdfT04oaW50ZWxfcmlu Z19kaXJlY3Rpb24ocmluZywgcnEtPndhX3RhaWwsIHJxLT5oZWFkKSA8PSAwKTsKK30KKwogLyoK ICAqIFJlc2VydmUgc3BhY2UgZm9yIDIgTk9PUHMgYXQgdGhlIGVuZCBvZiBlYWNoIHJlcXVlc3Qg dG8gYmUKICAqIHVzZWQgYXMgYSB3b3JrYXJvdW5kIGZvciBub3QgYmVpbmcgYWxsb3dlZCB0byBk byBsaXRlCkBAIC00NzcwLDYgKzQ3ODYsOSBAQCBzdGF0aWMgdTMyICpnZW44X2VtaXRfd2FfdGFp bChzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpyZXF1ZXN0LCB1MzIgKmNzKQogCSpjcysrID0gTUlfTk9P UDsKIAlyZXF1ZXN0LT53YV90YWlsID0gaW50ZWxfcmluZ19vZmZzZXQocmVxdWVzdCwgY3MpOwog CisJLyogQ2hlY2sgdGhhdCBlbnRpcmUgcmVxdWVzdCBpcyBsZXNzIHRoYW4gaGFsZiB0aGUgcmlu ZyAqLworCWFzc2VydF9yZXF1ZXN0X3ZhbGlkKHJlcXVlc3QpOworCiAJcmV0dXJuIGNzOwogfQog CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nLmMgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nLmMKaW5kZXggOGNkYTFiN2UxN2JhLi5iZGIz MjQxNjdlZjMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX3Jpbmcu YworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9yaW5nLmMKQEAgLTMxNSwzICsz MTUsNyBAQCBpbnQgaW50ZWxfcmluZ19jYWNoZWxpbmVfYWxpZ24oc3RydWN0IGk5MTVfcmVxdWVz dCAqcnEpCiAJR0VNX0JVR19PTihycS0+cmluZy0+ZW1pdCAmIChDQUNIRUxJTkVfQllURVMgLSAx KSk7CiAJcmV0dXJuIDA7CiB9CisKKyNpZiBJU19FTkFCTEVEKENPTkZJR19EUk1fSTkxNV9TRUxG VEVTVCkKKyNpbmNsdWRlICJzZWxmdGVzdF9yaW5nLmMiCisjZW5kaWYKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21vY3MuYyBiL2RyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L3NlbGZ0ZXN0X21vY3MuYwppbmRleCA3YmFlNjQwMThhZDkuLmIyNWViYTUwYzg4ZSAx MDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfbW9jcy5jCisrKyBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21vY3MuYwpAQCAtMTgsNiArMTgsMjAg QEAgc3RydWN0IGxpdmVfbW9jcyB7CiAJdm9pZCAqdmFkZHI7CiB9OwogCitzdGF0aWMgc3RydWN0 IGludGVsX2NvbnRleHQgKm1vY3NfY29udGV4dF9jcmVhdGUoc3RydWN0IGludGVsX2VuZ2luZV9j cyAqZW5naW5lKQoreworCXN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZTsKKworCWNlID0gaW50ZWxf Y29udGV4dF9jcmVhdGUoZW5naW5lKTsKKwlpZiAoSVNfRVJSKGNlKSkKKwkJcmV0dXJuIGNlOwor CisJLyogV2UgYnVpbGQgbGFyZ2UgcmVxdWVzdHMgdG8gcmVhZCB0aGUgcmVnaXN0ZXJzIGZyb20g dGhlIHJpbmcgKi8KKwljZS0+cmluZyA9IF9faW50ZWxfY29udGV4dF9yaW5nX3NpemUoU1pfMTZL KTsKKworCXJldHVybiBjZTsKK30KKwogc3RhdGljIGludCByZXF1ZXN0X2FkZF9zeW5jKHN0cnVj dCBpOTE1X3JlcXVlc3QgKnJxLCBpbnQgZXJyKQogewogCWk5MTVfcmVxdWVzdF9nZXQocnEpOwpA QCAtMzAxLDcgKzMxNSw3IEBAIHN0YXRpYyBpbnQgbGl2ZV9tb2NzX2NsZWFuKHZvaWQgKmFyZykK IAlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwgaWQpIHsKIAkJc3RydWN0IGludGVsX2NvbnRl eHQgKmNlOwogCi0JCWNlID0gaW50ZWxfY29udGV4dF9jcmVhdGUoZW5naW5lKTsKKwkJY2UgPSBt b2NzX2NvbnRleHRfY3JlYXRlKGVuZ2luZSk7CiAJCWlmIChJU19FUlIoY2UpKSB7CiAJCQllcnIg PSBQVFJfRVJSKGNlKTsKIAkJCWJyZWFrOwpAQCAtMzk1LDcgKzQwOSw3IEBAIHN0YXRpYyBpbnQg bGl2ZV9tb2NzX3Jlc2V0KHZvaWQgKmFyZykKIAlmb3JfZWFjaF9lbmdpbmUoZW5naW5lLCBndCwg aWQpIHsKIAkJc3RydWN0IGludGVsX2NvbnRleHQgKmNlOwogCi0JCWNlID0gaW50ZWxfY29udGV4 dF9jcmVhdGUoZW5naW5lKTsKKwkJY2UgPSBtb2NzX2NvbnRleHRfY3JlYXRlKGVuZ2luZSk7CiAJ CWlmIChJU19FUlIoY2UpKSB7CiAJCQllcnIgPSBQVFJfRVJSKGNlKTsKIAkJCWJyZWFrOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfcmluZy5jIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfcmluZy5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uMmE4YzUzNGRjMTI1Ci0tLSAvZGV2L251bGwKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3RfcmluZy5jCkBAIC0wLDAgKzEsMTEwIEBACisvLyBT UERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIENvcHlyaWdodCDCqSAyMDIw IEludGVsIENvcnBvcmF0aW9uCisgKi8KKworc3RhdGljIHN0cnVjdCBpbnRlbF9yaW5nICptb2Nr X3JpbmcodW5zaWduZWQgbG9uZyBzeikKK3sKKwlzdHJ1Y3QgaW50ZWxfcmluZyAqcmluZzsKKwor CXJpbmcgPSBremFsbG9jKHNpemVvZigqcmluZykgKyBzeiwgR0ZQX0tFUk5FTCk7CisJaWYgKCFy aW5nKQorCQlyZXR1cm4gTlVMTDsKKworCWtyZWZfaW5pdCgmcmluZy0+cmVmKTsKKwlyaW5nLT5z aXplID0gc3o7CisJcmluZy0+d3JhcCA9IEJJVFNfUEVSX1RZUEUocmluZy0+c2l6ZSkgLSBpbG9n Mihzeik7CisJcmluZy0+ZWZmZWN0aXZlX3NpemUgPSBzejsKKwlyaW5nLT52YWRkciA9ICh2b2lk ICopKHJpbmcgKyAxKTsKKwlhdG9taWNfc2V0KCZyaW5nLT5waW5fY291bnQsIDEpOworCisJaW50 ZWxfcmluZ191cGRhdGVfc3BhY2UocmluZyk7CisKKwlyZXR1cm4gcmluZzsKK30KKworc3RhdGlj IHZvaWQgbW9ja19yaW5nX2ZyZWUoc3RydWN0IGludGVsX3JpbmcgKnJpbmcpCit7CisJa2ZyZWUo cmluZyk7Cit9CisKK3N0YXRpYyBpbnQgY2hlY2tfcmluZ19kaXJlY3Rpb24oc3RydWN0IGludGVs X3JpbmcgKnJpbmcsCisJCQkJdTMyIG5leHQsIHUzMiBwcmV2LAorCQkJCWludCBleHBlY3RlZCkK K3sKKwlpbnQgcmVzdWx0OworCisJcmVzdWx0ID0gaW50ZWxfcmluZ19kaXJlY3Rpb24ocmluZywg bmV4dCwgcHJldik7CisJaWYgKHJlc3VsdCA8IDApCisJCXJlc3VsdCA9IC0xOworCWVsc2UgaWYg KHJlc3VsdCA+IDApCisJCXJlc3VsdCA9IDE7CisKKwlpZiAocmVzdWx0ICE9IGV4cGVjdGVkKSB7 CisJCXByX2VycigiaW50ZWxfcmluZ19kaXJlY3Rpb24oJXUsICV1KTolZCAhPSAlZFxuIiwKKwkJ ICAgICAgIG5leHQsIHByZXYsIHJlc3VsdCwgZXhwZWN0ZWQpOworCQlyZXR1cm4gLUVJTlZBTDsK Kwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBjaGVja19yaW5nX3N0ZXAoc3RydWN0 IGludGVsX3JpbmcgKnJpbmcsIHUzMiB4LCB1MzIgc3RlcCkKK3sKKwl1MzIgcHJldiA9IHgsIG5l eHQgPSBpbnRlbF9yaW5nX3dyYXAocmluZywgeCArIHN0ZXApOworCWludCBlcnIgPSAwOworCisJ ZXJyIHw9IGNoZWNrX3JpbmdfZGlyZWN0aW9uKHJpbmcsIG5leHQsIG5leHQsICAwKTsKKwllcnIg fD0gY2hlY2tfcmluZ19kaXJlY3Rpb24ocmluZywgcHJldiwgcHJldiwgIDApOworCWVyciB8PSBj aGVja19yaW5nX2RpcmVjdGlvbihyaW5nLCBuZXh0LCBwcmV2LCAgMSk7CisJZXJyIHw9IGNoZWNr X3JpbmdfZGlyZWN0aW9uKHJpbmcsIHByZXYsIG5leHQsIC0xKTsKKworCXJldHVybiBlcnI7Cit9 CisKK3N0YXRpYyBpbnQgY2hlY2tfcmluZ19vZmZzZXQoc3RydWN0IGludGVsX3JpbmcgKnJpbmcs IHUzMiB4LCB1MzIgc3RlcCkKK3sKKwlpbnQgZXJyID0gMDsKKworCWVyciB8PSBjaGVja19yaW5n X3N0ZXAocmluZywgeCwgc3RlcCk7CisJZXJyIHw9IGNoZWNrX3Jpbmdfc3RlcChyaW5nLCBpbnRl bF9yaW5nX3dyYXAocmluZywgeCArIDEpLCBzdGVwKTsKKwllcnIgfD0gY2hlY2tfcmluZ19zdGVw KHJpbmcsIGludGVsX3Jpbmdfd3JhcChyaW5nLCB4IC0gMSksIHN0ZXApOworCisJcmV0dXJuIGVy cjsKK30KKworc3RhdGljIGludCBpZ3RfcmluZ19kaXJlY3Rpb24odm9pZCAqZHVtbXkpCit7CisJ c3RydWN0IGludGVsX3JpbmcgKnJpbmc7CisJdW5zaWduZWQgaW50IGhhbGYgPSAyMDQ4OworCWlu dCBzdGVwLCBlcnIgPSAwOworCisJcmluZyA9IG1vY2tfcmluZygyICogaGFsZik7CisJaWYgKCFy aW5nKQorCQlyZXR1cm4gLUVOT01FTTsKKworCUdFTV9CVUdfT04ocmluZy0+c2l6ZSAhPSAyICog aGFsZik7CisKKwkvKiBQcmVjaXNpb24gb2Ygd3JhcCBkZXRlY3Rpb24gaXMgbGltaXRlZCB0byBy aW5nLT5zaXplIC8gMiAqLworCWZvciAoc3RlcCA9IDE7IHN0ZXAgPCBoYWxmOyBzdGVwIDw8PSAx KSB7CisJCWVyciB8PSBjaGVja19yaW5nX29mZnNldChyaW5nLCAwLCBzdGVwKTsKKwkJZXJyIHw9 IGNoZWNrX3Jpbmdfb2Zmc2V0KHJpbmcsIGhhbGYsIHN0ZXApOworCX0KKwllcnIgfD0gY2hlY2tf cmluZ19zdGVwKHJpbmcsIDAsIGhhbGYgLSA2NCk7CisKKwkvKiBBbmQgY2hlY2sgdW53cmFwcGVk IGhhbmRsaW5nIGZvciBnb29kIG1lYXN1cmUgKi8KKwllcnIgfD0gY2hlY2tfcmluZ19vZmZzZXQo cmluZywgMCwgMiAqIGhhbGYgKyA2NCk7CisJZXJyIHw9IGNoZWNrX3Jpbmdfb2Zmc2V0KHJpbmcs IDMgKiBoYWxmLCAxKTsKKworCW1vY2tfcmluZ19mcmVlKHJpbmcpOworCXJldHVybiBlcnI7Cit9 CisKK2ludCBpbnRlbF9yaW5nX21vY2tfc2VsZnRlc3RzKHZvaWQpCit7CisJc3RhdGljIGNvbnN0 IHN0cnVjdCBpOTE1X3N1YnRlc3QgdGVzdHNbXSA9IHsKKwkJU1VCVEVTVChpZ3RfcmluZ19kaXJl Y3Rpb24pLAorCX07CisKKwlyZXR1cm4gaTkxNV9zdWJ0ZXN0cyh0ZXN0cywgTlVMTCk7Cit9CmRp ZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9tb2NrX3NlbGZ0 ZXN0cy5oIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVz dHMuaAppbmRleCAxOTI5ZmViYTRlOGUuLjNkYjM0ZDNlZWE1OCAxMDA2NDQKLS0tIGEvZHJpdmVy cy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfbW9ja19zZWxmdGVzdHMuaAorKysgYi9kcml2 ZXJzL2dwdS9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9tb2NrX3NlbGZ0ZXN0cy5oCkBAIC0yMSw2 ICsyMSw3IEBAIHNlbGZ0ZXN0KGZlbmNlLCBpOTE1X3N3X2ZlbmNlX21vY2tfc2VsZnRlc3RzKQog c2VsZnRlc3Qoc2NhdHRlcmxpc3QsIHNjYXR0ZXJsaXN0X21vY2tfc2VsZnRlc3RzKQogc2VsZnRl c3Qoc3luY21hcCwgaTkxNV9zeW5jbWFwX21vY2tfc2VsZnRlc3RzKQogc2VsZnRlc3QodW5jb3Jl LCBpbnRlbF91bmNvcmVfbW9ja19zZWxmdGVzdHMpCitzZWxmdGVzdChyaW5nLCBpbnRlbF9yaW5n X21vY2tfc2VsZnRlc3RzKQogc2VsZnRlc3QoZW5naW5lLCBpbnRlbF9lbmdpbmVfY3NfbW9ja19z ZWxmdGVzdHMpCiBzZWxmdGVzdCh0aW1lbGluZXMsIGludGVsX3RpbWVsaW5lX21vY2tfc2VsZnRl c3RzKQogc2VsZnRlc3QocmVxdWVzdHMsIGk5MTVfcmVxdWVzdF9tb2NrX3NlbGZ0ZXN0cykKLS0g CjIuMjAuMQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K SW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0 dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==