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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 E7D28C4743F for ; Tue, 8 Jun 2021 09:29:28 +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 B7C8061263 for ; Tue, 8 Jun 2021 09:29:28 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B7C8061263 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 753776EB78; Tue, 8 Jun 2021 09:29:25 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 789ED6EB74; Tue, 8 Jun 2021 09:29:21 +0000 (UTC) IronPort-SDR: 2uVyxF8SmO5Gfep7Fku9Nhtij6XCJme15rAbuTppBmd5AGWU0uVKqNce4T+7oGtn0g4jAbv+gV D1y8rBt6nZQQ== X-IronPort-AV: E=McAfee;i="6200,9189,10008"; a="226150973" X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="226150973" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 02:29:21 -0700 IronPort-SDR: hNzntfVtL2mMO2zkc1tKFOdzBe/MQmyd9c1LiQZfcJxxb/t3XEYkxGFQ3ysfTRToBCPL1fW87x AKFEw/OmxYDg== X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="551544486" Received: from mkayyal-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.115]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 02:29:19 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH 9/9] drm/i915/gt: Setup a default migration context on the GT Date: Tue, 8 Jun 2021 11:28:46 +0200 Message-Id: <20210608092846.64198-10-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210608092846.64198-1-thomas.hellstrom@linux.intel.com> References: <20210608092846.64198-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com, Chris Wilson Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Chris Wilson Set up a default migration context on the GT and use it from the selftests. Add a perf selftest and make sure we exercise LMEM if available. Signed-off-by: Chris Wilson Co-developed-by: Thomas Hellström Signed-off-by: Thomas Hellström --- drivers/gpu/drm/i915/gt/intel_gt.c | 4 + drivers/gpu/drm/i915/gt/intel_gt_types.h | 3 + drivers/gpu/drm/i915/gt/intel_migrate.c | 4 +- drivers/gpu/drm/i915/gt/selftest_migrate.c | 227 +++++++++++++++++- .../drm/i915/selftests/i915_perf_selftests.h | 1 + 5 files changed, 232 insertions(+), 7 deletions(-) diff --git a/drivers/gpu/drm/i915/gt/intel_gt.c b/drivers/gpu/drm/i915/gt/intel_gt.c index 2161bf01ef8b..67ef057ae918 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt.c +++ b/drivers/gpu/drm/i915/gt/intel_gt.c @@ -13,6 +13,7 @@ #include "intel_gt_clock_utils.h" #include "intel_gt_pm.h" #include "intel_gt_requests.h" +#include "intel_migrate.h" #include "intel_mocs.h" #include "intel_rc6.h" #include "intel_renderstate.h" @@ -626,6 +627,8 @@ int intel_gt_init(struct intel_gt *gt) if (err) goto err_gt; + intel_migrate_init(>->migrate, gt); + goto out_fw; err_gt: __intel_gt_disable(gt); @@ -649,6 +652,7 @@ void intel_gt_driver_remove(struct intel_gt *gt) { __intel_gt_disable(gt); + intel_migrate_fini(>->migrate); intel_uc_driver_remove(>->uc); intel_engines_release(gt); diff --git a/drivers/gpu/drm/i915/gt/intel_gt_types.h b/drivers/gpu/drm/i915/gt/intel_gt_types.h index fecfacf551d5..7450935f2ca8 100644 --- a/drivers/gpu/drm/i915/gt/intel_gt_types.h +++ b/drivers/gpu/drm/i915/gt/intel_gt_types.h @@ -24,6 +24,7 @@ #include "intel_reset_types.h" #include "intel_rc6_types.h" #include "intel_rps_types.h" +#include "intel_migrate_types.h" #include "intel_wakeref.h" struct drm_i915_private; @@ -145,6 +146,8 @@ struct intel_gt { struct i915_vma *scratch; + struct intel_migrate migrate; + struct intel_gt_info { intel_engine_mask_t engine_mask; u8 num_engines; diff --git a/drivers/gpu/drm/i915/gt/intel_migrate.c b/drivers/gpu/drm/i915/gt/intel_migrate.c index 9b8178a79ad3..a7d196a6f3eb 100644 --- a/drivers/gpu/drm/i915/gt/intel_migrate.c +++ b/drivers/gpu/drm/i915/gt/intel_migrate.c @@ -416,10 +416,9 @@ intel_context_migrate_copy(struct intel_context *ce, struct i915_request *rq; int err; + GEM_BUG_ON(ce->vm != ce->engine->gt->migrate.context->vm); *out = NULL; - /* GEM_BUG_ON(ce->vm != migrate_vm); */ - GEM_BUG_ON(ce->ring->size < SZ_64K); do { @@ -534,6 +533,7 @@ intel_context_migrate_clear(struct intel_context *ce, struct i915_request *rq; int err; + GEM_BUG_ON(ce->vm != ce->engine->gt->migrate.context->vm); *out = NULL; GEM_BUG_ON(ce->ring->size < SZ_64K); diff --git a/drivers/gpu/drm/i915/gt/selftest_migrate.c b/drivers/gpu/drm/i915/gt/selftest_migrate.c index 159c8656e1b0..396c81364399 100644 --- a/drivers/gpu/drm/i915/gt/selftest_migrate.c +++ b/drivers/gpu/drm/i915/gt/selftest_migrate.c @@ -3,6 +3,8 @@ * Copyright © 2020 Intel Corporation */ +#include + #include "selftests/i915_random.h" static const unsigned int sizes[] = { @@ -441,14 +443,229 @@ int intel_migrate_live_selftests(struct drm_i915_private *i915) SUBTEST(thread_global_copy), SUBTEST(thread_global_clear), }; - struct intel_migrate m; + struct intel_gt *gt = &i915->gt; + + if (!gt->migrate.context) + return 0; + + return i915_subtests(tests, >->migrate); +} + +static struct drm_i915_gem_object * +create_init_lmem_internal(struct intel_gt *gt, size_t sz, bool try_lmem) +{ + struct drm_i915_gem_object *obj = NULL; int err; - if (intel_migrate_init(&m, &i915->gt)) + if (try_lmem && HAS_LMEM(gt->i915)) + obj = i915_gem_object_create_lmem(gt->i915, sz, 0); + + if (IS_ERR_OR_NULL(obj)) { + obj = i915_gem_object_create_internal(gt->i915, sz); + if (IS_ERR(obj)) + return obj; + } + + i915_gem_object_trylock(obj); + err = i915_gem_object_pin_pages(obj); + if (err) { + i915_gem_object_unlock(obj); + i915_gem_object_put(obj); + return ERR_PTR(err); + } + + return obj; +} + +static int wrap_ktime_compare(const void *A, const void *B) +{ + const ktime_t *a = A, *b = B; + + return ktime_compare(*a, *b); +} + +static int __perf_clear_blt(struct intel_context *ce, + struct scatterlist *sg, + enum i915_cache_level cache_level, + bool is_lmem, + size_t sz) +{ + ktime_t t[5]; + int pass; + int err = 0; + + for (pass = 0; pass < ARRAY_SIZE(t); pass++) { + struct i915_request *rq; + ktime_t t0, t1; + + t0 = ktime_get(); + + err = intel_context_migrate_clear(ce, NULL, sg, cache_level, + is_lmem, 0, &rq); + if (rq) { + if (i915_request_wait(rq, 0, MAX_SCHEDULE_TIMEOUT) < 0) + err = -EIO; + i915_request_put(rq); + } + if (err) + break; + + t1 = ktime_get(); + t[pass] = ktime_sub(t1, t0); + } + if (err) + return err; + + sort(t, ARRAY_SIZE(t), sizeof(*t), wrap_ktime_compare, NULL); + pr_info("%s: %zd KiB fill: %lld MiB/s\n", + ce->engine->name, sz >> 10, + div64_u64(mul_u32_u32(4 * sz, + 1000 * 1000 * 1000), + t[1] + 2 * t[2] + t[3]) >> 20); + return 0; +} + +static int perf_clear_blt(void *arg) +{ + struct intel_gt *gt = arg; + static const unsigned long sizes[] = { + SZ_4K, + SZ_64K, + SZ_2M, + SZ_64M + }; + int i; + + for (i = 0; i < ARRAY_SIZE(sizes); i++) { + struct drm_i915_gem_object *dst; + int err; + + dst = create_init_lmem_internal(gt, sizes[i], true); + if (IS_ERR(dst)) + return PTR_ERR(dst); + + err = __perf_clear_blt(gt->migrate.context, + dst->mm.pages->sgl, + I915_CACHE_NONE, + i915_gem_object_is_lmem(dst), + sizes[i]); + + i915_gem_object_unlock(dst); + i915_gem_object_put(dst); + if (err) + return err; + } + + return 0; +} + +static int __perf_copy_blt(struct intel_context *ce, + struct scatterlist *src, + enum i915_cache_level src_cache_level, + bool src_is_lmem, + struct scatterlist *dst, + enum i915_cache_level dst_cache_level, + bool dst_is_lmem, + size_t sz) +{ + ktime_t t[5]; + int pass; + int err = 0; + + for (pass = 0; pass < ARRAY_SIZE(t); pass++) { + struct i915_request *rq; + ktime_t t0, t1; + + t0 = ktime_get(); + + err = intel_context_migrate_copy(ce, NULL, + src, src_cache_level, + src_is_lmem, + dst, dst_cache_level, + dst_is_lmem, + &rq); + if (rq) { + if (i915_request_wait(rq, 0, MAX_SCHEDULE_TIMEOUT) < 0) + err = -EIO; + i915_request_put(rq); + } + if (err) + break; + + t1 = ktime_get(); + t[pass] = ktime_sub(t1, t0); + } + if (err) + return err; + + sort(t, ARRAY_SIZE(t), sizeof(*t), wrap_ktime_compare, NULL); + pr_info("%s: %zd KiB copy: %lld MiB/s\n", + ce->engine->name, sz >> 10, + div64_u64(mul_u32_u32(4 * sz, + 1000 * 1000 * 1000), + t[1] + 2 * t[2] + t[3]) >> 20); + return 0; +} + +static int perf_copy_blt(void *arg) +{ + struct intel_gt *gt = arg; + static const unsigned long sizes[] = { + SZ_4K, + SZ_64K, + SZ_2M, + SZ_64M + }; + int i; + + for (i = 0; i < ARRAY_SIZE(sizes); i++) { + struct drm_i915_gem_object *src, *dst; + int err; + + src = create_init_lmem_internal(gt, sizes[i], true); + if (IS_ERR(src)) + return PTR_ERR(src); + + dst = create_init_lmem_internal(gt, sizes[i], false); + if (IS_ERR(dst)) { + err = PTR_ERR(dst); + goto err_src; + } + + err = __perf_copy_blt(gt->migrate.context, + src->mm.pages->sgl, + I915_CACHE_NONE, + i915_gem_object_is_lmem(src), + dst->mm.pages->sgl, + I915_CACHE_NONE, + i915_gem_object_is_lmem(dst), + sizes[i]); + + i915_gem_object_unlock(dst); + i915_gem_object_put(dst); +err_src: + i915_gem_object_unlock(src); + i915_gem_object_put(src); + if (err) + return err; + } + + return 0; +} + +int intel_migrate_perf_selftests(struct drm_i915_private *i915) +{ + static const struct i915_subtest tests[] = { + SUBTEST(perf_clear_blt), + SUBTEST(perf_copy_blt), + }; + struct intel_gt *gt = &i915->gt; + + if (intel_gt_is_wedged(gt)) return 0; - err = i915_subtests(tests, &m); - intel_migrate_fini(&m); + if (!gt->migrate.context) + return 0; - return err; + return intel_gt_live_subtests(tests, gt); } diff --git a/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h b/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h index c2389f8a257d..5077dc3c3b8c 100644 --- a/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h +++ b/drivers/gpu/drm/i915/selftests/i915_perf_selftests.h @@ -17,5 +17,6 @@ */ selftest(engine_cs, intel_engine_cs_perf_selftests) selftest(request, i915_request_perf_selftests) +selftest(migrate, intel_migrate_perf_selftests) selftest(blt, i915_gem_object_blt_perf_selftests) selftest(region, intel_memory_region_perf_selftests) -- 2.31.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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 C1C5EC4743D for ; Tue, 8 Jun 2021 09:29:26 +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 8F46A6124C for ; Tue, 8 Jun 2021 09:29:26 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 8F46A6124C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linux.intel.com 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 40AB36EB76; Tue, 8 Jun 2021 09:29:23 +0000 (UTC) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by gabe.freedesktop.org (Postfix) with ESMTPS id 789ED6EB74; Tue, 8 Jun 2021 09:29:21 +0000 (UTC) IronPort-SDR: 2uVyxF8SmO5Gfep7Fku9Nhtij6XCJme15rAbuTppBmd5AGWU0uVKqNce4T+7oGtn0g4jAbv+gV D1y8rBt6nZQQ== X-IronPort-AV: E=McAfee;i="6200,9189,10008"; a="226150973" X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="226150973" Received: from orsmga004.jf.intel.com ([10.7.209.38]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 02:29:21 -0700 IronPort-SDR: hNzntfVtL2mMO2zkc1tKFOdzBe/MQmyd9c1LiQZfcJxxb/t3XEYkxGFQ3ysfTRToBCPL1fW87x AKFEw/OmxYDg== X-IronPort-AV: E=Sophos;i="5.83,257,1616482800"; d="scan'208";a="551544486" Received: from mkayyal-mobl.ger.corp.intel.com (HELO thellst-mobl1.intel.com) ([10.249.254.115]) by orsmga004-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Jun 2021 02:29:19 -0700 From: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= To: intel-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Date: Tue, 8 Jun 2021 11:28:46 +0200 Message-Id: <20210608092846.64198-10-thomas.hellstrom@linux.intel.com> X-Mailer: git-send-email 2.31.1 In-Reply-To: <20210608092846.64198-1-thomas.hellstrom@linux.intel.com> References: <20210608092846.64198-1-thomas.hellstrom@linux.intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 9/9] drm/i915/gt: Setup a default migration context on the GT 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: =?UTF-8?q?Thomas=20Hellstr=C3=B6m?= , matthew.auld@intel.com, Chris Wilson Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" RnJvbTogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13aWxzb24uY28udWs+CgpTZXQgdXAgYSBk ZWZhdWx0IG1pZ3JhdGlvbiBjb250ZXh0IG9uIHRoZSBHVCBhbmQgdXNlIGl0IGZyb20gdGhlCnNl bGZ0ZXN0cy4KQWRkIGEgcGVyZiBzZWxmdGVzdCBhbmQgbWFrZSBzdXJlIHdlIGV4ZXJjaXNlIExN RU0gaWYgYXZhaWxhYmxlLgoKU2lnbmVkLW9mZi1ieTogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJp cy13aWxzb24uY28udWs+CkNvLWRldmVsb3BlZC1ieTogVGhvbWFzIEhlbGxzdHLDtm0gPHRob21h cy5oZWxsc3Ryb21AbGludXguaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBUaG9tYXMgSGVsbHN0 csO2bSA8dGhvbWFzLmhlbGxzdHJvbUBsaW51eC5pbnRlbC5jb20+Ci0tLQogZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfZ3QuYyAgICAgICAgICAgIHwgICA0ICsKIGRyaXZlcnMvZ3B1L2Ry bS9pOTE1L2d0L2ludGVsX2d0X3R5cGVzLmggICAgICB8ICAgMyArCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9taWdyYXRlLmMgICAgICAgfCAgIDQgKy0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2d0L3NlbGZ0ZXN0X21pZ3JhdGUuYyAgICB8IDIyNyArKysrKysrKysrKysrKysrKy0KIC4u Li9kcm0vaTkxNS9zZWxmdGVzdHMvaTkxNV9wZXJmX3NlbGZ0ZXN0cy5oICB8ICAgMSArCiA1IGZp bGVzIGNoYW5nZWQsIDIzMiBpbnNlcnRpb25zKCspLCA3IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0LmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9ndC9pbnRlbF9ndC5jCmluZGV4IDIxNjFiZjAxZWY4Yi4uNjdlZjA1N2FlOTE4IDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9ndC5jCisrKyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L2ludGVsX2d0LmMKQEAgLTEzLDYgKzEzLDcgQEAKICNpbmNsdWRlICJp bnRlbF9ndF9jbG9ja191dGlscy5oIgogI2luY2x1ZGUgImludGVsX2d0X3BtLmgiCiAjaW5jbHVk ZSAiaW50ZWxfZ3RfcmVxdWVzdHMuaCIKKyNpbmNsdWRlICJpbnRlbF9taWdyYXRlLmgiCiAjaW5j bHVkZSAiaW50ZWxfbW9jcy5oIgogI2luY2x1ZGUgImludGVsX3JjNi5oIgogI2luY2x1ZGUgImlu dGVsX3JlbmRlcnN0YXRlLmgiCkBAIC02MjYsNiArNjI3LDggQEAgaW50IGludGVsX2d0X2luaXQo c3RydWN0IGludGVsX2d0ICpndCkKIAlpZiAoZXJyKQogCQlnb3RvIGVycl9ndDsKIAorCWludGVs X21pZ3JhdGVfaW5pdCgmZ3QtPm1pZ3JhdGUsIGd0KTsKKwogCWdvdG8gb3V0X2Z3OwogZXJyX2d0 OgogCV9faW50ZWxfZ3RfZGlzYWJsZShndCk7CkBAIC02NDksNiArNjUyLDcgQEAgdm9pZCBpbnRl bF9ndF9kcml2ZXJfcmVtb3ZlKHN0cnVjdCBpbnRlbF9ndCAqZ3QpCiB7CiAJX19pbnRlbF9ndF9k aXNhYmxlKGd0KTsKIAorCWludGVsX21pZ3JhdGVfZmluaSgmZ3QtPm1pZ3JhdGUpOwogCWludGVs X3VjX2RyaXZlcl9yZW1vdmUoJmd0LT51Yyk7CiAKIAlpbnRlbF9lbmdpbmVzX3JlbGVhc2UoZ3Qp OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfdHlwZXMuaCBi L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2ludGVsX2d0X3R5cGVzLmgKaW5kZXggZmVjZmFjZjU1 MWQ1Li43NDUwOTM1ZjJjYTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L2lu dGVsX2d0X3R5cGVzLmgKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfZ3RfdHlw ZXMuaApAQCAtMjQsNiArMjQsNyBAQAogI2luY2x1ZGUgImludGVsX3Jlc2V0X3R5cGVzLmgiCiAj aW5jbHVkZSAiaW50ZWxfcmM2X3R5cGVzLmgiCiAjaW5jbHVkZSAiaW50ZWxfcnBzX3R5cGVzLmgi CisjaW5jbHVkZSAiaW50ZWxfbWlncmF0ZV90eXBlcy5oIgogI2luY2x1ZGUgImludGVsX3dha2Vy ZWYuaCIKIAogc3RydWN0IGRybV9pOTE1X3ByaXZhdGU7CkBAIC0xNDUsNiArMTQ2LDggQEAgc3Ry dWN0IGludGVsX2d0IHsKIAogCXN0cnVjdCBpOTE1X3ZtYSAqc2NyYXRjaDsKIAorCXN0cnVjdCBp bnRlbF9taWdyYXRlIG1pZ3JhdGU7CisKIAlzdHJ1Y3QgaW50ZWxfZ3RfaW5mbyB7CiAJCWludGVs X2VuZ2luZV9tYXNrX3QgZW5naW5lX21hc2s7CiAJCXU4IG51bV9lbmdpbmVzOwpkaWZmIC0tZ2l0 IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbWlncmF0ZS5jIGIvZHJpdmVycy9ncHUv ZHJtL2k5MTUvZ3QvaW50ZWxfbWlncmF0ZS5jCmluZGV4IDliODE3OGE3OWFkMy4uYTdkMTk2YTZm M2ViIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9ndC9pbnRlbF9taWdyYXRlLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3QvaW50ZWxfbWlncmF0ZS5jCkBAIC00MTYsMTAg KzQxNiw5IEBAIGludGVsX2NvbnRleHRfbWlncmF0ZV9jb3B5KHN0cnVjdCBpbnRlbF9jb250ZXh0 ICpjZSwKIAlzdHJ1Y3QgaTkxNV9yZXF1ZXN0ICpycTsKIAlpbnQgZXJyOwogCisJR0VNX0JVR19P TihjZS0+dm0gIT0gY2UtPmVuZ2luZS0+Z3QtPm1pZ3JhdGUuY29udGV4dC0+dm0pOwogCSpvdXQg PSBOVUxMOwogCi0JLyogR0VNX0JVR19PTihjZS0+dm0gIT0gbWlncmF0ZV92bSk7ICovCi0KIAlH RU1fQlVHX09OKGNlLT5yaW5nLT5zaXplIDwgU1pfNjRLKTsKIAogCWRvIHsKQEAgLTUzNCw2ICs1 MzMsNyBAQCBpbnRlbF9jb250ZXh0X21pZ3JhdGVfY2xlYXIoc3RydWN0IGludGVsX2NvbnRleHQg KmNlLAogCXN0cnVjdCBpOTE1X3JlcXVlc3QgKnJxOwogCWludCBlcnI7CiAKKwlHRU1fQlVHX09O KGNlLT52bSAhPSBjZS0+ZW5naW5lLT5ndC0+bWlncmF0ZS5jb250ZXh0LT52bSk7CiAJKm91dCA9 IE5VTEw7CiAKIAlHRU1fQlVHX09OKGNlLT5yaW5nLT5zaXplIDwgU1pfNjRLKTsKZGlmZiAtLWdp dCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21pZ3JhdGUuYyBiL2RyaXZlcnMv Z3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21pZ3JhdGUuYwppbmRleCAxNTljODY1NmUxYjAuLjM5 NmM4MTM2NDM5OSAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZ3Qvc2VsZnRlc3Rf bWlncmF0ZS5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2d0L3NlbGZ0ZXN0X21pZ3JhdGUu YwpAQCAtMyw2ICszLDggQEAKICAqIENvcHlyaWdodCDCqSAyMDIwIEludGVsIENvcnBvcmF0aW9u CiAgKi8KIAorI2luY2x1ZGUgPGxpbnV4L3NvcnQuaD4KKwogI2luY2x1ZGUgInNlbGZ0ZXN0cy9p OTE1X3JhbmRvbS5oIgogCiBzdGF0aWMgY29uc3QgdW5zaWduZWQgaW50IHNpemVzW10gPSB7CkBA IC00NDEsMTQgKzQ0MywyMjkgQEAgaW50IGludGVsX21pZ3JhdGVfbGl2ZV9zZWxmdGVzdHMoc3Ry dWN0IGRybV9pOTE1X3ByaXZhdGUgKmk5MTUpCiAJCVNVQlRFU1QodGhyZWFkX2dsb2JhbF9jb3B5 KSwKIAkJU1VCVEVTVCh0aHJlYWRfZ2xvYmFsX2NsZWFyKSwKIAl9OwotCXN0cnVjdCBpbnRlbF9t aWdyYXRlIG07CisJc3RydWN0IGludGVsX2d0ICpndCA9ICZpOTE1LT5ndDsKKworCWlmICghZ3Qt Pm1pZ3JhdGUuY29udGV4dCkKKwkJcmV0dXJuIDA7CisKKwlyZXR1cm4gaTkxNV9zdWJ0ZXN0cyh0 ZXN0cywgJmd0LT5taWdyYXRlKTsKK30KKworc3RhdGljIHN0cnVjdCBkcm1faTkxNV9nZW1fb2Jq ZWN0ICoKK2NyZWF0ZV9pbml0X2xtZW1faW50ZXJuYWwoc3RydWN0IGludGVsX2d0ICpndCwgc2l6 ZV90IHN6LCBib29sIHRyeV9sbWVtKQoreworCXN0cnVjdCBkcm1faTkxNV9nZW1fb2JqZWN0ICpv YmogPSBOVUxMOwogCWludCBlcnI7CiAKLQlpZiAoaW50ZWxfbWlncmF0ZV9pbml0KCZtLCAmaTkx NS0+Z3QpKQorCWlmICh0cnlfbG1lbSAmJiBIQVNfTE1FTShndC0+aTkxNSkpCisJCW9iaiA9IGk5 MTVfZ2VtX29iamVjdF9jcmVhdGVfbG1lbShndC0+aTkxNSwgc3osIDApOworCisJaWYgKElTX0VS Ul9PUl9OVUxMKG9iaikpIHsKKwkJb2JqID0gaTkxNV9nZW1fb2JqZWN0X2NyZWF0ZV9pbnRlcm5h bChndC0+aTkxNSwgc3opOworCQlpZiAoSVNfRVJSKG9iaikpCisJCQlyZXR1cm4gb2JqOworCX0K KworCWk5MTVfZ2VtX29iamVjdF90cnlsb2NrKG9iaik7CisJZXJyID0gaTkxNV9nZW1fb2JqZWN0 X3Bpbl9wYWdlcyhvYmopOworCWlmIChlcnIpIHsKKwkJaTkxNV9nZW1fb2JqZWN0X3VubG9jayhv YmopOworCQlpOTE1X2dlbV9vYmplY3RfcHV0KG9iaik7CisJCXJldHVybiBFUlJfUFRSKGVycik7 CisJfQorCisJcmV0dXJuIG9iajsKK30KKworc3RhdGljIGludCB3cmFwX2t0aW1lX2NvbXBhcmUo Y29uc3Qgdm9pZCAqQSwgY29uc3Qgdm9pZCAqQikKK3sKKwljb25zdCBrdGltZV90ICphID0gQSwg KmIgPSBCOworCisJcmV0dXJuIGt0aW1lX2NvbXBhcmUoKmEsICpiKTsKK30KKworc3RhdGljIGlu dCBfX3BlcmZfY2xlYXJfYmx0KHN0cnVjdCBpbnRlbF9jb250ZXh0ICpjZSwKKwkJCSAgICBzdHJ1 Y3Qgc2NhdHRlcmxpc3QgKnNnLAorCQkJICAgIGVudW0gaTkxNV9jYWNoZV9sZXZlbCBjYWNoZV9s ZXZlbCwKKwkJCSAgICBib29sIGlzX2xtZW0sCisJCQkgICAgc2l6ZV90IHN6KQoreworCWt0aW1l X3QgdFs1XTsKKwlpbnQgcGFzczsKKwlpbnQgZXJyID0gMDsKKworCWZvciAocGFzcyA9IDA7IHBh c3MgPCBBUlJBWV9TSVpFKHQpOyBwYXNzKyspIHsKKwkJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7 CisJCWt0aW1lX3QgdDAsIHQxOworCisJCXQwID0ga3RpbWVfZ2V0KCk7CisKKwkJZXJyID0gaW50 ZWxfY29udGV4dF9taWdyYXRlX2NsZWFyKGNlLCBOVUxMLCBzZywgY2FjaGVfbGV2ZWwsCisJCQkJ CQkgIGlzX2xtZW0sIDAsICZycSk7CisJCWlmIChycSkgeworCQkJaWYgKGk5MTVfcmVxdWVzdF93 YWl0KHJxLCAwLCBNQVhfU0NIRURVTEVfVElNRU9VVCkgPCAwKQorCQkJCWVyciA9IC1FSU87CisJ CQlpOTE1X3JlcXVlc3RfcHV0KHJxKTsKKwkJfQorCQlpZiAoZXJyKQorCQkJYnJlYWs7CisKKwkJ dDEgPSBrdGltZV9nZXQoKTsKKwkJdFtwYXNzXSA9IGt0aW1lX3N1Yih0MSwgdDApOworCX0KKwlp ZiAoZXJyKQorCQlyZXR1cm4gZXJyOworCisJc29ydCh0LCBBUlJBWV9TSVpFKHQpLCBzaXplb2Yo KnQpLCB3cmFwX2t0aW1lX2NvbXBhcmUsIE5VTEwpOworCXByX2luZm8oIiVzOiAlemQgS2lCIGZp bGw6ICVsbGQgTWlCL3NcbiIsCisJCWNlLT5lbmdpbmUtPm5hbWUsIHN6ID4+IDEwLAorCQlkaXY2 NF91NjQobXVsX3UzMl91MzIoNCAqIHN6LAorCQkJCSAgICAgIDEwMDAgKiAxMDAwICogMTAwMCks CisJCQkgIHRbMV0gKyAyICogdFsyXSArIHRbM10pID4+IDIwKTsKKwlyZXR1cm4gMDsKK30KKwor c3RhdGljIGludCBwZXJmX2NsZWFyX2JsdCh2b2lkICphcmcpCit7CisJc3RydWN0IGludGVsX2d0 ICpndCA9IGFyZzsKKwlzdGF0aWMgY29uc3QgdW5zaWduZWQgbG9uZyBzaXplc1tdID0geworCQlT Wl80SywKKwkJU1pfNjRLLAorCQlTWl8yTSwKKwkJU1pfNjRNCisJfTsKKwlpbnQgaTsKKworCWZv ciAoaSA9IDA7IGkgPCBBUlJBWV9TSVpFKHNpemVzKTsgaSsrKSB7CisJCXN0cnVjdCBkcm1faTkx NV9nZW1fb2JqZWN0ICpkc3Q7CisJCWludCBlcnI7CisKKwkJZHN0ID0gY3JlYXRlX2luaXRfbG1l bV9pbnRlcm5hbChndCwgc2l6ZXNbaV0sIHRydWUpOworCQlpZiAoSVNfRVJSKGRzdCkpCisJCQly ZXR1cm4gUFRSX0VSUihkc3QpOworCisJCWVyciA9IF9fcGVyZl9jbGVhcl9ibHQoZ3QtPm1pZ3Jh dGUuY29udGV4dCwKKwkJCQkgICAgICAgZHN0LT5tbS5wYWdlcy0+c2dsLAorCQkJCSAgICAgICBJ OTE1X0NBQ0hFX05PTkUsCisJCQkJICAgICAgIGk5MTVfZ2VtX29iamVjdF9pc19sbWVtKGRzdCks CisJCQkJICAgICAgIHNpemVzW2ldKTsKKworCQlpOTE1X2dlbV9vYmplY3RfdW5sb2NrKGRzdCk7 CisJCWk5MTVfZ2VtX29iamVjdF9wdXQoZHN0KTsKKwkJaWYgKGVycikKKwkJCXJldHVybiBlcnI7 CisJfQorCisJcmV0dXJuIDA7Cit9CisKK3N0YXRpYyBpbnQgX19wZXJmX2NvcHlfYmx0KHN0cnVj dCBpbnRlbF9jb250ZXh0ICpjZSwKKwkJCSAgIHN0cnVjdCBzY2F0dGVybGlzdCAqc3JjLAorCQkJ ICAgZW51bSBpOTE1X2NhY2hlX2xldmVsIHNyY19jYWNoZV9sZXZlbCwKKwkJCSAgIGJvb2wgc3Jj X2lzX2xtZW0sCisJCQkgICBzdHJ1Y3Qgc2NhdHRlcmxpc3QgKmRzdCwKKwkJCSAgIGVudW0gaTkx NV9jYWNoZV9sZXZlbCBkc3RfY2FjaGVfbGV2ZWwsCisJCQkgICBib29sIGRzdF9pc19sbWVtLAor CQkJICAgc2l6ZV90IHN6KQoreworCWt0aW1lX3QgdFs1XTsKKwlpbnQgcGFzczsKKwlpbnQgZXJy ID0gMDsKKworCWZvciAocGFzcyA9IDA7IHBhc3MgPCBBUlJBWV9TSVpFKHQpOyBwYXNzKyspIHsK KwkJc3RydWN0IGk5MTVfcmVxdWVzdCAqcnE7CisJCWt0aW1lX3QgdDAsIHQxOworCisJCXQwID0g a3RpbWVfZ2V0KCk7CisKKwkJZXJyID0gaW50ZWxfY29udGV4dF9taWdyYXRlX2NvcHkoY2UsIE5V TEwsCisJCQkJCQkgc3JjLCBzcmNfY2FjaGVfbGV2ZWwsCisJCQkJCQkgc3JjX2lzX2xtZW0sCisJ CQkJCQkgZHN0LCBkc3RfY2FjaGVfbGV2ZWwsCisJCQkJCQkgZHN0X2lzX2xtZW0sCisJCQkJCQkg JnJxKTsKKwkJaWYgKHJxKSB7CisJCQlpZiAoaTkxNV9yZXF1ZXN0X3dhaXQocnEsIDAsIE1BWF9T Q0hFRFVMRV9USU1FT1VUKSA8IDApCisJCQkJZXJyID0gLUVJTzsKKwkJCWk5MTVfcmVxdWVzdF9w dXQocnEpOworCQl9CisJCWlmIChlcnIpCisJCQlicmVhazsKKworCQl0MSA9IGt0aW1lX2dldCgp OworCQl0W3Bhc3NdID0ga3RpbWVfc3ViKHQxLCB0MCk7CisJfQorCWlmIChlcnIpCisJCXJldHVy biBlcnI7CisKKwlzb3J0KHQsIEFSUkFZX1NJWkUodCksIHNpemVvZigqdCksIHdyYXBfa3RpbWVf Y29tcGFyZSwgTlVMTCk7CisJcHJfaW5mbygiJXM6ICV6ZCBLaUIgY29weTogJWxsZCBNaUIvc1xu IiwKKwkJY2UtPmVuZ2luZS0+bmFtZSwgc3ogPj4gMTAsCisJCWRpdjY0X3U2NChtdWxfdTMyX3Uz Mig0ICogc3osCisJCQkJICAgICAgMTAwMCAqIDEwMDAgKiAxMDAwKSwKKwkJCSAgdFsxXSArIDIg KiB0WzJdICsgdFszXSkgPj4gMjApOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50IHBlcmZf Y29weV9ibHQodm9pZCAqYXJnKQoreworCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSBhcmc7CisJc3Rh dGljIGNvbnN0IHVuc2lnbmVkIGxvbmcgc2l6ZXNbXSA9IHsKKwkJU1pfNEssCisJCVNaXzY0SywK KwkJU1pfMk0sCisJCVNaXzY0TQorCX07CisJaW50IGk7CisKKwlmb3IgKGkgPSAwOyBpIDwgQVJS QVlfU0laRShzaXplcyk7IGkrKykgeworCQlzdHJ1Y3QgZHJtX2k5MTVfZ2VtX29iamVjdCAqc3Jj LCAqZHN0OworCQlpbnQgZXJyOworCisJCXNyYyA9IGNyZWF0ZV9pbml0X2xtZW1faW50ZXJuYWwo Z3QsIHNpemVzW2ldLCB0cnVlKTsKKwkJaWYgKElTX0VSUihzcmMpKQorCQkJcmV0dXJuIFBUUl9F UlIoc3JjKTsKKworCQlkc3QgPSBjcmVhdGVfaW5pdF9sbWVtX2ludGVybmFsKGd0LCBzaXplc1tp XSwgZmFsc2UpOworCQlpZiAoSVNfRVJSKGRzdCkpIHsKKwkJCWVyciA9IFBUUl9FUlIoZHN0KTsK KwkJCWdvdG8gZXJyX3NyYzsKKwkJfQorCisJCWVyciA9IF9fcGVyZl9jb3B5X2JsdChndC0+bWln cmF0ZS5jb250ZXh0LAorCQkJCSAgICAgIHNyYy0+bW0ucGFnZXMtPnNnbCwKKwkJCQkgICAgICBJ OTE1X0NBQ0hFX05PTkUsCisJCQkJICAgICAgaTkxNV9nZW1fb2JqZWN0X2lzX2xtZW0oc3JjKSwK KwkJCQkgICAgICBkc3QtPm1tLnBhZ2VzLT5zZ2wsCisJCQkJICAgICAgSTkxNV9DQUNIRV9OT05F LAorCQkJCSAgICAgIGk5MTVfZ2VtX29iamVjdF9pc19sbWVtKGRzdCksCisJCQkJICAgICAgc2l6 ZXNbaV0pOworCisJCWk5MTVfZ2VtX29iamVjdF91bmxvY2soZHN0KTsKKwkJaTkxNV9nZW1fb2Jq ZWN0X3B1dChkc3QpOworZXJyX3NyYzoKKwkJaTkxNV9nZW1fb2JqZWN0X3VubG9jayhzcmMpOwor CQlpOTE1X2dlbV9vYmplY3RfcHV0KHNyYyk7CisJCWlmIChlcnIpCisJCQlyZXR1cm4gZXJyOwor CX0KKworCXJldHVybiAwOworfQorCitpbnQgaW50ZWxfbWlncmF0ZV9wZXJmX3NlbGZ0ZXN0cyhz dHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqaTkxNSkKK3sKKwlzdGF0aWMgY29uc3Qgc3RydWN0IGk5 MTVfc3VidGVzdCB0ZXN0c1tdID0geworCQlTVUJURVNUKHBlcmZfY2xlYXJfYmx0KSwKKwkJU1VC VEVTVChwZXJmX2NvcHlfYmx0KSwKKwl9OworCXN0cnVjdCBpbnRlbF9ndCAqZ3QgPSAmaTkxNS0+ Z3Q7CisKKwlpZiAoaW50ZWxfZ3RfaXNfd2VkZ2VkKGd0KSkKIAkJcmV0dXJuIDA7CiAKLQllcnIg PSBpOTE1X3N1YnRlc3RzKHRlc3RzLCAmbSk7Ci0JaW50ZWxfbWlncmF0ZV9maW5pKCZtKTsKKwlp ZiAoIWd0LT5taWdyYXRlLmNvbnRleHQpCisJCXJldHVybiAwOwogCi0JcmV0dXJuIGVycjsKKwly ZXR1cm4gaW50ZWxfZ3RfbGl2ZV9zdWJ0ZXN0cyh0ZXN0cywgZ3QpOwogfQpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvc2VsZnRlc3RzL2k5MTVfcGVyZl9zZWxmdGVzdHMuaCBiL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L3NlbGZ0ZXN0cy9pOTE1X3BlcmZfc2VsZnRlc3RzLmgKaW5kZXgg YzIzODlmOGEyNTdkLi41MDc3ZGMzYzNiOGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9p OTE1L3NlbGZ0ZXN0cy9pOTE1X3BlcmZfc2VsZnRlc3RzLmgKKysrIGIvZHJpdmVycy9ncHUvZHJt L2k5MTUvc2VsZnRlc3RzL2k5MTVfcGVyZl9zZWxmdGVzdHMuaApAQCAtMTcsNSArMTcsNiBAQAog ICovCiBzZWxmdGVzdChlbmdpbmVfY3MsIGludGVsX2VuZ2luZV9jc19wZXJmX3NlbGZ0ZXN0cykK IHNlbGZ0ZXN0KHJlcXVlc3QsIGk5MTVfcmVxdWVzdF9wZXJmX3NlbGZ0ZXN0cykKK3NlbGZ0ZXN0 KG1pZ3JhdGUsIGludGVsX21pZ3JhdGVfcGVyZl9zZWxmdGVzdHMpCiBzZWxmdGVzdChibHQsIGk5 MTVfZ2VtX29iamVjdF9ibHRfcGVyZl9zZWxmdGVzdHMpCiBzZWxmdGVzdChyZWdpb24sIGludGVs X21lbW9yeV9yZWdpb25fcGVyZl9zZWxmdGVzdHMpCi0tIAoyLjMxLjEKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCkludGVsLWdmeCBtYWlsaW5nIGxpc3QK SW50ZWwtZ2Z4QGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9w Lm9yZy9tYWlsbWFuL2xpc3RpbmZvL2ludGVsLWdmeAo=