From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 5ECB41E1A2 for ; Thu, 10 Aug 2023 14:44:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0AC5FC433CB; Thu, 10 Aug 2023 14:44:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1691678641; bh=mO3bnIbUtzEnniylSh7RL1DI8oatZ5JEMR3db9B8FcA=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=KsyS4dmNfewUOW0ZozKec2quRtce73f9R/mmJjYTfOrNILlhkl0witKj5ip7xwuUE eyaotSqhazNt5Phrmv+CaRzKvMK1xIUClyaVMb45/a4GGan9rQ3CvJUb/iuC+FUHKT boMdo5L9+4G7j00EzIBhr9m+1DhP8BMc5OFR+q1ceM8q6gnZXfrM4WqKp/XT+IKkvq 5Y1m8V9f7Im3T2fYyjU0jSBjfvksm3bYwnjETayNm6pWh9005xuqKEudxXdkydQOqC UmwqAMDSpWweVFxyUU3I3BfBCGAcekFPImhiEASVaIfKulTOGKTFWiv4iowEqIa0f0 HuIv4L5IGy8FQ== Received: from c-xd4ed8728.customers.hiper-net.dk ([212.237.135.40] helo=wait-a-minute.misterjones.org) by disco-boy.misterjones.org with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.95) (envelope-from ) id 1qU6tK-003r0K-JO; Thu, 10 Aug 2023 15:43:58 +0100 Date: Thu, 10 Aug 2023 15:44:06 +0100 Message-ID: <87ttt7ot3d.wl-maz@kernel.org> From: Marc Zyngier To: eric.auger@redhat.com Cc: kvmarm@lists.linux.dev, kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Catalin Marinas , Mark Brown , Mark Rutland , Will Deacon , Alexandru Elisei , Andre Przywara , Chase Conklin , Ganapatrao Kulkarni , Darren Hart , Miguel Luis , James Morse , Suzuki K Poulose , Oliver Upton , Zenghui Yu Subject: Re: [PATCH v3 14/27] KVM: arm64: nv: Add trap forwarding infrastructure In-Reply-To: <18eae581-500b-9c9e-2cce-e2f5fb007071@redhat.com> References: <20230808114711.2013842-1-maz@kernel.org> <20230808114711.2013842-15-maz@kernel.org> <18eae581-500b-9c9e-2cce-e2f5fb007071@redhat.com> User-Agent: Wanderlust/2.15.9 (Almost Unreal) SEMI-EPG/1.14.7 (Harue) FLIM-LB/1.14.9 (=?UTF-8?B?R29qxY0=?=) APEL-LB/10.8 EasyPG/1.0.0 Emacs/28.2 (x86_64-pc-linux-gnu) MULE/6.0 (HANACHIRUSATO) Precedence: bulk X-Mailing-List: kvmarm@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 (generated by SEMI-EPG 1.14.7 - "Harue") Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable X-SA-Exim-Connect-IP: 212.237.135.40 X-SA-Exim-Rcpt-To: eric.auger@redhat.com, kvmarm@lists.linux.dev, kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, broonie@kernel.org, mark.rutland@arm.com, will@kernel.org, alexandru.elisei@arm.com, andre.przywara@arm.com, chase.conklin@arm.com, gankulkarni@os.amperecomputing.com, darren@os.amperecomputing.com, miguel.luis@oracle.com, james.morse@arm.com, suzuki.poulose@arm.com, oliver.upton@linux.dev, yuzenghui@huawei.com X-SA-Exim-Mail-From: maz@kernel.org X-SA-Exim-Scanned: No (on disco-boy.misterjones.org); SAEximRunCond expanded to false Hi Eric, On Wed, 09 Aug 2023 14:27:27 +0100, Eric Auger wrote: >=20 > Hi Marc, >=20 > On 8/8/23 13:46, Marc Zyngier wrote: > > A significant part of what a NV hypervisor needs to do is to decide > > whether a trap from a L2+ guest has to be forwarded to a L1 guest > > or handled locally. This is done by checking for the trap bits that > > the guest hypervisor has set and acting accordingly, as described by > > the architecture. > > > > A previous approach was to sprinkle a bunch of checks in all the > > system register accessors, but this is pretty error prone and doesn't > > help getting an overview of what is happening. > > > > Instead, implement a set of global tables that describe a trap bit, > > combinations of trap bits, behaviours on trap, and what bits must > > be evaluated on a system register trap. > > > > Although this is painful to describe, this allows to specify each > > and every control bit in a static manner. To make it efficient, > > the table is inserted in an xarray that is global to the system, > > and checked each time we trap a system register while running > > a L2 guest. > > > > Add the basic infrastructure for now, while additional patches will > > implement configuration registers. > > > > Signed-off-by: Marc Zyngier > > --- > > arch/arm64/include/asm/kvm_host.h | 1 + > > arch/arm64/include/asm/kvm_nested.h | 2 + > > arch/arm64/kvm/emulate-nested.c | 262 ++++++++++++++++++++++++++++ > > arch/arm64/kvm/sys_regs.c | 6 + > > arch/arm64/kvm/trace_arm.h | 26 +++ > > 5 files changed, 297 insertions(+) > > > > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm= /kvm_host.h > > index 721680da1011..cb1c5c54cedd 100644 > > --- a/arch/arm64/include/asm/kvm_host.h > > +++ b/arch/arm64/include/asm/kvm_host.h > > @@ -988,6 +988,7 @@ int kvm_handle_cp10_id(struct kvm_vcpu *vcpu); > > void kvm_reset_sys_regs(struct kvm_vcpu *vcpu); > > =20 > > int __init kvm_sys_reg_table_init(void); > > +int __init populate_nv_trap_config(void); > > =20 > > bool lock_all_vcpus(struct kvm *kvm); > > void unlock_all_vcpus(struct kvm *kvm); > > diff --git a/arch/arm64/include/asm/kvm_nested.h b/arch/arm64/include/a= sm/kvm_nested.h > > index 8fb67f032fd1..fa23cc9c2adc 100644 > > --- a/arch/arm64/include/asm/kvm_nested.h > > +++ b/arch/arm64/include/asm/kvm_nested.h > > @@ -11,6 +11,8 @@ static inline bool vcpu_has_nv(const struct kvm_vcpu = *vcpu) > > test_bit(KVM_ARM_VCPU_HAS_EL2, vcpu->arch.features)); > > } > > =20 > > +extern bool __check_nv_sr_forward(struct kvm_vcpu *vcpu); > > + > > struct sys_reg_params; > > struct sys_reg_desc; > > =20 > > diff --git a/arch/arm64/kvm/emulate-nested.c b/arch/arm64/kvm/emulate-n= ested.c > > index b96662029fb1..1b1148770d45 100644 > > --- a/arch/arm64/kvm/emulate-nested.c > > +++ b/arch/arm64/kvm/emulate-nested.c > > @@ -14,6 +14,268 @@ > > =20 > > #include "trace.h" > > =20 > > +enum trap_behaviour { > > + BEHAVE_HANDLE_LOCALLY =3D 0, > > + BEHAVE_FORWARD_READ =3D BIT(0), > > + BEHAVE_FORWARD_WRITE =3D BIT(1), > > + BEHAVE_FORWARD_ANY =3D BEHAVE_FORWARD_READ | BEHAVE_FORWARD_WRITE, > > +}; > > + > > +struct trap_bits { > > + const enum vcpu_sysreg index; > > + const enum trap_behaviour behaviour; > > + const u64 value; > > + const u64 mask; > > +}; > > + > > +enum trap_group { > nit: Maybe add a comment saying that it relates to *coarse* trapping as > opposed to the other enum which is named fgt_group_id. cgt_group_id may > have been better but well ;-) You mean I should apply some sort of consistency to this code in order to help reviewers understanding it? Fool! ;-) Point taken, I'll go over it and apply your suggestion. >=20 > > + /* Indicates no coarse trap control */ > > + __RESERVED__, > > + > > + /* > > + * The first batch of IDs denote coarse trapping that are used > > + * on their own instead of being part of a combination of > > + * trap controls. > > + */ > > + > > + /* > > + * Anything after this point is a combination of trap controls, > coarse trap controls Yup. > > + * which all must be evaluated to decide what to do. > > + */ > > + __MULTIPLE_CONTROL_BITS__, > > + > > + /* > > + * Anything after this point requires a callback evaluating a > > + * complex trap condition. Hopefully we'll never need this... > > + */ > > + __COMPLEX_CONDITIONS__, > > + > > + /* Must be last */ > > + __NR_TRAP_GROUP_IDS__ > > +}; > > + > > +static const struct trap_bits coarse_trap_bits[] =3D { > > +}; > > + > > +#define MCB(id, ...) \ > > + [id - __MULTIPLE_CONTROL_BITS__] =3D \ > > + (const enum trap_group []){ \ > > + __VA_ARGS__, __RESERVED__ \ > > + } > > + > > +static const enum trap_group *coarse_control_combo[] =3D { > > +}; > > + > > +typedef enum trap_behaviour (*complex_condition_check)(struct kvm_vcpu= *); > > + > > +#define CCC(id, fn) \ > > + [id - __COMPLEX_CONDITIONS__] =3D fn > > + > > +static const complex_condition_check ccc[] =3D { > > +}; > > + > > +/* > > + * Bit assignment for the trap controls. We use a 64bit word with the > > + * following layout for each trapped sysreg: > > + * > > + * [9:0] enum trap_group (10 bits) > > + * [13:10] enum fgt_group_id (4 bits) > > + * [19:14] bit number in the FGT register (6 bits) > > + * [20] trap polarity (1 bit) > > + * [62:21] Unused (42 bits) > > + * [63] RES0 - Must be zero, as lost on insertion in the xarray > what do you mean by "as lost" The xarray is only able to store 63 bit of information, not 64, as it uses the LSB for its own purpose. This isn't a problem when storing a pointer (the last 2 bits are usually 0 if pointing to a structure). However, things get funny when you're trying to assign an integer value to an xarray location. This is why we use the xa_mk_value() helper, which is defined as: static inline void *xa_mk_value(unsigned long v) { WARN_ON((long)v < 0); return (void *)((v << 1) | 1); } and the opposite helper on retrieval: static inline unsigned long xa_to_value(const void *entry) { return (unsigned long)entry >> 1; } As you now tell, the MSB is lost on insertion. Hence the comment that warns against the use of bit 63, as we will never get it back. I'll add some extra checks for that in the code that populates the trap configuration. > > + */ > > +#define TC_CGT_BITS 10 > > +#define TC_FGT_BITS 4 > > + > > +union trap_config { > > + u64 val; > > + struct { > > + unsigned long cgt:TC_CGT_BITS; /* Coarse trap id */ > > + unsigned long fgt:TC_FGT_BITS; /* Fing Grained Trap id */ > Fine & align capital letter in Trap for both comments Done. > > + unsigned long bit:6; /* Bit number */ > > + unsigned long pol:1; /* Polarity */ > > + unsigned long unk:42; /* Unknown */ > s//Unknown/Unused? Yup, that's better. > > + unsigned long mbz:1; /* Must Be Zero */ > > + }; > > +}; > > + > > +struct encoding_to_trap_config { > > + const u32 encoding; > > + const u32 end; > > + const union trap_config tc; > > +}; > > + > > +#define SR_RANGE_TRAP(sr_start, sr_end, trap_id) \ > > + { \ > > + .encoding =3D sr_start, \ > > + .end =3D sr_end, \ > > + .tc =3D { \ > > + .cgt =3D trap_id, \ > > + }, \ > > + } > > + > > +#define SR_TRAP(sr, trap_id) SR_RANGE_TRAP(sr, sr, trap_id) > > + > > +/* > > + * Map encoding to trap bits for exception reported with EC=3D0x18. > > + * These must only be evaluated when running a nested hypervisor, but > > + * that the current context is not a hypervisor context. When the > > + * trapped access matches one of the trap controls, the exception is > > + * re-injected in the nested hypervisor. > I must confess I was confused by the "forwarding" terminology versus > "re-injection into the nested hyp"=C2=A0 >=20 > cf. >=20 > "decide whether a trap from a L2+ guest has to be forwarded to a L1 guest > or handled locally" >=20 > "re-injection into the nested hyp" sounds clearer to me. I see them as two sides of the same coin: the "forwarding" is the high-level action (we pass the exception on to the L1 hypervisor). The "re-injection" is the low-level implementation of the forwarding, which is a complicated process (a full world switch). >=20 > > + */ > > +static const struct encoding_to_trap_config encoding_to_cgt[] __initco= nst =3D { > > +}; > > + > > +static DEFINE_XARRAY(sr_forward_xa); > > + > > +static union trap_config get_trap_config(u32 sysreg) > > +{ > > + return (union trap_config) { > > + .val =3D xa_to_value(xa_load(&sr_forward_xa, sysreg)), > > + }; > > +} > > + > > +int __init populate_nv_trap_config(void) > > +{ > > + int ret =3D 0; > > + > > + BUILD_BUG_ON(sizeof(union trap_config) !=3D sizeof(void *)); > > + BUILD_BUG_ON(__NR_TRAP_GROUP_IDS__ > BIT(TC_CGT_BITS)); > > + > > + for (int i =3D 0; i < ARRAY_SIZE(encoding_to_cgt); i++) { > > + const struct encoding_to_trap_config *cgt =3D &encoding_to_cgt[i]; > > + void *prev; > > + > > + prev =3D xa_store_range(&sr_forward_xa, cgt->encoding, cgt->end, > > + xa_mk_value(cgt->tc.val), GFP_KERNEL); > > + > > + if (prev) { > > + kvm_err("Duplicate CGT for (%d, %d, %d, %d, %d)\n", > > + sys_reg_Op0(cgt->encoding), > > + sys_reg_Op1(cgt->encoding), > > + sys_reg_CRn(cgt->encoding), > > + sys_reg_CRm(cgt->encoding), > > + sys_reg_Op2(cgt->encoding)); > > + ret =3D -EINVAL; > > + } > > + } > > + > > + kvm_info("nv: %ld coarse grained trap handlers\n", > > + ARRAY_SIZE(encoding_to_cgt)); > > + > > + for (int id =3D __MULTIPLE_CONTROL_BITS__; > > + id < (__COMPLEX_CONDITIONS__ - 1); > > + id++) { > > + const enum trap_group *cgids; > > + > > + cgids =3D coarse_control_combo[id - __MULTIPLE_CONTROL_BITS__]; > > + > > + for (int i =3D 0; cgids[i] !=3D __RESERVED__; i++) { > > + if (cgids[i] >=3D __MULTIPLE_CONTROL_BITS__) { > > + kvm_err("Recursive MCB %d/%d\n", id, cgids[i]); > > + ret =3D -EINVAL; > > + } > > + } > > + } > > + > > + if (ret) > > + xa_destroy(&sr_forward_xa); > > + > > + return ret; > > +} > > + > > +static enum trap_behaviour get_behaviour(struct kvm_vcpu *vcpu, > > + const struct trap_bits *tb) > > +{ > > + enum trap_behaviour b =3D BEHAVE_HANDLE_LOCALLY; > > + u64 val; > > + > > + val =3D __vcpu_sys_reg(vcpu, tb->index); > > + if ((val & tb->mask) =3D=3D tb->value) > > + b |=3D tb->behaviour; > > + > > + return b; > > +} > > + > > +static enum trap_behaviour __do_compute_trap_behaviour(struct kvm_vcpu= *vcpu, > > + const enum trap_group id, > > + enum trap_behaviour b) > > +{ > > + switch (id) { > > + const enum trap_group *cgids; > > + > > + case __RESERVED__ ... __MULTIPLE_CONTROL_BITS__ - 1: > > + if (likely(id !=3D __RESERVED__)) > > + b |=3D get_behaviour(vcpu, &coarse_trap_bits[id]); > > + break; > > + case __MULTIPLE_CONTROL_BITS__ ... __COMPLEX_CONDITIONS__ - 1: > > + /* Yes, this is recursive. Don't do anything stupid. */ > > + cgids =3D coarse_control_combo[id - __MULTIPLE_CONTROL_BITS__]; > > + for (int i =3D 0; cgids[i] !=3D __RESERVED__; i++) > > + b |=3D __do_compute_trap_behaviour(vcpu, cgids[i], b); > > + break; > > + default: > > + if (ARRAY_SIZE(ccc)) > > + b |=3D ccc[id - __COMPLEX_CONDITIONS__](vcpu); > > + break; > > + } > > + > > + return b; > > +} > > + > > +static enum trap_behaviour compute_trap_behaviour(struct kvm_vcpu *vcp= u, > > + const union trap_config tc) > > +{ > > + enum trap_behaviour b =3D BEHAVE_HANDLE_LOCALLY; > > + > > + return __do_compute_trap_behaviour(vcpu, tc.cgt, b); > > +} > > + > > +bool __check_nv_sr_forward(struct kvm_vcpu *vcpu) > > +{ > > + union trap_config tc; > > + enum trap_behaviour b; > > + bool is_read; > > + u32 sysreg; > > + u64 esr; > > + > > + if (!vcpu_has_nv(vcpu) || is_hyp_ctxt(vcpu)) > > + return false; > > + > > + esr =3D kvm_vcpu_get_esr(vcpu); > > + sysreg =3D esr_sys64_to_sysreg(esr); > > + is_read =3D (esr & ESR_ELx_SYS64_ISS_DIR_MASK) =3D=3D ESR_ELx_SYS64_I= SS_DIR_READ; > > + > > + tc =3D get_trap_config(sysreg); > > + > > + /* > > + * A value of 0 for the whole entry means that we know nothing > > + * for this sysreg, and that it cannot be forwareded. In this > forwarded Fixed. Thanks again for all your suggestions. M. --=20 Without deviation from the norm, progress is not possible. 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 53A10C04A6A for ; Thu, 10 Aug 2023 14:44:33 +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: Subject:Cc:To:From:Message-ID:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=xVTG58KwZ0FphO3yE45P3bO97g0rvprb0aOITNzkaf4=; b=iRTBTwfbwLnKWz 4XmaEjh/2c+YJPWzwu7Nb+WZe9EOsm8/1Yk1Aw19f95QDUQY+syF7IhvFeuBzLSZNKY30w1DUKgOD GL5dS8F1pJ3nb9SyADlNM1no/03fdAAy9KV6mJ1EoT49N6gH3JX+WyyrloEgzguK+gZqj3PVNcjfM T0Q7coHYlhXOJddQU18lvQ4tEbXe/YgL8B4PiDERB2OuI1VPR58qekPXGRuEznXPi7MBkO4voZEb3 XRHxr0k63QdooPXhkl5w9bmfDmfU1ldmTwihSoEOqITAwTcu/KBWzcC28pmKr3UxDvWPBlm6X8OZs B6pvLhriCu2dzd6FGrGA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1qU6tR-007toU-2U; Thu, 10 Aug 2023 14:44:05 +0000 Received: from dfw.source.kernel.org ([139.178.84.217]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1qU6tO-007tng-2B for linux-arm-kernel@lists.infradead.org; Thu, 10 Aug 2023 14:44:04 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id F030D65EA9; Thu, 10 Aug 2023 14:44:01 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 0AC5FC433CB; Thu, 10 Aug 2023 14:44:01 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1691678641; bh=mO3bnIbUtzEnniylSh7RL1DI8oatZ5JEMR3db9B8FcA=; h=Date:From:To:Cc:Subject:In-Reply-To:References:From; b=KsyS4dmNfewUOW0ZozKec2quRtce73f9R/mmJjYTfOrNILlhkl0witKj5ip7xwuUE eyaotSqhazNt5Phrmv+CaRzKvMK1xIUClyaVMb45/a4GGan9rQ3CvJUb/iuC+FUHKT boMdo5L9+4G7j00EzIBhr9m+1DhP8BMc5OFR+q1ceM8q6gnZXfrM4WqKp/XT+IKkvq 5Y1m8V9f7Im3T2fYyjU0jSBjfvksm3bYwnjETayNm6pWh9005xuqKEudxXdkydQOqC UmwqAMDSpWweVFxyUU3I3BfBCGAcekFPImhiEASVaIfKulTOGKTFWiv4iowEqIa0f0 HuIv4L5IGy8FQ== Received: from c-xd4ed8728.customers.hiper-net.dk ([212.237.135.40] helo=wait-a-minute.misterjones.org) by disco-boy.misterjones.org with esmtpsa (TLS1.3) tls TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 (Exim 4.95) (envelope-from ) id 1qU6tK-003r0K-JO; Thu, 10 Aug 2023 15:43:58 +0100 Date: Thu, 10 Aug 2023 15:44:06 +0100 Message-ID: <87ttt7ot3d.wl-maz@kernel.org> From: Marc Zyngier To: eric.auger@redhat.com Cc: kvmarm@lists.linux.dev, kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Catalin Marinas , Mark Brown , Mark Rutland , Will Deacon , Alexandru Elisei , Andre Przywara , Chase Conklin , Ganapatrao Kulkarni , Darren Hart , Miguel Luis , James Morse , Suzuki K Poulose , Oliver Upton , Zenghui Yu Subject: Re: [PATCH v3 14/27] KVM: arm64: nv: Add trap forwarding infrastructure In-Reply-To: <18eae581-500b-9c9e-2cce-e2f5fb007071@redhat.com> References: <20230808114711.2013842-1-maz@kernel.org> <20230808114711.2013842-15-maz@kernel.org> <18eae581-500b-9c9e-2cce-e2f5fb007071@redhat.com> User-Agent: Wanderlust/2.15.9 (Almost Unreal) SEMI-EPG/1.14.7 (Harue) FLIM-LB/1.14.9 (=?UTF-8?B?R29qxY0=?=) APEL-LB/10.8 EasyPG/1.0.0 Emacs/28.2 (x86_64-pc-linux-gnu) MULE/6.0 (HANACHIRUSATO) MIME-Version: 1.0 (generated by SEMI-EPG 1.14.7 - "Harue") X-SA-Exim-Connect-IP: 212.237.135.40 X-SA-Exim-Rcpt-To: eric.auger@redhat.com, kvmarm@lists.linux.dev, kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, catalin.marinas@arm.com, broonie@kernel.org, mark.rutland@arm.com, will@kernel.org, alexandru.elisei@arm.com, andre.przywara@arm.com, chase.conklin@arm.com, gankulkarni@os.amperecomputing.com, darren@os.amperecomputing.com, miguel.luis@oracle.com, james.morse@arm.com, suzuki.poulose@arm.com, oliver.upton@linux.dev, yuzenghui@huawei.com X-SA-Exim-Mail-From: maz@kernel.org X-SA-Exim-Scanned: No (on disco-boy.misterjones.org); SAEximRunCond expanded to false X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230810_074402_798460_723CB0CA X-CRM114-Status: GOOD ( 58.07 ) 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-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgRXJpYywKCk9uIFdlZCwgMDkgQXVnIDIwMjMgMTQ6Mjc6MjcgKzAxMDAsCkVyaWMgQXVnZXIg PGVyaWMuYXVnZXJAcmVkaGF0LmNvbT4gd3JvdGU6Cj4gCj4gSGkgTWFyYywKPiAKPiBPbiA4Lzgv MjMgMTM6NDYsIE1hcmMgWnluZ2llciB3cm90ZToKPiA+IEEgc2lnbmlmaWNhbnQgcGFydCBvZiB3 aGF0IGEgTlYgaHlwZXJ2aXNvciBuZWVkcyB0byBkbyBpcyB0byBkZWNpZGUKPiA+IHdoZXRoZXIg YSB0cmFwIGZyb20gYSBMMisgZ3Vlc3QgaGFzIHRvIGJlIGZvcndhcmRlZCB0byBhIEwxIGd1ZXN0 Cj4gPiBvciBoYW5kbGVkIGxvY2FsbHkuIFRoaXMgaXMgZG9uZSBieSBjaGVja2luZyBmb3IgdGhl IHRyYXAgYml0cyB0aGF0Cj4gPiB0aGUgZ3Vlc3QgaHlwZXJ2aXNvciBoYXMgc2V0IGFuZCBhY3Rp bmcgYWNjb3JkaW5nbHksIGFzIGRlc2NyaWJlZCBieQo+ID4gdGhlIGFyY2hpdGVjdHVyZS4KPiA+ Cj4gPiBBIHByZXZpb3VzIGFwcHJvYWNoIHdhcyB0byBzcHJpbmtsZSBhIGJ1bmNoIG9mIGNoZWNr cyBpbiBhbGwgdGhlCj4gPiBzeXN0ZW0gcmVnaXN0ZXIgYWNjZXNzb3JzLCBidXQgdGhpcyBpcyBw cmV0dHkgZXJyb3IgcHJvbmUgYW5kIGRvZXNuJ3QKPiA+IGhlbHAgZ2V0dGluZyBhbiBvdmVydmll dyBvZiB3aGF0IGlzIGhhcHBlbmluZy4KPiA+Cj4gPiBJbnN0ZWFkLCBpbXBsZW1lbnQgYSBzZXQg b2YgZ2xvYmFsIHRhYmxlcyB0aGF0IGRlc2NyaWJlIGEgdHJhcCBiaXQsCj4gPiBjb21iaW5hdGlv bnMgb2YgdHJhcCBiaXRzLCBiZWhhdmlvdXJzIG9uIHRyYXAsIGFuZCB3aGF0IGJpdHMgbXVzdAo+ ID4gYmUgZXZhbHVhdGVkIG9uIGEgc3lzdGVtIHJlZ2lzdGVyIHRyYXAuCj4gPgo+ID4gQWx0aG91 Z2ggdGhpcyBpcyBwYWluZnVsIHRvIGRlc2NyaWJlLCB0aGlzIGFsbG93cyB0byBzcGVjaWZ5IGVh Y2gKPiA+IGFuZCBldmVyeSBjb250cm9sIGJpdCBpbiBhIHN0YXRpYyBtYW5uZXIuIFRvIG1ha2Ug aXQgZWZmaWNpZW50LAo+ID4gdGhlIHRhYmxlIGlzIGluc2VydGVkIGluIGFuIHhhcnJheSB0aGF0 IGlzIGdsb2JhbCB0byB0aGUgc3lzdGVtLAo+ID4gYW5kIGNoZWNrZWQgZWFjaCB0aW1lIHdlIHRy YXAgYSBzeXN0ZW0gcmVnaXN0ZXIgd2hpbGUgcnVubmluZwo+ID4gYSBMMiBndWVzdC4KPiA+Cj4g PiBBZGQgdGhlIGJhc2ljIGluZnJhc3RydWN0dXJlIGZvciBub3csIHdoaWxlIGFkZGl0aW9uYWwg cGF0Y2hlcyB3aWxsCj4gPiBpbXBsZW1lbnQgY29uZmlndXJhdGlvbiByZWdpc3RlcnMuCj4gPgo+ ID4gU2lnbmVkLW9mZi1ieTogTWFyYyBaeW5naWVyIDxtYXpAa2VybmVsLm9yZz4KPiA+IC0tLQo+ ID4gIGFyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCAgIHwgICAxICsKPiA+ICBhcmNo L2FybTY0L2luY2x1ZGUvYXNtL2t2bV9uZXN0ZWQuaCB8ICAgMiArCj4gPiAgYXJjaC9hcm02NC9r dm0vZW11bGF0ZS1uZXN0ZWQuYyAgICAgfCAyNjIgKysrKysrKysrKysrKysrKysrKysrKysrKysr Kwo+ID4gIGFyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMgICAgICAgICAgIHwgICA2ICsKPiA+ICBh cmNoL2FybTY0L2t2bS90cmFjZV9hcm0uaCAgICAgICAgICB8ICAyNiArKysKPiA+ICA1IGZpbGVz IGNoYW5nZWQsIDI5NyBpbnNlcnRpb25zKCspCj4gPgo+ID4gZGlmZiAtLWdpdCBhL2FyY2gvYXJt NjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hv c3QuaAo+ID4gaW5kZXggNzIxNjgwZGExMDExLi5jYjFjNWM1NGNlZGQgMTAwNjQ0Cj4gPiAtLS0g YS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiA+ICsrKyBiL2FyY2gvYXJtNjQv aW5jbHVkZS9hc20va3ZtX2hvc3QuaAo+ID4gQEAgLTk4OCw2ICs5ODgsNyBAQCBpbnQga3ZtX2hh bmRsZV9jcDEwX2lkKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSk7Cj4gPiAgdm9pZCBrdm1fcmVzZXRf c3lzX3JlZ3Moc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKPiA+ICAKPiA+ICBpbnQgX19pbml0IGt2 bV9zeXNfcmVnX3RhYmxlX2luaXQodm9pZCk7Cj4gPiAraW50IF9faW5pdCBwb3B1bGF0ZV9udl90 cmFwX2NvbmZpZyh2b2lkKTsKPiA+ICAKPiA+ICBib29sIGxvY2tfYWxsX3ZjcHVzKHN0cnVjdCBr dm0gKmt2bSk7Cj4gPiAgdm9pZCB1bmxvY2tfYWxsX3ZjcHVzKHN0cnVjdCBrdm0gKmt2bSk7Cj4g PiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmggYi9hcmNo L2FybTY0L2luY2x1ZGUvYXNtL2t2bV9uZXN0ZWQuaAo+ID4gaW5kZXggOGZiNjdmMDMyZmQxLi5m YTIzY2M5YzJhZGMgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9u ZXN0ZWQuaAo+ID4gKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fbmVzdGVkLmgKPiA+ IEBAIC0xMSw2ICsxMSw4IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCB2Y3B1X2hhc19udihjb25zdCBz dHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gPiAgCQl0ZXN0X2JpdChLVk1fQVJNX1ZDUFVfSEFTX0VM MiwgdmNwdS0+YXJjaC5mZWF0dXJlcykpOwo+ID4gIH0KPiA+ICAKPiA+ICtleHRlcm4gYm9vbCBf X2NoZWNrX252X3NyX2ZvcndhcmQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KTsKPiA+ICsKPiA+ICBz dHJ1Y3Qgc3lzX3JlZ19wYXJhbXM7Cj4gPiAgc3RydWN0IHN5c19yZWdfZGVzYzsKPiA+ICAKPiA+ IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9lbXVsYXRlLW5lc3RlZC5jIGIvYXJjaC9hcm02 NC9rdm0vZW11bGF0ZS1uZXN0ZWQuYwo+ID4gaW5kZXggYjk2NjYyMDI5ZmIxLi4xYjExNDg3NzBk NDUgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9lbXVsYXRlLW5lc3RlZC5jCj4gPiAr KysgYi9hcmNoL2FybTY0L2t2bS9lbXVsYXRlLW5lc3RlZC5jCj4gPiBAQCAtMTQsNiArMTQsMjY4 IEBACj4gPiAgCj4gPiAgI2luY2x1ZGUgInRyYWNlLmgiCj4gPiAgCj4gPiArZW51bSB0cmFwX2Jl aGF2aW91ciB7Cj4gPiArCUJFSEFWRV9IQU5ETEVfTE9DQUxMWQk9IDAsCj4gPiArCUJFSEFWRV9G T1JXQVJEX1JFQUQJPSBCSVQoMCksCj4gPiArCUJFSEFWRV9GT1JXQVJEX1dSSVRFCT0gQklUKDEp LAo+ID4gKwlCRUhBVkVfRk9SV0FSRF9BTlkJPSBCRUhBVkVfRk9SV0FSRF9SRUFEIHwgQkVIQVZF X0ZPUldBUkRfV1JJVEUsCj4gPiArfTsKPiA+ICsKPiA+ICtzdHJ1Y3QgdHJhcF9iaXRzIHsKPiA+ ICsJY29uc3QgZW51bSB2Y3B1X3N5c3JlZwkJaW5kZXg7Cj4gPiArCWNvbnN0IGVudW0gdHJhcF9i ZWhhdmlvdXIJYmVoYXZpb3VyOwo+ID4gKwljb25zdCB1NjQJCQl2YWx1ZTsKPiA+ICsJY29uc3Qg dTY0CQkJbWFzazsKPiA+ICt9Owo+ID4gKwo+ID4gK2VudW0gdHJhcF9ncm91cCB7Cj4gbml0OiBN YXliZSBhZGQgYSBjb21tZW50IHNheWluZyB0aGF0IGl0IHJlbGF0ZXMgdG8gKmNvYXJzZSogdHJh cHBpbmcgYXMKPiBvcHBvc2VkIHRvIHRoZSBvdGhlciBlbnVtIHdoaWNoIGlzIG5hbWVkIGZndF9n cm91cF9pZC4gY2d0X2dyb3VwX2lkIG1heQo+IGhhdmUgYmVlbiBiZXR0ZXIgYnV0IHdlbGwgOy0p CgpZb3UgbWVhbiBJIHNob3VsZCBhcHBseSBzb21lIHNvcnQgb2YgY29uc2lzdGVuY3kgdG8gdGhp cyBjb2RlIGluIG9yZGVyCnRvIGhlbHAgcmV2aWV3ZXJzIHVuZGVyc3RhbmRpbmcgaXQ/IEZvb2wh IDstKQoKUG9pbnQgdGFrZW4sIEknbGwgZ28gb3ZlciBpdCBhbmQgYXBwbHkgeW91ciBzdWdnZXN0 aW9uLgoKPiAKPiA+ICsJLyogSW5kaWNhdGVzIG5vIGNvYXJzZSB0cmFwIGNvbnRyb2wgKi8KPiA+ ICsJX19SRVNFUlZFRF9fLAo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBUaGUgZmlyc3QgYmF0Y2gg b2YgSURzIGRlbm90ZSBjb2Fyc2UgdHJhcHBpbmcgdGhhdCBhcmUgdXNlZAo+ID4gKwkgKiBvbiB0 aGVpciBvd24gaW5zdGVhZCBvZiBiZWluZyBwYXJ0IG9mIGEgY29tYmluYXRpb24gb2YKPiA+ICsJ ICogdHJhcCBjb250cm9scy4KPiA+ICsJICovCj4gPiArCj4gPiArCS8qCj4gPiArCSAqIEFueXRo aW5nIGFmdGVyIHRoaXMgcG9pbnQgaXMgYSBjb21iaW5hdGlvbiBvZiB0cmFwIGNvbnRyb2xzLAo+ IGNvYXJzZSB0cmFwIGNvbnRyb2xzCgpZdXAuCgo+ID4gKwkgKiB3aGljaCBhbGwgbXVzdCBiZSBl dmFsdWF0ZWQgdG8gZGVjaWRlIHdoYXQgdG8gZG8uCj4gPiArCSAqLwo+ID4gKwlfX01VTFRJUExF X0NPTlRST0xfQklUU19fLAo+ID4gKwo+ID4gKwkvKgo+ID4gKwkgKiBBbnl0aGluZyBhZnRlciB0 aGlzIHBvaW50IHJlcXVpcmVzIGEgY2FsbGJhY2sgZXZhbHVhdGluZyBhCj4gPiArCSAqIGNvbXBs ZXggdHJhcCBjb25kaXRpb24uIEhvcGVmdWxseSB3ZSdsbCBuZXZlciBuZWVkIHRoaXMuLi4KPiA+ ICsJICovCj4gPiArCV9fQ09NUExFWF9DT05ESVRJT05TX18sCj4gPiArCj4gPiArCS8qIE11c3Qg YmUgbGFzdCAqLwo+ID4gKwlfX05SX1RSQVBfR1JPVVBfSURTX18KPiA+ICt9Owo+ID4gKwo+ID4g K3N0YXRpYyBjb25zdCBzdHJ1Y3QgdHJhcF9iaXRzIGNvYXJzZV90cmFwX2JpdHNbXSA9IHsKPiA+ ICt9Owo+ID4gKwo+ID4gKyNkZWZpbmUgTUNCKGlkLCAuLi4pCQkJCQlcCj4gPiArCVtpZCAtIF9f TVVMVElQTEVfQ09OVFJPTF9CSVRTX19dCT0JXAo+ID4gKwkJKGNvbnN0IGVudW0gdHJhcF9ncm91 cCBbXSl7CQlcCj4gPiArCQkJX19WQV9BUkdTX18sIF9fUkVTRVJWRURfXwlcCj4gPiArCQl9Cj4g PiArCj4gPiArc3RhdGljIGNvbnN0IGVudW0gdHJhcF9ncm91cCAqY29hcnNlX2NvbnRyb2xfY29t Ym9bXSA9IHsKPiA+ICt9Owo+ID4gKwo+ID4gK3R5cGVkZWYgZW51bSB0cmFwX2JlaGF2aW91ciAo KmNvbXBsZXhfY29uZGl0aW9uX2NoZWNrKShzdHJ1Y3Qga3ZtX3ZjcHUgKik7Cj4gPiArCj4gPiAr I2RlZmluZSBDQ0MoaWQsIGZuKQkJCQlcCj4gPiArCVtpZCAtIF9fQ09NUExFWF9DT05ESVRJT05T X19dID0gZm4KPiA+ICsKPiA+ICtzdGF0aWMgY29uc3QgY29tcGxleF9jb25kaXRpb25fY2hlY2sg Y2NjW10gPSB7Cj4gPiArfTsKPiA+ICsKPiA+ICsvKgo+ID4gKyAqIEJpdCBhc3NpZ25tZW50IGZv ciB0aGUgdHJhcCBjb250cm9scy4gV2UgdXNlIGEgNjRiaXQgd29yZCB3aXRoIHRoZQo+ID4gKyAq IGZvbGxvd2luZyBsYXlvdXQgZm9yIGVhY2ggdHJhcHBlZCBzeXNyZWc6Cj4gPiArICoKPiA+ICsg KiBbOTowXQllbnVtIHRyYXBfZ3JvdXAgKDEwIGJpdHMpCj4gPiArICogWzEzOjEwXQllbnVtIGZn dF9ncm91cF9pZCAoNCBiaXRzKQo+ID4gKyAqIFsxOToxNF0JYml0IG51bWJlciBpbiB0aGUgRkdU IHJlZ2lzdGVyICg2IGJpdHMpCj4gPiArICogWzIwXQkJdHJhcCBwb2xhcml0eSAoMSBiaXQpCj4g PiArICogWzYyOjIxXQlVbnVzZWQgKDQyIGJpdHMpCj4gPiArICogWzYzXQkJUkVTMCAtIE11c3Qg YmUgemVybywgYXMgbG9zdCBvbiBpbnNlcnRpb24gaW4gdGhlIHhhcnJheQo+IHdoYXQgZG8geW91 IG1lYW4gYnkgImFzIGxvc3QiCgpUaGUgeGFycmF5IGlzIG9ubHkgYWJsZSB0byBzdG9yZSA2MyBi aXQgb2YgaW5mb3JtYXRpb24sIG5vdCA2NCwgYXMgaXQKdXNlcyB0aGUgTFNCIGZvciBpdHMgb3du IHB1cnBvc2UuIFRoaXMgaXNuJ3QgYSBwcm9ibGVtIHdoZW4gc3RvcmluZyBhCnBvaW50ZXIgKHRo ZSBsYXN0IDIgYml0cyBhcmUgdXN1YWxseSAwIGlmIHBvaW50aW5nIHRvIGEgc3RydWN0dXJlKS4K SG93ZXZlciwgdGhpbmdzIGdldCBmdW5ueSB3aGVuIHlvdSdyZSB0cnlpbmcgdG8gYXNzaWduIGFu IGludGVnZXIKdmFsdWUgdG8gYW4geGFycmF5IGxvY2F0aW9uLgoKVGhpcyBpcyB3aHkgd2UgdXNl IHRoZSB4YV9ta192YWx1ZSgpIGhlbHBlciwgd2hpY2ggaXMgZGVmaW5lZCBhczoKCnN0YXRpYyBp bmxpbmUgdm9pZCAqeGFfbWtfdmFsdWUodW5zaWduZWQgbG9uZyB2KQp7CiAgICAgICAgV0FSTl9P TigobG9uZyl2IDwgMCk7CiAgICAgICAgcmV0dXJuICh2b2lkICopKCh2IDw8IDEpIHwgMSk7Cn0K CmFuZCB0aGUgb3Bwb3NpdGUgaGVscGVyIG9uIHJldHJpZXZhbDoKCnN0YXRpYyBpbmxpbmUgdW5z aWduZWQgbG9uZyB4YV90b192YWx1ZShjb25zdCB2b2lkICplbnRyeSkKewogICAgICAgIHJldHVy biAodW5zaWduZWQgbG9uZyllbnRyeSA+PiAxOwp9CgpBcyB5b3Ugbm93IHRlbGwsIHRoZSBNU0Ig aXMgbG9zdCBvbiBpbnNlcnRpb24uIEhlbmNlIHRoZSBjb21tZW50IHRoYXQKd2FybnMgYWdhaW5z dCB0aGUgdXNlIG9mIGJpdCA2MywgYXMgd2Ugd2lsbCBuZXZlciBnZXQgaXQgYmFjay4gSSdsbAph ZGQgc29tZSBleHRyYSBjaGVja3MgZm9yIHRoYXQgaW4gdGhlIGNvZGUgdGhhdCBwb3B1bGF0ZXMg dGhlIHRyYXAKY29uZmlndXJhdGlvbi4KCj4gPiArICovCj4gPiArI2RlZmluZSBUQ19DR1RfQklU UwkxMAo+ID4gKyNkZWZpbmUgVENfRkdUX0JJVFMJNAo+ID4gKwo+ID4gK3VuaW9uIHRyYXBfY29u ZmlnIHsKPiA+ICsJdTY0CXZhbDsKPiA+ICsJc3RydWN0IHsKPiA+ICsJCXVuc2lnbmVkIGxvbmcJ Y2d0OlRDX0NHVF9CSVRTOyAvKiBDb2Fyc2UgdHJhcCBpZCAqLwo+ID4gKwkJdW5zaWduZWQgbG9u ZwlmZ3Q6VENfRkdUX0JJVFM7IC8qIEZpbmcgR3JhaW5lZCBUcmFwIGlkICovCj4gRmluZSAmIGFs aWduIGNhcGl0YWwgbGV0dGVyIGluIFRyYXAgZm9yIGJvdGggY29tbWVudHMKCkRvbmUuCgo+ID4g KwkJdW5zaWduZWQgbG9uZwliaXQ6NjsJCSAvKiBCaXQgbnVtYmVyICovCj4gPiArCQl1bnNpZ25l ZCBsb25nCXBvbDoxOwkJIC8qIFBvbGFyaXR5ICovCj4gPiArCQl1bnNpZ25lZCBsb25nCXVuazo0 MjsJCSAvKiBVbmtub3duICovCj4gcy8vVW5rbm93bi9VbnVzZWQ/CgpZdXAsIHRoYXQncyBiZXR0 ZXIuCgo+ID4gKwkJdW5zaWduZWQgbG9uZwltYno6MTsJCSAvKiBNdXN0IEJlIFplcm8gKi8KPiA+ ICsJfTsKPiA+ICt9Owo+ID4gKwo+ID4gK3N0cnVjdCBlbmNvZGluZ190b190cmFwX2NvbmZpZyB7 Cj4gPiArCWNvbnN0IHUzMgkJCWVuY29kaW5nOwo+ID4gKwljb25zdCB1MzIJCQllbmQ7Cj4gPiAr CWNvbnN0IHVuaW9uIHRyYXBfY29uZmlnCQl0YzsKPiA+ICt9Owo+ID4gKwo+ID4gKyNkZWZpbmUg U1JfUkFOR0VfVFJBUChzcl9zdGFydCwgc3JfZW5kLCB0cmFwX2lkKQkJCVwKPiA+ICsJewkJCQkJ CQkJXAo+ID4gKwkJLmVuY29kaW5nCT0gc3Jfc3RhcnQsCQkJCVwKPiA+ICsJCS5lbmQJCT0gc3Jf ZW5kLAkJCQlcCj4gPiArCQkudGMJCT0gewkJCQkJXAo+ID4gKwkJCS5jZ3QJCT0gdHJhcF9pZCwJ CQlcCj4gPiArCQl9LAkJCQkJCQlcCj4gPiArCX0KPiA+ICsKPiA+ICsjZGVmaW5lIFNSX1RSQVAo c3IsIHRyYXBfaWQpCQlTUl9SQU5HRV9UUkFQKHNyLCBzciwgdHJhcF9pZCkKPiA+ICsKPiA+ICsv Kgo+ID4gKyAqIE1hcCBlbmNvZGluZyB0byB0cmFwIGJpdHMgZm9yIGV4Y2VwdGlvbiByZXBvcnRl ZCB3aXRoIEVDPTB4MTguCj4gPiArICogVGhlc2UgbXVzdCBvbmx5IGJlIGV2YWx1YXRlZCB3aGVu IHJ1bm5pbmcgYSBuZXN0ZWQgaHlwZXJ2aXNvciwgYnV0Cj4gPiArICogdGhhdCB0aGUgY3VycmVu dCBjb250ZXh0IGlzIG5vdCBhIGh5cGVydmlzb3IgY29udGV4dC4gV2hlbiB0aGUKPiA+ICsgKiB0 cmFwcGVkIGFjY2VzcyBtYXRjaGVzIG9uZSBvZiB0aGUgdHJhcCBjb250cm9scywgdGhlIGV4Y2Vw dGlvbiBpcwo+ID4gKyAqIHJlLWluamVjdGVkIGluIHRoZSBuZXN0ZWQgaHlwZXJ2aXNvci4KPiBJ IG11c3QgY29uZmVzcyBJIHdhcyBjb25mdXNlZCBieSB0aGUgImZvcndhcmRpbmciIHRlcm1pbm9s b2d5IHZlcnN1cwo+ICJyZS1pbmplY3Rpb24gaW50byB0aGUgbmVzdGVkIGh5cCLCoAo+IAo+IGNm Lgo+IAo+ICJkZWNpZGUgd2hldGhlciBhIHRyYXAgZnJvbSBhIEwyKyBndWVzdCBoYXMgdG8gYmUg Zm9yd2FyZGVkIHRvIGEgTDEgZ3Vlc3QKPiBvciBoYW5kbGVkIGxvY2FsbHkiCj4gCj4gInJlLWlu amVjdGlvbiBpbnRvIHRoZSBuZXN0ZWQgaHlwIiBzb3VuZHMgY2xlYXJlciB0byBtZS4KCkkgc2Vl IHRoZW0gYXMgdHdvIHNpZGVzIG9mIHRoZSBzYW1lIGNvaW46IHRoZSAiZm9yd2FyZGluZyIgaXMg dGhlCmhpZ2gtbGV2ZWwgYWN0aW9uICh3ZSBwYXNzIHRoZSBleGNlcHRpb24gb24gdG8gdGhlIEwx IGh5cGVydmlzb3IpLiBUaGUKInJlLWluamVjdGlvbiIgaXMgdGhlIGxvdy1sZXZlbCBpbXBsZW1l bnRhdGlvbiBvZiB0aGUgZm9yd2FyZGluZywKd2hpY2ggaXMgYSBjb21wbGljYXRlZCBwcm9jZXNz IChhIGZ1bGwgd29ybGQgc3dpdGNoKS4KCj4gCj4gPiArICovCj4gPiArc3RhdGljIGNvbnN0IHN0 cnVjdCBlbmNvZGluZ190b190cmFwX2NvbmZpZyBlbmNvZGluZ190b19jZ3RbXSBfX2luaXRjb25z dCA9IHsKPiA+ICt9Owo+ID4gKwo+ID4gK3N0YXRpYyBERUZJTkVfWEFSUkFZKHNyX2ZvcndhcmRf eGEpOwo+ID4gKwo+ID4gK3N0YXRpYyB1bmlvbiB0cmFwX2NvbmZpZyBnZXRfdHJhcF9jb25maWco dTMyIHN5c3JlZykKPiA+ICt7Cj4gPiArCXJldHVybiAodW5pb24gdHJhcF9jb25maWcpIHsKPiA+ ICsJCS52YWwgPSB4YV90b192YWx1ZSh4YV9sb2FkKCZzcl9mb3J3YXJkX3hhLCBzeXNyZWcpKSwK PiA+ICsJfTsKPiA+ICt9Cj4gPiArCj4gPiAraW50IF9faW5pdCBwb3B1bGF0ZV9udl90cmFwX2Nv bmZpZyh2b2lkKQo+ID4gK3sKPiA+ICsJaW50IHJldCA9IDA7Cj4gPiArCj4gPiArCUJVSUxEX0JV R19PTihzaXplb2YodW5pb24gdHJhcF9jb25maWcpICE9IHNpemVvZih2b2lkICopKTsKPiA+ICsJ QlVJTERfQlVHX09OKF9fTlJfVFJBUF9HUk9VUF9JRFNfXyA+IEJJVChUQ19DR1RfQklUUykpOwo+ ID4gKwo+ID4gKwlmb3IgKGludCBpID0gMDsgaSA8IEFSUkFZX1NJWkUoZW5jb2RpbmdfdG9fY2d0 KTsgaSsrKSB7Cj4gPiArCQljb25zdCBzdHJ1Y3QgZW5jb2RpbmdfdG9fdHJhcF9jb25maWcgKmNn dCA9ICZlbmNvZGluZ190b19jZ3RbaV07Cj4gPiArCQl2b2lkICpwcmV2Owo+ID4gKwo+ID4gKwkJ cHJldiA9IHhhX3N0b3JlX3JhbmdlKCZzcl9mb3J3YXJkX3hhLCBjZ3QtPmVuY29kaW5nLCBjZ3Qt PmVuZCwKPiA+ICsJCQkJICAgICAgeGFfbWtfdmFsdWUoY2d0LT50Yy52YWwpLCBHRlBfS0VSTkVM KTsKPiA+ICsKPiA+ICsJCWlmIChwcmV2KSB7Cj4gPiArCQkJa3ZtX2VycigiRHVwbGljYXRlIENH VCBmb3IgKCVkLCAlZCwgJWQsICVkLCAlZClcbiIsCj4gPiArCQkJCXN5c19yZWdfT3AwKGNndC0+ ZW5jb2RpbmcpLAo+ID4gKwkJCQlzeXNfcmVnX09wMShjZ3QtPmVuY29kaW5nKSwKPiA+ICsJCQkJ c3lzX3JlZ19DUm4oY2d0LT5lbmNvZGluZyksCj4gPiArCQkJCXN5c19yZWdfQ1JtKGNndC0+ZW5j b2RpbmcpLAo+ID4gKwkJCQlzeXNfcmVnX09wMihjZ3QtPmVuY29kaW5nKSk7Cj4gPiArCQkJcmV0 ID0gLUVJTlZBTDsKPiA+ICsJCX0KPiA+ICsJfQo+ID4gKwo+ID4gKwlrdm1faW5mbygibnY6ICVs ZCBjb2Fyc2UgZ3JhaW5lZCB0cmFwIGhhbmRsZXJzXG4iLAo+ID4gKwkJIEFSUkFZX1NJWkUoZW5j b2RpbmdfdG9fY2d0KSk7Cj4gPiArCj4gPiArCWZvciAoaW50IGlkID0gX19NVUxUSVBMRV9DT05U Uk9MX0JJVFNfXzsKPiA+ICsJICAgICBpZCA8IChfX0NPTVBMRVhfQ09ORElUSU9OU19fIC0gMSk7 Cj4gPiArCSAgICAgaWQrKykgewo+ID4gKwkJY29uc3QgZW51bSB0cmFwX2dyb3VwICpjZ2lkczsK PiA+ICsKPiA+ICsJCWNnaWRzID0gY29hcnNlX2NvbnRyb2xfY29tYm9baWQgLSBfX01VTFRJUExF X0NPTlRST0xfQklUU19fXTsKPiA+ICsKPiA+ICsJCWZvciAoaW50IGkgPSAwOyBjZ2lkc1tpXSAh PSBfX1JFU0VSVkVEX187IGkrKykgewo+ID4gKwkJCWlmIChjZ2lkc1tpXSA+PSBfX01VTFRJUExF X0NPTlRST0xfQklUU19fKSB7Cj4gPiArCQkJCWt2bV9lcnIoIlJlY3Vyc2l2ZSBNQ0IgJWQvJWRc biIsIGlkLCBjZ2lkc1tpXSk7Cj4gPiArCQkJCXJldCA9IC1FSU5WQUw7Cj4gPiArCQkJfQo+ID4g KwkJfQo+ID4gKwl9Cj4gPiArCj4gPiArCWlmIChyZXQpCj4gPiArCQl4YV9kZXN0cm95KCZzcl9m b3J3YXJkX3hhKTsKPiA+ICsKPiA+ICsJcmV0dXJuIHJldDsKPiA+ICt9Cj4gPiArCj4gPiArc3Rh dGljIGVudW0gdHJhcF9iZWhhdmlvdXIgZ2V0X2JlaGF2aW91cihzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUsCj4gPiArCQkJCQkgY29uc3Qgc3RydWN0IHRyYXBfYml0cyAqdGIpCj4gPiArewo+ID4gKwll bnVtIHRyYXBfYmVoYXZpb3VyIGIgPSBCRUhBVkVfSEFORExFX0xPQ0FMTFk7Cj4gPiArCXU2NCB2 YWw7Cj4gPiArCj4gPiArCXZhbCA9IF9fdmNwdV9zeXNfcmVnKHZjcHUsIHRiLT5pbmRleCk7Cj4g PiArCWlmICgodmFsICYgdGItPm1hc2spID09IHRiLT52YWx1ZSkKPiA+ICsJCWIgfD0gdGItPmJl aGF2aW91cjsKPiA+ICsKPiA+ICsJcmV0dXJuIGI7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBl bnVtIHRyYXBfYmVoYXZpb3VyIF9fZG9fY29tcHV0ZV90cmFwX2JlaGF2aW91cihzdHJ1Y3Qga3Zt X3ZjcHUgKnZjcHUsCj4gPiArCQkJCQkJICAgICAgIGNvbnN0IGVudW0gdHJhcF9ncm91cCBpZCwK PiA+ICsJCQkJCQkgICAgICAgZW51bSB0cmFwX2JlaGF2aW91ciBiKQo+ID4gK3sKPiA+ICsJc3dp dGNoIChpZCkgewo+ID4gKwkJY29uc3QgZW51bSB0cmFwX2dyb3VwICpjZ2lkczsKPiA+ICsKPiA+ ICsJY2FzZSBfX1JFU0VSVkVEX18gLi4uIF9fTVVMVElQTEVfQ09OVFJPTF9CSVRTX18gLSAxOgo+ ID4gKwkJaWYgKGxpa2VseShpZCAhPSBfX1JFU0VSVkVEX18pKQo+ID4gKwkJCWIgfD0gZ2V0X2Jl aGF2aW91cih2Y3B1LCAmY29hcnNlX3RyYXBfYml0c1tpZF0pOwo+ID4gKwkJYnJlYWs7Cj4gPiAr CWNhc2UgX19NVUxUSVBMRV9DT05UUk9MX0JJVFNfXyAuLi4gX19DT01QTEVYX0NPTkRJVElPTlNf XyAtIDE6Cj4gPiArCQkvKiBZZXMsIHRoaXMgaXMgcmVjdXJzaXZlLiBEb24ndCBkbyBhbnl0aGlu ZyBzdHVwaWQuICovCj4gPiArCQljZ2lkcyA9IGNvYXJzZV9jb250cm9sX2NvbWJvW2lkIC0gX19N VUxUSVBMRV9DT05UUk9MX0JJVFNfX107Cj4gPiArCQlmb3IgKGludCBpID0gMDsgY2dpZHNbaV0g IT0gX19SRVNFUlZFRF9fOyBpKyspCj4gPiArCQkJYiB8PSBfX2RvX2NvbXB1dGVfdHJhcF9iZWhh dmlvdXIodmNwdSwgY2dpZHNbaV0sIGIpOwo+ID4gKwkJYnJlYWs7Cj4gPiArCWRlZmF1bHQ6Cj4g PiArCQlpZiAoQVJSQVlfU0laRShjY2MpKQo+ID4gKwkJCWIgfD0gY2NjW2lkIC0gIF9fQ09NUExF WF9DT05ESVRJT05TX19dKHZjcHUpOwo+ID4gKwkJYnJlYWs7Cj4gPiArCX0KPiA+ICsKPiA+ICsJ cmV0dXJuIGI7Cj4gPiArfQo+ID4gKwo+ID4gK3N0YXRpYyBlbnVtIHRyYXBfYmVoYXZpb3VyIGNv bXB1dGVfdHJhcF9iZWhhdmlvdXIoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAo+ID4gKwkJCQkJCSAg Y29uc3QgdW5pb24gdHJhcF9jb25maWcgdGMpCj4gPiArewo+ID4gKwllbnVtIHRyYXBfYmVoYXZp b3VyIGIgPSBCRUhBVkVfSEFORExFX0xPQ0FMTFk7Cj4gPiArCj4gPiArCXJldHVybiBfX2RvX2Nv bXB1dGVfdHJhcF9iZWhhdmlvdXIodmNwdSwgdGMuY2d0LCBiKTsKPiA+ICt9Cj4gPiArCj4gPiAr Ym9vbCBfX2NoZWNrX252X3NyX2ZvcndhcmQoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ID4gK3sK PiA+ICsJdW5pb24gdHJhcF9jb25maWcgdGM7Cj4gPiArCWVudW0gdHJhcF9iZWhhdmlvdXIgYjsK PiA+ICsJYm9vbCBpc19yZWFkOwo+ID4gKwl1MzIgc3lzcmVnOwo+ID4gKwl1NjQgZXNyOwo+ID4g Kwo+ID4gKwlpZiAoIXZjcHVfaGFzX252KHZjcHUpIHx8IGlzX2h5cF9jdHh0KHZjcHUpKQo+ID4g KwkJcmV0dXJuIGZhbHNlOwo+ID4gKwo+ID4gKwllc3IgPSBrdm1fdmNwdV9nZXRfZXNyKHZjcHUp Owo+ID4gKwlzeXNyZWcgPSBlc3Jfc3lzNjRfdG9fc3lzcmVnKGVzcik7Cj4gPiArCWlzX3JlYWQg PSAoZXNyICYgRVNSX0VMeF9TWVM2NF9JU1NfRElSX01BU0spID09IEVTUl9FTHhfU1lTNjRfSVNT X0RJUl9SRUFEOwo+ID4gKwo+ID4gKwl0YyA9IGdldF90cmFwX2NvbmZpZyhzeXNyZWcpOwo+ID4g Kwo+ID4gKwkvKgo+ID4gKwkgKiBBIHZhbHVlIG9mIDAgZm9yIHRoZSB3aG9sZSBlbnRyeSBtZWFu cyB0aGF0IHdlIGtub3cgbm90aGluZwo+ID4gKwkgKiBmb3IgdGhpcyBzeXNyZWcsIGFuZCB0aGF0 IGl0IGNhbm5vdCBiZSBmb3J3YXJlZGVkLiBJbiB0aGlzCj4gZm9yd2FyZGVkCgpGaXhlZC4KClRo YW5rcyBhZ2FpbiBmb3IgYWxsIHlvdXIgc3VnZ2VzdGlvbnMuCgoJTS4KCi0tIApXaXRob3V0IGRl dmlhdGlvbiBmcm9tIHRoZSBub3JtLCBwcm9ncmVzcyBpcyBub3QgcG9zc2libGUuCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVs IG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==