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.4 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 AA76AC433EF for ; Sun, 5 Sep 2021 20:56:21 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 89E4F60F90 for ; Sun, 5 Sep 2021 20:56:21 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238230AbhIEU5W (ORCPT ); Sun, 5 Sep 2021 16:57:22 -0400 Received: from mail.kernel.org ([198.145.29.99]:46050 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230217AbhIEU5V (ORCPT ); Sun, 5 Sep 2021 16:57:21 -0400 Received: by mail.kernel.org (Postfix) with ESMTPSA id C21706103E for ; Sun, 5 Sep 2021 20:56:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1630875377; bh=rKPAEQ3xd0gQPzqhrNVQNiukwEH1sFQZX9esT8huMKE=; h=References:In-Reply-To:From:Date:Subject:To:Cc:From; b=rFtwErdZp2o1fgcqTA9mp3sp7PsYoyOoZ9C7QExLZ3rOJ5KLbA1ESkB6pzjzUY93q t/vrDsF/KsPjw9Kmm+PyYlJROAPoTUl2ucd3pYcPpRodP7/wN2XJN6oc4/awft1GjC fikUtgKUv2z0B4MW9yQIbyhkm7JLXyZ+rg39u/4joR4MAJaYL1MnsZ6tjUyP2KgGCB yJfTltDSruZSAHtn2e2Pg/meJ8m43Z2yk2fIJc84DtnPItthARAdc1flg48WPZxvE5 wgaOO87dYRVAZktDA7TmvveYl6O+a2bN18/tkjQD24B7IkWKPGRmnTp1rDCZpV8q0f lDg0gq2rcGzzA== Received: by mail-ot1-f42.google.com with SMTP id o16-20020a9d2210000000b0051b1e56c98fso6242368ota.8 for ; Sun, 05 Sep 2021 13:56:17 -0700 (PDT) X-Gm-Message-State: AOAM53157leqQJJ+c8n9x4gUivJu1NddTwRDKKJJP52sCxebpGib4pnI +lyhSIN2Od0KEcgsgdwYcpK5avYbTmCFWnr/CZg= X-Google-Smtp-Source: ABdhPJz1bJVqmynPC8kyz3pLCB7Ud/y7jG/KjbHQ0NF6vmd78QbEKxDPD7a+VLjMCMGXkOKhxm0EXS43nFQyN0WA5WY= X-Received: by 2002:a9d:200b:: with SMTP id n11mr8125947ota.30.1630875376711; Sun, 05 Sep 2021 13:56:16 -0700 (PDT) MIME-Version: 1.0 References: <20210902155429.3987201-1-keithp@keithp.com> <20210904060908.1310204-1-keithp@keithp.com> <20210904060908.1310204-3-keithp@keithp.com> In-Reply-To: <20210904060908.1310204-3-keithp@keithp.com> From: Ard Biesheuvel Date: Sun, 5 Sep 2021 22:56:05 +0200 X-Gmail-Original-Message-ID: Message-ID: Subject: Re: [PATCH 2/3] ARM: Move thread_info into task_struct (v7 only) To: Keith Packard Cc: Linux Kernel Mailing List , Abbott Liu , Alexander Sverdlin , Andrew Morton , Anshuman Khandual , Arnd Bergmann , Bjorn Andersson , Florian Fainelli , Geert Uytterhoeven , Hartley Sweeten , Jens Axboe , Jian Cai , Joe Perches , Kees Cook , Krzysztof Kozlowski , Linus Walleij , Linux ARM , Manivannan Sadhasivam , Marc Zyngier , Masahiro Yamada , Miguel Ojeda , Mike Rapoport , Nathan Chancellor , Nick Desaulniers , Nicolas Pitre , Rob Herring , Russell King , Thomas Gleixner , =?UTF-8?Q?Uwe_Kleine=2DK=C3=B6nig?= , Valentin Schneider , Viresh Kumar , "Wolfram Sang (Renesas)" , YiFei Zhu , Keith Packard Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Sat, 4 Sept 2021 at 08:09, Keith Packard wrote: > > This avoids many stack overflow attacks which modified the thread_info > structure by moving that into the task_struct as is done is almost all > other architectures. > > The task_struct is now referenced by a per-cpu variable, > 'current_task', allowing the current one on each cpu to be located > from both C and assembly. > > This also involved removing the 'cpu' member from the thread_info > struct and using the one added to the task_struct instead by the > THREAD_INFO_IN_TASK code. > > This code is currently enabled only for v7 hardware as other ARM > architectures do not make the c13 register in the p15 co-processor > available for general OS use, leaving identifying the current cpu to > the 'cpu' field in the thread_info located off the stack pointer. > c13 is not a register, it is a value in one of the dimensions of the ARM sysreg space, and probably covers other system registers that pre-v7 cores do implement. Better to use its architectural name (TPIDRPRW) and clarify that pre-v6k/v7 cores simply don't implement it. > Signed-off-by: Keith Packard > --- > arch/arm/Kconfig | 1 + > arch/arm/Makefile | 8 ++++ > arch/arm/include/asm/assembler.h | 66 ++++++++++++++++++++++++++---- > arch/arm/include/asm/current.h | 41 +++++++++++++++++++ > arch/arm/include/asm/smp.h | 18 ++++++++ > arch/arm/include/asm/thread_info.h | 17 ++++++++ > arch/arm/kernel/asm-offsets.c | 4 ++ > arch/arm/kernel/entry-armv.S | 17 ++++---- > arch/arm/kernel/entry-common.S | 6 +-- > arch/arm/kernel/entry-v7m.S | 7 +++- > arch/arm/kernel/iwmmxt.S | 2 +- > arch/arm/kernel/smp.c | 12 ++++++ > arch/arm/lib/copy_from_user.S | 2 +- > arch/arm/lib/copy_to_user.S | 2 +- > arch/arm/mach-ep93xx/crunch-bits.S | 2 +- > arch/arm/mm/proc-macros.S | 2 +- > arch/arm/vfp/entry.S | 4 ++ > arch/arm/vfp/vfpmodule.c | 25 +++++++---- > 18 files changed, 204 insertions(+), 32 deletions(-) > create mode 100644 arch/arm/include/asm/current.h > Could we split this up? > diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig > index 24804f11302d..1c1ded500a2b 100644 > --- a/arch/arm/Kconfig > +++ b/arch/arm/Kconfig > @@ -128,6 +128,7 @@ config ARM > select RTC_LIB > select SET_FS > select SYS_SUPPORTS_APM_EMULATION > + select THREAD_INFO_IN_TASK if CPU_V7 CPU_V6K also supports this > # Above selects are sorted alphabetically; please add new ones > # according to that. Thanks. > help > diff --git a/arch/arm/Makefile b/arch/arm/Makefile > index 415c3514573a..71a2ba4549d3 100644 > --- a/arch/arm/Makefile > +++ b/arch/arm/Makefile > @@ -284,6 +284,14 @@ stack_protector_prepare: prepare0 > $(eval GCC_PLUGINS_CFLAGS +=3D $(SSP_PLUGIN_CFLAGS)) > endif > > +ifdef CONFIG_SMP > +prepare: task_cpu_prepare > + > +PHONY +=3D task_cpu_prepare > +task_cpu_prepare: prepare0 > + $(eval KBUILD_CFLAGS +=3D -D_TSK_CPU=3D$(shell awk '{if ($$2 =3D= =3D "TSK_CPU") print $$3;}' include/generated/asm-offsets.h)) > +endif > + > all: $(notdir $(KBUILD_IMAGE)) > This is rather horrid, and removed again in the next patch. Can we omit it entirely? > > diff --git a/arch/arm/include/asm/assembler.h b/arch/arm/include/asm/asse= mbler.h > index e2b1fd558bf3..2ce7403f9298 100644 > --- a/arch/arm/include/asm/assembler.h > +++ b/arch/arm/include/asm/assembler.h > @@ -199,16 +199,68 @@ > .endm > .endr > > +#ifdef CONFIG_THREAD_INFO_IN_TASK No need for this #ifdef - it only guards macros that will have no effect if they are never instantiated (another case below) > /* > - * Get current thread_info. > + * Get per-CPU offset > + * rd: Destination register > */ > - .macro get_thread_info, rd > - ARM( mov \rd, sp, lsr #THREAD_SIZE_ORDER + PAGE_SHIFT ) > - THUMB( mov \rd, sp ) > - THUMB( lsr \rd, \rd, #THREAD_SIZE_ORDER + PAGE_SHIFT ) > - mov \rd, \rd, lsl #THREAD_SIZE_ORDER + PAGE_SHIFT > + .macro this_cpu_offset rd:req > + mrc p15, 0, \rd, c13, c0, 4 > .endm > > +/* > + * Load a per-cpu variable > + * @dst: Destination register to receive value > + * @sym: The name of the per-cpu variable > + * @tmp: scratch register > + */ > + .macro ldr_this_cpu dst : req, sym : req, tmp : req > + movw \dst, #:lower16:\sym > + movt \dst, #:upper16:\sym > + this_cpu_offset \tmp > + ldr \dst, [\dst, \tmp] > + .endm > + > +/* > + * Store a value in a per-cpu variable > + * @src: Source register with value > + * @sym: The name of the per-cpu variable > + * @t1: scratch register 1 > + * @t2: scratch register 2 > + */ > + .macro str_this_cpu src : req, sym : req, t1 : req, t2 : req > + movw \t1, #:lower16:\sym > + movt \t1, #:upper16:\sym > + this_cpu_offset \t2 > + str \src, [\t1, \t2] > + .endm > +#endif > + > +/* > + * Get current thread_info > + * @dst: Destination register to receive current thread info > + * @tmp: scratch register > + */ > + .macro get_current, dst : req, tmp : req > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + ldr_this_cpu \dst, current_task, \tmp > +#else > + ARM( mov \dst, sp, lsr #THREAD_SIZE_ORDER + PAGE_SHIFT ) > + THUMB( mov \dst, sp ) > + THUMB( lsr \dst, \dst, #THREAD_SIZE_ORDER + PAGE_SHIFT ) > + mov \dst, \dst, lsl #THREAD_SIZE_ORDER + PAGE_SHIFT > +#endif > + .endm > + > +#ifdef CONFIG_THREAD_INFO_IN_TASK > +/* > + * Set current task info > + */ > + .macro set_current_task rs : req, t1 : req, t2 : req > + str_this_cpu \rs, current_task, \t1, \t2 > + .endm > +#endif > + > /* > * Increment/decrement the preempt count. > */ > @@ -226,7 +278,7 @@ > .endm > > .macro dec_preempt_count_ti, ti, tmp > - get_thread_info \ti > + get_current \ti, \tmp > dec_preempt_count \ti, \tmp > .endm > #else > diff --git a/arch/arm/include/asm/current.h b/arch/arm/include/asm/curren= t.h > new file mode 100644 > index 000000000000..7160315eb569 > --- /dev/null > +++ b/arch/arm/include/asm/current.h > @@ -0,0 +1,41 @@ > +/* > + * Copyright =C2=A9 2021 Keith Packard > + * > + * This program is free software; you can redistribute it and/or modify > + * it under the terms of the GNU General Public License as published by > + * the Free Software Foundation, either version 2 of the License, or > + * (at your option) any later version. > + * > + * This program is distributed in the hope that it will be useful, but > + * WITHOUT ANY WARRANTY; without even the implied warranty of > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + * General Public License for more details. Please drop the boilerplate and use a SPDX header instead. > + */ > + > +#ifndef _ASM_ARM_CURRENT_H > +#define _ASM_ARM_CURRENT_H > + > +#include > +#include > +#include > + > +#ifndef __ASSEMBLY__ > + > +#ifdef CONFIG_THREAD_INFO_IN_TASK > +struct task_struct; > + > +DECLARE_PER_CPU(struct task_struct *, current_task); > + > +static __always_inline struct task_struct *get_current(void) > +{ > + return raw_cpu_read(current_task); This needs to run with preemption disabled, or we might get migrated to another CPU halfway through, and produce the wrong result (i.e., the current task of the CPU we migrated from). However, it appears that manipulating the preempt count will create a circular dependency here. Instead of using a per-CPU variable for current, I think it might be better to borrow another system register (TPIDRURO or TPIDRURW) to carry 'current' when THREAD_INFO_IN_TASK is in effect, similar to how arm64 uses SP_EL0 - those registers could be preserved/restored in the entry/exit from/to user space paths rather than in the context switch path, and then be used any way we like while running in the kernel. > +} > + > +#define current get_current() > +#else > +#include > +#endif > + > +#endif /* __ASSEMBLY__ */ > + > +#endif /* _ASM_ARM_CURRENT_H */ > diff --git a/arch/arm/include/asm/smp.h b/arch/arm/include/asm/smp.h > index 86a7fd721556..1c38d1fde641 100644 > --- a/arch/arm/include/asm/smp.h > +++ b/arch/arm/include/asm/smp.h > @@ -15,7 +15,25 @@ > # error " included in non-SMP build" > #endif > > +#ifdef CONFIG_THREAD_INFO_IN_TASK > +/* > + * This is particularly ugly: it appears we can't actually get the defin= ition > + * of task_struct here, but we need access to the CPU this task is runni= ng on. > + * Instead of using task_struct we're using TSK_CPU which is extracted f= rom > + * asm-offsets.h by kbuild to get the current processor ID. > + * > + * This also needs to be safeguarded when building asm-offsets.s because= at > + * that time TSK_CPU is not defined yet. > + */ > +#ifndef _TSK_CPU > +#define raw_smp_processor_id() (0) > +#else > +#define raw_smp_processor_id() (*(unsigned int *)((void *)curren= t + _TSK_CPU)) > +#endif > + > +#else > #define raw_smp_processor_id() (current_thread_info()->cpu) > +#endif > > struct seq_file; > > diff --git a/arch/arm/include/asm/thread_info.h b/arch/arm/include/asm/th= read_info.h > index 70d4cbc49ae1..cbcd476a095b 100644 > --- a/arch/arm/include/asm/thread_info.h > +++ b/arch/arm/include/asm/thread_info.h > @@ -55,8 +55,10 @@ struct thread_info { > unsigned long flags; /* low level flags */ > int preempt_count; /* 0 =3D> preemptable, <0= =3D> bug */ > mm_segment_t addr_limit; /* address limit */ > +#ifndef CONFIG_THREAD_INFO_IN_TASK > struct task_struct *task; /* main task structure */ > __u32 cpu; /* cpu */ > +#endif > __u32 cpu_domain; /* cpu domain */ > #ifdef CONFIG_STACKPROTECTOR_PER_TASK > unsigned long stack_canary; > @@ -75,6 +77,17 @@ struct thread_info { > #endif > }; > > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + > +#define INIT_THREAD_INFO(tsk) \ > +{ \ > + .flags =3D 0, = \ > + .preempt_count =3D INIT_PREEMPT_COUNT, = \ > + .addr_limit =3D KERNEL_DS, = \ > +} > + > +#else > + > #define INIT_THREAD_INFO(tsk) \ > { \ > .task =3D &tsk, = \ > @@ -83,6 +96,9 @@ struct thread_info { > .addr_limit =3D KERNEL_DS, = \ > } > > +#endif > + > +#ifndef CONFIG_THREAD_INFO_IN_TASK > /* > * how to get the thread information struct from C > */ > @@ -93,6 +109,7 @@ static inline struct thread_info *current_thread_info(= void) > return (struct thread_info *) > (current_stack_pointer & ~(THREAD_SIZE - 1)); > } > +#endif > > #define thread_saved_pc(tsk) \ > ((unsigned long)(task_thread_info(tsk)->cpu_context.pc)) > diff --git a/arch/arm/kernel/asm-offsets.c b/arch/arm/kernel/asm-offsets.= c > index 70993af22d80..c91dcfe34bdd 100644 > --- a/arch/arm/kernel/asm-offsets.c > +++ b/arch/arm/kernel/asm-offsets.c > @@ -44,8 +44,12 @@ int main(void) > DEFINE(TI_FLAGS, offsetof(struct thread_info, flags)); > DEFINE(TI_PREEMPT, offsetof(struct thread_info, preempt_coun= t)); > DEFINE(TI_ADDR_LIMIT, offsetof(struct thread_info, addr= _limit)); > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + DEFINE(TSK_CPU, offsetof(struct task_struct, cpu)); > +#else > DEFINE(TI_TASK, offsetof(struct thread_info, task)); > DEFINE(TI_CPU, offsetof(struct thread_info, cpu)); > +#endif > DEFINE(TI_CPU_DOMAIN, offsetof(struct thread_info, cpu_= domain)); > DEFINE(TI_CPU_SAVE, offsetof(struct thread_info, cpu_context)= ); > DEFINE(TI_USED_CP, offsetof(struct thread_info, used_cp)); > diff --git a/arch/arm/kernel/entry-armv.S b/arch/arm/kernel/entry-armv.S > index 0ea8529a4872..a5d71b0d8897 100644 > --- a/arch/arm/kernel/entry-armv.S > +++ b/arch/arm/kernel/entry-armv.S > @@ -179,7 +179,7 @@ ENDPROC(__und_invalid) > @ > stmia r7, {r2 - r6} > > - get_thread_info tsk > + get_current tsk, r0 > uaccess_entry tsk, r0, r1, r2, \uaccess > > .if \trace > @@ -260,7 +260,7 @@ __und_svc: > bl __und_fault > > __und_svc_finish: > - get_thread_info tsk > + get_current tsk, r5 > ldr r5, [sp, #S_PSR] @ Get SVC cpsr > svc_exit r5 @ return from exception > UNWIND(.fnend ) > @@ -428,7 +428,7 @@ __irq_usr: > usr_entry > kuser_cmpxchg_check > irq_handler > - get_thread_info tsk > + get_current tsk, why > mov why, #0 > b ret_to_user_from_irq > UNWIND(.fnend ) > @@ -572,12 +572,12 @@ ENDPROC(__und_usr) > @ Fall-through from Thumb-2 __und_usr > @ > #ifdef CONFIG_NEON > - get_thread_info r10 @ get current thread > + get_current r10, r6 @ get current thread > adr r6, .LCneon_thumb_opcodes > b 2f > #endif > call_fpe: > - get_thread_info r10 @ get current thread > + get_current r10, r6 @ get current thread > #ifdef CONFIG_NEON > adr r6, .LCneon_arm_opcodes > 2: ldr r5, [r6], #4 @ mask value > @@ -722,7 +722,7 @@ __pabt_usr: > ENTRY(ret_from_exception) > UNWIND(.fnstart ) > UNWIND(.cantunwind ) > - get_thread_info tsk > + get_current tsk, why > mov why, #0 > b ret_to_user > UNWIND(.fnend ) > @@ -735,7 +735,7 @@ __fiq_usr: > kuser_cmpxchg_check > mov r0, sp @ struct pt_regs *regs > bl handle_fiq_as_nmi > - get_thread_info tsk > + get_current tsk, r0 > restore_user_regs fast =3D 0, offset =3D 0 > UNWIND(.fnend ) > ENDPROC(__fiq_usr) > @@ -771,6 +771,9 @@ ENTRY(__switch_to) > #endif > #ifdef CONFIG_CPU_USE_DOMAINS > mcr p15, 0, r6, c3, c0, 0 @ Set domain register > +#endif > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + set_current_task r2, r4, r5 > #endif > mov r5, r0 > add r4, r2, #TI_CPU_SAVE > diff --git a/arch/arm/kernel/entry-common.S b/arch/arm/kernel/entry-commo= n.S > index 7f0b7aba1498..52580ee463fe 100644 > --- a/arch/arm/kernel/entry-common.S > +++ b/arch/arm/kernel/entry-common.S > @@ -156,7 +156,7 @@ ENTRY(ret_from_fork) > movne r0, r4 > badrne lr, 1f > retne r5 > -1: get_thread_info tsk > +1: get_current tsk, r1 > b ret_slow_syscall > ENDPROC(ret_from_fork) > > @@ -243,7 +243,7 @@ ENTRY(vector_swi) > bic scno, scno, #0xff000000 @ mask off SWI op-code > eor scno, scno, #__NR_SYSCALL_BASE @ check OS number > #endif > - get_thread_info tsk > + get_current tsk, r10 > /* > * Reload the registers that may have been corrupted on entry to > * the syscall assembly (by tracing or context tracking.) > @@ -278,7 +278,7 @@ local_restart: > 9001: > sub lr, saved_pc, #4 > str lr, [sp, #S_PC] > - get_thread_info tsk > + get_current tsk, r1 > b ret_fast_syscall > #endif > ENDPROC(vector_swi) > diff --git a/arch/arm/kernel/entry-v7m.S b/arch/arm/kernel/entry-v7m.S > index d0e898608d30..f36a7a876085 100644 > --- a/arch/arm/kernel/entry-v7m.S > +++ b/arch/arm/kernel/entry-v7m.S > @@ -57,7 +57,7 @@ __irq_entry: > tst r0, V7M_SCB_ICSR_RETTOBASE > beq 2f > > - get_thread_info tsk > + get_current tsk, r2 > ldr r2, [tsk, #TI_FLAGS] > movs r2, r2, lsl #16 > beq 2f @ no work pending > @@ -83,7 +83,7 @@ __pendsv_entry: > str r0, [r1, V7M_SCB_ICSR] @ clear PendSV > > @ execute the pending work, including reschedule > - get_thread_info tsk > + get_current tsk, why > mov why, #0 > b ret_to_user_from_irq > ENDPROC(__pendsv_entry) > @@ -107,6 +107,9 @@ ENTRY(__switch_to) > bl atomic_notifier_call_chain > mov ip, r4 > mov r0, r5 > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + set_current_task r2, r4, r5 > +#endif > ldmia ip!, {r4 - r11} @ Load all regs saved previously > ldr sp, [ip] > ldr pc, [ip, #4]! > diff --git a/arch/arm/kernel/iwmmxt.S b/arch/arm/kernel/iwmmxt.S > index d2b4ac06e4ed..781f7c7fca90 100644 > --- a/arch/arm/kernel/iwmmxt.S > +++ b/arch/arm/kernel/iwmmxt.S > @@ -96,7 +96,7 @@ ENTRY(iwmmxt_task_enable) > bl concan_save > > #ifdef CONFIG_PREEMPT_COUNT > - get_thread_info r10 > + get_current r10, r3 > #endif > 4: dec_preempt_count r10, r3 > ret r9 @ normal exit from except= ion > diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c > index 55cb1689a4b3..be0ede16dbb1 100644 > --- a/arch/arm/kernel/smp.c > +++ b/arch/arm/kernel/smp.c > @@ -51,6 +51,13 @@ > #define CREATE_TRACE_POINTS > #include > > +#ifdef CONFIG_THREAD_INFO_IN_TASK > +DEFINE_PER_CPU(struct task_struct *, current_task) ____cacheline_aligned= =3D > + &init_task; > +EXPORT_PER_CPU_SYMBOL(current_task); > + > +#endif > + > /* > * as from 2.5, kernels no longer have an init_tasks structure > * so we need some other way of telling a new secondary core > @@ -156,6 +163,10 @@ int __cpu_up(unsigned int cpu, struct task_struct *i= dle) > secondary_data.cpu =3D cpu; > sync_cache_w(&secondary_data); > > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + per_cpu(current_task, cpu) =3D idle; > +#endif > + > /* > * Now bring the CPU into our world. > */ > @@ -509,6 +520,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus) > */ > if (max_cpus > ncores) > max_cpus =3D ncores; > + > if (ncores > 1 && max_cpus) { > /* > * Initialise the present map, which describes the set of= CPUs > diff --git a/arch/arm/lib/copy_from_user.S b/arch/arm/lib/copy_from_user.= S > index f8016e3db65d..5320950100a2 100644 > --- a/arch/arm/lib/copy_from_user.S > +++ b/arch/arm/lib/copy_from_user.S > @@ -109,7 +109,7 @@ > > ENTRY(arm_copy_from_user) > #ifdef CONFIG_CPU_SPECTRE > - get_thread_info r3 > + get_current r3, ip > ldr r3, [r3, #TI_ADDR_LIMIT] > uaccess_mask_range_ptr r1, r2, r3, ip > #endif > diff --git a/arch/arm/lib/copy_to_user.S b/arch/arm/lib/copy_to_user.S > index ebfe4cb3d912..e7e61c87893a 100644 > --- a/arch/arm/lib/copy_to_user.S > +++ b/arch/arm/lib/copy_to_user.S > @@ -109,7 +109,7 @@ > ENTRY(__copy_to_user_std) > WEAK(arm_copy_to_user) > #ifdef CONFIG_CPU_SPECTRE > - get_thread_info r3 > + get_current r3, ip > ldr r3, [r3, #TI_ADDR_LIMIT] > uaccess_mask_range_ptr r0, r2, r3, ip > #endif > diff --git a/arch/arm/mach-ep93xx/crunch-bits.S b/arch/arm/mach-ep93xx/cr= unch-bits.S > index fb2dbf76f09e..d0bb34b3d973 100644 > --- a/arch/arm/mach-ep93xx/crunch-bits.S > +++ b/arch/arm/mach-ep93xx/crunch-bits.S > @@ -192,7 +192,7 @@ crunch_load: > > 1: > #ifdef CONFIG_PREEMPT_COUNT > - get_thread_info r10 > + get_current r10, r3 > #endif > 2: dec_preempt_count r10, r3 > ret lr > diff --git a/arch/arm/mm/proc-macros.S b/arch/arm/mm/proc-macros.S > index e2c743aa2eb2..a782c025fdf3 100644 > --- a/arch/arm/mm/proc-macros.S > +++ b/arch/arm/mm/proc-macros.S > @@ -30,7 +30,7 @@ > * act_mm - get current->active_mm > */ > .macro act_mm, rd > - get_thread_info \rd > + get_current \rd, unused @ won't build if THREAD_I= NFO_IN_TASK > ldr \rd, [\rd, #TI_TASK] > .if (TSK_ACTIVE_MM > IMM12_MASK) > add \rd, \rd, #TSK_ACTIVE_MM & ~IMM12_MASK > diff --git a/arch/arm/vfp/entry.S b/arch/arm/vfp/entry.S > index 27b0a1f27fbd..48cb40a3b72d 100644 > --- a/arch/arm/vfp/entry.S > +++ b/arch/arm/vfp/entry.S > @@ -24,7 +24,11 @@ > ENTRY(do_vfp) > inc_preempt_count r10, r4 > ldr r4, .LCvfp > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + ldr r11, [r10, #TSK_CPU] @ CPU number > +#else > ldr r11, [r10, #TI_CPU] @ CPU number > +#endif > add r10, r10, #TI_VFPSTATE @ r10 =3D workspace > ldr pc, [r4] @ call VFP entry point > ENDPROC(do_vfp) > diff --git a/arch/arm/vfp/vfpmodule.c b/arch/arm/vfp/vfpmodule.c > index 2cb355c1b5b7..f929a26a05a5 100644 > --- a/arch/arm/vfp/vfpmodule.c > +++ b/arch/arm/vfp/vfpmodule.c > @@ -143,22 +143,27 @@ static void vfp_thread_copy(struct thread_info *thr= ead) > * THREAD_NOFTIFY_SWTICH: > * - the previously running thread will not be scheduled onto another = CPU. > * - the next thread to be run (v) will not be running on another CPU. > - * - thread->cpu is the local CPU number > + * - tsk->cpu is the local CPU number > * - not preemptible as we're called in the middle of a thread switch > * THREAD_NOTIFY_FLUSH: > * - the thread (v) will be running on the local CPU, so > - * v =3D=3D=3D current_thread_info() > - * - thread->cpu is the local CPU number at the time it is accessed, > + * v =3D=3D=3D current > + * - tsk->cpu is the local CPU number at the time it is accessed, > * but may change at any time. > * - we could be preempted if tree preempt rcu is enabled, so > - * it is unsafe to use thread->cpu. > + * it is unsafe to use tsk->cpu. > * THREAD_NOTIFY_EXIT > * - we could be preempted if tree preempt rcu is enabled, so > - * it is unsafe to use thread->cpu. > + * it is unsafe to use tsk->cpu. > */ > static int vfp_notifier(struct notifier_block *self, unsigned long cmd, = void *v) > { > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + struct task_struct *tsk =3D v; > + struct thread_info *thread =3D &tsk->thread_info; > +#else > struct thread_info *thread =3D v; > +#endif > u32 fpexc; > #ifdef CONFIG_SMP > unsigned int cpu; > @@ -169,7 +174,11 @@ static int vfp_notifier(struct notifier_block *self,= unsigned long cmd, void *v) > fpexc =3D fmrx(FPEXC); > > #ifdef CONFIG_SMP > +#ifdef CONFIG_THREAD_INFO_IN_TASK > + cpu =3D tsk->cpu; > +#else > cpu =3D thread->cpu; > +#endif > > /* > * On SMP, if VFP is enabled, save the old state in > @@ -458,16 +467,16 @@ static int vfp_pm_suspend(void) > > /* disable, just in case */ > fmxr(FPEXC, fmrx(FPEXC) & ~FPEXC_EN); > - } else if (vfp_current_hw_state[ti->cpu]) { > + } else if (vfp_current_hw_state[smp_processor_id()]) { > #ifndef CONFIG_SMP > fmxr(FPEXC, fpexc | FPEXC_EN); > - vfp_save_state(vfp_current_hw_state[ti->cpu], fpexc); > + vfp_save_state(vfp_current_hw_state[smp_processor_id()], = fpexc); > fmxr(FPEXC, fpexc); > #endif > } > > /* clear any information we had about last context state */ > - vfp_current_hw_state[ti->cpu] =3D NULL; > + vfp_current_hw_state[smp_processor_id()] =3D NULL; > > return 0; > } > -- > 2.33.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 X-Spam-Level: X-Spam-Status: No, score=-14.4 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI, SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED 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 4AAD0C433EF for ; Sun, 5 Sep 2021 20:58:30 +0000 (UTC) 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 mail.kernel.org (Postfix) with ESMTPS id DC03860F5E for ; Sun, 5 Sep 2021 20:58:29 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org DC03860F5E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org 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:Cc:To:Subject:Message-ID:Date:From: In-Reply-To:References:MIME-Version:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=UlsN1DshxYT9NZf/FksJ23mWe7Ha4DjTzPmu5kSJMok=; b=Cw2vNMRriwOWrD GPV2p6AAlTuaGZ9Ny+lWkPhbF/+4QLdWTLRzvt1NvGW1JGEJ8eJQJXPe7hHNKhE0cZXKMN0OmsUaz eYC7hBBA4MKA0XwJuU3npC6kFke4wWrsWATJV22tEj5iObl5l1GwRRpAti/yutKRlUhovuHkm9CLK WZ8KGRYM779yX55w4+qEOj1aeoHadqxU2U9vG1Zk43/ooocRuUNlHw0xbfPl/PBlMyvPaGUIWMPOb 1IVmG/sOk4mbLMoeMy0qWAcUiGAvt9now0/bQhHJD/KUWfOLmXB+no5BzPhQjakZ2ZaITxgQGgIru GGiQxpcR0mqglNftdRhw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1mMzBo-00GRak-6l; Sun, 05 Sep 2021 20:56:32 +0000 Received: from mail.kernel.org ([198.145.29.99]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1mMzBa-00GRY2-5H for linux-arm-kernel@lists.infradead.org; Sun, 05 Sep 2021 20:56:21 +0000 Received: by mail.kernel.org (Postfix) with ESMTPSA id 9EF0F61004 for ; Sun, 5 Sep 2021 20:56:17 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1630875377; bh=rKPAEQ3xd0gQPzqhrNVQNiukwEH1sFQZX9esT8huMKE=; h=References:In-Reply-To:From:Date:Subject:To:Cc:From; b=rFtwErdZp2o1fgcqTA9mp3sp7PsYoyOoZ9C7QExLZ3rOJ5KLbA1ESkB6pzjzUY93q t/vrDsF/KsPjw9Kmm+PyYlJROAPoTUl2ucd3pYcPpRodP7/wN2XJN6oc4/awft1GjC fikUtgKUv2z0B4MW9yQIbyhkm7JLXyZ+rg39u/4joR4MAJaYL1MnsZ6tjUyP2KgGCB yJfTltDSruZSAHtn2e2Pg/meJ8m43Z2yk2fIJc84DtnPItthARAdc1flg48WPZxvE5 wgaOO87dYRVAZktDA7TmvveYl6O+a2bN18/tkjQD24B7IkWKPGRmnTp1rDCZpV8q0f lDg0gq2rcGzzA== Received: by mail-ot1-f51.google.com with SMTP id v33-20020a0568300921b0290517cd06302dso6216689ott.13 for ; Sun, 05 Sep 2021 13:56:17 -0700 (PDT) X-Gm-Message-State: AOAM530fsUHJSCC7HcAa09QvmB+m5fUXuvpGqs5SVa4QiTh8iyhaNx4Y apMHS9ZRAlEZNXyXF8pTcjtKb1HS/eXXMqprbtY= X-Google-Smtp-Source: ABdhPJz1bJVqmynPC8kyz3pLCB7Ud/y7jG/KjbHQ0NF6vmd78QbEKxDPD7a+VLjMCMGXkOKhxm0EXS43nFQyN0WA5WY= X-Received: by 2002:a9d:200b:: with SMTP id n11mr8125947ota.30.1630875376711; Sun, 05 Sep 2021 13:56:16 -0700 (PDT) MIME-Version: 1.0 References: <20210902155429.3987201-1-keithp@keithp.com> <20210904060908.1310204-1-keithp@keithp.com> <20210904060908.1310204-3-keithp@keithp.com> In-Reply-To: <20210904060908.1310204-3-keithp@keithp.com> From: Ard Biesheuvel Date: Sun, 5 Sep 2021 22:56:05 +0200 X-Gmail-Original-Message-ID: Message-ID: Subject: Re: [PATCH 2/3] ARM: Move thread_info into task_struct (v7 only) To: Keith Packard Cc: Linux Kernel Mailing List , Abbott Liu , Alexander Sverdlin , Andrew Morton , Anshuman Khandual , Arnd Bergmann , Bjorn Andersson , Florian Fainelli , Geert Uytterhoeven , Hartley Sweeten , Jens Axboe , Jian Cai , Joe Perches , Kees Cook , Krzysztof Kozlowski , Linus Walleij , Linux ARM , Manivannan Sadhasivam , Marc Zyngier , Masahiro Yamada , Miguel Ojeda , Mike Rapoport , Nathan Chancellor , Nick Desaulniers , Nicolas Pitre , Rob Herring , Russell King , Thomas Gleixner , =?UTF-8?Q?Uwe_Kleine=2DK=C3=B6nig?= , Valentin Schneider , Viresh Kumar , "Wolfram Sang (Renesas)" , YiFei Zhu , Keith Packard X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210905_135618_300684_192C2E3E X-CRM114-Status: GOOD ( 50.72 ) 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 T24gU2F0LCA0IFNlcHQgMjAyMSBhdCAwODowOSwgS2VpdGggUGFja2FyZCA8a2VpdGhwQGtlaXRo cC5jb20+IHdyb3RlOgo+Cj4gVGhpcyBhdm9pZHMgbWFueSBzdGFjayBvdmVyZmxvdyBhdHRhY2tz IHdoaWNoIG1vZGlmaWVkIHRoZSB0aHJlYWRfaW5mbwo+IHN0cnVjdHVyZSBieSBtb3ZpbmcgdGhh dCBpbnRvIHRoZSB0YXNrX3N0cnVjdCBhcyBpcyBkb25lIGlzIGFsbW9zdCBhbGwKPiBvdGhlciBh cmNoaXRlY3R1cmVzLgo+Cj4gVGhlIHRhc2tfc3RydWN0IGlzIG5vdyByZWZlcmVuY2VkIGJ5IGEg cGVyLWNwdSB2YXJpYWJsZSwKPiAnY3VycmVudF90YXNrJywgYWxsb3dpbmcgdGhlIGN1cnJlbnQg b25lIG9uIGVhY2ggY3B1IHRvIGJlIGxvY2F0ZWQKPiBmcm9tIGJvdGggQyBhbmQgYXNzZW1ibHku Cj4KPiBUaGlzIGFsc28gaW52b2x2ZWQgcmVtb3ZpbmcgdGhlICdjcHUnIG1lbWJlciBmcm9tIHRo ZSB0aHJlYWRfaW5mbwo+IHN0cnVjdCBhbmQgdXNpbmcgdGhlIG9uZSBhZGRlZCB0byB0aGUgdGFz a19zdHJ1Y3QgaW5zdGVhZCBieSB0aGUKPiBUSFJFQURfSU5GT19JTl9UQVNLIGNvZGUuCj4KPiBU aGlzIGNvZGUgaXMgY3VycmVudGx5IGVuYWJsZWQgb25seSBmb3IgdjcgaGFyZHdhcmUgYXMgb3Ro ZXIgQVJNCj4gYXJjaGl0ZWN0dXJlcyBkbyBub3QgbWFrZSB0aGUgYzEzIHJlZ2lzdGVyIGluIHRo ZSBwMTUgY28tcHJvY2Vzc29yCj4gYXZhaWxhYmxlIGZvciBnZW5lcmFsIE9TIHVzZSwgbGVhdmlu ZyBpZGVudGlmeWluZyB0aGUgY3VycmVudCBjcHUgdG8KPiB0aGUgJ2NwdScgZmllbGQgaW4gdGhl IHRocmVhZF9pbmZvIGxvY2F0ZWQgb2ZmIHRoZSBzdGFjayBwb2ludGVyLgo+CgpjMTMgaXMgbm90 IGEgcmVnaXN0ZXIsIGl0IGlzIGEgdmFsdWUgaW4gb25lIG9mIHRoZSBkaW1lbnNpb25zIG9mIHRo ZQpBUk0gc3lzcmVnIHNwYWNlLCBhbmQgcHJvYmFibHkgY292ZXJzIG90aGVyIHN5c3RlbSByZWdp c3RlcnMgdGhhdApwcmUtdjcgY29yZXMgZG8gaW1wbGVtZW50LgoKQmV0dGVyIHRvIHVzZSBpdHMg YXJjaGl0ZWN0dXJhbCBuYW1lIChUUElEUlBSVykgYW5kIGNsYXJpZnkgdGhhdApwcmUtdjZrL3Y3 IGNvcmVzIHNpbXBseSBkb24ndCBpbXBsZW1lbnQgaXQuCgo+IFNpZ25lZC1vZmYtYnk6IEtlaXRo IFBhY2thcmQgPGtlaXRocGFjQGFtYXpvbi5jb20+Cj4gLS0tCj4gIGFyY2gvYXJtL0tjb25maWcg ICAgICAgICAgICAgICAgICAgfCAgMSArCj4gIGFyY2gvYXJtL01ha2VmaWxlICAgICAgICAgICAg ICAgICAgfCAgOCArKysrCj4gIGFyY2gvYXJtL2luY2x1ZGUvYXNtL2Fzc2VtYmxlci5oICAgfCA2 NiArKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0KPiAgYXJjaC9hcm0vaW5jbHVkZS9hc20v Y3VycmVudC5oICAgICB8IDQxICsrKysrKysrKysrKysrKysrKysKPiAgYXJjaC9hcm0vaW5jbHVk ZS9hc20vc21wLmggICAgICAgICB8IDE4ICsrKysrKysrCj4gIGFyY2gvYXJtL2luY2x1ZGUvYXNt L3RocmVhZF9pbmZvLmggfCAxNyArKysrKysrKwo+ICBhcmNoL2FybS9rZXJuZWwvYXNtLW9mZnNl dHMuYyAgICAgIHwgIDQgKysKPiAgYXJjaC9hcm0va2VybmVsL2VudHJ5LWFybXYuUyAgICAgICB8 IDE3ICsrKystLS0tCj4gIGFyY2gvYXJtL2tlcm5lbC9lbnRyeS1jb21tb24uUyAgICAgfCAgNiAr LS0KPiAgYXJjaC9hcm0va2VybmVsL2VudHJ5LXY3bS5TICAgICAgICB8ICA3ICsrKy0KPiAgYXJj aC9hcm0va2VybmVsL2l3bW14dC5TICAgICAgICAgICB8ICAyICstCj4gIGFyY2gvYXJtL2tlcm5l bC9zbXAuYyAgICAgICAgICAgICAgfCAxMiArKysrKysKPiAgYXJjaC9hcm0vbGliL2NvcHlfZnJv bV91c2VyLlMgICAgICB8ICAyICstCj4gIGFyY2gvYXJtL2xpYi9jb3B5X3RvX3VzZXIuUyAgICAg ICAgfCAgMiArLQo+ICBhcmNoL2FybS9tYWNoLWVwOTN4eC9jcnVuY2gtYml0cy5TIHwgIDIgKy0K PiAgYXJjaC9hcm0vbW0vcHJvYy1tYWNyb3MuUyAgICAgICAgICB8ICAyICstCj4gIGFyY2gvYXJt L3ZmcC9lbnRyeS5TICAgICAgICAgICAgICAgfCAgNCArKwo+ICBhcmNoL2FybS92ZnAvdmZwbW9k dWxlLmMgICAgICAgICAgIHwgMjUgKysrKysrKy0tLS0KPiAgMTggZmlsZXMgY2hhbmdlZCwgMjA0 IGluc2VydGlvbnMoKyksIDMyIGRlbGV0aW9ucygtKQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgYXJj aC9hcm0vaW5jbHVkZS9hc20vY3VycmVudC5oCj4KCkNvdWxkIHdlIHNwbGl0IHRoaXMgdXA/Cgo+ IGRpZmYgLS1naXQgYS9hcmNoL2FybS9LY29uZmlnIGIvYXJjaC9hcm0vS2NvbmZpZwo+IGluZGV4 IDI0ODA0ZjExMzAyZC4uMWMxZGVkNTAwYTJiIDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtL0tjb25m aWcKPiArKysgYi9hcmNoL2FybS9LY29uZmlnCj4gQEAgLTEyOCw2ICsxMjgsNyBAQCBjb25maWcg QVJNCj4gICAgICAgICBzZWxlY3QgUlRDX0xJQgo+ICAgICAgICAgc2VsZWN0IFNFVF9GUwo+ICAg ICAgICAgc2VsZWN0IFNZU19TVVBQT1JUU19BUE1fRU1VTEFUSU9OCj4gKyAgICAgICBzZWxlY3Qg VEhSRUFEX0lORk9fSU5fVEFTSyBpZiBDUFVfVjcKCkNQVV9WNksgYWxzbyBzdXBwb3J0cyB0aGlz Cgo+ICAgICAgICAgIyBBYm92ZSBzZWxlY3RzIGFyZSBzb3J0ZWQgYWxwaGFiZXRpY2FsbHk7IHBs ZWFzZSBhZGQgbmV3IG9uZXMKPiAgICAgICAgICMgYWNjb3JkaW5nIHRvIHRoYXQuICBUaGFua3Mu Cj4gICAgICAgICBoZWxwCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL01ha2VmaWxlIGIvYXJjaC9h cm0vTWFrZWZpbGUKPiBpbmRleCA0MTVjMzUxNDU3M2EuLjcxYTJiYTQ1NDlkMyAxMDA2NDQKPiAt LS0gYS9hcmNoL2FybS9NYWtlZmlsZQo+ICsrKyBiL2FyY2gvYXJtL01ha2VmaWxlCj4gQEAgLTI4 NCw2ICsyODQsMTQgQEAgc3RhY2tfcHJvdGVjdG9yX3ByZXBhcmU6IHByZXBhcmUwCj4gICAgICAg ICAkKGV2YWwgR0NDX1BMVUdJTlNfQ0ZMQUdTICs9ICQoU1NQX1BMVUdJTl9DRkxBR1MpKQo+ICBl bmRpZgo+Cj4gK2lmZGVmIENPTkZJR19TTVAKPiArcHJlcGFyZTogdGFza19jcHVfcHJlcGFyZQo+ ICsKPiArUEhPTlkgKz0gdGFza19jcHVfcHJlcGFyZQo+ICt0YXNrX2NwdV9wcmVwYXJlOiBwcmVw YXJlMAo+ICsgICAgICAgJChldmFsIEtCVUlMRF9DRkxBR1MgKz0gLURfVFNLX0NQVT0kKHNoZWxs IGF3ayAne2lmICgkJDIgPT0gIlRTS19DUFUiKSBwcmludCAkJDM7fScgaW5jbHVkZS9nZW5lcmF0 ZWQvYXNtLW9mZnNldHMuaCkpCj4gK2VuZGlmCj4gKwo+ICBhbGw6ICAgJChub3RkaXIgJChLQlVJ TERfSU1BR0UpKQo+CgpUaGlzIGlzIHJhdGhlciBob3JyaWQsIGFuZCByZW1vdmVkIGFnYWluIGlu IHRoZSBuZXh0IHBhdGNoLiBDYW4gd2UKb21pdCBpdCBlbnRpcmVseT8KCj4KPiBkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vYXNzZW1ibGVyLmggYi9hcmNoL2FybS9pbmNsdWRlL2Fz bS9hc3NlbWJsZXIuaAo+IGluZGV4IGUyYjFmZDU1OGJmMy4uMmNlNzQwM2Y5Mjk4IDEwMDY0NAo+ IC0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2Fzc2VtYmxlci5oCj4gKysrIGIvYXJjaC9hcm0v aW5jbHVkZS9hc20vYXNzZW1ibGVyLmgKPiBAQCAtMTk5LDE2ICsxOTksNjggQEAKPiAgICAgICAg IC5lbmRtCj4gICAgICAgICAuZW5kcgo+Cj4gKyNpZmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5f VEFTSwoKTm8gbmVlZCBmb3IgdGhpcyAjaWZkZWYgLSBpdCBvbmx5IGd1YXJkcyBtYWNyb3MgdGhh dCB3aWxsIGhhdmUgbm8KZWZmZWN0IGlmIHRoZXkgYXJlIG5ldmVyIGluc3RhbnRpYXRlZCAoYW5v dGhlciBjYXNlIGJlbG93KQoKPiAgLyoKPiAtICogR2V0IGN1cnJlbnQgdGhyZWFkX2luZm8uCj4g KyAqIEdldCBwZXItQ1BVIG9mZnNldAo+ICsgKiByZDogRGVzdGluYXRpb24gcmVnaXN0ZXIKPiAg ICovCj4gLSAgICAgICAubWFjcm8gIGdldF90aHJlYWRfaW5mbywgcmQKPiAtIEFSTSggIG1vdiAg ICAgXHJkLCBzcCwgbHNyICNUSFJFQURfU0laRV9PUkRFUiArIFBBR0VfU0hJRlQgICAgKQo+IC0g VEhVTUIoICAgICAgICBtb3YgICAgIFxyZCwgc3AgICAgICAgICAgICAgICAgICkKPiAtIFRIVU1C KCAgICAgICAgbHNyICAgICBccmQsIFxyZCwgI1RIUkVBRF9TSVpFX09SREVSICsgUEFHRV9TSElG VCAgICAgICApCj4gLSAgICAgICBtb3YgICAgIFxyZCwgXHJkLCBsc2wgI1RIUkVBRF9TSVpFX09S REVSICsgUEFHRV9TSElGVAo+ICsgICAgICAgLm1hY3JvIHRoaXNfY3B1X29mZnNldCByZDpyZXEK PiArICAgICAgIG1yYyBwMTUsIDAsIFxyZCwgYzEzLCBjMCwgNAo+ICAgICAgICAgLmVuZG0KPgo+ ICsvKgo+ICsgKiBMb2FkIGEgcGVyLWNwdSB2YXJpYWJsZQo+ICsgKiBAZHN0OiBEZXN0aW5hdGlv biByZWdpc3RlciB0byByZWNlaXZlIHZhbHVlCj4gKyAqIEBzeW06IFRoZSBuYW1lIG9mIHRoZSBw ZXItY3B1IHZhcmlhYmxlCj4gKyAqIEB0bXA6IHNjcmF0Y2ggcmVnaXN0ZXIKPiArICovCj4gKyAg ICAgICAubWFjcm8gbGRyX3RoaXNfY3B1IGRzdCA6IHJlcSwgc3ltIDogcmVxLCB0bXAgOiByZXEK PiArICAgICAgIG1vdncgICAgXGRzdCwgIzpsb3dlcjE2OlxzeW0KPiArICAgICAgIG1vdnQgICAg XGRzdCwgIzp1cHBlcjE2OlxzeW0KPiArICAgICAgIHRoaXNfY3B1X29mZnNldCBcdG1wCj4gKyAg ICAgICBsZHIgICAgIFxkc3QsIFtcZHN0LCBcdG1wXQo+ICsgICAgICAgLmVuZG0KPiArCj4gKy8q Cj4gKyAqIFN0b3JlIGEgdmFsdWUgaW4gYSBwZXItY3B1IHZhcmlhYmxlCj4gKyAqIEBzcmM6IFNv dXJjZSByZWdpc3RlciB3aXRoIHZhbHVlCj4gKyAqIEBzeW06IFRoZSBuYW1lIG9mIHRoZSBwZXIt Y3B1IHZhcmlhYmxlCj4gKyAqIEB0MTogc2NyYXRjaCByZWdpc3RlciAxCj4gKyAqIEB0Mjogc2Ny YXRjaCByZWdpc3RlciAyCj4gKyAqLwo+ICsgICAgICAgLm1hY3JvIHN0cl90aGlzX2NwdSBzcmMg OiByZXEsIHN5bSA6IHJlcSwgdDEgOiByZXEsIHQyIDogcmVxCj4gKyAgICAgICBtb3Z3ICAgIFx0 MSwgIzpsb3dlcjE2OlxzeW0KPiArICAgICAgIG1vdnQgICAgXHQxLCAjOnVwcGVyMTY6XHN5bQo+ ICsgICAgICAgdGhpc19jcHVfb2Zmc2V0IFx0Mgo+ICsgICAgICAgc3RyICAgICBcc3JjLCBbXHQx LCBcdDJdCj4gKyAgICAgICAuZW5kbQo+ICsjZW5kaWYKPiArCj4gKy8qCj4gKyAqIEdldCBjdXJy ZW50IHRocmVhZF9pbmZvCj4gKyAqIEBkc3Q6IERlc3RpbmF0aW9uIHJlZ2lzdGVyIHRvIHJlY2Vp dmUgY3VycmVudCB0aHJlYWQgaW5mbwo+ICsgKiBAdG1wOiBzY3JhdGNoIHJlZ2lzdGVyCj4gKyAq Lwo+ICsgICAgICAgLm1hY3JvIGdldF9jdXJyZW50LCBkc3QgOiByZXEsIHRtcCA6IHJlcQo+ICsj aWZkZWYgQ09ORklHX1RIUkVBRF9JTkZPX0lOX1RBU0sKPiArICAgICAgIGxkcl90aGlzX2NwdSBc ZHN0LCBjdXJyZW50X3Rhc2ssIFx0bXAKPiArI2Vsc2UKPiArIEFSTSggIG1vdiAgICAgXGRzdCwg c3AsIGxzciAjVEhSRUFEX1NJWkVfT1JERVIgKyBQQUdFX1NISUZUICAgKQo+ICsgVEhVTUIoICAg ICAgICBtb3YgICAgIFxkc3QsIHNwICAgICAgICAgICAgICAgICAgICAgICAgKQo+ICsgVEhVTUIo ICAgICAgICBsc3IgICAgIFxkc3QsIFxkc3QsICNUSFJFQURfU0laRV9PUkRFUiArIFBBR0VfU0hJ RlQgICAgICkKPiArICAgICAgIG1vdiAgICAgXGRzdCwgXGRzdCwgbHNsICNUSFJFQURfU0laRV9P UkRFUiArIFBBR0VfU0hJRlQKPiArI2VuZGlmCj4gKyAgICAgICAuZW5kbQo+ICsKPiArI2lmZGVm IENPTkZJR19USFJFQURfSU5GT19JTl9UQVNLCj4gKy8qCj4gKyAqIFNldCBjdXJyZW50IHRhc2sg aW5mbwo+ICsgKi8KPiArICAgICAgIC5tYWNybyAgc2V0X2N1cnJlbnRfdGFzayBycyA6IHJlcSwg dDEgOiByZXEsIHQyIDogcmVxCj4gKyAgICAgICBzdHJfdGhpc19jcHUgXHJzLCBjdXJyZW50X3Rh c2ssIFx0MSwgXHQyCj4gKyAgICAgICAuZW5kbQo+ICsjZW5kaWYKPiArCj4gIC8qCj4gICAqIElu Y3JlbWVudC9kZWNyZW1lbnQgdGhlIHByZWVtcHQgY291bnQuCj4gICAqLwo+IEBAIC0yMjYsNyAr Mjc4LDcgQEAKPiAgICAgICAgIC5lbmRtCj4KPiAgICAgICAgIC5tYWNybyAgZGVjX3ByZWVtcHRf Y291bnRfdGksIHRpLCB0bXAKPiAtICAgICAgIGdldF90aHJlYWRfaW5mbyBcdGkKPiArICAgICAg IGdldF9jdXJyZW50IFx0aSwgXHRtcAo+ICAgICAgICAgZGVjX3ByZWVtcHRfY291bnQgXHRpLCBc dG1wCj4gICAgICAgICAuZW5kbQo+ICAjZWxzZQo+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9pbmNs dWRlL2FzbS9jdXJyZW50LmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9jdXJyZW50LmgKPiBuZXcg ZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNzE2MDMxNWViNTY5Cj4gLS0t IC9kZXYvbnVsbAo+ICsrKyBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2N1cnJlbnQuaAo+IEBAIC0w LDAgKzEsNDEgQEAKPiArLyoKPiArICogQ29weXJpZ2h0IMKpIDIwMjEgS2VpdGggUGFja2FyZCA8 a2VpdGhwQGtlaXRocC5jb20+Cj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3 YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gKyAqIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5Cj4gKyAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24sIGVpdGhlciB2ZXJzaW9uIDIg b2YgdGhlIExpY2Vuc2UsIG9yCj4gKyAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNp b24uCj4gKyAqCj4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0 aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKPiArICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdp dGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgo+ICsgKiBNRVJDSEFOVEFCSUxJVFkg b3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuICBTZWUgdGhlIEdOVQo+ICsgKiBH ZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCgpQbGVhc2UgZHJvcCB0aGUg Ym9pbGVycGxhdGUgYW5kIHVzZSBhIFNQRFggaGVhZGVyIGluc3RlYWQuCgo+ICsgKi8KPiArCj4g KyNpZm5kZWYgX0FTTV9BUk1fQ1VSUkVOVF9ICj4gKyNkZWZpbmUgX0FTTV9BUk1fQ1VSUkVOVF9I Cj4gKwo+ICsjaW5jbHVkZSA8bGludXgvY29tcGlsZXIuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3Ro cmVhZF9pbmZvLmg+Cj4gKyNpbmNsdWRlIDxhc20vcGVyY3B1Lmg+Cj4gKwo+ICsjaWZuZGVmIF9f QVNTRU1CTFlfXwo+ICsKPiArI2lmZGVmIENPTkZJR19USFJFQURfSU5GT19JTl9UQVNLCj4gK3N0 cnVjdCB0YXNrX3N0cnVjdDsKPiArCj4gK0RFQ0xBUkVfUEVSX0NQVShzdHJ1Y3QgdGFza19zdHJ1 Y3QgKiwgY3VycmVudF90YXNrKTsKPiArCj4gK3N0YXRpYyBfX2Fsd2F5c19pbmxpbmUgc3RydWN0 IHRhc2tfc3RydWN0ICpnZXRfY3VycmVudCh2b2lkKQo+ICt7Cj4gKyAgICAgICByZXR1cm4gcmF3 X2NwdV9yZWFkKGN1cnJlbnRfdGFzayk7CgpUaGlzIG5lZWRzIHRvIHJ1biB3aXRoIHByZWVtcHRp b24gZGlzYWJsZWQsIG9yIHdlIG1pZ2h0IGdldCBtaWdyYXRlZAp0byBhbm90aGVyIENQVSBoYWxm d2F5IHRocm91Z2gsIGFuZCBwcm9kdWNlIHRoZSB3cm9uZyByZXN1bHQgKGkuZS4sCnRoZSBjdXJy ZW50IHRhc2sgb2YgdGhlIENQVSB3ZSBtaWdyYXRlZCBmcm9tKS4gSG93ZXZlciwgaXQgYXBwZWFy cwp0aGF0IG1hbmlwdWxhdGluZyB0aGUgcHJlZW1wdCBjb3VudCB3aWxsIGNyZWF0ZSBhIGNpcmN1 bGFyIGRlcGVuZGVuY3kKaGVyZS4KCkluc3RlYWQgb2YgdXNpbmcgYSBwZXItQ1BVIHZhcmlhYmxl IGZvciBjdXJyZW50LCBJIHRoaW5rIGl0IG1pZ2h0IGJlCmJldHRlciB0byBib3Jyb3cgYW5vdGhl ciBzeXN0ZW0gcmVnaXN0ZXIgKFRQSURSVVJPIG9yIFRQSURSVVJXKSB0bwpjYXJyeSAnY3VycmVu dCcgd2hlbiBUSFJFQURfSU5GT19JTl9UQVNLIGlzIGluIGVmZmVjdCwgc2ltaWxhciB0byBob3cK YXJtNjQgdXNlcyBTUF9FTDAgLSB0aG9zZSByZWdpc3RlcnMgY291bGQgYmUgcHJlc2VydmVkL3Jl c3RvcmVkIGluIHRoZQplbnRyeS9leGl0IGZyb20vdG8gdXNlciBzcGFjZSBwYXRocyByYXRoZXIg dGhhbiBpbiB0aGUgY29udGV4dCBzd2l0Y2gKcGF0aCwgYW5kIHRoZW4gYmUgdXNlZCBhbnkgd2F5 IHdlIGxpa2Ugd2hpbGUgcnVubmluZyBpbiB0aGUga2VybmVsLgoKCj4gK30KPiArCj4gKyNkZWZp bmUgY3VycmVudCBnZXRfY3VycmVudCgpCj4gKyNlbHNlCj4gKyNpbmNsdWRlIDxhc20tZ2VuZXJp Yy9jdXJyZW50Lmg+Cj4gKyNlbmRpZgo+ICsKPiArI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwo+ ICsKPiArI2VuZGlmIC8qIF9BU01fQVJNX0NVUlJFTlRfSCAqLwo+IGRpZmYgLS1naXQgYS9hcmNo L2FybS9pbmNsdWRlL2FzbS9zbXAuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL3NtcC5oCj4gaW5k ZXggODZhN2ZkNzIxNTU2Li4xYzM4ZDFmZGU2NDEgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0vaW5j bHVkZS9hc20vc21wLmgKPiArKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9zbXAuaAo+IEBAIC0x NSw3ICsxNSwyNSBAQAo+ICAjIGVycm9yICI8YXNtL3NtcC5oPiBpbmNsdWRlZCBpbiBub24tU01Q IGJ1aWxkIgo+ICAjZW5kaWYKPgo+ICsjaWZkZWYgQ09ORklHX1RIUkVBRF9JTkZPX0lOX1RBU0sK PiArLyoKPiArICogVGhpcyBpcyBwYXJ0aWN1bGFybHkgdWdseTogaXQgYXBwZWFycyB3ZSBjYW4n dCBhY3R1YWxseSBnZXQgdGhlIGRlZmluaXRpb24KPiArICogb2YgdGFza19zdHJ1Y3QgaGVyZSwg YnV0IHdlIG5lZWQgYWNjZXNzIHRvIHRoZSBDUFUgdGhpcyB0YXNrIGlzIHJ1bm5pbmcgb24uCj4g KyAqIEluc3RlYWQgb2YgdXNpbmcgdGFza19zdHJ1Y3Qgd2UncmUgdXNpbmcgVFNLX0NQVSB3aGlj aCBpcyBleHRyYWN0ZWQgZnJvbQo+ICsgKiBhc20tb2Zmc2V0cy5oIGJ5IGtidWlsZCB0byBnZXQg dGhlIGN1cnJlbnQgcHJvY2Vzc29yIElELgo+ICsgKgo+ICsgKiBUaGlzIGFsc28gbmVlZHMgdG8g YmUgc2FmZWd1YXJkZWQgd2hlbiBidWlsZGluZyBhc20tb2Zmc2V0cy5zIGJlY2F1c2UgYXQKPiAr ICogdGhhdCB0aW1lIFRTS19DUFUgaXMgbm90IGRlZmluZWQgeWV0Lgo+ICsgKi8KPiArI2lmbmRl ZiBfVFNLX0NQVQo+ICsjZGVmaW5lIHJhd19zbXBfcHJvY2Vzc29yX2lkKCkgICAgICAgICAoMCkK PiArI2Vsc2UKPiArI2RlZmluZSByYXdfc21wX3Byb2Nlc3Nvcl9pZCgpICAgICAgICAgKCoodW5z aWduZWQgaW50ICopKCh2b2lkICopY3VycmVudCArIF9UU0tfQ1BVKSkKPiArI2VuZGlmCj4gKwo+ ICsjZWxzZQo+ICAjZGVmaW5lIHJhd19zbXBfcHJvY2Vzc29yX2lkKCkgKGN1cnJlbnRfdGhyZWFk X2luZm8oKS0+Y3B1KQo+ICsjZW5kaWYKPgo+ICBzdHJ1Y3Qgc2VxX2ZpbGU7Cj4KPiBkaWZmIC0t Z2l0IGEvYXJjaC9hcm0vaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaCBiL2FyY2gvYXJtL2luY2x1 ZGUvYXNtL3RocmVhZF9pbmZvLmgKPiBpbmRleCA3MGQ0Y2JjNDlhZTEuLmNiY2Q0NzZhMDk1YiAx MDA2NDQKPiAtLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS90aHJlYWRfaW5mby5oCj4gKysrIGIv YXJjaC9hcm0vaW5jbHVkZS9hc20vdGhyZWFkX2luZm8uaAo+IEBAIC01NSw4ICs1NSwxMCBAQCBz dHJ1Y3QgdGhyZWFkX2luZm8gewo+ICAgICAgICAgdW5zaWduZWQgbG9uZyAgICAgICAgICAgZmxh Z3M7ICAgICAgICAgIC8qIGxvdyBsZXZlbCBmbGFncyAqLwo+ICAgICAgICAgaW50ICAgICAgICAg ICAgICAgICAgICAgcHJlZW1wdF9jb3VudDsgIC8qIDAgPT4gcHJlZW1wdGFibGUsIDwwID0+IGJ1 ZyAqLwo+ICAgICAgICAgbW1fc2VnbWVudF90ICAgICAgICAgICAgYWRkcl9saW1pdDsgICAgIC8q IGFkZHJlc3MgbGltaXQgKi8KPiArI2lmbmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5fVEFTSwo+ ICAgICAgICAgc3RydWN0IHRhc2tfc3RydWN0ICAgICAgKnRhc2s7ICAgICAgICAgIC8qIG1haW4g dGFzayBzdHJ1Y3R1cmUgKi8KPiAgICAgICAgIF9fdTMyICAgICAgICAgICAgICAgICAgIGNwdTsg ICAgICAgICAgICAvKiBjcHUgKi8KPiArI2VuZGlmCj4gICAgICAgICBfX3UzMiAgICAgICAgICAg ICAgICAgICBjcHVfZG9tYWluOyAgICAgLyogY3B1IGRvbWFpbiAqLwo+ICAjaWZkZWYgQ09ORklH X1NUQUNLUFJPVEVDVE9SX1BFUl9UQVNLCj4gICAgICAgICB1bnNpZ25lZCBsb25nICAgICAgICAg ICBzdGFja19jYW5hcnk7Cj4gQEAgLTc1LDYgKzc3LDE3IEBAIHN0cnVjdCB0aHJlYWRfaW5mbyB7 Cj4gICNlbmRpZgo+ICB9Owo+Cj4gKyNpZmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5fVEFTSwo+ ICsKPiArI2RlZmluZSBJTklUX1RIUkVBRF9JTkZPKHRzaykgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCj4gK3sgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+ICsgICAgICAgLmZsYWdz ICAgICAgICAgID0gMCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKPiArICAgICAgIC5wcmVlbXB0X2NvdW50ICA9IElOSVRfUFJFRU1QVF9DT1VOVCwgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCj4gKyAgICAgICAuYWRkcl9saW1pdCAgICAgPSBLRVJORUxf RFMsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+ICt9Cj4gKwo+ICsjZWxz ZQo+ICsKPiAgI2RlZmluZSBJTklUX1RIUkVBRF9JTkZPKHRzaykgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICBcCj4gIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAo+ICAgICAgICAgLnRh c2sgICAgICAgICAgID0gJnRzaywgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKPiBAQCAtODMsNiArOTYsOSBAQCBzdHJ1Y3QgdGhyZWFkX2luZm8gewo+ICAgICAgICAg LmFkZHJfbGltaXQgICAgID0gS0VSTkVMX0RTLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIFwKPiAgfQo+Cj4gKyNlbmRpZgo+ICsKPiArI2lmbmRlZiBDT05GSUdfVEhSRUFEX0lO Rk9fSU5fVEFTSwo+ICAvKgo+ICAgKiBob3cgdG8gZ2V0IHRoZSB0aHJlYWQgaW5mb3JtYXRpb24g c3RydWN0IGZyb20gQwo+ICAgKi8KPiBAQCAtOTMsNiArMTA5LDcgQEAgc3RhdGljIGlubGluZSBz dHJ1Y3QgdGhyZWFkX2luZm8gKmN1cnJlbnRfdGhyZWFkX2luZm8odm9pZCkKPiAgICAgICAgIHJl dHVybiAoc3RydWN0IHRocmVhZF9pbmZvICopCj4gICAgICAgICAgICAgICAgIChjdXJyZW50X3N0 YWNrX3BvaW50ZXIgJiB+KFRIUkVBRF9TSVpFIC0gMSkpOwo+ICB9Cj4gKyNlbmRpZgo+Cj4gICNk ZWZpbmUgdGhyZWFkX3NhdmVkX3BjKHRzaykgICBcCj4gICAgICAgICAoKHVuc2lnbmVkIGxvbmcp KHRhc2tfdGhyZWFkX2luZm8odHNrKS0+Y3B1X2NvbnRleHQucGMpKQo+IGRpZmYgLS1naXQgYS9h cmNoL2FybS9rZXJuZWwvYXNtLW9mZnNldHMuYyBiL2FyY2gvYXJtL2tlcm5lbC9hc20tb2Zmc2V0 cy5jCj4gaW5kZXggNzA5OTNhZjIyZDgwLi5jOTFkY2ZlMzRiZGQgMTAwNjQ0Cj4gLS0tIGEvYXJj aC9hcm0va2VybmVsL2FzbS1vZmZzZXRzLmMKPiArKysgYi9hcmNoL2FybS9rZXJuZWwvYXNtLW9m ZnNldHMuYwo+IEBAIC00NCw4ICs0NCwxMiBAQCBpbnQgbWFpbih2b2lkKQo+ICAgIERFRklORShU SV9GTEFHUywgICAgICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHRocmVhZF9pbmZvLCBmbGFncykp Owo+ICAgIERFRklORShUSV9QUkVFTVBULCAgICAgICAgICAgb2Zmc2V0b2Yoc3RydWN0IHRocmVh ZF9pbmZvLCBwcmVlbXB0X2NvdW50KSk7Cj4gICAgREVGSU5FKFRJX0FERFJfTElNSVQsICAgICAg ICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB0aHJlYWRfaW5mbywgYWRkcl9saW1pdCkpOwo+ICsj aWZkZWYgQ09ORklHX1RIUkVBRF9JTkZPX0lOX1RBU0sKPiArICBERUZJTkUoVFNLX0NQVSwgICAg ICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB0YXNrX3N0cnVjdCwgY3B1KSk7Cj4gKyNlbHNlCj4g ICAgREVGSU5FKFRJX1RBU0ssICAgICAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgdGhyZWFkX2lu Zm8sIHRhc2spKTsKPiAgICBERUZJTkUoVElfQ1BVLCAgICAgICAgICAgICAgIG9mZnNldG9mKHN0 cnVjdCB0aHJlYWRfaW5mbywgY3B1KSk7Cj4gKyNlbmRpZgo+ICAgIERFRklORShUSV9DUFVfRE9N QUlOLCAgICAgICAgICAgICAgICBvZmZzZXRvZihzdHJ1Y3QgdGhyZWFkX2luZm8sIGNwdV9kb21h aW4pKTsKPiAgICBERUZJTkUoVElfQ1BVX1NBVkUsICAgICAgICAgIG9mZnNldG9mKHN0cnVjdCB0 aHJlYWRfaW5mbywgY3B1X2NvbnRleHQpKTsKPiAgICBERUZJTkUoVElfVVNFRF9DUCwgICAgICAg ICAgIG9mZnNldG9mKHN0cnVjdCB0aHJlYWRfaW5mbywgdXNlZF9jcCkpOwo+IGRpZmYgLS1naXQg YS9hcmNoL2FybS9rZXJuZWwvZW50cnktYXJtdi5TIGIvYXJjaC9hcm0va2VybmVsL2VudHJ5LWFy bXYuUwo+IGluZGV4IDBlYTg1MjlhNDg3Mi4uYTVkNzFiMGQ4ODk3IDEwMDY0NAo+IC0tLSBhL2Fy Y2gvYXJtL2tlcm5lbC9lbnRyeS1hcm12LlMKPiArKysgYi9hcmNoL2FybS9rZXJuZWwvZW50cnkt YXJtdi5TCj4gQEAgLTE3OSw3ICsxNzksNyBAQCBFTkRQUk9DKF9fdW5kX2ludmFsaWQpCj4gICAg ICAgICBACj4gICAgICAgICBzdG1pYSAgIHI3LCB7cjIgLSByNn0KPgo+IC0gICAgICAgZ2V0X3Ro cmVhZF9pbmZvIHRzawo+ICsgICAgICAgZ2V0X2N1cnJlbnQgdHNrLCByMAo+ICAgICAgICAgdWFj Y2Vzc19lbnRyeSB0c2ssIHIwLCByMSwgcjIsIFx1YWNjZXNzCj4KPiAgICAgICAgIC5pZiBcdHJh Y2UKPiBAQCAtMjYwLDcgKzI2MCw3IEBAIF9fdW5kX3N2YzoKPiAgICAgICAgIGJsICAgICAgX191 bmRfZmF1bHQKPgo+ICBfX3VuZF9zdmNfZmluaXNoOgo+IC0gICAgICAgZ2V0X3RocmVhZF9pbmZv IHRzawo+ICsgICAgICAgZ2V0X2N1cnJlbnQgdHNrLCByNQo+ICAgICAgICAgbGRyICAgICByNSwg W3NwLCAjU19QU1JdICAgICAgICAgICAgICAgIEAgR2V0IFNWQyBjcHNyCj4gICAgICAgICBzdmNf ZXhpdCByNSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQCByZXR1cm4gZnJvbSBleGNlcHRp b24KPiAgIFVOV0lORCguZm5lbmQgICAgICAgICApCj4gQEAgLTQyOCw3ICs0MjgsNyBAQCBfX2ly cV91c3I6Cj4gICAgICAgICB1c3JfZW50cnkKPiAgICAgICAgIGt1c2VyX2NtcHhjaGdfY2hlY2sK PiAgICAgICAgIGlycV9oYW5kbGVyCj4gLSAgICAgICBnZXRfdGhyZWFkX2luZm8gdHNrCj4gKyAg ICAgICBnZXRfY3VycmVudCB0c2ssIHdoeQo+ICAgICAgICAgbW92ICAgICB3aHksICMwCj4gICAg ICAgICBiICAgICAgIHJldF90b191c2VyX2Zyb21faXJxCj4gICBVTldJTkQoLmZuZW5kICAgICAg ICAgKQo+IEBAIC01NzIsMTIgKzU3MiwxMiBAQCBFTkRQUk9DKF9fdW5kX3VzcikKPiAgICAgICAg IEAgRmFsbC10aHJvdWdoIGZyb20gVGh1bWItMiBfX3VuZF91c3IKPiAgICAgICAgIEAKPiAgI2lm ZGVmIENPTkZJR19ORU9OCj4gLSAgICAgICBnZXRfdGhyZWFkX2luZm8gcjEwICAgICAgICAgICAg ICAgICAgICAgQCBnZXQgY3VycmVudCB0aHJlYWQKPiArICAgICAgIGdldF9jdXJyZW50IHIxMCwg cjYgICAgICAgICAgICAgICAgICAgICBAIGdldCBjdXJyZW50IHRocmVhZAo+ICAgICAgICAgYWRy ICAgICByNiwgLkxDbmVvbl90aHVtYl9vcGNvZGVzCj4gICAgICAgICBiICAgICAgIDJmCj4gICNl bmRpZgo+ICBjYWxsX2ZwZToKPiAtICAgICAgIGdldF90aHJlYWRfaW5mbyByMTAgICAgICAgICAg ICAgICAgICAgICBAIGdldCBjdXJyZW50IHRocmVhZAo+ICsgICAgICAgZ2V0X2N1cnJlbnQgcjEw LCByNiAgICAgICAgICAgICAgICAgICAgIEAgZ2V0IGN1cnJlbnQgdGhyZWFkCj4gICNpZmRlZiBD T05GSUdfTkVPTgo+ICAgICAgICAgYWRyICAgICByNiwgLkxDbmVvbl9hcm1fb3Bjb2Rlcwo+ICAy OiAgICAgbGRyICAgICByNSwgW3I2XSwgIzQgICAgICAgICAgICAgICAgICAgIEAgbWFzayB2YWx1 ZQo+IEBAIC03MjIsNyArNzIyLDcgQEAgX19wYWJ0X3VzcjoKPiAgRU5UUlkocmV0X2Zyb21fZXhj ZXB0aW9uKQo+ICAgVU5XSU5EKC5mbnN0YXJ0ICAgICAgICkKPiAgIFVOV0lORCguY2FudHVud2lu ZCAgICApCj4gLSAgICAgICBnZXRfdGhyZWFkX2luZm8gdHNrCj4gKyAgICAgICBnZXRfY3VycmVu dCB0c2ssIHdoeQo+ICAgICAgICAgbW92ICAgICB3aHksICMwCj4gICAgICAgICBiICAgICAgIHJl dF90b191c2VyCj4gICBVTldJTkQoLmZuZW5kICAgICAgICAgKQo+IEBAIC03MzUsNyArNzM1LDcg QEAgX19maXFfdXNyOgo+ICAgICAgICAga3VzZXJfY21weGNoZ19jaGVjawo+ICAgICAgICAgbW92 ICAgICByMCwgc3AgICAgICAgICAgICAgICAgICAgICAgICAgIEAgc3RydWN0IHB0X3JlZ3MgKnJl Z3MKPiAgICAgICAgIGJsICAgICAgaGFuZGxlX2ZpcV9hc19ubWkKPiAtICAgICAgIGdldF90aHJl YWRfaW5mbyB0c2sKPiArICAgICAgIGdldF9jdXJyZW50IHRzaywgcjAKPiAgICAgICAgIHJlc3Rv cmVfdXNlcl9yZWdzIGZhc3QgPSAwLCBvZmZzZXQgPSAwCj4gICBVTldJTkQoLmZuZW5kICAgICAg ICAgKQo+ICBFTkRQUk9DKF9fZmlxX3VzcikKPiBAQCAtNzcxLDYgKzc3MSw5IEBAIEVOVFJZKF9f c3dpdGNoX3RvKQo+ICAjZW5kaWYKPiAgI2lmZGVmIENPTkZJR19DUFVfVVNFX0RPTUFJTlMKPiAg ICAgICAgIG1jciAgICAgcDE1LCAwLCByNiwgYzMsIGMwLCAwICAgICAgICAgICBAIFNldCBkb21h aW4gcmVnaXN0ZXIKPiArI2VuZGlmCj4gKyNpZmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5fVEFT Swo+ICsgICAgICAgc2V0X2N1cnJlbnRfdGFzayByMiwgcjQsIHI1Cj4gICNlbmRpZgo+ICAgICAg ICAgbW92ICAgICByNSwgcjAKPiAgICAgICAgIGFkZCAgICAgcjQsIHIyLCAjVElfQ1BVX1NBVkUK PiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL2VudHJ5LWNvbW1vbi5TIGIvYXJjaC9hcm0v a2VybmVsL2VudHJ5LWNvbW1vbi5TCj4gaW5kZXggN2YwYjdhYmExNDk4Li41MjU4MGVlNDYzZmUg MTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0va2VybmVsL2VudHJ5LWNvbW1vbi5TCj4gKysrIGIvYXJj aC9hcm0va2VybmVsL2VudHJ5LWNvbW1vbi5TCj4gQEAgLTE1Niw3ICsxNTYsNyBAQCBFTlRSWShy ZXRfZnJvbV9mb3JrKQo+ICAgICAgICAgbW92bmUgICByMCwgcjQKPiAgICAgICAgIGJhZHJuZSAg bHIsIDFmCj4gICAgICAgICByZXRuZSAgIHI1Cj4gLTE6ICAgICBnZXRfdGhyZWFkX2luZm8gdHNr Cj4gKzE6ICAgICBnZXRfY3VycmVudCB0c2ssIHIxCj4gICAgICAgICBiICAgICAgIHJldF9zbG93 X3N5c2NhbGwKPiAgRU5EUFJPQyhyZXRfZnJvbV9mb3JrKQo+Cj4gQEAgLTI0Myw3ICsyNDMsNyBA QCBFTlRSWSh2ZWN0b3Jfc3dpKQo+ICAgICAgICAgYmljICAgICBzY25vLCBzY25vLCAjMHhmZjAw MDAwMCAgICAgICAgIEAgbWFzayBvZmYgU1dJIG9wLWNvZGUKPiAgICAgICAgIGVvciAgICAgc2Nu bywgc2NubywgI19fTlJfU1lTQ0FMTF9CQVNFICBAIGNoZWNrIE9TIG51bWJlcgo+ICAjZW5kaWYK PiAtICAgICAgIGdldF90aHJlYWRfaW5mbyB0c2sKPiArICAgICAgIGdldF9jdXJyZW50IHRzaywg cjEwCj4gICAgICAgICAvKgo+ICAgICAgICAgICogUmVsb2FkIHRoZSByZWdpc3RlcnMgdGhhdCBt YXkgaGF2ZSBiZWVuIGNvcnJ1cHRlZCBvbiBlbnRyeSB0bwo+ICAgICAgICAgICogdGhlIHN5c2Nh bGwgYXNzZW1ibHkgKGJ5IHRyYWNpbmcgb3IgY29udGV4dCB0cmFja2luZy4pCj4gQEAgLTI3OCw3 ICsyNzgsNyBAQCBsb2NhbF9yZXN0YXJ0Ogo+ICA5MDAxOgo+ICAgICAgICAgc3ViICAgICBsciwg c2F2ZWRfcGMsICM0Cj4gICAgICAgICBzdHIgICAgIGxyLCBbc3AsICNTX1BDXQo+IC0gICAgICAg Z2V0X3RocmVhZF9pbmZvIHRzawo+ICsgICAgICAgZ2V0X2N1cnJlbnQgdHNrLCByMQo+ICAgICAg ICAgYiAgICAgICByZXRfZmFzdF9zeXNjYWxsCj4gICNlbmRpZgo+ICBFTkRQUk9DKHZlY3Rvcl9z d2kpCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS12N20uUyBiL2FyY2gvYXJt L2tlcm5lbC9lbnRyeS12N20uUwo+IGluZGV4IGQwZTg5ODYwOGQzMC4uZjM2YTdhODc2MDg1IDEw MDY0NAo+IC0tLSBhL2FyY2gvYXJtL2tlcm5lbC9lbnRyeS12N20uUwo+ICsrKyBiL2FyY2gvYXJt L2tlcm5lbC9lbnRyeS12N20uUwo+IEBAIC01Nyw3ICs1Nyw3IEBAIF9faXJxX2VudHJ5Ogo+ICAg ICAgICAgdHN0ICAgICByMCwgVjdNX1NDQl9JQ1NSX1JFVFRPQkFTRQo+ICAgICAgICAgYmVxICAg ICAyZgo+Cj4gLSAgICAgICBnZXRfdGhyZWFkX2luZm8gdHNrCj4gKyAgICAgICBnZXRfY3VycmVu dCB0c2ssIHIyCj4gICAgICAgICBsZHIgICAgIHIyLCBbdHNrLCAjVElfRkxBR1NdCj4gICAgICAg ICBtb3ZzICAgIHIyLCByMiwgbHNsICMxNgo+ICAgICAgICAgYmVxICAgICAyZiAgICAgICAgICAg ICAgICAgICAgICBAIG5vIHdvcmsgcGVuZGluZwo+IEBAIC04Myw3ICs4Myw3IEBAIF9fcGVuZHN2 X2VudHJ5Ogo+ICAgICAgICAgc3RyICAgICByMCwgW3IxLCBWN01fU0NCX0lDU1JdICBAIGNsZWFy IFBlbmRTVgo+Cj4gICAgICAgICBAIGV4ZWN1dGUgdGhlIHBlbmRpbmcgd29yaywgaW5jbHVkaW5n IHJlc2NoZWR1bGUKPiAtICAgICAgIGdldF90aHJlYWRfaW5mbyB0c2sKPiArICAgICAgIGdldF9j dXJyZW50IHRzaywgd2h5Cj4gICAgICAgICBtb3YgICAgIHdoeSwgIzAKPiAgICAgICAgIGIgICAg ICAgcmV0X3RvX3VzZXJfZnJvbV9pcnEKPiAgRU5EUFJPQyhfX3BlbmRzdl9lbnRyeSkKPiBAQCAt MTA3LDYgKzEwNyw5IEBAIEVOVFJZKF9fc3dpdGNoX3RvKQo+ICAgICAgICAgYmwgICAgICBhdG9t aWNfbm90aWZpZXJfY2FsbF9jaGFpbgo+ICAgICAgICAgbW92ICAgICBpcCwgcjQKPiAgICAgICAg IG1vdiAgICAgcjAsIHI1Cj4gKyNpZmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5fVEFTSwo+ICsg ICAgICAgc2V0X2N1cnJlbnRfdGFzayByMiwgcjQsIHI1Cj4gKyNlbmRpZgo+ICAgICAgICAgbGRt aWEgICBpcCEsIHtyNCAtIHIxMX0gICAgICAgICBAIExvYWQgYWxsIHJlZ3Mgc2F2ZWQgcHJldmlv dXNseQo+ICAgICAgICAgbGRyICAgICBzcCwgW2lwXQo+ICAgICAgICAgbGRyICAgICBwYywgW2lw LCAjNF0hCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9pd21teHQuUyBiL2FyY2gvYXJt L2tlcm5lbC9pd21teHQuUwo+IGluZGV4IGQyYjRhYzA2ZTRlZC4uNzgxZjdjN2ZjYTkwIDEwMDY0 NAo+IC0tLSBhL2FyY2gvYXJtL2tlcm5lbC9pd21teHQuUwo+ICsrKyBiL2FyY2gvYXJtL2tlcm5l bC9pd21teHQuUwo+IEBAIC05Niw3ICs5Niw3IEBAIEVOVFJZKGl3bW14dF90YXNrX2VuYWJsZSkK PiAgICAgICAgIGJsICAgICAgY29uY2FuX3NhdmUKPgo+ICAjaWZkZWYgQ09ORklHX1BSRUVNUFRf Q09VTlQKPiAtICAgICAgIGdldF90aHJlYWRfaW5mbyByMTAKPiArICAgICAgIGdldF9jdXJyZW50 IHIxMCwgcjMKPiAgI2VuZGlmCj4gIDQ6ICAgICBkZWNfcHJlZW1wdF9jb3VudCByMTAsIHIzCj4g ICAgICAgICByZXQgICAgIHI5ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQCBub3JtYWwg ZXhpdCBmcm9tIGV4Y2VwdGlvbgo+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvc21wLmMg Yi9hcmNoL2FybS9rZXJuZWwvc21wLmMKPiBpbmRleCA1NWNiMTY4OWE0YjMuLmJlMGVkZTE2ZGJi MSAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS9rZXJuZWwvc21wLmMKPiArKysgYi9hcmNoL2FybS9r ZXJuZWwvc21wLmMKPiBAQCAtNTEsNiArNTEsMTMgQEAKPiAgI2RlZmluZSBDUkVBVEVfVFJBQ0Vf UE9JTlRTCj4gICNpbmNsdWRlIDx0cmFjZS9ldmVudHMvaXBpLmg+Cj4KPiArI2lmZGVmIENPTkZJ R19USFJFQURfSU5GT19JTl9UQVNLCj4gK0RFRklORV9QRVJfQ1BVKHN0cnVjdCB0YXNrX3N0cnVj dCAqLCBjdXJyZW50X3Rhc2spIF9fX19jYWNoZWxpbmVfYWxpZ25lZCA9Cj4gKyAgICAgICAmaW5p dF90YXNrOwo+ICtFWFBPUlRfUEVSX0NQVV9TWU1CT0woY3VycmVudF90YXNrKTsKPiArCj4gKyNl bmRpZgo+ICsKPiAgLyoKPiAgICogYXMgZnJvbSAyLjUsIGtlcm5lbHMgbm8gbG9uZ2VyIGhhdmUg YW4gaW5pdF90YXNrcyBzdHJ1Y3R1cmUKPiAgICogc28gd2UgbmVlZCBzb21lIG90aGVyIHdheSBv ZiB0ZWxsaW5nIGEgbmV3IHNlY29uZGFyeSBjb3JlCj4gQEAgLTE1Niw2ICsxNjMsMTAgQEAgaW50 IF9fY3B1X3VwKHVuc2lnbmVkIGludCBjcHUsIHN0cnVjdCB0YXNrX3N0cnVjdCAqaWRsZSkKPiAg ICAgICAgIHNlY29uZGFyeV9kYXRhLmNwdSA9IGNwdTsKPiAgICAgICAgIHN5bmNfY2FjaGVfdygm c2Vjb25kYXJ5X2RhdGEpOwo+Cj4gKyNpZmRlZiBDT05GSUdfVEhSRUFEX0lORk9fSU5fVEFTSwo+ ICsgICAgICAgcGVyX2NwdShjdXJyZW50X3Rhc2ssIGNwdSkgPSBpZGxlOwo+ICsjZW5kaWYKPiAr Cj4gICAgICAgICAvKgo+ICAgICAgICAgICogTm93IGJyaW5nIHRoZSBDUFUgaW50byBvdXIgd29y bGQuCj4gICAgICAgICAgKi8KPiBAQCAtNTA5LDYgKzUyMCw3IEBAIHZvaWQgX19pbml0IHNtcF9w cmVwYXJlX2NwdXModW5zaWduZWQgaW50IG1heF9jcHVzKQo+ICAgICAgICAgICovCj4gICAgICAg ICBpZiAobWF4X2NwdXMgPiBuY29yZXMpCj4gICAgICAgICAgICAgICAgIG1heF9jcHVzID0gbmNv cmVzOwo+ICsKPiAgICAgICAgIGlmIChuY29yZXMgPiAxICYmIG1heF9jcHVzKSB7Cj4gICAgICAg ICAgICAgICAgIC8qCj4gICAgICAgICAgICAgICAgICAqIEluaXRpYWxpc2UgdGhlIHByZXNlbnQg bWFwLCB3aGljaCBkZXNjcmliZXMgdGhlIHNldCBvZiBDUFVzCj4gZGlmZiAtLWdpdCBhL2FyY2gv YXJtL2xpYi9jb3B5X2Zyb21fdXNlci5TIGIvYXJjaC9hcm0vbGliL2NvcHlfZnJvbV91c2VyLlMK PiBpbmRleCBmODAxNmUzZGI2NWQuLjUzMjA5NTAxMDBhMiAxMDA2NDQKPiAtLS0gYS9hcmNoL2Fy bS9saWIvY29weV9mcm9tX3VzZXIuUwo+ICsrKyBiL2FyY2gvYXJtL2xpYi9jb3B5X2Zyb21fdXNl ci5TCj4gQEAgLTEwOSw3ICsxMDksNyBAQAo+Cj4gIEVOVFJZKGFybV9jb3B5X2Zyb21fdXNlcikK PiAgI2lmZGVmIENPTkZJR19DUFVfU1BFQ1RSRQo+IC0gICAgICAgZ2V0X3RocmVhZF9pbmZvIHIz Cj4gKyAgICAgICBnZXRfY3VycmVudCByMywgaXAKPiAgICAgICAgIGxkciAgICAgcjMsIFtyMywg I1RJX0FERFJfTElNSVRdCj4gICAgICAgICB1YWNjZXNzX21hc2tfcmFuZ2VfcHRyIHIxLCByMiwg cjMsIGlwCj4gICNlbmRpZgo+IGRpZmYgLS1naXQgYS9hcmNoL2FybS9saWIvY29weV90b191c2Vy LlMgYi9hcmNoL2FybS9saWIvY29weV90b191c2VyLlMKPiBpbmRleCBlYmZlNGNiM2Q5MTIuLmU3 ZTYxYzg3ODkzYSAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS9saWIvY29weV90b191c2VyLlMKPiAr KysgYi9hcmNoL2FybS9saWIvY29weV90b191c2VyLlMKPiBAQCAtMTA5LDcgKzEwOSw3IEBACj4g IEVOVFJZKF9fY29weV90b191c2VyX3N0ZCkKPiAgV0VBSyhhcm1fY29weV90b191c2VyKQo+ICAj aWZkZWYgQ09ORklHX0NQVV9TUEVDVFJFCj4gLSAgICAgICBnZXRfdGhyZWFkX2luZm8gcjMKPiAr ICAgICAgIGdldF9jdXJyZW50IHIzLCBpcAo+ICAgICAgICAgbGRyICAgICByMywgW3IzLCAjVElf QUREUl9MSU1JVF0KPiAgICAgICAgIHVhY2Nlc3NfbWFza19yYW5nZV9wdHIgcjAsIHIyLCByMywg aXAKPiAgI2VuZGlmCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL21hY2gtZXA5M3h4L2NydW5jaC1i aXRzLlMgYi9hcmNoL2FybS9tYWNoLWVwOTN4eC9jcnVuY2gtYml0cy5TCj4gaW5kZXggZmIyZGJm NzZmMDllLi5kMGJiMzRiM2Q5NzMgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm0vbWFjaC1lcDkzeHgv Y3J1bmNoLWJpdHMuUwo+ICsrKyBiL2FyY2gvYXJtL21hY2gtZXA5M3h4L2NydW5jaC1iaXRzLlMK PiBAQCAtMTkyLDcgKzE5Miw3IEBAIGNydW5jaF9sb2FkOgo+Cj4gIDE6Cj4gICNpZmRlZiBDT05G SUdfUFJFRU1QVF9DT1VOVAo+IC0gICAgICAgZ2V0X3RocmVhZF9pbmZvIHIxMAo+ICsgICAgICAg Z2V0X2N1cnJlbnQgcjEwLCByMwo+ICAjZW5kaWYKPiAgMjogICAgIGRlY19wcmVlbXB0X2NvdW50 IHIxMCwgcjMKPiAgICAgICAgIHJldCAgICAgbHIKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0v cHJvYy1tYWNyb3MuUyBiL2FyY2gvYXJtL21tL3Byb2MtbWFjcm9zLlMKPiBpbmRleCBlMmM3NDNh YTJlYjIuLmE3ODJjMDI1ZmRmMyAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS9tbS9wcm9jLW1hY3Jv cy5TCj4gKysrIGIvYXJjaC9hcm0vbW0vcHJvYy1tYWNyb3MuUwo+IEBAIC0zMCw3ICszMCw3IEBA Cj4gICAqIGFjdF9tbSAtIGdldCBjdXJyZW50LT5hY3RpdmVfbW0KPiAgICovCj4gICAgICAgICAu bWFjcm8gIGFjdF9tbSwgcmQKPiAtICAgICAgIGdldF90aHJlYWRfaW5mbyBccmQKPiArICAgICAg IGdldF9jdXJyZW50IFxyZCwgdW51c2VkICAgICAgICAgICAgICAgICBAIHdvbid0IGJ1aWxkIGlm IFRIUkVBRF9JTkZPX0lOX1RBU0sKPiAgICAgICAgIGxkciAgICAgXHJkLCBbXHJkLCAjVElfVEFT S10KPiAgICAgICAgIC5pZiAoVFNLX0FDVElWRV9NTSA+IElNTTEyX01BU0spCj4gICAgICAgICBh ZGQgICAgIFxyZCwgXHJkLCAjVFNLX0FDVElWRV9NTSAmIH5JTU0xMl9NQVNLCj4gZGlmZiAtLWdp dCBhL2FyY2gvYXJtL3ZmcC9lbnRyeS5TIGIvYXJjaC9hcm0vdmZwL2VudHJ5LlMKPiBpbmRleCAy N2IwYTFmMjdmYmQuLjQ4Y2I0MGEzYjcyZCAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS92ZnAvZW50 cnkuUwo+ICsrKyBiL2FyY2gvYXJtL3ZmcC9lbnRyeS5TCj4gQEAgLTI0LDcgKzI0LDExIEBACj4g IEVOVFJZKGRvX3ZmcCkKPiAgICAgICAgIGluY19wcmVlbXB0X2NvdW50IHIxMCwgcjQKPiAgICAg ICAgIGxkciAgICAgcjQsIC5MQ3ZmcAo+ICsjaWZkZWYgQ09ORklHX1RIUkVBRF9JTkZPX0lOX1RB U0sKPiArICAgICAgIGxkciAgICAgcjExLCBbcjEwLCAjVFNLX0NQVV0gICAgQCBDUFUgbnVtYmVy Cj4gKyNlbHNlCj4gICAgICAgICBsZHIgICAgIHIxMSwgW3IxMCwgI1RJX0NQVV0gICAgIEAgQ1BV IG51bWJlcgo+ICsjZW5kaWYKPiAgICAgICAgIGFkZCAgICAgcjEwLCByMTAsICNUSV9WRlBTVEFU RSAgQCByMTAgPSB3b3Jrc3BhY2UKPiAgICAgICAgIGxkciAgICAgcGMsIFtyNF0gICAgICAgICAg ICAgICAgQCBjYWxsIFZGUCBlbnRyeSBwb2ludAo+ICBFTkRQUk9DKGRvX3ZmcCkKPiBkaWZmIC0t Z2l0IGEvYXJjaC9hcm0vdmZwL3ZmcG1vZHVsZS5jIGIvYXJjaC9hcm0vdmZwL3ZmcG1vZHVsZS5j Cj4gaW5kZXggMmNiMzU1YzFiNWI3Li5mOTI5YTI2YTA1YTUgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9h cm0vdmZwL3ZmcG1vZHVsZS5jCj4gKysrIGIvYXJjaC9hcm0vdmZwL3ZmcG1vZHVsZS5jCj4gQEAg LTE0MywyMiArMTQzLDI3IEBAIHN0YXRpYyB2b2lkIHZmcF90aHJlYWRfY29weShzdHJ1Y3QgdGhy ZWFkX2luZm8gKnRocmVhZCkKPiAgICogIFRIUkVBRF9OT0ZUSUZZX1NXVElDSDoKPiAgICogICAt IHRoZSBwcmV2aW91c2x5IHJ1bm5pbmcgdGhyZWFkIHdpbGwgbm90IGJlIHNjaGVkdWxlZCBvbnRv IGFub3RoZXIgQ1BVLgo+ICAgKiAgIC0gdGhlIG5leHQgdGhyZWFkIHRvIGJlIHJ1biAodikgd2ls bCBub3QgYmUgcnVubmluZyBvbiBhbm90aGVyIENQVS4KPiAtICogICAtIHRocmVhZC0+Y3B1IGlz IHRoZSBsb2NhbCBDUFUgbnVtYmVyCj4gKyAqICAgLSB0c2stPmNwdSBpcyB0aGUgbG9jYWwgQ1BV IG51bWJlcgo+ICAgKiAgIC0gbm90IHByZWVtcHRpYmxlIGFzIHdlJ3JlIGNhbGxlZCBpbiB0aGUg bWlkZGxlIG9mIGEgdGhyZWFkIHN3aXRjaAo+ICAgKiAgVEhSRUFEX05PVElGWV9GTFVTSDoKPiAg ICogICAtIHRoZSB0aHJlYWQgKHYpIHdpbGwgYmUgcnVubmluZyBvbiB0aGUgbG9jYWwgQ1BVLCBz bwo+IC0gKiAgICAgdiA9PT0gY3VycmVudF90aHJlYWRfaW5mbygpCj4gLSAqICAgLSB0aHJlYWQt PmNwdSBpcyB0aGUgbG9jYWwgQ1BVIG51bWJlciBhdCB0aGUgdGltZSBpdCBpcyBhY2Nlc3NlZCwK PiArICogICAgIHYgPT09IGN1cnJlbnQKPiArICogICAtIHRzay0+Y3B1IGlzIHRoZSBsb2NhbCBD UFUgbnVtYmVyIGF0IHRoZSB0aW1lIGl0IGlzIGFjY2Vzc2VkLAo+ICAgKiAgICAgYnV0IG1heSBj aGFuZ2UgYXQgYW55IHRpbWUuCj4gICAqICAgLSB3ZSBjb3VsZCBiZSBwcmVlbXB0ZWQgaWYgdHJl ZSBwcmVlbXB0IHJjdSBpcyBlbmFibGVkLCBzbwo+IC0gKiAgICAgaXQgaXMgdW5zYWZlIHRvIHVz ZSB0aHJlYWQtPmNwdS4KPiArICogICAgIGl0IGlzIHVuc2FmZSB0byB1c2UgdHNrLT5jcHUuCj4g ICAqICBUSFJFQURfTk9USUZZX0VYSVQKPiAgICogICAtIHdlIGNvdWxkIGJlIHByZWVtcHRlZCBp ZiB0cmVlIHByZWVtcHQgcmN1IGlzIGVuYWJsZWQsIHNvCj4gLSAqICAgICBpdCBpcyB1bnNhZmUg dG8gdXNlIHRocmVhZC0+Y3B1Lgo+ICsgKiAgICAgaXQgaXMgdW5zYWZlIHRvIHVzZSB0c2stPmNw dS4KPiAgICovCj4gIHN0YXRpYyBpbnQgdmZwX25vdGlmaWVyKHN0cnVjdCBub3RpZmllcl9ibG9j ayAqc2VsZiwgdW5zaWduZWQgbG9uZyBjbWQsIHZvaWQgKnYpCj4gIHsKPiArI2lmZGVmIENPTkZJ R19USFJFQURfSU5GT19JTl9UQVNLCj4gKyAgICAgICBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnRzayA9 IHY7Cj4gKyAgICAgICBzdHJ1Y3QgdGhyZWFkX2luZm8gKnRocmVhZCA9ICZ0c2stPnRocmVhZF9p bmZvOwo+ICsjZWxzZQo+ICAgICAgICAgc3RydWN0IHRocmVhZF9pbmZvICp0aHJlYWQgPSB2Owo+ ICsjZW5kaWYKPiAgICAgICAgIHUzMiBmcGV4YzsKPiAgI2lmZGVmIENPTkZJR19TTVAKPiAgICAg ICAgIHVuc2lnbmVkIGludCBjcHU7Cj4gQEAgLTE2OSw3ICsxNzQsMTEgQEAgc3RhdGljIGludCB2 ZnBfbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLCB1bnNpZ25lZCBsb25nIGNt ZCwgdm9pZCAqdikKPiAgICAgICAgICAgICAgICAgZnBleGMgPSBmbXJ4KEZQRVhDKTsKPgo+ICAj aWZkZWYgQ09ORklHX1NNUAo+ICsjaWZkZWYgQ09ORklHX1RIUkVBRF9JTkZPX0lOX1RBU0sKPiAr ICAgICAgICAgICAgICAgY3B1ID0gdHNrLT5jcHU7Cj4gKyNlbHNlCj4gICAgICAgICAgICAgICAg IGNwdSA9IHRocmVhZC0+Y3B1Owo+ICsjZW5kaWYKPgo+ICAgICAgICAgICAgICAgICAvKgo+ICAg ICAgICAgICAgICAgICAgKiBPbiBTTVAsIGlmIFZGUCBpcyBlbmFibGVkLCBzYXZlIHRoZSBvbGQg c3RhdGUgaW4KPiBAQCAtNDU4LDE2ICs0NjcsMTYgQEAgc3RhdGljIGludCB2ZnBfcG1fc3VzcGVu ZCh2b2lkKQo+Cj4gICAgICAgICAgICAgICAgIC8qIGRpc2FibGUsIGp1c3QgaW4gY2FzZSAqLwo+ ICAgICAgICAgICAgICAgICBmbXhyKEZQRVhDLCBmbXJ4KEZQRVhDKSAmIH5GUEVYQ19FTik7Cj4g LSAgICAgICB9IGVsc2UgaWYgKHZmcF9jdXJyZW50X2h3X3N0YXRlW3RpLT5jcHVdKSB7Cj4gKyAg ICAgICB9IGVsc2UgaWYgKHZmcF9jdXJyZW50X2h3X3N0YXRlW3NtcF9wcm9jZXNzb3JfaWQoKV0p IHsKPiAgI2lmbmRlZiBDT05GSUdfU01QCj4gICAgICAgICAgICAgICAgIGZteHIoRlBFWEMsIGZw ZXhjIHwgRlBFWENfRU4pOwo+IC0gICAgICAgICAgICAgICB2ZnBfc2F2ZV9zdGF0ZSh2ZnBfY3Vy cmVudF9od19zdGF0ZVt0aS0+Y3B1XSwgZnBleGMpOwo+ICsgICAgICAgICAgICAgICB2ZnBfc2F2 ZV9zdGF0ZSh2ZnBfY3VycmVudF9od19zdGF0ZVtzbXBfcHJvY2Vzc29yX2lkKCldLCBmcGV4Yyk7 Cj4gICAgICAgICAgICAgICAgIGZteHIoRlBFWEMsIGZwZXhjKTsKPiAgI2VuZGlmCj4gICAgICAg ICB9Cj4KPiAgICAgICAgIC8qIGNsZWFyIGFueSBpbmZvcm1hdGlvbiB3ZSBoYWQgYWJvdXQgbGFz dCBjb250ZXh0IHN0YXRlICovCj4gLSAgICAgICB2ZnBfY3VycmVudF9od19zdGF0ZVt0aS0+Y3B1 XSA9IE5VTEw7Cj4gKyAgICAgICB2ZnBfY3VycmVudF9od19zdGF0ZVtzbXBfcHJvY2Vzc29yX2lk KCldID0gTlVMTDsKPgo+ICAgICAgICAgcmV0dXJuIDA7Cj4gIH0KPiAtLQo+IDIuMzMuMAo+Cgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0t a2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcK aHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2Vy bmVsCg==