From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from foss.arm.com (foss.arm.com [217.140.110.172]) by smtp.subspace.kernel.org (Postfix) with ESMTP id CEEA612C478; Tue, 16 Apr 2024 13:30:12 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=217.140.110.172 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713274214; cv=none; b=nUS9Pi7/SjeS4yW7Td+an47cUrvAr1Acy4rTqscDODStS4JdnQsgACOlHJmoD7Oqb+pZiCozvo77BERMBqPIi/4AEqZ72nV4NCttaXfjuIQr45/88/+PB++9fqPRmeQMwxPk2u7zVAlr1RDXLWR3I5g+isepctSavlnX0S93gFY= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1713274214; c=relaxed/simple; bh=+j/6gM3a937z2BzVy5L+xPXIwJaTO68RZyd2qEEbv9U=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=n0Y/tHmHx1XNTMJlCoA8YgmE//vFesQZZEOMMqYF630YX1O3fpYNalW9STbE1UkQyShJcszm6cl3oUrgkovIAgP4DFlXCu0yzBT3ItZ/3AZ9zwP/fR0cvEnvOncBJfVNm1FqFTt/35laDbCO6kRt42/lrdhMCc++ayMmc+mRebg= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com; spf=pass smtp.mailfrom=arm.com; arc=none smtp.client-ip=217.140.110.172 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=arm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=arm.com Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 68DE4339; Tue, 16 Apr 2024 06:30:40 -0700 (PDT) Received: from [10.1.197.1] (ewhatever.cambridge.arm.com [10.1.197.1]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 1EB303F738; Tue, 16 Apr 2024 06:30:07 -0700 (PDT) Message-ID: <37fa1ff5-9e94-4def-afd6-fb9ea9356977@arm.com> Date: Tue, 16 Apr 2024 14:30:04 +0100 Precedence: bulk X-Mailing-List: linux-coco@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 07/43] arm64: RME: Check for RME support at KVM init To: Steven Price , kvm@vger.kernel.org, kvmarm@lists.linux.dev Cc: Catalin Marinas , Marc Zyngier , Will Deacon , James Morse , Oliver Upton , Zenghui Yu , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Joey Gouly , Alexandru Elisei , Christoffer Dall , Fuad Tabba , linux-coco@lists.linux.dev, Ganapatrao Kulkarni References: <20240412084056.1733704-1-steven.price@arm.com> <20240412084309.1733783-1-steven.price@arm.com> <20240412084309.1733783-8-steven.price@arm.com> Content-Language: en-US From: Suzuki K Poulose In-Reply-To: <20240412084309.1733783-8-steven.price@arm.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Hi Steven On 12/04/2024 09:42, Steven Price wrote: > Query the RMI version number and check if it is a compatible version. A > static key is also provided to signal that a supported RMM is available. > > Functions are provided to query if a VM or VCPU is a realm (or rec) > which currently will always return false. > > Signed-off-by: Steven Price > --- > arch/arm64/include/asm/kvm_emulate.h | 18 +++++++++ > arch/arm64/include/asm/kvm_host.h | 4 ++ > arch/arm64/include/asm/kvm_rme.h | 56 ++++++++++++++++++++++++++++ > arch/arm64/include/asm/virt.h | 1 + > arch/arm64/kvm/Makefile | 3 +- > arch/arm64/kvm/arm.c | 9 +++++ > arch/arm64/kvm/rme.c | 52 ++++++++++++++++++++++++++ > 7 files changed, 142 insertions(+), 1 deletion(-) > create mode 100644 arch/arm64/include/asm/kvm_rme.h > create mode 100644 arch/arm64/kvm/rme.c > > diff --git a/arch/arm64/include/asm/kvm_emulate.h b/arch/arm64/include/asm/kvm_emulate.h > index 975af30af31f..6f08398537e2 100644 > --- a/arch/arm64/include/asm/kvm_emulate.h > +++ b/arch/arm64/include/asm/kvm_emulate.h > @@ -611,4 +611,22 @@ static __always_inline void kvm_reset_cptr_el2(struct kvm_vcpu *vcpu) > > kvm_write_cptr_el2(val); > } > + > +static inline bool kvm_is_realm(struct kvm *kvm) > +{ > + if (static_branch_unlikely(&kvm_rme_is_available)) > + return kvm->arch.is_realm; > + return false; > +} > + > +static inline enum realm_state kvm_realm_state(struct kvm *kvm) > +{ > + return READ_ONCE(kvm->arch.realm.state); > +} > + > +static inline bool vcpu_is_rec(struct kvm_vcpu *vcpu) > +{ > + return false; > +} > + > #endif /* __ARM64_KVM_EMULATE_H__ */ > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h > index 9e8a496fb284..63b68b85db3f 100644 > --- a/arch/arm64/include/asm/kvm_host.h > +++ b/arch/arm64/include/asm/kvm_host.h > @@ -27,6 +27,7 @@ > #include > #include > #include > +#include > #include > > #define __KVM_HAVE_ARCH_INTC_INITIALIZED > @@ -348,6 +349,9 @@ struct kvm_arch { > * the associated pKVM instance in the hypervisor. > */ > struct kvm_protected_vm pkvm; > + > + bool is_realm; > + struct realm realm; > }; > > struct kvm_vcpu_fault_info { > diff --git a/arch/arm64/include/asm/kvm_rme.h b/arch/arm64/include/asm/kvm_rme.h > new file mode 100644 > index 000000000000..922da3f47227 > --- /dev/null > +++ b/arch/arm64/include/asm/kvm_rme.h > @@ -0,0 +1,56 @@ > +/* SPDX-License-Identifier: GPL-2.0 */ > +/* > + * Copyright (C) 2023 ARM Ltd. > + */ > + > +#ifndef __ASM_KVM_RME_H > +#define __ASM_KVM_RME_H > + > +/** > + * enum realm_state - State of a Realm > + */ > +enum realm_state { > + /** > + * @REALM_STATE_NONE: > + * Realm has not yet been created. rmi_realm_create() may be > + * called to create the realm. > + */ > + REALM_STATE_NONE, > + /** > + * @REALM_STATE_NEW: > + * Realm is under construction, not eligible for execution. Pages > + * may be populated with rmi_data_create(). > + */ > + REALM_STATE_NEW, > + /** > + * @REALM_STATE_ACTIVE: > + * Realm has been created and is eligible for execution with > + * rmi_rec_enter(). Pages may no longer be populated with > + * rmi_data_create(). > + */ > + REALM_STATE_ACTIVE, > + /** > + * @REALM_STATE_DYING: > + * Realm is in the process of being destroyed or has already been > + * destroyed. > + */ > + REALM_STATE_DYING, > + /** > + * @REALM_STATE_DEAD: > + * Realm has been destroyed. > + */ > + REALM_STATE_DEAD > +}; > + > +/** > + * struct realm - Additional per VM data for a Realm > + * > + * @state: The lifetime state machine for the realm > + */ > +struct realm { > + enum realm_state state; > +}; > + > +int kvm_init_rme(void); > + > +#endif > diff --git a/arch/arm64/include/asm/virt.h b/arch/arm64/include/asm/virt.h > index 261d6e9df2e1..12cf36c38189 100644 > --- a/arch/arm64/include/asm/virt.h > +++ b/arch/arm64/include/asm/virt.h > @@ -81,6 +81,7 @@ void __hyp_reset_vectors(void); > bool is_kvm_arm_initialised(void); > > DECLARE_STATIC_KEY_FALSE(kvm_protected_mode_initialized); > +DECLARE_STATIC_KEY_FALSE(kvm_rme_is_available); > > /* Reports the availability of HYP mode */ > static inline bool is_hyp_mode_available(void) > diff --git a/arch/arm64/kvm/Makefile b/arch/arm64/kvm/Makefile > index c0c050e53157..1c1d8cdf381f 100644 > --- a/arch/arm64/kvm/Makefile > +++ b/arch/arm64/kvm/Makefile > @@ -20,7 +20,8 @@ kvm-y += arm.o mmu.o mmio.o psci.o hypercalls.o pvtime.o \ > vgic/vgic-v3.o vgic/vgic-v4.o \ > vgic/vgic-mmio.o vgic/vgic-mmio-v2.o \ > vgic/vgic-mmio-v3.o vgic/vgic-kvm-device.o \ > - vgic/vgic-its.o vgic/vgic-debug.o > + vgic/vgic-its.o vgic/vgic-debug.o \ > + rme.o > > kvm-$(CONFIG_HW_PERF_EVENTS) += pmu-emul.o pmu.o > > diff --git a/arch/arm64/kvm/arm.c b/arch/arm64/kvm/arm.c > index 3dee5490eea9..2056c660c5ee 100644 > --- a/arch/arm64/kvm/arm.c > +++ b/arch/arm64/kvm/arm.c > @@ -38,6 +38,7 @@ > #include > #include > #include > +#include > #include > #include > > @@ -47,6 +48,8 @@ > > static enum kvm_mode kvm_mode = KVM_MODE_DEFAULT; > > +DEFINE_STATIC_KEY_FALSE(kvm_rme_is_available); > + > DECLARE_KVM_HYP_PER_CPU(unsigned long, kvm_hyp_vector); > > DEFINE_PER_CPU(unsigned long, kvm_arm_hyp_stack_page); > @@ -2562,6 +2565,12 @@ static __init int kvm_arm_init(void) > > in_hyp_mode = is_kernel_in_hyp_mode(); > > + if (in_hyp_mode) { > + err = kvm_init_rme(); > + if (err) > + return err; > + } > + > if (cpus_have_final_cap(ARM64_WORKAROUND_DEVICE_LOAD_ACQUIRE) || > cpus_have_final_cap(ARM64_WORKAROUND_1508412)) > kvm_info("Guests without required CPU erratum workarounds can deadlock system!\n" \ > diff --git a/arch/arm64/kvm/rme.c b/arch/arm64/kvm/rme.c > new file mode 100644 > index 000000000000..3dbbf9d046bf > --- /dev/null > +++ b/arch/arm64/kvm/rme.c > @@ -0,0 +1,52 @@ > +// SPDX-License-Identifier: GPL-2.0 > +/* > + * Copyright (C) 2023 ARM Ltd. > + */ > + > +#include > + > +#include > +#include > + > +static int rmi_check_version(void) > +{ > + struct arm_smccc_res res; > + int version_major, version_minor; > + unsigned long host_version = RMI_ABI_VERSION(RMI_ABI_MAJOR_VERSION, > + RMI_ABI_MINOR_VERSION); > + > + arm_smccc_1_1_invoke(SMC_RMI_VERSION, host_version, &res); > + > + if (res.a0 == SMCCC_RET_NOT_SUPPORTED) > + return -ENXIO; > + > + version_major = RMI_ABI_VERSION_GET_MAJOR(res.a1); > + version_minor = RMI_ABI_VERSION_GET_MINOR(res.a1); > + We don't seem to be using the res.a0 to determin if the RMM supports our requested version. As per RMM spec, section B4.3.23 : " The status code and lower revision output values indicate which of the following is true, in order of precedence: a) The RMM supports an interface revision which is compatible with the requested revision. • The status code is RMI_SUCCESS. • The lower revision is equal to the requested revision. b) The RMM does not support an interface revision which is compatible with the requested revision The RMM supports an interface revision which is incompatible with and less than the requested revision. • The status code is RMI_ERROR_INPUT. • The lower revision is the highest interface revision which is both less than the requested revision and supported by the RMM. c) The RMM does not support an interface revision which is compatible with the requested revision The RMM supports an interface revision which is incompatible with and greater than the requested revision. • The status code is RMI_ERROR_INPUT. • The lower revision is equal to the higher revision. So, we could simply check the res.a0 for RMI_SUCCESS and proceed with marking RMM available. > + if (version_major != RMI_ABI_MAJOR_VERSION) { > + kvm_err("Unsupported RMI ABI (v%d.%d) host supports v%d.%d\n", > + version_major, version_minor, > + RMI_ABI_MAJOR_VERSION, > + RMI_ABI_MINOR_VERSION); > + return -ENXIO; > + } > + > + kvm_info("RMI ABI version %d.%d\n", version_major, version_minor); > + > + return 0; > +} > + > +int kvm_init_rme(void) > +{ > + if (PAGE_SIZE != SZ_4K) > + /* Only 4k page size on the host is supported */ > + return 0; > + > + if (rmi_check_version()) > + /* Continue without realm support */ > + return 0; > + > + /* Future patch will enable static branch kvm_rme_is_available */ > + > + return 0; Do we ever expect this to fail the kvm initialisation ? Otherwise, we could leave it as a void ? Suzuki > +} 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 D44BBC4345F for ; Tue, 16 Apr 2024 13:30:29 +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-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:Cc:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=PTteN5A14vbATztNRq5ZTMVnons8ll+3ItahN43tLdM=; b=poyk6eukn2wOA7 wVhwzPibDKZu4Mc04i9NwwaSCu8wUszCtWZTk/YgnxoDuxJkXKWVpgMzBORKYjVNzBtnKtlEEMEs0 q5ROCy5cB4MH2C51oDS/TZ4VH5L9bOqFc6jlnWYGxXzZaRem84C0T87IdX5dz0xJ+eQdFwpbT6uq6 XZ+OIIHSXeuKbuW3cyrymtLdIbvOWyJ8Cuk4JGwCyYG0ISqG8KM+BdCAFLm/g1th/Wa+zRhP32Bhs bIaye6+PtbPvpDbi0rzae0GD0iPkADwm9loPGzkoUUwDPtzDjJpWB+ROa23aIFf/Yih5p6c3L0dXc z+CsnCUbt0wUZiUKMFyQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rwit6-0000000CJHJ-1Ey8; Tue, 16 Apr 2024 13:30:16 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1rwit3-0000000CJG2-1iEK for linux-arm-kernel@lists.infradead.org; Tue, 16 Apr 2024 13:30:14 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 68DE4339; Tue, 16 Apr 2024 06:30:40 -0700 (PDT) Received: from [10.1.197.1] (ewhatever.cambridge.arm.com [10.1.197.1]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 1EB303F738; Tue, 16 Apr 2024 06:30:07 -0700 (PDT) Message-ID: <37fa1ff5-9e94-4def-afd6-fb9ea9356977@arm.com> Date: Tue, 16 Apr 2024 14:30:04 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH v2 07/43] arm64: RME: Check for RME support at KVM init To: Steven Price , kvm@vger.kernel.org, kvmarm@lists.linux.dev Cc: Catalin Marinas , Marc Zyngier , Will Deacon , James Morse , Oliver Upton , Zenghui Yu , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, Joey Gouly , Alexandru Elisei , Christoffer Dall , Fuad Tabba , linux-coco@lists.linux.dev, Ganapatrao Kulkarni References: <20240412084056.1733704-1-steven.price@arm.com> <20240412084309.1733783-1-steven.price@arm.com> <20240412084309.1733783-8-steven.price@arm.com> Content-Language: en-US From: Suzuki K Poulose In-Reply-To: <20240412084309.1733783-8-steven.price@arm.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240416_063013_566966_55434270 X-CRM114-Status: GOOD ( 34.30 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgU3RldmVuCgpPbiAxMi8wNC8yMDI0IDA5OjQyLCBTdGV2ZW4gUHJpY2Ugd3JvdGU6Cj4gUXVl cnkgdGhlIFJNSSB2ZXJzaW9uIG51bWJlciBhbmQgY2hlY2sgaWYgaXQgaXMgYSBjb21wYXRpYmxl IHZlcnNpb24uIEEKPiBzdGF0aWMga2V5IGlzIGFsc28gcHJvdmlkZWQgdG8gc2lnbmFsIHRoYXQg YSBzdXBwb3J0ZWQgUk1NIGlzIGF2YWlsYWJsZS4KPiAKPiBGdW5jdGlvbnMgYXJlIHByb3ZpZGVk IHRvIHF1ZXJ5IGlmIGEgVk0gb3IgVkNQVSBpcyBhIHJlYWxtIChvciByZWMpCj4gd2hpY2ggY3Vy cmVudGx5IHdpbGwgYWx3YXlzIHJldHVybiBmYWxzZS4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBTdGV2 ZW4gUHJpY2UgPHN0ZXZlbi5wcmljZUBhcm0uY29tPgo+IC0tLQo+ICAgYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1fZW11bGF0ZS5oIHwgMTggKysrKysrKysrCj4gICBhcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmggICAgfCAgNCArKwo+ICAgYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9r dm1fcm1lLmggICAgIHwgNTYgKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAgYXJjaC9h cm02NC9pbmNsdWRlL2FzbS92aXJ0LmggICAgICAgIHwgIDEgKwo+ICAgYXJjaC9hcm02NC9rdm0v TWFrZWZpbGUgICAgICAgICAgICAgIHwgIDMgKy0KPiAgIGFyY2gvYXJtNjQva3ZtL2FybS5jICAg ICAgICAgICAgICAgICB8ICA5ICsrKysrCj4gICBhcmNoL2FybTY0L2t2bS9ybWUuYyAgICAgICAg ICAgICAgICAgfCA1MiArKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICAgNyBmaWxlcyBjaGFu Z2VkLCAxNDIgaW5zZXJ0aW9ucygrKSwgMSBkZWxldGlvbigtKQo+ICAgY3JlYXRlIG1vZGUgMTAw NjQ0IGFyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX3JtZS5oCj4gICBjcmVhdGUgbW9kZSAxMDA2 NDQgYXJjaC9hcm02NC9rdm0vcm1lLmMKPiAKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1fZW11bGF0ZS5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fZW11bGF0 ZS5oCj4gaW5kZXggOTc1YWYzMGFmMzFmLi42ZjA4Mzk4NTM3ZTIgMTAwNjQ0Cj4gLS0tIGEvYXJj aC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fZW11bGF0ZS5oCj4gKysrIGIvYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1fZW11bGF0ZS5oCj4gQEAgLTYxMSw0ICs2MTEsMjIgQEAgc3RhdGljIF9fYWx3 YXlzX2lubGluZSB2b2lkIGt2bV9yZXNldF9jcHRyX2VsMihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUp Cj4gICAKPiAgIAlrdm1fd3JpdGVfY3B0cl9lbDIodmFsKTsKPiAgIH0KPiArCj4gK3N0YXRpYyBp bmxpbmUgYm9vbCBrdm1faXNfcmVhbG0oc3RydWN0IGt2bSAqa3ZtKQo+ICt7Cj4gKwlpZiAoc3Rh dGljX2JyYW5jaF91bmxpa2VseSgma3ZtX3JtZV9pc19hdmFpbGFibGUpKQo+ICsJCXJldHVybiBr dm0tPmFyY2guaXNfcmVhbG07Cj4gKwlyZXR1cm4gZmFsc2U7Cj4gK30KPiArCj4gK3N0YXRpYyBp bmxpbmUgZW51bSByZWFsbV9zdGF0ZSBrdm1fcmVhbG1fc3RhdGUoc3RydWN0IGt2bSAqa3ZtKQo+ ICt7Cj4gKwlyZXR1cm4gUkVBRF9PTkNFKGt2bS0+YXJjaC5yZWFsbS5zdGF0ZSk7Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbmxpbmUgYm9vbCB2Y3B1X2lzX3JlYyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUp Cj4gK3sKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiAgICNlbmRpZiAvKiBfX0FSTTY0X0tW TV9FTVVMQVRFX0hfXyAqLwo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2 bV9ob3N0LmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiBpbmRleCA5ZThh NDk2ZmIyODQuLjYzYjY4Yjg1ZGIzZiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUv YXNtL2t2bV9ob3N0LmgKPiArKysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgK PiBAQCAtMjcsNiArMjcsNyBAQAo+ICAgI2luY2x1ZGUgPGFzbS9mcHNpbWQuaD4KPiAgICNpbmNs dWRlIDxhc20va3ZtLmg+Cj4gICAjaW5jbHVkZSA8YXNtL2t2bV9hc20uaD4KPiArI2luY2x1ZGUg PGFzbS9rdm1fcm1lLmg+Cj4gICAjaW5jbHVkZSA8YXNtL3ZuY3JfbWFwcGluZy5oPgo+ICAgCj4g ICAjZGVmaW5lIF9fS1ZNX0hBVkVfQVJDSF9JTlRDX0lOSVRJQUxJWkVECj4gQEAgLTM0OCw2ICsz NDksOSBAQCBzdHJ1Y3Qga3ZtX2FyY2ggewo+ICAgCSAqIHRoZSBhc3NvY2lhdGVkIHBLVk0gaW5z dGFuY2UgaW4gdGhlIGh5cGVydmlzb3IuCj4gICAJICovCj4gICAJc3RydWN0IGt2bV9wcm90ZWN0 ZWRfdm0gcGt2bTsKPiArCj4gKwlib29sIGlzX3JlYWxtOwo+ICsJc3RydWN0IHJlYWxtIHJlYWxt Owo+ICAgfTsKPiAgIAo+ICAgc3RydWN0IGt2bV92Y3B1X2ZhdWx0X2luZm8gewo+IGRpZmYgLS1n aXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ybWUuaCBiL2FyY2gvYXJtNjQvaW5jbHVk ZS9hc20va3ZtX3JtZS5oCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAw MDAuLjkyMmRhM2Y0NzIyNwo+IC0tLSAvZGV2L251bGwKPiArKysgYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ybWUuaAo+IEBAIC0wLDAgKzEsNTYgQEAKPiArLyogU1BEWC1MaWNlbnNlLUlk ZW50aWZpZXI6IEdQTC0yLjAgKi8KPiArLyoKPiArICogQ29weXJpZ2h0IChDKSAyMDIzIEFSTSBM dGQuCj4gKyAqLwo+ICsKPiArI2lmbmRlZiBfX0FTTV9LVk1fUk1FX0gKPiArI2RlZmluZSBfX0FT TV9LVk1fUk1FX0gKPiArCj4gKy8qKgo+ICsgKiBlbnVtIHJlYWxtX3N0YXRlIC0gU3RhdGUgb2Yg YSBSZWFsbQo+ICsgKi8KPiArZW51bSByZWFsbV9zdGF0ZSB7Cj4gKwkvKioKPiArCSAqIEBSRUFM TV9TVEFURV9OT05FOgo+ICsJICogICAgICBSZWFsbSBoYXMgbm90IHlldCBiZWVuIGNyZWF0ZWQu IHJtaV9yZWFsbV9jcmVhdGUoKSBtYXkgYmUKPiArCSAqICAgICAgY2FsbGVkIHRvIGNyZWF0ZSB0 aGUgcmVhbG0uCj4gKwkgKi8KPiArCVJFQUxNX1NUQVRFX05PTkUsCj4gKwkvKioKPiArCSAqIEBS RUFMTV9TVEFURV9ORVc6Cj4gKwkgKiAgICAgIFJlYWxtIGlzIHVuZGVyIGNvbnN0cnVjdGlvbiwg bm90IGVsaWdpYmxlIGZvciBleGVjdXRpb24uIFBhZ2VzCj4gKwkgKiAgICAgIG1heSBiZSBwb3B1 bGF0ZWQgd2l0aCBybWlfZGF0YV9jcmVhdGUoKS4KPiArCSAqLwo+ICsJUkVBTE1fU1RBVEVfTkVX LAo+ICsJLyoqCj4gKwkgKiBAUkVBTE1fU1RBVEVfQUNUSVZFOgo+ICsJICogICAgICBSZWFsbSBo YXMgYmVlbiBjcmVhdGVkIGFuZCBpcyBlbGlnaWJsZSBmb3IgZXhlY3V0aW9uIHdpdGgKPiArCSAq ICAgICAgcm1pX3JlY19lbnRlcigpLiBQYWdlcyBtYXkgbm8gbG9uZ2VyIGJlIHBvcHVsYXRlZCB3 aXRoCj4gKwkgKiAgICAgIHJtaV9kYXRhX2NyZWF0ZSgpLgo+ICsJICovCj4gKwlSRUFMTV9TVEFU RV9BQ1RJVkUsCj4gKwkvKioKPiArCSAqIEBSRUFMTV9TVEFURV9EWUlORzoKPiArCSAqICAgICAg UmVhbG0gaXMgaW4gdGhlIHByb2Nlc3Mgb2YgYmVpbmcgZGVzdHJveWVkIG9yIGhhcyBhbHJlYWR5 IGJlZW4KPiArCSAqICAgICAgZGVzdHJveWVkLgo+ICsJICovCj4gKwlSRUFMTV9TVEFURV9EWUlO RywKPiArCS8qKgo+ICsJICogQFJFQUxNX1NUQVRFX0RFQUQ6Cj4gKwkgKiAgICAgIFJlYWxtIGhh cyBiZWVuIGRlc3Ryb3llZC4KPiArCSAqLwo+ICsJUkVBTE1fU1RBVEVfREVBRAo+ICt9Owo+ICsK PiArLyoqCj4gKyAqIHN0cnVjdCByZWFsbSAtIEFkZGl0aW9uYWwgcGVyIFZNIGRhdGEgZm9yIGEg UmVhbG0KPiArICoKPiArICogQHN0YXRlOiBUaGUgbGlmZXRpbWUgc3RhdGUgbWFjaGluZSBmb3Ig dGhlIHJlYWxtCj4gKyAqLwo+ICtzdHJ1Y3QgcmVhbG0gewo+ICsJZW51bSByZWFsbV9zdGF0ZSBz dGF0ZTsKPiArfTsKPiArCj4gK2ludCBrdm1faW5pdF9ybWUodm9pZCk7Cj4gKwo+ICsjZW5kaWYK PiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS92aXJ0LmggYi9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL3ZpcnQuaAo+IGluZGV4IDI2MWQ2ZTlkZjJlMS4uMTJjZjM2YzM4MTg5IDEw MDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vdmlydC5oCj4gKysrIGIvYXJjaC9h cm02NC9pbmNsdWRlL2FzbS92aXJ0LmgKPiBAQCAtODEsNiArODEsNyBAQCB2b2lkIF9faHlwX3Jl c2V0X3ZlY3RvcnModm9pZCk7Cj4gICBib29sIGlzX2t2bV9hcm1faW5pdGlhbGlzZWQodm9pZCk7 Cj4gICAKPiAgIERFQ0xBUkVfU1RBVElDX0tFWV9GQUxTRShrdm1fcHJvdGVjdGVkX21vZGVfaW5p dGlhbGl6ZWQpOwo+ICtERUNMQVJFX1NUQVRJQ19LRVlfRkFMU0Uoa3ZtX3JtZV9pc19hdmFpbGFi bGUpOwo+ICAgCj4gICAvKiBSZXBvcnRzIHRoZSBhdmFpbGFiaWxpdHkgb2YgSFlQIG1vZGUgKi8K PiAgIHN0YXRpYyBpbmxpbmUgYm9vbCBpc19oeXBfbW9kZV9hdmFpbGFibGUodm9pZCkKPiBkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vTWFrZWZpbGUgYi9hcmNoL2FybTY0L2t2bS9NYWtlZmls ZQo+IGluZGV4IGMwYzA1MGU1MzE1Ny4uMWMxZDhjZGYzODFmIDEwMDY0NAo+IC0tLSBhL2FyY2gv YXJtNjQva3ZtL01ha2VmaWxlCj4gKysrIGIvYXJjaC9hcm02NC9rdm0vTWFrZWZpbGUKPiBAQCAt MjAsNyArMjAsOCBAQCBrdm0teSArPSBhcm0ubyBtbXUubyBtbWlvLm8gcHNjaS5vIGh5cGVyY2Fs bHMubyBwdnRpbWUubyBcCj4gICAJIHZnaWMvdmdpYy12My5vIHZnaWMvdmdpYy12NC5vIFwKPiAg IAkgdmdpYy92Z2ljLW1taW8ubyB2Z2ljL3ZnaWMtbW1pby12Mi5vIFwKPiAgIAkgdmdpYy92Z2lj LW1taW8tdjMubyB2Z2ljL3ZnaWMta3ZtLWRldmljZS5vIFwKPiAtCSB2Z2ljL3ZnaWMtaXRzLm8g dmdpYy92Z2ljLWRlYnVnLm8KPiArCSB2Z2ljL3ZnaWMtaXRzLm8gdmdpYy92Z2ljLWRlYnVnLm8g XAo+ICsJIHJtZS5vCj4gICAKPiAgIGt2bS0kKENPTkZJR19IV19QRVJGX0VWRU5UUykgICs9IHBt dS1lbXVsLm8gcG11Lm8KPiAgIAo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9hcm0uYyBi L2FyY2gvYXJtNjQva3ZtL2FybS5jCj4gaW5kZXggM2RlZTU0OTBlZWE5Li4yMDU2YzY2MGM1ZWUg MTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02NC9rdm0vYXJtLmMKPiArKysgYi9hcmNoL2FybTY0L2t2 bS9hcm0uYwo+IEBAIC0zOCw2ICszOCw3IEBACj4gICAjaW5jbHVkZSA8YXNtL2t2bV9tbXUuaD4K PiAgICNpbmNsdWRlIDxhc20va3ZtX25lc3RlZC5oPgo+ICAgI2luY2x1ZGUgPGFzbS9rdm1fcGt2 bS5oPgo+ICsjaW5jbHVkZSA8YXNtL2t2bV9ybWUuaD4KPiAgICNpbmNsdWRlIDxhc20va3ZtX2Vt dWxhdGUuaD4KPiAgICNpbmNsdWRlIDxhc20vc2VjdGlvbnMuaD4KPiAgIAo+IEBAIC00Nyw2ICs0 OCw4IEBACj4gICAKPiAgIHN0YXRpYyBlbnVtIGt2bV9tb2RlIGt2bV9tb2RlID0gS1ZNX01PREVf REVGQVVMVDsKPiAgIAo+ICtERUZJTkVfU1RBVElDX0tFWV9GQUxTRShrdm1fcm1lX2lzX2F2YWls YWJsZSk7Cj4gKwo+ICAgREVDTEFSRV9LVk1fSFlQX1BFUl9DUFUodW5zaWduZWQgbG9uZywga3Zt X2h5cF92ZWN0b3IpOwo+ICAgCj4gICBERUZJTkVfUEVSX0NQVSh1bnNpZ25lZCBsb25nLCBrdm1f YXJtX2h5cF9zdGFja19wYWdlKTsKPiBAQCAtMjU2Miw2ICsyNTY1LDEyIEBAIHN0YXRpYyBfX2lu aXQgaW50IGt2bV9hcm1faW5pdCh2b2lkKQo+ICAgCj4gICAJaW5faHlwX21vZGUgPSBpc19rZXJu ZWxfaW5faHlwX21vZGUoKTsKPiAgIAo+ICsJaWYgKGluX2h5cF9tb2RlKSB7Cj4gKwkJZXJyID0g a3ZtX2luaXRfcm1lKCk7Cj4gKwkJaWYgKGVycikKPiArCQkJcmV0dXJuIGVycjsKPiArCX0KPiAr Cj4gICAJaWYgKGNwdXNfaGF2ZV9maW5hbF9jYXAoQVJNNjRfV09SS0FST1VORF9ERVZJQ0VfTE9B RF9BQ1FVSVJFKSB8fAo+ICAgCSAgICBjcHVzX2hhdmVfZmluYWxfY2FwKEFSTTY0X1dPUktBUk9V TkRfMTUwODQxMikpCj4gICAJCWt2bV9pbmZvKCJHdWVzdHMgd2l0aG91dCByZXF1aXJlZCBDUFUg ZXJyYXR1bSB3b3JrYXJvdW5kcyBjYW4gZGVhZGxvY2sgc3lzdGVtIVxuIiBcCj4gZGlmZiAtLWdp dCBhL2FyY2gvYXJtNjQva3ZtL3JtZS5jIGIvYXJjaC9hcm02NC9rdm0vcm1lLmMKPiBuZXcgZmls ZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uM2RiYmY5ZDA0NmJmCj4gLS0tIC9k ZXYvbnVsbAo+ICsrKyBiL2FyY2gvYXJtNjQva3ZtL3JtZS5jCj4gQEAgLTAsMCArMSw1MiBAQAo+ ICsvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICsvKgo+ICsgKiBDb3B5cmln aHQgKEMpIDIwMjMgQVJNIEx0ZC4KPiArICovCj4gKwo+ICsjaW5jbHVkZSA8bGludXgva3ZtX2hv c3QuaD4KPiArCj4gKyNpbmNsdWRlIDxhc20vcm1pX2NtZHMuaD4KPiArI2luY2x1ZGUgPGFzbS92 aXJ0Lmg+Cj4gKwo+ICtzdGF0aWMgaW50IHJtaV9jaGVja192ZXJzaW9uKHZvaWQpCj4gK3sKPiAr CXN0cnVjdCBhcm1fc21jY2NfcmVzIHJlczsKPiArCWludCB2ZXJzaW9uX21ham9yLCB2ZXJzaW9u X21pbm9yOwo+ICsJdW5zaWduZWQgbG9uZyBob3N0X3ZlcnNpb24gPSBSTUlfQUJJX1ZFUlNJT04o Uk1JX0FCSV9NQUpPUl9WRVJTSU9OLAo+ICsJCQkJCQkgICAgIFJNSV9BQklfTUlOT1JfVkVSU0lP Tik7Cj4gKwo+ICsJYXJtX3NtY2NjXzFfMV9pbnZva2UoU01DX1JNSV9WRVJTSU9OLCBob3N0X3Zl cnNpb24sICZyZXMpOwo+ICsKPiArCWlmIChyZXMuYTAgPT0gU01DQ0NfUkVUX05PVF9TVVBQT1JU RUQpCj4gKwkJcmV0dXJuIC1FTlhJTzsKPiArCj4gKwl2ZXJzaW9uX21ham9yID0gUk1JX0FCSV9W RVJTSU9OX0dFVF9NQUpPUihyZXMuYTEpOwo+ICsJdmVyc2lvbl9taW5vciA9IFJNSV9BQklfVkVS U0lPTl9HRVRfTUlOT1IocmVzLmExKTsKPiArCgpXZSBkb24ndCBzZWVtIHRvIGJlIHVzaW5nIHRo ZSByZXMuYTAgdG8gZGV0ZXJtaW4gaWYgdGhlIFJNTSBzdXBwb3J0cyBvdXIKcmVxdWVzdGVkIHZl cnNpb24uIEFzIHBlciBSTU0gc3BlYywgc2VjdGlvbiBCNC4zLjIzIDoKCiIKVGhlIHN0YXR1cyBj b2RlIGFuZCBsb3dlciByZXZpc2lvbiBvdXRwdXQgdmFsdWVzIGluZGljYXRlIHdoaWNoIG9mIHRo ZSAKZm9sbG93aW5nIGlzIHRydWUsIGluIG9yZGVyIG9mIHByZWNlZGVuY2U6CiAgYSkgVGhlIFJN TSBzdXBwb3J0cyBhbiBpbnRlcmZhY2UgcmV2aXNpb24gd2hpY2ggaXMgY29tcGF0aWJsZSB3aXRo IHRoZQogICAgIHJlcXVlc3RlZCByZXZpc2lvbi4KICAgICAg4oCiIFRoZSBzdGF0dXMgY29kZSBp cyBSTUlfU1VDQ0VTUy4KICAgICAg4oCiIFRoZSBsb3dlciByZXZpc2lvbiBpcyBlcXVhbCB0byB0 aGUgcmVxdWVzdGVkIHJldmlzaW9uLgogIGIpIFRoZSBSTU0gZG9lcyBub3Qgc3VwcG9ydCBhbiBp bnRlcmZhY2UgcmV2aXNpb24gd2hpY2ggaXMgY29tcGF0aWJsZQogICAgIHdpdGggdGhlIHJlcXVl c3RlZCByZXZpc2lvbiBUaGUgUk1NIHN1cHBvcnRzIGFuIGludGVyZmFjZSByZXZpc2lvbgogICAg IHdoaWNoIGlzIGluY29tcGF0aWJsZSB3aXRoIGFuZCBsZXNzIHRoYW4gdGhlIHJlcXVlc3RlZCBy ZXZpc2lvbi4KICAgICAg4oCiIFRoZSBzdGF0dXMgY29kZSBpcyBSTUlfRVJST1JfSU5QVVQuCiAg ICAgIOKAoiBUaGUgbG93ZXIgcmV2aXNpb24gaXMgdGhlIGhpZ2hlc3QgaW50ZXJmYWNlIHJldmlz aW9uIHdoaWNoIGlzCiAgICAgICAgYm90aCBsZXNzIHRoYW4gdGhlIHJlcXVlc3RlZCByZXZpc2lv biBhbmQgc3VwcG9ydGVkIGJ5IHRoZSBSTU0uCgogIGMpIFRoZSBSTU0gZG9lcyBub3Qgc3VwcG9y dCBhbiBpbnRlcmZhY2UgcmV2aXNpb24gd2hpY2ggaXMgY29tcGF0aWJsZQogICAgIHdpdGggdGhl IHJlcXVlc3RlZCByZXZpc2lvbiBUaGUgUk1NIHN1cHBvcnRzIGFuIGludGVyZmFjZSByZXZpc2lv bgogICAgIHdoaWNoIGlzIGluY29tcGF0aWJsZSB3aXRoIGFuZCBncmVhdGVyIHRoYW4gdGhlIHJl cXVlc3RlZCByZXZpc2lvbi4KICAgICAg4oCiIFRoZSBzdGF0dXMgY29kZSBpcyBSTUlfRVJST1Jf SU5QVVQuCiAgICAgIOKAoiBUaGUgbG93ZXIgcmV2aXNpb24gaXMgZXF1YWwgdG8gdGhlIGhpZ2hl ciByZXZpc2lvbi4KClNvLCB3ZSBjb3VsZCBzaW1wbHkgY2hlY2sgdGhlIHJlcy5hMCBmb3IgUk1J X1NVQ0NFU1MgYW5kIHByb2NlZWQgd2l0aAptYXJraW5nIFJNTSBhdmFpbGFibGUuCgoKPiArCWlm ICh2ZXJzaW9uX21ham9yICE9IFJNSV9BQklfTUFKT1JfVkVSU0lPTikgewo+ICsJCWt2bV9lcnIo IlVuc3VwcG9ydGVkIFJNSSBBQkkgKHYlZC4lZCkgaG9zdCBzdXBwb3J0cyB2JWQuJWRcbiIsCj4g KwkJCXZlcnNpb25fbWFqb3IsIHZlcnNpb25fbWlub3IsCj4gKwkJCVJNSV9BQklfTUFKT1JfVkVS U0lPTiwKPiArCQkJUk1JX0FCSV9NSU5PUl9WRVJTSU9OKTsKPiArCQlyZXR1cm4gLUVOWElPOwo+ ICsJfQo+ICsKPiArCWt2bV9pbmZvKCJSTUkgQUJJIHZlcnNpb24gJWQuJWRcbiIsIHZlcnNpb25f bWFqb3IsIHZlcnNpb25fbWlub3IpOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtpbnQg a3ZtX2luaXRfcm1lKHZvaWQpCj4gK3sKPiArCWlmIChQQUdFX1NJWkUgIT0gU1pfNEspCj4gKwkJ LyogT25seSA0ayBwYWdlIHNpemUgb24gdGhlIGhvc3QgaXMgc3VwcG9ydGVkICovCj4gKwkJcmV0 dXJuIDA7Cj4gKwo+ICsJaWYgKHJtaV9jaGVja192ZXJzaW9uKCkpCj4gKwkJLyogQ29udGludWUg d2l0aG91dCByZWFsbSBzdXBwb3J0ICovCj4gKwkJcmV0dXJuIDA7Cj4gKwo+ICsJLyogRnV0dXJl IHBhdGNoIHdpbGwgZW5hYmxlIHN0YXRpYyBicmFuY2gga3ZtX3JtZV9pc19hdmFpbGFibGUgKi8K PiArCj4gKwlyZXR1cm4gMDsKCkRvIHdlIGV2ZXIgZXhwZWN0IHRoaXMgdG8gZmFpbCB0aGUga3Zt IGluaXRpYWxpc2F0aW9uID8gT3RoZXJ3aXNlLCB3ZQpjb3VsZCBsZWF2ZSBpdCBhcyBhIHZvaWQg PwoKU3V6dWtpCj4gK30KCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxp c3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0 aW5mby9saW51eC1hcm0ta2VybmVsCg==