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 90B8539FE4; Sun, 5 May 2024 16:09:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1714925350; cv=none; b=QwvsAF3prABGS8MHhXgYTA+k8nlmiTwXO0QtrH54z5wvFEVVgf2CRNsvQk5gLxhFcxXNTT1EUNto9XSKlw+lrHudlCZx8oCW/edBIOftTPCAFj0rA2xPMTwgS25lYuozbqAGcApEsH/Yn/qAScGuh5DdDmnRe0OOVj1CO2TrzJ0= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1714925350; c=relaxed/simple; bh=5OMBgTFrr36VXyNsljkCHRabEmmDGidsMIUvtOQa2/E=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=LMff+p53XxsYpSm/nMnCzHYk6YeBx4yB/8CsB/yo6xg9j8/cbGOLCOztEYikx1H2juzsmTXrkO1/AkJVFzf8aXkzh3PvRFpQe9u0YpFU039MM1MXk2QB8fujgD/EC/r0UJ36dcpuTcYV8IZygIbVLf6arKLNB5VOpEe00x0dsBM= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=HUOjkTY0; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="HUOjkTY0" Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED18EC4DDE2; Sun, 5 May 2024 16:08:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1714925350; bh=5OMBgTFrr36VXyNsljkCHRabEmmDGidsMIUvtOQa2/E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HUOjkTY0MY4Avcwze7CfRrRzvZ8uJCMrkjJMVefuOUwtMJ5EdhxU7JNfJcc54972f 3oOhpCvwmoQ9Q1GPkwpinF5evj2fIyiPqFqm2A6rXSrs6J+b5saRST0hEptRzBNchm Auf1aZnNL10BrlRGGKBPvzfY9zUsb8WDijER56YCQ/T3mYlDNtjhQrdcTBiDC4+1sT 39YY7luhKaiRxcdo24wF1OZY2OK73xFTQ7yliDwpr/XtTQ0GXkhPn658Wk2etTrXSA AvAmAW4UhT0vEPNgqOYrKQUZ1Ak+cHmYwEhJlWambSDSLpHUwgD8LRPOLI6LdEFSyk +vzxUot7u+I/w== From: Mike Rapoport To: linux-kernel@vger.kernel.org Cc: Alexandre Ghiti , Andrew Morton , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Catalin Marinas , Christophe Leroy , "David S. Miller" , Dinh Nguyen , Donald Dutile , Eric Chanudet , Heiko Carstens , Helge Deller , Huacai Chen , Kent Overstreet , Liviu Dudau , Luis Chamberlain , Mark Rutland , Masami Hiramatsu , Michael Ellerman , Mike Rapoport , Nadav Amit , Palmer Dabbelt , Peter Zijlstra , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Rick Edgecombe , Russell King , Sam Ravnborg , Song Liu , Steven Rostedt , Thomas Bogendoerfer , Thomas Gleixner , Will Deacon , bpf@vger.kernel.org, linux-arch@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linux-mm@kvack.org, linux-modules@vger.kernel.org, linux-parisc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, loongarch@lists.linux.dev, netdev@vger.kernel.org, sparclinux@vger.kernel.org, x86@kernel.org Subject: [PATCH RESEND v8 12/16] arch: make execmem setup available regardless of CONFIG_MODULES Date: Sun, 5 May 2024 19:06:24 +0300 Message-ID: <20240505160628.2323363-13-rppt@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240505160628.2323363-1-rppt@kernel.org> References: <20240505160628.2323363-1-rppt@kernel.org> Precedence: bulk X-Mailing-List: bpf@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: "Mike Rapoport (IBM)" execmem does not depend on modules, on the contrary modules use execmem. To make execmem available when CONFIG_MODULES=n, for instance for kprobes, split execmem_params initialization out from arch/*/kernel/module.c and compile it when CONFIG_EXECMEM=y Signed-off-by: Mike Rapoport (IBM) Reviewed-by: Philippe Mathieu-Daudé --- arch/arm/kernel/module.c | 43 ---------- arch/arm/mm/init.c | 45 +++++++++++ arch/arm64/kernel/module.c | 140 --------------------------------- arch/arm64/mm/init.c | 140 +++++++++++++++++++++++++++++++++ arch/loongarch/kernel/module.c | 19 ----- arch/loongarch/mm/init.c | 21 +++++ arch/mips/kernel/module.c | 22 ------ arch/mips/mm/init.c | 23 ++++++ arch/nios2/kernel/module.c | 20 ----- arch/nios2/mm/init.c | 21 +++++ arch/parisc/kernel/module.c | 20 ----- arch/parisc/mm/init.c | 23 +++++- arch/powerpc/kernel/module.c | 63 --------------- arch/powerpc/mm/mem.c | 64 +++++++++++++++ arch/riscv/kernel/module.c | 34 -------- arch/riscv/mm/init.c | 35 +++++++++ arch/s390/kernel/module.c | 27 ------- arch/s390/mm/init.c | 30 +++++++ arch/sparc/kernel/module.c | 19 ----- arch/sparc/mm/Makefile | 2 + arch/sparc/mm/execmem.c | 21 +++++ arch/x86/kernel/module.c | 27 ------- arch/x86/mm/init.c | 29 +++++++ 23 files changed, 453 insertions(+), 435 deletions(-) create mode 100644 arch/sparc/mm/execmem.c diff --git a/arch/arm/kernel/module.c b/arch/arm/kernel/module.c index a98fdf6ff26c..677f218f7e84 100644 --- a/arch/arm/kernel/module.c +++ b/arch/arm/kernel/module.c @@ -12,57 +12,14 @@ #include #include #include -#include #include #include -#include -#include #include #include #include #include -#ifdef CONFIG_XIP_KERNEL -/* - * The XIP kernel text is mapped in the module area for modules and - * some other stuff to work without any indirect relocations. - * MODULES_VADDR is redefined here and not in asm/memory.h to avoid - * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off. - */ -#undef MODULES_VADDR -#define MODULES_VADDR (((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK) -#endif - -#ifdef CONFIG_MMU -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long fallback_start = 0, fallback_end = 0; - - if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS)) { - fallback_start = VMALLOC_START; - fallback_end = VMALLOC_END; - } - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL_EXEC, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - }, - }; - - return &execmem_info; -} -#endif - bool module_init_section(const char *name) { return strstarts(name, ".init") || diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c index e8c6f4be0ce1..5345d218899a 100644 --- a/arch/arm/mm/init.c +++ b/arch/arm/mm/init.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -486,3 +487,47 @@ void free_initrd_mem(unsigned long start, unsigned long end) free_reserved_area((void *)start, (void *)end, -1, "initrd"); } #endif + +#ifdef CONFIG_EXECMEM + +#ifdef CONFIG_XIP_KERNEL +/* + * The XIP kernel text is mapped in the module area for modules and + * some other stuff to work without any indirect relocations. + * MODULES_VADDR is redefined here and not in asm/memory.h to avoid + * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off. + */ +#undef MODULES_VADDR +#define MODULES_VADDR (((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK) +#endif + +#ifdef CONFIG_MMU +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long fallback_start = 0, fallback_end = 0; + + if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS)) { + fallback_start = VMALLOC_START; + fallback_end = VMALLOC_END; + } + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL_EXEC, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_MMU */ + +#endif /* CONFIG_EXECMEM */ diff --git a/arch/arm64/kernel/module.c b/arch/arm64/kernel/module.c index a52240ea084b..36b25af56324 100644 --- a/arch/arm64/kernel/module.c +++ b/arch/arm64/kernel/module.c @@ -12,158 +12,18 @@ #include #include #include -#include #include #include #include #include #include #include -#include -#include #include #include #include #include -static u64 module_direct_base __ro_after_init = 0; -static u64 module_plt_base __ro_after_init = 0; - -/* - * Choose a random page-aligned base address for a window of 'size' bytes which - * entirely contains the interval [start, end - 1]. - */ -static u64 __init random_bounding_box(u64 size, u64 start, u64 end) -{ - u64 max_pgoff, pgoff; - - if ((end - start) >= size) - return 0; - - max_pgoff = (size - (end - start)) / PAGE_SIZE; - pgoff = get_random_u32_inclusive(0, max_pgoff); - - return start - pgoff * PAGE_SIZE; -} - -/* - * Modules may directly reference data and text anywhere within the kernel - * image and other modules. References using PREL32 relocations have a +/-2G - * range, and so we need to ensure that the entire kernel image and all modules - * fall within a 2G window such that these are always within range. - * - * Modules may directly branch to functions and code within the kernel text, - * and to functions and code within other modules. These branches will use - * CALL26/JUMP26 relocations with a +/-128M range. Without PLTs, we must ensure - * that the entire kernel text and all module text falls within a 128M window - * such that these are always within range. With PLTs, we can expand this to a - * 2G window. - * - * We chose the 128M region to surround the entire kernel image (rather than - * just the text) as using the same bounds for the 128M and 2G regions ensures - * by construction that we never select a 128M region that is not a subset of - * the 2G region. For very large and unusual kernel configurations this means - * we may fall back to PLTs where they could have been avoided, but this keeps - * the logic significantly simpler. - */ -static int __init module_init_limits(void) -{ - u64 kernel_end = (u64)_end; - u64 kernel_start = (u64)_text; - u64 kernel_size = kernel_end - kernel_start; - - /* - * The default modules region is placed immediately below the kernel - * image, and is large enough to use the full 2G relocation range. - */ - BUILD_BUG_ON(KIMAGE_VADDR != MODULES_END); - BUILD_BUG_ON(MODULES_VSIZE < SZ_2G); - - if (!kaslr_enabled()) { - if (kernel_size < SZ_128M) - module_direct_base = kernel_end - SZ_128M; - if (kernel_size < SZ_2G) - module_plt_base = kernel_end - SZ_2G; - } else { - u64 min = kernel_start; - u64 max = kernel_end; - - if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) { - pr_info("2G module region forced by RANDOMIZE_MODULE_REGION_FULL\n"); - } else { - module_direct_base = random_bounding_box(SZ_128M, min, max); - if (module_direct_base) { - min = module_direct_base; - max = module_direct_base + SZ_128M; - } - } - - module_plt_base = random_bounding_box(SZ_2G, min, max); - } - - pr_info("%llu pages in range for non-PLT usage", - module_direct_base ? (SZ_128M - kernel_size) / PAGE_SIZE : 0); - pr_info("%llu pages in range for PLT usage", - module_plt_base ? (SZ_2G - kernel_size) / PAGE_SIZE : 0); - - return 0; -} - -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long fallback_start = 0, fallback_end = 0; - unsigned long start = 0, end = 0; - - module_init_limits(); - - /* - * Where possible, prefer to allocate within direct branch range of the - * kernel such that no PLTs are necessary. - */ - if (module_direct_base) { - start = module_direct_base; - end = module_direct_base + SZ_128M; - - if (module_plt_base) { - fallback_start = module_plt_base; - fallback_end = module_plt_base + SZ_2G; - } - } else if (module_plt_base) { - start = module_plt_base; - end = module_plt_base + SZ_2G; - } - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = start, - .end = end, - .pgprot = PAGE_KERNEL, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_ROX, - .alignment = 1, - }, - [EXECMEM_BPF] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - enum aarch64_reloc_op { RELOC_OP_NONE, RELOC_OP_ABS, diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c index 03efd86dce0a..9b5ab6818f7f 100644 --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -432,3 +433,142 @@ void dump_mem_limit(void) pr_emerg("Memory Limit: none\n"); } } + +#ifdef CONFIG_EXECMEM +static u64 module_direct_base __ro_after_init = 0; +static u64 module_plt_base __ro_after_init = 0; + +/* + * Choose a random page-aligned base address for a window of 'size' bytes which + * entirely contains the interval [start, end - 1]. + */ +static u64 __init random_bounding_box(u64 size, u64 start, u64 end) +{ + u64 max_pgoff, pgoff; + + if ((end - start) >= size) + return 0; + + max_pgoff = (size - (end - start)) / PAGE_SIZE; + pgoff = get_random_u32_inclusive(0, max_pgoff); + + return start - pgoff * PAGE_SIZE; +} + +/* + * Modules may directly reference data and text anywhere within the kernel + * image and other modules. References using PREL32 relocations have a +/-2G + * range, and so we need to ensure that the entire kernel image and all modules + * fall within a 2G window such that these are always within range. + * + * Modules may directly branch to functions and code within the kernel text, + * and to functions and code within other modules. These branches will use + * CALL26/JUMP26 relocations with a +/-128M range. Without PLTs, we must ensure + * that the entire kernel text and all module text falls within a 128M window + * such that these are always within range. With PLTs, we can expand this to a + * 2G window. + * + * We chose the 128M region to surround the entire kernel image (rather than + * just the text) as using the same bounds for the 128M and 2G regions ensures + * by construction that we never select a 128M region that is not a subset of + * the 2G region. For very large and unusual kernel configurations this means + * we may fall back to PLTs where they could have been avoided, but this keeps + * the logic significantly simpler. + */ +static int __init module_init_limits(void) +{ + u64 kernel_end = (u64)_end; + u64 kernel_start = (u64)_text; + u64 kernel_size = kernel_end - kernel_start; + + /* + * The default modules region is placed immediately below the kernel + * image, and is large enough to use the full 2G relocation range. + */ + BUILD_BUG_ON(KIMAGE_VADDR != MODULES_END); + BUILD_BUG_ON(MODULES_VSIZE < SZ_2G); + + if (!kaslr_enabled()) { + if (kernel_size < SZ_128M) + module_direct_base = kernel_end - SZ_128M; + if (kernel_size < SZ_2G) + module_plt_base = kernel_end - SZ_2G; + } else { + u64 min = kernel_start; + u64 max = kernel_end; + + if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) { + pr_info("2G module region forced by RANDOMIZE_MODULE_REGION_FULL\n"); + } else { + module_direct_base = random_bounding_box(SZ_128M, min, max); + if (module_direct_base) { + min = module_direct_base; + max = module_direct_base + SZ_128M; + } + } + + module_plt_base = random_bounding_box(SZ_2G, min, max); + } + + pr_info("%llu pages in range for non-PLT usage", + module_direct_base ? (SZ_128M - kernel_size) / PAGE_SIZE : 0); + pr_info("%llu pages in range for PLT usage", + module_plt_base ? (SZ_2G - kernel_size) / PAGE_SIZE : 0); + + return 0; +} + +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long fallback_start = 0, fallback_end = 0; + unsigned long start = 0, end = 0; + + module_init_limits(); + + /* + * Where possible, prefer to allocate within direct branch range of the + * kernel such that no PLTs are necessary. + */ + if (module_direct_base) { + start = module_direct_base; + end = module_direct_base + SZ_128M; + + if (module_plt_base) { + fallback_start = module_plt_base; + fallback_end = module_plt_base + SZ_2G; + } + } else if (module_plt_base) { + start = module_plt_base; + end = module_plt_base + SZ_2G; + } + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = start, + .end = end, + .pgprot = PAGE_KERNEL, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_ROX, + .alignment = 1, + }, + [EXECMEM_BPF] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/loongarch/kernel/module.c b/arch/loongarch/kernel/module.c index ca6dd7ea1610..36d6d9eeb7c7 100644 --- a/arch/loongarch/kernel/module.c +++ b/arch/loongarch/kernel/module.c @@ -18,7 +18,6 @@ #include #include #include -#include #include #include #include @@ -491,24 +490,6 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab, return 0; } -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - static void module_init_ftrace_plt(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mod) { diff --git a/arch/loongarch/mm/init.c b/arch/loongarch/mm/init.c index 4dd53427f657..bf789d114c2d 100644 --- a/arch/loongarch/mm/init.c +++ b/arch/loongarch/mm/init.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include @@ -248,3 +249,23 @@ EXPORT_SYMBOL(invalid_pmd_table); #endif pte_t invalid_pte_table[PTRS_PER_PTE] __page_aligned_bss; EXPORT_SYMBOL(invalid_pte_table); + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/mips/kernel/module.c b/arch/mips/kernel/module.c index 59225a3cf918..ba0f62d8eff5 100644 --- a/arch/mips/kernel/module.c +++ b/arch/mips/kernel/module.c @@ -13,14 +13,12 @@ #include #include #include -#include #include #include #include #include #include #include -#include #include struct mips_hi16 { @@ -32,26 +30,6 @@ struct mips_hi16 { static LIST_HEAD(dbe_list); static DEFINE_SPINLOCK(dbe_lock); -#ifdef MODULES_VADDR -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} -#endif - static void apply_r_mips_32(u32 *location, u32 base, Elf_Addr v) { *location = base + v; diff --git a/arch/mips/mm/init.c b/arch/mips/mm/init.c index 39f129205b0c..4583d1a2a73e 100644 --- a/arch/mips/mm/init.c +++ b/arch/mips/mm/init.c @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -576,3 +577,25 @@ EXPORT_SYMBOL_GPL(invalid_pmd_table); #endif pte_t invalid_pte_table[PTRS_PER_PTE] __page_aligned_bss; EXPORT_SYMBOL(invalid_pte_table); + +#ifdef CONFIG_EXECMEM +#ifdef MODULES_VADDR +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif +#endif /* CONFIG_EXECMEM */ diff --git a/arch/nios2/kernel/module.c b/arch/nios2/kernel/module.c index 0d1ee86631fc..f4483243578d 100644 --- a/arch/nios2/kernel/module.c +++ b/arch/nios2/kernel/module.c @@ -13,33 +13,13 @@ #include #include #include -#include #include #include #include #include -#include #include -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL_EXEC, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab, unsigned int symindex, unsigned int relsec, struct module *mod) diff --git a/arch/nios2/mm/init.c b/arch/nios2/mm/init.c index 7bc82ee889c9..3459df28afee 100644 --- a/arch/nios2/mm/init.c +++ b/arch/nios2/mm/init.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -143,3 +144,23 @@ static const pgprot_t protection_map[16] = { [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = MKP(1, 1, 1) }; DECLARE_VM_GET_PAGE_PROT + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL_EXEC, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/parisc/kernel/module.c b/arch/parisc/kernel/module.c index bdfa85e10c1b..4e5d991b2b65 100644 --- a/arch/parisc/kernel/module.c +++ b/arch/parisc/kernel/module.c @@ -41,7 +41,6 @@ #include #include -#include #include #include #include @@ -49,7 +48,6 @@ #include #include #include -#include #include #include @@ -174,24 +172,6 @@ static inline int reassemble_22(int as22) ((as22 & 0x0003ff) << 3)); } -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_RWX, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - #ifndef CONFIG_64BIT static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n) { diff --git a/arch/parisc/mm/init.c b/arch/parisc/mm/init.c index f876af56e13f..34d91cb8b259 100644 --- a/arch/parisc/mm/init.c +++ b/arch/parisc/mm/init.c @@ -24,6 +24,7 @@ #include /* for node_online_map */ #include /* for release_pages */ #include +#include #include #include @@ -481,7 +482,7 @@ void free_initmem(void) /* finally dump all the instructions which were cached, since the * pages are no-longer executable */ flush_icache_range(init_begin, init_end); - + free_initmem_default(POISON_FREE_INITMEM); /* set up a new led state on systems shipped LED State panel */ @@ -992,3 +993,23 @@ static const pgprot_t protection_map[16] = { [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = PAGE_RWX }; DECLARE_VM_GET_PAGE_PROT + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_RWX, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/powerpc/kernel/module.c b/arch/powerpc/kernel/module.c index 2a23cf7e141b..77ea82e9dc5f 100644 --- a/arch/powerpc/kernel/module.c +++ b/arch/powerpc/kernel/module.c @@ -7,10 +7,8 @@ #include #include #include -#include #include #include -#include #include #include #include @@ -89,64 +87,3 @@ int module_finalize(const Elf_Ehdr *hdr, return 0; } - -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - pgprot_t kprobes_prot = strict_module_rwx_enabled() ? PAGE_KERNEL_ROX : PAGE_KERNEL_EXEC; - pgprot_t prot = strict_module_rwx_enabled() ? PAGE_KERNEL : PAGE_KERNEL_EXEC; - unsigned long fallback_start = 0, fallback_end = 0; - unsigned long start, end; - - /* - * BOOK3S_32 and 8xx define MODULES_VADDR for text allocations and - * allow allocating data in the entire vmalloc space - */ -#ifdef MODULES_VADDR - unsigned long limit = (unsigned long)_etext - SZ_32M; - - BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR); - - /* First try within 32M limit from _etext to avoid branch trampolines */ - if (MODULES_VADDR < PAGE_OFFSET && MODULES_END > limit) { - start = limit; - fallback_start = MODULES_VADDR; - fallback_end = MODULES_END; - } else { - start = MODULES_VADDR; - } - - end = MODULES_END; -#else - start = VMALLOC_START; - end = VMALLOC_END; -#endif - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = start, - .end = end, - .pgprot = prot, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = kprobes_prot, - .alignment = 1, - }, - [EXECMEM_MODULE_DATA] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c index 3a440004b97d..5de62a3c1d4b 100644 --- a/arch/powerpc/mm/mem.c +++ b/arch/powerpc/mm/mem.c @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -406,3 +407,66 @@ int devmem_is_allowed(unsigned long pfn) * the EHEA driver. Drop this when drivers/net/ethernet/ibm/ehea is removed. */ EXPORT_SYMBOL_GPL(walk_system_ram_range); + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + pgprot_t kprobes_prot = strict_module_rwx_enabled() ? PAGE_KERNEL_ROX : PAGE_KERNEL_EXEC; + pgprot_t prot = strict_module_rwx_enabled() ? PAGE_KERNEL : PAGE_KERNEL_EXEC; + unsigned long fallback_start = 0, fallback_end = 0; + unsigned long start, end; + + /* + * BOOK3S_32 and 8xx define MODULES_VADDR for text allocations and + * allow allocating data in the entire vmalloc space + */ +#ifdef MODULES_VADDR + unsigned long limit = (unsigned long)_etext - SZ_32M; + + BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR); + + /* First try within 32M limit from _etext to avoid branch trampolines */ + if (MODULES_VADDR < PAGE_OFFSET && MODULES_END > limit) { + start = limit; + fallback_start = MODULES_VADDR; + fallback_end = MODULES_END; + } else { + start = MODULES_VADDR; + } + + end = MODULES_END; +#else + start = VMALLOC_START; + end = VMALLOC_END; +#endif + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = start, + .end = end, + .pgprot = prot, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = kprobes_prot, + .alignment = 1, + }, + [EXECMEM_MODULE_DATA] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/riscv/kernel/module.c b/arch/riscv/kernel/module.c index 0e6415f00fca..906f9a3a5d65 100644 --- a/arch/riscv/kernel/module.c +++ b/arch/riscv/kernel/module.c @@ -11,10 +11,8 @@ #include #include #include -#include #include #include -#include #include #include @@ -906,38 +904,6 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab, return 0; } -#ifdef CONFIG_MMU -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_READ_EXEC, - .alignment = 1, - }, - [EXECMEM_BPF] = { - .start = BPF_JIT_REGION_START, - .end = BPF_JIT_REGION_END, - .pgprot = PAGE_KERNEL, - .alignment = PAGE_SIZE, - }, - }, - }; - - return &execmem_info; -} -#endif - int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *me) diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c index fe8e159394d8..a8290609554f 100644 --- a/arch/riscv/mm/init.c +++ b/arch/riscv/mm/init.c @@ -24,6 +24,7 @@ #include #endif #include +#include #include #include @@ -1481,3 +1482,37 @@ void __init pgtable_cache_init(void) preallocate_pgd_pages_range(MODULES_VADDR, MODULES_END, "bpf/modules"); } #endif + +#ifdef CONFIG_EXECMEM +#ifdef CONFIG_MMU +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_READ_EXEC, + .alignment = 1, + }, + [EXECMEM_BPF] = { + .start = BPF_JIT_REGION_START, + .end = BPF_JIT_REGION_END, + .pgprot = PAGE_KERNEL, + .alignment = PAGE_SIZE, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_MMU */ +#endif /* CONFIG_EXECMEM */ diff --git a/arch/s390/kernel/module.c b/arch/s390/kernel/module.c index 7fee64fdc1bb..91e207b50394 100644 --- a/arch/s390/kernel/module.c +++ b/arch/s390/kernel/module.c @@ -37,33 +37,6 @@ #define PLT_ENTRY_SIZE 22 -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long module_load_offset = 0; - unsigned long start; - - if (kaslr_enabled()) - module_load_offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; - - start = MODULES_VADDR + module_load_offset; - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .flags = EXECMEM_KASAN_SHADOW, - .start = start, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = MODULE_ALIGN, - }, - }, - }; - - return &execmem_info; -} - #ifdef CONFIG_FUNCTION_TRACER void module_arch_cleanup(struct module *mod) { diff --git a/arch/s390/mm/init.c b/arch/s390/mm/init.c index f6391442c0c2..e769d2726f4e 100644 --- a/arch/s390/mm/init.c +++ b/arch/s390/mm/init.c @@ -49,6 +49,7 @@ #include #include #include +#include pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(".bss..swapper_pg_dir"); pgd_t invalid_pg_dir[PTRS_PER_PGD] __section(".bss..invalid_pg_dir"); @@ -302,3 +303,32 @@ void arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap) vmem_remove_mapping(start, size); } #endif /* CONFIG_MEMORY_HOTPLUG */ + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long module_load_offset = 0; + unsigned long start; + + if (kaslr_enabled()) + module_load_offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; + + start = MODULES_VADDR + module_load_offset; + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .flags = EXECMEM_KASAN_SHADOW, + .start = start, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = MODULE_ALIGN, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/sparc/kernel/module.c b/arch/sparc/kernel/module.c index 8b7ee45defc3..b8c51cc23d96 100644 --- a/arch/sparc/kernel/module.c +++ b/arch/sparc/kernel/module.c @@ -14,7 +14,6 @@ #include #include #include -#include #include #include @@ -22,24 +21,6 @@ #include "entry.h" -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - /* Make generic code ignore STT_REGISTER dummy undefined symbols. */ int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs, diff --git a/arch/sparc/mm/Makefile b/arch/sparc/mm/Makefile index 809d993f6d88..2d1752108d77 100644 --- a/arch/sparc/mm/Makefile +++ b/arch/sparc/mm/Makefile @@ -14,3 +14,5 @@ obj-$(CONFIG_SPARC32) += leon_mm.o # Only used by sparc64 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o + +obj-$(CONFIG_EXECMEM) += execmem.o diff --git a/arch/sparc/mm/execmem.c b/arch/sparc/mm/execmem.c new file mode 100644 index 000000000000..0fac97dd5728 --- /dev/null +++ b/arch/sparc/mm/execmem.c @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include + +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c index 45b1a7c03379..837450b6e882 100644 --- a/arch/x86/kernel/module.c +++ b/arch/x86/kernel/module.c @@ -19,7 +19,6 @@ #include #include #include -#include #include #include @@ -37,32 +36,6 @@ do { \ } while (0) #endif -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long start, offset = 0; - - if (kaslr_enabled()) - offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; - - start = MODULES_VADDR + offset; - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .flags = EXECMEM_KASAN_SHADOW, - .start = start, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = MODULE_ALIGN, - }, - }, - }; - - return &execmem_info; -} - #ifdef CONFIG_X86_32 int apply_relocate(Elf32_Shdr *sechdrs, const char *strtab, diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c index 679893ea5e68..be4fee17b717 100644 --- a/arch/x86/mm/init.c +++ b/arch/x86/mm/init.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -1099,3 +1100,31 @@ unsigned long arch_max_swapfile_size(void) return pages; } #endif + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long start, offset = 0; + + if (kaslr_enabled()) + offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; + + start = MODULES_VADDR + offset; + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .flags = EXECMEM_KASAN_SHADOW, + .start = start, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = MODULE_ALIGN, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ -- 2.43.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 86A40C4345F for ; Sun, 5 May 2024 16:09:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=B/tLr/KjkTD8/+mR+SBmXahzrOAfda5kuw5Vscid9XI=; b=VPD5V+N54+abCq HcNnfsEwZ3qOpfJ8Udgp5wEfOYbxiFiHhzWy7+zyclhrZ72YRUi4rav5PCilTNdxwJkOPeYylKbw9 1WnPSELGGf4dpd8sNlZZjpUY2VawuVpnGF7dLXrnHFT0BMEHniX8rATQrzYOxTdXF4Tu0OTUJsPAv /SHFje/DVfFvr8FIQVInULCjTVDI/dv4kqou729u4yHcE4lJXNyb8lSMIkIL75G/rlhQ2Zs5EpfP3 pi0H859w17KRtZWSV1uvU4K7c/9rqfRh6vWTbS6v9C7JkN5lLITAnIjx166RGtcbfVgdLqykpi3A4 sBbjidUtxToEK/tP71mg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQp-00000004j40-0WeV; Sun, 05 May 2024 16:09:44 +0000 Received: from desiato.infradead.org ([2001:8b0:10b:1:d65d:64ff:fe57:4e05]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQR-00000004ikY-2nh6; Sun, 05 May 2024 16:09:20 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=Content-Transfer-Encoding:Content-Type :MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Sender:Reply-To:Content-ID:Content-Description; bh=T7xAcO5/CoULMfPQgJR7+ovdKspvbrejEkNN0k7yqQ4=; b=Iwa8ZLQZcgxUnY68l/4KnOgZIH zBZNMkZjt5l08RO6klzx46zYmGZMstd88RpUjb0uI6v+IQwzavDs8HUONEB4EsXCsOjVzFT+AOLK7 EhCL2VNpvjGalrS40O3zmADDUFv4zChcC0QlGDU75ffHbl8M9JzEhBMtHuwRBIAiafT8n+z+hKX6D +T9dctGHNQiB4GCfQaELFhDOeb9eAthoMz9bia7qOZskUsydhXfzPkQULcf/lkgtlanoaooAeX4JE jz/+ibftCTSwQofYMNHKL1eYrjkHLfT0qq60hmRuFaCvO1VBevDF8Jzg/UgnzVrou64pSTNHpgEvx zjk9i5yQ==; Received: from sin.source.kernel.org ([2604:1380:40e1:4800::1]) by desiato.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQN-00000001OHB-15lE; Sun, 05 May 2024 16:09:18 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id EB8C9CE0AB2; Sun, 5 May 2024 16:09:10 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED18EC4DDE2; Sun, 5 May 2024 16:08:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1714925350; bh=5OMBgTFrr36VXyNsljkCHRabEmmDGidsMIUvtOQa2/E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HUOjkTY0MY4Avcwze7CfRrRzvZ8uJCMrkjJMVefuOUwtMJ5EdhxU7JNfJcc54972f 3oOhpCvwmoQ9Q1GPkwpinF5evj2fIyiPqFqm2A6rXSrs6J+b5saRST0hEptRzBNchm Auf1aZnNL10BrlRGGKBPvzfY9zUsb8WDijER56YCQ/T3mYlDNtjhQrdcTBiDC4+1sT 39YY7luhKaiRxcdo24wF1OZY2OK73xFTQ7yliDwpr/XtTQ0GXkhPn658Wk2etTrXSA AvAmAW4UhT0vEPNgqOYrKQUZ1Ak+cHmYwEhJlWambSDSLpHUwgD8LRPOLI6LdEFSyk +vzxUot7u+I/w== From: Mike Rapoport To: linux-kernel@vger.kernel.org Cc: Alexandre Ghiti , Andrew Morton , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Catalin Marinas , Christophe Leroy , "David S. Miller" , Dinh Nguyen , Donald Dutile , Eric Chanudet , Heiko Carstens , Helge Deller , Huacai Chen , Kent Overstreet , Liviu Dudau , Luis Chamberlain , Mark Rutland , Masami Hiramatsu , Michael Ellerman , Mike Rapoport , Nadav Amit , Palmer Dabbelt , Peter Zijlstra , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Rick Edgecombe , Russell King , Sam Ravnborg , Song Liu , Steven Rostedt , Thomas Bogendoerfer , Thomas Gleixner , Will Deacon , bpf@vger.kernel.org, linux-arch@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linux-mm@kvack.org, linux-modules@vger.kernel.org, linux-parisc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, loongarch@lists.linux.dev, netdev@vger.kernel.org, sparclinux@vger.kernel.org, x86@kernel.org Subject: [PATCH RESEND v8 12/16] arch: make execmem setup available regardless of CONFIG_MODULES Date: Sun, 5 May 2024 19:06:24 +0300 Message-ID: <20240505160628.2323363-13-rppt@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240505160628.2323363-1-rppt@kernel.org> References: <20240505160628.2323363-1-rppt@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240505_170916_417538_0FB5EB41 X-CRM114-Status: GOOD ( 30.20 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org RnJvbTogIk1pa2UgUmFwb3BvcnQgKElCTSkiIDxycHB0QGtlcm5lbC5vcmc+CgpleGVjbWVtIGRv ZXMgbm90IGRlcGVuZCBvbiBtb2R1bGVzLCBvbiB0aGUgY29udHJhcnkgbW9kdWxlcyB1c2UKZXhl Y21lbS4KClRvIG1ha2UgZXhlY21lbSBhdmFpbGFibGUgd2hlbiBDT05GSUdfTU9EVUxFUz1uLCBm b3IgaW5zdGFuY2UgZm9yCmtwcm9iZXMsIHNwbGl0IGV4ZWNtZW1fcGFyYW1zIGluaXRpYWxpemF0 aW9uIG91dCBmcm9tCmFyY2gvKi9rZXJuZWwvbW9kdWxlLmMgYW5kIGNvbXBpbGUgaXQgd2hlbiBD T05GSUdfRVhFQ01FTT15CgpTaWduZWQtb2ZmLWJ5OiBNaWtlIFJhcG9wb3J0IChJQk0pIDxycHB0 QGtlcm5lbC5vcmc+ClJldmlld2VkLWJ5OiBQaGlsaXBwZSBNYXRoaWV1LURhdWTDqSA8cGhpbG1k QGxpbmFyby5vcmc+Ci0tLQogYXJjaC9hcm0va2VybmVsL21vZHVsZS5jICAgICAgIHwgIDQzIC0t LS0tLS0tLS0KIGFyY2gvYXJtL21tL2luaXQuYyAgICAgICAgICAgICB8ICA0NSArKysrKysrKysr KwogYXJjaC9hcm02NC9rZXJuZWwvbW9kdWxlLmMgICAgIHwgMTQwIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogYXJjaC9hcm02NC9tbS9pbml0LmMgICAgICAgICAgIHwgMTQwICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogYXJjaC9sb29uZ2FyY2gva2VybmVsL21v ZHVsZS5jIHwgIDE5IC0tLS0tCiBhcmNoL2xvb25nYXJjaC9tbS9pbml0LmMgICAgICAgfCAgMjEg KysrKysKIGFyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMgICAgICB8ICAyMiAtLS0tLS0KIGFyY2gv bWlwcy9tbS9pbml0LmMgICAgICAgICAgICB8ICAyMyArKysrKysKIGFyY2gvbmlvczIva2VybmVs L21vZHVsZS5jICAgICB8ICAyMCAtLS0tLQogYXJjaC9uaW9zMi9tbS9pbml0LmMgICAgICAgICAg IHwgIDIxICsrKysrCiBhcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMgICAgfCAgMjAgLS0tLS0K IGFyY2gvcGFyaXNjL21tL2luaXQuYyAgICAgICAgICB8ICAyMyArKysrKy0KIGFyY2gvcG93ZXJw Yy9rZXJuZWwvbW9kdWxlLmMgICB8ICA2MyAtLS0tLS0tLS0tLS0tLS0KIGFyY2gvcG93ZXJwYy9t bS9tZW0uYyAgICAgICAgICB8ICA2NCArKysrKysrKysrKysrKysKIGFyY2gvcmlzY3Yva2VybmVs L21vZHVsZS5jICAgICB8ICAzNCAtLS0tLS0tLQogYXJjaC9yaXNjdi9tbS9pbml0LmMgICAgICAg ICAgIHwgIDM1ICsrKysrKysrKwogYXJjaC9zMzkwL2tlcm5lbC9tb2R1bGUuYyAgICAgIHwgIDI3 IC0tLS0tLS0KIGFyY2gvczM5MC9tbS9pbml0LmMgICAgICAgICAgICB8ICAzMCArKysrKysrCiBh cmNoL3NwYXJjL2tlcm5lbC9tb2R1bGUuYyAgICAgfCAgMTkgLS0tLS0KIGFyY2gvc3BhcmMvbW0v TWFrZWZpbGUgICAgICAgICB8ICAgMiArCiBhcmNoL3NwYXJjL21tL2V4ZWNtZW0uYyAgICAgICAg fCAgMjEgKysrKysKIGFyY2gveDg2L2tlcm5lbC9tb2R1bGUuYyAgICAgICB8ICAyNyAtLS0tLS0t CiBhcmNoL3g4Ni9tbS9pbml0LmMgICAgICAgICAgICAgfCAgMjkgKysrKysrKwogMjMgZmlsZXMg Y2hhbmdlZCwgNDUzIGluc2VydGlvbnMoKyksIDQzNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBhcmNoL3NwYXJjL21tL2V4ZWNtZW0uYwoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tl cm5lbC9tb2R1bGUuYyBiL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYwppbmRleCBhOThmZGY2ZmYy NmMuLjY3N2YyMThmN2U4NCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL21vZHVsZS5jCisr KyBiL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYwpAQCAtMTIsNTcgKzEyLDE0IEBACiAjaW5jbHVk ZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51 eC9lbGYuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+CiAjaW5jbHVkZSA8bGludXgvZnMu aD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KLSNpbmNsdWRlIDxsaW51eC9nZnAuaD4KLSNp bmNsdWRlIDxsaW51eC9leGVjbWVtLmg+CiAKICNpbmNsdWRlIDxhc20vc2VjdGlvbnMuaD4KICNp bmNsdWRlIDxhc20vc21wX3BsYXQuaD4KICNpbmNsdWRlIDxhc20vdW53aW5kLmg+CiAjaW5jbHVk ZSA8YXNtL29wY29kZXMuaD4KIAotI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCi0vKgotICogVGhl IFhJUCBrZXJuZWwgdGV4dCBpcyBtYXBwZWQgaW4gdGhlIG1vZHVsZSBhcmVhIGZvciBtb2R1bGVz IGFuZAotICogc29tZSBvdGhlciBzdHVmZiB0byB3b3JrIHdpdGhvdXQgYW55IGluZGlyZWN0IHJl bG9jYXRpb25zLgotICogTU9EVUxFU19WQUREUiBpcyByZWRlZmluZWQgaGVyZSBhbmQgbm90IGlu IGFzbS9tZW1vcnkuaCB0byBhdm9pZAotICogcmVjb21waWxpbmcgdGhlIHdob2xlIGtlcm5lbCB3 aGVuIENPTkZJR19YSVBfS0VSTkVMIGlzIHR1cm5lZCBvbi9vZmYuCi0gKi8KLSN1bmRlZiBNT0RV TEVTX1ZBRERSCi0jZGVmaW5lIE1PRFVMRVNfVkFERFIJKCgodW5zaWduZWQgbG9uZylfZXhpcHJv bSArIH5QTURfTUFTSykgJiBQTURfTUFTSykKLSNlbmRpZgotCi0jaWZkZWYgQ09ORklHX01NVQot c3RhdGljIHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsK LQotc3RydWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQot ewotCXVuc2lnbmVkIGxvbmcgZmFsbGJhY2tfc3RhcnQgPSAwLCBmYWxsYmFja19lbmQgPSAwOwot Ci0JaWYgKElTX0VOQUJMRUQoQ09ORklHX0FSTV9NT0RVTEVfUExUUykpIHsKLQkJZmFsbGJhY2tf c3RhcnQgPSBWTUFMTE9DX1NUQVJUOwotCQlmYWxsYmFja19lbmQgPSBWTUFMTE9DX0VORDsKLQl9 Ci0KLQlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7 Ci0JCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKLQkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZBRERSLAot CQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxfRVhFQywK LQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFja19zdGFy dCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0gZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJfSwKLQl9Owot Ci0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0jZW5kaWYKLQogYm9vbCBtb2R1bGVfaW5pdF9z ZWN0aW9uKGNvbnN0IGNoYXIgKm5hbWUpCiB7CiAJcmV0dXJuIHN0cnN0YXJ0cyhuYW1lLCAiLmlu aXQiKSB8fApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vaW5pdC5jIGIvYXJjaC9hcm0vbW0vaW5p dC5jCmluZGV4IGU4YzZmNGJlMGNlMS4uNTM0NWQyMTg4OTlhIDEwMDY0NAotLS0gYS9hcmNoL2Fy bS9tbS9pbml0LmMKKysrIGIvYXJjaC9hcm0vbW0vaW5pdC5jCkBAIC0yMiw2ICsyMiw3IEBACiAj aW5jbHVkZSA8bGludXgvc2l6ZXMuaD4KICNpbmNsdWRlIDxsaW51eC9zdG9wX21hY2hpbmUuaD4K ICNpbmNsdWRlIDxsaW51eC9zd2lvdGxiLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgog CiAjaW5jbHVkZSA8YXNtL2NwMTUuaD4KICNpbmNsdWRlIDxhc20vbWFjaC10eXBlcy5oPgpAQCAt NDg2LDMgKzQ4Nyw0NyBAQCB2b2lkIGZyZWVfaW5pdHJkX21lbSh1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGVuZCkKIAlmcmVlX3Jlc2VydmVkX2FyZWEoKHZvaWQgKilzdGFydCwg KHZvaWQgKillbmQsIC0xLCAiaW5pdHJkIik7CiB9CiAjZW5kaWYKKworI2lmZGVmIENPTkZJR19F WEVDTUVNCisKKyNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAorLyoKKyAqIFRoZSBYSVAga2VybmVs IHRleHQgaXMgbWFwcGVkIGluIHRoZSBtb2R1bGUgYXJlYSBmb3IgbW9kdWxlcyBhbmQKKyAqIHNv bWUgb3RoZXIgc3R1ZmYgdG8gd29yayB3aXRob3V0IGFueSBpbmRpcmVjdCByZWxvY2F0aW9ucy4K KyAqIE1PRFVMRVNfVkFERFIgaXMgcmVkZWZpbmVkIGhlcmUgYW5kIG5vdCBpbiBhc20vbWVtb3J5 LmggdG8gYXZvaWQKKyAqIHJlY29tcGlsaW5nIHRoZSB3aG9sZSBrZXJuZWwgd2hlbiBDT05GSUdf WElQX0tFUk5FTCBpcyB0dXJuZWQgb24vb2ZmLgorICovCisjdW5kZWYgTU9EVUxFU19WQUREUgor I2RlZmluZSBNT0RVTEVTX1ZBRERSCSgoKHVuc2lnbmVkIGxvbmcpX2V4aXByb20gKyB+UE1EX01B U0spICYgUE1EX01BU0spCisjZW5kaWYKKworI2lmZGVmIENPTkZJR19NTVUKK3N0YXRpYyBzdHJ1 Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7CisKK3N0cnVjdCBl eGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKK3sKKwl1bnNpZ25l ZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJhY2tfZW5kID0gMDsKKworCWlmIChJU19F TkFCTEVEKENPTkZJR19BUk1fTU9EVUxFX1BMVFMpKSB7CisJCWZhbGxiYWNrX3N0YXJ0ID0gVk1B TExPQ19TVEFSVDsKKwkJZmFsbGJhY2tfZW5kID0gVk1BTExPQ19FTkQ7CisJfQorCisJZXhlY21l bV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNN RU1fREVGQVVMVF0gPSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKKwkJCQkuZW5kCT0g TU9EVUxFU19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX0VYRUMsCisJCQkJLmFsaWdu bWVudCA9IDEsCisJCQkJLmZhbGxiYWNrX3N0YXJ0CT0gZmFsbGJhY2tfc3RhcnQsCisJCQkJLmZh bGxiYWNrX2VuZAk9IGZhbGxiYWNrX2VuZCwKKwkJCX0sCisJCX0sCisJfTsKKworCXJldHVybiAm ZXhlY21lbV9pbmZvOworfQorI2VuZGlmIC8qIENPTkZJR19NTVUgKi8KKworI2VuZGlmIC8qIENP TkZJR19FWEVDTUVNICovCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYyBi L2FyY2gvYXJtNjQva2VybmVsL21vZHVsZS5jCmluZGV4IGE1MjI0MGVhMDg0Yi4uMzZiMjVhZjU2 MzI0IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL2Fy bTY0L2tlcm5lbC9tb2R1bGUuYwpAQCAtMTIsMTU4ICsxMiwxOCBAQAogI2luY2x1ZGUgPGxpbnV4 L2JpdG9wcy5oPgogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFj ZS5oPgotI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgogI2luY2x1ZGUgPGxpbnV4L2thc2FuLmg+CiAj aW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRl IDxsaW51eC9tb2R1bGVsb2FkZXIuaD4KICNpbmNsdWRlIDxsaW51eC9yYW5kb20uaD4KICNpbmNs dWRlIDxsaW51eC9zY3MuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+Ci0jaW5jbHVkZSA8 bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVkZSA8YXNtL2FsdGVybmF0aXZlLmg+CiAjaW5jbHVk ZSA8YXNtL2luc24uaD4KICNpbmNsdWRlIDxhc20vc2NzLmg+CiAjaW5jbHVkZSA8YXNtL3NlY3Rp b25zLmg+CiAKLXN0YXRpYyB1NjQgbW9kdWxlX2RpcmVjdF9iYXNlIF9fcm9fYWZ0ZXJfaW5pdCA9 IDA7Ci1zdGF0aWMgdTY0IG1vZHVsZV9wbHRfYmFzZSBfX3JvX2FmdGVyX2luaXQgPSAwOwotCi0v KgotICogQ2hvb3NlIGEgcmFuZG9tIHBhZ2UtYWxpZ25lZCBiYXNlIGFkZHJlc3MgZm9yIGEgd2lu ZG93IG9mICdzaXplJyBieXRlcyB3aGljaAotICogZW50aXJlbHkgY29udGFpbnMgdGhlIGludGVy dmFsIFtzdGFydCwgZW5kIC0gMV0uCi0gKi8KLXN0YXRpYyB1NjQgX19pbml0IHJhbmRvbV9ib3Vu ZGluZ19ib3godTY0IHNpemUsIHU2NCBzdGFydCwgdTY0IGVuZCkKLXsKLQl1NjQgbWF4X3Bnb2Zm LCBwZ29mZjsKLQotCWlmICgoZW5kIC0gc3RhcnQpID49IHNpemUpCi0JCXJldHVybiAwOwotCi0J bWF4X3Bnb2ZmID0gKHNpemUgLSAoZW5kIC0gc3RhcnQpKSAvIFBBR0VfU0laRTsKLQlwZ29mZiA9 IGdldF9yYW5kb21fdTMyX2luY2x1c2l2ZSgwLCBtYXhfcGdvZmYpOwotCi0JcmV0dXJuIHN0YXJ0 IC0gcGdvZmYgKiBQQUdFX1NJWkU7Ci19Ci0KLS8qCi0gKiBNb2R1bGVzIG1heSBkaXJlY3RseSBy ZWZlcmVuY2UgZGF0YSBhbmQgdGV4dCBhbnl3aGVyZSB3aXRoaW4gdGhlIGtlcm5lbAotICogaW1h Z2UgYW5kIG90aGVyIG1vZHVsZXMuIFJlZmVyZW5jZXMgdXNpbmcgUFJFTDMyIHJlbG9jYXRpb25z IGhhdmUgYSArLy0yRwotICogcmFuZ2UsIGFuZCBzbyB3ZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHRo ZSBlbnRpcmUga2VybmVsIGltYWdlIGFuZCBhbGwgbW9kdWxlcwotICogZmFsbCB3aXRoaW4gYSAy RyB3aW5kb3cgc3VjaCB0aGF0IHRoZXNlIGFyZSBhbHdheXMgd2l0aGluIHJhbmdlLgotICoKLSAq IE1vZHVsZXMgbWF5IGRpcmVjdGx5IGJyYW5jaCB0byBmdW5jdGlvbnMgYW5kIGNvZGUgd2l0aGlu IHRoZSBrZXJuZWwgdGV4dCwKLSAqIGFuZCB0byBmdW5jdGlvbnMgYW5kIGNvZGUgd2l0aGluIG90 aGVyIG1vZHVsZXMuIFRoZXNlIGJyYW5jaGVzIHdpbGwgdXNlCi0gKiBDQUxMMjYvSlVNUDI2IHJl bG9jYXRpb25zIHdpdGggYSArLy0xMjhNIHJhbmdlLiBXaXRob3V0IFBMVHMsIHdlIG11c3QgZW5z dXJlCi0gKiB0aGF0IHRoZSBlbnRpcmUga2VybmVsIHRleHQgYW5kIGFsbCBtb2R1bGUgdGV4dCBm YWxscyB3aXRoaW4gYSAxMjhNIHdpbmRvdwotICogc3VjaCB0aGF0IHRoZXNlIGFyZSBhbHdheXMg d2l0aGluIHJhbmdlLiBXaXRoIFBMVHMsIHdlIGNhbiBleHBhbmQgdGhpcyB0byBhCi0gKiAyRyB3 aW5kb3cuCi0gKgotICogV2UgY2hvc2UgdGhlIDEyOE0gcmVnaW9uIHRvIHN1cnJvdW5kIHRoZSBl bnRpcmUga2VybmVsIGltYWdlIChyYXRoZXIgdGhhbgotICoganVzdCB0aGUgdGV4dCkgYXMgdXNp bmcgdGhlIHNhbWUgYm91bmRzIGZvciB0aGUgMTI4TSBhbmQgMkcgcmVnaW9ucyBlbnN1cmVzCi0g KiBieSBjb25zdHJ1Y3Rpb24gdGhhdCB3ZSBuZXZlciBzZWxlY3QgYSAxMjhNIHJlZ2lvbiB0aGF0 IGlzIG5vdCBhIHN1YnNldCBvZgotICogdGhlIDJHIHJlZ2lvbi4gRm9yIHZlcnkgbGFyZ2UgYW5k IHVudXN1YWwga2VybmVsIGNvbmZpZ3VyYXRpb25zIHRoaXMgbWVhbnMKLSAqIHdlIG1heSBmYWxs IGJhY2sgdG8gUExUcyB3aGVyZSB0aGV5IGNvdWxkIGhhdmUgYmVlbiBhdm9pZGVkLCBidXQgdGhp cyBrZWVwcwotICogdGhlIGxvZ2ljIHNpZ25pZmljYW50bHkgc2ltcGxlci4KLSAqLwotc3RhdGlj IGludCBfX2luaXQgbW9kdWxlX2luaXRfbGltaXRzKHZvaWQpCi17Ci0JdTY0IGtlcm5lbF9lbmQg PSAodTY0KV9lbmQ7Ci0JdTY0IGtlcm5lbF9zdGFydCA9ICh1NjQpX3RleHQ7Ci0JdTY0IGtlcm5l bF9zaXplID0ga2VybmVsX2VuZCAtIGtlcm5lbF9zdGFydDsKLQotCS8qCi0JICogVGhlIGRlZmF1 bHQgbW9kdWxlcyByZWdpb24gaXMgcGxhY2VkIGltbWVkaWF0ZWx5IGJlbG93IHRoZSBrZXJuZWwK LQkgKiBpbWFnZSwgYW5kIGlzIGxhcmdlIGVub3VnaCB0byB1c2UgdGhlIGZ1bGwgMkcgcmVsb2Nh dGlvbiByYW5nZS4KLQkgKi8KLQlCVUlMRF9CVUdfT04oS0lNQUdFX1ZBRERSICE9IE1PRFVMRVNf RU5EKTsKLQlCVUlMRF9CVUdfT04oTU9EVUxFU19WU0laRSA8IFNaXzJHKTsKLQotCWlmICgha2Fz bHJfZW5hYmxlZCgpKSB7Ci0JCWlmIChrZXJuZWxfc2l6ZSA8IFNaXzEyOE0pCi0JCQltb2R1bGVf ZGlyZWN0X2Jhc2UgPSBrZXJuZWxfZW5kIC0gU1pfMTI4TTsKLQkJaWYgKGtlcm5lbF9zaXplIDwg U1pfMkcpCi0JCQltb2R1bGVfcGx0X2Jhc2UgPSBrZXJuZWxfZW5kIC0gU1pfMkc7Ci0JfSBlbHNl IHsKLQkJdTY0IG1pbiA9IGtlcm5lbF9zdGFydDsKLQkJdTY0IG1heCA9IGtlcm5lbF9lbmQ7Ci0K LQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX1JBTkRPTUlaRV9NT0RVTEVfUkVHSU9OX0ZVTEwpKSB7 Ci0JCQlwcl9pbmZvKCIyRyBtb2R1bGUgcmVnaW9uIGZvcmNlZCBieSBSQU5ET01JWkVfTU9EVUxF X1JFR0lPTl9GVUxMXG4iKTsKLQkJfSBlbHNlIHsKLQkJCW1vZHVsZV9kaXJlY3RfYmFzZSA9IHJh bmRvbV9ib3VuZGluZ19ib3goU1pfMTI4TSwgbWluLCBtYXgpOwotCQkJaWYgKG1vZHVsZV9kaXJl Y3RfYmFzZSkgewotCQkJCW1pbiA9IG1vZHVsZV9kaXJlY3RfYmFzZTsKLQkJCQltYXggPSBtb2R1 bGVfZGlyZWN0X2Jhc2UgKyBTWl8xMjhNOwotCQkJfQotCQl9Ci0KLQkJbW9kdWxlX3BsdF9iYXNl ID0gcmFuZG9tX2JvdW5kaW5nX2JveChTWl8yRywgbWluLCBtYXgpOwotCX0KLQotCXByX2luZm8o IiVsbHUgcGFnZXMgaW4gcmFuZ2UgZm9yIG5vbi1QTFQgdXNhZ2UiLAotCQltb2R1bGVfZGlyZWN0 X2Jhc2UgPyAoU1pfMTI4TSAtIGtlcm5lbF9zaXplKSAvIFBBR0VfU0laRSA6IDApOwotCXByX2lu Zm8oIiVsbHUgcGFnZXMgaW4gcmFuZ2UgZm9yIFBMVCB1c2FnZSIsCi0JCW1vZHVsZV9wbHRfYmFz ZSA/IChTWl8yRyAtIGtlcm5lbF9zaXplKSAvIFBBR0VfU0laRSA6IDApOwotCi0JcmV0dXJuIDA7 Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVy X2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAo dm9pZCkKLXsKLQl1bnNpZ25lZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJhY2tfZW5k ID0gMDsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gMCwgZW5kID0gMDsKLQotCW1vZHVsZV9pbml0 X2xpbWl0cygpOwotCi0JLyoKLQkgKiBXaGVyZSBwb3NzaWJsZSwgcHJlZmVyIHRvIGFsbG9jYXRl IHdpdGhpbiBkaXJlY3QgYnJhbmNoIHJhbmdlIG9mIHRoZQotCSAqIGtlcm5lbCBzdWNoIHRoYXQg bm8gUExUcyBhcmUgbmVjZXNzYXJ5LgotCSAqLwotCWlmIChtb2R1bGVfZGlyZWN0X2Jhc2UpIHsK LQkJc3RhcnQgPSBtb2R1bGVfZGlyZWN0X2Jhc2U7Ci0JCWVuZCA9IG1vZHVsZV9kaXJlY3RfYmFz ZSArIFNaXzEyOE07Ci0KLQkJaWYgKG1vZHVsZV9wbHRfYmFzZSkgewotCQkJZmFsbGJhY2tfc3Rh cnQgPSBtb2R1bGVfcGx0X2Jhc2U7Ci0JCQlmYWxsYmFja19lbmQgPSBtb2R1bGVfcGx0X2Jhc2Ug KyBTWl8yRzsKLQkJfQotCX0gZWxzZSBpZiAobW9kdWxlX3BsdF9iYXNlKSB7Ci0JCXN0YXJ0ID0g bW9kdWxlX3BsdF9iYXNlOwotCQllbmQgPSBtb2R1bGVfcGx0X2Jhc2UgKyBTWl8yRzsKLQl9Ci0K LQlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7Ci0J CQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKLQkJCQkuc3RhcnQJPSBzdGFydCwKLQkJCQkuZW5kCT0g ZW5kLAotCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJ CQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFja19zdGFydCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0g ZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJCVtFWEVDTUVNX0tQUk9CRVNdID0gewotCQkJCS5zdGFy dAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVuZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJ PSBQQUdFX0tFUk5FTF9ST1gsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9LAotCQkJW0VYRUNN RU1fQlBGXSA9IHsKLQkJCQkuc3RhcnQJPSBWTUFMTE9DX1NUQVJULAotCQkJCS5lbmQJPSBWTUFM TE9DX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFsaWdubWVudCA9IDEs Ci0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0KLQogZW51bSBh YXJjaDY0X3JlbG9jX29wIHsKIAlSRUxPQ19PUF9OT05FLAogCVJFTE9DX09QX0FCUywKZGlmZiAt LWdpdCBhL2FyY2gvYXJtNjQvbW0vaW5pdC5jIGIvYXJjaC9hcm02NC9tbS9pbml0LmMKaW5kZXgg MDNlZmQ4NmRjZTBhLi45YjVhYjY4MThmN2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvbW0vaW5p dC5jCisrKyBiL2FyY2gvYXJtNjQvbW0vaW5pdC5jCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVk ZSA8bGludXgvaHVnZXRsYi5oPgogI2luY2x1ZGUgPGxpbnV4L2FjcGlfaW9ydC5oPgogI2luY2x1 ZGUgPGxpbnV4L2ttZW1sZWFrLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5j bHVkZSA8YXNtL2Jvb3QuaD4KICNpbmNsdWRlIDxhc20vZml4bWFwLmg+CkBAIC00MzIsMyArNDMz LDE0MiBAQCB2b2lkIGR1bXBfbWVtX2xpbWl0KHZvaWQpCiAJCXByX2VtZXJnKCJNZW1vcnkgTGlt aXQ6IG5vbmVcbiIpOwogCX0KIH0KKworI2lmZGVmIENPTkZJR19FWEVDTUVNCitzdGF0aWMgdTY0 IG1vZHVsZV9kaXJlY3RfYmFzZSBfX3JvX2FmdGVyX2luaXQgPSAwOworc3RhdGljIHU2NCBtb2R1 bGVfcGx0X2Jhc2UgX19yb19hZnRlcl9pbml0ID0gMDsKKworLyoKKyAqIENob29zZSBhIHJhbmRv bSBwYWdlLWFsaWduZWQgYmFzZSBhZGRyZXNzIGZvciBhIHdpbmRvdyBvZiAnc2l6ZScgYnl0ZXMg d2hpY2gKKyAqIGVudGlyZWx5IGNvbnRhaW5zIHRoZSBpbnRlcnZhbCBbc3RhcnQsIGVuZCAtIDFd LgorICovCitzdGF0aWMgdTY0IF9faW5pdCByYW5kb21fYm91bmRpbmdfYm94KHU2NCBzaXplLCB1 NjQgc3RhcnQsIHU2NCBlbmQpCit7CisJdTY0IG1heF9wZ29mZiwgcGdvZmY7CisKKwlpZiAoKGVu ZCAtIHN0YXJ0KSA+PSBzaXplKQorCQlyZXR1cm4gMDsKKworCW1heF9wZ29mZiA9IChzaXplIC0g KGVuZCAtIHN0YXJ0KSkgLyBQQUdFX1NJWkU7CisJcGdvZmYgPSBnZXRfcmFuZG9tX3UzMl9pbmNs dXNpdmUoMCwgbWF4X3Bnb2ZmKTsKKworCXJldHVybiBzdGFydCAtIHBnb2ZmICogUEFHRV9TSVpF OworfQorCisvKgorICogTW9kdWxlcyBtYXkgZGlyZWN0bHkgcmVmZXJlbmNlIGRhdGEgYW5kIHRl eHQgYW55d2hlcmUgd2l0aGluIHRoZSBrZXJuZWwKKyAqIGltYWdlIGFuZCBvdGhlciBtb2R1bGVz LiBSZWZlcmVuY2VzIHVzaW5nIFBSRUwzMiByZWxvY2F0aW9ucyBoYXZlIGEgKy8tMkcKKyAqIHJh bmdlLCBhbmQgc28gd2UgbmVlZCB0byBlbnN1cmUgdGhhdCB0aGUgZW50aXJlIGtlcm5lbCBpbWFn ZSBhbmQgYWxsIG1vZHVsZXMKKyAqIGZhbGwgd2l0aGluIGEgMkcgd2luZG93IHN1Y2ggdGhhdCB0 aGVzZSBhcmUgYWx3YXlzIHdpdGhpbiByYW5nZS4KKyAqCisgKiBNb2R1bGVzIG1heSBkaXJlY3Rs eSBicmFuY2ggdG8gZnVuY3Rpb25zIGFuZCBjb2RlIHdpdGhpbiB0aGUga2VybmVsIHRleHQsCisg KiBhbmQgdG8gZnVuY3Rpb25zIGFuZCBjb2RlIHdpdGhpbiBvdGhlciBtb2R1bGVzLiBUaGVzZSBi cmFuY2hlcyB3aWxsIHVzZQorICogQ0FMTDI2L0pVTVAyNiByZWxvY2F0aW9ucyB3aXRoIGEgKy8t MTI4TSByYW5nZS4gV2l0aG91dCBQTFRzLCB3ZSBtdXN0IGVuc3VyZQorICogdGhhdCB0aGUgZW50 aXJlIGtlcm5lbCB0ZXh0IGFuZCBhbGwgbW9kdWxlIHRleHQgZmFsbHMgd2l0aGluIGEgMTI4TSB3 aW5kb3cKKyAqIHN1Y2ggdGhhdCB0aGVzZSBhcmUgYWx3YXlzIHdpdGhpbiByYW5nZS4gV2l0aCBQ TFRzLCB3ZSBjYW4gZXhwYW5kIHRoaXMgdG8gYQorICogMkcgd2luZG93LgorICoKKyAqIFdlIGNo b3NlIHRoZSAxMjhNIHJlZ2lvbiB0byBzdXJyb3VuZCB0aGUgZW50aXJlIGtlcm5lbCBpbWFnZSAo cmF0aGVyIHRoYW4KKyAqIGp1c3QgdGhlIHRleHQpIGFzIHVzaW5nIHRoZSBzYW1lIGJvdW5kcyBm b3IgdGhlIDEyOE0gYW5kIDJHIHJlZ2lvbnMgZW5zdXJlcworICogYnkgY29uc3RydWN0aW9uIHRo YXQgd2UgbmV2ZXIgc2VsZWN0IGEgMTI4TSByZWdpb24gdGhhdCBpcyBub3QgYSBzdWJzZXQgb2YK KyAqIHRoZSAyRyByZWdpb24uIEZvciB2ZXJ5IGxhcmdlIGFuZCB1bnVzdWFsIGtlcm5lbCBjb25m aWd1cmF0aW9ucyB0aGlzIG1lYW5zCisgKiB3ZSBtYXkgZmFsbCBiYWNrIHRvIFBMVHMgd2hlcmUg dGhleSBjb3VsZCBoYXZlIGJlZW4gYXZvaWRlZCwgYnV0IHRoaXMga2VlcHMKKyAqIHRoZSBsb2dp YyBzaWduaWZpY2FudGx5IHNpbXBsZXIuCisgKi8KK3N0YXRpYyBpbnQgX19pbml0IG1vZHVsZV9p bml0X2xpbWl0cyh2b2lkKQoreworCXU2NCBrZXJuZWxfZW5kID0gKHU2NClfZW5kOworCXU2NCBr ZXJuZWxfc3RhcnQgPSAodTY0KV90ZXh0OworCXU2NCBrZXJuZWxfc2l6ZSA9IGtlcm5lbF9lbmQg LSBrZXJuZWxfc3RhcnQ7CisKKwkvKgorCSAqIFRoZSBkZWZhdWx0IG1vZHVsZXMgcmVnaW9uIGlz IHBsYWNlZCBpbW1lZGlhdGVseSBiZWxvdyB0aGUga2VybmVsCisJICogaW1hZ2UsIGFuZCBpcyBs YXJnZSBlbm91Z2ggdG8gdXNlIHRoZSBmdWxsIDJHIHJlbG9jYXRpb24gcmFuZ2UuCisJICovCisJ QlVJTERfQlVHX09OKEtJTUFHRV9WQUREUiAhPSBNT0RVTEVTX0VORCk7CisJQlVJTERfQlVHX09O KE1PRFVMRVNfVlNJWkUgPCBTWl8yRyk7CisKKwlpZiAoIWthc2xyX2VuYWJsZWQoKSkgeworCQlp ZiAoa2VybmVsX3NpemUgPCBTWl8xMjhNKQorCQkJbW9kdWxlX2RpcmVjdF9iYXNlID0ga2VybmVs X2VuZCAtIFNaXzEyOE07CisJCWlmIChrZXJuZWxfc2l6ZSA8IFNaXzJHKQorCQkJbW9kdWxlX3Bs dF9iYXNlID0ga2VybmVsX2VuZCAtIFNaXzJHOworCX0gZWxzZSB7CisJCXU2NCBtaW4gPSBrZXJu ZWxfc3RhcnQ7CisJCXU2NCBtYXggPSBrZXJuZWxfZW5kOworCisJCWlmIChJU19FTkFCTEVEKENP TkZJR19SQU5ET01JWkVfTU9EVUxFX1JFR0lPTl9GVUxMKSkgeworCQkJcHJfaW5mbygiMkcgbW9k dWxlIHJlZ2lvbiBmb3JjZWQgYnkgUkFORE9NSVpFX01PRFVMRV9SRUdJT05fRlVMTFxuIik7CisJ CX0gZWxzZSB7CisJCQltb2R1bGVfZGlyZWN0X2Jhc2UgPSByYW5kb21fYm91bmRpbmdfYm94KFNa XzEyOE0sIG1pbiwgbWF4KTsKKwkJCWlmIChtb2R1bGVfZGlyZWN0X2Jhc2UpIHsKKwkJCQltaW4g PSBtb2R1bGVfZGlyZWN0X2Jhc2U7CisJCQkJbWF4ID0gbW9kdWxlX2RpcmVjdF9iYXNlICsgU1pf MTI4TTsKKwkJCX0KKwkJfQorCisJCW1vZHVsZV9wbHRfYmFzZSA9IHJhbmRvbV9ib3VuZGluZ19i b3goU1pfMkcsIG1pbiwgbWF4KTsKKwl9CisKKwlwcl9pbmZvKCIlbGx1IHBhZ2VzIGluIHJhbmdl IGZvciBub24tUExUIHVzYWdlIiwKKwkJbW9kdWxlX2RpcmVjdF9iYXNlID8gKFNaXzEyOE0gLSBr ZXJuZWxfc2l6ZSkgLyBQQUdFX1NJWkUgOiAwKTsKKwlwcl9pbmZvKCIlbGx1IHBhZ2VzIGluIHJh bmdlIGZvciBQTFQgdXNhZ2UiLAorCQltb2R1bGVfcGx0X2Jhc2UgPyAoU1pfMkcgLSBrZXJuZWxf c2l6ZSkgLyBQQUdFX1NJWkUgOiAwKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0 IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OworCitzdHJ1Y3QgZXhl Y21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCit7CisJdW5zaWduZWQg bG9uZyBmYWxsYmFja19zdGFydCA9IDAsIGZhbGxiYWNrX2VuZCA9IDA7CisJdW5zaWduZWQgbG9u ZyBzdGFydCA9IDAsIGVuZCA9IDA7CisKKwltb2R1bGVfaW5pdF9saW1pdHMoKTsKKworCS8qCisJ ICogV2hlcmUgcG9zc2libGUsIHByZWZlciB0byBhbGxvY2F0ZSB3aXRoaW4gZGlyZWN0IGJyYW5j aCByYW5nZSBvZiB0aGUKKwkgKiBrZXJuZWwgc3VjaCB0aGF0IG5vIFBMVHMgYXJlIG5lY2Vzc2Fy eS4KKwkgKi8KKwlpZiAobW9kdWxlX2RpcmVjdF9iYXNlKSB7CisJCXN0YXJ0ID0gbW9kdWxlX2Rp cmVjdF9iYXNlOworCQllbmQgPSBtb2R1bGVfZGlyZWN0X2Jhc2UgKyBTWl8xMjhNOworCisJCWlm IChtb2R1bGVfcGx0X2Jhc2UpIHsKKwkJCWZhbGxiYWNrX3N0YXJ0ID0gbW9kdWxlX3BsdF9iYXNl OworCQkJZmFsbGJhY2tfZW5kID0gbW9kdWxlX3BsdF9iYXNlICsgU1pfMkc7CisJCX0KKwl9IGVs c2UgaWYgKG1vZHVsZV9wbHRfYmFzZSkgeworCQlzdGFydCA9IG1vZHVsZV9wbHRfYmFzZTsKKwkJ ZW5kID0gbW9kdWxlX3BsdF9iYXNlICsgU1pfMkc7CisJfQorCisJZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7CisJCQkJLnN0YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IGVuZCwKKwkJCQkucGdwcm90CT0g UEFHRV9LRVJORUwsCisJCQkJLmFsaWdubWVudCA9IDEsCisJCQkJLmZhbGxiYWNrX3N0YXJ0CT0g ZmFsbGJhY2tfc3RhcnQsCisJCQkJLmZhbGxiYWNrX2VuZAk9IGZhbGxiYWNrX2VuZCwKKwkJCX0s CisJCQlbRVhFQ01FTV9LUFJPQkVTXSA9IHsKKwkJCQkuc3RhcnQJPSBWTUFMTE9DX1NUQVJULAor CQkJCS5lbmQJPSBWTUFMTE9DX0VORCwKKwkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxfUk9YLAor CQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJCVtFWEVDTUVNX0JQRl0gPSB7CisJCQkJLnN0 YXJ0CT0gVk1BTExPQ19TVEFSVCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCisJCQkJLnBncHJv dAk9IFBBR0VfS0VSTkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9Owor CisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8K ZGlmZiAtLWdpdCBhL2FyY2gvbG9vbmdhcmNoL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvbG9vbmdh cmNoL2tlcm5lbC9tb2R1bGUuYwppbmRleCBjYTZkZDdlYTE2MTAuLjM2ZDZkOWVlYjdjNyAxMDA2 NDQKLS0tIGEvYXJjaC9sb29uZ2FyY2gva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvbG9vbmdh cmNoL2tlcm5lbC9tb2R1bGUuYwpAQCAtMTgsNyArMTgsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2Z0 cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5l bC5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KICNpbmNsdWRlIDxhc20vYWx0ZXJuYXRp dmUuaD4KICNpbmNsdWRlIDxhc20vaW5zdC5oPgogI2luY2x1ZGUgPGFzbS91bndpbmQuaD4KQEAg LTQ5MSwyNCArNDkwLDYgQEAgaW50IGFwcGx5X3JlbG9jYXRlX2FkZChFbGZfU2hkciAqc2VjaGRy cywgY29uc3QgY2hhciAqc3RydGFiLAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IGV4 ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21l bV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZv ID0gKHN0cnVjdCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVG QVVMVF0gPSB7Ci0JCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxF U19FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAot CQkJfSwKLQkJfSwKLQl9OwotCi0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0KIHN0YXRpYyB2 b2lkIG1vZHVsZV9pbml0X2Z0cmFjZV9wbHQoY29uc3QgRWxmX0VoZHIgKmhkciwKIAkJCQkgICBj b25zdCBFbGZfU2hkciAqc2VjaGRycywgc3RydWN0IG1vZHVsZSAqbW9kKQogewpkaWZmIC0tZ2l0 IGEvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jIGIvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jCmlu ZGV4IDRkZDUzNDI3ZjY1Ny4uYmY3ODlkMTE0YzJkIDEwMDY0NAotLS0gYS9hcmNoL2xvb25nYXJj aC9tbS9pbml0LmMKKysrIGIvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jCkBAIC0yNCw2ICsyNCw3 IEBACiAjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CiAjaW5jbHVkZSA8bGludXgvaHVnZXRsYi5oPgog I2luY2x1ZGUgPGxpbnV4L21tem9uZS5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAog I2luY2x1ZGUgPGFzbS9hc20tb2Zmc2V0cy5oPgogI2luY2x1ZGUgPGFzbS9ib290aW5mby5oPgpA QCAtMjQ4LDMgKzI0OSwyMyBAQCBFWFBPUlRfU1lNQk9MKGludmFsaWRfcG1kX3RhYmxlKTsKICNl bmRpZgogcHRlX3QgaW52YWxpZF9wdGVfdGFibGVbUFRSU19QRVJfUFRFXSBfX3BhZ2VfYWxpZ25l ZF9ic3M7CiBFWFBPUlRfU1lNQk9MKGludmFsaWRfcHRlX3RhYmxlKTsKKworI2lmZGVmIENPTkZJ R19FWEVDTUVNCitzdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19h ZnRlcl9pbml0OworCitzdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3Nl dHVwKHZvaWQpCit7CisJZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQku cmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxF U19WQUREUiwKKwkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VS TkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZl eGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBh L2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL21pcHMva2VybmVsL21vZHVsZS5jCmlu ZGV4IDU5MjI1YTNjZjkxOC4uYmEwZjYyZDhlZmY1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2Vy bmVsL21vZHVsZS5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMKQEAgLTEzLDE0ICsx MywxMiBAQAogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAj aW5jbHVkZSA8bGludXgvbnVtYS5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNs dWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51 eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9z cGlubG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L2p1bXBfbGFiZWwuaD4KLSNpbmNsdWRlIDxsaW51 eC9leGVjbWVtLmg+CiAjaW5jbHVkZSA8YXNtL2p1bXBfbGFiZWwuaD4KIAogc3RydWN0IG1pcHNf aGkxNiB7CkBAIC0zMiwyNiArMzAsNiBAQCBzdHJ1Y3QgbWlwc19oaTE2IHsKIHN0YXRpYyBMSVNU X0hFQUQoZGJlX2xpc3QpOwogc3RhdGljIERFRklORV9TUElOTE9DSyhkYmVfbG9jayk7CiAKLSNp ZmRlZiBNT0RVTEVTX1ZBRERSCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2lu Zm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21l bV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2lu Zm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7Ci0JCQkJLnN0YXJ0 CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0JCQkJLnBncHJvdAk9 IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAotCQkJfSwKLQkJfSwKLQl9OwotCi0J cmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0jZW5kaWYKLQogc3RhdGljIHZvaWQgYXBwbHlfcl9t aXBzXzMyKHUzMiAqbG9jYXRpb24sIHUzMiBiYXNlLCBFbGZfQWRkciB2KQogewogCSpsb2NhdGlv biA9IGJhc2UgKyB2OwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21tL2luaXQuYyBiL2FyY2gvbWlw cy9tbS9pbml0LmMKaW5kZXggMzlmMTI5MjA1YjBjLi40NTgzZDFhMmE3M2UgMTAwNjQ0Ci0tLSBh L2FyY2gvbWlwcy9tbS9pbml0LmMKKysrIGIvYXJjaC9taXBzL21tL2luaXQuYwpAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgogI2luY2x1ZGUgPGxpbnV4L2tjb3JlLmg+ CiAjaW5jbHVkZSA8bGludXgvaW5pdHJkLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgog CiAjaW5jbHVkZSA8YXNtL2Jvb3RpbmZvLmg+CiAjaW5jbHVkZSA8YXNtL2NhY2hlY3RsLmg+CkBA IC01NzYsMyArNTc3LDI1IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGludmFsaWRfcG1kX3RhYmxlKTsK ICNlbmRpZgogcHRlX3QgaW52YWxpZF9wdGVfdGFibGVbUFRSU19QRVJfUFRFXSBfX3BhZ2VfYWxp Z25lZF9ic3M7CiBFWFBPUlRfU1lNQk9MKGludmFsaWRfcHRlX3RhYmxlKTsKKworI2lmZGVmIENP TkZJR19FWEVDTUVNCisjaWZkZWYgTU9EVUxFU19WQUREUgorc3RhdGljIHN0cnVjdCBleGVjbWVt X2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5m byBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCWV4ZWNtZW1faW5mbyA9IChz dHJ1Y3QgZXhlY21lbV9pbmZvKXsKKwkJLnJhbmdlcyA9IHsKKwkJCVtFWEVDTUVNX0RFRkFVTFRd ID0geworCQkJCS5zdGFydAk9IE1PRFVMRVNfVkFERFIsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5E LAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0s CisJCX0sCisJfTsKKworCXJldHVybiAmZXhlY21lbV9pbmZvOworfQorI2VuZGlmCisjZW5kaWYg LyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIva2VybmVsL21vZHVs ZS5jIGIvYXJjaC9uaW9zMi9rZXJuZWwvbW9kdWxlLmMKaW5kZXggMGQxZWU4NjYzMWZjLi5mNDQ4 MzI0MzU3OGQgMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIva2VybmVsL21vZHVsZS5jCisrKyBiL2Fy Y2gvbmlvczIva2VybmVsL21vZHVsZS5jCkBAIC0xMywzMyArMTMsMTMgQEAKICNpbmNsdWRlIDxs aW51eC9tb2R1bGVsb2FkZXIuaD4KICNpbmNsdWRlIDxsaW51eC9lbGYuaD4KICNpbmNsdWRlIDxs aW51eC9tbS5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9z bGFiLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4K ICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9leGVjbWVtLmg+CiAK ICNpbmNsdWRlIDxhc20vY2FjaGVmbHVzaC5oPgogCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5m byBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9f aW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVj dCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7 Ci0JCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0J CQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX0VYRUMsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9 LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0KLQogaW50IGFwcGx5X3Jl bG9jYXRlX2FkZChFbGYzMl9TaGRyICpzZWNoZHJzLCBjb25zdCBjaGFyICpzdHJ0YWIsCiAJCQl1 bnNpZ25lZCBpbnQgc3ltaW5kZXgsIHVuc2lnbmVkIGludCByZWxzZWMsCiAJCQlzdHJ1Y3QgbW9k dWxlICptb2QpCmRpZmYgLS1naXQgYS9hcmNoL25pb3MyL21tL2luaXQuYyBiL2FyY2gvbmlvczIv bW0vaW5pdC5jCmluZGV4IDdiYzgyZWU4ODljOS4uMzQ1OWRmMjhhZmVlIDEwMDY0NAotLS0gYS9h cmNoL25pb3MyL21tL2luaXQuYworKysgYi9hcmNoL25pb3MyL21tL2luaXQuYwpAQCAtMjYsNiAr MjYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21lbWJsb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvc2xh Yi5oPgogI2luY2x1ZGUgPGxpbnV4L2JpbmZtdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9leGVjbWVt Lmg+CiAKICNpbmNsdWRlIDxhc20vc2V0dXAuaD4KICNpbmNsdWRlIDxhc20vcGFnZS5oPgpAQCAt MTQzLDMgKzE0NCwyMyBAQCBzdGF0aWMgY29uc3QgcGdwcm90X3QgcHJvdGVjdGlvbl9tYXBbMTZd ID0gewogCVtWTV9TSEFSRUQgfCBWTV9FWEVDIHwgVk1fV1JJVEUgfCBWTV9SRUFEXQk9IE1LUCgx LCAxLCAxKQogfTsKIERFQ0xBUkVfVk1fR0VUX1BBR0VfUFJPVAorCisjaWZkZWYgQ09ORklHX0VY RUNNRU0KK3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVy X2luaXQ7CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAo dm9pZCkKK3sKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7CisJCS5yYW5n ZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZB RERSLAorCQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKKwkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxf RVhFQywKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0sCisJCX0sCisJfTsKKworCXJldHVybiAm ZXhlY21lbV9pbmZvOworfQorI2VuZGlmIC8qIENPTkZJR19FWEVDTUVNICovCmRpZmYgLS1naXQg YS9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxl LmMKaW5kZXggYmRmYTg1ZTEwYzFiLi40ZTVkOTkxYjJiNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFy aXNjL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMKQEAg LTQxLDcgKzQxLDYgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZWxvYWRlci5oPgogI2luY2x1 ZGUgPGxpbnV4L2VsZi5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxs aW51eC9mcy5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0 cmluZy5oPgpAQCAtNDksNyArNDgsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2J1Zy5oPgogI2luY2x1 ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4 L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFzbS91bndpbmQuaD4KICNpbmNsdWRlIDxhc20vc2Vj dGlvbnMuaD4KQEAgLTE3NCwyNCArMTcyLDYgQEAgc3RhdGljIGlubGluZSBpbnQgcmVhc3NlbWJs ZV8yMihpbnQgYXMyMikKIAkJKChhczIyICYgMHgwMDAzZmYpIDw8IDMpKTsKIH0KIAotc3RhdGlj IHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKLQotc3Ry dWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQotewotCWV4 ZWNtZW1faW5mbyA9IChzdHJ1Y3QgZXhlY21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtF WEVDTUVNX0RFRkFVTFRdID0gewotCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVu ZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTF9SV1gsCi0JCQkJLmFs aWdubWVudCA9IDEsCi0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsK LX0KLQogI2lmbmRlZiBDT05GSUdfNjRCSVQKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBj b3VudF9nb3RzKGNvbnN0IEVsZl9SZWxhICpyZWxhLCB1bnNpZ25lZCBsb25nIG4pCiB7CmRpZmYg LS1naXQgYS9hcmNoL3BhcmlzYy9tbS9pbml0LmMgYi9hcmNoL3BhcmlzYy9tbS9pbml0LmMKaW5k ZXggZjg3NmFmNTZlMTNmLi4zNGQ5MWNiOGIyNTkgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL21t L2luaXQuYworKysgYi9hcmNoL3BhcmlzYy9tbS9pbml0LmMKQEAgLTI0LDYgKzI0LDcgQEAKICNp bmNsdWRlIDxsaW51eC9ub2RlbWFzay5oPgkvKiBmb3Igbm9kZV9vbmxpbmVfbWFwICovCiAjaW5j bHVkZSA8bGludXgvcGFnZW1hcC5oPgkvKiBmb3IgcmVsZWFzZV9wYWdlcyAqLwogI2luY2x1ZGUg PGxpbnV4L2NvbXBhdC5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUg PGFzbS9wZ2FsbG9jLmg+CiAjaW5jbHVkZSA8YXNtL3RsYi5oPgpAQCAtNDgxLDcgKzQ4Miw3IEBA IHZvaWQgZnJlZV9pbml0bWVtKHZvaWQpCiAJLyogZmluYWxseSBkdW1wIGFsbCB0aGUgaW5zdHJ1 Y3Rpb25zIHdoaWNoIHdlcmUgY2FjaGVkLCBzaW5jZSB0aGUKIAkgKiBwYWdlcyBhcmUgbm8tbG9u Z2VyIGV4ZWN1dGFibGUgKi8KIAlmbHVzaF9pY2FjaGVfcmFuZ2UoaW5pdF9iZWdpbiwgaW5pdF9l bmQpOwotCQorCiAJZnJlZV9pbml0bWVtX2RlZmF1bHQoUE9JU09OX0ZSRUVfSU5JVE1FTSk7CiAK IAkvKiBzZXQgdXAgYSBuZXcgbGVkIHN0YXRlIG9uIHN5c3RlbXMgc2hpcHBlZCBMRUQgU3RhdGUg cGFuZWwgKi8KQEAgLTk5MiwzICs5OTMsMjMgQEAgc3RhdGljIGNvbnN0IHBncHJvdF90IHByb3Rl Y3Rpb25fbWFwWzE2XSA9IHsKIAlbVk1fU0hBUkVEIHwgVk1fRVhFQyB8IFZNX1dSSVRFIHwgVk1f UkVBRF0JPSBQQUdFX1JXWAogfTsKIERFQ0xBUkVfVk1fR0VUX1BBR0VfUFJPVAorCisjaWZkZWYg Q09ORklHX0VYRUNNRU0KK3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBf X3JvX2FmdGVyX2luaXQ7CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2Fy Y2hfc2V0dXAodm9pZCkKK3sKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7 CisJCS5yYW5nZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJPSBW TUFMTE9DX1NUQVJULAorCQkJCS5lbmQJPSBWTUFMTE9DX0VORCwKKwkJCQkucGdwcm90CT0gUEFH RV9LRVJORUxfUldYLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJ cmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlm ZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3Bvd2VycGMva2Vy bmVsL21vZHVsZS5jCmluZGV4IDJhMjNjZjdlMTQxYi4uNzdlYTgyZTlkYzVmIDEwMDY0NAotLS0g YS9hcmNoL3Bvd2VycGMva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwv bW9kdWxlLmMKQEAgLTcsMTAgKzcsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZWxvYWRlci5oPgogI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgotI2luY2x1 ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxp bnV4L2J1Zy5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KICNpbmNsdWRlIDxhc20vbW9k dWxlLmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGFzbS9maXJtd2Fy ZS5oPgpAQCAtODksNjQgKzg3LDMgQEAgaW50IG1vZHVsZV9maW5hbGl6ZShjb25zdCBFbGZfRWhk ciAqaGRyLAogCiAJcmV0dXJuIDA7CiB9Ci0KLXN0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4 ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2luZm8gX19pbml0 ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQlwZ3Byb3RfdCBrcHJvYmVzX3Byb3QgPSBz dHJpY3RfbW9kdWxlX3J3eF9lbmFibGVkKCkgPyBQQUdFX0tFUk5FTF9ST1ggOiBQQUdFX0tFUk5F TF9FWEVDOwotCXBncHJvdF90IHByb3QgPSBzdHJpY3RfbW9kdWxlX3J3eF9lbmFibGVkKCkgPyBQ QUdFX0tFUk5FTCA6IFBBR0VfS0VSTkVMX0VYRUM7Ci0JdW5zaWduZWQgbG9uZyBmYWxsYmFja19z dGFydCA9IDAsIGZhbGxiYWNrX2VuZCA9IDA7Ci0JdW5zaWduZWQgbG9uZyBzdGFydCwgZW5kOwot Ci0JLyoKLQkgKiBCT09LM1NfMzIgYW5kIDh4eCBkZWZpbmUgTU9EVUxFU19WQUREUiBmb3IgdGV4 dCBhbGxvY2F0aW9ucyBhbmQKLQkgKiBhbGxvdyBhbGxvY2F0aW5nIGRhdGEgaW4gdGhlIGVudGly ZSB2bWFsbG9jIHNwYWNlCi0JICovCi0jaWZkZWYgTU9EVUxFU19WQUREUgotCXVuc2lnbmVkIGxv bmcgbGltaXQgPSAodW5zaWduZWQgbG9uZylfZXRleHQgLSBTWl8zMk07Ci0KLQlCVUlMRF9CVUdf T04oVEFTS19TSVpFID4gTU9EVUxFU19WQUREUik7Ci0KLQkvKiBGaXJzdCB0cnkgd2l0aGluIDMy TSBsaW1pdCBmcm9tIF9ldGV4dCB0byBhdm9pZCBicmFuY2ggdHJhbXBvbGluZXMgKi8KLQlpZiAo TU9EVUxFU19WQUREUiA8IFBBR0VfT0ZGU0VUICYmIE1PRFVMRVNfRU5EID4gbGltaXQpIHsKLQkJ c3RhcnQgPSBsaW1pdDsKLQkJZmFsbGJhY2tfc3RhcnQgPSBNT0RVTEVTX1ZBRERSOwotCQlmYWxs YmFja19lbmQgPSBNT0RVTEVTX0VORDsKLQl9IGVsc2UgewotCQlzdGFydCA9IE1PRFVMRVNfVkFE RFI7Ci0JfQotCi0JZW5kID0gTU9EVUxFU19FTkQ7Ci0jZWxzZQotCXN0YXJ0ID0gVk1BTExPQ19T VEFSVDsKLQllbmQgPSBWTUFMTE9DX0VORDsKLSNlbmRpZgotCi0JZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7Ci0JCQkJLnN0YXJ0CT0gc3RhcnQsCi0JCQkJLmVuZAk9IGVuZCwKLQkJCQkucGdwcm90CT0g cHJvdCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFj a19zdGFydCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0gZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJCVtF WEVDTUVNX0tQUk9CRVNdID0gewotCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVu ZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJPSBrcHJvYmVzX3Byb3QsCi0JCQkJLmFsaWdu bWVudCA9IDEsCi0JCQl9LAotCQkJW0VYRUNNRU1fTU9EVUxFX0RBVEFdID0gewotCQkJCS5zdGFy dAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVuZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJ PSBQQUdFX0tFUk5FTCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCX0sCi0JCX0sCi0JfTsKLQot CXJldHVybiAmZXhlY21lbV9pbmZvOwotfQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL21l bS5jIGIvYXJjaC9wb3dlcnBjL21tL21lbS5jCmluZGV4IDNhNDQwMDA0Yjk3ZC4uNWRlNjJhM2Mx ZDRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbW0vbWVtLmMKKysrIGIvYXJjaC9wb3dlcnBj L21tL21lbS5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgog I2luY2x1ZGUgPGxpbnV4L3N1c3BlbmQuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtZGlyZWN0Lmg+ CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVkZSA8YXNtL3N3aW90bGIuaD4K ICNpbmNsdWRlIDxhc20vbWFjaGRlcC5oPgpAQCAtNDA2LDMgKzQwNyw2NiBAQCBpbnQgZGV2bWVt X2lzX2FsbG93ZWQodW5zaWduZWQgbG9uZyBwZm4pCiAgKiB0aGUgRUhFQSBkcml2ZXIuIERyb3Ag dGhpcyB3aGVuIGRyaXZlcnMvbmV0L2V0aGVybmV0L2libS9laGVhIGlzIHJlbW92ZWQuCiAgKi8K IEVYUE9SVF9TWU1CT0xfR1BMKHdhbGtfc3lzdGVtX3JhbV9yYW5nZSk7CisKKyNpZmRlZiBDT05G SUdfRVhFQ01FTQorc3RhdGljIHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9f YWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9z ZXR1cCh2b2lkKQoreworCXBncHJvdF90IGtwcm9iZXNfcHJvdCA9IHN0cmljdF9tb2R1bGVfcnd4 X2VuYWJsZWQoKSA/IFBBR0VfS0VSTkVMX1JPWCA6IFBBR0VfS0VSTkVMX0VYRUM7CisJcGdwcm90 X3QgcHJvdCA9IHN0cmljdF9tb2R1bGVfcnd4X2VuYWJsZWQoKSA/IFBBR0VfS0VSTkVMIDogUEFH RV9LRVJORUxfRVhFQzsKKwl1bnNpZ25lZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJh Y2tfZW5kID0gMDsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBlbmQ7CisKKwkvKgorCSAqIEJPT0sz U18zMiBhbmQgOHh4IGRlZmluZSBNT0RVTEVTX1ZBRERSIGZvciB0ZXh0IGFsbG9jYXRpb25zIGFu ZAorCSAqIGFsbG93IGFsbG9jYXRpbmcgZGF0YSBpbiB0aGUgZW50aXJlIHZtYWxsb2Mgc3BhY2UK KwkgKi8KKyNpZmRlZiBNT0RVTEVTX1ZBRERSCisJdW5zaWduZWQgbG9uZyBsaW1pdCA9ICh1bnNp Z25lZCBsb25nKV9ldGV4dCAtIFNaXzMyTTsKKworCUJVSUxEX0JVR19PTihUQVNLX1NJWkUgPiBN T0RVTEVTX1ZBRERSKTsKKworCS8qIEZpcnN0IHRyeSB3aXRoaW4gMzJNIGxpbWl0IGZyb20gX2V0 ZXh0IHRvIGF2b2lkIGJyYW5jaCB0cmFtcG9saW5lcyAqLworCWlmIChNT0RVTEVTX1ZBRERSIDwg UEFHRV9PRkZTRVQgJiYgTU9EVUxFU19FTkQgPiBsaW1pdCkgeworCQlzdGFydCA9IGxpbWl0Owor CQlmYWxsYmFja19zdGFydCA9IE1PRFVMRVNfVkFERFI7CisJCWZhbGxiYWNrX2VuZCA9IE1PRFVM RVNfRU5EOworCX0gZWxzZSB7CisJCXN0YXJ0ID0gTU9EVUxFU19WQUREUjsKKwl9CisKKwllbmQg PSBNT0RVTEVTX0VORDsKKyNlbHNlCisJc3RhcnQgPSBWTUFMTE9DX1NUQVJUOworCWVuZCA9IFZN QUxMT0NfRU5EOworI2VuZGlmCisKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5m byl7CisJCS5yYW5nZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJ PSBzdGFydCwKKwkJCQkuZW5kCT0gZW5kLAorCQkJCS5wZ3Byb3QJPSBwcm90LAorCQkJCS5hbGln bm1lbnQgPSAxLAorCQkJCS5mYWxsYmFja19zdGFydAk9IGZhbGxiYWNrX3N0YXJ0LAorCQkJCS5m YWxsYmFja19lbmQJPSBmYWxsYmFja19lbmQsCisJCQl9LAorCQkJW0VYRUNNRU1fS1BST0JFU10g PSB7CisJCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFSVCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQs CisJCQkJLnBncHJvdAk9IGtwcm9iZXNfcHJvdCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0s CisJCQlbRVhFQ01FTV9NT0RVTEVfREFUQV0gPSB7CisJCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFS VCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAor CQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVt X2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gv cmlzY3Yva2VybmVsL21vZHVsZS5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvbW9kdWxlLmMKaW5kZXgg MGU2NDE1ZjAwZmNhLi45MDZmOWEzYTVkNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVs L21vZHVsZS5jCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL21vZHVsZS5jCkBAIC0xMSwxMCArMTEs OCBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2xvZzIuaD4K ICNpbmNsdWRlIDxsaW51eC9tb2R1bGVsb2FkZXIuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9j Lmg+CiAjaW5jbHVkZSA8bGludXgvc2l6ZXMuaD4KICNpbmNsdWRlIDxsaW51eC9wZ3RhYmxlLmg+ Ci0jaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogI2luY2x1ZGUgPGFzbS9hbHRlcm5hdGl2ZS5o PgogI2luY2x1ZGUgPGFzbS9zZWN0aW9ucy5oPgogCkBAIC05MDYsMzggKzkwNCw2IEBAIGludCBh cHBseV9yZWxvY2F0ZV9hZGQoRWxmX1NoZHIgKnNlY2hkcnMsIGNvbnN0IGNoYXIgKnN0cnRhYiwK IAlyZXR1cm4gMDsKIH0KIAotI2lmZGVmIENPTkZJR19NTVUKLXN0YXRpYyBzdHJ1Y3QgZXhlY21l bV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2lu Zm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQlleGVjbWVtX2luZm8gPSAo c3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7Ci0JCQlbRVhFQ01FTV9ERUZBVUxU XSA9IHsKLQkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZBRERSLAotCQkJCS5lbmQJPSBNT0RVTEVTX0VO RCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9 LAotCQkJW0VYRUNNRU1fS1BST0JFU10gPSB7Ci0JCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFSVCwK LQkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX1JFQURf RVhFQywKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCX0sCi0JCQlbRVhFQ01FTV9CUEZdID0gewot CQkJCS5zdGFydAk9IEJQRl9KSVRfUkVHSU9OX1NUQVJULAotCQkJCS5lbmQJPSBCUEZfSklUX1JF R0lPTl9FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSBQ QUdFX1NJWkUsCi0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0K LSNlbmRpZgotCiBpbnQgbW9kdWxlX2ZpbmFsaXplKGNvbnN0IEVsZl9FaGRyICpoZHIsCiAJCSAg ICBjb25zdCBFbGZfU2hkciAqc2VjaGRycywKIAkJICAgIHN0cnVjdCBtb2R1bGUgKm1lKQpkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9tbS9pbml0LmMgYi9hcmNoL3Jpc2N2L21tL2luaXQuYwppbmRl eCBmZThlMTU5Mzk0ZDguLmE4MjkwNjA5NTU0ZiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9tbS9p bml0LmMKKysrIGIvYXJjaC9yaXNjdi9tbS9pbml0LmMKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNs dWRlIDxsaW51eC9lbGYuaD4KICNlbmRpZgogI2luY2x1ZGUgPGxpbnV4L2tmZW5jZS5oPgorI2lu Y2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFzbS9maXhtYXAuaD4KICNpbmNs dWRlIDxhc20vaW8uaD4KQEAgLTE0ODEsMyArMTQ4MiwzNyBAQCB2b2lkIF9faW5pdCBwZ3RhYmxl X2NhY2hlX2luaXQodm9pZCkKIAkJcHJlYWxsb2NhdGVfcGdkX3BhZ2VzX3JhbmdlKE1PRFVMRVNf VkFERFIsIE1PRFVMRVNfRU5ELCAiYnBmL21vZHVsZXMiKTsKIH0KICNlbmRpZgorCisjaWZkZWYg Q09ORklHX0VYRUNNRU0KKyNpZmRlZiBDT05GSUdfTU1VCitzdGF0aWMgc3RydWN0IGV4ZWNtZW1f aW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OworCitzdHJ1Y3QgZXhlY21lbV9pbmZv IF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCit7CisJZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKKwkJCQkuZW5kCT0gTU9EVUxFU19FTkQs CisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwK KwkJCVtFWEVDTUVNX0tQUk9CRVNdID0geworCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCisJ CQkJLmVuZAk9IFZNQUxMT0NfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTF9SRUFEX0VY RUMsCisJCQkJLmFsaWdubWVudCA9IDEsCisJCQl9LAorCQkJW0VYRUNNRU1fQlBGXSA9IHsKKwkJ CQkuc3RhcnQJPSBCUEZfSklUX1JFR0lPTl9TVEFSVCwKKwkJCQkuZW5kCT0gQlBGX0pJVF9SRUdJ T05fRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gUEFH RV9TSVpFLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9Cisj ZW5kaWYgLyogQ09ORklHX01NVSAqLworI2VuZGlmIC8qIENPTkZJR19FWEVDTUVNICovCmRpZmYg LS1naXQgYS9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jIGIvYXJjaC9zMzkwL2tlcm5lbC9tb2R1 bGUuYwppbmRleCA3ZmVlNjRmZGMxYmIuLjkxZTIwN2I1MDM5NCAxMDA2NDQKLS0tIGEvYXJjaC9z MzkwL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jCkBAIC0z NywzMyArMzcsNiBAQAogCiAjZGVmaW5lIFBMVF9FTlRSWV9TSVpFIDIyCiAKLXN0YXRpYyBzdHJ1 Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBl eGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQl1bnNpZ25l ZCBsb25nIG1vZHVsZV9sb2FkX29mZnNldCA9IDA7Ci0JdW5zaWduZWQgbG9uZyBzdGFydDsKLQot CWlmIChrYXNscl9lbmFibGVkKCkpCi0JCW1vZHVsZV9sb2FkX29mZnNldCA9IGdldF9yYW5kb21f dTMyX2luY2x1c2l2ZSgxLCAxMDI0KSAqIFBBR0VfU0laRTsKLQotCXN0YXJ0ID0gTU9EVUxFU19W QUREUiArIG1vZHVsZV9sb2FkX29mZnNldDsKLQotCWV4ZWNtZW1faW5mbyA9IChzdHJ1Y3QgZXhl Y21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtFWEVDTUVNX0RFRkFVTFRdID0gewotCQkJ CS5mbGFncwk9IEVYRUNNRU1fS0FTQU5fU0hBRE9XLAotCQkJCS5zdGFydAk9IHN0YXJ0LAotCQkJ CS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFs aWdubWVudCA9IE1PRFVMRV9BTElHTiwKLQkJCX0sCi0JCX0sCi0JfTsKLQotCXJldHVybiAmZXhl Y21lbV9pbmZvOwotfQotCiAjaWZkZWYgQ09ORklHX0ZVTkNUSU9OX1RSQUNFUgogdm9pZCBtb2R1 bGVfYXJjaF9jbGVhbnVwKHN0cnVjdCBtb2R1bGUgKm1vZCkKIHsKZGlmZiAtLWdpdCBhL2FyY2gv czM5MC9tbS9pbml0LmMgYi9hcmNoL3MzOTAvbW0vaW5pdC5jCmluZGV4IGY2MzkxNDQyYzBjMi4u ZTc2OWQyNzI2ZjRlIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvbW0vaW5pdC5jCisrKyBiL2FyY2gv czM5MC9tbS9pbml0LmMKQEAgLTQ5LDYgKzQ5LDcgQEAKICNpbmNsdWRlIDxhc20vdXYuaD4KICNp bmNsdWRlIDxsaW51eC92aXJ0aW9fYW5jaG9yLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2Nv bmZpZy5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogcGdkX3Qgc3dhcHBlcl9wZ19k aXJbUFRSU19QRVJfUEdEXSBfX3NlY3Rpb24oIi5ic3MuLnN3YXBwZXJfcGdfZGlyIik7CiBwZ2Rf dCBpbnZhbGlkX3BnX2RpcltQVFJTX1BFUl9QR0RdIF9fc2VjdGlvbigiLmJzcy4uaW52YWxpZF9w Z19kaXIiKTsKQEAgLTMwMiwzICszMDMsMzIgQEAgdm9pZCBhcmNoX3JlbW92ZV9tZW1vcnkodTY0 IHN0YXJ0LCB1NjQgc2l6ZSwgc3RydWN0IHZtZW1fYWx0bWFwICphbHRtYXApCiAJdm1lbV9yZW1v dmVfbWFwcGluZyhzdGFydCwgc2l6ZSk7CiB9CiAjZW5kaWYgLyogQ09ORklHX01FTU9SWV9IT1RQ TFVHICovCisKKyNpZmRlZiBDT05GSUdfRVhFQ01FTQorc3RhdGljIHN0cnVjdCBleGVjbWVtX2lu Zm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBf X2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCXVuc2lnbmVkIGxvbmcgbW9kdWxl X2xvYWRfb2Zmc2V0ID0gMDsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0OworCisJaWYgKGthc2xyX2Vu YWJsZWQoKSkKKwkJbW9kdWxlX2xvYWRfb2Zmc2V0ID0gZ2V0X3JhbmRvbV91MzJfaW5jbHVzaXZl KDEsIDEwMjQpICogUEFHRV9TSVpFOworCisJc3RhcnQgPSBNT0RVTEVTX1ZBRERSICsgbW9kdWxl X2xvYWRfb2Zmc2V0OworCisJZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8pewor CQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7CisJCQkJLmZsYWdzCT0gRVhF Q01FTV9LQVNBTl9TSEFET1csCisJCQkJLnN0YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IE1PRFVM RVNfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gTU9E VUxFX0FMSUdOLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9 CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMva2Vy bmVsL21vZHVsZS5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvbW9kdWxlLmMKaW5kZXggOGI3ZWU0NWRl ZmMzLi5iOGM1MWNjMjNkOTYgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL21vZHVsZS5j CisrKyBiL2FyY2gvc3BhcmMva2VybmVsL21vZHVsZS5jCkBAIC0xNCw3ICsxNCw2IEBACiAjaW5j bHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4KICNpbmNsdWRl IDxsaW51eC9tbS5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFz bS9wcm9jZXNzb3IuaD4KICNpbmNsdWRlIDxhc20vc3BpdGZpcmUuaD4KQEAgLTIyLDI0ICsyMSw2 IEBACiAKICNpbmNsdWRlICJlbnRyeS5oIgogCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBl eGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5p dCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVjdCBl eGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7Ci0J CQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0JCQkJ LnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAotCQkJfSwKLQkJfSwK LQl9OwotCi0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0KIC8qIE1ha2UgZ2VuZXJpYyBjb2Rl IGlnbm9yZSBTVFRfUkVHSVNURVIgZHVtbXkgdW5kZWZpbmVkIHN5bWJvbHMuICAqLwogaW50IG1v ZHVsZV9mcm9iX2FyY2hfc2VjdGlvbnMoRWxmX0VoZHIgKmhkciwKIAkJCSAgICAgIEVsZl9TaGRy ICpzZWNoZHJzLApkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9tbS9NYWtlZmlsZSBiL2FyY2gvc3Bh cmMvbW0vTWFrZWZpbGUKaW5kZXggODA5ZDk5M2Y2ZDg4Li4yZDE3NTIxMDhkNzcgMTAwNjQ0Ci0t LSBhL2FyY2gvc3BhcmMvbW0vTWFrZWZpbGUKKysrIGIvYXJjaC9zcGFyYy9tbS9NYWtlZmlsZQpA QCAtMTQsMyArMTQsNSBAQCBvYmotJChDT05GSUdfU1BBUkMzMikgICArPSBsZW9uX21tLm8KIAog IyBPbmx5IHVzZWQgYnkgc3BhcmM2NAogb2JqLSQoQ09ORklHX0hVR0VUTEJfUEFHRSkgKz0gaHVn ZXRsYnBhZ2UubworCitvYmotJChDT05GSUdfRVhFQ01FTSkJKz0gZXhlY21lbS5vCmRpZmYgLS1n aXQgYS9hcmNoL3NwYXJjL21tL2V4ZWNtZW0uYyBiL2FyY2gvc3BhcmMvbW0vZXhlY21lbS5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGZhYzk3ZGQ1NzI4Ci0tLSAv ZGV2L251bGwKKysrIGIvYXJjaC9zcGFyYy9tbS9leGVjbWVtLmMKQEAgLTAsMCArMSwyMSBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKyNpbmNsdWRlIDxsaW51eC9tbS5o PgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KKworc3RhdGljIHN0cnVjdCBleGVjbWVtX2lu Zm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBf X2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCWV4ZWNtZW1faW5mbyA9IChzdHJ1 Y3QgZXhlY21lbV9pbmZvKXsKKwkJLnJhbmdlcyA9IHsKKwkJCVtFWEVDTUVNX0RFRkFVTFRdID0g eworCQkJCS5zdGFydAk9IE1PRFVMRVNfVkFERFIsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5ELAor CQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0sCisJ CX0sCisJfTsKKworCXJldHVybiAmZXhlY21lbV9pbmZvOworfQpkaWZmIC0tZ2l0IGEvYXJjaC94 ODYva2VybmVsL21vZHVsZS5jIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCmluZGV4IDQ1YjFh N2MwMzM3OS4uODM3NDUwYjZlODgyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvbW9kdWxl LmMKKysrIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCkBAIC0xOSw3ICsxOSw2IEBACiAjaW5j bHVkZSA8bGludXgvanVtcF9sYWJlbC5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgogI2lu Y2x1ZGUgPGxpbnV4L21lbW9yeS5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2lu Y2x1ZGUgPGFzbS90ZXh0LXBhdGNoaW5nLmg+CiAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KQEAgLTM3 LDMyICszNiw2IEBAIGRvIHsJCQkJCQkJXAogfSB3aGlsZSAoMCkKICNlbmRpZgogCi1zdGF0aWMg c3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1 Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JdW5z aWduZWQgbG9uZyBzdGFydCwgb2Zmc2V0ID0gMDsKLQotCWlmIChrYXNscl9lbmFibGVkKCkpCi0J CW9mZnNldCA9IGdldF9yYW5kb21fdTMyX2luY2x1c2l2ZSgxLCAxMDI0KSAqIFBBR0VfU0laRTsK LQotCXN0YXJ0ID0gTU9EVUxFU19WQUREUiArIG9mZnNldDsKLQotCWV4ZWNtZW1faW5mbyA9IChz dHJ1Y3QgZXhlY21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtFWEVDTUVNX0RFRkFVTFRd ID0gewotCQkJCS5mbGFncwk9IEVYRUNNRU1fS0FTQU5fU0hBRE9XLAotCQkJCS5zdGFydAk9IHN0 YXJ0LAotCQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUws Ci0JCQkJLmFsaWdubWVudCA9IE1PRFVMRV9BTElHTiwKLQkJCX0sCi0JCX0sCi0JfTsKLQotCXJl dHVybiAmZXhlY21lbV9pbmZvOwotfQotCiAjaWZkZWYgQ09ORklHX1g4Nl8zMgogaW50IGFwcGx5 X3JlbG9jYXRlKEVsZjMyX1NoZHIgKnNlY2hkcnMsCiAJCSAgIGNvbnN0IGNoYXIgKnN0cnRhYiwK ZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2luaXQuYyBiL2FyY2gveDg2L21tL2luaXQuYwppbmRl eCA2Nzk4OTNlYTVlNjguLmJlNGZlZTE3YjcxNyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vaW5p dC5jCisrKyBiL2FyY2gveDg2L21tL2luaXQuYwpAQCAtNyw2ICs3LDcgQEAKICNpbmNsdWRlIDxs aW51eC9zd2Fwb3BzLmg+CiAjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KICNpbmNsdWRlIDxs aW51eC9zY2hlZC90YXNrLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVk ZSA8YXNtL3NldF9tZW1vcnkuaD4KICNpbmNsdWRlIDxhc20vY3B1X2RldmljZV9pZC5oPgpAQCAt MTA5OSwzICsxMTAwLDMxIEBAIHVuc2lnbmVkIGxvbmcgYXJjaF9tYXhfc3dhcGZpbGVfc2l6ZSh2 b2lkKQogCXJldHVybiBwYWdlczsKIH0KICNlbmRpZgorCisjaWZkZWYgQ09ORklHX0VYRUNNRU0K K3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7 CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkK K3sKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBvZmZzZXQgPSAwOworCisJaWYgKGthc2xyX2VuYWJs ZWQoKSkKKwkJb2Zmc2V0ID0gZ2V0X3JhbmRvbV91MzJfaW5jbHVzaXZlKDEsIDEwMjQpICogUEFH RV9TSVpFOworCisJc3RhcnQgPSBNT0RVTEVTX1ZBRERSICsgb2Zmc2V0OworCisJZXhlY21lbV9p bmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1f REVGQVVMVF0gPSB7CisJCQkJLmZsYWdzCT0gRVhFQ01FTV9LQVNBTl9TSEFET1csCisJCQkJLnN0 YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdF X0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gTU9EVUxFX0FMSUdOLAorCQkJfSwKKwkJfSwKKwl9 OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0g Ki8KLS0gCjIuNDMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgt cmlzY3YK 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 lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (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 47EF8C4345F for ; Sun, 5 May 2024 16:16:03 +0000 (UTC) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=HUOjkTY0; dkim-atps=neutral Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4VXV5Y6gh5z3g84 for ; Mon, 6 May 2024 02:16:01 +1000 (AEST) Authentication-Results: lists.ozlabs.org; dmarc=pass (p=none dis=none) header.from=kernel.org Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=HUOjkTY0; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=kernel.org (client-ip=145.40.73.55; helo=sin.source.kernel.org; envelope-from=rppt@kernel.org; receiver=lists.ozlabs.org) Received: from sin.source.kernel.org (sin.source.kernel.org [145.40.73.55]) (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 lists.ozlabs.org (Postfix) with ESMTPS id 4VXTxh2jfQz3dBX for ; Mon, 6 May 2024 02:09:12 +1000 (AEST) Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id EB8C9CE0AB2; Sun, 5 May 2024 16:09:10 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED18EC4DDE2; Sun, 5 May 2024 16:08:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1714925350; bh=5OMBgTFrr36VXyNsljkCHRabEmmDGidsMIUvtOQa2/E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HUOjkTY0MY4Avcwze7CfRrRzvZ8uJCMrkjJMVefuOUwtMJ5EdhxU7JNfJcc54972f 3oOhpCvwmoQ9Q1GPkwpinF5evj2fIyiPqFqm2A6rXSrs6J+b5saRST0hEptRzBNchm Auf1aZnNL10BrlRGGKBPvzfY9zUsb8WDijER56YCQ/T3mYlDNtjhQrdcTBiDC4+1sT 39YY7luhKaiRxcdo24wF1OZY2OK73xFTQ7yliDwpr/XtTQ0GXkhPn658Wk2etTrXSA AvAmAW4UhT0vEPNgqOYrKQUZ1Ak+cHmYwEhJlWambSDSLpHUwgD8LRPOLI6LdEFSyk +vzxUot7u+I/w== From: Mike Rapoport To: linux-kernel@vger.kernel.org Subject: [PATCH RESEND v8 12/16] arch: make execmem setup available regardless of CONFIG_MODULES Date: Sun, 5 May 2024 19:06:24 +0300 Message-ID: <20240505160628.2323363-13-rppt@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240505160628.2323363-1-rppt@kernel.org> References: <20240505160628.2323363-1-rppt@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Mark Rutland , x86@kernel.org, Sam Ravnborg , Peter Zijlstra , Catalin Marinas , Russell King , Song Liu , Donald Dutile , sparclinux@vger.kernel.org, linux-riscv@lists.infradead.org, Nadav Amit , linux-arch@vger.kernel.org, linux-s390@vger.kernel.org, Helge Deller , Huacai Chen , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , linux-trace-kernel@vger.kernel.org, Alexandre Ghiti , Will Deacon , Heiko Carstens , Steven Rostedt , loongarch@lists.linux.dev, Thomas Gleixner , bpf@vger.kernel.org, linux-arm-kernel@lists.infradead.org, Liviu Dudau , Thomas Bogendoerfer , linux-parisc@vger.kernel.org, =?UTF-8?q?Philippe=20Mathieu-D aud=C3=A9?= , linux-mm@kvack.org, netdev@vger.kernel.org, Kent Overstreet , linux-mips@vger.kernel.org, Dinh Nguyen , Luis Chamberlain , Eric Chanudet , Palmer Dabbelt , Masami Hiramatsu , linux-modules@vger.kernel.org, Andrew Morton , Rick Edgecombe , linuxppc-dev@lists.ozlabs.org, "David S. Miller" , Mike Rapoport Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" From: "Mike Rapoport (IBM)" execmem does not depend on modules, on the contrary modules use execmem. To make execmem available when CONFIG_MODULES=n, for instance for kprobes, split execmem_params initialization out from arch/*/kernel/module.c and compile it when CONFIG_EXECMEM=y Signed-off-by: Mike Rapoport (IBM) Reviewed-by: Philippe Mathieu-Daudé --- arch/arm/kernel/module.c | 43 ---------- arch/arm/mm/init.c | 45 +++++++++++ arch/arm64/kernel/module.c | 140 --------------------------------- arch/arm64/mm/init.c | 140 +++++++++++++++++++++++++++++++++ arch/loongarch/kernel/module.c | 19 ----- arch/loongarch/mm/init.c | 21 +++++ arch/mips/kernel/module.c | 22 ------ arch/mips/mm/init.c | 23 ++++++ arch/nios2/kernel/module.c | 20 ----- arch/nios2/mm/init.c | 21 +++++ arch/parisc/kernel/module.c | 20 ----- arch/parisc/mm/init.c | 23 +++++- arch/powerpc/kernel/module.c | 63 --------------- arch/powerpc/mm/mem.c | 64 +++++++++++++++ arch/riscv/kernel/module.c | 34 -------- arch/riscv/mm/init.c | 35 +++++++++ arch/s390/kernel/module.c | 27 ------- arch/s390/mm/init.c | 30 +++++++ arch/sparc/kernel/module.c | 19 ----- arch/sparc/mm/Makefile | 2 + arch/sparc/mm/execmem.c | 21 +++++ arch/x86/kernel/module.c | 27 ------- arch/x86/mm/init.c | 29 +++++++ 23 files changed, 453 insertions(+), 435 deletions(-) create mode 100644 arch/sparc/mm/execmem.c diff --git a/arch/arm/kernel/module.c b/arch/arm/kernel/module.c index a98fdf6ff26c..677f218f7e84 100644 --- a/arch/arm/kernel/module.c +++ b/arch/arm/kernel/module.c @@ -12,57 +12,14 @@ #include #include #include -#include #include #include -#include -#include #include #include #include #include -#ifdef CONFIG_XIP_KERNEL -/* - * The XIP kernel text is mapped in the module area for modules and - * some other stuff to work without any indirect relocations. - * MODULES_VADDR is redefined here and not in asm/memory.h to avoid - * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off. - */ -#undef MODULES_VADDR -#define MODULES_VADDR (((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK) -#endif - -#ifdef CONFIG_MMU -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long fallback_start = 0, fallback_end = 0; - - if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS)) { - fallback_start = VMALLOC_START; - fallback_end = VMALLOC_END; - } - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL_EXEC, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - }, - }; - - return &execmem_info; -} -#endif - bool module_init_section(const char *name) { return strstarts(name, ".init") || diff --git a/arch/arm/mm/init.c b/arch/arm/mm/init.c index e8c6f4be0ce1..5345d218899a 100644 --- a/arch/arm/mm/init.c +++ b/arch/arm/mm/init.c @@ -22,6 +22,7 @@ #include #include #include +#include #include #include @@ -486,3 +487,47 @@ void free_initrd_mem(unsigned long start, unsigned long end) free_reserved_area((void *)start, (void *)end, -1, "initrd"); } #endif + +#ifdef CONFIG_EXECMEM + +#ifdef CONFIG_XIP_KERNEL +/* + * The XIP kernel text is mapped in the module area for modules and + * some other stuff to work without any indirect relocations. + * MODULES_VADDR is redefined here and not in asm/memory.h to avoid + * recompiling the whole kernel when CONFIG_XIP_KERNEL is turned on/off. + */ +#undef MODULES_VADDR +#define MODULES_VADDR (((unsigned long)_exiprom + ~PMD_MASK) & PMD_MASK) +#endif + +#ifdef CONFIG_MMU +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long fallback_start = 0, fallback_end = 0; + + if (IS_ENABLED(CONFIG_ARM_MODULE_PLTS)) { + fallback_start = VMALLOC_START; + fallback_end = VMALLOC_END; + } + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL_EXEC, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_MMU */ + +#endif /* CONFIG_EXECMEM */ diff --git a/arch/arm64/kernel/module.c b/arch/arm64/kernel/module.c index a52240ea084b..36b25af56324 100644 --- a/arch/arm64/kernel/module.c +++ b/arch/arm64/kernel/module.c @@ -12,158 +12,18 @@ #include #include #include -#include #include #include #include #include #include #include -#include -#include #include #include #include #include -static u64 module_direct_base __ro_after_init = 0; -static u64 module_plt_base __ro_after_init = 0; - -/* - * Choose a random page-aligned base address for a window of 'size' bytes which - * entirely contains the interval [start, end - 1]. - */ -static u64 __init random_bounding_box(u64 size, u64 start, u64 end) -{ - u64 max_pgoff, pgoff; - - if ((end - start) >= size) - return 0; - - max_pgoff = (size - (end - start)) / PAGE_SIZE; - pgoff = get_random_u32_inclusive(0, max_pgoff); - - return start - pgoff * PAGE_SIZE; -} - -/* - * Modules may directly reference data and text anywhere within the kernel - * image and other modules. References using PREL32 relocations have a +/-2G - * range, and so we need to ensure that the entire kernel image and all modules - * fall within a 2G window such that these are always within range. - * - * Modules may directly branch to functions and code within the kernel text, - * and to functions and code within other modules. These branches will use - * CALL26/JUMP26 relocations with a +/-128M range. Without PLTs, we must ensure - * that the entire kernel text and all module text falls within a 128M window - * such that these are always within range. With PLTs, we can expand this to a - * 2G window. - * - * We chose the 128M region to surround the entire kernel image (rather than - * just the text) as using the same bounds for the 128M and 2G regions ensures - * by construction that we never select a 128M region that is not a subset of - * the 2G region. For very large and unusual kernel configurations this means - * we may fall back to PLTs where they could have been avoided, but this keeps - * the logic significantly simpler. - */ -static int __init module_init_limits(void) -{ - u64 kernel_end = (u64)_end; - u64 kernel_start = (u64)_text; - u64 kernel_size = kernel_end - kernel_start; - - /* - * The default modules region is placed immediately below the kernel - * image, and is large enough to use the full 2G relocation range. - */ - BUILD_BUG_ON(KIMAGE_VADDR != MODULES_END); - BUILD_BUG_ON(MODULES_VSIZE < SZ_2G); - - if (!kaslr_enabled()) { - if (kernel_size < SZ_128M) - module_direct_base = kernel_end - SZ_128M; - if (kernel_size < SZ_2G) - module_plt_base = kernel_end - SZ_2G; - } else { - u64 min = kernel_start; - u64 max = kernel_end; - - if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) { - pr_info("2G module region forced by RANDOMIZE_MODULE_REGION_FULL\n"); - } else { - module_direct_base = random_bounding_box(SZ_128M, min, max); - if (module_direct_base) { - min = module_direct_base; - max = module_direct_base + SZ_128M; - } - } - - module_plt_base = random_bounding_box(SZ_2G, min, max); - } - - pr_info("%llu pages in range for non-PLT usage", - module_direct_base ? (SZ_128M - kernel_size) / PAGE_SIZE : 0); - pr_info("%llu pages in range for PLT usage", - module_plt_base ? (SZ_2G - kernel_size) / PAGE_SIZE : 0); - - return 0; -} - -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long fallback_start = 0, fallback_end = 0; - unsigned long start = 0, end = 0; - - module_init_limits(); - - /* - * Where possible, prefer to allocate within direct branch range of the - * kernel such that no PLTs are necessary. - */ - if (module_direct_base) { - start = module_direct_base; - end = module_direct_base + SZ_128M; - - if (module_plt_base) { - fallback_start = module_plt_base; - fallback_end = module_plt_base + SZ_2G; - } - } else if (module_plt_base) { - start = module_plt_base; - end = module_plt_base + SZ_2G; - } - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = start, - .end = end, - .pgprot = PAGE_KERNEL, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_ROX, - .alignment = 1, - }, - [EXECMEM_BPF] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - enum aarch64_reloc_op { RELOC_OP_NONE, RELOC_OP_ABS, diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c index 03efd86dce0a..9b5ab6818f7f 100644 --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -32,6 +32,7 @@ #include #include #include +#include #include #include @@ -432,3 +433,142 @@ void dump_mem_limit(void) pr_emerg("Memory Limit: none\n"); } } + +#ifdef CONFIG_EXECMEM +static u64 module_direct_base __ro_after_init = 0; +static u64 module_plt_base __ro_after_init = 0; + +/* + * Choose a random page-aligned base address for a window of 'size' bytes which + * entirely contains the interval [start, end - 1]. + */ +static u64 __init random_bounding_box(u64 size, u64 start, u64 end) +{ + u64 max_pgoff, pgoff; + + if ((end - start) >= size) + return 0; + + max_pgoff = (size - (end - start)) / PAGE_SIZE; + pgoff = get_random_u32_inclusive(0, max_pgoff); + + return start - pgoff * PAGE_SIZE; +} + +/* + * Modules may directly reference data and text anywhere within the kernel + * image and other modules. References using PREL32 relocations have a +/-2G + * range, and so we need to ensure that the entire kernel image and all modules + * fall within a 2G window such that these are always within range. + * + * Modules may directly branch to functions and code within the kernel text, + * and to functions and code within other modules. These branches will use + * CALL26/JUMP26 relocations with a +/-128M range. Without PLTs, we must ensure + * that the entire kernel text and all module text falls within a 128M window + * such that these are always within range. With PLTs, we can expand this to a + * 2G window. + * + * We chose the 128M region to surround the entire kernel image (rather than + * just the text) as using the same bounds for the 128M and 2G regions ensures + * by construction that we never select a 128M region that is not a subset of + * the 2G region. For very large and unusual kernel configurations this means + * we may fall back to PLTs where they could have been avoided, but this keeps + * the logic significantly simpler. + */ +static int __init module_init_limits(void) +{ + u64 kernel_end = (u64)_end; + u64 kernel_start = (u64)_text; + u64 kernel_size = kernel_end - kernel_start; + + /* + * The default modules region is placed immediately below the kernel + * image, and is large enough to use the full 2G relocation range. + */ + BUILD_BUG_ON(KIMAGE_VADDR != MODULES_END); + BUILD_BUG_ON(MODULES_VSIZE < SZ_2G); + + if (!kaslr_enabled()) { + if (kernel_size < SZ_128M) + module_direct_base = kernel_end - SZ_128M; + if (kernel_size < SZ_2G) + module_plt_base = kernel_end - SZ_2G; + } else { + u64 min = kernel_start; + u64 max = kernel_end; + + if (IS_ENABLED(CONFIG_RANDOMIZE_MODULE_REGION_FULL)) { + pr_info("2G module region forced by RANDOMIZE_MODULE_REGION_FULL\n"); + } else { + module_direct_base = random_bounding_box(SZ_128M, min, max); + if (module_direct_base) { + min = module_direct_base; + max = module_direct_base + SZ_128M; + } + } + + module_plt_base = random_bounding_box(SZ_2G, min, max); + } + + pr_info("%llu pages in range for non-PLT usage", + module_direct_base ? (SZ_128M - kernel_size) / PAGE_SIZE : 0); + pr_info("%llu pages in range for PLT usage", + module_plt_base ? (SZ_2G - kernel_size) / PAGE_SIZE : 0); + + return 0; +} + +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long fallback_start = 0, fallback_end = 0; + unsigned long start = 0, end = 0; + + module_init_limits(); + + /* + * Where possible, prefer to allocate within direct branch range of the + * kernel such that no PLTs are necessary. + */ + if (module_direct_base) { + start = module_direct_base; + end = module_direct_base + SZ_128M; + + if (module_plt_base) { + fallback_start = module_plt_base; + fallback_end = module_plt_base + SZ_2G; + } + } else if (module_plt_base) { + start = module_plt_base; + end = module_plt_base + SZ_2G; + } + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = start, + .end = end, + .pgprot = PAGE_KERNEL, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_ROX, + .alignment = 1, + }, + [EXECMEM_BPF] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/loongarch/kernel/module.c b/arch/loongarch/kernel/module.c index ca6dd7ea1610..36d6d9eeb7c7 100644 --- a/arch/loongarch/kernel/module.c +++ b/arch/loongarch/kernel/module.c @@ -18,7 +18,6 @@ #include #include #include -#include #include #include #include @@ -491,24 +490,6 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab, return 0; } -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - static void module_init_ftrace_plt(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *mod) { diff --git a/arch/loongarch/mm/init.c b/arch/loongarch/mm/init.c index 4dd53427f657..bf789d114c2d 100644 --- a/arch/loongarch/mm/init.c +++ b/arch/loongarch/mm/init.c @@ -24,6 +24,7 @@ #include #include #include +#include #include #include @@ -248,3 +249,23 @@ EXPORT_SYMBOL(invalid_pmd_table); #endif pte_t invalid_pte_table[PTRS_PER_PTE] __page_aligned_bss; EXPORT_SYMBOL(invalid_pte_table); + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/mips/kernel/module.c b/arch/mips/kernel/module.c index 59225a3cf918..ba0f62d8eff5 100644 --- a/arch/mips/kernel/module.c +++ b/arch/mips/kernel/module.c @@ -13,14 +13,12 @@ #include #include #include -#include #include #include #include #include #include #include -#include #include struct mips_hi16 { @@ -32,26 +30,6 @@ struct mips_hi16 { static LIST_HEAD(dbe_list); static DEFINE_SPINLOCK(dbe_lock); -#ifdef MODULES_VADDR -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} -#endif - static void apply_r_mips_32(u32 *location, u32 base, Elf_Addr v) { *location = base + v; diff --git a/arch/mips/mm/init.c b/arch/mips/mm/init.c index 39f129205b0c..4583d1a2a73e 100644 --- a/arch/mips/mm/init.c +++ b/arch/mips/mm/init.c @@ -31,6 +31,7 @@ #include #include #include +#include #include #include @@ -576,3 +577,25 @@ EXPORT_SYMBOL_GPL(invalid_pmd_table); #endif pte_t invalid_pte_table[PTRS_PER_PTE] __page_aligned_bss; EXPORT_SYMBOL(invalid_pte_table); + +#ifdef CONFIG_EXECMEM +#ifdef MODULES_VADDR +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif +#endif /* CONFIG_EXECMEM */ diff --git a/arch/nios2/kernel/module.c b/arch/nios2/kernel/module.c index 0d1ee86631fc..f4483243578d 100644 --- a/arch/nios2/kernel/module.c +++ b/arch/nios2/kernel/module.c @@ -13,33 +13,13 @@ #include #include #include -#include #include #include #include #include -#include #include -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL_EXEC, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - int apply_relocate_add(Elf32_Shdr *sechdrs, const char *strtab, unsigned int symindex, unsigned int relsec, struct module *mod) diff --git a/arch/nios2/mm/init.c b/arch/nios2/mm/init.c index 7bc82ee889c9..3459df28afee 100644 --- a/arch/nios2/mm/init.c +++ b/arch/nios2/mm/init.c @@ -26,6 +26,7 @@ #include #include #include +#include #include #include @@ -143,3 +144,23 @@ static const pgprot_t protection_map[16] = { [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = MKP(1, 1, 1) }; DECLARE_VM_GET_PAGE_PROT + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL_EXEC, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/parisc/kernel/module.c b/arch/parisc/kernel/module.c index bdfa85e10c1b..4e5d991b2b65 100644 --- a/arch/parisc/kernel/module.c +++ b/arch/parisc/kernel/module.c @@ -41,7 +41,6 @@ #include #include -#include #include #include #include @@ -49,7 +48,6 @@ #include #include #include -#include #include #include @@ -174,24 +172,6 @@ static inline int reassemble_22(int as22) ((as22 & 0x0003ff) << 3)); } -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_RWX, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - #ifndef CONFIG_64BIT static inline unsigned long count_gots(const Elf_Rela *rela, unsigned long n) { diff --git a/arch/parisc/mm/init.c b/arch/parisc/mm/init.c index f876af56e13f..34d91cb8b259 100644 --- a/arch/parisc/mm/init.c +++ b/arch/parisc/mm/init.c @@ -24,6 +24,7 @@ #include /* for node_online_map */ #include /* for release_pages */ #include +#include #include #include @@ -481,7 +482,7 @@ void free_initmem(void) /* finally dump all the instructions which were cached, since the * pages are no-longer executable */ flush_icache_range(init_begin, init_end); - + free_initmem_default(POISON_FREE_INITMEM); /* set up a new led state on systems shipped LED State panel */ @@ -992,3 +993,23 @@ static const pgprot_t protection_map[16] = { [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = PAGE_RWX }; DECLARE_VM_GET_PAGE_PROT + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_RWX, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/powerpc/kernel/module.c b/arch/powerpc/kernel/module.c index 2a23cf7e141b..77ea82e9dc5f 100644 --- a/arch/powerpc/kernel/module.c +++ b/arch/powerpc/kernel/module.c @@ -7,10 +7,8 @@ #include #include #include -#include #include #include -#include #include #include #include @@ -89,64 +87,3 @@ int module_finalize(const Elf_Ehdr *hdr, return 0; } - -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - pgprot_t kprobes_prot = strict_module_rwx_enabled() ? PAGE_KERNEL_ROX : PAGE_KERNEL_EXEC; - pgprot_t prot = strict_module_rwx_enabled() ? PAGE_KERNEL : PAGE_KERNEL_EXEC; - unsigned long fallback_start = 0, fallback_end = 0; - unsigned long start, end; - - /* - * BOOK3S_32 and 8xx define MODULES_VADDR for text allocations and - * allow allocating data in the entire vmalloc space - */ -#ifdef MODULES_VADDR - unsigned long limit = (unsigned long)_etext - SZ_32M; - - BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR); - - /* First try within 32M limit from _etext to avoid branch trampolines */ - if (MODULES_VADDR < PAGE_OFFSET && MODULES_END > limit) { - start = limit; - fallback_start = MODULES_VADDR; - fallback_end = MODULES_END; - } else { - start = MODULES_VADDR; - } - - end = MODULES_END; -#else - start = VMALLOC_START; - end = VMALLOC_END; -#endif - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = start, - .end = end, - .pgprot = prot, - .alignment = 1, - .fallback_start = fallback_start, - .fallback_end = fallback_end, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = kprobes_prot, - .alignment = 1, - }, - [EXECMEM_MODULE_DATA] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} diff --git a/arch/powerpc/mm/mem.c b/arch/powerpc/mm/mem.c index 3a440004b97d..5de62a3c1d4b 100644 --- a/arch/powerpc/mm/mem.c +++ b/arch/powerpc/mm/mem.c @@ -16,6 +16,7 @@ #include #include #include +#include #include #include @@ -406,3 +407,66 @@ int devmem_is_allowed(unsigned long pfn) * the EHEA driver. Drop this when drivers/net/ethernet/ibm/ehea is removed. */ EXPORT_SYMBOL_GPL(walk_system_ram_range); + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + pgprot_t kprobes_prot = strict_module_rwx_enabled() ? PAGE_KERNEL_ROX : PAGE_KERNEL_EXEC; + pgprot_t prot = strict_module_rwx_enabled() ? PAGE_KERNEL : PAGE_KERNEL_EXEC; + unsigned long fallback_start = 0, fallback_end = 0; + unsigned long start, end; + + /* + * BOOK3S_32 and 8xx define MODULES_VADDR for text allocations and + * allow allocating data in the entire vmalloc space + */ +#ifdef MODULES_VADDR + unsigned long limit = (unsigned long)_etext - SZ_32M; + + BUILD_BUG_ON(TASK_SIZE > MODULES_VADDR); + + /* First try within 32M limit from _etext to avoid branch trampolines */ + if (MODULES_VADDR < PAGE_OFFSET && MODULES_END > limit) { + start = limit; + fallback_start = MODULES_VADDR; + fallback_end = MODULES_END; + } else { + start = MODULES_VADDR; + } + + end = MODULES_END; +#else + start = VMALLOC_START; + end = VMALLOC_END; +#endif + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = start, + .end = end, + .pgprot = prot, + .alignment = 1, + .fallback_start = fallback_start, + .fallback_end = fallback_end, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = kprobes_prot, + .alignment = 1, + }, + [EXECMEM_MODULE_DATA] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/riscv/kernel/module.c b/arch/riscv/kernel/module.c index 0e6415f00fca..906f9a3a5d65 100644 --- a/arch/riscv/kernel/module.c +++ b/arch/riscv/kernel/module.c @@ -11,10 +11,8 @@ #include #include #include -#include #include #include -#include #include #include @@ -906,38 +904,6 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const char *strtab, return 0; } -#ifdef CONFIG_MMU -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - [EXECMEM_KPROBES] = { - .start = VMALLOC_START, - .end = VMALLOC_END, - .pgprot = PAGE_KERNEL_READ_EXEC, - .alignment = 1, - }, - [EXECMEM_BPF] = { - .start = BPF_JIT_REGION_START, - .end = BPF_JIT_REGION_END, - .pgprot = PAGE_KERNEL, - .alignment = PAGE_SIZE, - }, - }, - }; - - return &execmem_info; -} -#endif - int module_finalize(const Elf_Ehdr *hdr, const Elf_Shdr *sechdrs, struct module *me) diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c index fe8e159394d8..a8290609554f 100644 --- a/arch/riscv/mm/init.c +++ b/arch/riscv/mm/init.c @@ -24,6 +24,7 @@ #include #endif #include +#include #include #include @@ -1481,3 +1482,37 @@ void __init pgtable_cache_init(void) preallocate_pgd_pages_range(MODULES_VADDR, MODULES_END, "bpf/modules"); } #endif + +#ifdef CONFIG_EXECMEM +#ifdef CONFIG_MMU +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + [EXECMEM_KPROBES] = { + .start = VMALLOC_START, + .end = VMALLOC_END, + .pgprot = PAGE_KERNEL_READ_EXEC, + .alignment = 1, + }, + [EXECMEM_BPF] = { + .start = BPF_JIT_REGION_START, + .end = BPF_JIT_REGION_END, + .pgprot = PAGE_KERNEL, + .alignment = PAGE_SIZE, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_MMU */ +#endif /* CONFIG_EXECMEM */ diff --git a/arch/s390/kernel/module.c b/arch/s390/kernel/module.c index 7fee64fdc1bb..91e207b50394 100644 --- a/arch/s390/kernel/module.c +++ b/arch/s390/kernel/module.c @@ -37,33 +37,6 @@ #define PLT_ENTRY_SIZE 22 -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long module_load_offset = 0; - unsigned long start; - - if (kaslr_enabled()) - module_load_offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; - - start = MODULES_VADDR + module_load_offset; - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .flags = EXECMEM_KASAN_SHADOW, - .start = start, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = MODULE_ALIGN, - }, - }, - }; - - return &execmem_info; -} - #ifdef CONFIG_FUNCTION_TRACER void module_arch_cleanup(struct module *mod) { diff --git a/arch/s390/mm/init.c b/arch/s390/mm/init.c index f6391442c0c2..e769d2726f4e 100644 --- a/arch/s390/mm/init.c +++ b/arch/s390/mm/init.c @@ -49,6 +49,7 @@ #include #include #include +#include pgd_t swapper_pg_dir[PTRS_PER_PGD] __section(".bss..swapper_pg_dir"); pgd_t invalid_pg_dir[PTRS_PER_PGD] __section(".bss..invalid_pg_dir"); @@ -302,3 +303,32 @@ void arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap) vmem_remove_mapping(start, size); } #endif /* CONFIG_MEMORY_HOTPLUG */ + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long module_load_offset = 0; + unsigned long start; + + if (kaslr_enabled()) + module_load_offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; + + start = MODULES_VADDR + module_load_offset; + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .flags = EXECMEM_KASAN_SHADOW, + .start = start, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = MODULE_ALIGN, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ diff --git a/arch/sparc/kernel/module.c b/arch/sparc/kernel/module.c index 8b7ee45defc3..b8c51cc23d96 100644 --- a/arch/sparc/kernel/module.c +++ b/arch/sparc/kernel/module.c @@ -14,7 +14,6 @@ #include #include #include -#include #include #include @@ -22,24 +21,6 @@ #include "entry.h" -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .start = MODULES_VADDR, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = 1, - }, - }, - }; - - return &execmem_info; -} - /* Make generic code ignore STT_REGISTER dummy undefined symbols. */ int module_frob_arch_sections(Elf_Ehdr *hdr, Elf_Shdr *sechdrs, diff --git a/arch/sparc/mm/Makefile b/arch/sparc/mm/Makefile index 809d993f6d88..2d1752108d77 100644 --- a/arch/sparc/mm/Makefile +++ b/arch/sparc/mm/Makefile @@ -14,3 +14,5 @@ obj-$(CONFIG_SPARC32) += leon_mm.o # Only used by sparc64 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o + +obj-$(CONFIG_EXECMEM) += execmem.o diff --git a/arch/sparc/mm/execmem.c b/arch/sparc/mm/execmem.c new file mode 100644 index 000000000000..0fac97dd5728 --- /dev/null +++ b/arch/sparc/mm/execmem.c @@ -0,0 +1,21 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include + +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .start = MODULES_VADDR, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = 1, + }, + }, + }; + + return &execmem_info; +} diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c index 45b1a7c03379..837450b6e882 100644 --- a/arch/x86/kernel/module.c +++ b/arch/x86/kernel/module.c @@ -19,7 +19,6 @@ #include #include #include -#include #include #include @@ -37,32 +36,6 @@ do { \ } while (0) #endif -static struct execmem_info execmem_info __ro_after_init; - -struct execmem_info __init *execmem_arch_setup(void) -{ - unsigned long start, offset = 0; - - if (kaslr_enabled()) - offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; - - start = MODULES_VADDR + offset; - - execmem_info = (struct execmem_info){ - .ranges = { - [EXECMEM_DEFAULT] = { - .flags = EXECMEM_KASAN_SHADOW, - .start = start, - .end = MODULES_END, - .pgprot = PAGE_KERNEL, - .alignment = MODULE_ALIGN, - }, - }, - }; - - return &execmem_info; -} - #ifdef CONFIG_X86_32 int apply_relocate(Elf32_Shdr *sechdrs, const char *strtab, diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c index 679893ea5e68..be4fee17b717 100644 --- a/arch/x86/mm/init.c +++ b/arch/x86/mm/init.c @@ -7,6 +7,7 @@ #include #include #include +#include #include #include @@ -1099,3 +1100,31 @@ unsigned long arch_max_swapfile_size(void) return pages; } #endif + +#ifdef CONFIG_EXECMEM +static struct execmem_info execmem_info __ro_after_init; + +struct execmem_info __init *execmem_arch_setup(void) +{ + unsigned long start, offset = 0; + + if (kaslr_enabled()) + offset = get_random_u32_inclusive(1, 1024) * PAGE_SIZE; + + start = MODULES_VADDR + offset; + + execmem_info = (struct execmem_info){ + .ranges = { + [EXECMEM_DEFAULT] = { + .flags = EXECMEM_KASAN_SHADOW, + .start = start, + .end = MODULES_END, + .pgprot = PAGE_KERNEL, + .alignment = MODULE_ALIGN, + }, + }, + }; + + return &execmem_info; +} +#endif /* CONFIG_EXECMEM */ -- 2.43.0 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 7C45BC4345F for ; Sun, 5 May 2024 16:09:55 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=YWmuO/3LMhFwhmb27Lnu7y3/AYo/uLRU82AuOOsw6MY=; b=Tu25I0u3+YKCX1 mKt726/KtxPo2FnVKG+wsAF3rFazwZYdXOXr/LanX9BTUjdt0UEoHwZG6L4TyXafXCWt4fWnuyI8b y3pY0Ir6rhdeh0DQQ9GI/GGBqAOCPVnnwJrUwP4c+FH1956dY9Zu72lLwpxWX37du6gjtAt07b/OR dzKhrc8lhdu3uW4eFNLctOg1/W1LPp8//QhstVrRwbmasQpGzyug28q7LFr8xaAWG+NU+0xCci5S+ yGXKDXRa9RQkqauKVEGyzB2vbrY8rD1L1pl3PhPa/YvY9JL+cs49Sb5EwaJpq8HFR8+dRQFnEG0it a+nMx1FWZtsLKGuREbVw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQl-00000004j16-3kCF; Sun, 05 May 2024 16:09:39 +0000 Received: from desiato.infradead.org ([2001:8b0:10b:1:d65d:64ff:fe57:4e05]) by bombadil.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQR-00000004ikY-2nh6; Sun, 05 May 2024 16:09:20 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=Content-Transfer-Encoding:Content-Type :MIME-Version:References:In-Reply-To:Message-ID:Date:Subject:Cc:To:From: Sender:Reply-To:Content-ID:Content-Description; bh=T7xAcO5/CoULMfPQgJR7+ovdKspvbrejEkNN0k7yqQ4=; b=Iwa8ZLQZcgxUnY68l/4KnOgZIH zBZNMkZjt5l08RO6klzx46zYmGZMstd88RpUjb0uI6v+IQwzavDs8HUONEB4EsXCsOjVzFT+AOLK7 EhCL2VNpvjGalrS40O3zmADDUFv4zChcC0QlGDU75ffHbl8M9JzEhBMtHuwRBIAiafT8n+z+hKX6D +T9dctGHNQiB4GCfQaELFhDOeb9eAthoMz9bia7qOZskUsydhXfzPkQULcf/lkgtlanoaooAeX4JE jz/+ibftCTSwQofYMNHKL1eYrjkHLfT0qq60hmRuFaCvO1VBevDF8Jzg/UgnzVrou64pSTNHpgEvx zjk9i5yQ==; Received: from sin.source.kernel.org ([2604:1380:40e1:4800::1]) by desiato.infradead.org with esmtps (Exim 4.97.1 #2 (Red Hat Linux)) id 1s3eQN-00000001OHB-15lE; Sun, 05 May 2024 16:09:18 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by sin.source.kernel.org (Postfix) with ESMTP id EB8C9CE0AB2; Sun, 5 May 2024 16:09:10 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED18EC4DDE2; Sun, 5 May 2024 16:08:58 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1714925350; bh=5OMBgTFrr36VXyNsljkCHRabEmmDGidsMIUvtOQa2/E=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HUOjkTY0MY4Avcwze7CfRrRzvZ8uJCMrkjJMVefuOUwtMJ5EdhxU7JNfJcc54972f 3oOhpCvwmoQ9Q1GPkwpinF5evj2fIyiPqFqm2A6rXSrs6J+b5saRST0hEptRzBNchm Auf1aZnNL10BrlRGGKBPvzfY9zUsb8WDijER56YCQ/T3mYlDNtjhQrdcTBiDC4+1sT 39YY7luhKaiRxcdo24wF1OZY2OK73xFTQ7yliDwpr/XtTQ0GXkhPn658Wk2etTrXSA AvAmAW4UhT0vEPNgqOYrKQUZ1Ak+cHmYwEhJlWambSDSLpHUwgD8LRPOLI6LdEFSyk +vzxUot7u+I/w== From: Mike Rapoport To: linux-kernel@vger.kernel.org Cc: Alexandre Ghiti , Andrew Morton , =?UTF-8?q?Bj=C3=B6rn=20T=C3=B6pel?= , Catalin Marinas , Christophe Leroy , "David S. Miller" , Dinh Nguyen , Donald Dutile , Eric Chanudet , Heiko Carstens , Helge Deller , Huacai Chen , Kent Overstreet , Liviu Dudau , Luis Chamberlain , Mark Rutland , Masami Hiramatsu , Michael Ellerman , Mike Rapoport , Nadav Amit , Palmer Dabbelt , Peter Zijlstra , =?UTF-8?q?Philippe=20Mathieu-Daud=C3=A9?= , Rick Edgecombe , Russell King , Sam Ravnborg , Song Liu , Steven Rostedt , Thomas Bogendoerfer , Thomas Gleixner , Will Deacon , bpf@vger.kernel.org, linux-arch@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linux-mm@kvack.org, linux-modules@vger.kernel.org, linux-parisc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-s390@vger.kernel.org, linux-trace-kernel@vger.kernel.org, linuxppc-dev@lists.ozlabs.org, loongarch@lists.linux.dev, netdev@vger.kernel.org, sparclinux@vger.kernel.org, x86@kernel.org Subject: [PATCH RESEND v8 12/16] arch: make execmem setup available regardless of CONFIG_MODULES Date: Sun, 5 May 2024 19:06:24 +0300 Message-ID: <20240505160628.2323363-13-rppt@kernel.org> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20240505160628.2323363-1-rppt@kernel.org> References: <20240505160628.2323363-1-rppt@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20240505_170916_417538_0FB5EB41 X-CRM114-Status: GOOD ( 30.20 ) 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 RnJvbTogIk1pa2UgUmFwb3BvcnQgKElCTSkiIDxycHB0QGtlcm5lbC5vcmc+CgpleGVjbWVtIGRv ZXMgbm90IGRlcGVuZCBvbiBtb2R1bGVzLCBvbiB0aGUgY29udHJhcnkgbW9kdWxlcyB1c2UKZXhl Y21lbS4KClRvIG1ha2UgZXhlY21lbSBhdmFpbGFibGUgd2hlbiBDT05GSUdfTU9EVUxFUz1uLCBm b3IgaW5zdGFuY2UgZm9yCmtwcm9iZXMsIHNwbGl0IGV4ZWNtZW1fcGFyYW1zIGluaXRpYWxpemF0 aW9uIG91dCBmcm9tCmFyY2gvKi9rZXJuZWwvbW9kdWxlLmMgYW5kIGNvbXBpbGUgaXQgd2hlbiBD T05GSUdfRVhFQ01FTT15CgpTaWduZWQtb2ZmLWJ5OiBNaWtlIFJhcG9wb3J0IChJQk0pIDxycHB0 QGtlcm5lbC5vcmc+ClJldmlld2VkLWJ5OiBQaGlsaXBwZSBNYXRoaWV1LURhdWTDqSA8cGhpbG1k QGxpbmFyby5vcmc+Ci0tLQogYXJjaC9hcm0va2VybmVsL21vZHVsZS5jICAgICAgIHwgIDQzIC0t LS0tLS0tLS0KIGFyY2gvYXJtL21tL2luaXQuYyAgICAgICAgICAgICB8ICA0NSArKysrKysrKysr KwogYXJjaC9hcm02NC9rZXJuZWwvbW9kdWxlLmMgICAgIHwgMTQwIC0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLQogYXJjaC9hcm02NC9tbS9pbml0LmMgICAgICAgICAgIHwgMTQwICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogYXJjaC9sb29uZ2FyY2gva2VybmVsL21v ZHVsZS5jIHwgIDE5IC0tLS0tCiBhcmNoL2xvb25nYXJjaC9tbS9pbml0LmMgICAgICAgfCAgMjEg KysrKysKIGFyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMgICAgICB8ICAyMiAtLS0tLS0KIGFyY2gv bWlwcy9tbS9pbml0LmMgICAgICAgICAgICB8ICAyMyArKysrKysKIGFyY2gvbmlvczIva2VybmVs L21vZHVsZS5jICAgICB8ICAyMCAtLS0tLQogYXJjaC9uaW9zMi9tbS9pbml0LmMgICAgICAgICAg IHwgIDIxICsrKysrCiBhcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMgICAgfCAgMjAgLS0tLS0K IGFyY2gvcGFyaXNjL21tL2luaXQuYyAgICAgICAgICB8ICAyMyArKysrKy0KIGFyY2gvcG93ZXJw Yy9rZXJuZWwvbW9kdWxlLmMgICB8ICA2MyAtLS0tLS0tLS0tLS0tLS0KIGFyY2gvcG93ZXJwYy9t bS9tZW0uYyAgICAgICAgICB8ICA2NCArKysrKysrKysrKysrKysKIGFyY2gvcmlzY3Yva2VybmVs L21vZHVsZS5jICAgICB8ICAzNCAtLS0tLS0tLQogYXJjaC9yaXNjdi9tbS9pbml0LmMgICAgICAg ICAgIHwgIDM1ICsrKysrKysrKwogYXJjaC9zMzkwL2tlcm5lbC9tb2R1bGUuYyAgICAgIHwgIDI3 IC0tLS0tLS0KIGFyY2gvczM5MC9tbS9pbml0LmMgICAgICAgICAgICB8ICAzMCArKysrKysrCiBh cmNoL3NwYXJjL2tlcm5lbC9tb2R1bGUuYyAgICAgfCAgMTkgLS0tLS0KIGFyY2gvc3BhcmMvbW0v TWFrZWZpbGUgICAgICAgICB8ICAgMiArCiBhcmNoL3NwYXJjL21tL2V4ZWNtZW0uYyAgICAgICAg fCAgMjEgKysrKysKIGFyY2gveDg2L2tlcm5lbC9tb2R1bGUuYyAgICAgICB8ICAyNyAtLS0tLS0t CiBhcmNoL3g4Ni9tbS9pbml0LmMgICAgICAgICAgICAgfCAgMjkgKysrKysrKwogMjMgZmlsZXMg Y2hhbmdlZCwgNDUzIGluc2VydGlvbnMoKyksIDQzNSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBtb2Rl IDEwMDY0NCBhcmNoL3NwYXJjL21tL2V4ZWNtZW0uYwoKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2tl cm5lbC9tb2R1bGUuYyBiL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYwppbmRleCBhOThmZGY2ZmYy NmMuLjY3N2YyMThmN2U4NCAxMDA2NDQKLS0tIGEvYXJjaC9hcm0va2VybmVsL21vZHVsZS5jCisr KyBiL2FyY2gvYXJtL2tlcm5lbC9tb2R1bGUuYwpAQCAtMTIsNTcgKzEyLDE0IEBACiAjaW5jbHVk ZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRlIDxsaW51 eC9lbGYuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+CiAjaW5jbHVkZSA8bGludXgvZnMu aD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4KLSNpbmNsdWRlIDxsaW51eC9nZnAuaD4KLSNp bmNsdWRlIDxsaW51eC9leGVjbWVtLmg+CiAKICNpbmNsdWRlIDxhc20vc2VjdGlvbnMuaD4KICNp bmNsdWRlIDxhc20vc21wX3BsYXQuaD4KICNpbmNsdWRlIDxhc20vdW53aW5kLmg+CiAjaW5jbHVk ZSA8YXNtL29wY29kZXMuaD4KIAotI2lmZGVmIENPTkZJR19YSVBfS0VSTkVMCi0vKgotICogVGhl IFhJUCBrZXJuZWwgdGV4dCBpcyBtYXBwZWQgaW4gdGhlIG1vZHVsZSBhcmVhIGZvciBtb2R1bGVz IGFuZAotICogc29tZSBvdGhlciBzdHVmZiB0byB3b3JrIHdpdGhvdXQgYW55IGluZGlyZWN0IHJl bG9jYXRpb25zLgotICogTU9EVUxFU19WQUREUiBpcyByZWRlZmluZWQgaGVyZSBhbmQgbm90IGlu IGFzbS9tZW1vcnkuaCB0byBhdm9pZAotICogcmVjb21waWxpbmcgdGhlIHdob2xlIGtlcm5lbCB3 aGVuIENPTkZJR19YSVBfS0VSTkVMIGlzIHR1cm5lZCBvbi9vZmYuCi0gKi8KLSN1bmRlZiBNT0RV TEVTX1ZBRERSCi0jZGVmaW5lIE1PRFVMRVNfVkFERFIJKCgodW5zaWduZWQgbG9uZylfZXhpcHJv bSArIH5QTURfTUFTSykgJiBQTURfTUFTSykKLSNlbmRpZgotCi0jaWZkZWYgQ09ORklHX01NVQot c3RhdGljIHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsK LQotc3RydWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQot ewotCXVuc2lnbmVkIGxvbmcgZmFsbGJhY2tfc3RhcnQgPSAwLCBmYWxsYmFja19lbmQgPSAwOwot Ci0JaWYgKElTX0VOQUJMRUQoQ09ORklHX0FSTV9NT0RVTEVfUExUUykpIHsKLQkJZmFsbGJhY2tf c3RhcnQgPSBWTUFMTE9DX1NUQVJUOwotCQlmYWxsYmFja19lbmQgPSBWTUFMTE9DX0VORDsKLQl9 Ci0KLQlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7 Ci0JCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKLQkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZBRERSLAot CQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxfRVhFQywK LQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFja19zdGFy dCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0gZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJfSwKLQl9Owot Ci0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0jZW5kaWYKLQogYm9vbCBtb2R1bGVfaW5pdF9z ZWN0aW9uKGNvbnN0IGNoYXIgKm5hbWUpCiB7CiAJcmV0dXJuIHN0cnN0YXJ0cyhuYW1lLCAiLmlu aXQiKSB8fApkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vaW5pdC5jIGIvYXJjaC9hcm0vbW0vaW5p dC5jCmluZGV4IGU4YzZmNGJlMGNlMS4uNTM0NWQyMTg4OTlhIDEwMDY0NAotLS0gYS9hcmNoL2Fy bS9tbS9pbml0LmMKKysrIGIvYXJjaC9hcm0vbW0vaW5pdC5jCkBAIC0yMiw2ICsyMiw3IEBACiAj aW5jbHVkZSA8bGludXgvc2l6ZXMuaD4KICNpbmNsdWRlIDxsaW51eC9zdG9wX21hY2hpbmUuaD4K ICNpbmNsdWRlIDxsaW51eC9zd2lvdGxiLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgog CiAjaW5jbHVkZSA8YXNtL2NwMTUuaD4KICNpbmNsdWRlIDxhc20vbWFjaC10eXBlcy5oPgpAQCAt NDg2LDMgKzQ4Nyw0NyBAQCB2b2lkIGZyZWVfaW5pdHJkX21lbSh1bnNpZ25lZCBsb25nIHN0YXJ0 LCB1bnNpZ25lZCBsb25nIGVuZCkKIAlmcmVlX3Jlc2VydmVkX2FyZWEoKHZvaWQgKilzdGFydCwg KHZvaWQgKillbmQsIC0xLCAiaW5pdHJkIik7CiB9CiAjZW5kaWYKKworI2lmZGVmIENPTkZJR19F WEVDTUVNCisKKyNpZmRlZiBDT05GSUdfWElQX0tFUk5FTAorLyoKKyAqIFRoZSBYSVAga2VybmVs IHRleHQgaXMgbWFwcGVkIGluIHRoZSBtb2R1bGUgYXJlYSBmb3IgbW9kdWxlcyBhbmQKKyAqIHNv bWUgb3RoZXIgc3R1ZmYgdG8gd29yayB3aXRob3V0IGFueSBpbmRpcmVjdCByZWxvY2F0aW9ucy4K KyAqIE1PRFVMRVNfVkFERFIgaXMgcmVkZWZpbmVkIGhlcmUgYW5kIG5vdCBpbiBhc20vbWVtb3J5 LmggdG8gYXZvaWQKKyAqIHJlY29tcGlsaW5nIHRoZSB3aG9sZSBrZXJuZWwgd2hlbiBDT05GSUdf WElQX0tFUk5FTCBpcyB0dXJuZWQgb24vb2ZmLgorICovCisjdW5kZWYgTU9EVUxFU19WQUREUgor I2RlZmluZSBNT0RVTEVTX1ZBRERSCSgoKHVuc2lnbmVkIGxvbmcpX2V4aXByb20gKyB+UE1EX01B U0spICYgUE1EX01BU0spCisjZW5kaWYKKworI2lmZGVmIENPTkZJR19NTVUKK3N0YXRpYyBzdHJ1 Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7CisKK3N0cnVjdCBl eGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKK3sKKwl1bnNpZ25l ZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJhY2tfZW5kID0gMDsKKworCWlmIChJU19F TkFCTEVEKENPTkZJR19BUk1fTU9EVUxFX1BMVFMpKSB7CisJCWZhbGxiYWNrX3N0YXJ0ID0gVk1B TExPQ19TVEFSVDsKKwkJZmFsbGJhY2tfZW5kID0gVk1BTExPQ19FTkQ7CisJfQorCisJZXhlY21l bV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNN RU1fREVGQVVMVF0gPSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKKwkJCQkuZW5kCT0g TU9EVUxFU19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX0VYRUMsCisJCQkJLmFsaWdu bWVudCA9IDEsCisJCQkJLmZhbGxiYWNrX3N0YXJ0CT0gZmFsbGJhY2tfc3RhcnQsCisJCQkJLmZh bGxiYWNrX2VuZAk9IGZhbGxiYWNrX2VuZCwKKwkJCX0sCisJCX0sCisJfTsKKworCXJldHVybiAm ZXhlY21lbV9pbmZvOworfQorI2VuZGlmIC8qIENPTkZJR19NTVUgKi8KKworI2VuZGlmIC8qIENP TkZJR19FWEVDTUVNICovCmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYyBi L2FyY2gvYXJtNjQva2VybmVsL21vZHVsZS5jCmluZGV4IGE1MjI0MGVhMDg0Yi4uMzZiMjVhZjU2 MzI0IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL2Fy bTY0L2tlcm5lbC9tb2R1bGUuYwpAQCAtMTIsMTU4ICsxMiwxOCBAQAogI2luY2x1ZGUgPGxpbnV4 L2JpdG9wcy5oPgogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFj ZS5oPgotI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgogI2luY2x1ZGUgPGxpbnV4L2thc2FuLmg+CiAj aW5jbHVkZSA8bGludXgva2VybmVsLmg+CiAjaW5jbHVkZSA8bGludXgvbW0uaD4KICNpbmNsdWRl IDxsaW51eC9tb2R1bGVsb2FkZXIuaD4KICNpbmNsdWRlIDxsaW51eC9yYW5kb20uaD4KICNpbmNs dWRlIDxsaW51eC9zY3MuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9jLmg+Ci0jaW5jbHVkZSA8 bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVkZSA8YXNtL2FsdGVybmF0aXZlLmg+CiAjaW5jbHVk ZSA8YXNtL2luc24uaD4KICNpbmNsdWRlIDxhc20vc2NzLmg+CiAjaW5jbHVkZSA8YXNtL3NlY3Rp b25zLmg+CiAKLXN0YXRpYyB1NjQgbW9kdWxlX2RpcmVjdF9iYXNlIF9fcm9fYWZ0ZXJfaW5pdCA9 IDA7Ci1zdGF0aWMgdTY0IG1vZHVsZV9wbHRfYmFzZSBfX3JvX2FmdGVyX2luaXQgPSAwOwotCi0v KgotICogQ2hvb3NlIGEgcmFuZG9tIHBhZ2UtYWxpZ25lZCBiYXNlIGFkZHJlc3MgZm9yIGEgd2lu ZG93IG9mICdzaXplJyBieXRlcyB3aGljaAotICogZW50aXJlbHkgY29udGFpbnMgdGhlIGludGVy dmFsIFtzdGFydCwgZW5kIC0gMV0uCi0gKi8KLXN0YXRpYyB1NjQgX19pbml0IHJhbmRvbV9ib3Vu ZGluZ19ib3godTY0IHNpemUsIHU2NCBzdGFydCwgdTY0IGVuZCkKLXsKLQl1NjQgbWF4X3Bnb2Zm LCBwZ29mZjsKLQotCWlmICgoZW5kIC0gc3RhcnQpID49IHNpemUpCi0JCXJldHVybiAwOwotCi0J bWF4X3Bnb2ZmID0gKHNpemUgLSAoZW5kIC0gc3RhcnQpKSAvIFBBR0VfU0laRTsKLQlwZ29mZiA9 IGdldF9yYW5kb21fdTMyX2luY2x1c2l2ZSgwLCBtYXhfcGdvZmYpOwotCi0JcmV0dXJuIHN0YXJ0 IC0gcGdvZmYgKiBQQUdFX1NJWkU7Ci19Ci0KLS8qCi0gKiBNb2R1bGVzIG1heSBkaXJlY3RseSBy ZWZlcmVuY2UgZGF0YSBhbmQgdGV4dCBhbnl3aGVyZSB3aXRoaW4gdGhlIGtlcm5lbAotICogaW1h Z2UgYW5kIG90aGVyIG1vZHVsZXMuIFJlZmVyZW5jZXMgdXNpbmcgUFJFTDMyIHJlbG9jYXRpb25z IGhhdmUgYSArLy0yRwotICogcmFuZ2UsIGFuZCBzbyB3ZSBuZWVkIHRvIGVuc3VyZSB0aGF0IHRo ZSBlbnRpcmUga2VybmVsIGltYWdlIGFuZCBhbGwgbW9kdWxlcwotICogZmFsbCB3aXRoaW4gYSAy RyB3aW5kb3cgc3VjaCB0aGF0IHRoZXNlIGFyZSBhbHdheXMgd2l0aGluIHJhbmdlLgotICoKLSAq IE1vZHVsZXMgbWF5IGRpcmVjdGx5IGJyYW5jaCB0byBmdW5jdGlvbnMgYW5kIGNvZGUgd2l0aGlu IHRoZSBrZXJuZWwgdGV4dCwKLSAqIGFuZCB0byBmdW5jdGlvbnMgYW5kIGNvZGUgd2l0aGluIG90 aGVyIG1vZHVsZXMuIFRoZXNlIGJyYW5jaGVzIHdpbGwgdXNlCi0gKiBDQUxMMjYvSlVNUDI2IHJl bG9jYXRpb25zIHdpdGggYSArLy0xMjhNIHJhbmdlLiBXaXRob3V0IFBMVHMsIHdlIG11c3QgZW5z dXJlCi0gKiB0aGF0IHRoZSBlbnRpcmUga2VybmVsIHRleHQgYW5kIGFsbCBtb2R1bGUgdGV4dCBm YWxscyB3aXRoaW4gYSAxMjhNIHdpbmRvdwotICogc3VjaCB0aGF0IHRoZXNlIGFyZSBhbHdheXMg d2l0aGluIHJhbmdlLiBXaXRoIFBMVHMsIHdlIGNhbiBleHBhbmQgdGhpcyB0byBhCi0gKiAyRyB3 aW5kb3cuCi0gKgotICogV2UgY2hvc2UgdGhlIDEyOE0gcmVnaW9uIHRvIHN1cnJvdW5kIHRoZSBl bnRpcmUga2VybmVsIGltYWdlIChyYXRoZXIgdGhhbgotICoganVzdCB0aGUgdGV4dCkgYXMgdXNp bmcgdGhlIHNhbWUgYm91bmRzIGZvciB0aGUgMTI4TSBhbmQgMkcgcmVnaW9ucyBlbnN1cmVzCi0g KiBieSBjb25zdHJ1Y3Rpb24gdGhhdCB3ZSBuZXZlciBzZWxlY3QgYSAxMjhNIHJlZ2lvbiB0aGF0 IGlzIG5vdCBhIHN1YnNldCBvZgotICogdGhlIDJHIHJlZ2lvbi4gRm9yIHZlcnkgbGFyZ2UgYW5k IHVudXN1YWwga2VybmVsIGNvbmZpZ3VyYXRpb25zIHRoaXMgbWVhbnMKLSAqIHdlIG1heSBmYWxs IGJhY2sgdG8gUExUcyB3aGVyZSB0aGV5IGNvdWxkIGhhdmUgYmVlbiBhdm9pZGVkLCBidXQgdGhp cyBrZWVwcwotICogdGhlIGxvZ2ljIHNpZ25pZmljYW50bHkgc2ltcGxlci4KLSAqLwotc3RhdGlj IGludCBfX2luaXQgbW9kdWxlX2luaXRfbGltaXRzKHZvaWQpCi17Ci0JdTY0IGtlcm5lbF9lbmQg PSAodTY0KV9lbmQ7Ci0JdTY0IGtlcm5lbF9zdGFydCA9ICh1NjQpX3RleHQ7Ci0JdTY0IGtlcm5l bF9zaXplID0ga2VybmVsX2VuZCAtIGtlcm5lbF9zdGFydDsKLQotCS8qCi0JICogVGhlIGRlZmF1 bHQgbW9kdWxlcyByZWdpb24gaXMgcGxhY2VkIGltbWVkaWF0ZWx5IGJlbG93IHRoZSBrZXJuZWwK LQkgKiBpbWFnZSwgYW5kIGlzIGxhcmdlIGVub3VnaCB0byB1c2UgdGhlIGZ1bGwgMkcgcmVsb2Nh dGlvbiByYW5nZS4KLQkgKi8KLQlCVUlMRF9CVUdfT04oS0lNQUdFX1ZBRERSICE9IE1PRFVMRVNf RU5EKTsKLQlCVUlMRF9CVUdfT04oTU9EVUxFU19WU0laRSA8IFNaXzJHKTsKLQotCWlmICgha2Fz bHJfZW5hYmxlZCgpKSB7Ci0JCWlmIChrZXJuZWxfc2l6ZSA8IFNaXzEyOE0pCi0JCQltb2R1bGVf ZGlyZWN0X2Jhc2UgPSBrZXJuZWxfZW5kIC0gU1pfMTI4TTsKLQkJaWYgKGtlcm5lbF9zaXplIDwg U1pfMkcpCi0JCQltb2R1bGVfcGx0X2Jhc2UgPSBrZXJuZWxfZW5kIC0gU1pfMkc7Ci0JfSBlbHNl IHsKLQkJdTY0IG1pbiA9IGtlcm5lbF9zdGFydDsKLQkJdTY0IG1heCA9IGtlcm5lbF9lbmQ7Ci0K LQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX1JBTkRPTUlaRV9NT0RVTEVfUkVHSU9OX0ZVTEwpKSB7 Ci0JCQlwcl9pbmZvKCIyRyBtb2R1bGUgcmVnaW9uIGZvcmNlZCBieSBSQU5ET01JWkVfTU9EVUxF X1JFR0lPTl9GVUxMXG4iKTsKLQkJfSBlbHNlIHsKLQkJCW1vZHVsZV9kaXJlY3RfYmFzZSA9IHJh bmRvbV9ib3VuZGluZ19ib3goU1pfMTI4TSwgbWluLCBtYXgpOwotCQkJaWYgKG1vZHVsZV9kaXJl Y3RfYmFzZSkgewotCQkJCW1pbiA9IG1vZHVsZV9kaXJlY3RfYmFzZTsKLQkJCQltYXggPSBtb2R1 bGVfZGlyZWN0X2Jhc2UgKyBTWl8xMjhNOwotCQkJfQotCQl9Ci0KLQkJbW9kdWxlX3BsdF9iYXNl ID0gcmFuZG9tX2JvdW5kaW5nX2JveChTWl8yRywgbWluLCBtYXgpOwotCX0KLQotCXByX2luZm8o IiVsbHUgcGFnZXMgaW4gcmFuZ2UgZm9yIG5vbi1QTFQgdXNhZ2UiLAotCQltb2R1bGVfZGlyZWN0 X2Jhc2UgPyAoU1pfMTI4TSAtIGtlcm5lbF9zaXplKSAvIFBBR0VfU0laRSA6IDApOwotCXByX2lu Zm8oIiVsbHUgcGFnZXMgaW4gcmFuZ2UgZm9yIFBMVCB1c2FnZSIsCi0JCW1vZHVsZV9wbHRfYmFz ZSA/IChTWl8yRyAtIGtlcm5lbF9zaXplKSAvIFBBR0VfU0laRSA6IDApOwotCi0JcmV0dXJuIDA7 Ci19Ci0KLXN0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVy X2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAo dm9pZCkKLXsKLQl1bnNpZ25lZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJhY2tfZW5k ID0gMDsKLQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gMCwgZW5kID0gMDsKLQotCW1vZHVsZV9pbml0 X2xpbWl0cygpOwotCi0JLyoKLQkgKiBXaGVyZSBwb3NzaWJsZSwgcHJlZmVyIHRvIGFsbG9jYXRl IHdpdGhpbiBkaXJlY3QgYnJhbmNoIHJhbmdlIG9mIHRoZQotCSAqIGtlcm5lbCBzdWNoIHRoYXQg bm8gUExUcyBhcmUgbmVjZXNzYXJ5LgotCSAqLwotCWlmIChtb2R1bGVfZGlyZWN0X2Jhc2UpIHsK LQkJc3RhcnQgPSBtb2R1bGVfZGlyZWN0X2Jhc2U7Ci0JCWVuZCA9IG1vZHVsZV9kaXJlY3RfYmFz ZSArIFNaXzEyOE07Ci0KLQkJaWYgKG1vZHVsZV9wbHRfYmFzZSkgewotCQkJZmFsbGJhY2tfc3Rh cnQgPSBtb2R1bGVfcGx0X2Jhc2U7Ci0JCQlmYWxsYmFja19lbmQgPSBtb2R1bGVfcGx0X2Jhc2Ug KyBTWl8yRzsKLQkJfQotCX0gZWxzZSBpZiAobW9kdWxlX3BsdF9iYXNlKSB7Ci0JCXN0YXJ0ID0g bW9kdWxlX3BsdF9iYXNlOwotCQllbmQgPSBtb2R1bGVfcGx0X2Jhc2UgKyBTWl8yRzsKLQl9Ci0K LQlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7Ci0J CQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKLQkJCQkuc3RhcnQJPSBzdGFydCwKLQkJCQkuZW5kCT0g ZW5kLAotCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJ CQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFja19zdGFydCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0g ZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJCVtFWEVDTUVNX0tQUk9CRVNdID0gewotCQkJCS5zdGFy dAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVuZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJ PSBQQUdFX0tFUk5FTF9ST1gsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9LAotCQkJW0VYRUNN RU1fQlBGXSA9IHsKLQkJCQkuc3RhcnQJPSBWTUFMTE9DX1NUQVJULAotCQkJCS5lbmQJPSBWTUFM TE9DX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFsaWdubWVudCA9IDEs Ci0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0KLQogZW51bSBh YXJjaDY0X3JlbG9jX29wIHsKIAlSRUxPQ19PUF9OT05FLAogCVJFTE9DX09QX0FCUywKZGlmZiAt LWdpdCBhL2FyY2gvYXJtNjQvbW0vaW5pdC5jIGIvYXJjaC9hcm02NC9tbS9pbml0LmMKaW5kZXgg MDNlZmQ4NmRjZTBhLi45YjVhYjY4MThmN2YgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvbW0vaW5p dC5jCisrKyBiL2FyY2gvYXJtNjQvbW0vaW5pdC5jCkBAIC0zMiw2ICszMiw3IEBACiAjaW5jbHVk ZSA8bGludXgvaHVnZXRsYi5oPgogI2luY2x1ZGUgPGxpbnV4L2FjcGlfaW9ydC5oPgogI2luY2x1 ZGUgPGxpbnV4L2ttZW1sZWFrLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5j bHVkZSA8YXNtL2Jvb3QuaD4KICNpbmNsdWRlIDxhc20vZml4bWFwLmg+CkBAIC00MzIsMyArNDMz LDE0MiBAQCB2b2lkIGR1bXBfbWVtX2xpbWl0KHZvaWQpCiAJCXByX2VtZXJnKCJNZW1vcnkgTGlt aXQ6IG5vbmVcbiIpOwogCX0KIH0KKworI2lmZGVmIENPTkZJR19FWEVDTUVNCitzdGF0aWMgdTY0 IG1vZHVsZV9kaXJlY3RfYmFzZSBfX3JvX2FmdGVyX2luaXQgPSAwOworc3RhdGljIHU2NCBtb2R1 bGVfcGx0X2Jhc2UgX19yb19hZnRlcl9pbml0ID0gMDsKKworLyoKKyAqIENob29zZSBhIHJhbmRv bSBwYWdlLWFsaWduZWQgYmFzZSBhZGRyZXNzIGZvciBhIHdpbmRvdyBvZiAnc2l6ZScgYnl0ZXMg d2hpY2gKKyAqIGVudGlyZWx5IGNvbnRhaW5zIHRoZSBpbnRlcnZhbCBbc3RhcnQsIGVuZCAtIDFd LgorICovCitzdGF0aWMgdTY0IF9faW5pdCByYW5kb21fYm91bmRpbmdfYm94KHU2NCBzaXplLCB1 NjQgc3RhcnQsIHU2NCBlbmQpCit7CisJdTY0IG1heF9wZ29mZiwgcGdvZmY7CisKKwlpZiAoKGVu ZCAtIHN0YXJ0KSA+PSBzaXplKQorCQlyZXR1cm4gMDsKKworCW1heF9wZ29mZiA9IChzaXplIC0g KGVuZCAtIHN0YXJ0KSkgLyBQQUdFX1NJWkU7CisJcGdvZmYgPSBnZXRfcmFuZG9tX3UzMl9pbmNs dXNpdmUoMCwgbWF4X3Bnb2ZmKTsKKworCXJldHVybiBzdGFydCAtIHBnb2ZmICogUEFHRV9TSVpF OworfQorCisvKgorICogTW9kdWxlcyBtYXkgZGlyZWN0bHkgcmVmZXJlbmNlIGRhdGEgYW5kIHRl eHQgYW55d2hlcmUgd2l0aGluIHRoZSBrZXJuZWwKKyAqIGltYWdlIGFuZCBvdGhlciBtb2R1bGVz LiBSZWZlcmVuY2VzIHVzaW5nIFBSRUwzMiByZWxvY2F0aW9ucyBoYXZlIGEgKy8tMkcKKyAqIHJh bmdlLCBhbmQgc28gd2UgbmVlZCB0byBlbnN1cmUgdGhhdCB0aGUgZW50aXJlIGtlcm5lbCBpbWFn ZSBhbmQgYWxsIG1vZHVsZXMKKyAqIGZhbGwgd2l0aGluIGEgMkcgd2luZG93IHN1Y2ggdGhhdCB0 aGVzZSBhcmUgYWx3YXlzIHdpdGhpbiByYW5nZS4KKyAqCisgKiBNb2R1bGVzIG1heSBkaXJlY3Rs eSBicmFuY2ggdG8gZnVuY3Rpb25zIGFuZCBjb2RlIHdpdGhpbiB0aGUga2VybmVsIHRleHQsCisg KiBhbmQgdG8gZnVuY3Rpb25zIGFuZCBjb2RlIHdpdGhpbiBvdGhlciBtb2R1bGVzLiBUaGVzZSBi cmFuY2hlcyB3aWxsIHVzZQorICogQ0FMTDI2L0pVTVAyNiByZWxvY2F0aW9ucyB3aXRoIGEgKy8t MTI4TSByYW5nZS4gV2l0aG91dCBQTFRzLCB3ZSBtdXN0IGVuc3VyZQorICogdGhhdCB0aGUgZW50 aXJlIGtlcm5lbCB0ZXh0IGFuZCBhbGwgbW9kdWxlIHRleHQgZmFsbHMgd2l0aGluIGEgMTI4TSB3 aW5kb3cKKyAqIHN1Y2ggdGhhdCB0aGVzZSBhcmUgYWx3YXlzIHdpdGhpbiByYW5nZS4gV2l0aCBQ TFRzLCB3ZSBjYW4gZXhwYW5kIHRoaXMgdG8gYQorICogMkcgd2luZG93LgorICoKKyAqIFdlIGNo b3NlIHRoZSAxMjhNIHJlZ2lvbiB0byBzdXJyb3VuZCB0aGUgZW50aXJlIGtlcm5lbCBpbWFnZSAo cmF0aGVyIHRoYW4KKyAqIGp1c3QgdGhlIHRleHQpIGFzIHVzaW5nIHRoZSBzYW1lIGJvdW5kcyBm b3IgdGhlIDEyOE0gYW5kIDJHIHJlZ2lvbnMgZW5zdXJlcworICogYnkgY29uc3RydWN0aW9uIHRo YXQgd2UgbmV2ZXIgc2VsZWN0IGEgMTI4TSByZWdpb24gdGhhdCBpcyBub3QgYSBzdWJzZXQgb2YK KyAqIHRoZSAyRyByZWdpb24uIEZvciB2ZXJ5IGxhcmdlIGFuZCB1bnVzdWFsIGtlcm5lbCBjb25m aWd1cmF0aW9ucyB0aGlzIG1lYW5zCisgKiB3ZSBtYXkgZmFsbCBiYWNrIHRvIFBMVHMgd2hlcmUg dGhleSBjb3VsZCBoYXZlIGJlZW4gYXZvaWRlZCwgYnV0IHRoaXMga2VlcHMKKyAqIHRoZSBsb2dp YyBzaWduaWZpY2FudGx5IHNpbXBsZXIuCisgKi8KK3N0YXRpYyBpbnQgX19pbml0IG1vZHVsZV9p bml0X2xpbWl0cyh2b2lkKQoreworCXU2NCBrZXJuZWxfZW5kID0gKHU2NClfZW5kOworCXU2NCBr ZXJuZWxfc3RhcnQgPSAodTY0KV90ZXh0OworCXU2NCBrZXJuZWxfc2l6ZSA9IGtlcm5lbF9lbmQg LSBrZXJuZWxfc3RhcnQ7CisKKwkvKgorCSAqIFRoZSBkZWZhdWx0IG1vZHVsZXMgcmVnaW9uIGlz IHBsYWNlZCBpbW1lZGlhdGVseSBiZWxvdyB0aGUga2VybmVsCisJICogaW1hZ2UsIGFuZCBpcyBs YXJnZSBlbm91Z2ggdG8gdXNlIHRoZSBmdWxsIDJHIHJlbG9jYXRpb24gcmFuZ2UuCisJICovCisJ QlVJTERfQlVHX09OKEtJTUFHRV9WQUREUiAhPSBNT0RVTEVTX0VORCk7CisJQlVJTERfQlVHX09O KE1PRFVMRVNfVlNJWkUgPCBTWl8yRyk7CisKKwlpZiAoIWthc2xyX2VuYWJsZWQoKSkgeworCQlp ZiAoa2VybmVsX3NpemUgPCBTWl8xMjhNKQorCQkJbW9kdWxlX2RpcmVjdF9iYXNlID0ga2VybmVs X2VuZCAtIFNaXzEyOE07CisJCWlmIChrZXJuZWxfc2l6ZSA8IFNaXzJHKQorCQkJbW9kdWxlX3Bs dF9iYXNlID0ga2VybmVsX2VuZCAtIFNaXzJHOworCX0gZWxzZSB7CisJCXU2NCBtaW4gPSBrZXJu ZWxfc3RhcnQ7CisJCXU2NCBtYXggPSBrZXJuZWxfZW5kOworCisJCWlmIChJU19FTkFCTEVEKENP TkZJR19SQU5ET01JWkVfTU9EVUxFX1JFR0lPTl9GVUxMKSkgeworCQkJcHJfaW5mbygiMkcgbW9k dWxlIHJlZ2lvbiBmb3JjZWQgYnkgUkFORE9NSVpFX01PRFVMRV9SRUdJT05fRlVMTFxuIik7CisJ CX0gZWxzZSB7CisJCQltb2R1bGVfZGlyZWN0X2Jhc2UgPSByYW5kb21fYm91bmRpbmdfYm94KFNa XzEyOE0sIG1pbiwgbWF4KTsKKwkJCWlmIChtb2R1bGVfZGlyZWN0X2Jhc2UpIHsKKwkJCQltaW4g PSBtb2R1bGVfZGlyZWN0X2Jhc2U7CisJCQkJbWF4ID0gbW9kdWxlX2RpcmVjdF9iYXNlICsgU1pf MTI4TTsKKwkJCX0KKwkJfQorCisJCW1vZHVsZV9wbHRfYmFzZSA9IHJhbmRvbV9ib3VuZGluZ19i b3goU1pfMkcsIG1pbiwgbWF4KTsKKwl9CisKKwlwcl9pbmZvKCIlbGx1IHBhZ2VzIGluIHJhbmdl IGZvciBub24tUExUIHVzYWdlIiwKKwkJbW9kdWxlX2RpcmVjdF9iYXNlID8gKFNaXzEyOE0gLSBr ZXJuZWxfc2l6ZSkgLyBQQUdFX1NJWkUgOiAwKTsKKwlwcl9pbmZvKCIlbGx1IHBhZ2VzIGluIHJh bmdlIGZvciBQTFQgdXNhZ2UiLAorCQltb2R1bGVfcGx0X2Jhc2UgPyAoU1pfMkcgLSBrZXJuZWxf c2l6ZSkgLyBQQUdFX1NJWkUgOiAwKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgc3RydWN0 IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OworCitzdHJ1Y3QgZXhl Y21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCit7CisJdW5zaWduZWQg bG9uZyBmYWxsYmFja19zdGFydCA9IDAsIGZhbGxiYWNrX2VuZCA9IDA7CisJdW5zaWduZWQgbG9u ZyBzdGFydCA9IDAsIGVuZCA9IDA7CisKKwltb2R1bGVfaW5pdF9saW1pdHMoKTsKKworCS8qCisJ ICogV2hlcmUgcG9zc2libGUsIHByZWZlciB0byBhbGxvY2F0ZSB3aXRoaW4gZGlyZWN0IGJyYW5j aCByYW5nZSBvZiB0aGUKKwkgKiBrZXJuZWwgc3VjaCB0aGF0IG5vIFBMVHMgYXJlIG5lY2Vzc2Fy eS4KKwkgKi8KKwlpZiAobW9kdWxlX2RpcmVjdF9iYXNlKSB7CisJCXN0YXJ0ID0gbW9kdWxlX2Rp cmVjdF9iYXNlOworCQllbmQgPSBtb2R1bGVfZGlyZWN0X2Jhc2UgKyBTWl8xMjhNOworCisJCWlm IChtb2R1bGVfcGx0X2Jhc2UpIHsKKwkJCWZhbGxiYWNrX3N0YXJ0ID0gbW9kdWxlX3BsdF9iYXNl OworCQkJZmFsbGJhY2tfZW5kID0gbW9kdWxlX3BsdF9iYXNlICsgU1pfMkc7CisJCX0KKwl9IGVs c2UgaWYgKG1vZHVsZV9wbHRfYmFzZSkgeworCQlzdGFydCA9IG1vZHVsZV9wbHRfYmFzZTsKKwkJ ZW5kID0gbW9kdWxlX3BsdF9iYXNlICsgU1pfMkc7CisJfQorCisJZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7CisJCQkJLnN0YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IGVuZCwKKwkJCQkucGdwcm90CT0g UEFHRV9LRVJORUwsCisJCQkJLmFsaWdubWVudCA9IDEsCisJCQkJLmZhbGxiYWNrX3N0YXJ0CT0g ZmFsbGJhY2tfc3RhcnQsCisJCQkJLmZhbGxiYWNrX2VuZAk9IGZhbGxiYWNrX2VuZCwKKwkJCX0s CisJCQlbRVhFQ01FTV9LUFJPQkVTXSA9IHsKKwkJCQkuc3RhcnQJPSBWTUFMTE9DX1NUQVJULAor CQkJCS5lbmQJPSBWTUFMTE9DX0VORCwKKwkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxfUk9YLAor CQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJCVtFWEVDTUVNX0JQRl0gPSB7CisJCQkJLnN0 YXJ0CT0gVk1BTExPQ19TVEFSVCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCisJCQkJLnBncHJv dAk9IFBBR0VfS0VSTkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9Owor CisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8K ZGlmZiAtLWdpdCBhL2FyY2gvbG9vbmdhcmNoL2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvbG9vbmdh cmNoL2tlcm5lbC9tb2R1bGUuYwppbmRleCBjYTZkZDdlYTE2MTAuLjM2ZDZkOWVlYjdjNyAxMDA2 NDQKLS0tIGEvYXJjaC9sb29uZ2FyY2gva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvbG9vbmdh cmNoL2tlcm5lbC9tb2R1bGUuYwpAQCAtMTgsNyArMTgsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2Z0 cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0cmluZy5oPgogI2luY2x1ZGUgPGxpbnV4L2tlcm5l bC5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KICNpbmNsdWRlIDxhc20vYWx0ZXJuYXRp dmUuaD4KICNpbmNsdWRlIDxhc20vaW5zdC5oPgogI2luY2x1ZGUgPGFzbS91bndpbmQuaD4KQEAg LTQ5MSwyNCArNDkwLDYgQEAgaW50IGFwcGx5X3JlbG9jYXRlX2FkZChFbGZfU2hkciAqc2VjaGRy cywgY29uc3QgY2hhciAqc3RydGFiLAogCXJldHVybiAwOwogfQogCi1zdGF0aWMgc3RydWN0IGV4 ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21l bV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZv ID0gKHN0cnVjdCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVG QVVMVF0gPSB7Ci0JCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxF U19FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAot CQkJfSwKLQkJfSwKLQl9OwotCi0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0KIHN0YXRpYyB2 b2lkIG1vZHVsZV9pbml0X2Z0cmFjZV9wbHQoY29uc3QgRWxmX0VoZHIgKmhkciwKIAkJCQkgICBj b25zdCBFbGZfU2hkciAqc2VjaGRycywgc3RydWN0IG1vZHVsZSAqbW9kKQogewpkaWZmIC0tZ2l0 IGEvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jIGIvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jCmlu ZGV4IDRkZDUzNDI3ZjY1Ny4uYmY3ODlkMTE0YzJkIDEwMDY0NAotLS0gYS9hcmNoL2xvb25nYXJj aC9tbS9pbml0LmMKKysrIGIvYXJjaC9sb29uZ2FyY2gvbW0vaW5pdC5jCkBAIC0yNCw2ICsyNCw3 IEBACiAjaW5jbHVkZSA8bGludXgvZ2ZwLmg+CiAjaW5jbHVkZSA8bGludXgvaHVnZXRsYi5oPgog I2luY2x1ZGUgPGxpbnV4L21tem9uZS5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAog I2luY2x1ZGUgPGFzbS9hc20tb2Zmc2V0cy5oPgogI2luY2x1ZGUgPGFzbS9ib290aW5mby5oPgpA QCAtMjQ4LDMgKzI0OSwyMyBAQCBFWFBPUlRfU1lNQk9MKGludmFsaWRfcG1kX3RhYmxlKTsKICNl bmRpZgogcHRlX3QgaW52YWxpZF9wdGVfdGFibGVbUFRSU19QRVJfUFRFXSBfX3BhZ2VfYWxpZ25l ZF9ic3M7CiBFWFBPUlRfU1lNQk9MKGludmFsaWRfcHRlX3RhYmxlKTsKKworI2lmZGVmIENPTkZJ R19FWEVDTUVNCitzdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19h ZnRlcl9pbml0OworCitzdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3Nl dHVwKHZvaWQpCit7CisJZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQku cmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxF U19WQUREUiwKKwkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VS TkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZl eGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBh L2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL21pcHMva2VybmVsL21vZHVsZS5jCmlu ZGV4IDU5MjI1YTNjZjkxOC4uYmEwZjYyZDhlZmY1IDEwMDY0NAotLS0gYS9hcmNoL21pcHMva2Vy bmVsL21vZHVsZS5jCisrKyBiL2FyY2gvbWlwcy9rZXJuZWwvbW9kdWxlLmMKQEAgLTEzLDE0ICsx MywxMiBAQAogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1ZGUgPGxpbnV4L21tLmg+CiAj aW5jbHVkZSA8bGludXgvbnVtYS5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNs dWRlIDxsaW51eC9zbGFiLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51 eC9zdHJpbmcuaD4KICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KICNpbmNsdWRlIDxsaW51eC9z cGlubG9jay5oPgogI2luY2x1ZGUgPGxpbnV4L2p1bXBfbGFiZWwuaD4KLSNpbmNsdWRlIDxsaW51 eC9leGVjbWVtLmg+CiAjaW5jbHVkZSA8YXNtL2p1bXBfbGFiZWwuaD4KIAogc3RydWN0IG1pcHNf aGkxNiB7CkBAIC0zMiwyNiArMzAsNiBAQCBzdHJ1Y3QgbWlwc19oaTE2IHsKIHN0YXRpYyBMSVNU X0hFQUQoZGJlX2xpc3QpOwogc3RhdGljIERFRklORV9TUElOTE9DSyhkYmVfbG9jayk7CiAKLSNp ZmRlZiBNT0RVTEVTX1ZBRERSCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2lu Zm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21l bV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2lu Zm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7Ci0JCQkJLnN0YXJ0 CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0JCQkJLnBncHJvdAk9 IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAotCQkJfSwKLQkJfSwKLQl9OwotCi0J cmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0jZW5kaWYKLQogc3RhdGljIHZvaWQgYXBwbHlfcl9t aXBzXzMyKHUzMiAqbG9jYXRpb24sIHUzMiBiYXNlLCBFbGZfQWRkciB2KQogewogCSpsb2NhdGlv biA9IGJhc2UgKyB2OwpkaWZmIC0tZ2l0IGEvYXJjaC9taXBzL21tL2luaXQuYyBiL2FyY2gvbWlw cy9tbS9pbml0LmMKaW5kZXggMzlmMTI5MjA1YjBjLi40NTgzZDFhMmE3M2UgMTAwNjQ0Ci0tLSBh L2FyY2gvbWlwcy9tbS9pbml0LmMKKysrIGIvYXJjaC9taXBzL21tL2luaXQuYwpAQCAtMzEsNiAr MzEsNyBAQAogI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgogI2luY2x1ZGUgPGxpbnV4L2tjb3JlLmg+ CiAjaW5jbHVkZSA8bGludXgvaW5pdHJkLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgog CiAjaW5jbHVkZSA8YXNtL2Jvb3RpbmZvLmg+CiAjaW5jbHVkZSA8YXNtL2NhY2hlY3RsLmg+CkBA IC01NzYsMyArNTc3LDI1IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGludmFsaWRfcG1kX3RhYmxlKTsK ICNlbmRpZgogcHRlX3QgaW52YWxpZF9wdGVfdGFibGVbUFRSU19QRVJfUFRFXSBfX3BhZ2VfYWxp Z25lZF9ic3M7CiBFWFBPUlRfU1lNQk9MKGludmFsaWRfcHRlX3RhYmxlKTsKKworI2lmZGVmIENP TkZJR19FWEVDTUVNCisjaWZkZWYgTU9EVUxFU19WQUREUgorc3RhdGljIHN0cnVjdCBleGVjbWVt X2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5m byBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCWV4ZWNtZW1faW5mbyA9IChz dHJ1Y3QgZXhlY21lbV9pbmZvKXsKKwkJLnJhbmdlcyA9IHsKKwkJCVtFWEVDTUVNX0RFRkFVTFRd ID0geworCQkJCS5zdGFydAk9IE1PRFVMRVNfVkFERFIsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5E LAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0s CisJCX0sCisJfTsKKworCXJldHVybiAmZXhlY21lbV9pbmZvOworfQorI2VuZGlmCisjZW5kaWYg LyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gvbmlvczIva2VybmVsL21vZHVs ZS5jIGIvYXJjaC9uaW9zMi9rZXJuZWwvbW9kdWxlLmMKaW5kZXggMGQxZWU4NjYzMWZjLi5mNDQ4 MzI0MzU3OGQgMTAwNjQ0Ci0tLSBhL2FyY2gvbmlvczIva2VybmVsL21vZHVsZS5jCisrKyBiL2Fy Y2gvbmlvczIva2VybmVsL21vZHVsZS5jCkBAIC0xMywzMyArMTMsMTMgQEAKICNpbmNsdWRlIDxs aW51eC9tb2R1bGVsb2FkZXIuaD4KICNpbmNsdWRlIDxsaW51eC9lbGYuaD4KICNpbmNsdWRlIDxs aW51eC9tbS5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9z bGFiLmg+CiAjaW5jbHVkZSA8bGludXgvZnMuaD4KICNpbmNsdWRlIDxsaW51eC9zdHJpbmcuaD4K ICNpbmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KLSNpbmNsdWRlIDxsaW51eC9leGVjbWVtLmg+CiAK ICNpbmNsdWRlIDxhc20vY2FjaGVmbHVzaC5oPgogCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5m byBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9f aW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVj dCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7 Ci0JCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0J CQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX0VYRUMsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9 LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0KLQogaW50IGFwcGx5X3Jl bG9jYXRlX2FkZChFbGYzMl9TaGRyICpzZWNoZHJzLCBjb25zdCBjaGFyICpzdHJ0YWIsCiAJCQl1 bnNpZ25lZCBpbnQgc3ltaW5kZXgsIHVuc2lnbmVkIGludCByZWxzZWMsCiAJCQlzdHJ1Y3QgbW9k dWxlICptb2QpCmRpZmYgLS1naXQgYS9hcmNoL25pb3MyL21tL2luaXQuYyBiL2FyY2gvbmlvczIv bW0vaW5pdC5jCmluZGV4IDdiYzgyZWU4ODljOS4uMzQ1OWRmMjhhZmVlIDEwMDY0NAotLS0gYS9h cmNoL25pb3MyL21tL2luaXQuYworKysgYi9hcmNoL25pb3MyL21tL2luaXQuYwpAQCAtMjYsNiAr MjYsNyBAQAogI2luY2x1ZGUgPGxpbnV4L21lbWJsb2NrLmg+CiAjaW5jbHVkZSA8bGludXgvc2xh Yi5oPgogI2luY2x1ZGUgPGxpbnV4L2JpbmZtdHMuaD4KKyNpbmNsdWRlIDxsaW51eC9leGVjbWVt Lmg+CiAKICNpbmNsdWRlIDxhc20vc2V0dXAuaD4KICNpbmNsdWRlIDxhc20vcGFnZS5oPgpAQCAt MTQzLDMgKzE0NCwyMyBAQCBzdGF0aWMgY29uc3QgcGdwcm90X3QgcHJvdGVjdGlvbl9tYXBbMTZd ID0gewogCVtWTV9TSEFSRUQgfCBWTV9FWEVDIHwgVk1fV1JJVEUgfCBWTV9SRUFEXQk9IE1LUCgx LCAxLCAxKQogfTsKIERFQ0xBUkVfVk1fR0VUX1BBR0VfUFJPVAorCisjaWZkZWYgQ09ORklHX0VY RUNNRU0KK3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVy X2luaXQ7CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAo dm9pZCkKK3sKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7CisJCS5yYW5n ZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZB RERSLAorCQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKKwkJCQkucGdwcm90CT0gUEFHRV9LRVJORUxf RVhFQywKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0sCisJCX0sCisJfTsKKworCXJldHVybiAm ZXhlY21lbV9pbmZvOworfQorI2VuZGlmIC8qIENPTkZJR19FWEVDTUVNICovCmRpZmYgLS1naXQg YS9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxl LmMKaW5kZXggYmRmYTg1ZTEwYzFiLi40ZTVkOTkxYjJiNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFy aXNjL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3BhcmlzYy9rZXJuZWwvbW9kdWxlLmMKQEAg LTQxLDcgKzQxLDYgQEAKIAogI2luY2x1ZGUgPGxpbnV4L21vZHVsZWxvYWRlci5oPgogI2luY2x1 ZGUgPGxpbnV4L2VsZi5oPgotI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxs aW51eC9mcy5oPgogI2luY2x1ZGUgPGxpbnV4L2Z0cmFjZS5oPgogI2luY2x1ZGUgPGxpbnV4L3N0 cmluZy5oPgpAQCAtNDksNyArNDgsNiBAQAogI2luY2x1ZGUgPGxpbnV4L2J1Zy5oPgogI2luY2x1 ZGUgPGxpbnV4L21tLmg+CiAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgotI2luY2x1ZGUgPGxpbnV4 L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFzbS91bndpbmQuaD4KICNpbmNsdWRlIDxhc20vc2Vj dGlvbnMuaD4KQEAgLTE3NCwyNCArMTcyLDYgQEAgc3RhdGljIGlubGluZSBpbnQgcmVhc3NlbWJs ZV8yMihpbnQgYXMyMikKIAkJKChhczIyICYgMHgwMDAzZmYpIDw8IDMpKTsKIH0KIAotc3RhdGlj IHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKLQotc3Ry dWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQotewotCWV4 ZWNtZW1faW5mbyA9IChzdHJ1Y3QgZXhlY21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtF WEVDTUVNX0RFRkFVTFRdID0gewotCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVu ZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTF9SV1gsCi0JCQkJLmFs aWdubWVudCA9IDEsCi0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsK LX0KLQogI2lmbmRlZiBDT05GSUdfNjRCSVQKIHN0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBj b3VudF9nb3RzKGNvbnN0IEVsZl9SZWxhICpyZWxhLCB1bnNpZ25lZCBsb25nIG4pCiB7CmRpZmYg LS1naXQgYS9hcmNoL3BhcmlzYy9tbS9pbml0LmMgYi9hcmNoL3BhcmlzYy9tbS9pbml0LmMKaW5k ZXggZjg3NmFmNTZlMTNmLi4zNGQ5MWNiOGIyNTkgMTAwNjQ0Ci0tLSBhL2FyY2gvcGFyaXNjL21t L2luaXQuYworKysgYi9hcmNoL3BhcmlzYy9tbS9pbml0LmMKQEAgLTI0LDYgKzI0LDcgQEAKICNp bmNsdWRlIDxsaW51eC9ub2RlbWFzay5oPgkvKiBmb3Igbm9kZV9vbmxpbmVfbWFwICovCiAjaW5j bHVkZSA8bGludXgvcGFnZW1hcC5oPgkvKiBmb3IgcmVsZWFzZV9wYWdlcyAqLwogI2luY2x1ZGUg PGxpbnV4L2NvbXBhdC5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUg PGFzbS9wZ2FsbG9jLmg+CiAjaW5jbHVkZSA8YXNtL3RsYi5oPgpAQCAtNDgxLDcgKzQ4Miw3IEBA IHZvaWQgZnJlZV9pbml0bWVtKHZvaWQpCiAJLyogZmluYWxseSBkdW1wIGFsbCB0aGUgaW5zdHJ1 Y3Rpb25zIHdoaWNoIHdlcmUgY2FjaGVkLCBzaW5jZSB0aGUKIAkgKiBwYWdlcyBhcmUgbm8tbG9u Z2VyIGV4ZWN1dGFibGUgKi8KIAlmbHVzaF9pY2FjaGVfcmFuZ2UoaW5pdF9iZWdpbiwgaW5pdF9l bmQpOwotCQorCiAJZnJlZV9pbml0bWVtX2RlZmF1bHQoUE9JU09OX0ZSRUVfSU5JVE1FTSk7CiAK IAkvKiBzZXQgdXAgYSBuZXcgbGVkIHN0YXRlIG9uIHN5c3RlbXMgc2hpcHBlZCBMRUQgU3RhdGUg cGFuZWwgKi8KQEAgLTk5MiwzICs5OTMsMjMgQEAgc3RhdGljIGNvbnN0IHBncHJvdF90IHByb3Rl Y3Rpb25fbWFwWzE2XSA9IHsKIAlbVk1fU0hBUkVEIHwgVk1fRVhFQyB8IFZNX1dSSVRFIHwgVk1f UkVBRF0JPSBQQUdFX1JXWAogfTsKIERFQ0xBUkVfVk1fR0VUX1BBR0VfUFJPVAorCisjaWZkZWYg Q09ORklHX0VYRUNNRU0KK3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBf X3JvX2FmdGVyX2luaXQ7CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2Fy Y2hfc2V0dXAodm9pZCkKK3sKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5mbyl7 CisJCS5yYW5nZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJPSBW TUFMTE9DX1NUQVJULAorCQkJCS5lbmQJPSBWTUFMTE9DX0VORCwKKwkJCQkucGdwcm90CT0gUEFH RV9LRVJORUxfUldYLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJ cmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlm ZiAtLWdpdCBhL2FyY2gvcG93ZXJwYy9rZXJuZWwvbW9kdWxlLmMgYi9hcmNoL3Bvd2VycGMva2Vy bmVsL21vZHVsZS5jCmluZGV4IDJhMjNjZjdlMTQxYi4uNzdlYTgyZTlkYzVmIDEwMDY0NAotLS0g YS9hcmNoL3Bvd2VycGMva2VybmVsL21vZHVsZS5jCisrKyBiL2FyY2gvcG93ZXJwYy9rZXJuZWwv bW9kdWxlLmMKQEAgLTcsMTAgKzcsOCBAQAogI2luY2x1ZGUgPGxpbnV4L2VsZi5oPgogI2luY2x1 ZGUgPGxpbnV4L21vZHVsZWxvYWRlci5oPgogI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgotI2luY2x1 ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KICNpbmNsdWRlIDxsaW51eC9tbS5oPgogI2luY2x1ZGUgPGxp bnV4L2J1Zy5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KICNpbmNsdWRlIDxhc20vbW9k dWxlLmg+CiAjaW5jbHVkZSA8bGludXgvdWFjY2Vzcy5oPgogI2luY2x1ZGUgPGFzbS9maXJtd2Fy ZS5oPgpAQCAtODksNjQgKzg3LDMgQEAgaW50IG1vZHVsZV9maW5hbGl6ZShjb25zdCBFbGZfRWhk ciAqaGRyLAogCiAJcmV0dXJuIDA7CiB9Ci0KLXN0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4 ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2luZm8gX19pbml0 ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQlwZ3Byb3RfdCBrcHJvYmVzX3Byb3QgPSBz dHJpY3RfbW9kdWxlX3J3eF9lbmFibGVkKCkgPyBQQUdFX0tFUk5FTF9ST1ggOiBQQUdFX0tFUk5F TF9FWEVDOwotCXBncHJvdF90IHByb3QgPSBzdHJpY3RfbW9kdWxlX3J3eF9lbmFibGVkKCkgPyBQ QUdFX0tFUk5FTCA6IFBBR0VfS0VSTkVMX0VYRUM7Ci0JdW5zaWduZWQgbG9uZyBmYWxsYmFja19z dGFydCA9IDAsIGZhbGxiYWNrX2VuZCA9IDA7Ci0JdW5zaWduZWQgbG9uZyBzdGFydCwgZW5kOwot Ci0JLyoKLQkgKiBCT09LM1NfMzIgYW5kIDh4eCBkZWZpbmUgTU9EVUxFU19WQUREUiBmb3IgdGV4 dCBhbGxvY2F0aW9ucyBhbmQKLQkgKiBhbGxvdyBhbGxvY2F0aW5nIGRhdGEgaW4gdGhlIGVudGly ZSB2bWFsbG9jIHNwYWNlCi0JICovCi0jaWZkZWYgTU9EVUxFU19WQUREUgotCXVuc2lnbmVkIGxv bmcgbGltaXQgPSAodW5zaWduZWQgbG9uZylfZXRleHQgLSBTWl8zMk07Ci0KLQlCVUlMRF9CVUdf T04oVEFTS19TSVpFID4gTU9EVUxFU19WQUREUik7Ci0KLQkvKiBGaXJzdCB0cnkgd2l0aGluIDMy TSBsaW1pdCBmcm9tIF9ldGV4dCB0byBhdm9pZCBicmFuY2ggdHJhbXBvbGluZXMgKi8KLQlpZiAo TU9EVUxFU19WQUREUiA8IFBBR0VfT0ZGU0VUICYmIE1PRFVMRVNfRU5EID4gbGltaXQpIHsKLQkJ c3RhcnQgPSBsaW1pdDsKLQkJZmFsbGJhY2tfc3RhcnQgPSBNT0RVTEVTX1ZBRERSOwotCQlmYWxs YmFja19lbmQgPSBNT0RVTEVTX0VORDsKLQl9IGVsc2UgewotCQlzdGFydCA9IE1PRFVMRVNfVkFE RFI7Ci0JfQotCi0JZW5kID0gTU9EVUxFU19FTkQ7Ci0jZWxzZQotCXN0YXJ0ID0gVk1BTExPQ19T VEFSVDsKLQllbmQgPSBWTUFMTE9DX0VORDsKLSNlbmRpZgotCi0JZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7Ci0JCQkJLnN0YXJ0CT0gc3RhcnQsCi0JCQkJLmVuZAk9IGVuZCwKLQkJCQkucGdwcm90CT0g cHJvdCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCQkuZmFsbGJhY2tfc3RhcnQJPSBmYWxsYmFj a19zdGFydCwKLQkJCQkuZmFsbGJhY2tfZW5kCT0gZmFsbGJhY2tfZW5kLAotCQkJfSwKLQkJCVtF WEVDTUVNX0tQUk9CRVNdID0gewotCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVu ZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJPSBrcHJvYmVzX3Byb3QsCi0JCQkJLmFsaWdu bWVudCA9IDEsCi0JCQl9LAotCQkJW0VYRUNNRU1fTU9EVUxFX0RBVEFdID0gewotCQkJCS5zdGFy dAk9IFZNQUxMT0NfU1RBUlQsCi0JCQkJLmVuZAk9IFZNQUxMT0NfRU5ELAotCQkJCS5wZ3Byb3QJ PSBQQUdFX0tFUk5FTCwKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCX0sCi0JCX0sCi0JfTsKLQot CXJldHVybiAmZXhlY21lbV9pbmZvOwotfQpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL21tL21l bS5jIGIvYXJjaC9wb3dlcnBjL21tL21lbS5jCmluZGV4IDNhNDQwMDA0Yjk3ZC4uNWRlNjJhM2Mx ZDRiIDEwMDY0NAotLS0gYS9hcmNoL3Bvd2VycGMvbW0vbWVtLmMKKysrIGIvYXJjaC9wb3dlcnBj L21tL21lbS5jCkBAIC0xNiw2ICsxNiw3IEBACiAjaW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgog I2luY2x1ZGUgPGxpbnV4L3N1c3BlbmQuaD4KICNpbmNsdWRlIDxsaW51eC9kbWEtZGlyZWN0Lmg+ CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVkZSA8YXNtL3N3aW90bGIuaD4K ICNpbmNsdWRlIDxhc20vbWFjaGRlcC5oPgpAQCAtNDA2LDMgKzQwNyw2NiBAQCBpbnQgZGV2bWVt X2lzX2FsbG93ZWQodW5zaWduZWQgbG9uZyBwZm4pCiAgKiB0aGUgRUhFQSBkcml2ZXIuIERyb3Ag dGhpcyB3aGVuIGRyaXZlcnMvbmV0L2V0aGVybmV0L2libS9laGVhIGlzIHJlbW92ZWQuCiAgKi8K IEVYUE9SVF9TWU1CT0xfR1BMKHdhbGtfc3lzdGVtX3JhbV9yYW5nZSk7CisKKyNpZmRlZiBDT05G SUdfRVhFQ01FTQorc3RhdGljIHN0cnVjdCBleGVjbWVtX2luZm8gZXhlY21lbV9pbmZvIF9fcm9f YWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBfX2luaXQgKmV4ZWNtZW1fYXJjaF9z ZXR1cCh2b2lkKQoreworCXBncHJvdF90IGtwcm9iZXNfcHJvdCA9IHN0cmljdF9tb2R1bGVfcnd4 X2VuYWJsZWQoKSA/IFBBR0VfS0VSTkVMX1JPWCA6IFBBR0VfS0VSTkVMX0VYRUM7CisJcGdwcm90 X3QgcHJvdCA9IHN0cmljdF9tb2R1bGVfcnd4X2VuYWJsZWQoKSA/IFBBR0VfS0VSTkVMIDogUEFH RV9LRVJORUxfRVhFQzsKKwl1bnNpZ25lZCBsb25nIGZhbGxiYWNrX3N0YXJ0ID0gMCwgZmFsbGJh Y2tfZW5kID0gMDsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBlbmQ7CisKKwkvKgorCSAqIEJPT0sz U18zMiBhbmQgOHh4IGRlZmluZSBNT0RVTEVTX1ZBRERSIGZvciB0ZXh0IGFsbG9jYXRpb25zIGFu ZAorCSAqIGFsbG93IGFsbG9jYXRpbmcgZGF0YSBpbiB0aGUgZW50aXJlIHZtYWxsb2Mgc3BhY2UK KwkgKi8KKyNpZmRlZiBNT0RVTEVTX1ZBRERSCisJdW5zaWduZWQgbG9uZyBsaW1pdCA9ICh1bnNp Z25lZCBsb25nKV9ldGV4dCAtIFNaXzMyTTsKKworCUJVSUxEX0JVR19PTihUQVNLX1NJWkUgPiBN T0RVTEVTX1ZBRERSKTsKKworCS8qIEZpcnN0IHRyeSB3aXRoaW4gMzJNIGxpbWl0IGZyb20gX2V0 ZXh0IHRvIGF2b2lkIGJyYW5jaCB0cmFtcG9saW5lcyAqLworCWlmIChNT0RVTEVTX1ZBRERSIDwg UEFHRV9PRkZTRVQgJiYgTU9EVUxFU19FTkQgPiBsaW1pdCkgeworCQlzdGFydCA9IGxpbWl0Owor CQlmYWxsYmFja19zdGFydCA9IE1PRFVMRVNfVkFERFI7CisJCWZhbGxiYWNrX2VuZCA9IE1PRFVM RVNfRU5EOworCX0gZWxzZSB7CisJCXN0YXJ0ID0gTU9EVUxFU19WQUREUjsKKwl9CisKKwllbmQg PSBNT0RVTEVTX0VORDsKKyNlbHNlCisJc3RhcnQgPSBWTUFMTE9DX1NUQVJUOworCWVuZCA9IFZN QUxMT0NfRU5EOworI2VuZGlmCisKKwlleGVjbWVtX2luZm8gPSAoc3RydWN0IGV4ZWNtZW1faW5m byl7CisJCS5yYW5nZXMgPSB7CisJCQlbRVhFQ01FTV9ERUZBVUxUXSA9IHsKKwkJCQkuc3RhcnQJ PSBzdGFydCwKKwkJCQkuZW5kCT0gZW5kLAorCQkJCS5wZ3Byb3QJPSBwcm90LAorCQkJCS5hbGln bm1lbnQgPSAxLAorCQkJCS5mYWxsYmFja19zdGFydAk9IGZhbGxiYWNrX3N0YXJ0LAorCQkJCS5m YWxsYmFja19lbmQJPSBmYWxsYmFja19lbmQsCisJCQl9LAorCQkJW0VYRUNNRU1fS1BST0JFU10g PSB7CisJCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFSVCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQs CisJCQkJLnBncHJvdAk9IGtwcm9iZXNfcHJvdCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0s CisJCQlbRVhFQ01FTV9NT0RVTEVfREFUQV0gPSB7CisJCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFS VCwKKwkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAor CQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVt X2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gv cmlzY3Yva2VybmVsL21vZHVsZS5jIGIvYXJjaC9yaXNjdi9rZXJuZWwvbW9kdWxlLmMKaW5kZXgg MGU2NDE1ZjAwZmNhLi45MDZmOWEzYTVkNjUgMTAwNjQ0Ci0tLSBhL2FyY2gvcmlzY3Yva2VybmVs L21vZHVsZS5jCisrKyBiL2FyY2gvcmlzY3Yva2VybmVsL21vZHVsZS5jCkBAIC0xMSwxMCArMTEs OCBAQAogI2luY2x1ZGUgPGxpbnV4L2tlcm5lbC5oPgogI2luY2x1ZGUgPGxpbnV4L2xvZzIuaD4K ICNpbmNsdWRlIDxsaW51eC9tb2R1bGVsb2FkZXIuaD4KLSNpbmNsdWRlIDxsaW51eC92bWFsbG9j Lmg+CiAjaW5jbHVkZSA8bGludXgvc2l6ZXMuaD4KICNpbmNsdWRlIDxsaW51eC9wZ3RhYmxlLmg+ Ci0jaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogI2luY2x1ZGUgPGFzbS9hbHRlcm5hdGl2ZS5o PgogI2luY2x1ZGUgPGFzbS9zZWN0aW9ucy5oPgogCkBAIC05MDYsMzggKzkwNCw2IEBAIGludCBh cHBseV9yZWxvY2F0ZV9hZGQoRWxmX1NoZHIgKnNlY2hkcnMsIGNvbnN0IGNoYXIgKnN0cnRhYiwK IAlyZXR1cm4gMDsKIH0KIAotI2lmZGVmIENPTkZJR19NTVUKLXN0YXRpYyBzdHJ1Y3QgZXhlY21l bV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBleGVjbWVtX2lu Zm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQlleGVjbWVtX2luZm8gPSAo c3RydWN0IGV4ZWNtZW1faW5mbyl7Ci0JCS5yYW5nZXMgPSB7Ci0JCQlbRVhFQ01FTV9ERUZBVUxU XSA9IHsKLQkJCQkuc3RhcnQJPSBNT0RVTEVTX1ZBRERSLAotCQkJCS5lbmQJPSBNT0RVTEVTX0VO RCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFsaWdubWVudCA9IDEsCi0JCQl9 LAotCQkJW0VYRUNNRU1fS1BST0JFU10gPSB7Ci0JCQkJLnN0YXJ0CT0gVk1BTExPQ19TVEFSVCwK LQkJCQkuZW5kCT0gVk1BTExPQ19FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMX1JFQURf RVhFQywKLQkJCQkuYWxpZ25tZW50ID0gMSwKLQkJCX0sCi0JCQlbRVhFQ01FTV9CUEZdID0gewot CQkJCS5zdGFydAk9IEJQRl9KSVRfUkVHSU9OX1NUQVJULAotCQkJCS5lbmQJPSBCUEZfSklUX1JF R0lPTl9FTkQsCi0JCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSBQ QUdFX1NJWkUsCi0JCQl9LAotCQl9LAotCX07Ci0KLQlyZXR1cm4gJmV4ZWNtZW1faW5mbzsKLX0K LSNlbmRpZgotCiBpbnQgbW9kdWxlX2ZpbmFsaXplKGNvbnN0IEVsZl9FaGRyICpoZHIsCiAJCSAg ICBjb25zdCBFbGZfU2hkciAqc2VjaGRycywKIAkJICAgIHN0cnVjdCBtb2R1bGUgKm1lKQpkaWZm IC0tZ2l0IGEvYXJjaC9yaXNjdi9tbS9pbml0LmMgYi9hcmNoL3Jpc2N2L21tL2luaXQuYwppbmRl eCBmZThlMTU5Mzk0ZDguLmE4MjkwNjA5NTU0ZiAxMDA2NDQKLS0tIGEvYXJjaC9yaXNjdi9tbS9p bml0LmMKKysrIGIvYXJjaC9yaXNjdi9tbS9pbml0LmMKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNs dWRlIDxsaW51eC9lbGYuaD4KICNlbmRpZgogI2luY2x1ZGUgPGxpbnV4L2tmZW5jZS5oPgorI2lu Y2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFzbS9maXhtYXAuaD4KICNpbmNs dWRlIDxhc20vaW8uaD4KQEAgLTE0ODEsMyArMTQ4MiwzNyBAQCB2b2lkIF9faW5pdCBwZ3RhYmxl X2NhY2hlX2luaXQodm9pZCkKIAkJcHJlYWxsb2NhdGVfcGdkX3BhZ2VzX3JhbmdlKE1PRFVMRVNf VkFERFIsIE1PRFVMRVNfRU5ELCAiYnBmL21vZHVsZXMiKTsKIH0KICNlbmRpZgorCisjaWZkZWYg Q09ORklHX0VYRUNNRU0KKyNpZmRlZiBDT05GSUdfTU1VCitzdGF0aWMgc3RydWN0IGV4ZWNtZW1f aW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OworCitzdHJ1Y3QgZXhlY21lbV9pbmZv IF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCit7CisJZXhlY21lbV9pbmZvID0gKHN0 cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0g PSB7CisJCQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKKwkJCQkuZW5kCT0gTU9EVUxFU19FTkQs CisJCQkJLnBncHJvdAk9IFBBR0VfS0VSTkVMLAorCQkJCS5hbGlnbm1lbnQgPSAxLAorCQkJfSwK KwkJCVtFWEVDTUVNX0tQUk9CRVNdID0geworCQkJCS5zdGFydAk9IFZNQUxMT0NfU1RBUlQsCisJ CQkJLmVuZAk9IFZNQUxMT0NfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTF9SRUFEX0VY RUMsCisJCQkJLmFsaWdubWVudCA9IDEsCisJCQl9LAorCQkJW0VYRUNNRU1fQlBGXSA9IHsKKwkJ CQkuc3RhcnQJPSBCUEZfSklUX1JFR0lPTl9TVEFSVCwKKwkJCQkuZW5kCT0gQlBGX0pJVF9SRUdJ T05fRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gUEFH RV9TSVpFLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9Cisj ZW5kaWYgLyogQ09ORklHX01NVSAqLworI2VuZGlmIC8qIENPTkZJR19FWEVDTUVNICovCmRpZmYg LS1naXQgYS9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jIGIvYXJjaC9zMzkwL2tlcm5lbC9tb2R1 bGUuYwppbmRleCA3ZmVlNjRmZGMxYmIuLjkxZTIwN2I1MDM5NCAxMDA2NDQKLS0tIGEvYXJjaC9z MzkwL2tlcm5lbC9tb2R1bGUuYworKysgYi9hcmNoL3MzOTAva2VybmVsL21vZHVsZS5jCkBAIC0z NywzMyArMzcsNiBAQAogCiAjZGVmaW5lIFBMVF9FTlRSWV9TSVpFIDIyCiAKLXN0YXRpYyBzdHJ1 Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7Ci0KLXN0cnVjdCBl eGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkKLXsKLQl1bnNpZ25l ZCBsb25nIG1vZHVsZV9sb2FkX29mZnNldCA9IDA7Ci0JdW5zaWduZWQgbG9uZyBzdGFydDsKLQot CWlmIChrYXNscl9lbmFibGVkKCkpCi0JCW1vZHVsZV9sb2FkX29mZnNldCA9IGdldF9yYW5kb21f dTMyX2luY2x1c2l2ZSgxLCAxMDI0KSAqIFBBR0VfU0laRTsKLQotCXN0YXJ0ID0gTU9EVUxFU19W QUREUiArIG1vZHVsZV9sb2FkX29mZnNldDsKLQotCWV4ZWNtZW1faW5mbyA9IChzdHJ1Y3QgZXhl Y21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtFWEVDTUVNX0RFRkFVTFRdID0gewotCQkJ CS5mbGFncwk9IEVYRUNNRU1fS0FTQU5fU0hBRE9XLAotCQkJCS5zdGFydAk9IHN0YXJ0LAotCQkJ CS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUwsCi0JCQkJLmFs aWdubWVudCA9IE1PRFVMRV9BTElHTiwKLQkJCX0sCi0JCX0sCi0JfTsKLQotCXJldHVybiAmZXhl Y21lbV9pbmZvOwotfQotCiAjaWZkZWYgQ09ORklHX0ZVTkNUSU9OX1RSQUNFUgogdm9pZCBtb2R1 bGVfYXJjaF9jbGVhbnVwKHN0cnVjdCBtb2R1bGUgKm1vZCkKIHsKZGlmZiAtLWdpdCBhL2FyY2gv czM5MC9tbS9pbml0LmMgYi9hcmNoL3MzOTAvbW0vaW5pdC5jCmluZGV4IGY2MzkxNDQyYzBjMi4u ZTc2OWQyNzI2ZjRlIDEwMDY0NAotLS0gYS9hcmNoL3MzOTAvbW0vaW5pdC5jCisrKyBiL2FyY2gv czM5MC9tbS9pbml0LmMKQEAgLTQ5LDYgKzQ5LDcgQEAKICNpbmNsdWRlIDxhc20vdXYuaD4KICNp bmNsdWRlIDxsaW51eC92aXJ0aW9fYW5jaG9yLmg+CiAjaW5jbHVkZSA8bGludXgvdmlydGlvX2Nv bmZpZy5oPgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogcGdkX3Qgc3dhcHBlcl9wZ19k aXJbUFRSU19QRVJfUEdEXSBfX3NlY3Rpb24oIi5ic3MuLnN3YXBwZXJfcGdfZGlyIik7CiBwZ2Rf dCBpbnZhbGlkX3BnX2RpcltQVFJTX1BFUl9QR0RdIF9fc2VjdGlvbigiLmJzcy4uaW52YWxpZF9w Z19kaXIiKTsKQEAgLTMwMiwzICszMDMsMzIgQEAgdm9pZCBhcmNoX3JlbW92ZV9tZW1vcnkodTY0 IHN0YXJ0LCB1NjQgc2l6ZSwgc3RydWN0IHZtZW1fYWx0bWFwICphbHRtYXApCiAJdm1lbV9yZW1v dmVfbWFwcGluZyhzdGFydCwgc2l6ZSk7CiB9CiAjZW5kaWYgLyogQ09ORklHX01FTU9SWV9IT1RQ TFVHICovCisKKyNpZmRlZiBDT05GSUdfRVhFQ01FTQorc3RhdGljIHN0cnVjdCBleGVjbWVtX2lu Zm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBf X2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCXVuc2lnbmVkIGxvbmcgbW9kdWxl X2xvYWRfb2Zmc2V0ID0gMDsKKwl1bnNpZ25lZCBsb25nIHN0YXJ0OworCisJaWYgKGthc2xyX2Vu YWJsZWQoKSkKKwkJbW9kdWxlX2xvYWRfb2Zmc2V0ID0gZ2V0X3JhbmRvbV91MzJfaW5jbHVzaXZl KDEsIDEwMjQpICogUEFHRV9TSVpFOworCisJc3RhcnQgPSBNT0RVTEVTX1ZBRERSICsgbW9kdWxl X2xvYWRfb2Zmc2V0OworCisJZXhlY21lbV9pbmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8pewor CQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7CisJCQkJLmZsYWdzCT0gRVhF Q01FTV9LQVNBTl9TSEFET1csCisJCQkJLnN0YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IE1PRFVM RVNfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gTU9E VUxFX0FMSUdOLAorCQkJfSwKKwkJfSwKKwl9OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9 CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0gKi8KZGlmZiAtLWdpdCBhL2FyY2gvc3BhcmMva2Vy bmVsL21vZHVsZS5jIGIvYXJjaC9zcGFyYy9rZXJuZWwvbW9kdWxlLmMKaW5kZXggOGI3ZWU0NWRl ZmMzLi5iOGM1MWNjMjNkOTYgMTAwNjQ0Ci0tLSBhL2FyY2gvc3BhcmMva2VybmVsL21vZHVsZS5j CisrKyBiL2FyY2gvc3BhcmMva2VybmVsL21vZHVsZS5jCkBAIC0xNCw3ICsxNCw2IEBACiAjaW5j bHVkZSA8bGludXgvc3RyaW5nLmg+CiAjaW5jbHVkZSA8bGludXgvY3R5cGUuaD4KICNpbmNsdWRl IDxsaW51eC9tbS5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2luY2x1ZGUgPGFz bS9wcm9jZXNzb3IuaD4KICNpbmNsdWRlIDxhc20vc3BpdGZpcmUuaD4KQEAgLTIyLDI0ICsyMSw2 IEBACiAKICNpbmNsdWRlICJlbnRyeS5oIgogCi1zdGF0aWMgc3RydWN0IGV4ZWNtZW1faW5mbyBl eGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1Y3QgZXhlY21lbV9pbmZvIF9faW5p dCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JZXhlY21lbV9pbmZvID0gKHN0cnVjdCBl eGVjbWVtX2luZm8pewotCQkucmFuZ2VzID0gewotCQkJW0VYRUNNRU1fREVGQVVMVF0gPSB7Ci0J CQkJLnN0YXJ0CT0gTU9EVUxFU19WQUREUiwKLQkJCQkuZW5kCT0gTU9EVUxFU19FTkQsCi0JCQkJ LnBncHJvdAk9IFBBR0VfS0VSTkVMLAotCQkJCS5hbGlnbm1lbnQgPSAxLAotCQkJfSwKLQkJfSwK LQl9OwotCi0JcmV0dXJuICZleGVjbWVtX2luZm87Ci19Ci0KIC8qIE1ha2UgZ2VuZXJpYyBjb2Rl IGlnbm9yZSBTVFRfUkVHSVNURVIgZHVtbXkgdW5kZWZpbmVkIHN5bWJvbHMuICAqLwogaW50IG1v ZHVsZV9mcm9iX2FyY2hfc2VjdGlvbnMoRWxmX0VoZHIgKmhkciwKIAkJCSAgICAgIEVsZl9TaGRy ICpzZWNoZHJzLApkaWZmIC0tZ2l0IGEvYXJjaC9zcGFyYy9tbS9NYWtlZmlsZSBiL2FyY2gvc3Bh cmMvbW0vTWFrZWZpbGUKaW5kZXggODA5ZDk5M2Y2ZDg4Li4yZDE3NTIxMDhkNzcgMTAwNjQ0Ci0t LSBhL2FyY2gvc3BhcmMvbW0vTWFrZWZpbGUKKysrIGIvYXJjaC9zcGFyYy9tbS9NYWtlZmlsZQpA QCAtMTQsMyArMTQsNSBAQCBvYmotJChDT05GSUdfU1BBUkMzMikgICArPSBsZW9uX21tLm8KIAog IyBPbmx5IHVzZWQgYnkgc3BhcmM2NAogb2JqLSQoQ09ORklHX0hVR0VUTEJfUEFHRSkgKz0gaHVn ZXRsYnBhZ2UubworCitvYmotJChDT05GSUdfRVhFQ01FTSkJKz0gZXhlY21lbS5vCmRpZmYgLS1n aXQgYS9hcmNoL3NwYXJjL21tL2V4ZWNtZW0uYyBiL2FyY2gvc3BhcmMvbW0vZXhlY21lbS5jCm5l dyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGZhYzk3ZGQ1NzI4Ci0tLSAv ZGV2L251bGwKKysrIGIvYXJjaC9zcGFyYy9tbS9leGVjbWVtLmMKQEAgLTAsMCArMSwyMSBAQAor Ly8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKyNpbmNsdWRlIDxsaW51eC9tbS5o PgorI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KKworc3RhdGljIHN0cnVjdCBleGVjbWVtX2lu Zm8gZXhlY21lbV9pbmZvIF9fcm9fYWZ0ZXJfaW5pdDsKKworc3RydWN0IGV4ZWNtZW1faW5mbyBf X2luaXQgKmV4ZWNtZW1fYXJjaF9zZXR1cCh2b2lkKQoreworCWV4ZWNtZW1faW5mbyA9IChzdHJ1 Y3QgZXhlY21lbV9pbmZvKXsKKwkJLnJhbmdlcyA9IHsKKwkJCVtFWEVDTUVNX0RFRkFVTFRdID0g eworCQkJCS5zdGFydAk9IE1PRFVMRVNfVkFERFIsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5ELAor CQkJCS5wZ3Byb3QJPSBQQUdFX0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gMSwKKwkJCX0sCisJ CX0sCisJfTsKKworCXJldHVybiAmZXhlY21lbV9pbmZvOworfQpkaWZmIC0tZ2l0IGEvYXJjaC94 ODYva2VybmVsL21vZHVsZS5jIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCmluZGV4IDQ1YjFh N2MwMzM3OS4uODM3NDUwYjZlODgyIDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9rZXJuZWwvbW9kdWxl LmMKKysrIGIvYXJjaC94ODYva2VybmVsL21vZHVsZS5jCkBAIC0xOSw3ICsxOSw2IEBACiAjaW5j bHVkZSA8bGludXgvanVtcF9sYWJlbC5oPgogI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgogI2lu Y2x1ZGUgPGxpbnV4L21lbW9yeS5oPgotI2luY2x1ZGUgPGxpbnV4L2V4ZWNtZW0uaD4KIAogI2lu Y2x1ZGUgPGFzbS90ZXh0LXBhdGNoaW5nLmg+CiAjaW5jbHVkZSA8YXNtL3BhZ2UuaD4KQEAgLTM3 LDMyICszNiw2IEBAIGRvIHsJCQkJCQkJXAogfSB3aGlsZSAoMCkKICNlbmRpZgogCi1zdGF0aWMg c3RydWN0IGV4ZWNtZW1faW5mbyBleGVjbWVtX2luZm8gX19yb19hZnRlcl9pbml0OwotCi1zdHJ1 Y3QgZXhlY21lbV9pbmZvIF9faW5pdCAqZXhlY21lbV9hcmNoX3NldHVwKHZvaWQpCi17Ci0JdW5z aWduZWQgbG9uZyBzdGFydCwgb2Zmc2V0ID0gMDsKLQotCWlmIChrYXNscl9lbmFibGVkKCkpCi0J CW9mZnNldCA9IGdldF9yYW5kb21fdTMyX2luY2x1c2l2ZSgxLCAxMDI0KSAqIFBBR0VfU0laRTsK LQotCXN0YXJ0ID0gTU9EVUxFU19WQUREUiArIG9mZnNldDsKLQotCWV4ZWNtZW1faW5mbyA9IChz dHJ1Y3QgZXhlY21lbV9pbmZvKXsKLQkJLnJhbmdlcyA9IHsKLQkJCVtFWEVDTUVNX0RFRkFVTFRd ID0gewotCQkJCS5mbGFncwk9IEVYRUNNRU1fS0FTQU5fU0hBRE9XLAotCQkJCS5zdGFydAk9IHN0 YXJ0LAotCQkJCS5lbmQJPSBNT0RVTEVTX0VORCwKLQkJCQkucGdwcm90CT0gUEFHRV9LRVJORUws Ci0JCQkJLmFsaWdubWVudCA9IE1PRFVMRV9BTElHTiwKLQkJCX0sCi0JCX0sCi0JfTsKLQotCXJl dHVybiAmZXhlY21lbV9pbmZvOwotfQotCiAjaWZkZWYgQ09ORklHX1g4Nl8zMgogaW50IGFwcGx5 X3JlbG9jYXRlKEVsZjMyX1NoZHIgKnNlY2hkcnMsCiAJCSAgIGNvbnN0IGNoYXIgKnN0cnRhYiwK ZGlmZiAtLWdpdCBhL2FyY2gveDg2L21tL2luaXQuYyBiL2FyY2gveDg2L21tL2luaXQuYwppbmRl eCA2Nzk4OTNlYTVlNjguLmJlNGZlZTE3YjcxNyAxMDA2NDQKLS0tIGEvYXJjaC94ODYvbW0vaW5p dC5jCisrKyBiL2FyY2gveDg2L21tL2luaXQuYwpAQCAtNyw2ICs3LDcgQEAKICNpbmNsdWRlIDxs aW51eC9zd2Fwb3BzLmg+CiAjaW5jbHVkZSA8bGludXgva21lbWxlYWsuaD4KICNpbmNsdWRlIDxs aW51eC9zY2hlZC90YXNrLmg+CisjaW5jbHVkZSA8bGludXgvZXhlY21lbS5oPgogCiAjaW5jbHVk ZSA8YXNtL3NldF9tZW1vcnkuaD4KICNpbmNsdWRlIDxhc20vY3B1X2RldmljZV9pZC5oPgpAQCAt MTA5OSwzICsxMTAwLDMxIEBAIHVuc2lnbmVkIGxvbmcgYXJjaF9tYXhfc3dhcGZpbGVfc2l6ZSh2 b2lkKQogCXJldHVybiBwYWdlczsKIH0KICNlbmRpZgorCisjaWZkZWYgQ09ORklHX0VYRUNNRU0K K3N0YXRpYyBzdHJ1Y3QgZXhlY21lbV9pbmZvIGV4ZWNtZW1faW5mbyBfX3JvX2FmdGVyX2luaXQ7 CisKK3N0cnVjdCBleGVjbWVtX2luZm8gX19pbml0ICpleGVjbWVtX2FyY2hfc2V0dXAodm9pZCkK K3sKKwl1bnNpZ25lZCBsb25nIHN0YXJ0LCBvZmZzZXQgPSAwOworCisJaWYgKGthc2xyX2VuYWJs ZWQoKSkKKwkJb2Zmc2V0ID0gZ2V0X3JhbmRvbV91MzJfaW5jbHVzaXZlKDEsIDEwMjQpICogUEFH RV9TSVpFOworCisJc3RhcnQgPSBNT0RVTEVTX1ZBRERSICsgb2Zmc2V0OworCisJZXhlY21lbV9p bmZvID0gKHN0cnVjdCBleGVjbWVtX2luZm8peworCQkucmFuZ2VzID0geworCQkJW0VYRUNNRU1f REVGQVVMVF0gPSB7CisJCQkJLmZsYWdzCT0gRVhFQ01FTV9LQVNBTl9TSEFET1csCisJCQkJLnN0 YXJ0CT0gc3RhcnQsCisJCQkJLmVuZAk9IE1PRFVMRVNfRU5ELAorCQkJCS5wZ3Byb3QJPSBQQUdF X0tFUk5FTCwKKwkJCQkuYWxpZ25tZW50ID0gTU9EVUxFX0FMSUdOLAorCQkJfSwKKwkJfSwKKwl9 OworCisJcmV0dXJuICZleGVjbWVtX2luZm87Cit9CisjZW5kaWYgLyogQ09ORklHX0VYRUNNRU0g Ki8KLS0gCjIuNDMuMAoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlz dHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3Rp bmZvL2xpbnV4LWFybS1rZXJuZWwK