From mboxrd@z Thu Jan 1 00:00:00 1970 From: Andrew Jones Date: Fri, 15 Mar 2024 14:40:11 +0100 Subject: [PATCH 1/5] riscv: Add Zawrs support for spinlocks In-Reply-To: <20240315134009.580167-7-ajones@ventanamicro.com> References: <20240315134009.580167-7-ajones@ventanamicro.com> Message-ID: <20240315134009.580167-8-ajones@ventanamicro.com> List-Id: To: kvm-riscv@lists.infradead.org MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit From: Christoph M?llner The current RISC-V code uses the generic ticket lock implementation, that calls the macros smp_cond_load_relaxed() and smp_cond_load_acquire(). Currently, RISC-V uses the generic implementation of these macros. This patch introduces a RISC-V specific implementation, of these macros, that peels off the first loop iteration and modifies the waiting loop such, that it is possible to use the WRS.STO instruction of the Zawrs ISA extension to stall the CPU. The resulting implementation of smp_cond_load_*() will only work for 32-bit or 64-bit types for RV64 and 32-bit types for RV32. This is caused by the restrictions of the LR instruction (RISC-V only has LR.W and LR.D). Compiler assertions guard this new restriction. This patch uses the existing RISC-V ISA extension framework to detect the presence of Zawrs at run-time. If available a NOP instruction will be replaced by WRS.NTO or WRS.STO. The whole mechanism is gated by Kconfig setting, which defaults to Y. The Zawrs specification can be found here: https://github.com/riscv/riscv-zawrs/blob/main/zawrs.adoc Signed-off-by: Christoph M?llner [rebase, update to review comments] Signed-off-by: Heiko Stuebner [rebase, move ALT_WRS* to barrier.h] Signed-off-by: Andrew Jones --- arch/riscv/Kconfig | 13 +++++ arch/riscv/include/asm/barrier.h | 82 ++++++++++++++++++++++++++++++++ arch/riscv/include/asm/hwcap.h | 1 + arch/riscv/kernel/cpufeature.c | 1 + 4 files changed, 97 insertions(+) diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index e3142ce531a0..2c296113aeb1 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -569,6 +569,19 @@ config RISCV_ISA_V_PREEMPTIVE preemption. Enabling this config will result in higher memory consumption due to the allocation of per-task's kernel Vector context. +config RISCV_ISA_ZAWRS + bool "Zawrs extension support for more efficient busy waiting" + depends on RISCV_ALTERNATIVE + default y + help + Enable the use of the Zawrs (wait for reservation set) extension + when available. + + The Zawrs extension instructions (wrs.nto and wrs.sto) are used for + more efficient busy waiting. + + If you don't know what to do here, say Y. + config TOOLCHAIN_HAS_ZBB bool default y diff --git a/arch/riscv/include/asm/barrier.h b/arch/riscv/include/asm/barrier.h index 110752594228..93b3f572d643 100644 --- a/arch/riscv/include/asm/barrier.h +++ b/arch/riscv/include/asm/barrier.h @@ -11,11 +11,26 @@ #define _ASM_RISCV_BARRIER_H #ifndef __ASSEMBLY__ +#include +#include +#include +#include #define nop() __asm__ __volatile__ ("nop") #define __nops(n) ".rept " #n "\nnop\n.endr\n" #define nops(n) __asm__ __volatile__ (__nops(n)) +#define ZAWRS_WRS_NTO ".long 0x00d00073" +#define ZAWRS_WRS_STO ".long 0x01d00073" +#define ALT_WRS_NTO() \ + __asm__ __volatile__ (ALTERNATIVE( \ + "nop\n", ZAWRS_WRS_NTO "\n", \ + 0, RISCV_ISA_EXT_ZAWRS, CONFIG_RISCV_ISA_ZAWRS)) +#define ALT_WRS_STO() \ + __asm__ __volatile__ (ALTERNATIVE( \ + "nop\n", ZAWRS_WRS_STO "\n", \ + 0, RISCV_ISA_EXT_ZAWRS, CONFIG_RISCV_ISA_ZAWRS)) + #define RISCV_FENCE(p, s) \ __asm__ __volatile__ ("fence " #p "," #s : : : "memory") @@ -44,6 +59,39 @@ do { \ ___p1; \ }) +#define ___smp_load_reservedN(attr, ptr) \ +({ \ + typeof(*ptr) ___p1; \ + \ + __asm__ __volatile__ ("lr." attr " %[p], %[c]\n" \ + : [p]"=&r" (___p1), [c]"+A"(*ptr)); \ + ___p1; \ +}) + +#define __smp_load_reserved_relaxed(ptr) \ +({ \ + typeof(*ptr) ___p1; \ + \ + if (sizeof(*ptr) == sizeof(int)) \ + ___p1 = ___smp_load_reservedN("w", ptr); \ + else if (sizeof(*ptr) == sizeof(long)) \ + ___p1 = ___smp_load_reservedN("d", ptr); \ + else \ + compiletime_assert(0, \ + "Need type compatible with LR/SC instructions for " \ + __stringify(ptr)); \ + ___p1; \ +}) + +#define __smp_load_reserved_acquire(ptr) \ +({ \ + typeof(*ptr) ___p1; \ + \ + ___p1 = __smp_load_reserved_relaxed(ptr); \ + RISCV_FENCE(r, rw); \ + ___p1; \ +}) + /* * This is a very specific barrier: it's currently only used in two places in * the kernel, both in the scheduler. See include/linux/spinlock.h for the two @@ -71,6 +119,40 @@ do { \ */ #define smp_mb__after_spinlock() RISCV_FENCE(iorw,iorw) +#define smp_cond_load_relaxed(ptr, cond_expr) \ +({ \ + typeof(ptr) __PTR = (ptr); \ + __unqual_scalar_typeof(*ptr) VAL; \ + \ + VAL = READ_ONCE(*__PTR); \ + if (!cond_expr) { \ + for (;;) { \ + VAL = __smp_load_reserved_relaxed(__PTR); \ + if (cond_expr) \ + break; \ + ALT_WRS_STO(); \ + } \ + } \ + (typeof(*ptr))VAL; \ +}) + +#define smp_cond_load_acquire(ptr, cond_expr) \ +({ \ + typeof(ptr) __PTR = (ptr); \ + __unqual_scalar_typeof(*ptr) VAL; \ + \ + VAL = smp_load_acquire(__PTR); \ + if (!cond_expr) { \ + for (;;) { \ + VAL = __smp_load_reserved_acquire(__PTR); \ + if (cond_expr) \ + break; \ + ALT_WRS_STO(); \ + } \ + } \ + (typeof(*ptr))VAL; \ +}) + #include #endif /* __ASSEMBLY__ */ diff --git a/arch/riscv/include/asm/hwcap.h b/arch/riscv/include/asm/hwcap.h index 1f2d2599c655..eac7214a4bd0 100644 --- a/arch/riscv/include/asm/hwcap.h +++ b/arch/riscv/include/asm/hwcap.h @@ -80,6 +80,7 @@ #define RISCV_ISA_EXT_ZFA 71 #define RISCV_ISA_EXT_ZTSO 72 #define RISCV_ISA_EXT_ZACAS 73 +#define RISCV_ISA_EXT_ZAWRS 74 #define RISCV_ISA_EXT_XLINUXENVCFG 127 diff --git a/arch/riscv/kernel/cpufeature.c b/arch/riscv/kernel/cpufeature.c index 79a5a35fab96..0e3c79094b07 100644 --- a/arch/riscv/kernel/cpufeature.c +++ b/arch/riscv/kernel/cpufeature.c @@ -271,6 +271,7 @@ const struct riscv_isa_ext_data riscv_isa_ext[] = { __RISCV_ISA_EXT_DATA(zihintpause, RISCV_ISA_EXT_ZIHINTPAUSE), __RISCV_ISA_EXT_DATA(zihpm, RISCV_ISA_EXT_ZIHPM), __RISCV_ISA_EXT_DATA(zacas, RISCV_ISA_EXT_ZACAS), + __RISCV_ISA_EXT_DATA(zawrs, RISCV_ISA_EXT_ZAWRS), __RISCV_ISA_EXT_DATA(zfa, RISCV_ISA_EXT_ZFA), __RISCV_ISA_EXT_DATA(zfh, RISCV_ISA_EXT_ZFH), __RISCV_ISA_EXT_DATA(zfhmin, RISCV_ISA_EXT_ZFHMIN), -- 2.44.0 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id F0A5EC54E69 for ; Fri, 15 Mar 2024 13:40:22 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ps88GbmUm/8RLKU9JTflbWXcE5Wh2/8Q1u/5zw+zvBI=; b=4koxRxeiwCUhMi 9WaUy4JSYAFqZzLYywKOlLCsW0NDaQdAl0496po1lJ1mzKB/o6bsCZ9w62IrMS1baFwpNoEnzAceN fA/byxp108fnPpZM3Fd+W10fTMRO1y0hYqilk8Vh2NpxXl04HGKyRH1kIFcs28l7Kqc1PRhLAHwYg AluyZgk0J+uwbNCPa9o5AJSP4R8/xDUjcONX71nokMQ6FKo6edCWTTHFsKNwguLtMXaYzD5kX+K7A CHwmTDQfnzCJCriurCHHDackLsrYQSrsiLvVUuJEg4Q5BQWnkLgHskIi8+6NCASSJQTmh0Yb3iFE6 FXQxsLdI6tIYKZ9iUYsQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rl7nG-00000000M3w-1UPt; Fri, 15 Mar 2024 13:40:18 +0000 Received: from mail-ej1-x636.google.com ([2a00:1450:4864:20::636]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1rl7nC-00000000M1B-2Gzo for linux-riscv@lists.infradead.org; Fri, 15 Mar 2024 13:40:16 +0000 Received: by mail-ej1-x636.google.com with SMTP id a640c23a62f3a-a461c50deccso260870866b.0 for ; Fri, 15 Mar 2024 06:40:13 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ventanamicro.com; s=google; t=1710510012; x=1711114812; darn=lists.infradead.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=s/82QkV7lsuYytCREMvIABOartLQJEXqVwZ7l/vDDVc=; b=TRbJeI/hX6oBkB877qiK7M91NZ6Z418isdVHUkn2Auv0Lqlzt50AhW2rhJAu+0V8U7 DjGzZBkQIViGDTeCrL6j3Yo+ItUhVKAy+Y60WxYoNuQRSm3IwUcSsn+bEjOFJ9YDJ6Ew QDOTgQvFuIYBhy6TmvrLl3XyPIStSvWOHpDbMAGeo/CrsIOaKvGJ1Ui1nwtpVjMlcvVT VswpCElZcMoJAXdZmcePhfy9SJ6Bfwj9fDIsjZDV09baKHe2331QvKCJvpHZUV9ZSXSM XtGMT8d4VPnmmhgvmTMt2PeaNghbCEfYzaQ29IWf1DZVq4b8FdbE33DDYgO0WBZ7brHT Gd/A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1710510012; x=1711114812; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=s/82QkV7lsuYytCREMvIABOartLQJEXqVwZ7l/vDDVc=; b=vmYpwe2Wff5N69I4nSB9FdNEFELROuU5slwnidkynj5GF/moNa2C/JsSFvSb8iEGJB YfqwaESdvqIsDCIBr/lSLcDZfQ9uHyv9LEuNjqxmGi1E4Vh/b7ghDinOsI9SP2qOMz4L QOmGyR+Tg35/8MTVvT/FrqwCbAeD5HrB/SUVxlZe2Xh/1qqGw7l+CcHevEt1KiK7xtzJ JONn7fKwVfCPYxEIjLhZjOxmVVFd7jz9nJOw1GRftZWpTiz18kUa0Eo6DqivRerIyiGW iK1fF1bmMzyQM1uXS6zwx5eorTOVhzh+pQ5T31pjWmUyFTjRDk2eG9KZvxQudzcPNgEG nYpg== X-Gm-Message-State: AOJu0YzzHzliajdoxvydEy7Mwu6rZbrTTYdl9d2jg0Yezc85Ly4xvdAY QcqFC0hNrNNXbxIJbqcu1IgwBxsGzyCKyUxCckE10qiJ10mWdmlJ8v/fEj03NjpjnkS/tZcIF0v h X-Google-Smtp-Source: AGHT+IFHP6Jg6Qc7D4WCQzZ58TKJZBLj4tlDP5a4xkYQ+HUpTYy8cW16RV/ap4g6RdF9Quj/dZk1HA== X-Received: by 2002:a17:907:6d1d:b0:a46:8bf7:8adf with SMTP id sa29-20020a1709076d1d00b00a468bf78adfmr1387841ejc.63.1710510012531; Fri, 15 Mar 2024 06:40:12 -0700 (PDT) Received: from localhost (2001-1ae9-1c2-4c00-20f-c6b4-1e57-7965.ip6.tmcz.cz. [2001:1ae9:1c2:4c00:20f:c6b4:1e57:7965]) by smtp.gmail.com with ESMTPSA id d10-20020a170907272a00b00a45ff890df0sm1731767ejl.35.2024.03.15.06.40.11 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 15 Mar 2024 06:40:12 -0700 (PDT) From: Andrew Jones To: linux-riscv@lists.infradead.org, kvm-riscv@lists.infradead.org Cc: paul.walmsley@sifive.com, palmer@dabbelt.com, aou@eecs.berkeley.edu, conor.dooley@microchip.com, anup@brainfault.org, atishp@atishpatra.org, christoph.muellner@vrull.eu, heiko@sntech.de, charlie@rivosinc.com, David.Laight@ACULAB.COM, Heiko Stuebner Subject: [PATCH 1/5] riscv: Add Zawrs support for spinlocks Date: Fri, 15 Mar 2024 14:40:11 +0100 Message-ID: <20240315134009.580167-8-ajones@ventanamicro.com> X-Mailer: git-send-email 2.44.0 In-Reply-To: <20240315134009.580167-7-ajones@ventanamicro.com> References: <20240315134009.580167-7-ajones@ventanamicro.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240315_064014_629478_9FEFCCA1 X-CRM114-Status: GOOD ( 20.45 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogQ2hyaXN0b3BoIE3DvGxsbmVyIDxjaHJpc3RvcGgubXVlbGxuZXJAdnJ1bGwuZXU+CgpU aGUgY3VycmVudCBSSVNDLVYgY29kZSB1c2VzIHRoZSBnZW5lcmljIHRpY2tldCBsb2NrIGltcGxl bWVudGF0aW9uLAp0aGF0IGNhbGxzIHRoZSBtYWNyb3Mgc21wX2NvbmRfbG9hZF9yZWxheGVkKCkg YW5kIHNtcF9jb25kX2xvYWRfYWNxdWlyZSgpLgpDdXJyZW50bHksIFJJU0MtViB1c2VzIHRoZSBn ZW5lcmljIGltcGxlbWVudGF0aW9uIG9mIHRoZXNlIG1hY3Jvcy4KVGhpcyBwYXRjaCBpbnRyb2R1 Y2VzIGEgUklTQy1WIHNwZWNpZmljIGltcGxlbWVudGF0aW9uLCBvZiB0aGVzZQptYWNyb3MsIHRo YXQgcGVlbHMgb2ZmIHRoZSBmaXJzdCBsb29wIGl0ZXJhdGlvbiBhbmQgbW9kaWZpZXMgdGhlIHdh aXRpbmcKbG9vcCBzdWNoLCB0aGF0IGl0IGlzIHBvc3NpYmxlIHRvIHVzZSB0aGUgV1JTLlNUTyBp bnN0cnVjdGlvbiBvZiB0aGUgWmF3cnMKSVNBIGV4dGVuc2lvbiB0byBzdGFsbCB0aGUgQ1BVLgoK VGhlIHJlc3VsdGluZyBpbXBsZW1lbnRhdGlvbiBvZiBzbXBfY29uZF9sb2FkXyooKSB3aWxsIG9u bHkgd29yayBmb3IKMzItYml0IG9yIDY0LWJpdCB0eXBlcyBmb3IgUlY2NCBhbmQgMzItYml0IHR5 cGVzIGZvciBSVjMyLgpUaGlzIGlzIGNhdXNlZCBieSB0aGUgcmVzdHJpY3Rpb25zIG9mIHRoZSBM UiBpbnN0cnVjdGlvbiAoUklTQy1WIG9ubHkKaGFzIExSLlcgYW5kIExSLkQpLiBDb21waWxlciBh c3NlcnRpb25zIGd1YXJkIHRoaXMgbmV3IHJlc3RyaWN0aW9uLgoKVGhpcyBwYXRjaCB1c2VzIHRo ZSBleGlzdGluZyBSSVNDLVYgSVNBIGV4dGVuc2lvbiBmcmFtZXdvcmsKdG8gZGV0ZWN0IHRoZSBw cmVzZW5jZSBvZiBaYXdycyBhdCBydW4tdGltZS4KSWYgYXZhaWxhYmxlIGEgTk9QIGluc3RydWN0 aW9uIHdpbGwgYmUgcmVwbGFjZWQgYnkgV1JTLk5UTyBvciBXUlMuU1RPLgoKVGhlIHdob2xlIG1l Y2hhbmlzbSBpcyBnYXRlZCBieSBLY29uZmlnIHNldHRpbmcsIHdoaWNoIGRlZmF1bHRzIHRvIFku CgpUaGUgWmF3cnMgc3BlY2lmaWNhdGlvbiBjYW4gYmUgZm91bmQgaGVyZToKaHR0cHM6Ly9naXRo dWIuY29tL3Jpc2N2L3Jpc2N2LXphd3JzL2Jsb2IvbWFpbi96YXdycy5hZG9jCgpTaWduZWQtb2Zm LWJ5OiBDaHJpc3RvcGggTcO8bGxuZXIgPGNocmlzdG9waC5tdWVsbG5lckB2cnVsbC5ldT4KW3Jl YmFzZSwgdXBkYXRlIHRvIHJldmlldyBjb21tZW50c10KU2lnbmVkLW9mZi1ieTogSGVpa28gU3R1 ZWJuZXIgPGhlaWtvLnN0dWVibmVyQHZydWxsLmV1PgpbcmViYXNlLCBtb3ZlIEFMVF9XUlMqIHRv IGJhcnJpZXIuaF0KU2lnbmVkLW9mZi1ieTogQW5kcmV3IEpvbmVzIDxham9uZXNAdmVudGFuYW1p Y3JvLmNvbT4KLS0tCiBhcmNoL3Jpc2N2L0tjb25maWcgICAgICAgICAgICAgICB8IDEzICsrKysr CiBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2JhcnJpZXIuaCB8IDgyICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrCiBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL2h3Y2FwLmggICB8ICAxICsK IGFyY2gvcmlzY3Yva2VybmVsL2NwdWZlYXR1cmUuYyAgIHwgIDEgKwogNCBmaWxlcyBjaGFuZ2Vk LCA5NyBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9LY29uZmlnIGIvYXJj aC9yaXNjdi9LY29uZmlnCmluZGV4IGUzMTQyY2U1MzFhMC4uMmMyOTYxMTNhZWIxIDEwMDY0NAot LS0gYS9hcmNoL3Jpc2N2L0tjb25maWcKKysrIGIvYXJjaC9yaXNjdi9LY29uZmlnCkBAIC01Njks NiArNTY5LDE5IEBAIGNvbmZpZyBSSVNDVl9JU0FfVl9QUkVFTVBUSVZFCiAJICBwcmVlbXB0aW9u LiBFbmFibGluZyB0aGlzIGNvbmZpZyB3aWxsIHJlc3VsdCBpbiBoaWdoZXIgbWVtb3J5CiAJICBj b25zdW1wdGlvbiBkdWUgdG8gdGhlIGFsbG9jYXRpb24gb2YgcGVyLXRhc2sncyBrZXJuZWwgVmVj dG9yIGNvbnRleHQuCiAKK2NvbmZpZyBSSVNDVl9JU0FfWkFXUlMKKwlib29sICJaYXdycyBleHRl bnNpb24gc3VwcG9ydCBmb3IgbW9yZSBlZmZpY2llbnQgYnVzeSB3YWl0aW5nIgorCWRlcGVuZHMg b24gUklTQ1ZfQUxURVJOQVRJVkUKKwlkZWZhdWx0IHkKKwloZWxwCisJICAgRW5hYmxlIHRoZSB1 c2Ugb2YgdGhlIFphd3JzICh3YWl0IGZvciByZXNlcnZhdGlvbiBzZXQpIGV4dGVuc2lvbgorCSAg IHdoZW4gYXZhaWxhYmxlLgorCisJICAgVGhlIFphd3JzIGV4dGVuc2lvbiBpbnN0cnVjdGlvbnMg KHdycy5udG8gYW5kIHdycy5zdG8pIGFyZSB1c2VkIGZvcgorCSAgIG1vcmUgZWZmaWNpZW50IGJ1 c3kgd2FpdGluZy4KKworCSAgIElmIHlvdSBkb24ndCBrbm93IHdoYXQgdG8gZG8gaGVyZSwgc2F5 IFkuCisKIGNvbmZpZyBUT09MQ0hBSU5fSEFTX1pCQgogCWJvb2wKIAlkZWZhdWx0IHkKZGlmZiAt LWdpdCBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vYmFycmllci5oIGIvYXJjaC9yaXNjdi9pbmNs dWRlL2FzbS9iYXJyaWVyLmgKaW5kZXggMTEwNzUyNTk0MjI4Li45M2IzZjU3MmQ2NDMgMTAwNjQ0 Ci0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vYmFycmllci5oCisrKyBiL2FyY2gvcmlzY3Yv aW5jbHVkZS9hc20vYmFycmllci5oCkBAIC0xMSwxMSArMTEsMjYgQEAKICNkZWZpbmUgX0FTTV9S SVNDVl9CQVJSSUVSX0gKIAogI2lmbmRlZiBfX0FTU0VNQkxZX18KKyNpbmNsdWRlIDxsaW51eC9j b21waWxlci5oPgorI2luY2x1ZGUgPGFzbS9hbHRlcm5hdGl2ZS1tYWNyb3MuaD4KKyNpbmNsdWRl IDxhc20vaHdjYXAuaD4KKyNpbmNsdWRlIDxhc20vcndvbmNlLmg+CiAKICNkZWZpbmUgbm9wKCkJ CV9fYXNtX18gX192b2xhdGlsZV9fICgibm9wIikKICNkZWZpbmUgX19ub3BzKG4pCSIucmVwdAki ICNuICJcbm5vcFxuLmVuZHJcbiIKICNkZWZpbmUgbm9wcyhuKQkJX19hc21fXyBfX3ZvbGF0aWxl X18gKF9fbm9wcyhuKSkKIAorI2RlZmluZSBaQVdSU19XUlNfTlRPCSIubG9uZyAweDAwZDAwMDcz IgorI2RlZmluZSBaQVdSU19XUlNfU1RPCSIubG9uZyAweDAxZDAwMDczIgorI2RlZmluZSBBTFRf V1JTX05UTygpCQkJCQkJCVwKKwlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoQUxURVJOQVRJVkUoCQkJ CVwKKwkJIm5vcFxuIiwgWkFXUlNfV1JTX05UTyAiXG4iLAkJCQlcCisJCTAsIFJJU0NWX0lTQV9F WFRfWkFXUlMsIENPTkZJR19SSVNDVl9JU0FfWkFXUlMpKQorI2RlZmluZSBBTFRfV1JTX1NUTygp CQkJCQkJCVwKKwlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoQUxURVJOQVRJVkUoCQkJCVwKKwkJIm5v cFxuIiwgWkFXUlNfV1JTX1NUTyAiXG4iLAkJCQlcCisJCTAsIFJJU0NWX0lTQV9FWFRfWkFXUlMs IENPTkZJR19SSVNDVl9JU0FfWkFXUlMpKQorCiAjZGVmaW5lIFJJU0NWX0ZFTkNFKHAsIHMpIFwK IAlfX2FzbV9fIF9fdm9sYXRpbGVfXyAoImZlbmNlICIgI3AgIiwiICNzIDogOiA6ICJtZW1vcnki KQogCkBAIC00NCw2ICs1OSwzOSBAQCBkbyB7CQkJCQkJCQkJXAogCV9fX3AxOwkJCQkJCQkJXAog fSkKIAorI2RlZmluZSBfX19zbXBfbG9hZF9yZXNlcnZlZE4oYXR0ciwgcHRyKQkJCQlcCisoewkJ CQkJCQkJCVwKKwl0eXBlb2YoKnB0cikgX19fcDE7CQkJCQkJXAorCQkJCQkJCQkJXAorCV9fYXNt X18gX192b2xhdGlsZV9fICgibHIuIiBhdHRyICIgICAgICAgJVtwXSwgJVtjXVxuIgkJXAorCQkJ ICAgICAgOiBbcF0iPSZyIiAoX19fcDEpLCBbY10iK0EiKCpwdHIpKTsJXAorCV9fX3AxOwkJCQkJ CQkJXAorfSkKKworI2RlZmluZSBfX3NtcF9sb2FkX3Jlc2VydmVkX3JlbGF4ZWQocHRyKQkJCQlc CisoewkJCQkJCQkJCVwKKwl0eXBlb2YoKnB0cikgX19fcDE7CQkJCQkJXAorCQkJCQkJCQkJXAor CWlmIChzaXplb2YoKnB0cikgPT0gc2l6ZW9mKGludCkpCQkJCVwKKwkJX19fcDEgPSBfX19zbXBf bG9hZF9yZXNlcnZlZE4oInciLCBwdHIpOwkJXAorCWVsc2UgaWYgKHNpemVvZigqcHRyKSA9PSBz aXplb2YobG9uZykpCQkJCVwKKwkJX19fcDEgPSBfX19zbXBfbG9hZF9yZXNlcnZlZE4oImQiLCBw dHIpOwkJXAorCWVsc2UJCQkJCQkJCVwKKwkJY29tcGlsZXRpbWVfYXNzZXJ0KDAsCQkJCQlcCisJ CSJOZWVkIHR5cGUgY29tcGF0aWJsZSB3aXRoIExSL1NDIGluc3RydWN0aW9ucyBmb3IgIglcCisJ CV9fc3RyaW5naWZ5KHB0cikpOwkJCQkJXAorCV9fX3AxOwkJCQkJCQkJXAorfSkKKworI2RlZmlu ZSBfX3NtcF9sb2FkX3Jlc2VydmVkX2FjcXVpcmUocHRyKQkJCQlcCisoewkJCQkJCQkJCVwKKwl0 eXBlb2YoKnB0cikgX19fcDE7CQkJCQkJXAorCQkJCQkJCQkJXAorCV9fX3AxID0gX19zbXBfbG9h ZF9yZXNlcnZlZF9yZWxheGVkKHB0cik7CQkJXAorCVJJU0NWX0ZFTkNFKHIsIHJ3KTsJCQkJCQlc CisJX19fcDE7CQkJCQkJCQlcCit9KQorCiAvKgogICogVGhpcyBpcyBhIHZlcnkgc3BlY2lmaWMg YmFycmllcjogaXQncyBjdXJyZW50bHkgb25seSB1c2VkIGluIHR3byBwbGFjZXMgaW4KICAqIHRo ZSBrZXJuZWwsIGJvdGggaW4gdGhlIHNjaGVkdWxlci4gIFNlZSBpbmNsdWRlL2xpbnV4L3NwaW5s b2NrLmggZm9yIHRoZSB0d28KQEAgLTcxLDYgKzExOSw0MCBAQCBkbyB7CQkJCQkJCQkJXAogICov CiAjZGVmaW5lIHNtcF9tYl9fYWZ0ZXJfc3BpbmxvY2soKQlSSVNDVl9GRU5DRShpb3J3LGlvcncp CiAKKyNkZWZpbmUgc21wX2NvbmRfbG9hZF9yZWxheGVkKHB0ciwgY29uZF9leHByKQkJCQlcCiso ewkJCQkJCQkJCVwKKwl0eXBlb2YocHRyKSBfX1BUUiA9IChwdHIpOwkJCQkJXAorCV9fdW5xdWFs X3NjYWxhcl90eXBlb2YoKnB0cikgVkFMOwkJCQlcCisJCQkJCQkJCQlcCisJVkFMID0gUkVBRF9P TkNFKCpfX1BUUik7CQkJCQlcCisJaWYgKCFjb25kX2V4cHIpIHsJCQkJCQlcCisJCWZvciAoOzsp IHsJCQkJCQlcCisJCQlWQUwgPSBfX3NtcF9sb2FkX3Jlc2VydmVkX3JlbGF4ZWQoX19QVFIpOwlc CisJCQlpZiAoY29uZF9leHByKQkJCQkJXAorCQkJCWJyZWFrOwkJCQkJXAorCQkJQUxUX1dSU19T VE8oKTsJCQkJCVwKKwkJfQkJCQkJCQlcCisJfQkJCQkJCQkJXAorCSh0eXBlb2YoKnB0cikpVkFM OwkJCQkJCVwKK30pCisKKyNkZWZpbmUgc21wX2NvbmRfbG9hZF9hY3F1aXJlKHB0ciwgY29uZF9l eHByKQkJCQlcCisoewkJCQkJCQkJCVwKKwl0eXBlb2YocHRyKSBfX1BUUiA9IChwdHIpOwkJCQkJ XAorCV9fdW5xdWFsX3NjYWxhcl90eXBlb2YoKnB0cikgVkFMOwkJCQlcCisJCQkJCQkJCQlcCisJ VkFMID0gc21wX2xvYWRfYWNxdWlyZShfX1BUUik7CQkJCQlcCisJaWYgKCFjb25kX2V4cHIpIHsJ CQkJCQlcCisJCWZvciAoOzspIHsJCQkJCQlcCisJCQlWQUwgPSBfX3NtcF9sb2FkX3Jlc2VydmVk X2FjcXVpcmUoX19QVFIpOwlcCisJCQlpZiAoY29uZF9leHByKQkJCQkJXAorCQkJCWJyZWFrOwkJ CQkJXAorCQkJQUxUX1dSU19TVE8oKTsJCQkJCVwKKwkJfQkJCQkJCQlcCisJfQkJCQkJCQkJXAor CSh0eXBlb2YoKnB0cikpVkFMOwkJCQkJCVwKK30pCisKICNpbmNsdWRlIDxhc20tZ2VuZXJpYy9i YXJyaWVyLmg+CiAKICNlbmRpZiAvKiBfX0FTU0VNQkxZX18gKi8KZGlmZiAtLWdpdCBhL2FyY2gv cmlzY3YvaW5jbHVkZS9hc20vaHdjYXAuaCBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vaHdjYXAu aAppbmRleCAxZjJkMjU5OWM2NTUuLmVhYzcyMTRhNGJkMCAxMDA2NDQKLS0tIGEvYXJjaC9yaXNj di9pbmNsdWRlL2FzbS9od2NhcC5oCisrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vaHdjYXAu aApAQCAtODAsNiArODAsNyBAQAogI2RlZmluZSBSSVNDVl9JU0FfRVhUX1pGQQkJNzEKICNkZWZp bmUgUklTQ1ZfSVNBX0VYVF9aVFNPCQk3MgogI2RlZmluZSBSSVNDVl9JU0FfRVhUX1pBQ0FTCQk3 MworI2RlZmluZSBSSVNDVl9JU0FfRVhUX1pBV1JTCQk3NAogCiAjZGVmaW5lIFJJU0NWX0lTQV9F WFRfWExJTlVYRU5WQ0ZHCTEyNwogCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9jcHVm ZWF0dXJlLmMgYi9hcmNoL3Jpc2N2L2tlcm5lbC9jcHVmZWF0dXJlLmMKaW5kZXggNzlhNWEzNWZh Yjk2Li4wZTNjNzkwOTRiMDcgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVsL2NwdWZlYXR1 cmUuYworKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9jcHVmZWF0dXJlLmMKQEAgLTI3MSw2ICsyNzEs NyBAQCBjb25zdCBzdHJ1Y3QgcmlzY3ZfaXNhX2V4dF9kYXRhIHJpc2N2X2lzYV9leHRbXSA9IHsK IAlfX1JJU0NWX0lTQV9FWFRfREFUQSh6aWhpbnRwYXVzZSwgUklTQ1ZfSVNBX0VYVF9aSUhJTlRQ QVVTRSksCiAJX19SSVNDVl9JU0FfRVhUX0RBVEEoemlocG0sIFJJU0NWX0lTQV9FWFRfWklIUE0p LAogCV9fUklTQ1ZfSVNBX0VYVF9EQVRBKHphY2FzLCBSSVNDVl9JU0FfRVhUX1pBQ0FTKSwKKwlf X1JJU0NWX0lTQV9FWFRfREFUQSh6YXdycywgUklTQ1ZfSVNBX0VYVF9aQVdSUyksCiAJX19SSVND Vl9JU0FfRVhUX0RBVEEoemZhLCBSSVNDVl9JU0FfRVhUX1pGQSksCiAJX19SSVNDVl9JU0FfRVhU X0RBVEEoemZoLCBSSVNDVl9JU0FfRVhUX1pGSCksCiAJX19SSVNDVl9JU0FfRVhUX0RBVEEoemZo bWluLCBSSVNDVl9JU0FfRVhUX1pGSE1JTiksCi0tIAoyLjQ0LjAKCgpfX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1yaXNjdiBtYWlsaW5nIGxpc3QK bGludXgtcmlzY3ZAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9y Zy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJpc2N2Cg==