From mboxrd@z Thu Jan 1 00:00:00 1970 From: Qian Cai Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers Date: Wed, 26 Feb 2020 09:09:42 -0500 Message-ID: <1582726182.7365.123.camel@lca.pw> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> Sender: linux-kernel-owner@vger.kernel.org To: Anshuman Khandual , linux-mm@kvack.org Cc: Andrew Morton , Mike Rapoport , Vineet Gupta , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Michael Ellerman , Heiko Carstens , Vasily Gorbik , Christian Borntraeger , Thomas Gleixner , Ingo Molnar , Borislav Petkov , "H. Peter Anvin" , "Kirill A . Shutemov" , Paul Walmsley , Palmer Dabbelt , linux-snps-arc@lists.infradead.org, linux-arm-kern List-Id: linux-arch.vger.kernel.org On Mon, 2020-02-17 at 08:47 +0530, Anshuman Khandual wrote: > This adds tests which will validate architecture page table helpers and > other accessors in their compliance with expected generic MM semantics. > This will help various architectures in validating changes to existing > page table helpers or addition of new ones. > > This test covers basic page table entry transformations including but not > limited to old, young, dirty, clean, write, write protect etc at various > level along with populating intermediate entries with next page table page > and validating them. > > Test page table pages are allocated from system memory with required size > and alignments. The mapped pfns at page table levels are derived from a > real pfn representing a valid kernel text symbol. This test gets called > inside kernel_init() right after async_synchronize_full(). > > This test gets built and run when CONFIG_DEBUG_VM_PGTABLE is selected. Any > architecture, which is willing to subscribe this test will need to select > ARCH_HAS_DEBUG_VM_PGTABLE. For now this is limited to arc, arm64, x86, s390 > and ppc32 platforms where the test is known to build and run successfully. > Going forward, other architectures too can subscribe the test after fixing > any build or runtime problems with their page table helpers. Meanwhile for > better platform coverage, the test can also be enabled with CONFIG_EXPERT > even without ARCH_HAS_DEBUG_VM_PGTABLE. > > Folks interested in making sure that a given platform's page table helpers > conform to expected generic MM semantics should enable the above config > which will just trigger this test during boot. Any non conformity here will > be reported as an warning which would need to be fixed. This test will help > catch any changes to the agreed upon semantics expected from generic MM and > enable platforms to accommodate it thereafter. How useful is this that straightly crash the powerpc? [   23.263425][    T1] debug_vm_pgtable: debug_vm_pgtable: Validating architecture page table helpers [   23.263625][    T1] ------------[ cut here ]------------ [   23.263649][    T1] kernel BUG at arch/powerpc/mm/pgtable.c:274! [   23.263675][    T1] Oops: Exception in kernel mode, sig: 5 [#1] [   23.263698][    T1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=256 DEBUG_PAGEALLOC NUMA PowerNV [   23.263731][    T1] Modules linked in: [   23.263752][    T1] CPU: 4 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc3-next- 20200226 #1 [   23.263776][    T1] NIP:  c00000000007308c LR: c00000000103dbd8 CTR: 0000000000000000 [   23.263810][    T1] REGS: c00000003ddaf9c0 TRAP: 0700   Not tainted  (5.6.0- rc3-next-20200226) [   23.263846][    T1] MSR:  9000000000029033   CR: 22000228  XER: 00000000 [   23.263888][    T1] CFAR: c000000000073030 IRQMASK: 0  [   23.263888][    T1] GPR00: c00000000103dbd8 c00000003ddafc50 c000000001656f00 c000001d7b4ca080  [   23.263888][    T1] GPR04: 0000000000000000 0000000000000009 c00000003ddafc04 0000000000000000  [   23.263888][    T1] GPR08: f0ffffffffffffff 0000000000000001 c0000000016279d0 00000000000a0000  [   23.263888][    T1] GPR12: 0000000000000000 c000001fffffae00 c000000000010e84 0000000000000000  [   23.263888][    T1] GPR16: 0000000000000000 8000000000000105 0000000000000100 c000000001689a18  [   23.263888][    T1] GPR20: c00020032c660000 c00020032c620000 c000000001716030 c00020032c600000  [   23.263888][    T1] GPR24: 000000000000000d c000000001716030 c000001d7b4ca080 c000000001716040  [   23.263888][    T1] GPR28: c000000001716038 0000000000000000 0000000000000000 0000000000000000  [   23.264122][    T1] NIP [c00000000007308c] assert_pte_locked+0x11c/0x320 [   23.264154][    T1] LR [c00000000103dbd8] debug_vm_pgtable+0x770/0xb7c [   23.264186][    T1] Call Trace: [   23.264206][    T1] [c00000003ddafc50] [c000000000999760] _raw_spin_unlock+0x30/0x70 (unreliable) [   23.264244][    T1] [c00000003ddafcd0] [c00000000103d924] debug_vm_pgtable+0x4bc/0xb7c [   23.264279][    T1] [c00000003ddafdb0] [c000000000010eac] kernel_init+0x30/0x194 [   23.264315][    T1] [c00000003ddafe20] [c00000000000b748] ret_from_kernel_thread+0x5c/0x74 [   23.264349][    T1] Instruction dump: [   23.264368][    T1] 60000000 3be00001 7fbef436 eafa0040 7fffc030 3bffffff 7fff07b4 7ffff038  [   23.264409][    T1] 7bff1f24 7d37f82a 7d290074 7929d182 <0b090000> ebdb0000 e93c0000 7fde4a14  [   23.264460][    T1] ---[ end trace 72d2931022e9ab24 ]--- [   23.627311][    T1]  [   24.627407][    T1] Kernel panic - not syncing: Fatal exception [   26.5 > > Cc: Andrew Morton > Cc: Mike Rapoport > Cc: Vineet Gupta > Cc: Catalin Marinas > Cc: Will Deacon > Cc: Benjamin Herrenschmidt > Cc: Paul Mackerras > Cc: Michael Ellerman > Cc: Heiko Carstens > Cc: Vasily Gorbik > Cc: Christian Borntraeger > Cc: Thomas Gleixner > Cc: Ingo Molnar > Cc: Borislav Petkov > Cc: "H. Peter Anvin" > Cc: Kirill A. Shutemov > Cc: Paul Walmsley > Cc: Palmer Dabbelt > Cc: linux-snps-arc@lists.infradead.org > Cc: linux-arm-kernel@lists.infradead.org > Cc: linuxppc-dev@lists.ozlabs.org > Cc: linux-s390@vger.kernel.org > Cc: linux-riscv@lists.infradead.org > Cc: x86@kernel.org > Cc: linux-arch@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > > Suggested-by: Catalin Marinas > Reviewed-by: Ingo Molnar > Tested-by: Gerald Schaefer # s390 > Tested-by: Christophe Leroy # ppc32 > Signed-off-by: Andrew Morton > Signed-off-by: Christophe Leroy > Signed-off-by: Anshuman Khandual > --- > This adds a test validation for architecture exported page table helpers. > Patch adds basic transformation tests at various levels of the page table. > > This test was originally suggested by Catalin during arm64 THP migration > RFC discussion earlier. Going forward it can include more specific tests > with respect to various generic MM functions like THP, HugeTLB etc and > platform specific tests. > > https://lore.kernel.org/linux-mm/20190628102003.GA56463@arrakis.emea.arm.com/ > > Needs to be applied on linux V5.6-rc2 > > Changes in V14: > > - Disabled DEBUG_VM_PGFLAGS for IA64 and ARM (32 Bit) per Andrew and Christophe > - Updated DEBUG_VM_PGFLAGS documentation wrt EXPERT and disabled platforms > - Updated RANDOM_[OR|NZ]VALUE open encodings with GENMASK() per Catalin > - Updated s390 constraint bits from 12 to 4 (S390_MASK_BITS) per Gerald > - Updated in-code documentation for RANDOM_ORVALUE per Gerald > - Updated pxx_basic_tests() to use invert functions first per Catalin > - Dropped ARCH_HAS_4LEVEL_HACK check from pud_basic_tests() > - Replaced __ARCH_HAS_[4|5]LEVEL_HACK with __PAGETABLE_[PUD|P4D]_FOLDED per Catalin > - Trimmed the CC list on the commit message per Catalin > > Changes in V13: (https://patchwork.kernel.org/project/linux-mm/list/?series=237125) > > - Subscribed s390 platform and updated debug-vm-pgtable/arch-support.txt per Gerald > - Dropped keyword 'extern' from debug_vm_pgtable() declaration per Christophe > - Moved debug_vm_pgtable() declarations to per Christophe > - Moved debug_vm_pgtable() call site into kernel_init() per Christophe > - Changed CONFIG_DEBUG_VM_PGTABLE rules per Christophe > - Updated commit to include new supported platforms and changed config selection > > Changes in V12: (https://patchwork.kernel.org/project/linux-mm/list/?series=233905) > > - Replaced __mmdrop() with mmdrop() > - Enable ARCH_HAS_DEBUG_VM_PGTABLE on X86 for non CONFIG_X86_PAE platforms as the > test procedure interfere with pre-allocated PMDs attached to the PGD resulting > in runtime failures with VM_BUG_ON() > > Changes in V11: (https://patchwork.kernel.org/project/linux-mm/list/?series=221135) > > - Rebased the patch on V5.4 > > Changes in V10: (https://patchwork.kernel.org/project/linux-mm/list/?series=205529) > > - Always enable DEBUG_VM_PGTABLE when DEBUG_VM is enabled per Ingo > - Added tags from Ingo > > Changes in V9: (https://patchwork.kernel.org/project/linux-mm/list/?series=201429) > > - Changed feature support enumeration for powerpc platforms per Christophe > - Changed config wrapper for basic_[pmd|pud]_tests() to enable ARC platform > - Enabled the test on ARC platform > > Changes in V8: (https://patchwork.kernel.org/project/linux-mm/list/?series=194297) > > - Enabled ARCH_HAS_DEBUG_VM_PGTABLE on PPC32 platform per Christophe > - Updated feature documentation as DEBUG_VM_PGTABLE is now enabled on PPC32 platform > - Moved ARCH_HAS_DEBUG_VM_PGTABLE earlier to indent it with DEBUG_VM per Christophe > - Added an information message in debug_vm_pgtable() per Christophe > - Dropped random_vaddr boundary condition checks per Christophe and Qian > - Replaced virt_addr_valid() check with pfn_valid() check in debug_vm_pgtable() > - Slightly changed pr_fmt(fmt) information > > Changes in V7: (https://patchwork.kernel.org/project/linux-mm/list/?series=193051) > > - Memory allocation and free routines for mapped pages have been droped > - Mapped pfns are derived from standard kernel text symbol per Matthew > - Moved debug_vm_pgtaable() after page_alloc_init_late() per Michal and Qian > - Updated the commit message per Michal > - Updated W=1 GCC warning problem on x86 per Qian Cai > - Addition of new alloc_contig_pages() helper has been submitted separately > > Changes in V6: (https://patchwork.kernel.org/project/linux-mm/list/?series=187589) > > - Moved alloc_gigantic_page_order() into mm/page_alloc.c per Michal > - Moved alloc_gigantic_page_order() within CONFIG_CONTIG_ALLOC in the test > - Folded Andrew's include/asm-generic/pgtable.h fix into the test patch 2/2 > > Changes in V5: (https://patchwork.kernel.org/project/linux-mm/list/?series=185991) > > - Redefined and moved X86 mm_p4d_folded() into a different header per Kirill/Ingo > - Updated the config option comment per Ingo and dropped 'kernel module' reference > - Updated the commit message and dropped 'kernel module' reference > - Changed DEBUG_ARCH_PGTABLE_TEST into DEBUG_VM_PGTABLE per Ingo > - Moved config option from mm/Kconfig.debug into lib/Kconfig.debug > - Renamed core test function arch_pgtable_tests() as debug_vm_pgtable() > - Renamed mm/arch_pgtable_test.c as mm/debug_vm_pgtable.c > - debug_vm_pgtable() gets called from kernel_init_freeable() after init_mm_internals() > - Added an entry in Documentation/features/debug/ per Ingo > - Enabled the test on arm64 and x86 platforms for now > > Changes in V4: (https://patchwork.kernel.org/project/linux-mm/list/?series=183465) > > - Disable DEBUG_ARCH_PGTABLE_TEST for ARM and IA64 platforms > > Changes in V3: (https://lore.kernel.org/patchwork/project/lkml/list/?series=411216) > > - Changed test trigger from module format into late_initcall() > - Marked all functions with __init to be freed after completion > - Changed all __PGTABLE_PXX_FOLDED checks as mm_pxx_folded() > - Folded in PPC32 fixes from Christophe > > Changes in V2: > > https://lore.kernel.org/linux-mm/1568268173-31302-1-git-send-email-anshuman.khandual@arm.com/T/#t > > - Fixed small typo error in MODULE_DESCRIPTION() > - Fixed m64k build problems for lvalue concerns in pmd_xxx_tests() > - Fixed dynamic page table level folding problems on x86 as per Kirril > - Fixed second pointers during pxx_populate_tests() per Kirill and Gerald > - Allocate and free pte table with pte_alloc_one/pte_free per Kirill > - Modified pxx_clear_tests() to accommodate s390 lower 12 bits situation > - Changed RANDOM_NZVALUE value from 0xbe to 0xff > - Changed allocation, usage, free sequence for saved_ptep > - Renamed VMA_FLAGS as VMFLAGS > - Implemented a new method for random vaddr generation > - Implemented some other cleanups > - Dropped extern reference to mm_alloc() > - Created and exported new alloc_gigantic_page_order() > - Dropped the custom allocator and used new alloc_gigantic_page_order() > > Changes in V1: > > https://lore.kernel.org/linux-mm/1567497706-8649-1-git-send-email-anshuman.khandual@arm.com/ > > - Added fallback mechanism for PMD aligned memory allocation failure > > Changes in RFC V2: > > https://lore.kernel.org/linux-mm/1565335998-22553-1-git-send-email-anshuman.khandual@arm.com/T/#u > > - Moved test module and it's config from lib/ to mm/ > - Renamed config TEST_ARCH_PGTABLE as DEBUG_ARCH_PGTABLE_TEST > - Renamed file from test_arch_pgtable.c to arch_pgtable_test.c > - Added relevant MODULE_DESCRIPTION() and MODULE_AUTHOR() details > - Dropped loadable module config option > - Basic tests now use memory blocks with required size and alignment > - PUD aligned memory block gets allocated with alloc_contig_range() > - If PUD aligned memory could not be allocated it falls back on PMD aligned > memory block from page allocator and pud_* tests are skipped > - Clear and populate tests now operate on real in memory page table entries > - Dummy mm_struct gets allocated with mm_alloc() > - Dummy page table entries get allocated with [pud|pmd|pte]_alloc_[map]() > - Simplified [p4d|pgd]_basic_tests(), now has random values in the entries > > Original RFC V1: > > https://lore.kernel.org/linux-mm/1564037723-26676-1-git-send-email-anshuman.khandual@arm.com/ > > > .../debug/debug-vm-pgtable/arch-support.txt | 35 ++ > arch/arc/Kconfig | 1 + > arch/arm64/Kconfig | 1 + > arch/powerpc/Kconfig | 1 + > arch/s390/Kconfig | 1 + > arch/x86/Kconfig | 1 + > arch/x86/include/asm/pgtable_64.h | 6 + > include/linux/mmdebug.h | 5 + > init/main.c | 2 + > lib/Kconfig.debug | 26 ++ > mm/Makefile | 1 + > mm/debug_vm_pgtable.c | 389 ++++++++++++++++++ > 12 files changed, 469 insertions(+) > create mode 100644 Documentation/features/debug/debug-vm-pgtable/arch-support.txt > create mode 100644 mm/debug_vm_pgtable.c > > diff --git a/Documentation/features/debug/debug-vm-pgtable/arch-support.txt b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > new file mode 100644 > index 000000000000..64d0f9b15c49 > --- /dev/null > +++ b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > @@ -0,0 +1,35 @@ > +# > +# Feature name: debug-vm-pgtable > +# Kconfig: ARCH_HAS_DEBUG_VM_PGTABLE > +# description: arch supports pgtable tests for semantics compliance > +# > + ----------------------- > + | arch |status| > + ----------------------- > + | alpha: | TODO | > + | arc: | ok | > + | arm: | TODO | > + | arm64: | ok | > + | c6x: | TODO | > + | csky: | TODO | > + | h8300: | TODO | > + | hexagon: | TODO | > + | ia64: | TODO | > + | m68k: | TODO | > + | microblaze: | TODO | > + | mips: | TODO | > + | nds32: | TODO | > + | nios2: | TODO | > + | openrisc: | TODO | > + | parisc: | TODO | > + | powerpc/32: | ok | > + | powerpc/64: | TODO | > + | riscv: | TODO | > + | s390: | ok | > + | sh: | TODO | > + | sparc: | TODO | > + | um: | TODO | > + | unicore32: | TODO | > + | x86: | ok | > + | xtensa: | TODO | > + ----------------------- > diff --git a/arch/arc/Kconfig b/arch/arc/Kconfig > index ff2a393b635c..3e72e6cf0e42 100644 > --- a/arch/arc/Kconfig > +++ b/arch/arc/Kconfig > @@ -6,6 +6,7 @@ > config ARC > def_bool y > select ARC_TIMERS > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_PTE_SPECIAL > select ARCH_HAS_SETUP_DMA_OPS > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index 0b30e884e088..aaf8ba415145 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -11,6 +11,7 @@ config ARM64 > select ACPI_PPTT if ACPI > select ARCH_CLOCKSOURCE_DATA > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig > index 497b7d0b2d7e..8d5ae14c5d4c 100644 > --- a/arch/powerpc/Kconfig > +++ b/arch/powerpc/Kconfig > @@ -116,6 +116,7 @@ config PPC > # > select ARCH_32BIT_OFF_T if PPC32 > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if PPC32 > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig > index 8abe77536d9d..af284dbb07e7 100644 > --- a/arch/s390/Kconfig > +++ b/arch/s390/Kconfig > @@ -59,6 +59,7 @@ config KASAN_SHADOW_OFFSET > config S390 > def_bool y > select ARCH_BINFMT_ELF_STATE > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index beea77046f9b..df8a19e52e82 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -61,6 +61,7 @@ config X86 > select ARCH_CLOCKSOURCE_INIT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if !X86_PAE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FAST_MULTIPLIER > diff --git a/arch/x86/include/asm/pgtable_64.h b/arch/x86/include/asm/pgtable_64.h > index 0b6c4042942a..fb0e76d254b3 100644 > --- a/arch/x86/include/asm/pgtable_64.h > +++ b/arch/x86/include/asm/pgtable_64.h > @@ -53,6 +53,12 @@ static inline void sync_initial_page_table(void) { } > > struct mm_struct; > > +#define mm_p4d_folded mm_p4d_folded > +static inline bool mm_p4d_folded(struct mm_struct *mm) > +{ > + return !pgtable_l5_enabled(); > +} > + > void set_pte_vaddr_p4d(p4d_t *p4d_page, unsigned long vaddr, pte_t new_pte); > void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte); > > diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h > index 2ad72d2c8cc5..5339aa14b749 100644 > --- a/include/linux/mmdebug.h > +++ b/include/linux/mmdebug.h > @@ -64,4 +64,9 @@ void dump_mm(const struct mm_struct *mm); > #define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond) > #endif > > +#ifdef CONFIG_DEBUG_VM_PGTABLE > +void debug_vm_pgtable(void); > +#else > +static inline void debug_vm_pgtable(void) { } > +#endif > #endif > diff --git a/init/main.c b/init/main.c > index cc0ee4873419..adf37e8b1d69 100644 > --- a/init/main.c > +++ b/init/main.c > @@ -94,6 +94,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -1323,6 +1324,7 @@ static int __ref kernel_init(void *unused) > kernel_init_freeable(); > /* need to finish all async __init code before freeing the memory */ > async_synchronize_full(); > + debug_vm_pgtable(); > ftrace_free_init_mem(); > free_initmem(); > mark_readonly(); > diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug > index 69def4a9df00..1b5bd9f7c967 100644 > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -653,6 +653,12 @@ config SCHED_STACK_END_CHECK > data corruption or a sporadic crash at a later stage once the region > is examined. The runtime overhead introduced is minimal. > > +config ARCH_HAS_DEBUG_VM_PGTABLE > + bool > + help > + An architecture should select this when it can successfully > + build and run DEBUG_VM_PGTABLE. > + > config DEBUG_VM > bool "Debug VM" > depends on DEBUG_KERNEL > @@ -688,6 +694,26 @@ config DEBUG_VM_PGFLAGS > > If unsure, say N. > > +config DEBUG_VM_PGTABLE > + bool "Debug arch page table for semantics compliance" > + depends on MMU > + depends on !IA64 && !ARM > + depends on ARCH_HAS_DEBUG_VM_PGTABLE || EXPERT > + default n if !ARCH_HAS_DEBUG_VM_PGTABLE > + default y if DEBUG_VM > + help > + This option provides a debug method which can be used to test > + architecture page table helper functions on various platforms in > + verifying if they comply with expected generic MM semantics. This > + will help architecture code in making sure that any changes or > + new additions of these helpers still conform to expected > + semantics of the generic MM. Platforms will have to opt in for > + this through ARCH_HAS_DEBUG_VM_PGTABLE. Although it can also be > + enabled through EXPERT without requiring code change. This test > + is disabled on IA64 and ARM platforms where it fails to build. > + > + If unsure, say N. > + > config ARCH_HAS_DEBUG_VIRTUAL > bool > > diff --git a/mm/Makefile b/mm/Makefile > index 272e66039e70..b0692e6a4b58 100644 > --- a/mm/Makefile > +++ b/mm/Makefile > @@ -87,6 +87,7 @@ obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o > obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o > obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak-test.o > obj-$(CONFIG_DEBUG_RODATA_TEST) += rodata_test.o > +obj-$(CONFIG_DEBUG_VM_PGTABLE) += debug_vm_pgtable.o > obj-$(CONFIG_PAGE_OWNER) += page_owner.o > obj-$(CONFIG_CLEANCACHE) += cleancache.o > obj-$(CONFIG_MEMORY_ISOLATION) += page_isolation.o > diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c > new file mode 100644 > index 000000000000..70bf8ed8fd51 > --- /dev/null > +++ b/mm/debug_vm_pgtable.c > @@ -0,0 +1,389 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * This kernel test validates architecture page table helpers and > + * accessors and helps in verifying their continued compliance with > + * expected generic MM semantics. > + * > + * Copyright (C) 2019 ARM Ltd. > + * > + * Author: Anshuman Khandual > + */ > +#define pr_fmt(fmt) "debug_vm_pgtable: %s: " fmt, __func__ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * Basic operations > + * > + * mkold(entry) = An old and not a young entry > + * mkyoung(entry) = A young and not an old entry > + * mkdirty(entry) = A dirty and not a clean entry > + * mkclean(entry) = A clean and not a dirty entry > + * mkwrite(entry) = A write and not a write protected entry > + * wrprotect(entry) = A write protected and not a write entry > + * pxx_bad(entry) = A mapped and non-table entry > + * pxx_same(entry1, entry2) = Both entries hold the exact same value > + */ > +#define VMFLAGS (VM_READ|VM_WRITE|VM_EXEC) > + > +/* > + * On s390 platform, the lower 4 bits are used to identify given page table > + * entry type. But these bits might affect the ability to clear entries with > + * pxx_clear() because of how dynamic page table folding works on s390. So > + * while loading up the entries do not change the lower 4 bits. It does not > + * have affect any other platform. > + */ > +#define S390_MASK_BITS 4 > +#define RANDOM_ORVALUE GENMASK(BITS_PER_LONG - 1, S390_MASK_BITS) > +#define RANDOM_NZVALUE GENMASK(7, 0) > + > +static void __init pte_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pte_t pte = pfn_pte(pfn, prot); > + > + WARN_ON(!pte_same(pte, pte)); > + WARN_ON(!pte_young(pte_mkyoung(pte_mkold(pte)))); > + WARN_ON(!pte_dirty(pte_mkdirty(pte_mkclean(pte)))); > + WARN_ON(!pte_write(pte_mkwrite(pte_wrprotect(pte)))); > + WARN_ON(pte_young(pte_mkold(pte_mkyoung(pte)))); > + WARN_ON(pte_dirty(pte_mkclean(pte_mkdirty(pte)))); > + WARN_ON(pte_write(pte_wrprotect(pte_mkwrite(pte)))); > +} > + > +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pmd_t pmd = pfn_pmd(pfn, prot); > + > + WARN_ON(!pmd_same(pmd, pmd)); > + WARN_ON(!pmd_young(pmd_mkyoung(pmd_mkold(pmd)))); > + WARN_ON(!pmd_dirty(pmd_mkdirty(pmd_mkclean(pmd)))); > + WARN_ON(!pmd_write(pmd_mkwrite(pmd_wrprotect(pmd)))); > + WARN_ON(pmd_young(pmd_mkold(pmd_mkyoung(pmd)))); > + WARN_ON(pmd_dirty(pmd_mkclean(pmd_mkdirty(pmd)))); > + WARN_ON(pmd_write(pmd_wrprotect(pmd_mkwrite(pmd)))); > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pmd_bad(). > + */ > + WARN_ON(!pmd_bad(pmd_mkhuge(pmd))); > +} > + > +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pud_t pud = pfn_pud(pfn, prot); > + > + WARN_ON(!pud_same(pud, pud)); > + WARN_ON(!pud_young(pud_mkyoung(pud_mkold(pud)))); > + WARN_ON(!pud_write(pud_mkwrite(pud_wrprotect(pud)))); > + WARN_ON(pud_write(pud_wrprotect(pud_mkwrite(pud)))); > + WARN_ON(pud_young(pud_mkold(pud_mkyoung(pud)))); > + > + if (mm_pmd_folded(mm)) > + return; > + > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pud_bad(). > + */ > + WARN_ON(!pud_bad(pud_mkhuge(pud))); > +} > +#else > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > +#else > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) { } > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > + > +static void __init p4d_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + p4d_t p4d; > + > + memset(&p4d, RANDOM_NZVALUE, sizeof(p4d_t)); > + WARN_ON(!p4d_same(p4d, p4d)); > +} > + > +static void __init pgd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pgd_t pgd; > + > + memset(&pgd, RANDOM_NZVALUE, sizeof(pgd_t)); > + WARN_ON(!pgd_same(pgd, pgd)); > +} > + > +#ifndef __PAGETABLE_PUD_FOLDED > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) > +{ > + pud_t pud = READ_ONCE(*pudp); > + > + if (mm_pmd_folded(mm)) > + return; > + > + pud = __pud(pud_val(pud) | RANDOM_ORVALUE); > + WRITE_ONCE(*pudp, pud); > + pud_clear(pudp); > + pud = READ_ONCE(*pudp); > + WARN_ON(!pud_none(pud)); > +} > + > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > + pud_t pud; > + > + if (mm_pmd_folded(mm)) > + return; > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pud_bad(). > + */ > + pmd_clear(pmdp); > + pud_clear(pudp); > + pud_populate(mm, pudp, pmdp); > + pud = READ_ONCE(*pudp); > + WARN_ON(pud_bad(pud)); > +} > +#else > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) { } > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > +} > +#endif > + > +#ifndef __PAGETABLE_P4D_FOLDED > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) > +{ > + p4d_t p4d = READ_ONCE(*p4dp); > + > + if (mm_pud_folded(mm)) > + return; > + > + p4d = __p4d(p4d_val(p4d) | RANDOM_ORVALUE); > + WRITE_ONCE(*p4dp, p4d); > + p4d_clear(p4dp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(!p4d_none(p4d)); > +} > + > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > + p4d_t p4d; > + > + if (mm_pud_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as p4d_bad(). > + */ > + pud_clear(pudp); > + p4d_clear(p4dp); > + p4d_populate(mm, p4dp, pudp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(p4d_bad(p4d)); > +} > + > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) > +{ > + pgd_t pgd = READ_ONCE(*pgdp); > + > + if (mm_p4d_folded(mm)) > + return; > + > + pgd = __pgd(pgd_val(pgd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pgdp, pgd); > + pgd_clear(pgdp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(!pgd_none(pgd)); > +} > + > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > + pgd_t pgd; > + > + if (mm_p4d_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pgd_bad(). > + */ > + p4d_clear(p4dp); > + pgd_clear(pgdp); > + pgd_populate(mm, pgdp, p4dp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(pgd_bad(pgd)); > +} > +#else > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) { } > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) { } > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > +} > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > +} > +#endif > + > +static void __init pte_clear_tests(struct mm_struct *mm, pte_t *ptep) > +{ > + pte_t pte = READ_ONCE(*ptep); > + > + pte = __pte(pte_val(pte) | RANDOM_ORVALUE); > + WRITE_ONCE(*ptep, pte); > + pte_clear(mm, 0, ptep); > + pte = READ_ONCE(*ptep); > + WARN_ON(!pte_none(pte)); > +} > + > +static void __init pmd_clear_tests(struct mm_struct *mm, pmd_t *pmdp) > +{ > + pmd_t pmd = READ_ONCE(*pmdp); > + > + pmd = __pmd(pmd_val(pmd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pmdp, pmd); > + pmd_clear(pmdp); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(!pmd_none(pmd)); > +} > + > +static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, > + pgtable_t pgtable) > +{ > + pmd_t pmd; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pmd_bad(). > + */ > + pmd_clear(pmdp); > + pmd_populate(mm, pmdp, pgtable); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(pmd_bad(pmd)); > +} > + > +static unsigned long __init get_random_vaddr(void) > +{ > + unsigned long random_vaddr, random_pages, total_user_pages; > + > + total_user_pages = (TASK_SIZE - FIRST_USER_ADDRESS) / PAGE_SIZE; > + > + random_pages = get_random_long() % total_user_pages; > + random_vaddr = FIRST_USER_ADDRESS + random_pages * PAGE_SIZE; > + > + return random_vaddr; > +} > + > +void __init debug_vm_pgtable(void) > +{ > + struct mm_struct *mm; > + pgd_t *pgdp; > + p4d_t *p4dp, *saved_p4dp; > + pud_t *pudp, *saved_pudp; > + pmd_t *pmdp, *saved_pmdp, pmd; > + pte_t *ptep; > + pgtable_t saved_ptep; > + pgprot_t prot; > + phys_addr_t paddr; > + unsigned long vaddr, pte_aligned, pmd_aligned; > + unsigned long pud_aligned, p4d_aligned, pgd_aligned; > + > + pr_info("Validating architecture page table helpers\n"); > + prot = vm_get_page_prot(VMFLAGS); > + vaddr = get_random_vaddr(); > + mm = mm_alloc(); > + if (!mm) { > + pr_err("mm_struct allocation failed\n"); > + return; > + } > + > + /* > + * PFN for mapping at PTE level is determined from a standard kernel > + * text symbol. But pfns for higher page table levels are derived by > + * masking lower bits of this real pfn. These derived pfns might not > + * exist on the platform but that does not really matter as pfn_pxx() > + * helpers will still create appropriate entries for the test. This > + * helps avoid large memory block allocations to be used for mapping > + * at higher page table levels. > + */ > + paddr = __pa(&start_kernel); > + > + pte_aligned = (paddr & PAGE_MASK) >> PAGE_SHIFT; > + pmd_aligned = (paddr & PMD_MASK) >> PAGE_SHIFT; > + pud_aligned = (paddr & PUD_MASK) >> PAGE_SHIFT; > + p4d_aligned = (paddr & P4D_MASK) >> PAGE_SHIFT; > + pgd_aligned = (paddr & PGDIR_MASK) >> PAGE_SHIFT; > + WARN_ON(!pfn_valid(pte_aligned)); > + > + pgdp = pgd_offset(mm, vaddr); > + p4dp = p4d_alloc(mm, pgdp, vaddr); > + pudp = pud_alloc(mm, p4dp, vaddr); > + pmdp = pmd_alloc(mm, pudp, vaddr); > + ptep = pte_alloc_map(mm, pmdp, vaddr); > + > + /* > + * Save all the page table page addresses as the page table > + * entries will be used for testing with random or garbage > + * values. These saved addresses will be used for freeing > + * page table pages. > + */ > + pmd = READ_ONCE(*pmdp); > + saved_p4dp = p4d_offset(pgdp, 0UL); > + saved_pudp = pud_offset(p4dp, 0UL); > + saved_pmdp = pmd_offset(pudp, 0UL); > + saved_ptep = pmd_pgtable(pmd); > + > + pte_basic_tests(pte_aligned, prot); > + pmd_basic_tests(pmd_aligned, prot); > + pud_basic_tests(pud_aligned, prot); > + p4d_basic_tests(p4d_aligned, prot); > + pgd_basic_tests(pgd_aligned, prot); > + > + pte_clear_tests(mm, ptep); > + pmd_clear_tests(mm, pmdp); > + pud_clear_tests(mm, pudp); > + p4d_clear_tests(mm, p4dp); > + pgd_clear_tests(mm, pgdp); > + > + pte_unmap(ptep); > + > + pmd_populate_tests(mm, pmdp, saved_ptep); > + pud_populate_tests(mm, pudp, saved_pmdp); > + p4d_populate_tests(mm, p4dp, saved_pudp); > + pgd_populate_tests(mm, pgdp, saved_p4dp); > + > + p4d_free(mm, saved_p4dp); > + pud_free(mm, saved_pudp); > + pmd_free(mm, saved_pmdp); > + pte_free(mm, saved_ptep); > + > + mm_dec_nr_puds(mm); > + mm_dec_nr_pmds(mm); > + mm_dec_nr_ptes(mm); > + mmdrop(mm); > +} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Message-ID: <1582726182.7365.123.camel@lca.pw> Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers From: Qian Cai Date: Wed, 26 Feb 2020 09:09:42 -0500 In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> Content-Type: text/plain; charset="UTF-8" Mime-Version: 1.0 Content-Transfer-Encoding: 8bit List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-riscv" Errors-To: linux-riscv-bounces+rppt=linux.ibm.com@lists.infradead.org To: Anshuman Khandual , linux-mm@kvack.org Cc: Catalin Marinas , Heiko Carstens , Paul Mackerras , "H. Peter Anvin" , linux-riscv@lists.infradead.org, Will Deacon , linux-arch@vger.kernel.org, linux-s390@vger.kernel.org, Michael Ellerman , x86@kernel.org, Mike Rapoport , Christian Borntraeger , Ingo Molnar , Benjamin Herrenschmidt , linux-snps-arc@lists.infradead.org, Vasily Gorbik , Borislav Petkov , Paul Walmsley , "Kirill A . Shutemov" , Thomas Gleixner , linux-arm-kernel@lists.infradead.org, Christophe Leroy , Vineet Gupta , linux-kernel@vger.kernel.org, Palmer Dabbelt , Andrew Morton , linuxppc-dev@lists.ozlabs.org List-ID: Message-ID: <20200226140942.jBK9L9NDru7XxGy2jokOrTH7j6VaUmuHzv-wpFrjmn8@z> On Mon, 2020-02-17 at 08:47 +0530, Anshuman Khandual wrote: > This adds tests which will validate architecture page table helpers and > other accessors in their compliance with expected generic MM semantics. > This will help various architectures in validating changes to existing > page table helpers or addition of new ones. > > This test covers basic page table entry transformations including but not > limited to old, young, dirty, clean, write, write protect etc at various > level along with populating intermediate entries with next page table page > and validating them. > > Test page table pages are allocated from system memory with required size > and alignments. The mapped pfns at page table levels are derived from a > real pfn representing a valid kernel text symbol. This test gets called > inside kernel_init() right after async_synchronize_full(). > > This test gets built and run when CONFIG_DEBUG_VM_PGTABLE is selected. Any > architecture, which is willing to subscribe this test will need to select > ARCH_HAS_DEBUG_VM_PGTABLE. For now this is limited to arc, arm64, x86, s390 > and ppc32 platforms where the test is known to build and run successfully. > Going forward, other architectures too can subscribe the test after fixing > any build or runtime problems with their page table helpers. Meanwhile for > better platform coverage, the test can also be enabled with CONFIG_EXPERT > even without ARCH_HAS_DEBUG_VM_PGTABLE. > > Folks interested in making sure that a given platform's page table helpers > conform to expected generic MM semantics should enable the above config > which will just trigger this test during boot. Any non conformity here will > be reported as an warning which would need to be fixed. This test will help > catch any changes to the agreed upon semantics expected from generic MM and > enable platforms to accommodate it thereafter. How useful is this that straightly crash the powerpc? [   23.263425][    T1] debug_vm_pgtable: debug_vm_pgtable: Validating architecture page table helpers [   23.263625][    T1] ------------[ cut here ]------------ [   23.263649][    T1] kernel BUG at arch/powerpc/mm/pgtable.c:274! [   23.263675][    T1] Oops: Exception in kernel mode, sig: 5 [#1] [   23.263698][    T1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=256 DEBUG_PAGEALLOC NUMA PowerNV [   23.263731][    T1] Modules linked in: [   23.263752][    T1] CPU: 4 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc3-next- 20200226 #1 [   23.263776][    T1] NIP:  c00000000007308c LR: c00000000103dbd8 CTR: 0000000000000000 [   23.263810][    T1] REGS: c00000003ddaf9c0 TRAP: 0700   Not tainted  (5.6.0- rc3-next-20200226) [   23.263846][    T1] MSR:  9000000000029033   CR: 22000228  XER: 00000000 [   23.263888][    T1] CFAR: c000000000073030 IRQMASK: 0  [   23.263888][    T1] GPR00: c00000000103dbd8 c00000003ddafc50 c000000001656f00 c000001d7b4ca080  [   23.263888][    T1] GPR04: 0000000000000000 0000000000000009 c00000003ddafc04 0000000000000000  [   23.263888][    T1] GPR08: f0ffffffffffffff 0000000000000001 c0000000016279d0 00000000000a0000  [   23.263888][    T1] GPR12: 0000000000000000 c000001fffffae00 c000000000010e84 0000000000000000  [   23.263888][    T1] GPR16: 0000000000000000 8000000000000105 0000000000000100 c000000001689a18  [   23.263888][    T1] GPR20: c00020032c660000 c00020032c620000 c000000001716030 c00020032c600000  [   23.263888][    T1] GPR24: 000000000000000d c000000001716030 c000001d7b4ca080 c000000001716040  [   23.263888][    T1] GPR28: c000000001716038 0000000000000000 0000000000000000 0000000000000000  [   23.264122][    T1] NIP [c00000000007308c] assert_pte_locked+0x11c/0x320 [   23.264154][    T1] LR [c00000000103dbd8] debug_vm_pgtable+0x770/0xb7c [   23.264186][    T1] Call Trace: [   23.264206][    T1] [c00000003ddafc50] [c000000000999760] _raw_spin_unlock+0x30/0x70 (unreliable) [   23.264244][    T1] [c00000003ddafcd0] [c00000000103d924] debug_vm_pgtable+0x4bc/0xb7c [   23.264279][    T1] [c00000003ddafdb0] [c000000000010eac] kernel_init+0x30/0x194 [   23.264315][    T1] [c00000003ddafe20] [c00000000000b748] ret_from_kernel_thread+0x5c/0x74 [   23.264349][    T1] Instruction dump: [   23.264368][    T1] 60000000 3be00001 7fbef436 eafa0040 7fffc030 3bffffff 7fff07b4 7ffff038  [   23.264409][    T1] 7bff1f24 7d37f82a 7d290074 7929d182 <0b090000> ebdb0000 e93c0000 7fde4a14  [   23.264460][    T1] ---[ end trace 72d2931022e9ab24 ]--- [   23.627311][    T1]  [   24.627407][    T1] Kernel panic - not syncing: Fatal exception [   26.5 > > Cc: Andrew Morton > Cc: Mike Rapoport > Cc: Vineet Gupta > Cc: Catalin Marinas > Cc: Will Deacon > Cc: Benjamin Herrenschmidt > Cc: Paul Mackerras > Cc: Michael Ellerman > Cc: Heiko Carstens > Cc: Vasily Gorbik > Cc: Christian Borntraeger > Cc: Thomas Gleixner > Cc: Ingo Molnar > Cc: Borislav Petkov > Cc: "H. Peter Anvin" > Cc: Kirill A. Shutemov > Cc: Paul Walmsley > Cc: Palmer Dabbelt > Cc: linux-snps-arc@lists.infradead.org > Cc: linux-arm-kernel@lists.infradead.org > Cc: linuxppc-dev@lists.ozlabs.org > Cc: linux-s390@vger.kernel.org > Cc: linux-riscv@lists.infradead.org > Cc: x86@kernel.org > Cc: linux-arch@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > > Suggested-by: Catalin Marinas > Reviewed-by: Ingo Molnar > Tested-by: Gerald Schaefer # s390 > Tested-by: Christophe Leroy # ppc32 > Signed-off-by: Andrew Morton > Signed-off-by: Christophe Leroy > Signed-off-by: Anshuman Khandual > --- > This adds a test validation for architecture exported page table helpers. > Patch adds basic transformation tests at various levels of the page table. > > This test was originally suggested by Catalin during arm64 THP migration > RFC discussion earlier. Going forward it can include more specific tests > with respect to various generic MM functions like THP, HugeTLB etc and > platform specific tests. > > https://lore.kernel.org/linux-mm/20190628102003.GA56463@arrakis.emea.arm.com/ > > Needs to be applied on linux V5.6-rc2 > > Changes in V14: > > - Disabled DEBUG_VM_PGFLAGS for IA64 and ARM (32 Bit) per Andrew and Christophe > - Updated DEBUG_VM_PGFLAGS documentation wrt EXPERT and disabled platforms > - Updated RANDOM_[OR|NZ]VALUE open encodings with GENMASK() per Catalin > - Updated s390 constraint bits from 12 to 4 (S390_MASK_BITS) per Gerald > - Updated in-code documentation for RANDOM_ORVALUE per Gerald > - Updated pxx_basic_tests() to use invert functions first per Catalin > - Dropped ARCH_HAS_4LEVEL_HACK check from pud_basic_tests() > - Replaced __ARCH_HAS_[4|5]LEVEL_HACK with __PAGETABLE_[PUD|P4D]_FOLDED per Catalin > - Trimmed the CC list on the commit message per Catalin > > Changes in V13: (https://patchwork.kernel.org/project/linux-mm/list/?series=237125) > > - Subscribed s390 platform and updated debug-vm-pgtable/arch-support.txt per Gerald > - Dropped keyword 'extern' from debug_vm_pgtable() declaration per Christophe > - Moved debug_vm_pgtable() declarations to per Christophe > - Moved debug_vm_pgtable() call site into kernel_init() per Christophe > - Changed CONFIG_DEBUG_VM_PGTABLE rules per Christophe > - Updated commit to include new supported platforms and changed config selection > > Changes in V12: (https://patchwork.kernel.org/project/linux-mm/list/?series=233905) > > - Replaced __mmdrop() with mmdrop() > - Enable ARCH_HAS_DEBUG_VM_PGTABLE on X86 for non CONFIG_X86_PAE platforms as the > test procedure interfere with pre-allocated PMDs attached to the PGD resulting > in runtime failures with VM_BUG_ON() > > Changes in V11: (https://patchwork.kernel.org/project/linux-mm/list/?series=221135) > > - Rebased the patch on V5.4 > > Changes in V10: (https://patchwork.kernel.org/project/linux-mm/list/?series=205529) > > - Always enable DEBUG_VM_PGTABLE when DEBUG_VM is enabled per Ingo > - Added tags from Ingo > > Changes in V9: (https://patchwork.kernel.org/project/linux-mm/list/?series=201429) > > - Changed feature support enumeration for powerpc platforms per Christophe > - Changed config wrapper for basic_[pmd|pud]_tests() to enable ARC platform > - Enabled the test on ARC platform > > Changes in V8: (https://patchwork.kernel.org/project/linux-mm/list/?series=194297) > > - Enabled ARCH_HAS_DEBUG_VM_PGTABLE on PPC32 platform per Christophe > - Updated feature documentation as DEBUG_VM_PGTABLE is now enabled on PPC32 platform > - Moved ARCH_HAS_DEBUG_VM_PGTABLE earlier to indent it with DEBUG_VM per Christophe > - Added an information message in debug_vm_pgtable() per Christophe > - Dropped random_vaddr boundary condition checks per Christophe and Qian > - Replaced virt_addr_valid() check with pfn_valid() check in debug_vm_pgtable() > - Slightly changed pr_fmt(fmt) information > > Changes in V7: (https://patchwork.kernel.org/project/linux-mm/list/?series=193051) > > - Memory allocation and free routines for mapped pages have been droped > - Mapped pfns are derived from standard kernel text symbol per Matthew > - Moved debug_vm_pgtaable() after page_alloc_init_late() per Michal and Qian > - Updated the commit message per Michal > - Updated W=1 GCC warning problem on x86 per Qian Cai > - Addition of new alloc_contig_pages() helper has been submitted separately > > Changes in V6: (https://patchwork.kernel.org/project/linux-mm/list/?series=187589) > > - Moved alloc_gigantic_page_order() into mm/page_alloc.c per Michal > - Moved alloc_gigantic_page_order() within CONFIG_CONTIG_ALLOC in the test > - Folded Andrew's include/asm-generic/pgtable.h fix into the test patch 2/2 > > Changes in V5: (https://patchwork.kernel.org/project/linux-mm/list/?series=185991) > > - Redefined and moved X86 mm_p4d_folded() into a different header per Kirill/Ingo > - Updated the config option comment per Ingo and dropped 'kernel module' reference > - Updated the commit message and dropped 'kernel module' reference > - Changed DEBUG_ARCH_PGTABLE_TEST into DEBUG_VM_PGTABLE per Ingo > - Moved config option from mm/Kconfig.debug into lib/Kconfig.debug > - Renamed core test function arch_pgtable_tests() as debug_vm_pgtable() > - Renamed mm/arch_pgtable_test.c as mm/debug_vm_pgtable.c > - debug_vm_pgtable() gets called from kernel_init_freeable() after init_mm_internals() > - Added an entry in Documentation/features/debug/ per Ingo > - Enabled the test on arm64 and x86 platforms for now > > Changes in V4: (https://patchwork.kernel.org/project/linux-mm/list/?series=183465) > > - Disable DEBUG_ARCH_PGTABLE_TEST for ARM and IA64 platforms > > Changes in V3: (https://lore.kernel.org/patchwork/project/lkml/list/?series=411216) > > - Changed test trigger from module format into late_initcall() > - Marked all functions with __init to be freed after completion > - Changed all __PGTABLE_PXX_FOLDED checks as mm_pxx_folded() > - Folded in PPC32 fixes from Christophe > > Changes in V2: > > https://lore.kernel.org/linux-mm/1568268173-31302-1-git-send-email-anshuman.khandual@arm.com/T/#t > > - Fixed small typo error in MODULE_DESCRIPTION() > - Fixed m64k build problems for lvalue concerns in pmd_xxx_tests() > - Fixed dynamic page table level folding problems on x86 as per Kirril > - Fixed second pointers during pxx_populate_tests() per Kirill and Gerald > - Allocate and free pte table with pte_alloc_one/pte_free per Kirill > - Modified pxx_clear_tests() to accommodate s390 lower 12 bits situation > - Changed RANDOM_NZVALUE value from 0xbe to 0xff > - Changed allocation, usage, free sequence for saved_ptep > - Renamed VMA_FLAGS as VMFLAGS > - Implemented a new method for random vaddr generation > - Implemented some other cleanups > - Dropped extern reference to mm_alloc() > - Created and exported new alloc_gigantic_page_order() > - Dropped the custom allocator and used new alloc_gigantic_page_order() > > Changes in V1: > > https://lore.kernel.org/linux-mm/1567497706-8649-1-git-send-email-anshuman.khandual@arm.com/ > > - Added fallback mechanism for PMD aligned memory allocation failure > > Changes in RFC V2: > > https://lore.kernel.org/linux-mm/1565335998-22553-1-git-send-email-anshuman.khandual@arm.com/T/#u > > - Moved test module and it's config from lib/ to mm/ > - Renamed config TEST_ARCH_PGTABLE as DEBUG_ARCH_PGTABLE_TEST > - Renamed file from test_arch_pgtable.c to arch_pgtable_test.c > - Added relevant MODULE_DESCRIPTION() and MODULE_AUTHOR() details > - Dropped loadable module config option > - Basic tests now use memory blocks with required size and alignment > - PUD aligned memory block gets allocated with alloc_contig_range() > - If PUD aligned memory could not be allocated it falls back on PMD aligned > memory block from page allocator and pud_* tests are skipped > - Clear and populate tests now operate on real in memory page table entries > - Dummy mm_struct gets allocated with mm_alloc() > - Dummy page table entries get allocated with [pud|pmd|pte]_alloc_[map]() > - Simplified [p4d|pgd]_basic_tests(), now has random values in the entries > > Original RFC V1: > > https://lore.kernel.org/linux-mm/1564037723-26676-1-git-send-email-anshuman.khandual@arm.com/ > > > .../debug/debug-vm-pgtable/arch-support.txt | 35 ++ > arch/arc/Kconfig | 1 + > arch/arm64/Kconfig | 1 + > arch/powerpc/Kconfig | 1 + > arch/s390/Kconfig | 1 + > arch/x86/Kconfig | 1 + > arch/x86/include/asm/pgtable_64.h | 6 + > include/linux/mmdebug.h | 5 + > init/main.c | 2 + > lib/Kconfig.debug | 26 ++ > mm/Makefile | 1 + > mm/debug_vm_pgtable.c | 389 ++++++++++++++++++ > 12 files changed, 469 insertions(+) > create mode 100644 Documentation/features/debug/debug-vm-pgtable/arch-support.txt > create mode 100644 mm/debug_vm_pgtable.c > > diff --git a/Documentation/features/debug/debug-vm-pgtable/arch-support.txt b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > new file mode 100644 > index 000000000000..64d0f9b15c49 > --- /dev/null > +++ b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > @@ -0,0 +1,35 @@ > +# > +# Feature name: debug-vm-pgtable > +# Kconfig: ARCH_HAS_DEBUG_VM_PGTABLE > +# description: arch supports pgtable tests for semantics compliance > +# > + ----------------------- > + | arch |status| > + ----------------------- > + | alpha: | TODO | > + | arc: | ok | > + | arm: | TODO | > + | arm64: | ok | > + | c6x: | TODO | > + | csky: | TODO | > + | h8300: | TODO | > + | hexagon: | TODO | > + | ia64: | TODO | > + | m68k: | TODO | > + | microblaze: | TODO | > + | mips: | TODO | > + | nds32: | TODO | > + | nios2: | TODO | > + | openrisc: | TODO | > + | parisc: | TODO | > + | powerpc/32: | ok | > + | powerpc/64: | TODO | > + | riscv: | TODO | > + | s390: | ok | > + | sh: | TODO | > + | sparc: | TODO | > + | um: | TODO | > + | unicore32: | TODO | > + | x86: | ok | > + | xtensa: | TODO | > + ----------------------- > diff --git a/arch/arc/Kconfig b/arch/arc/Kconfig > index ff2a393b635c..3e72e6cf0e42 100644 > --- a/arch/arc/Kconfig > +++ b/arch/arc/Kconfig > @@ -6,6 +6,7 @@ > config ARC > def_bool y > select ARC_TIMERS > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_PTE_SPECIAL > select ARCH_HAS_SETUP_DMA_OPS > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index 0b30e884e088..aaf8ba415145 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -11,6 +11,7 @@ config ARM64 > select ACPI_PPTT if ACPI > select ARCH_CLOCKSOURCE_DATA > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig > index 497b7d0b2d7e..8d5ae14c5d4c 100644 > --- a/arch/powerpc/Kconfig > +++ b/arch/powerpc/Kconfig > @@ -116,6 +116,7 @@ config PPC > # > select ARCH_32BIT_OFF_T if PPC32 > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if PPC32 > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig > index 8abe77536d9d..af284dbb07e7 100644 > --- a/arch/s390/Kconfig > +++ b/arch/s390/Kconfig > @@ -59,6 +59,7 @@ config KASAN_SHADOW_OFFSET > config S390 > def_bool y > select ARCH_BINFMT_ELF_STATE > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index beea77046f9b..df8a19e52e82 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -61,6 +61,7 @@ config X86 > select ARCH_CLOCKSOURCE_INIT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if !X86_PAE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FAST_MULTIPLIER > diff --git a/arch/x86/include/asm/pgtable_64.h b/arch/x86/include/asm/pgtable_64.h > index 0b6c4042942a..fb0e76d254b3 100644 > --- a/arch/x86/include/asm/pgtable_64.h > +++ b/arch/x86/include/asm/pgtable_64.h > @@ -53,6 +53,12 @@ static inline void sync_initial_page_table(void) { } > > struct mm_struct; > > +#define mm_p4d_folded mm_p4d_folded > +static inline bool mm_p4d_folded(struct mm_struct *mm) > +{ > + return !pgtable_l5_enabled(); > +} > + > void set_pte_vaddr_p4d(p4d_t *p4d_page, unsigned long vaddr, pte_t new_pte); > void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte); > > diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h > index 2ad72d2c8cc5..5339aa14b749 100644 > --- a/include/linux/mmdebug.h > +++ b/include/linux/mmdebug.h > @@ -64,4 +64,9 @@ void dump_mm(const struct mm_struct *mm); > #define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond) > #endif > > +#ifdef CONFIG_DEBUG_VM_PGTABLE > +void debug_vm_pgtable(void); > +#else > +static inline void debug_vm_pgtable(void) { } > +#endif > #endif > diff --git a/init/main.c b/init/main.c > index cc0ee4873419..adf37e8b1d69 100644 > --- a/init/main.c > +++ b/init/main.c > @@ -94,6 +94,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -1323,6 +1324,7 @@ static int __ref kernel_init(void *unused) > kernel_init_freeable(); > /* need to finish all async __init code before freeing the memory */ > async_synchronize_full(); > + debug_vm_pgtable(); > ftrace_free_init_mem(); > free_initmem(); > mark_readonly(); > diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug > index 69def4a9df00..1b5bd9f7c967 100644 > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -653,6 +653,12 @@ config SCHED_STACK_END_CHECK > data corruption or a sporadic crash at a later stage once the region > is examined. The runtime overhead introduced is minimal. > > +config ARCH_HAS_DEBUG_VM_PGTABLE > + bool > + help > + An architecture should select this when it can successfully > + build and run DEBUG_VM_PGTABLE. > + > config DEBUG_VM > bool "Debug VM" > depends on DEBUG_KERNEL > @@ -688,6 +694,26 @@ config DEBUG_VM_PGFLAGS > > If unsure, say N. > > +config DEBUG_VM_PGTABLE > + bool "Debug arch page table for semantics compliance" > + depends on MMU > + depends on !IA64 && !ARM > + depends on ARCH_HAS_DEBUG_VM_PGTABLE || EXPERT > + default n if !ARCH_HAS_DEBUG_VM_PGTABLE > + default y if DEBUG_VM > + help > + This option provides a debug method which can be used to test > + architecture page table helper functions on various platforms in > + verifying if they comply with expected generic MM semantics. This > + will help architecture code in making sure that any changes or > + new additions of these helpers still conform to expected > + semantics of the generic MM. Platforms will have to opt in for > + this through ARCH_HAS_DEBUG_VM_PGTABLE. Although it can also be > + enabled through EXPERT without requiring code change. This test > + is disabled on IA64 and ARM platforms where it fails to build. > + > + If unsure, say N. > + > config ARCH_HAS_DEBUG_VIRTUAL > bool > > diff --git a/mm/Makefile b/mm/Makefile > index 272e66039e70..b0692e6a4b58 100644 > --- a/mm/Makefile > +++ b/mm/Makefile > @@ -87,6 +87,7 @@ obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o > obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o > obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak-test.o > obj-$(CONFIG_DEBUG_RODATA_TEST) += rodata_test.o > +obj-$(CONFIG_DEBUG_VM_PGTABLE) += debug_vm_pgtable.o > obj-$(CONFIG_PAGE_OWNER) += page_owner.o > obj-$(CONFIG_CLEANCACHE) += cleancache.o > obj-$(CONFIG_MEMORY_ISOLATION) += page_isolation.o > diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c > new file mode 100644 > index 000000000000..70bf8ed8fd51 > --- /dev/null > +++ b/mm/debug_vm_pgtable.c > @@ -0,0 +1,389 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * This kernel test validates architecture page table helpers and > + * accessors and helps in verifying their continued compliance with > + * expected generic MM semantics. > + * > + * Copyright (C) 2019 ARM Ltd. > + * > + * Author: Anshuman Khandual > + */ > +#define pr_fmt(fmt) "debug_vm_pgtable: %s: " fmt, __func__ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * Basic operations > + * > + * mkold(entry) = An old and not a young entry > + * mkyoung(entry) = A young and not an old entry > + * mkdirty(entry) = A dirty and not a clean entry > + * mkclean(entry) = A clean and not a dirty entry > + * mkwrite(entry) = A write and not a write protected entry > + * wrprotect(entry) = A write protected and not a write entry > + * pxx_bad(entry) = A mapped and non-table entry > + * pxx_same(entry1, entry2) = Both entries hold the exact same value > + */ > +#define VMFLAGS (VM_READ|VM_WRITE|VM_EXEC) > + > +/* > + * On s390 platform, the lower 4 bits are used to identify given page table > + * entry type. But these bits might affect the ability to clear entries with > + * pxx_clear() because of how dynamic page table folding works on s390. So > + * while loading up the entries do not change the lower 4 bits. It does not > + * have affect any other platform. > + */ > +#define S390_MASK_BITS 4 > +#define RANDOM_ORVALUE GENMASK(BITS_PER_LONG - 1, S390_MASK_BITS) > +#define RANDOM_NZVALUE GENMASK(7, 0) > + > +static void __init pte_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pte_t pte = pfn_pte(pfn, prot); > + > + WARN_ON(!pte_same(pte, pte)); > + WARN_ON(!pte_young(pte_mkyoung(pte_mkold(pte)))); > + WARN_ON(!pte_dirty(pte_mkdirty(pte_mkclean(pte)))); > + WARN_ON(!pte_write(pte_mkwrite(pte_wrprotect(pte)))); > + WARN_ON(pte_young(pte_mkold(pte_mkyoung(pte)))); > + WARN_ON(pte_dirty(pte_mkclean(pte_mkdirty(pte)))); > + WARN_ON(pte_write(pte_wrprotect(pte_mkwrite(pte)))); > +} > + > +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pmd_t pmd = pfn_pmd(pfn, prot); > + > + WARN_ON(!pmd_same(pmd, pmd)); > + WARN_ON(!pmd_young(pmd_mkyoung(pmd_mkold(pmd)))); > + WARN_ON(!pmd_dirty(pmd_mkdirty(pmd_mkclean(pmd)))); > + WARN_ON(!pmd_write(pmd_mkwrite(pmd_wrprotect(pmd)))); > + WARN_ON(pmd_young(pmd_mkold(pmd_mkyoung(pmd)))); > + WARN_ON(pmd_dirty(pmd_mkclean(pmd_mkdirty(pmd)))); > + WARN_ON(pmd_write(pmd_wrprotect(pmd_mkwrite(pmd)))); > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pmd_bad(). > + */ > + WARN_ON(!pmd_bad(pmd_mkhuge(pmd))); > +} > + > +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pud_t pud = pfn_pud(pfn, prot); > + > + WARN_ON(!pud_same(pud, pud)); > + WARN_ON(!pud_young(pud_mkyoung(pud_mkold(pud)))); > + WARN_ON(!pud_write(pud_mkwrite(pud_wrprotect(pud)))); > + WARN_ON(pud_write(pud_wrprotect(pud_mkwrite(pud)))); > + WARN_ON(pud_young(pud_mkold(pud_mkyoung(pud)))); > + > + if (mm_pmd_folded(mm)) > + return; > + > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pud_bad(). > + */ > + WARN_ON(!pud_bad(pud_mkhuge(pud))); > +} > +#else > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > +#else > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) { } > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > + > +static void __init p4d_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + p4d_t p4d; > + > + memset(&p4d, RANDOM_NZVALUE, sizeof(p4d_t)); > + WARN_ON(!p4d_same(p4d, p4d)); > +} > + > +static void __init pgd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pgd_t pgd; > + > + memset(&pgd, RANDOM_NZVALUE, sizeof(pgd_t)); > + WARN_ON(!pgd_same(pgd, pgd)); > +} > + > +#ifndef __PAGETABLE_PUD_FOLDED > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) > +{ > + pud_t pud = READ_ONCE(*pudp); > + > + if (mm_pmd_folded(mm)) > + return; > + > + pud = __pud(pud_val(pud) | RANDOM_ORVALUE); > + WRITE_ONCE(*pudp, pud); > + pud_clear(pudp); > + pud = READ_ONCE(*pudp); > + WARN_ON(!pud_none(pud)); > +} > + > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > + pud_t pud; > + > + if (mm_pmd_folded(mm)) > + return; > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pud_bad(). > + */ > + pmd_clear(pmdp); > + pud_clear(pudp); > + pud_populate(mm, pudp, pmdp); > + pud = READ_ONCE(*pudp); > + WARN_ON(pud_bad(pud)); > +} > +#else > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) { } > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > +} > +#endif > + > +#ifndef __PAGETABLE_P4D_FOLDED > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) > +{ > + p4d_t p4d = READ_ONCE(*p4dp); > + > + if (mm_pud_folded(mm)) > + return; > + > + p4d = __p4d(p4d_val(p4d) | RANDOM_ORVALUE); > + WRITE_ONCE(*p4dp, p4d); > + p4d_clear(p4dp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(!p4d_none(p4d)); > +} > + > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > + p4d_t p4d; > + > + if (mm_pud_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as p4d_bad(). > + */ > + pud_clear(pudp); > + p4d_clear(p4dp); > + p4d_populate(mm, p4dp, pudp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(p4d_bad(p4d)); > +} > + > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) > +{ > + pgd_t pgd = READ_ONCE(*pgdp); > + > + if (mm_p4d_folded(mm)) > + return; > + > + pgd = __pgd(pgd_val(pgd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pgdp, pgd); > + pgd_clear(pgdp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(!pgd_none(pgd)); > +} > + > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > + pgd_t pgd; > + > + if (mm_p4d_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pgd_bad(). > + */ > + p4d_clear(p4dp); > + pgd_clear(pgdp); > + pgd_populate(mm, pgdp, p4dp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(pgd_bad(pgd)); > +} > +#else > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) { } > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) { } > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > +} > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > +} > +#endif > + > +static void __init pte_clear_tests(struct mm_struct *mm, pte_t *ptep) > +{ > + pte_t pte = READ_ONCE(*ptep); > + > + pte = __pte(pte_val(pte) | RANDOM_ORVALUE); > + WRITE_ONCE(*ptep, pte); > + pte_clear(mm, 0, ptep); > + pte = READ_ONCE(*ptep); > + WARN_ON(!pte_none(pte)); > +} > + > +static void __init pmd_clear_tests(struct mm_struct *mm, pmd_t *pmdp) > +{ > + pmd_t pmd = READ_ONCE(*pmdp); > + > + pmd = __pmd(pmd_val(pmd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pmdp, pmd); > + pmd_clear(pmdp); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(!pmd_none(pmd)); > +} > + > +static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, > + pgtable_t pgtable) > +{ > + pmd_t pmd; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pmd_bad(). > + */ > + pmd_clear(pmdp); > + pmd_populate(mm, pmdp, pgtable); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(pmd_bad(pmd)); > +} > + > +static unsigned long __init get_random_vaddr(void) > +{ > + unsigned long random_vaddr, random_pages, total_user_pages; > + > + total_user_pages = (TASK_SIZE - FIRST_USER_ADDRESS) / PAGE_SIZE; > + > + random_pages = get_random_long() % total_user_pages; > + random_vaddr = FIRST_USER_ADDRESS + random_pages * PAGE_SIZE; > + > + return random_vaddr; > +} > + > +void __init debug_vm_pgtable(void) > +{ > + struct mm_struct *mm; > + pgd_t *pgdp; > + p4d_t *p4dp, *saved_p4dp; > + pud_t *pudp, *saved_pudp; > + pmd_t *pmdp, *saved_pmdp, pmd; > + pte_t *ptep; > + pgtable_t saved_ptep; > + pgprot_t prot; > + phys_addr_t paddr; > + unsigned long vaddr, pte_aligned, pmd_aligned; > + unsigned long pud_aligned, p4d_aligned, pgd_aligned; > + > + pr_info("Validating architecture page table helpers\n"); > + prot = vm_get_page_prot(VMFLAGS); > + vaddr = get_random_vaddr(); > + mm = mm_alloc(); > + if (!mm) { > + pr_err("mm_struct allocation failed\n"); > + return; > + } > + > + /* > + * PFN for mapping at PTE level is determined from a standard kernel > + * text symbol. But pfns for higher page table levels are derived by > + * masking lower bits of this real pfn. These derived pfns might not > + * exist on the platform but that does not really matter as pfn_pxx() > + * helpers will still create appropriate entries for the test. This > + * helps avoid large memory block allocations to be used for mapping > + * at higher page table levels. > + */ > + paddr = __pa(&start_kernel); > + > + pte_aligned = (paddr & PAGE_MASK) >> PAGE_SHIFT; > + pmd_aligned = (paddr & PMD_MASK) >> PAGE_SHIFT; > + pud_aligned = (paddr & PUD_MASK) >> PAGE_SHIFT; > + p4d_aligned = (paddr & P4D_MASK) >> PAGE_SHIFT; > + pgd_aligned = (paddr & PGDIR_MASK) >> PAGE_SHIFT; > + WARN_ON(!pfn_valid(pte_aligned)); > + > + pgdp = pgd_offset(mm, vaddr); > + p4dp = p4d_alloc(mm, pgdp, vaddr); > + pudp = pud_alloc(mm, p4dp, vaddr); > + pmdp = pmd_alloc(mm, pudp, vaddr); > + ptep = pte_alloc_map(mm, pmdp, vaddr); > + > + /* > + * Save all the page table page addresses as the page table > + * entries will be used for testing with random or garbage > + * values. These saved addresses will be used for freeing > + * page table pages. > + */ > + pmd = READ_ONCE(*pmdp); > + saved_p4dp = p4d_offset(pgdp, 0UL); > + saved_pudp = pud_offset(p4dp, 0UL); > + saved_pmdp = pmd_offset(pudp, 0UL); > + saved_ptep = pmd_pgtable(pmd); > + > + pte_basic_tests(pte_aligned, prot); > + pmd_basic_tests(pmd_aligned, prot); > + pud_basic_tests(pud_aligned, prot); > + p4d_basic_tests(p4d_aligned, prot); > + pgd_basic_tests(pgd_aligned, prot); > + > + pte_clear_tests(mm, ptep); > + pmd_clear_tests(mm, pmdp); > + pud_clear_tests(mm, pudp); > + p4d_clear_tests(mm, p4dp); > + pgd_clear_tests(mm, pgdp); > + > + pte_unmap(ptep); > + > + pmd_populate_tests(mm, pmdp, saved_ptep); > + pud_populate_tests(mm, pudp, saved_pmdp); > + p4d_populate_tests(mm, p4dp, saved_pudp); > + pgd_populate_tests(mm, pgdp, saved_p4dp); > + > + p4d_free(mm, saved_p4dp); > + pud_free(mm, saved_pudp); > + pmd_free(mm, saved_pmdp); > + pte_free(mm, saved_ptep); > + > + mm_dec_nr_puds(mm); > + mm_dec_nr_pmds(mm); > + mm_dec_nr_ptes(mm); > + mmdrop(mm); > +} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-qt1-f194.google.com ([209.85.160.194]:35412 "EHLO mail-qt1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726778AbgBZOJr (ORCPT ); Wed, 26 Feb 2020 09:09:47 -0500 Received: by mail-qt1-f194.google.com with SMTP id 88so1490678qtc.2 for ; Wed, 26 Feb 2020 06:09:46 -0800 (PST) Message-ID: <1582726182.7365.123.camel@lca.pw> Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers From: Qian Cai Date: Wed, 26 Feb 2020 09:09:42 -0500 In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> Content-Type: text/plain; charset="utf-8" Mime-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-s390-owner@vger.kernel.org List-ID: To: Anshuman Khandual , linux-mm@kvack.org Cc: Andrew Morton , Mike Rapoport , Vineet Gupta , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Michael Ellerman , Heiko Carstens , Vasily Gorbik , Christian Borntraeger , Thomas Gleixner , Ingo Molnar , Borislav Petkov , "H. Peter Anvin" , "Kirill A . Shutemov" , Paul Walmsley , Palmer Dabbelt , linux-snps-arc@lists.infradead.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-s390@vger.kernel.org, linux-riscv@lists.infradead.org, x86@kernel.org, linux-arch@vger.kernel.org, linux-kernel@vger.kernel.org, Christophe Leroy On Mon, 2020-02-17 at 08:47 +0530, Anshuman Khandual wrote: > This adds tests which will validate architecture page table helpers and > other accessors in their compliance with expected generic MM semantics. > This will help various architectures in validating changes to existing > page table helpers or addition of new ones. > > This test covers basic page table entry transformations including but not > limited to old, young, dirty, clean, write, write protect etc at various > level along with populating intermediate entries with next page table page > and validating them. > > Test page table pages are allocated from system memory with required size > and alignments. The mapped pfns at page table levels are derived from a > real pfn representing a valid kernel text symbol. This test gets called > inside kernel_init() right after async_synchronize_full(). > > This test gets built and run when CONFIG_DEBUG_VM_PGTABLE is selected. Any > architecture, which is willing to subscribe this test will need to select > ARCH_HAS_DEBUG_VM_PGTABLE. For now this is limited to arc, arm64, x86, s390 > and ppc32 platforms where the test is known to build and run successfully. > Going forward, other architectures too can subscribe the test after fixing > any build or runtime problems with their page table helpers. Meanwhile for > better platform coverage, the test can also be enabled with CONFIG_EXPERT > even without ARCH_HAS_DEBUG_VM_PGTABLE. > > Folks interested in making sure that a given platform's page table helpers > conform to expected generic MM semantics should enable the above config > which will just trigger this test during boot. Any non conformity here will > be reported as an warning which would need to be fixed. This test will help > catch any changes to the agreed upon semantics expected from generic MM and > enable platforms to accommodate it thereafter. How useful is this that straightly crash the powerpc? [   23.263425][    T1] debug_vm_pgtable: debug_vm_pgtable: Validating architecture page table helpers [   23.263625][    T1] ------------[ cut here ]------------ [   23.263649][    T1] kernel BUG at arch/powerpc/mm/pgtable.c:274! [   23.263675][    T1] Oops: Exception in kernel mode, sig: 5 [#1] [   23.263698][    T1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=256 DEBUG_PAGEALLOC NUMA PowerNV [   23.263731][    T1] Modules linked in: [   23.263752][    T1] CPU: 4 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc3-next- 20200226 #1 [   23.263776][    T1] NIP:  c00000000007308c LR: c00000000103dbd8 CTR: 0000000000000000 [   23.263810][    T1] REGS: c00000003ddaf9c0 TRAP: 0700   Not tainted  (5.6.0- rc3-next-20200226) [   23.263846][    T1] MSR:  9000000000029033   CR: 22000228  XER: 00000000 [   23.263888][    T1] CFAR: c000000000073030 IRQMASK: 0  [   23.263888][    T1] GPR00: c00000000103dbd8 c00000003ddafc50 c000000001656f00 c000001d7b4ca080  [   23.263888][    T1] GPR04: 0000000000000000 0000000000000009 c00000003ddafc04 0000000000000000  [   23.263888][    T1] GPR08: f0ffffffffffffff 0000000000000001 c0000000016279d0 00000000000a0000  [   23.263888][    T1] GPR12: 0000000000000000 c000001fffffae00 c000000000010e84 0000000000000000  [   23.263888][    T1] GPR16: 0000000000000000 8000000000000105 0000000000000100 c000000001689a18  [   23.263888][    T1] GPR20: c00020032c660000 c00020032c620000 c000000001716030 c00020032c600000  [   23.263888][    T1] GPR24: 000000000000000d c000000001716030 c000001d7b4ca080 c000000001716040  [   23.263888][    T1] GPR28: c000000001716038 0000000000000000 0000000000000000 0000000000000000  [   23.264122][    T1] NIP [c00000000007308c] assert_pte_locked+0x11c/0x320 [   23.264154][    T1] LR [c00000000103dbd8] debug_vm_pgtable+0x770/0xb7c [   23.264186][    T1] Call Trace: [   23.264206][    T1] [c00000003ddafc50] [c000000000999760] _raw_spin_unlock+0x30/0x70 (unreliable) [   23.264244][    T1] [c00000003ddafcd0] [c00000000103d924] debug_vm_pgtable+0x4bc/0xb7c [   23.264279][    T1] [c00000003ddafdb0] [c000000000010eac] kernel_init+0x30/0x194 [   23.264315][    T1] [c00000003ddafe20] [c00000000000b748] ret_from_kernel_thread+0x5c/0x74 [   23.264349][    T1] Instruction dump: [   23.264368][    T1] 60000000 3be00001 7fbef436 eafa0040 7fffc030 3bffffff 7fff07b4 7ffff038  [   23.264409][    T1] 7bff1f24 7d37f82a 7d290074 7929d182 <0b090000> ebdb0000 e93c0000 7fde4a14  [   23.264460][    T1] ---[ end trace 72d2931022e9ab24 ]--- [   23.627311][    T1]  [   24.627407][    T1] Kernel panic - not syncing: Fatal exception [   26.5 > > Cc: Andrew Morton > Cc: Mike Rapoport > Cc: Vineet Gupta > Cc: Catalin Marinas > Cc: Will Deacon > Cc: Benjamin Herrenschmidt > Cc: Paul Mackerras > Cc: Michael Ellerman > Cc: Heiko Carstens > Cc: Vasily Gorbik > Cc: Christian Borntraeger > Cc: Thomas Gleixner > Cc: Ingo Molnar > Cc: Borislav Petkov > Cc: "H. Peter Anvin" > Cc: Kirill A. Shutemov > Cc: Paul Walmsley > Cc: Palmer Dabbelt > Cc: linux-snps-arc@lists.infradead.org > Cc: linux-arm-kernel@lists.infradead.org > Cc: linuxppc-dev@lists.ozlabs.org > Cc: linux-s390@vger.kernel.org > Cc: linux-riscv@lists.infradead.org > Cc: x86@kernel.org > Cc: linux-arch@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > > Suggested-by: Catalin Marinas > Reviewed-by: Ingo Molnar > Tested-by: Gerald Schaefer # s390 > Tested-by: Christophe Leroy # ppc32 > Signed-off-by: Andrew Morton > Signed-off-by: Christophe Leroy > Signed-off-by: Anshuman Khandual > --- > This adds a test validation for architecture exported page table helpers. > Patch adds basic transformation tests at various levels of the page table. > > This test was originally suggested by Catalin during arm64 THP migration > RFC discussion earlier. Going forward it can include more specific tests > with respect to various generic MM functions like THP, HugeTLB etc and > platform specific tests. > > https://lore.kernel.org/linux-mm/20190628102003.GA56463@arrakis.emea.arm.com/ > > Needs to be applied on linux V5.6-rc2 > > Changes in V14: > > - Disabled DEBUG_VM_PGFLAGS for IA64 and ARM (32 Bit) per Andrew and Christophe > - Updated DEBUG_VM_PGFLAGS documentation wrt EXPERT and disabled platforms > - Updated RANDOM_[OR|NZ]VALUE open encodings with GENMASK() per Catalin > - Updated s390 constraint bits from 12 to 4 (S390_MASK_BITS) per Gerald > - Updated in-code documentation for RANDOM_ORVALUE per Gerald > - Updated pxx_basic_tests() to use invert functions first per Catalin > - Dropped ARCH_HAS_4LEVEL_HACK check from pud_basic_tests() > - Replaced __ARCH_HAS_[4|5]LEVEL_HACK with __PAGETABLE_[PUD|P4D]_FOLDED per Catalin > - Trimmed the CC list on the commit message per Catalin > > Changes in V13: (https://patchwork.kernel.org/project/linux-mm/list/?series=237125) > > - Subscribed s390 platform and updated debug-vm-pgtable/arch-support.txt per Gerald > - Dropped keyword 'extern' from debug_vm_pgtable() declaration per Christophe > - Moved debug_vm_pgtable() declarations to per Christophe > - Moved debug_vm_pgtable() call site into kernel_init() per Christophe > - Changed CONFIG_DEBUG_VM_PGTABLE rules per Christophe > - Updated commit to include new supported platforms and changed config selection > > Changes in V12: (https://patchwork.kernel.org/project/linux-mm/list/?series=233905) > > - Replaced __mmdrop() with mmdrop() > - Enable ARCH_HAS_DEBUG_VM_PGTABLE on X86 for non CONFIG_X86_PAE platforms as the > test procedure interfere with pre-allocated PMDs attached to the PGD resulting > in runtime failures with VM_BUG_ON() > > Changes in V11: (https://patchwork.kernel.org/project/linux-mm/list/?series=221135) > > - Rebased the patch on V5.4 > > Changes in V10: (https://patchwork.kernel.org/project/linux-mm/list/?series=205529) > > - Always enable DEBUG_VM_PGTABLE when DEBUG_VM is enabled per Ingo > - Added tags from Ingo > > Changes in V9: (https://patchwork.kernel.org/project/linux-mm/list/?series=201429) > > - Changed feature support enumeration for powerpc platforms per Christophe > - Changed config wrapper for basic_[pmd|pud]_tests() to enable ARC platform > - Enabled the test on ARC platform > > Changes in V8: (https://patchwork.kernel.org/project/linux-mm/list/?series=194297) > > - Enabled ARCH_HAS_DEBUG_VM_PGTABLE on PPC32 platform per Christophe > - Updated feature documentation as DEBUG_VM_PGTABLE is now enabled on PPC32 platform > - Moved ARCH_HAS_DEBUG_VM_PGTABLE earlier to indent it with DEBUG_VM per Christophe > - Added an information message in debug_vm_pgtable() per Christophe > - Dropped random_vaddr boundary condition checks per Christophe and Qian > - Replaced virt_addr_valid() check with pfn_valid() check in debug_vm_pgtable() > - Slightly changed pr_fmt(fmt) information > > Changes in V7: (https://patchwork.kernel.org/project/linux-mm/list/?series=193051) > > - Memory allocation and free routines for mapped pages have been droped > - Mapped pfns are derived from standard kernel text symbol per Matthew > - Moved debug_vm_pgtaable() after page_alloc_init_late() per Michal and Qian > - Updated the commit message per Michal > - Updated W=1 GCC warning problem on x86 per Qian Cai > - Addition of new alloc_contig_pages() helper has been submitted separately > > Changes in V6: (https://patchwork.kernel.org/project/linux-mm/list/?series=187589) > > - Moved alloc_gigantic_page_order() into mm/page_alloc.c per Michal > - Moved alloc_gigantic_page_order() within CONFIG_CONTIG_ALLOC in the test > - Folded Andrew's include/asm-generic/pgtable.h fix into the test patch 2/2 > > Changes in V5: (https://patchwork.kernel.org/project/linux-mm/list/?series=185991) > > - Redefined and moved X86 mm_p4d_folded() into a different header per Kirill/Ingo > - Updated the config option comment per Ingo and dropped 'kernel module' reference > - Updated the commit message and dropped 'kernel module' reference > - Changed DEBUG_ARCH_PGTABLE_TEST into DEBUG_VM_PGTABLE per Ingo > - Moved config option from mm/Kconfig.debug into lib/Kconfig.debug > - Renamed core test function arch_pgtable_tests() as debug_vm_pgtable() > - Renamed mm/arch_pgtable_test.c as mm/debug_vm_pgtable.c > - debug_vm_pgtable() gets called from kernel_init_freeable() after init_mm_internals() > - Added an entry in Documentation/features/debug/ per Ingo > - Enabled the test on arm64 and x86 platforms for now > > Changes in V4: (https://patchwork.kernel.org/project/linux-mm/list/?series=183465) > > - Disable DEBUG_ARCH_PGTABLE_TEST for ARM and IA64 platforms > > Changes in V3: (https://lore.kernel.org/patchwork/project/lkml/list/?series=411216) > > - Changed test trigger from module format into late_initcall() > - Marked all functions with __init to be freed after completion > - Changed all __PGTABLE_PXX_FOLDED checks as mm_pxx_folded() > - Folded in PPC32 fixes from Christophe > > Changes in V2: > > https://lore.kernel.org/linux-mm/1568268173-31302-1-git-send-email-anshuman.khandual@arm.com/T/#t > > - Fixed small typo error in MODULE_DESCRIPTION() > - Fixed m64k build problems for lvalue concerns in pmd_xxx_tests() > - Fixed dynamic page table level folding problems on x86 as per Kirril > - Fixed second pointers during pxx_populate_tests() per Kirill and Gerald > - Allocate and free pte table with pte_alloc_one/pte_free per Kirill > - Modified pxx_clear_tests() to accommodate s390 lower 12 bits situation > - Changed RANDOM_NZVALUE value from 0xbe to 0xff > - Changed allocation, usage, free sequence for saved_ptep > - Renamed VMA_FLAGS as VMFLAGS > - Implemented a new method for random vaddr generation > - Implemented some other cleanups > - Dropped extern reference to mm_alloc() > - Created and exported new alloc_gigantic_page_order() > - Dropped the custom allocator and used new alloc_gigantic_page_order() > > Changes in V1: > > https://lore.kernel.org/linux-mm/1567497706-8649-1-git-send-email-anshuman.khandual@arm.com/ > > - Added fallback mechanism for PMD aligned memory allocation failure > > Changes in RFC V2: > > https://lore.kernel.org/linux-mm/1565335998-22553-1-git-send-email-anshuman.khandual@arm.com/T/#u > > - Moved test module and it's config from lib/ to mm/ > - Renamed config TEST_ARCH_PGTABLE as DEBUG_ARCH_PGTABLE_TEST > - Renamed file from test_arch_pgtable.c to arch_pgtable_test.c > - Added relevant MODULE_DESCRIPTION() and MODULE_AUTHOR() details > - Dropped loadable module config option > - Basic tests now use memory blocks with required size and alignment > - PUD aligned memory block gets allocated with alloc_contig_range() > - If PUD aligned memory could not be allocated it falls back on PMD aligned > memory block from page allocator and pud_* tests are skipped > - Clear and populate tests now operate on real in memory page table entries > - Dummy mm_struct gets allocated with mm_alloc() > - Dummy page table entries get allocated with [pud|pmd|pte]_alloc_[map]() > - Simplified [p4d|pgd]_basic_tests(), now has random values in the entries > > Original RFC V1: > > https://lore.kernel.org/linux-mm/1564037723-26676-1-git-send-email-anshuman.khandual@arm.com/ > > > .../debug/debug-vm-pgtable/arch-support.txt | 35 ++ > arch/arc/Kconfig | 1 + > arch/arm64/Kconfig | 1 + > arch/powerpc/Kconfig | 1 + > arch/s390/Kconfig | 1 + > arch/x86/Kconfig | 1 + > arch/x86/include/asm/pgtable_64.h | 6 + > include/linux/mmdebug.h | 5 + > init/main.c | 2 + > lib/Kconfig.debug | 26 ++ > mm/Makefile | 1 + > mm/debug_vm_pgtable.c | 389 ++++++++++++++++++ > 12 files changed, 469 insertions(+) > create mode 100644 Documentation/features/debug/debug-vm-pgtable/arch-support.txt > create mode 100644 mm/debug_vm_pgtable.c > > diff --git a/Documentation/features/debug/debug-vm-pgtable/arch-support.txt b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > new file mode 100644 > index 000000000000..64d0f9b15c49 > --- /dev/null > +++ b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > @@ -0,0 +1,35 @@ > +# > +# Feature name: debug-vm-pgtable > +# Kconfig: ARCH_HAS_DEBUG_VM_PGTABLE > +# description: arch supports pgtable tests for semantics compliance > +# > + ----------------------- > + | arch |status| > + ----------------------- > + | alpha: | TODO | > + | arc: | ok | > + | arm: | TODO | > + | arm64: | ok | > + | c6x: | TODO | > + | csky: | TODO | > + | h8300: | TODO | > + | hexagon: | TODO | > + | ia64: | TODO | > + | m68k: | TODO | > + | microblaze: | TODO | > + | mips: | TODO | > + | nds32: | TODO | > + | nios2: | TODO | > + | openrisc: | TODO | > + | parisc: | TODO | > + | powerpc/32: | ok | > + | powerpc/64: | TODO | > + | riscv: | TODO | > + | s390: | ok | > + | sh: | TODO | > + | sparc: | TODO | > + | um: | TODO | > + | unicore32: | TODO | > + | x86: | ok | > + | xtensa: | TODO | > + ----------------------- > diff --git a/arch/arc/Kconfig b/arch/arc/Kconfig > index ff2a393b635c..3e72e6cf0e42 100644 > --- a/arch/arc/Kconfig > +++ b/arch/arc/Kconfig > @@ -6,6 +6,7 @@ > config ARC > def_bool y > select ARC_TIMERS > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_PTE_SPECIAL > select ARCH_HAS_SETUP_DMA_OPS > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index 0b30e884e088..aaf8ba415145 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -11,6 +11,7 @@ config ARM64 > select ACPI_PPTT if ACPI > select ARCH_CLOCKSOURCE_DATA > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig > index 497b7d0b2d7e..8d5ae14c5d4c 100644 > --- a/arch/powerpc/Kconfig > +++ b/arch/powerpc/Kconfig > @@ -116,6 +116,7 @@ config PPC > # > select ARCH_32BIT_OFF_T if PPC32 > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if PPC32 > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig > index 8abe77536d9d..af284dbb07e7 100644 > --- a/arch/s390/Kconfig > +++ b/arch/s390/Kconfig > @@ -59,6 +59,7 @@ config KASAN_SHADOW_OFFSET > config S390 > def_bool y > select ARCH_BINFMT_ELF_STATE > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index beea77046f9b..df8a19e52e82 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -61,6 +61,7 @@ config X86 > select ARCH_CLOCKSOURCE_INIT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if !X86_PAE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FAST_MULTIPLIER > diff --git a/arch/x86/include/asm/pgtable_64.h b/arch/x86/include/asm/pgtable_64.h > index 0b6c4042942a..fb0e76d254b3 100644 > --- a/arch/x86/include/asm/pgtable_64.h > +++ b/arch/x86/include/asm/pgtable_64.h > @@ -53,6 +53,12 @@ static inline void sync_initial_page_table(void) { } > > struct mm_struct; > > +#define mm_p4d_folded mm_p4d_folded > +static inline bool mm_p4d_folded(struct mm_struct *mm) > +{ > + return !pgtable_l5_enabled(); > +} > + > void set_pte_vaddr_p4d(p4d_t *p4d_page, unsigned long vaddr, pte_t new_pte); > void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte); > > diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h > index 2ad72d2c8cc5..5339aa14b749 100644 > --- a/include/linux/mmdebug.h > +++ b/include/linux/mmdebug.h > @@ -64,4 +64,9 @@ void dump_mm(const struct mm_struct *mm); > #define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond) > #endif > > +#ifdef CONFIG_DEBUG_VM_PGTABLE > +void debug_vm_pgtable(void); > +#else > +static inline void debug_vm_pgtable(void) { } > +#endif > #endif > diff --git a/init/main.c b/init/main.c > index cc0ee4873419..adf37e8b1d69 100644 > --- a/init/main.c > +++ b/init/main.c > @@ -94,6 +94,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -1323,6 +1324,7 @@ static int __ref kernel_init(void *unused) > kernel_init_freeable(); > /* need to finish all async __init code before freeing the memory */ > async_synchronize_full(); > + debug_vm_pgtable(); > ftrace_free_init_mem(); > free_initmem(); > mark_readonly(); > diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug > index 69def4a9df00..1b5bd9f7c967 100644 > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -653,6 +653,12 @@ config SCHED_STACK_END_CHECK > data corruption or a sporadic crash at a later stage once the region > is examined. The runtime overhead introduced is minimal. > > +config ARCH_HAS_DEBUG_VM_PGTABLE > + bool > + help > + An architecture should select this when it can successfully > + build and run DEBUG_VM_PGTABLE. > + > config DEBUG_VM > bool "Debug VM" > depends on DEBUG_KERNEL > @@ -688,6 +694,26 @@ config DEBUG_VM_PGFLAGS > > If unsure, say N. > > +config DEBUG_VM_PGTABLE > + bool "Debug arch page table for semantics compliance" > + depends on MMU > + depends on !IA64 && !ARM > + depends on ARCH_HAS_DEBUG_VM_PGTABLE || EXPERT > + default n if !ARCH_HAS_DEBUG_VM_PGTABLE > + default y if DEBUG_VM > + help > + This option provides a debug method which can be used to test > + architecture page table helper functions on various platforms in > + verifying if they comply with expected generic MM semantics. This > + will help architecture code in making sure that any changes or > + new additions of these helpers still conform to expected > + semantics of the generic MM. Platforms will have to opt in for > + this through ARCH_HAS_DEBUG_VM_PGTABLE. Although it can also be > + enabled through EXPERT without requiring code change. This test > + is disabled on IA64 and ARM platforms where it fails to build. > + > + If unsure, say N. > + > config ARCH_HAS_DEBUG_VIRTUAL > bool > > diff --git a/mm/Makefile b/mm/Makefile > index 272e66039e70..b0692e6a4b58 100644 > --- a/mm/Makefile > +++ b/mm/Makefile > @@ -87,6 +87,7 @@ obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o > obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o > obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak-test.o > obj-$(CONFIG_DEBUG_RODATA_TEST) += rodata_test.o > +obj-$(CONFIG_DEBUG_VM_PGTABLE) += debug_vm_pgtable.o > obj-$(CONFIG_PAGE_OWNER) += page_owner.o > obj-$(CONFIG_CLEANCACHE) += cleancache.o > obj-$(CONFIG_MEMORY_ISOLATION) += page_isolation.o > diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c > new file mode 100644 > index 000000000000..70bf8ed8fd51 > --- /dev/null > +++ b/mm/debug_vm_pgtable.c > @@ -0,0 +1,389 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * This kernel test validates architecture page table helpers and > + * accessors and helps in verifying their continued compliance with > + * expected generic MM semantics. > + * > + * Copyright (C) 2019 ARM Ltd. > + * > + * Author: Anshuman Khandual > + */ > +#define pr_fmt(fmt) "debug_vm_pgtable: %s: " fmt, __func__ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * Basic operations > + * > + * mkold(entry) = An old and not a young entry > + * mkyoung(entry) = A young and not an old entry > + * mkdirty(entry) = A dirty and not a clean entry > + * mkclean(entry) = A clean and not a dirty entry > + * mkwrite(entry) = A write and not a write protected entry > + * wrprotect(entry) = A write protected and not a write entry > + * pxx_bad(entry) = A mapped and non-table entry > + * pxx_same(entry1, entry2) = Both entries hold the exact same value > + */ > +#define VMFLAGS (VM_READ|VM_WRITE|VM_EXEC) > + > +/* > + * On s390 platform, the lower 4 bits are used to identify given page table > + * entry type. But these bits might affect the ability to clear entries with > + * pxx_clear() because of how dynamic page table folding works on s390. So > + * while loading up the entries do not change the lower 4 bits. It does not > + * have affect any other platform. > + */ > +#define S390_MASK_BITS 4 > +#define RANDOM_ORVALUE GENMASK(BITS_PER_LONG - 1, S390_MASK_BITS) > +#define RANDOM_NZVALUE GENMASK(7, 0) > + > +static void __init pte_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pte_t pte = pfn_pte(pfn, prot); > + > + WARN_ON(!pte_same(pte, pte)); > + WARN_ON(!pte_young(pte_mkyoung(pte_mkold(pte)))); > + WARN_ON(!pte_dirty(pte_mkdirty(pte_mkclean(pte)))); > + WARN_ON(!pte_write(pte_mkwrite(pte_wrprotect(pte)))); > + WARN_ON(pte_young(pte_mkold(pte_mkyoung(pte)))); > + WARN_ON(pte_dirty(pte_mkclean(pte_mkdirty(pte)))); > + WARN_ON(pte_write(pte_wrprotect(pte_mkwrite(pte)))); > +} > + > +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pmd_t pmd = pfn_pmd(pfn, prot); > + > + WARN_ON(!pmd_same(pmd, pmd)); > + WARN_ON(!pmd_young(pmd_mkyoung(pmd_mkold(pmd)))); > + WARN_ON(!pmd_dirty(pmd_mkdirty(pmd_mkclean(pmd)))); > + WARN_ON(!pmd_write(pmd_mkwrite(pmd_wrprotect(pmd)))); > + WARN_ON(pmd_young(pmd_mkold(pmd_mkyoung(pmd)))); > + WARN_ON(pmd_dirty(pmd_mkclean(pmd_mkdirty(pmd)))); > + WARN_ON(pmd_write(pmd_wrprotect(pmd_mkwrite(pmd)))); > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pmd_bad(). > + */ > + WARN_ON(!pmd_bad(pmd_mkhuge(pmd))); > +} > + > +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pud_t pud = pfn_pud(pfn, prot); > + > + WARN_ON(!pud_same(pud, pud)); > + WARN_ON(!pud_young(pud_mkyoung(pud_mkold(pud)))); > + WARN_ON(!pud_write(pud_mkwrite(pud_wrprotect(pud)))); > + WARN_ON(pud_write(pud_wrprotect(pud_mkwrite(pud)))); > + WARN_ON(pud_young(pud_mkold(pud_mkyoung(pud)))); > + > + if (mm_pmd_folded(mm)) > + return; > + > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pud_bad(). > + */ > + WARN_ON(!pud_bad(pud_mkhuge(pud))); > +} > +#else > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > +#else > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) { } > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > + > +static void __init p4d_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + p4d_t p4d; > + > + memset(&p4d, RANDOM_NZVALUE, sizeof(p4d_t)); > + WARN_ON(!p4d_same(p4d, p4d)); > +} > + > +static void __init pgd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pgd_t pgd; > + > + memset(&pgd, RANDOM_NZVALUE, sizeof(pgd_t)); > + WARN_ON(!pgd_same(pgd, pgd)); > +} > + > +#ifndef __PAGETABLE_PUD_FOLDED > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) > +{ > + pud_t pud = READ_ONCE(*pudp); > + > + if (mm_pmd_folded(mm)) > + return; > + > + pud = __pud(pud_val(pud) | RANDOM_ORVALUE); > + WRITE_ONCE(*pudp, pud); > + pud_clear(pudp); > + pud = READ_ONCE(*pudp); > + WARN_ON(!pud_none(pud)); > +} > + > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > + pud_t pud; > + > + if (mm_pmd_folded(mm)) > + return; > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pud_bad(). > + */ > + pmd_clear(pmdp); > + pud_clear(pudp); > + pud_populate(mm, pudp, pmdp); > + pud = READ_ONCE(*pudp); > + WARN_ON(pud_bad(pud)); > +} > +#else > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) { } > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > +} > +#endif > + > +#ifndef __PAGETABLE_P4D_FOLDED > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) > +{ > + p4d_t p4d = READ_ONCE(*p4dp); > + > + if (mm_pud_folded(mm)) > + return; > + > + p4d = __p4d(p4d_val(p4d) | RANDOM_ORVALUE); > + WRITE_ONCE(*p4dp, p4d); > + p4d_clear(p4dp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(!p4d_none(p4d)); > +} > + > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > + p4d_t p4d; > + > + if (mm_pud_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as p4d_bad(). > + */ > + pud_clear(pudp); > + p4d_clear(p4dp); > + p4d_populate(mm, p4dp, pudp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(p4d_bad(p4d)); > +} > + > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) > +{ > + pgd_t pgd = READ_ONCE(*pgdp); > + > + if (mm_p4d_folded(mm)) > + return; > + > + pgd = __pgd(pgd_val(pgd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pgdp, pgd); > + pgd_clear(pgdp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(!pgd_none(pgd)); > +} > + > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > + pgd_t pgd; > + > + if (mm_p4d_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pgd_bad(). > + */ > + p4d_clear(p4dp); > + pgd_clear(pgdp); > + pgd_populate(mm, pgdp, p4dp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(pgd_bad(pgd)); > +} > +#else > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) { } > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) { } > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > +} > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > +} > +#endif > + > +static void __init pte_clear_tests(struct mm_struct *mm, pte_t *ptep) > +{ > + pte_t pte = READ_ONCE(*ptep); > + > + pte = __pte(pte_val(pte) | RANDOM_ORVALUE); > + WRITE_ONCE(*ptep, pte); > + pte_clear(mm, 0, ptep); > + pte = READ_ONCE(*ptep); > + WARN_ON(!pte_none(pte)); > +} > + > +static void __init pmd_clear_tests(struct mm_struct *mm, pmd_t *pmdp) > +{ > + pmd_t pmd = READ_ONCE(*pmdp); > + > + pmd = __pmd(pmd_val(pmd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pmdp, pmd); > + pmd_clear(pmdp); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(!pmd_none(pmd)); > +} > + > +static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, > + pgtable_t pgtable) > +{ > + pmd_t pmd; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pmd_bad(). > + */ > + pmd_clear(pmdp); > + pmd_populate(mm, pmdp, pgtable); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(pmd_bad(pmd)); > +} > + > +static unsigned long __init get_random_vaddr(void) > +{ > + unsigned long random_vaddr, random_pages, total_user_pages; > + > + total_user_pages = (TASK_SIZE - FIRST_USER_ADDRESS) / PAGE_SIZE; > + > + random_pages = get_random_long() % total_user_pages; > + random_vaddr = FIRST_USER_ADDRESS + random_pages * PAGE_SIZE; > + > + return random_vaddr; > +} > + > +void __init debug_vm_pgtable(void) > +{ > + struct mm_struct *mm; > + pgd_t *pgdp; > + p4d_t *p4dp, *saved_p4dp; > + pud_t *pudp, *saved_pudp; > + pmd_t *pmdp, *saved_pmdp, pmd; > + pte_t *ptep; > + pgtable_t saved_ptep; > + pgprot_t prot; > + phys_addr_t paddr; > + unsigned long vaddr, pte_aligned, pmd_aligned; > + unsigned long pud_aligned, p4d_aligned, pgd_aligned; > + > + pr_info("Validating architecture page table helpers\n"); > + prot = vm_get_page_prot(VMFLAGS); > + vaddr = get_random_vaddr(); > + mm = mm_alloc(); > + if (!mm) { > + pr_err("mm_struct allocation failed\n"); > + return; > + } > + > + /* > + * PFN for mapping at PTE level is determined from a standard kernel > + * text symbol. But pfns for higher page table levels are derived by > + * masking lower bits of this real pfn. These derived pfns might not > + * exist on the platform but that does not really matter as pfn_pxx() > + * helpers will still create appropriate entries for the test. This > + * helps avoid large memory block allocations to be used for mapping > + * at higher page table levels. > + */ > + paddr = __pa(&start_kernel); > + > + pte_aligned = (paddr & PAGE_MASK) >> PAGE_SHIFT; > + pmd_aligned = (paddr & PMD_MASK) >> PAGE_SHIFT; > + pud_aligned = (paddr & PUD_MASK) >> PAGE_SHIFT; > + p4d_aligned = (paddr & P4D_MASK) >> PAGE_SHIFT; > + pgd_aligned = (paddr & PGDIR_MASK) >> PAGE_SHIFT; > + WARN_ON(!pfn_valid(pte_aligned)); > + > + pgdp = pgd_offset(mm, vaddr); > + p4dp = p4d_alloc(mm, pgdp, vaddr); > + pudp = pud_alloc(mm, p4dp, vaddr); > + pmdp = pmd_alloc(mm, pudp, vaddr); > + ptep = pte_alloc_map(mm, pmdp, vaddr); > + > + /* > + * Save all the page table page addresses as the page table > + * entries will be used for testing with random or garbage > + * values. These saved addresses will be used for freeing > + * page table pages. > + */ > + pmd = READ_ONCE(*pmdp); > + saved_p4dp = p4d_offset(pgdp, 0UL); > + saved_pudp = pud_offset(p4dp, 0UL); > + saved_pmdp = pmd_offset(pudp, 0UL); > + saved_ptep = pmd_pgtable(pmd); > + > + pte_basic_tests(pte_aligned, prot); > + pmd_basic_tests(pmd_aligned, prot); > + pud_basic_tests(pud_aligned, prot); > + p4d_basic_tests(p4d_aligned, prot); > + pgd_basic_tests(pgd_aligned, prot); > + > + pte_clear_tests(mm, ptep); > + pmd_clear_tests(mm, pmdp); > + pud_clear_tests(mm, pudp); > + p4d_clear_tests(mm, p4dp); > + pgd_clear_tests(mm, pgdp); > + > + pte_unmap(ptep); > + > + pmd_populate_tests(mm, pmdp, saved_ptep); > + pud_populate_tests(mm, pudp, saved_pmdp); > + p4d_populate_tests(mm, p4dp, saved_pudp); > + pgd_populate_tests(mm, pgdp, saved_p4dp); > + > + p4d_free(mm, saved_p4dp); > + pud_free(mm, saved_pudp); > + pmd_free(mm, saved_pmdp); > + pte_free(mm, saved_ptep); > + > + mm_dec_nr_puds(mm); > + mm_dec_nr_pmds(mm); > + mm_dec_nr_ptes(mm); > + mmdrop(mm); > +} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_2 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id D8149C4BA10 for ; Wed, 26 Feb 2020 14:10:24 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9C51D2467B for ; Wed, 26 Feb 2020 14:10:24 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="NFwdYntr"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=lca.pw header.i=@lca.pw header.b="YE3R28K0" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9C51D2467B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=lca.pw Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-snps-arc-bounces+linux-snps-arc=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Mime-Version:References:In-Reply-To: Date:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Qxn9wg9zqOlK4btXTfVirXXqeZLRL5aX5+w9BivYXWs=; b=NFwdYntrIWOZgM B1JFkQupWXJ+bnGW64M9lthYeZ2o5dXt7kiARnyUkHv9fvHkJMUZo4Ww1i6WG9BFFsq9T8hNVFAZQ Og2y8e6jp432oFus9M9iiOd8W1Sx2YHJ5qUTrB4c/CuVFC5qt3qlMI54giOf5PgWx0wiaRVy78CDA S/12GKmIdBt7ymqiUFysQuOIhU6bgEG7MK1rmkz+BNNVSdWWPanUnrPMTHumJAYAgedd3JIE5Lu80 91eDi4xj5CHsc4uU+UEeWHqHu0A1D7gQZuNN2JHJRpu1rTzKoYO4jwjULEbEQUiP586dGjydTObNZ IIGWDpaAGkplhryhSM7Q==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6xOH-0004N9-6S; Wed, 26 Feb 2020 14:10:21 +0000 Received: from mail-qt1-x844.google.com ([2607:f8b0:4864:20::844]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6xNm-0002uW-VB for linux-snps-arc@lists.infradead.org; Wed, 26 Feb 2020 14:09:58 +0000 Received: by mail-qt1-x844.google.com with SMTP id l16so2324982qtq.1 for ; Wed, 26 Feb 2020 06:09:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lca.pw; s=google; h=message-id:subject:from:to:cc:date:in-reply-to:references :mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=YE3R28K03/OSkKci4pIu5feJz/Gza2peB1lndyCeGfvTr8WSbzxpFaAqlK/20xrBvl 6QpXE5F7H7Vx83KoDdAzQd4b3z0ApO16qPGG/ft6YbvZNOaPkn87uQWs825uQ85pt/4b 6iLpy8Vc4N/vq91uAhMsYpM6abgr85RtDcb3e6GNiUOwS/8MHsgktIWoPXcHIJX382y4 eQPAzmcZV3HPXCrkguoaDLw2qUKIkkBKWsa0lAG3fgRUaEaHdqBmwboSJl5RPi1yeMej b/aMFlj2uh6WPxJMdvcluXKnXEc/lfM/eeQ1zXrVk7RsLNT7Ol7Bgk22NZcLjJQYlBn5 L7MA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=k2Bt4+cGa4MophgxRw/ekbrcACLpZpsHaJ8ba2EYO3i3X96v8Gsff3RCFHRhq395KS O/qtBK6ZPcdDXYuvV7bIQ+4Ppcq1yHu1Dv3YxH0MOfrZB1NNA8lQcN1fZZ2PwqMNeJ7F ChWbuiRPXH2EEIkEsiMcaVhZPdbFv+RB87ZN/FDT28c3gQecO+ACcxe+s361aScD3jkM TesoVp6FLWwMNCIaRinNlRwTrKq8oyRU1W9tvUVEP2AOZfYZqPmU7x/0IU5ItCVGYuPy 6TdPp7rh8ckWpL/HWIpypcLXdpxMEEreNlja7MiYPTZybmlDhzF/76nxcDKZ9Cv5Ixyc 1HYw== X-Gm-Message-State: APjAAAUe1MVOK6k+a452YpS6uoma5eODJ27EkaDPbEWeKJSzRY4yl8fk Vhb0KkysjiAmILzB6US9ooao9Q== X-Google-Smtp-Source: APXvYqxRvESuFPk6siqL9qo/1/2cXkkp2ceYeSTQ/uCoTGJhGid6usa2pYO6rAddiidPiSORcGRtfQ== X-Received: by 2002:ac8:2bf8:: with SMTP id n53mr5572816qtn.1.1582726185762; Wed, 26 Feb 2020 06:09:45 -0800 (PST) Received: from dhcp-41-57.bos.redhat.com (nat-pool-bos-t.redhat.com. [66.187.233.206]) by smtp.gmail.com with ESMTPSA id b5sm1176402qkg.110.2020.02.26.06.09.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 26 Feb 2020 06:09:44 -0800 (PST) Message-ID: <1582726182.7365.123.camel@lca.pw> Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers From: Qian Cai To: Anshuman Khandual , linux-mm@kvack.org Date: Wed, 26 Feb 2020 09:09:42 -0500 In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> X-Mailer: Evolution 3.22.6 (3.22.6-10.el7) Mime-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200226_060951_036767_D81EF98B X-CRM114-Status: GOOD ( 24.77 ) X-BeenThere: linux-snps-arc@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on Synopsys ARC Processors List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Catalin Marinas , Heiko Carstens , Paul Mackerras , "H. Peter Anvin" , linux-riscv@lists.infradead.org, Will Deacon , linux-arch@vger.kernel.org, linux-s390@vger.kernel.org, Michael Ellerman , x86@kernel.org, Mike Rapoport , Christian Borntraeger , Ingo Molnar , Benjamin Herrenschmidt , linux-snps-arc@lists.infradead.org, Vasily Gorbik , Borislav Petkov , Paul Walmsley , "Kirill A . Shutemov" , Thomas Gleixner , linux-arm-kernel@lists.infradead.org, Christophe Leroy , Vineet Gupta , linux-kernel@vger.kernel.org, Palmer Dabbelt , Andrew Morton , linuxppc-dev@lists.ozlabs.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-snps-arc" Errors-To: linux-snps-arc-bounces+linux-snps-arc=archiver.kernel.org@lists.infradead.org T24gTW9uLCAyMDIwLTAyLTE3IGF0IDA4OjQ3ICswNTMwLCBBbnNodW1hbiBLaGFuZHVhbCB3cm90 ZToKPiBUaGlzIGFkZHMgdGVzdHMgd2hpY2ggd2lsbCB2YWxpZGF0ZSBhcmNoaXRlY3R1cmUgcGFn ZSB0YWJsZSBoZWxwZXJzIGFuZAo+IG90aGVyIGFjY2Vzc29ycyBpbiB0aGVpciBjb21wbGlhbmNl IHdpdGggZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3MuCj4gVGhpcyB3aWxsIGhlbHAgdmFy aW91cyBhcmNoaXRlY3R1cmVzIGluIHZhbGlkYXRpbmcgY2hhbmdlcyB0byBleGlzdGluZwo+IHBh Z2UgdGFibGUgaGVscGVycyBvciBhZGRpdGlvbiBvZiBuZXcgb25lcy4KPiAKPiBUaGlzIHRlc3Qg Y292ZXJzIGJhc2ljIHBhZ2UgdGFibGUgZW50cnkgdHJhbnNmb3JtYXRpb25zIGluY2x1ZGluZyBi dXQgbm90Cj4gbGltaXRlZCB0byBvbGQsIHlvdW5nLCBkaXJ0eSwgY2xlYW4sIHdyaXRlLCB3cml0 ZSBwcm90ZWN0IGV0YyBhdCB2YXJpb3VzCj4gbGV2ZWwgYWxvbmcgd2l0aCBwb3B1bGF0aW5nIGlu dGVybWVkaWF0ZSBlbnRyaWVzIHdpdGggbmV4dCBwYWdlIHRhYmxlIHBhZ2UKPiBhbmQgdmFsaWRh dGluZyB0aGVtLgo+IAo+IFRlc3QgcGFnZSB0YWJsZSBwYWdlcyBhcmUgYWxsb2NhdGVkIGZyb20g c3lzdGVtIG1lbW9yeSB3aXRoIHJlcXVpcmVkIHNpemUKPiBhbmQgYWxpZ25tZW50cy4gVGhlIG1h cHBlZCBwZm5zIGF0IHBhZ2UgdGFibGUgbGV2ZWxzIGFyZSBkZXJpdmVkIGZyb20gYQo+IHJlYWwg cGZuIHJlcHJlc2VudGluZyBhIHZhbGlkIGtlcm5lbCB0ZXh0IHN5bWJvbC4gVGhpcyB0ZXN0IGdl dHMgY2FsbGVkCj4gaW5zaWRlIGtlcm5lbF9pbml0KCkgcmlnaHQgYWZ0ZXIgYXN5bmNfc3luY2hy b25pemVfZnVsbCgpLgo+IAo+IFRoaXMgdGVzdCBnZXRzIGJ1aWx0IGFuZCBydW4gd2hlbiBDT05G SUdfREVCVUdfVk1fUEdUQUJMRSBpcyBzZWxlY3RlZC4gQW55Cj4gYXJjaGl0ZWN0dXJlLCB3aGlj aCBpcyB3aWxsaW5nIHRvIHN1YnNjcmliZSB0aGlzIHRlc3Qgd2lsbCBuZWVkIHRvIHNlbGVjdAo+ IEFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUuIEZvciBub3cgdGhpcyBpcyBsaW1pdGVkIHRvIGFy YywgYXJtNjQsIHg4NiwgczM5MAo+IGFuZCBwcGMzMiBwbGF0Zm9ybXMgd2hlcmUgdGhlIHRlc3Qg aXMga25vd24gdG8gYnVpbGQgYW5kIHJ1biBzdWNjZXNzZnVsbHkuCj4gR29pbmcgZm9yd2FyZCwg b3RoZXIgYXJjaGl0ZWN0dXJlcyB0b28gY2FuIHN1YnNjcmliZSB0aGUgdGVzdCBhZnRlciBmaXhp bmcKPiBhbnkgYnVpbGQgb3IgcnVudGltZSBwcm9ibGVtcyB3aXRoIHRoZWlyIHBhZ2UgdGFibGUg aGVscGVycy4gTWVhbndoaWxlIGZvcgo+IGJldHRlciBwbGF0Zm9ybSBjb3ZlcmFnZSwgdGhlIHRl c3QgY2FuIGFsc28gYmUgZW5hYmxlZCB3aXRoIENPTkZJR19FWFBFUlQKPiBldmVuIHdpdGhvdXQg QVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRS4KPiAKPiBGb2xrcyBpbnRlcmVzdGVkIGluIG1ha2lu ZyBzdXJlIHRoYXQgYSBnaXZlbiBwbGF0Zm9ybSdzIHBhZ2UgdGFibGUgaGVscGVycwo+IGNvbmZv cm0gdG8gZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3Mgc2hvdWxkIGVuYWJsZSB0aGUgYWJv dmUgY29uZmlnCj4gd2hpY2ggd2lsbCBqdXN0IHRyaWdnZXIgdGhpcyB0ZXN0IGR1cmluZyBib290 LiBBbnkgbm9uIGNvbmZvcm1pdHkgaGVyZSB3aWxsCj4gYmUgcmVwb3J0ZWQgYXMgYW4gd2Fybmlu ZyB3aGljaCB3b3VsZCBuZWVkIHRvIGJlIGZpeGVkLiBUaGlzIHRlc3Qgd2lsbCBoZWxwCj4gY2F0 Y2ggYW55IGNoYW5nZXMgdG8gdGhlIGFncmVlZCB1cG9uIHNlbWFudGljcyBleHBlY3RlZCBmcm9t IGdlbmVyaWMgTU0gYW5kCj4gZW5hYmxlIHBsYXRmb3JtcyB0byBhY2NvbW1vZGF0ZSBpdCB0aGVy ZWFmdGVyLgoKSG93IHVzZWZ1bCBpcyB0aGlzIHRoYXQgc3RyYWlnaHRseSBjcmFzaCB0aGUgcG93 ZXJwYz8KClvCoMKgwqAyMy4yNjM0MjVdW8KgwqDCoMKgVDFdIGRlYnVnX3ZtX3BndGFibGU6IGRl YnVnX3ZtX3BndGFibGU6IFZhbGlkYXRpbmcKYXJjaGl0ZWN0dXJlIHBhZ2UgdGFibGUgaGVscGVy cwpbwqDCoMKgMjMuMjYzNjI1XVvCoMKgwqDCoFQxXSAtLS0tLS0tLS0tLS1bIGN1dCBoZXJlIF0t LS0tLS0tLS0tLS0KW8KgwqDCoDIzLjI2MzY0OV1bwqDCoMKgwqBUMV0ga2VybmVsIEJVRyBhdCBh cmNoL3Bvd2VycGMvbW0vcGd0YWJsZS5jOjI3NCEKW8KgwqDCoDIzLjI2MzY3NV1bwqDCoMKgwqBU MV0gT29wczogRXhjZXB0aW9uIGluIGtlcm5lbCBtb2RlLCBzaWc6IDUgWyMxXQpbwqDCoMKgMjMu MjYzNjk4XVvCoMKgwqDCoFQxXSBMRSBQQUdFX1NJWkU9NjRLIE1NVT1SYWRpeCBTTVAgTlJfQ1BV Uz0yNTYKREVCVUdfUEFHRUFMTE9DIE5VTUEgUG93ZXJOVgpbwqDCoMKgMjMuMjYzNzMxXVvCoMKg wqDCoFQxXSBNb2R1bGVzIGxpbmtlZCBpbjoKW8KgwqDCoDIzLjI2Mzc1Ml1bwqDCoMKgwqBUMV0g Q1BVOiA0IFBJRDogMSBDb21tOiBzd2FwcGVyLzAgTm90IHRhaW50ZWQgNS42LjAtcmMzLW5leHQt CjIwMjAwMjI2ICMxClvCoMKgwqAyMy4yNjM3NzZdW8KgwqDCoMKgVDFdIE5JUDrCoMKgYzAwMDAw MDAwMDA3MzA4YyBMUjogYzAwMDAwMDAwMTAzZGJkOCBDVFI6CjAwMDAwMDAwMDAwMDAwMDAKW8Kg wqDCoDIzLjI2MzgxMF1bwqDCoMKgwqBUMV0gUkVHUzogYzAwMDAwMDAzZGRhZjljMCBUUkFQOiAw NzAwwqDCoMKgTm90IHRhaW50ZWTCoMKgKDUuNi4wLQpyYzMtbmV4dC0yMDIwMDIyNikKW8KgwqDC oDIzLjI2Mzg0Nl1bwqDCoMKgwqBUMV0gTVNSOsKgwqA5MDAwMDAwMDAwMDI5MDMzIDxTRixIVixF RSxNRSxJUixEUixSSSxMRT7CoMKgQ1I6CjIyMDAwMjI4wqDCoFhFUjogMDAwMDAwMDAKW8KgwqDC oDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gQ0ZBUjogYzAwMDAwMDAwMDA3MzAzMCBJUlFNQVNLOiAw wqAKW8KgwqDCoDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gR1BSMDA6IGMwMDAwMDAwMDEwM2RiZDgg YzAwMDAwMDAzZGRhZmM1MCBjMDAwMDAwMDAxNjU2ZjAwCmMwMDAwMDFkN2I0Y2EwODDCoApbwqDC oMKgMjMuMjYzODg4XVvCoMKgwqDCoFQxXSBHUFIwNDogMDAwMDAwMDAwMDAwMDAwMCAwMDAwMDAw MDAwMDAwMDA5IGMwMDAwMDAwM2RkYWZjMDQKMDAwMDAwMDAwMDAwMDAwMMKgClvCoMKgwqAyMy4y NjM4ODhdW8KgwqDCoMKgVDFdIEdQUjA4OiBmMGZmZmZmZmZmZmZmZmZmIDAwMDAwMDAwMDAwMDAw MDEgYzAwMDAwMDAwMTYyNzlkMAowMDAwMDAwMDAwMGEwMDAwwqAKW8KgwqDCoDIzLjI2Mzg4OF1b wqDCoMKgwqBUMV0gR1BSMTI6IDAwMDAwMDAwMDAwMDAwMDAgYzAwMDAwMWZmZmZmYWUwMCBjMDAw MDAwMDAwMDEwZTg0CjAwMDAwMDAwMDAwMDAwMDDCoApbwqDCoMKgMjMuMjYzODg4XVvCoMKgwqDC oFQxXSBHUFIxNjogMDAwMDAwMDAwMDAwMDAwMCA4MDAwMDAwMDAwMDAwMTA1IDAwMDAwMDAwMDAw MDAxMDAKYzAwMDAwMDAwMTY4OWExOMKgClvCoMKgwqAyMy4yNjM4ODhdW8KgwqDCoMKgVDFdIEdQ UjIwOiBjMDAwMjAwMzJjNjYwMDAwIGMwMDAyMDAzMmM2MjAwMDAgYzAwMDAwMDAwMTcxNjAzMApj MDAwMjAwMzJjNjAwMDAwwqAKW8KgwqDCoDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gR1BSMjQ6IDAw MDAwMDAwMDAwMDAwMGQgYzAwMDAwMDAwMTcxNjAzMCBjMDAwMDAxZDdiNGNhMDgwCmMwMDAwMDAw MDE3MTYwNDDCoApbwqDCoMKgMjMuMjYzODg4XVvCoMKgwqDCoFQxXSBHUFIyODogYzAwMDAwMDAw MTcxNjAzOCAwMDAwMDAwMDAwMDAwMDAwIDAwMDAwMDAwMDAwMDAwMDAKMDAwMDAwMDAwMDAwMDAw MMKgClvCoMKgwqAyMy4yNjQxMjJdW8KgwqDCoMKgVDFdIE5JUCBbYzAwMDAwMDAwMDA3MzA4Y10g YXNzZXJ0X3B0ZV9sb2NrZWQrMHgxMWMvMHgzMjAKW8KgwqDCoDIzLjI2NDE1NF1bwqDCoMKgwqBU MV0gTFIgW2MwMDAwMDAwMDEwM2RiZDhdIGRlYnVnX3ZtX3BndGFibGUrMHg3NzAvMHhiN2MKW8Kg wqDCoDIzLjI2NDE4Nl1bwqDCoMKgwqBUMV0gQ2FsbCBUcmFjZToKW8KgwqDCoDIzLjI2NDIwNl1b wqDCoMKgwqBUMV0gW2MwMDAwMDAwM2RkYWZjNTBdIFtjMDAwMDAwMDAwOTk5NzYwXQpfcmF3X3Nw aW5fdW5sb2NrKzB4MzAvMHg3MCAodW5yZWxpYWJsZSkKW8KgwqDCoDIzLjI2NDI0NF1bwqDCoMKg wqBUMV0gW2MwMDAwMDAwM2RkYWZjZDBdIFtjMDAwMDAwMDAxMDNkOTI0XQpkZWJ1Z192bV9wZ3Rh YmxlKzB4NGJjLzB4YjdjClvCoMKgwqAyMy4yNjQyNzldW8KgwqDCoMKgVDFdIFtjMDAwMDAwMDNk ZGFmZGIwXSBbYzAwMDAwMDAwMDAxMGVhY10Ka2VybmVsX2luaXQrMHgzMC8weDE5NApbwqDCoMKg MjMuMjY0MzE1XVvCoMKgwqDCoFQxXSBbYzAwMDAwMDAzZGRhZmUyMF0gW2MwMDAwMDAwMDAwMGI3 NDhdCnJldF9mcm9tX2tlcm5lbF90aHJlYWQrMHg1Yy8weDc0ClvCoMKgwqAyMy4yNjQzNDldW8Kg wqDCoMKgVDFdIEluc3RydWN0aW9uIGR1bXA6ClvCoMKgwqAyMy4yNjQzNjhdW8KgwqDCoMKgVDFd IDYwMDAwMDAwIDNiZTAwMDAxIDdmYmVmNDM2IGVhZmEwMDQwIDdmZmZjMDMwIDNiZmZmZmZmCjdm ZmYwN2I0IDdmZmZmMDM4wqAKW8KgwqDCoDIzLjI2NDQwOV1bwqDCoMKgwqBUMV0gN2JmZjFmMjQg N2QzN2Y4MmEgN2QyOTAwNzQgNzkyOWQxODIgPDBiMDkwMDAwPiBlYmRiMDAwMAplOTNjMDAwMCA3 ZmRlNGExNMKgClvCoMKgwqAyMy4yNjQ0NjBdW8KgwqDCoMKgVDFdIC0tLVsgZW5kIHRyYWNlIDcy ZDI5MzEwMjJlOWFiMjQgXS0tLQpbwqDCoMKgMjMuNjI3MzExXVvCoMKgwqDCoFQxXcKgClvCoMKg wqAyNC42Mjc0MDddW8KgwqDCoMKgVDFdIEtlcm5lbCBwYW5pYyAtIG5vdCBzeW5jaW5nOiBGYXRh bCBleGNlcHRpb24KW8KgwqDCoDI2LjUKCj4gCj4gQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGlu dXgtZm91bmRhdGlvbi5vcmc+Cj4gQ2M6IE1pa2UgUmFwb3BvcnQgPHJwcHRAbGludXguaWJtLmNv bT4KPiBDYzogVmluZWV0IEd1cHRhIDx2Z3VwdGFAc3lub3BzeXMuY29tPgo+IENjOiBDYXRhbGlu IE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+IENjOiBXaWxsIERlYWNvbiA8d2ls bEBrZXJuZWwub3JnPgo+IENjOiBCZW5qYW1pbiBIZXJyZW5zY2htaWR0IDxiZW5oQGtlcm5lbC5j cmFzaGluZy5vcmc+Cj4gQ2M6IFBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgo+IENj OiBNaWNoYWVsIEVsbGVybWFuIDxtcGVAZWxsZXJtYW4uaWQuYXU+Cj4gQ2M6IEhlaWtvIENhcnN0 ZW5zIDxoZWlrby5jYXJzdGVuc0BkZS5pYm0uY29tPgo+IENjOiBWYXNpbHkgR29yYmlrIDxnb3JA bGludXguaWJtLmNvbT4KPiBDYzogQ2hyaXN0aWFuIEJvcm50cmFlZ2VyIDxib3JudHJhZWdlckBk ZS5pYm0uY29tPgo+IENjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KPiBD YzogSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+Cj4gQ2M6IEJvcmlzbGF2IFBldGtvdiA8 YnBAYWxpZW44LmRlPgo+IENjOiAiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPgo+IENj OiBLaXJpbGwgQS4gU2h1dGVtb3YgPGtpcmlsbEBzaHV0ZW1vdi5uYW1lPgo+IENjOiBQYXVsIFdh bG1zbGV5IDxwYXVsLndhbG1zbGV5QHNpZml2ZS5jb20+Cj4gQ2M6IFBhbG1lciBEYWJiZWx0IDxw YWxtZXJAZGFiYmVsdC5jb20+Cj4gQ2M6IGxpbnV4LXNucHMtYXJjQGxpc3RzLmluZnJhZGVhZC5v cmcKPiBDYzogbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCj4gQ2M6IGxpbnV4 cHBjLWRldkBsaXN0cy5vemxhYnMub3JnCj4gQ2M6IGxpbnV4LXMzOTBAdmdlci5rZXJuZWwub3Jn Cj4gQ2M6IGxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKPiBDYzogeDg2QGtlcm5lbC5v cmcKPiBDYzogbGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogbGludXgta2VybmVsQHZn ZXIua2VybmVsLm9yZwo+IAo+IFN1Z2dlc3RlZC1ieTogQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGlu Lm1hcmluYXNAYXJtLmNvbT4KPiBSZXZpZXdlZC1ieTogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5l bC5vcmc+Cj4gVGVzdGVkLWJ5OiBHZXJhbGQgU2NoYWVmZXIgPGdlcmFsZC5zY2hhZWZlckBkZS5p Ym0uY29tPgkjIHMzOTAKPiBUZXN0ZWQtYnk6IENocmlzdG9waGUgTGVyb3kgPGNocmlzdG9waGUu bGVyb3lAYy1zLmZyPgkjIHBwYzMyCj4gU2lnbmVkLW9mZi1ieTogQW5kcmV3IE1vcnRvbiA8YWtw bUBsaW51eC1mb3VuZGF0aW9uLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGhlIExlcm95 IDxjaHJpc3RvcGhlLmxlcm95QGMtcy5mcj4KPiBTaWduZWQtb2ZmLWJ5OiBBbnNodW1hbiBLaGFu ZHVhbCA8YW5zaHVtYW4ua2hhbmR1YWxAYXJtLmNvbT4KPiAtLS0KPiBUaGlzIGFkZHMgYSB0ZXN0 IHZhbGlkYXRpb24gZm9yIGFyY2hpdGVjdHVyZSBleHBvcnRlZCBwYWdlIHRhYmxlIGhlbHBlcnMu Cj4gUGF0Y2ggYWRkcyBiYXNpYyB0cmFuc2Zvcm1hdGlvbiB0ZXN0cyBhdCB2YXJpb3VzIGxldmVs cyBvZiB0aGUgcGFnZSB0YWJsZS4KPiAKPiBUaGlzIHRlc3Qgd2FzIG9yaWdpbmFsbHkgc3VnZ2Vz dGVkIGJ5IENhdGFsaW4gZHVyaW5nIGFybTY0IFRIUCBtaWdyYXRpb24KPiBSRkMgZGlzY3Vzc2lv biBlYXJsaWVyLiBHb2luZyBmb3J3YXJkIGl0IGNhbiBpbmNsdWRlIG1vcmUgc3BlY2lmaWMgdGVz dHMKPiB3aXRoIHJlc3BlY3QgdG8gdmFyaW91cyBnZW5lcmljIE1NIGZ1bmN0aW9ucyBsaWtlIFRI UCwgSHVnZVRMQiBldGMgYW5kCj4gcGxhdGZvcm0gc3BlY2lmaWMgdGVzdHMuCj4gCj4gaHR0cHM6 Ly9sb3JlLmtlcm5lbC5vcmcvbGludXgtbW0vMjAxOTA2MjgxMDIwMDMuR0E1NjQ2M0BhcnJha2lz LmVtZWEuYXJtLmNvbS8KPiAKPiBOZWVkcyB0byBiZSBhcHBsaWVkIG9uIGxpbnV4IFY1LjYtcmMy Cj4gCj4gQ2hhbmdlcyBpbiBWMTQ6Cj4gCj4gLSBEaXNhYmxlZCBERUJVR19WTV9QR0ZMQUdTIGZv ciBJQTY0IGFuZCBBUk0gKDMyIEJpdCkgcGVyIEFuZHJldyBhbmQgQ2hyaXN0b3BoZQo+IC0gVXBk YXRlZCBERUJVR19WTV9QR0ZMQUdTIGRvY3VtZW50YXRpb24gd3J0IEVYUEVSVCBhbmQgZGlzYWJs ZWQgcGxhdGZvcm1zCj4gLSBVcGRhdGVkIFJBTkRPTV9bT1J8TlpdVkFMVUUgb3BlbiBlbmNvZGlu Z3Mgd2l0aCBHRU5NQVNLKCkgcGVyIENhdGFsaW4KPiAtIFVwZGF0ZWQgczM5MCBjb25zdHJhaW50 IGJpdHMgZnJvbSAxMiB0byA0IChTMzkwX01BU0tfQklUUykgcGVyIEdlcmFsZAo+IC0gVXBkYXRl ZCBpbi1jb2RlIGRvY3VtZW50YXRpb24gZm9yIFJBTkRPTV9PUlZBTFVFIHBlciBHZXJhbGQKPiAt IFVwZGF0ZWQgcHh4X2Jhc2ljX3Rlc3RzKCkgdG8gdXNlIGludmVydCBmdW5jdGlvbnMgZmlyc3Qg cGVyIENhdGFsaW4KPiAtIERyb3BwZWQgQVJDSF9IQVNfNExFVkVMX0hBQ0sgY2hlY2sgZnJvbSBw dWRfYmFzaWNfdGVzdHMoKQo+IC0gUmVwbGFjZWQgX19BUkNIX0hBU19bNHw1XUxFVkVMX0hBQ0sg d2l0aCBfX1BBR0VUQUJMRV9bUFVEfFA0RF1fRk9MREVEIHBlciBDYXRhbGluCj4gLSBUcmltbWVk IHRoZSBDQyBsaXN0IG9uIHRoZSBjb21taXQgbWVzc2FnZSBwZXIgQ2F0YWxpbgo+IAo+IENoYW5n ZXMgaW4gVjEzOiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1t L2xpc3QvP3Nlcmllcz0yMzcxMjUpCj4gCj4gLSBTdWJzY3JpYmVkIHMzOTAgcGxhdGZvcm0gYW5k IHVwZGF0ZWQgZGVidWctdm0tcGd0YWJsZS9hcmNoLXN1cHBvcnQudHh0IHBlciBHZXJhbGQKPiAt IERyb3BwZWQga2V5d29yZCAnZXh0ZXJuJyBmcm9tIGRlYnVnX3ZtX3BndGFibGUoKSBkZWNsYXJh dGlvbiBwZXIgQ2hyaXN0b3BoZQo+IC0gTW92ZWQgZGVidWdfdm1fcGd0YWJsZSgpIGRlY2xhcmF0 aW9ucyB0byA8bGludXgvbW1kZWJ1Zy5oPiBwZXIgQ2hyaXN0b3BoZQo+IC0gTW92ZWQgZGVidWdf dm1fcGd0YWJsZSgpIGNhbGwgc2l0ZSBpbnRvIGtlcm5lbF9pbml0KCkgcGVyIENocmlzdG9waGUK PiAtIENoYW5nZWQgQ09ORklHX0RFQlVHX1ZNX1BHVEFCTEUgcnVsZXMgcGVyIENocmlzdG9waGUK PiAtIFVwZGF0ZWQgY29tbWl0IHRvIGluY2x1ZGUgbmV3IHN1cHBvcnRlZCBwbGF0Zm9ybXMgYW5k IGNoYW5nZWQgY29uZmlnIHNlbGVjdGlvbgo+IAo+IENoYW5nZXMgaW4gVjEyOiAoaHR0cHM6Ly9w YXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xpc3QvP3Nlcmllcz0yMzM5MDUp Cj4gCj4gLSBSZXBsYWNlZCBfX21tZHJvcCgpIHdpdGggbW1kcm9wKCkKPiAtIEVuYWJsZSBBUkNI X0hBU19ERUJVR19WTV9QR1RBQkxFIG9uIFg4NiBmb3Igbm9uIENPTkZJR19YODZfUEFFIHBsYXRm b3JtcyBhcyB0aGUKPiAgIHRlc3QgcHJvY2VkdXJlIGludGVyZmVyZSB3aXRoIHByZS1hbGxvY2F0 ZWQgUE1EcyBhdHRhY2hlZCB0byB0aGUgUEdEIHJlc3VsdGluZwo+ICAgaW4gcnVudGltZSBmYWls dXJlcyB3aXRoIFZNX0JVR19PTigpCj4gCj4gQ2hhbmdlcyBpbiBWMTE6IChodHRwczovL3BhdGNo d29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVzPTIyMTEzNSkKPiAK PiAtIFJlYmFzZWQgdGhlIHBhdGNoIG9uIFY1LjQKPiAKPiBDaGFuZ2VzIGluIFYxMDogKGh0dHBz Oi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJvamVjdC9saW51eC1tbS9saXN0Lz9zZXJpZXM9MjA1 NTI5KQo+IAo+IC0gQWx3YXlzIGVuYWJsZSBERUJVR19WTV9QR1RBQkxFIHdoZW4gREVCVUdfVk0g aXMgZW5hYmxlZCBwZXIgSW5nbwo+IC0gQWRkZWQgdGFncyBmcm9tIEluZ28KPiAKPiBDaGFuZ2Vz IGluIFY5OiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xp c3QvP3Nlcmllcz0yMDE0MjkpCj4gCj4gLSBDaGFuZ2VkIGZlYXR1cmUgc3VwcG9ydCBlbnVtZXJh dGlvbiBmb3IgcG93ZXJwYyBwbGF0Zm9ybXMgcGVyIENocmlzdG9waGUKPiAtIENoYW5nZWQgY29u ZmlnIHdyYXBwZXIgZm9yIGJhc2ljX1twbWR8cHVkXV90ZXN0cygpIHRvIGVuYWJsZSBBUkMgcGxh dGZvcm0KPiAtIEVuYWJsZWQgdGhlIHRlc3Qgb24gQVJDIHBsYXRmb3JtCj4gCj4gQ2hhbmdlcyBp biBWODogKGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJvamVjdC9saW51eC1tbS9saXN0 Lz9zZXJpZXM9MTk0Mjk3KQo+IAo+IC0gRW5hYmxlZCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxF IG9uIFBQQzMyIHBsYXRmb3JtIHBlciBDaHJpc3RvcGhlCj4gLSBVcGRhdGVkIGZlYXR1cmUgZG9j dW1lbnRhdGlvbiBhcyBERUJVR19WTV9QR1RBQkxFIGlzIG5vdyBlbmFibGVkIG9uIFBQQzMyIHBs YXRmb3JtCj4gLSBNb3ZlZCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFIGVhcmxpZXIgdG8gaW5k ZW50IGl0IHdpdGggREVCVUdfVk0gcGVyIENocmlzdG9waGUKPiAtIEFkZGVkIGFuIGluZm9ybWF0 aW9uIG1lc3NhZ2UgaW4gZGVidWdfdm1fcGd0YWJsZSgpIHBlciBDaHJpc3RvcGhlCj4gLSBEcm9w cGVkIHJhbmRvbV92YWRkciBib3VuZGFyeSBjb25kaXRpb24gY2hlY2tzIHBlciBDaHJpc3RvcGhl IGFuZCBRaWFuCj4gLSBSZXBsYWNlZCB2aXJ0X2FkZHJfdmFsaWQoKSBjaGVjayB3aXRoIHBmbl92 YWxpZCgpIGNoZWNrIGluIGRlYnVnX3ZtX3BndGFibGUoKQo+IC0gU2xpZ2h0bHkgY2hhbmdlZCBw cl9mbXQoZm10KSBpbmZvcm1hdGlvbgo+IAo+IENoYW5nZXMgaW4gVjc6IChodHRwczovL3BhdGNo d29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVzPTE5MzA1MSkKPiAK PiAtIE1lbW9yeSBhbGxvY2F0aW9uIGFuZCBmcmVlIHJvdXRpbmVzIGZvciBtYXBwZWQgcGFnZXMg aGF2ZSBiZWVuIGRyb3BlZAo+IC0gTWFwcGVkIHBmbnMgYXJlIGRlcml2ZWQgZnJvbSBzdGFuZGFy ZCBrZXJuZWwgdGV4dCBzeW1ib2wgcGVyIE1hdHRoZXcKPiAtIE1vdmVkIGRlYnVnX3ZtX3BndGFh YmxlKCkgYWZ0ZXIgcGFnZV9hbGxvY19pbml0X2xhdGUoKSBwZXIgTWljaGFsIGFuZCBRaWFuIAo+ IC0gVXBkYXRlZCB0aGUgY29tbWl0IG1lc3NhZ2UgcGVyIE1pY2hhbAo+IC0gVXBkYXRlZCBXPTEg R0NDIHdhcm5pbmcgcHJvYmxlbSBvbiB4ODYgcGVyIFFpYW4gQ2FpCj4gLSBBZGRpdGlvbiBvZiBu ZXcgYWxsb2NfY29udGlnX3BhZ2VzKCkgaGVscGVyIGhhcyBiZWVuIHN1Ym1pdHRlZCBzZXBhcmF0 ZWx5Cj4gCj4gQ2hhbmdlcyBpbiBWNjogKGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJv amVjdC9saW51eC1tbS9saXN0Lz9zZXJpZXM9MTg3NTg5KQo+IAo+IC0gTW92ZWQgYWxsb2NfZ2ln YW50aWNfcGFnZV9vcmRlcigpIGludG8gbW0vcGFnZV9hbGxvYy5jIHBlciBNaWNoYWwKPiAtIE1v dmVkIGFsbG9jX2dpZ2FudGljX3BhZ2Vfb3JkZXIoKSB3aXRoaW4gQ09ORklHX0NPTlRJR19BTExP QyBpbiB0aGUgdGVzdAo+IC0gRm9sZGVkIEFuZHJldydzIGluY2x1ZGUvYXNtLWdlbmVyaWMvcGd0 YWJsZS5oIGZpeCBpbnRvIHRoZSB0ZXN0IHBhdGNoIDIvMgo+IAo+IENoYW5nZXMgaW4gVjU6ICho dHRwczovL3BhdGNod29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVz PTE4NTk5MSkKPiAKPiAtIFJlZGVmaW5lZCBhbmQgbW92ZWQgWDg2IG1tX3A0ZF9mb2xkZWQoKSBp bnRvIGEgZGlmZmVyZW50IGhlYWRlciBwZXIgS2lyaWxsL0luZ28KPiAtIFVwZGF0ZWQgdGhlIGNv bmZpZyBvcHRpb24gY29tbWVudCBwZXIgSW5nbyBhbmQgZHJvcHBlZCAna2VybmVsIG1vZHVsZScg cmVmZXJlbmNlCj4gLSBVcGRhdGVkIHRoZSBjb21taXQgbWVzc2FnZSBhbmQgZHJvcHBlZCAna2Vy bmVsIG1vZHVsZScgcmVmZXJlbmNlCj4gLSBDaGFuZ2VkIERFQlVHX0FSQ0hfUEdUQUJMRV9URVNU IGludG8gREVCVUdfVk1fUEdUQUJMRSBwZXIgSW5nbwo+IC0gTW92ZWQgY29uZmlnIG9wdGlvbiBm cm9tIG1tL0tjb25maWcuZGVidWcgaW50byBsaWIvS2NvbmZpZy5kZWJ1Zwo+IC0gUmVuYW1lZCBj b3JlIHRlc3QgZnVuY3Rpb24gYXJjaF9wZ3RhYmxlX3Rlc3RzKCkgYXMgZGVidWdfdm1fcGd0YWJs ZSgpCj4gLSBSZW5hbWVkIG1tL2FyY2hfcGd0YWJsZV90ZXN0LmMgYXMgbW0vZGVidWdfdm1fcGd0 YWJsZS5jCj4gLSBkZWJ1Z192bV9wZ3RhYmxlKCkgZ2V0cyBjYWxsZWQgZnJvbSBrZXJuZWxfaW5p dF9mcmVlYWJsZSgpIGFmdGVyIGluaXRfbW1faW50ZXJuYWxzKCkKPiAtIEFkZGVkIGFuIGVudHJ5 IGluIERvY3VtZW50YXRpb24vZmVhdHVyZXMvZGVidWcvIHBlciBJbmdvCj4gLSBFbmFibGVkIHRo ZSB0ZXN0IG9uIGFybTY0IGFuZCB4ODYgcGxhdGZvcm1zIGZvciBub3cKPiAKPiBDaGFuZ2VzIGlu IFY0OiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xpc3Qv P3Nlcmllcz0xODM0NjUpCj4gCj4gLSBEaXNhYmxlIERFQlVHX0FSQ0hfUEdUQUJMRV9URVNUIGZv ciBBUk0gYW5kIElBNjQgcGxhdGZvcm1zCj4gCj4gQ2hhbmdlcyBpbiBWMzogKGh0dHBzOi8vbG9y ZS5rZXJuZWwub3JnL3BhdGNod29yay9wcm9qZWN0L2xrbWwvbGlzdC8/c2VyaWVzPTQxMTIxNikK PiAKPiAtIENoYW5nZWQgdGVzdCB0cmlnZ2VyIGZyb20gbW9kdWxlIGZvcm1hdCBpbnRvIGxhdGVf aW5pdGNhbGwoKQo+IC0gTWFya2VkIGFsbCBmdW5jdGlvbnMgd2l0aCBfX2luaXQgdG8gYmUgZnJl ZWQgYWZ0ZXIgY29tcGxldGlvbgo+IC0gQ2hhbmdlZCBhbGwgX19QR1RBQkxFX1BYWF9GT0xERUQg Y2hlY2tzIGFzIG1tX3B4eF9mb2xkZWQoKQo+IC0gRm9sZGVkIGluIFBQQzMyIGZpeGVzIGZyb20g Q2hyaXN0b3BoZQo+IAo+IENoYW5nZXMgaW4gVjI6Cj4gCj4gaHR0cHM6Ly9sb3JlLmtlcm5lbC5v cmcvbGludXgtbW0vMTU2ODI2ODE3My0zMTMwMi0xLWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmto YW5kdWFsQGFybS5jb20vVC8jdAo+IAo+IC0gRml4ZWQgc21hbGwgdHlwbyBlcnJvciBpbiBNT0RV TEVfREVTQ1JJUFRJT04oKQo+IC0gRml4ZWQgbTY0ayBidWlsZCBwcm9ibGVtcyBmb3IgbHZhbHVl IGNvbmNlcm5zIGluIHBtZF94eHhfdGVzdHMoKQo+IC0gRml4ZWQgZHluYW1pYyBwYWdlIHRhYmxl IGxldmVsIGZvbGRpbmcgcHJvYmxlbXMgb24geDg2IGFzIHBlciBLaXJyaWwKPiAtIEZpeGVkIHNl Y29uZCBwb2ludGVycyBkdXJpbmcgcHh4X3BvcHVsYXRlX3Rlc3RzKCkgcGVyIEtpcmlsbCBhbmQg R2VyYWxkCj4gLSBBbGxvY2F0ZSBhbmQgZnJlZSBwdGUgdGFibGUgd2l0aCBwdGVfYWxsb2Nfb25l L3B0ZV9mcmVlIHBlciBLaXJpbGwKPiAtIE1vZGlmaWVkIHB4eF9jbGVhcl90ZXN0cygpIHRvIGFj Y29tbW9kYXRlIHMzOTAgbG93ZXIgMTIgYml0cyBzaXR1YXRpb24KPiAtIENoYW5nZWQgUkFORE9N X05aVkFMVUUgdmFsdWUgZnJvbSAweGJlIHRvIDB4ZmYKPiAtIENoYW5nZWQgYWxsb2NhdGlvbiwg dXNhZ2UsIGZyZWUgc2VxdWVuY2UgZm9yIHNhdmVkX3B0ZXAKPiAtIFJlbmFtZWQgVk1BX0ZMQUdT IGFzIFZNRkxBR1MKPiAtIEltcGxlbWVudGVkIGEgbmV3IG1ldGhvZCBmb3IgcmFuZG9tIHZhZGRy IGdlbmVyYXRpb24KPiAtIEltcGxlbWVudGVkIHNvbWUgb3RoZXIgY2xlYW51cHMKPiAtIERyb3Bw ZWQgZXh0ZXJuIHJlZmVyZW5jZSB0byBtbV9hbGxvYygpCj4gLSBDcmVhdGVkIGFuZCBleHBvcnRl ZCBuZXcgYWxsb2NfZ2lnYW50aWNfcGFnZV9vcmRlcigpCj4gLSBEcm9wcGVkIHRoZSBjdXN0b20g YWxsb2NhdG9yIGFuZCB1c2VkIG5ldyBhbGxvY19naWdhbnRpY19wYWdlX29yZGVyKCkKPiAKPiBD aGFuZ2VzIGluIFYxOgo+IAo+IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xpbnV4LW1tLzE1Njc0 OTc3MDYtODY0OS0xLWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmtoYW5kdWFsQGFybS5jb20vCj4g Cj4gLSBBZGRlZCBmYWxsYmFjayBtZWNoYW5pc20gZm9yIFBNRCBhbGlnbmVkIG1lbW9yeSBhbGxv Y2F0aW9uIGZhaWx1cmUKPiAKPiBDaGFuZ2VzIGluIFJGQyBWMjoKPiAKPiBodHRwczovL2xvcmUu a2VybmVsLm9yZy9saW51eC1tbS8xNTY1MzM1OTk4LTIyNTUzLTEtZ2l0LXNlbmQtZW1haWwtYW5z aHVtYW4ua2hhbmR1YWxAYXJtLmNvbS9ULyN1Cj4gCj4gLSBNb3ZlZCB0ZXN0IG1vZHVsZSBhbmQg aXQncyBjb25maWcgZnJvbSBsaWIvIHRvIG1tLwo+IC0gUmVuYW1lZCBjb25maWcgVEVTVF9BUkNI X1BHVEFCTEUgYXMgREVCVUdfQVJDSF9QR1RBQkxFX1RFU1QKPiAtIFJlbmFtZWQgZmlsZSBmcm9t IHRlc3RfYXJjaF9wZ3RhYmxlLmMgdG8gYXJjaF9wZ3RhYmxlX3Rlc3QuYwo+IC0gQWRkZWQgcmVs ZXZhbnQgTU9EVUxFX0RFU0NSSVBUSU9OKCkgYW5kIE1PRFVMRV9BVVRIT1IoKSBkZXRhaWxzCj4g LSBEcm9wcGVkIGxvYWRhYmxlIG1vZHVsZSBjb25maWcgb3B0aW9uCj4gLSBCYXNpYyB0ZXN0cyBu b3cgdXNlIG1lbW9yeSBibG9ja3Mgd2l0aCByZXF1aXJlZCBzaXplIGFuZCBhbGlnbm1lbnQKPiAt IFBVRCBhbGlnbmVkIG1lbW9yeSBibG9jayBnZXRzIGFsbG9jYXRlZCB3aXRoIGFsbG9jX2NvbnRp Z19yYW5nZSgpCj4gLSBJZiBQVUQgYWxpZ25lZCBtZW1vcnkgY291bGQgbm90IGJlIGFsbG9jYXRl ZCBpdCBmYWxscyBiYWNrIG9uIFBNRCBhbGlnbmVkCj4gICBtZW1vcnkgYmxvY2sgZnJvbSBwYWdl IGFsbG9jYXRvciBhbmQgcHVkXyogdGVzdHMgYXJlIHNraXBwZWQKPiAtIENsZWFyIGFuZCBwb3B1 bGF0ZSB0ZXN0cyBub3cgb3BlcmF0ZSBvbiByZWFsIGluIG1lbW9yeSBwYWdlIHRhYmxlIGVudHJp ZXMKPiAtIER1bW15IG1tX3N0cnVjdCBnZXRzIGFsbG9jYXRlZCB3aXRoIG1tX2FsbG9jKCkKPiAt IER1bW15IHBhZ2UgdGFibGUgZW50cmllcyBnZXQgYWxsb2NhdGVkIHdpdGggW3B1ZHxwbWR8cHRl XV9hbGxvY19bbWFwXSgpCj4gLSBTaW1wbGlmaWVkIFtwNGR8cGdkXV9iYXNpY190ZXN0cygpLCBu b3cgaGFzIHJhbmRvbSB2YWx1ZXMgaW4gdGhlIGVudHJpZXMKPiAKPiBPcmlnaW5hbCBSRkMgVjE6 Cj4gCj4gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvbGludXgtbW0vMTU2NDAzNzcyMy0yNjY3Ni0x LWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmtoYW5kdWFsQGFybS5jb20vCj4gCj4gCj4gIC4uLi9k ZWJ1Zy9kZWJ1Zy12bS1wZ3RhYmxlL2FyY2gtc3VwcG9ydC50eHQgICB8ICAzNSArKwo+ICBhcmNo L2FyYy9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L2FybTY0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3Bvd2VycGMvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3MzOTAvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3g4Ni9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlXzY0LmggICAgICAgICAgICAgfCAgIDYgKwo+ICBpbmNs dWRlL2xpbnV4L21tZGVidWcuaCAgICAgICAgICAgICAgICAgICAgICAgfCAgIDUgKwo+ICBpbml0 L21haW4uYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKwo+ICBsaWIv S2NvbmZpZy5kZWJ1ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMjYgKysKPiAgbW0v TWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgbW0v ZGVidWdfdm1fcGd0YWJsZS5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgMzg5ICsrKysrKysr KysrKysrKysrKwo+ICAxMiBmaWxlcyBjaGFuZ2VkLCA0NjkgaW5zZXJ0aW9ucygrKQo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9mZWF0dXJlcy9kZWJ1Zy9kZWJ1Zy12bS1wZ3Rh YmxlL2FyY2gtc3VwcG9ydC50eHQKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IG1tL2RlYnVnX3ZtX3Bn dGFibGUuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZlYXR1cmVzL2RlYnVnL2Rl YnVnLXZtLXBndGFibGUvYXJjaC1zdXBwb3J0LnR4dCBiL0RvY3VtZW50YXRpb24vZmVhdHVyZXMv ZGVidWcvZGVidWctdm0tcGd0YWJsZS9hcmNoLXN1cHBvcnQudHh0Cj4gbmV3IGZpbGUgbW9kZSAx MDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjY0ZDBmOWIxNWM0OQo+IC0tLSAvZGV2L251bGwK PiArKysgYi9Eb2N1bWVudGF0aW9uL2ZlYXR1cmVzL2RlYnVnL2RlYnVnLXZtLXBndGFibGUvYXJj aC1zdXBwb3J0LnR4dAo+IEBAIC0wLDAgKzEsMzUgQEAKPiArIwo+ICsjIEZlYXR1cmUgbmFtZTog ICAgICAgICAgZGVidWctdm0tcGd0YWJsZQo+ICsjICAgICAgICAgS2NvbmZpZzogICAgICAgQVJD SF9IQVNfREVCVUdfVk1fUEdUQUJMRQo+ICsjICAgICAgICAgZGVzY3JpcHRpb246ICAgYXJjaCBz dXBwb3J0cyBwZ3RhYmxlIHRlc3RzIGZvciBzZW1hbnRpY3MgY29tcGxpYW5jZQo+ICsjCj4gKyAg ICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICsgICAgfCAgICAgICAgIGFyY2ggfHN0YXR1c3wK PiArICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gKyAgICB8ICAgICAgIGFscGhhOiB8IFRP RE8gfAo+ICsgICAgfCAgICAgICAgIGFyYzogfCAgb2sgIHwKPiArICAgIHwgICAgICAgICBhcm06 IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgIGFybTY0OiB8ICBvayAgfAo+ICsgICAgfCAgICAgICAg IGM2eDogfCBUT0RPIHwKPiArICAgIHwgICAgICAgIGNza3k6IHwgVE9ETyB8Cj4gKyAgICB8ICAg ICAgIGg4MzAwOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgaGV4YWdvbjogfCBUT0RPIHwKPiArICAg IHwgICAgICAgIGlhNjQ6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgICBtNjhrOiB8IFRPRE8gfAo+ ICsgICAgfCAgbWljcm9ibGF6ZTogfCBUT0RPIHwKPiArICAgIHwgICAgICAgIG1pcHM6IHwgVE9E TyB8Cj4gKyAgICB8ICAgICAgIG5kczMyOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgICBuaW9zMjog fCBUT0RPIHwKPiArICAgIHwgICAgb3BlbnJpc2M6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgcGFy aXNjOiB8IFRPRE8gfAo+ICsgICAgfCAgcG93ZXJwYy8zMjogfCAgb2sgIHwKPiArICAgIHwgIHBv d2VycGMvNjQ6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgIHJpc2N2OiB8IFRPRE8gfAo+ICsgICAg fCAgICAgICAgczM5MDogfCAgb2sgIHwKPiArICAgIHwgICAgICAgICAgc2g6IHwgVE9ETyB8Cj4g KyAgICB8ICAgICAgIHNwYXJjOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgICAgICB1bTogfCBUT0RP IHwKPiArICAgIHwgICB1bmljb3JlMzI6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgICAgeDg2OiB8 ICBvayAgfAo+ICsgICAgfCAgICAgIHh0ZW5zYTogfCBUT0RPIHwKPiArICAgIC0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJjL0tjb25maWcgYi9hcmNoL2FyYy9L Y29uZmlnCj4gaW5kZXggZmYyYTM5M2I2MzVjLi4zZTcyZTZjZjBlNDIgMTAwNjQ0Cj4gLS0tIGEv YXJjaC9hcmMvS2NvbmZpZwo+ICsrKyBiL2FyY2gvYXJjL0tjb25maWcKPiBAQCAtNiw2ICs2LDcg QEAKPiAgY29uZmlnIEFSQwo+ICAJZGVmX2Jvb2wgeQo+ICAJc2VsZWN0IEFSQ19USU1FUlMKPiAr CXNlbGVjdCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gIAlzZWxlY3QgQVJDSF9IQVNfRE1B X1BSRVBfQ09IRVJFTlQKPiAgCXNlbGVjdCBBUkNIX0hBU19QVEVfU1BFQ0lBTAo+ICAJc2VsZWN0 IEFSQ0hfSEFTX1NFVFVQX0RNQV9PUFMKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9LY29uZmln IGIvYXJjaC9hcm02NC9LY29uZmlnCj4gaW5kZXggMGIzMGU4ODRlMDg4Li5hYWY4YmE0MTUxNDUg MTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02NC9LY29uZmlnCj4gKysrIGIvYXJjaC9hcm02NC9LY29u ZmlnCj4gQEAgLTExLDYgKzExLDcgQEAgY29uZmlnIEFSTTY0Cj4gIAlzZWxlY3QgQUNQSV9QUFRU IGlmIEFDUEkKPiAgCXNlbGVjdCBBUkNIX0NMT0NLU09VUkNFX0RBVEEKPiAgCXNlbGVjdCBBUkNI X0hBU19ERUJVR19WSVJUVUFMCj4gKwlzZWxlY3QgQVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRQo+ ICAJc2VsZWN0IEFSQ0hfSEFTX0RFVk1FTV9JU19BTExPV0VECj4gIAlzZWxlY3QgQVJDSF9IQVNf RE1BX1BSRVBfQ09IRVJFTlQKPiAgCXNlbGVjdCBBUkNIX0hBU19BQ1BJX1RBQkxFX1VQR1JBREUg aWYgQUNQSQo+IGRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvS2NvbmZpZyBiL2FyY2gvcG93ZXJw Yy9LY29uZmlnCj4gaW5kZXggNDk3YjdkMGIyZDdlLi44ZDVhZTE0YzVkNGMgMTAwNjQ0Cj4gLS0t IGEvYXJjaC9wb3dlcnBjL0tjb25maWcKPiArKysgYi9hcmNoL3Bvd2VycGMvS2NvbmZpZwo+IEBA IC0xMTYsNiArMTE2LDcgQEAgY29uZmlnIFBQQwo+ICAJIwo+ICAJc2VsZWN0IEFSQ0hfMzJCSVRf T0ZGX1QgaWYgUFBDMzIKPiAgCXNlbGVjdCBBUkNIX0hBU19ERUJVR19WSVJUVUFMCj4gKwlzZWxl Y3QgQVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRSBpZiBQUEMzMgo+ICAJc2VsZWN0IEFSQ0hfSEFT X0RFVk1FTV9JU19BTExPV0VECj4gIAlzZWxlY3QgQVJDSF9IQVNfRUxGX1JBTkRPTUlaRQo+ICAJ c2VsZWN0IEFSQ0hfSEFTX0ZPUlRJRllfU09VUkNFCj4gZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9L Y29uZmlnIGIvYXJjaC9zMzkwL0tjb25maWcKPiBpbmRleCA4YWJlNzc1MzZkOWQuLmFmMjg0ZGJi MDdlNyAxMDA2NDQKPiAtLS0gYS9hcmNoL3MzOTAvS2NvbmZpZwo+ICsrKyBiL2FyY2gvczM5MC9L Y29uZmlnCj4gQEAgLTU5LDYgKzU5LDcgQEAgY29uZmlnIEtBU0FOX1NIQURPV19PRkZTRVQKPiAg Y29uZmlnIFMzOTAKPiAgCWRlZl9ib29sIHkKPiAgCXNlbGVjdCBBUkNIX0JJTkZNVF9FTEZfU1RB VEUKPiArCXNlbGVjdCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gIAlzZWxlY3QgQVJDSF9I QVNfREVWTUVNX0lTX0FMTE9XRUQKPiAgCXNlbGVjdCBBUkNIX0hBU19FTEZfUkFORE9NSVpFCj4g IAlzZWxlY3QgQVJDSF9IQVNfRk9SVElGWV9TT1VSQ0UKPiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYv S2NvbmZpZyBiL2FyY2gveDg2L0tjb25maWcKPiBpbmRleCBiZWVhNzcwNDZmOWIuLmRmOGExOWU1 MmU4MiAxMDA2NDQKPiAtLS0gYS9hcmNoL3g4Ni9LY29uZmlnCj4gKysrIGIvYXJjaC94ODYvS2Nv bmZpZwo+IEBAIC02MSw2ICs2MSw3IEBAIGNvbmZpZyBYODYKPiAgCXNlbGVjdCBBUkNIX0NMT0NL U09VUkNFX0lOSVQKPiAgCXNlbGVjdCBBUkNIX0hBU19BQ1BJX1RBQkxFX1VQR1JBREUJaWYgQUNQ SQo+ICAJc2VsZWN0IEFSQ0hfSEFTX0RFQlVHX1ZJUlRVQUwKPiArCXNlbGVjdCBBUkNIX0hBU19E RUJVR19WTV9QR1RBQkxFCWlmICFYODZfUEFFCj4gIAlzZWxlY3QgQVJDSF9IQVNfREVWTUVNX0lT X0FMTE9XRUQKPiAgCXNlbGVjdCBBUkNIX0hBU19FTEZfUkFORE9NSVpFCj4gIAlzZWxlY3QgQVJD SF9IQVNfRkFTVF9NVUxUSVBMSUVSCj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNt L3BndGFibGVfNjQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfNjQuaAo+IGluZGV4 IDBiNmM0MDQyOTQyYS4uZmIwZTc2ZDI1NGIzIDEwMDY0NAo+IC0tLSBhL2FyY2gveDg2L2luY2x1 ZGUvYXNtL3BndGFibGVfNjQuaAo+ICsrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVf NjQuaAo+IEBAIC01Myw2ICs1MywxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgc3luY19pbml0aWFs X3BhZ2VfdGFibGUodm9pZCkgeyB9Cj4gIAo+ICBzdHJ1Y3QgbW1fc3RydWN0Owo+ICAKPiArI2Rl ZmluZSBtbV9wNGRfZm9sZGVkIG1tX3A0ZF9mb2xkZWQKPiArc3RhdGljIGlubGluZSBib29sIG1t X3A0ZF9mb2xkZWQoc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArCXJldHVybiAhcGd0YWJs ZV9sNV9lbmFibGVkKCk7Cj4gK30KPiArCj4gIHZvaWQgc2V0X3B0ZV92YWRkcl9wNGQocDRkX3Qg KnA0ZF9wYWdlLCB1bnNpZ25lZCBsb25nIHZhZGRyLCBwdGVfdCBuZXdfcHRlKTsKPiAgdm9pZCBz ZXRfcHRlX3ZhZGRyX3B1ZChwdWRfdCAqcHVkX3BhZ2UsIHVuc2lnbmVkIGxvbmcgdmFkZHIsIHB0 ZV90IG5ld19wdGUpOwo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbWRlYnVnLmgg Yi9pbmNsdWRlL2xpbnV4L21tZGVidWcuaAo+IGluZGV4IDJhZDcyZDJjOGNjNS4uNTMzOWFhMTRi NzQ5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW1kZWJ1Zy5oCj4gKysrIGIvaW5jbHVk ZS9saW51eC9tbWRlYnVnLmgKPiBAQCAtNjQsNCArNjQsOSBAQCB2b2lkIGR1bXBfbW0oY29uc3Qg c3RydWN0IG1tX3N0cnVjdCAqbW0pOwo+ICAjZGVmaW5lIFZNX0JVR19PTl9QR0ZMQUdTKGNvbmQs IHBhZ2UpIEJVSUxEX0JVR19PTl9JTlZBTElEKGNvbmQpCj4gICNlbmRpZgo+ICAKPiArI2lmZGVm IENPTkZJR19ERUJVR19WTV9QR1RBQkxFCj4gK3ZvaWQgZGVidWdfdm1fcGd0YWJsZSh2b2lkKTsK PiArI2Vsc2UKPiArc3RhdGljIGlubGluZSB2b2lkIGRlYnVnX3ZtX3BndGFibGUodm9pZCkgeyB9 Cj4gKyNlbmRpZgo+ICAjZW5kaWYKPiBkaWZmIC0tZ2l0IGEvaW5pdC9tYWluLmMgYi9pbml0L21h aW4uYwo+IGluZGV4IGNjMGVlNDg3MzQxOS4uYWRmMzdlOGIxZDY5IDEwMDY0NAo+IC0tLSBhL2lu aXQvbWFpbi5jCj4gKysrIGIvaW5pdC9tYWluLmMKPiBAQCAtOTQsNiArOTQsNyBAQAo+ICAjaW5j bHVkZSA8bGludXgvcm9kYXRhX3Rlc3QuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2p1bXBfbGFiZWwu aD4KPiAgI2luY2x1ZGUgPGxpbnV4L21lbV9lbmNyeXB0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t bWRlYnVnLmg+Cj4gIAo+ICAjaW5jbHVkZSA8YXNtL2lvLmg+Cj4gICNpbmNsdWRlIDxhc20vYnVn cy5oPgo+IEBAIC0xMzIzLDYgKzEzMjQsNyBAQCBzdGF0aWMgaW50IF9fcmVmIGtlcm5lbF9pbml0 KHZvaWQgKnVudXNlZCkKPiAgCWtlcm5lbF9pbml0X2ZyZWVhYmxlKCk7Cj4gIAkvKiBuZWVkIHRv IGZpbmlzaCBhbGwgYXN5bmMgX19pbml0IGNvZGUgYmVmb3JlIGZyZWVpbmcgdGhlIG1lbW9yeSAq Lwo+ICAJYXN5bmNfc3luY2hyb25pemVfZnVsbCgpOwo+ICsJZGVidWdfdm1fcGd0YWJsZSgpOwo+ ICAJZnRyYWNlX2ZyZWVfaW5pdF9tZW0oKTsKPiAgCWZyZWVfaW5pdG1lbSgpOwo+ICAJbWFya19y ZWFkb25seSgpOwo+IGRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmln LmRlYnVnCj4gaW5kZXggNjlkZWY0YTlkZjAwLi4xYjViZDlmN2M5NjcgMTAwNjQ0Cj4gLS0tIGEv bGliL0tjb25maWcuZGVidWcKPiArKysgYi9saWIvS2NvbmZpZy5kZWJ1Zwo+IEBAIC02NTMsNiAr NjUzLDEyIEBAIGNvbmZpZyBTQ0hFRF9TVEFDS19FTkRfQ0hFQ0sKPiAgCSAgZGF0YSBjb3JydXB0 aW9uIG9yIGEgc3BvcmFkaWMgY3Jhc2ggYXQgYSBsYXRlciBzdGFnZSBvbmNlIHRoZSByZWdpb24K PiAgCSAgaXMgZXhhbWluZWQuIFRoZSBydW50aW1lIG92ZXJoZWFkIGludHJvZHVjZWQgaXMgbWlu aW1hbC4KPiAgCj4gK2NvbmZpZyBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gKwlib29sCj4g KwloZWxwCj4gKwkgIEFuIGFyY2hpdGVjdHVyZSBzaG91bGQgc2VsZWN0IHRoaXMgd2hlbiBpdCBj YW4gc3VjY2Vzc2Z1bGx5Cj4gKwkgIGJ1aWxkIGFuZCBydW4gREVCVUdfVk1fUEdUQUJMRS4KPiAr Cj4gIGNvbmZpZyBERUJVR19WTQo+ICAJYm9vbCAiRGVidWcgVk0iCj4gIAlkZXBlbmRzIG9uIERF QlVHX0tFUk5FTAo+IEBAIC02ODgsNiArNjk0LDI2IEBAIGNvbmZpZyBERUJVR19WTV9QR0ZMQUdT Cj4gIAo+ICAJICBJZiB1bnN1cmUsIHNheSBOLgo+ICAKPiArY29uZmlnIERFQlVHX1ZNX1BHVEFC TEUKPiArCWJvb2wgIkRlYnVnIGFyY2ggcGFnZSB0YWJsZSBmb3Igc2VtYW50aWNzIGNvbXBsaWFu Y2UiCj4gKwlkZXBlbmRzIG9uIE1NVQo+ICsJZGVwZW5kcyBvbiAhSUE2NCAmJiAhQVJNCj4gKwlk ZXBlbmRzIG9uIEFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUgfHwgRVhQRVJUCj4gKwlkZWZhdWx0 IG4gaWYgIUFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUKPiArCWRlZmF1bHQgeSBpZiBERUJVR19W TQo+ICsJaGVscAo+ICsJICBUaGlzIG9wdGlvbiBwcm92aWRlcyBhIGRlYnVnIG1ldGhvZCB3aGlj aCBjYW4gYmUgdXNlZCB0byB0ZXN0Cj4gKwkgIGFyY2hpdGVjdHVyZSBwYWdlIHRhYmxlIGhlbHBl ciBmdW5jdGlvbnMgb24gdmFyaW91cyBwbGF0Zm9ybXMgaW4KPiArCSAgdmVyaWZ5aW5nIGlmIHRo ZXkgY29tcGx5IHdpdGggZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3MuIFRoaXMKPiArCSAg d2lsbCBoZWxwIGFyY2hpdGVjdHVyZSBjb2RlIGluIG1ha2luZyBzdXJlIHRoYXQgYW55IGNoYW5n ZXMgb3IKPiArCSAgbmV3IGFkZGl0aW9ucyBvZiB0aGVzZSBoZWxwZXJzIHN0aWxsIGNvbmZvcm0g dG8gZXhwZWN0ZWQKPiArCSAgc2VtYW50aWNzIG9mIHRoZSBnZW5lcmljIE1NLiBQbGF0Zm9ybXMg d2lsbCBoYXZlIHRvIG9wdCBpbiBmb3IKPiArCSAgdGhpcyB0aHJvdWdoIEFSQ0hfSEFTX0RFQlVH X1ZNX1BHVEFCTEUuIEFsdGhvdWdoIGl0IGNhbiBhbHNvIGJlCj4gKwkgIGVuYWJsZWQgdGhyb3Vn aCBFWFBFUlQgd2l0aG91dCByZXF1aXJpbmcgY29kZSBjaGFuZ2UuIFRoaXMgdGVzdAo+ICsJICBp cyBkaXNhYmxlZCBvbiBJQTY0IGFuZCBBUk0gcGxhdGZvcm1zIHdoZXJlIGl0IGZhaWxzIHRvIGJ1 aWxkLgo+ICsKPiArCSAgSWYgdW5zdXJlLCBzYXkgTi4KPiArCj4gIGNvbmZpZyBBUkNIX0hBU19E RUJVR19WSVJUVUFMCj4gIAlib29sCj4gIAo+IGRpZmYgLS1naXQgYS9tbS9NYWtlZmlsZSBiL21t L01ha2VmaWxlCj4gaW5kZXggMjcyZTY2MDM5ZTcwLi5iMDY5MmU2YTRiNTggMTAwNjQ0Cj4gLS0t IGEvbW0vTWFrZWZpbGUKPiArKysgYi9tbS9NYWtlZmlsZQo+IEBAIC04Nyw2ICs4Nyw3IEBAIG9i ai0kKENPTkZJR19IV1BPSVNPTl9JTkpFQ1QpICs9IGh3cG9pc29uLWluamVjdC5vCj4gIG9iai0k KENPTkZJR19ERUJVR19LTUVNTEVBSykgKz0ga21lbWxlYWsubwo+ICBvYmotJChDT05GSUdfREVC VUdfS01FTUxFQUtfVEVTVCkgKz0ga21lbWxlYWstdGVzdC5vCj4gIG9iai0kKENPTkZJR19ERUJV R19ST0RBVEFfVEVTVCkgKz0gcm9kYXRhX3Rlc3Qubwo+ICtvYmotJChDT05GSUdfREVCVUdfVk1f UEdUQUJMRSkgKz0gZGVidWdfdm1fcGd0YWJsZS5vCj4gIG9iai0kKENPTkZJR19QQUdFX09XTkVS KSArPSBwYWdlX293bmVyLm8KPiAgb2JqLSQoQ09ORklHX0NMRUFOQ0FDSEUpICs9IGNsZWFuY2Fj aGUubwo+ICBvYmotJChDT05GSUdfTUVNT1JZX0lTT0xBVElPTikgKz0gcGFnZV9pc29sYXRpb24u bwo+IGRpZmYgLS1naXQgYS9tbS9kZWJ1Z192bV9wZ3RhYmxlLmMgYi9tbS9kZWJ1Z192bV9wZ3Rh YmxlLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNzBiZjhl ZDhmZDUxCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL21tL2RlYnVnX3ZtX3BndGFibGUuYwo+IEBA IC0wLDAgKzEsMzg5IEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkKPiArLyoKPiArICogVGhpcyBrZXJuZWwgdGVzdCB2YWxpZGF0ZXMgYXJjaGl0ZWN0dXJlIHBh Z2UgdGFibGUgaGVscGVycyBhbmQKPiArICogYWNjZXNzb3JzIGFuZCBoZWxwcyBpbiB2ZXJpZnlp bmcgdGhlaXIgY29udGludWVkIGNvbXBsaWFuY2Ugd2l0aAo+ICsgKiBleHBlY3RlZCBnZW5lcmlj IE1NIHNlbWFudGljcy4KPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE5IEFSTSBMdGQuCj4g KyAqCj4gKyAqIEF1dGhvcjogQW5zaHVtYW4gS2hhbmR1YWwgPGFuc2h1bWFuLmtoYW5kdWFsQGFy bS5jb20+Cj4gKyAqLwo+ICsjZGVmaW5lIHByX2ZtdChmbXQpICJkZWJ1Z192bV9wZ3RhYmxlOiAl czogIiBmbXQsIF9fZnVuY19fCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvZ2ZwLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9oaWdobWVtLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9odWdldGxiLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2tjb25maWcuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L21tLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tbWFuLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tbV90eXBlcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9wZm5fdC5oPgo+ICsjaW5jbHVkZSA8bGludXgvcHJpbnRrLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9yYW5kb20uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zd2FwLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zd2Fwb3BzLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zdGFydF9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NjaGVk L21tLmg+Cj4gKyNpbmNsdWRlIDxhc20vcGdhbGxvYy5oPgo+ICsjaW5jbHVkZSA8YXNtL3BndGFi bGUuaD4KPiArCj4gKy8qCj4gKyAqIEJhc2ljIG9wZXJhdGlvbnMKPiArICoKPiArICogbWtvbGQo ZW50cnkpCQkJPSBBbiBvbGQgYW5kIG5vdCBhIHlvdW5nIGVudHJ5Cj4gKyAqIG1reW91bmcoZW50 cnkpCQk9IEEgeW91bmcgYW5kIG5vdCBhbiBvbGQgZW50cnkKPiArICogbWtkaXJ0eShlbnRyeSkJ CT0gQSBkaXJ0eSBhbmQgbm90IGEgY2xlYW4gZW50cnkKPiArICogbWtjbGVhbihlbnRyeSkJCT0g QSBjbGVhbiBhbmQgbm90IGEgZGlydHkgZW50cnkKPiArICogbWt3cml0ZShlbnRyeSkJCT0gQSB3 cml0ZSBhbmQgbm90IGEgd3JpdGUgcHJvdGVjdGVkIGVudHJ5Cj4gKyAqIHdycHJvdGVjdChlbnRy eSkJCT0gQSB3cml0ZSBwcm90ZWN0ZWQgYW5kIG5vdCBhIHdyaXRlIGVudHJ5Cj4gKyAqIHB4eF9i YWQoZW50cnkpCQk9IEEgbWFwcGVkIGFuZCBub24tdGFibGUgZW50cnkKPiArICogcHh4X3NhbWUo ZW50cnkxLCBlbnRyeTIpCT0gQm90aCBlbnRyaWVzIGhvbGQgdGhlIGV4YWN0IHNhbWUgdmFsdWUK PiArICovCj4gKyNkZWZpbmUgVk1GTEFHUwkoVk1fUkVBRHxWTV9XUklURXxWTV9FWEVDKQo+ICsK PiArLyoKPiArICogT24gczM5MCBwbGF0Zm9ybSwgdGhlIGxvd2VyIDQgYml0cyBhcmUgdXNlZCB0 byBpZGVudGlmeSBnaXZlbiBwYWdlIHRhYmxlCj4gKyAqIGVudHJ5IHR5cGUuIEJ1dCB0aGVzZSBi aXRzIG1pZ2h0IGFmZmVjdCB0aGUgYWJpbGl0eSB0byBjbGVhciBlbnRyaWVzIHdpdGgKPiArICog cHh4X2NsZWFyKCkgYmVjYXVzZSBvZiBob3cgZHluYW1pYyBwYWdlIHRhYmxlIGZvbGRpbmcgd29y a3Mgb24gczM5MC4gU28KPiArICogd2hpbGUgbG9hZGluZyB1cCB0aGUgZW50cmllcyBkbyBub3Qg Y2hhbmdlIHRoZSBsb3dlciA0IGJpdHMuIEl0IGRvZXMgbm90Cj4gKyAqIGhhdmUgYWZmZWN0IGFu eSBvdGhlciBwbGF0Zm9ybS4KPiArICovCj4gKyNkZWZpbmUgUzM5MF9NQVNLX0JJVFMJNAo+ICsj ZGVmaW5lIFJBTkRPTV9PUlZBTFVFCUdFTk1BU0soQklUU19QRVJfTE9ORyAtIDEsIFMzOTBfTUFT S19CSVRTKQo+ICsjZGVmaW5lIFJBTkRPTV9OWlZBTFVFCUdFTk1BU0soNywgMCkKPiArCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwdGVfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpCj4gK3sKPiArCXB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPiArCj4g KwlXQVJOX09OKCFwdGVfc2FtZShwdGUsIHB0ZSkpOwo+ICsJV0FSTl9PTighcHRlX3lvdW5nKHB0 ZV9ta3lvdW5nKHB0ZV9ta29sZChwdGUpKSkpOwo+ICsJV0FSTl9PTighcHRlX2RpcnR5KHB0ZV9t a2RpcnR5KHB0ZV9ta2NsZWFuKHB0ZSkpKSk7Cj4gKwlXQVJOX09OKCFwdGVfd3JpdGUocHRlX21r d3JpdGUocHRlX3dycHJvdGVjdChwdGUpKSkpOwo+ICsJV0FSTl9PTihwdGVfeW91bmcocHRlX21r b2xkKHB0ZV9ta3lvdW5nKHB0ZSkpKSk7Cj4gKwlXQVJOX09OKHB0ZV9kaXJ0eShwdGVfbWtjbGVh bihwdGVfbWtkaXJ0eShwdGUpKSkpOwo+ICsJV0FSTl9PTihwdGVfd3JpdGUocHRlX3dycHJvdGVj dChwdGVfbWt3cml0ZShwdGUpKSkpOwo+ICt9Cj4gKwo+ICsjaWZkZWYgQ09ORklHX1RSQU5TUEFS RU5UX0hVR0VQQUdFCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfYmFzaWNfdGVzdHModW5zaWdu ZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4gK3sKPiArCXBtZF90IHBtZCA9IHBmbl9wbWQo cGZuLCBwcm90KTsKPiArCj4gKwlXQVJOX09OKCFwbWRfc2FtZShwbWQsIHBtZCkpOwo+ICsJV0FS Tl9PTighcG1kX3lvdW5nKHBtZF9ta3lvdW5nKHBtZF9ta29sZChwbWQpKSkpOwo+ICsJV0FSTl9P TighcG1kX2RpcnR5KHBtZF9ta2RpcnR5KHBtZF9ta2NsZWFuKHBtZCkpKSk7Cj4gKwlXQVJOX09O KCFwbWRfd3JpdGUocG1kX21rd3JpdGUocG1kX3dycHJvdGVjdChwbWQpKSkpOwo+ICsJV0FSTl9P TihwbWRfeW91bmcocG1kX21rb2xkKHBtZF9ta3lvdW5nKHBtZCkpKSk7Cj4gKwlXQVJOX09OKHBt ZF9kaXJ0eShwbWRfbWtjbGVhbihwbWRfbWtkaXJ0eShwbWQpKSkpOwo+ICsJV0FSTl9PTihwbWRf d3JpdGUocG1kX3dycHJvdGVjdChwbWRfbWt3cml0ZShwbWQpKSkpOwo+ICsJLyoKPiArCSAqIEEg aHVnZSBwYWdlIGRvZXMgbm90IHBvaW50IHRvIG5leHQgbGV2ZWwgcGFnZSB0YWJsZQo+ICsJICog ZW50cnkuIEhlbmNlIHRoaXMgbXVzdCBxdWFsaWZ5IGFzIHBtZF9iYWQoKS4KPiArCSAqLwo+ICsJ V0FSTl9PTighcG1kX2JhZChwbWRfbWtodWdlKHBtZCkpKTsKPiArfQo+ICsKPiArI2lmZGVmIENP TkZJR19IQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwdWRfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4g K3sKPiArCXB1ZF90IHB1ZCA9IHBmbl9wdWQocGZuLCBwcm90KTsKPiArCj4gKwlXQVJOX09OKCFw dWRfc2FtZShwdWQsIHB1ZCkpOwo+ICsJV0FSTl9PTighcHVkX3lvdW5nKHB1ZF9ta3lvdW5nKHB1 ZF9ta29sZChwdWQpKSkpOwo+ICsJV0FSTl9PTighcHVkX3dyaXRlKHB1ZF9ta3dyaXRlKHB1ZF93 cnByb3RlY3QocHVkKSkpKTsKPiArCVdBUk5fT04ocHVkX3dyaXRlKHB1ZF93cnByb3RlY3QocHVk X21rd3JpdGUocHVkKSkpKTsKPiArCVdBUk5fT04ocHVkX3lvdW5nKHB1ZF9ta29sZChwdWRfbWt5 b3VuZyhwdWQpKSkpOwo+ICsKPiArCWlmIChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47 Cj4gKwo+ICsJLyoKPiArCSAqIEEgaHVnZSBwYWdlIGRvZXMgbm90IHBvaW50IHRvIG5leHQgbGV2 ZWwgcGFnZSB0YWJsZQo+ICsJICogZW50cnkuIEhlbmNlIHRoaXMgbXVzdCBxdWFsaWZ5IGFzIHB1 ZF9iYWQoKS4KPiArCSAqLwo+ICsJV0FSTl9PTighcHVkX2JhZChwdWRfbWtodWdlKHB1ZCkpKTsK PiArfQo+ICsjZWxzZQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2Jhc2ljX3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPiArI2VuZGlmCj4gKyNlbHNlCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwbWRfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpIHsgfQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2Jhc2ljX3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPiArI2VuZGlmCj4gKwo+ICtzdGF0aWMg dm9pZCBfX2luaXQgcDRkX2Jhc2ljX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KQo+ICt7Cj4gKwlwNGRfdCBwNGQ7Cj4gKwo+ICsJbWVtc2V0KCZwNGQsIFJBTkRPTV9OWlZB TFVFLCBzaXplb2YocDRkX3QpKTsKPiArCVdBUk5fT04oIXA0ZF9zYW1lKHA0ZCwgcDRkKSk7Cj4g K30KPiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwZ2RfYmFzaWNfdGVzdHModW5zaWduZWQgbG9u ZyBwZm4sIHBncHJvdF90IHByb3QpCj4gK3sKPiArCXBnZF90IHBnZDsKPiArCj4gKwltZW1zZXQo JnBnZCwgUkFORE9NX05aVkFMVUUsIHNpemVvZihwZ2RfdCkpOwo+ICsJV0FSTl9PTighcGdkX3Nh bWUocGdkLCBwZ2QpKTsKPiArfQo+ICsKPiArI2lmbmRlZiBfX1BBR0VUQUJMRV9QVURfRk9MREVE Cj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdWRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAq bW0sIHB1ZF90ICpwdWRwKQo+ICt7Cj4gKwlwdWRfdCBwdWQgPSBSRUFEX09OQ0UoKnB1ZHApOwo+ ICsKPiArCWlmIChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJcHVkID0g X19wdWQocHVkX3ZhbChwdWQpIHwgUkFORE9NX09SVkFMVUUpOwo+ICsJV1JJVEVfT05DRSgqcHVk cCwgcHVkKTsKPiArCXB1ZF9jbGVhcihwdWRwKTsKPiArCXB1ZCA9IFJFQURfT05DRSgqcHVkcCk7 Cj4gKwlXQVJOX09OKCFwdWRfbm9uZShwdWQpKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgX19p bml0IHB1ZF9wb3B1bGF0ZV90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcHVkX3QgKnB1ZHAs Cj4gKwkJCQkgICAgICBwbWRfdCAqcG1kcCkKPiArewo+ICsJcHVkX3QgcHVkOwo+ICsKPiArCWlm IChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47Cj4gKwkvKgo+ICsJICogVGhpcyBlbnRy eSBwb2ludHMgdG8gbmV4dCBsZXZlbCBwYWdlIHRhYmxlIHBhZ2UuCj4gKwkgKiBIZW5jZSB0aGlz IG11c3Qgbm90IHF1YWxpZnkgYXMgcHVkX2JhZCgpLgo+ICsJICovCj4gKwlwbWRfY2xlYXIocG1k cCk7Cj4gKwlwdWRfY2xlYXIocHVkcCk7Cj4gKwlwdWRfcG9wdWxhdGUobW0sIHB1ZHAsIHBtZHAp Owo+ICsJcHVkID0gUkVBRF9PTkNFKCpwdWRwKTsKPiArCVdBUk5fT04ocHVkX2JhZChwdWQpKTsK PiArfQo+ICsjZWxzZQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2NsZWFyX3Rlc3RzKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLCBwdWRfdCAqcHVkcCkgeyB9Cj4gK3N0YXRpYyB2b2lkIF9faW5pdCBw dWRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHB1ZF90ICpwdWRwLAo+ICsJ CQkJICAgICAgcG1kX3QgKnBtZHApCj4gK3sKPiArfQo+ICsjZW5kaWYKPiArCj4gKyNpZm5kZWYg X19QQUdFVEFCTEVfUDREX0ZPTERFRAo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcDRkX2NsZWFyX3Rl c3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwNGRfdCAqcDRkcCkKPiArewo+ICsJcDRkX3QgcDRk ID0gUkVBRF9PTkNFKCpwNGRwKTsKPiArCj4gKwlpZiAobW1fcHVkX2ZvbGRlZChtbSkpCj4gKwkJ cmV0dXJuOwo+ICsKPiArCXA0ZCA9IF9fcDRkKHA0ZF92YWwocDRkKSB8IFJBTkRPTV9PUlZBTFVF KTsKPiArCVdSSVRFX09OQ0UoKnA0ZHAsIHA0ZCk7Cj4gKwlwNGRfY2xlYXIocDRkcCk7Cj4gKwlw NGQgPSBSRUFEX09OQ0UoKnA0ZHApOwo+ICsJV0FSTl9PTighcDRkX25vbmUocDRkKSk7Cj4gK30K PiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwNGRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0 cnVjdCAqbW0sIHA0ZF90ICpwNGRwLAo+ICsJCQkJICAgICAgcHVkX3QgKnB1ZHApCj4gK3sKPiAr CXA0ZF90IHA0ZDsKPiArCj4gKwlpZiAobW1fcHVkX2ZvbGRlZChtbSkpCj4gKwkJcmV0dXJuOwo+ ICsKPiArCS8qCj4gKwkgKiBUaGlzIGVudHJ5IHBvaW50cyB0byBuZXh0IGxldmVsIHBhZ2UgdGFi bGUgcGFnZS4KPiArCSAqIEhlbmNlIHRoaXMgbXVzdCBub3QgcXVhbGlmeSBhcyBwNGRfYmFkKCku Cj4gKwkgKi8KPiArCXB1ZF9jbGVhcihwdWRwKTsKPiArCXA0ZF9jbGVhcihwNGRwKTsKPiArCXA0 ZF9wb3B1bGF0ZShtbSwgcDRkcCwgcHVkcCk7Cj4gKwlwNGQgPSBSRUFEX09OQ0UoKnA0ZHApOwo+ ICsJV0FSTl9PTihwNGRfYmFkKHA0ZCkpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBfX2luaXQg cGdkX2NsZWFyX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwZ2RfdCAqcGdkcCkKPiArewo+ ICsJcGdkX3QgcGdkID0gUkVBRF9PTkNFKCpwZ2RwKTsKPiArCj4gKwlpZiAobW1fcDRkX2ZvbGRl ZChtbSkpCj4gKwkJcmV0dXJuOwo+ICsKPiArCXBnZCA9IF9fcGdkKHBnZF92YWwocGdkKSB8IFJB TkRPTV9PUlZBTFVFKTsKPiArCVdSSVRFX09OQ0UoKnBnZHAsIHBnZCk7Cj4gKwlwZ2RfY2xlYXIo cGdkcCk7Cj4gKwlwZ2QgPSBSRUFEX09OQ0UoKnBnZHApOwo+ICsJV0FSTl9PTighcGdkX25vbmUo cGdkKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwZ2RfcG9wdWxhdGVfdGVzdHMo c3RydWN0IG1tX3N0cnVjdCAqbW0sIHBnZF90ICpwZ2RwLAo+ICsJCQkJICAgICAgcDRkX3QgKnA0 ZHApCj4gK3sKPiArCXBnZF90IHBnZDsKPiArCj4gKwlpZiAobW1fcDRkX2ZvbGRlZChtbSkpCj4g KwkJcmV0dXJuOwo+ICsKPiArCS8qCj4gKwkgKiBUaGlzIGVudHJ5IHBvaW50cyB0byBuZXh0IGxl dmVsIHBhZ2UgdGFibGUgcGFnZS4KPiArCSAqIEhlbmNlIHRoaXMgbXVzdCBub3QgcXVhbGlmeSBh cyBwZ2RfYmFkKCkuCj4gKwkgKi8KPiArCXA0ZF9jbGVhcihwNGRwKTsKPiArCXBnZF9jbGVhcihw Z2RwKTsKPiArCXBnZF9wb3B1bGF0ZShtbSwgcGdkcCwgcDRkcCk7Cj4gKwlwZ2QgPSBSRUFEX09O Q0UoKnBnZHApOwo+ICsJV0FSTl9PTihwZ2RfYmFkKHBnZCkpOwo+ICt9Cj4gKyNlbHNlCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwNGRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHA0 ZF90ICpwNGRwKSB7IH0KPiArc3RhdGljIHZvaWQgX19pbml0IHBnZF9jbGVhcl90ZXN0cyhzdHJ1 Y3QgbW1fc3RydWN0ICptbSwgcGdkX3QgKnBnZHApIHsgfQo+ICtzdGF0aWMgdm9pZCBfX2luaXQg cDRkX3BvcHVsYXRlX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwNGRfdCAqcDRkcCwKPiAr CQkJCSAgICAgIHB1ZF90ICpwdWRwKQo+ICt7Cj4gK30KPiArc3RhdGljIHZvaWQgX19pbml0IHBn ZF9wb3B1bGF0ZV90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcGdkX3QgKnBnZHAsCj4gKwkJ CQkgICAgICBwNGRfdCAqcDRkcCkKPiArewo+ICt9Cj4gKyNlbmRpZgo+ICsKPiArc3RhdGljIHZv aWQgX19pbml0IHB0ZV9jbGVhcl90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcHRlX3QgKnB0 ZXApCj4gK3sKPiArCXB0ZV90IHB0ZSA9IFJFQURfT05DRSgqcHRlcCk7Cj4gKwo+ICsJcHRlID0g X19wdGUocHRlX3ZhbChwdGUpIHwgUkFORE9NX09SVkFMVUUpOwo+ICsJV1JJVEVfT05DRSgqcHRl cCwgcHRlKTsKPiArCXB0ZV9jbGVhcihtbSwgMCwgcHRlcCk7Cj4gKwlwdGUgPSBSRUFEX09OQ0Uo KnB0ZXApOwo+ICsJV0FSTl9PTighcHRlX25vbmUocHRlKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2 b2lkIF9faW5pdCBwbWRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpw bWRwKQo+ICt7Cj4gKwlwbWRfdCBwbWQgPSBSRUFEX09OQ0UoKnBtZHApOwo+ICsKPiArCXBtZCA9 IF9fcG1kKHBtZF92YWwocG1kKSB8IFJBTkRPTV9PUlZBTFVFKTsKPiArCVdSSVRFX09OQ0UoKnBt ZHAsIHBtZCk7Cj4gKwlwbWRfY2xlYXIocG1kcCk7Cj4gKwlwbWQgPSBSRUFEX09OQ0UoKnBtZHAp Owo+ICsJV0FSTl9PTighcG1kX25vbmUocG1kKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwbWRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpwbWRw LAo+ICsJCQkJICAgICAgcGd0YWJsZV90IHBndGFibGUpCj4gK3sKPiArCXBtZF90IHBtZDsKPiAr Cj4gKwkvKgo+ICsJICogVGhpcyBlbnRyeSBwb2ludHMgdG8gbmV4dCBsZXZlbCBwYWdlIHRhYmxl IHBhZ2UuCj4gKwkgKiBIZW5jZSB0aGlzIG11c3Qgbm90IHF1YWxpZnkgYXMgcG1kX2JhZCgpLgo+ ICsJICovCj4gKwlwbWRfY2xlYXIocG1kcCk7Cj4gKwlwbWRfcG9wdWxhdGUobW0sIHBtZHAsIHBn dGFibGUpOwo+ICsJcG1kID0gUkVBRF9PTkNFKCpwbWRwKTsKPiArCVdBUk5fT04ocG1kX2JhZChw bWQpKTsKPiArfQo+ICsKPiArc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0IGdldF9yYW5kb21f dmFkZHIodm9pZCkKPiArewo+ICsJdW5zaWduZWQgbG9uZyByYW5kb21fdmFkZHIsIHJhbmRvbV9w YWdlcywgdG90YWxfdXNlcl9wYWdlczsKPiArCj4gKwl0b3RhbF91c2VyX3BhZ2VzID0gKFRBU0tf U0laRSAtIEZJUlNUX1VTRVJfQUREUkVTUykgLyBQQUdFX1NJWkU7Cj4gKwo+ICsJcmFuZG9tX3Bh Z2VzID0gZ2V0X3JhbmRvbV9sb25nKCkgJSB0b3RhbF91c2VyX3BhZ2VzOwo+ICsJcmFuZG9tX3Zh ZGRyID0gRklSU1RfVVNFUl9BRERSRVNTICsgcmFuZG9tX3BhZ2VzICogUEFHRV9TSVpFOwo+ICsK PiArCXJldHVybiByYW5kb21fdmFkZHI7Cj4gK30KPiArCj4gK3ZvaWQgX19pbml0IGRlYnVnX3Zt X3BndGFibGUodm9pZCkKPiArewo+ICsJc3RydWN0IG1tX3N0cnVjdCAqbW07Cj4gKwlwZ2RfdCAq cGdkcDsKPiArCXA0ZF90ICpwNGRwLCAqc2F2ZWRfcDRkcDsKPiArCXB1ZF90ICpwdWRwLCAqc2F2 ZWRfcHVkcDsKPiArCXBtZF90ICpwbWRwLCAqc2F2ZWRfcG1kcCwgcG1kOwo+ICsJcHRlX3QgKnB0 ZXA7Cj4gKwlwZ3RhYmxlX3Qgc2F2ZWRfcHRlcDsKPiArCXBncHJvdF90IHByb3Q7Cj4gKwlwaHlz X2FkZHJfdCBwYWRkcjsKPiArCXVuc2lnbmVkIGxvbmcgdmFkZHIsIHB0ZV9hbGlnbmVkLCBwbWRf YWxpZ25lZDsKPiArCXVuc2lnbmVkIGxvbmcgcHVkX2FsaWduZWQsIHA0ZF9hbGlnbmVkLCBwZ2Rf YWxpZ25lZDsKPiArCj4gKwlwcl9pbmZvKCJWYWxpZGF0aW5nIGFyY2hpdGVjdHVyZSBwYWdlIHRh YmxlIGhlbHBlcnNcbiIpOwo+ICsJcHJvdCA9IHZtX2dldF9wYWdlX3Byb3QoVk1GTEFHUyk7Cj4g Kwl2YWRkciA9IGdldF9yYW5kb21fdmFkZHIoKTsKPiArCW1tID0gbW1fYWxsb2MoKTsKPiArCWlm ICghbW0pIHsKPiArCQlwcl9lcnIoIm1tX3N0cnVjdCBhbGxvY2F0aW9uIGZhaWxlZFxuIik7Cj4g KwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiBQRk4gZm9yIG1hcHBpbmcgYXQgUFRF IGxldmVsIGlzIGRldGVybWluZWQgZnJvbSBhIHN0YW5kYXJkIGtlcm5lbAo+ICsJICogdGV4dCBz eW1ib2wuIEJ1dCBwZm5zIGZvciBoaWdoZXIgcGFnZSB0YWJsZSBsZXZlbHMgYXJlIGRlcml2ZWQg YnkKPiArCSAqIG1hc2tpbmcgbG93ZXIgYml0cyBvZiB0aGlzIHJlYWwgcGZuLiBUaGVzZSBkZXJp dmVkIHBmbnMgbWlnaHQgbm90Cj4gKwkgKiBleGlzdCBvbiB0aGUgcGxhdGZvcm0gYnV0IHRoYXQg ZG9lcyBub3QgcmVhbGx5IG1hdHRlciBhcyBwZm5fcHh4KCkKPiArCSAqIGhlbHBlcnMgd2lsbCBz dGlsbCBjcmVhdGUgYXBwcm9wcmlhdGUgZW50cmllcyBmb3IgdGhlIHRlc3QuIFRoaXMKPiArCSAq IGhlbHBzIGF2b2lkIGxhcmdlIG1lbW9yeSBibG9jayBhbGxvY2F0aW9ucyB0byBiZSB1c2VkIGZv ciBtYXBwaW5nCj4gKwkgKiBhdCBoaWdoZXIgcGFnZSB0YWJsZSBsZXZlbHMuCj4gKwkgKi8KPiAr CXBhZGRyID0gX19wYSgmc3RhcnRfa2VybmVsKTsKPiArCj4gKwlwdGVfYWxpZ25lZCA9IChwYWRk ciAmIFBBR0VfTUFTSykgPj4gUEFHRV9TSElGVDsKPiArCXBtZF9hbGlnbmVkID0gKHBhZGRyICYg UE1EX01BU0spID4+IFBBR0VfU0hJRlQ7Cj4gKwlwdWRfYWxpZ25lZCA9IChwYWRkciAmIFBVRF9N QVNLKSA+PiBQQUdFX1NISUZUOwo+ICsJcDRkX2FsaWduZWQgPSAocGFkZHIgJiBQNERfTUFTSykg Pj4gUEFHRV9TSElGVDsKPiArCXBnZF9hbGlnbmVkID0gKHBhZGRyICYgUEdESVJfTUFTSykgPj4g UEFHRV9TSElGVDsKPiArCVdBUk5fT04oIXBmbl92YWxpZChwdGVfYWxpZ25lZCkpOwo+ICsKPiAr CXBnZHAgPSBwZ2Rfb2Zmc2V0KG1tLCB2YWRkcik7Cj4gKwlwNGRwID0gcDRkX2FsbG9jKG1tLCBw Z2RwLCB2YWRkcik7Cj4gKwlwdWRwID0gcHVkX2FsbG9jKG1tLCBwNGRwLCB2YWRkcik7Cj4gKwlw bWRwID0gcG1kX2FsbG9jKG1tLCBwdWRwLCB2YWRkcik7Cj4gKwlwdGVwID0gcHRlX2FsbG9jX21h cChtbSwgcG1kcCwgdmFkZHIpOwo+ICsKPiArCS8qCj4gKwkgKiBTYXZlIGFsbCB0aGUgcGFnZSB0 YWJsZSBwYWdlIGFkZHJlc3NlcyBhcyB0aGUgcGFnZSB0YWJsZQo+ICsJICogZW50cmllcyB3aWxs IGJlIHVzZWQgZm9yIHRlc3Rpbmcgd2l0aCByYW5kb20gb3IgZ2FyYmFnZQo+ICsJICogdmFsdWVz LiBUaGVzZSBzYXZlZCBhZGRyZXNzZXMgd2lsbCBiZSB1c2VkIGZvciBmcmVlaW5nCj4gKwkgKiBw YWdlIHRhYmxlIHBhZ2VzLgo+ICsJICovCj4gKwlwbWQgPSBSRUFEX09OQ0UoKnBtZHApOwo+ICsJ c2F2ZWRfcDRkcCA9IHA0ZF9vZmZzZXQocGdkcCwgMFVMKTsKPiArCXNhdmVkX3B1ZHAgPSBwdWRf b2Zmc2V0KHA0ZHAsIDBVTCk7Cj4gKwlzYXZlZF9wbWRwID0gcG1kX29mZnNldChwdWRwLCAwVUwp Owo+ICsJc2F2ZWRfcHRlcCA9IHBtZF9wZ3RhYmxlKHBtZCk7Cj4gKwo+ICsJcHRlX2Jhc2ljX3Rl c3RzKHB0ZV9hbGlnbmVkLCBwcm90KTsKPiArCXBtZF9iYXNpY190ZXN0cyhwbWRfYWxpZ25lZCwg cHJvdCk7Cj4gKwlwdWRfYmFzaWNfdGVzdHMocHVkX2FsaWduZWQsIHByb3QpOwo+ICsJcDRkX2Jh c2ljX3Rlc3RzKHA0ZF9hbGlnbmVkLCBwcm90KTsKPiArCXBnZF9iYXNpY190ZXN0cyhwZ2RfYWxp Z25lZCwgcHJvdCk7Cj4gKwo+ICsJcHRlX2NsZWFyX3Rlc3RzKG1tLCBwdGVwKTsKPiArCXBtZF9j bGVhcl90ZXN0cyhtbSwgcG1kcCk7Cj4gKwlwdWRfY2xlYXJfdGVzdHMobW0sIHB1ZHApOwo+ICsJ cDRkX2NsZWFyX3Rlc3RzKG1tLCBwNGRwKTsKPiArCXBnZF9jbGVhcl90ZXN0cyhtbSwgcGdkcCk7 Cj4gKwo+ICsJcHRlX3VubWFwKHB0ZXApOwo+ICsKPiArCXBtZF9wb3B1bGF0ZV90ZXN0cyhtbSwg cG1kcCwgc2F2ZWRfcHRlcCk7Cj4gKwlwdWRfcG9wdWxhdGVfdGVzdHMobW0sIHB1ZHAsIHNhdmVk X3BtZHApOwo+ICsJcDRkX3BvcHVsYXRlX3Rlc3RzKG1tLCBwNGRwLCBzYXZlZF9wdWRwKTsKPiAr CXBnZF9wb3B1bGF0ZV90ZXN0cyhtbSwgcGdkcCwgc2F2ZWRfcDRkcCk7Cj4gKwo+ICsJcDRkX2Zy ZWUobW0sIHNhdmVkX3A0ZHApOwo+ICsJcHVkX2ZyZWUobW0sIHNhdmVkX3B1ZHApOwo+ICsJcG1k X2ZyZWUobW0sIHNhdmVkX3BtZHApOwo+ICsJcHRlX2ZyZWUobW0sIHNhdmVkX3B0ZXApOwo+ICsK PiArCW1tX2RlY19ucl9wdWRzKG1tKTsKPiArCW1tX2RlY19ucl9wbWRzKG1tKTsKPiArCW1tX2Rl Y19ucl9wdGVzKG1tKTsKPiArCW1tZHJvcChtbSk7Cj4gK30KCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXNucHMtYXJjIG1haWxpbmcgbGlzdAps aW51eC1zbnBzLWFyY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQu b3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtc25wcy1hcmMK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.1 required=3.0 tests=DKIM_INVALID,DKIM_SIGNED, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_2 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id B88F8C4BA12 for ; Wed, 26 Feb 2020 14:13:16 +0000 (UTC) Received: from lists.ozlabs.org (lists.ozlabs.org [203.11.71.2]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 3E17E2467B for ; Wed, 26 Feb 2020 14:13:16 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=lca.pw header.i=@lca.pw header.b="YE3R28K0" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 3E17E2467B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=lca.pw Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Received: from lists.ozlabs.org (lists.ozlabs.org [IPv6:2401:3900:2:1::3]) by lists.ozlabs.org (Postfix) with ESMTP id 48SHp15zc2zDqkS for ; Thu, 27 Feb 2020 01:13:13 +1100 (AEDT) Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=lca.pw (client-ip=2607:f8b0:4864:20::842; helo=mail-qt1-x842.google.com; envelope-from=cai@lca.pw; receiver=) Authentication-Results: lists.ozlabs.org; dmarc=none (p=none dis=none) header.from=lca.pw Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=lca.pw header.i=@lca.pw header.a=rsa-sha256 header.s=google header.b=YE3R28K0; dkim-atps=neutral Received: from mail-qt1-x842.google.com (mail-qt1-x842.google.com [IPv6:2607:f8b0:4864:20::842]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 48SHk63gVTzDqjk for ; Thu, 27 Feb 2020 01:09:50 +1100 (AEDT) Received: by mail-qt1-x842.google.com with SMTP id l21so2293122qtr.8 for ; Wed, 26 Feb 2020 06:09:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lca.pw; s=google; h=message-id:subject:from:to:cc:date:in-reply-to:references :mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=YE3R28K03/OSkKci4pIu5feJz/Gza2peB1lndyCeGfvTr8WSbzxpFaAqlK/20xrBvl 6QpXE5F7H7Vx83KoDdAzQd4b3z0ApO16qPGG/ft6YbvZNOaPkn87uQWs825uQ85pt/4b 6iLpy8Vc4N/vq91uAhMsYpM6abgr85RtDcb3e6GNiUOwS/8MHsgktIWoPXcHIJX382y4 eQPAzmcZV3HPXCrkguoaDLw2qUKIkkBKWsa0lAG3fgRUaEaHdqBmwboSJl5RPi1yeMej b/aMFlj2uh6WPxJMdvcluXKnXEc/lfM/eeQ1zXrVk7RsLNT7Ol7Bgk22NZcLjJQYlBn5 L7MA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=ZQYtwgVxb1pVv7tLE+ebO6ucuAABubIsEuVMeeDGcZLS4IRUvRLmmfu0cW5ppRh+W8 mSAibY1OhlPgRJyk47aCY1LgTa4S0xMJ8DkNECNg2H2m36nq0t8vGhi9taeG0KGPJLe1 K8zoyO9RC7CXlMnOlQ0fOeDI2yAwwdI0PZmpLqx3c5W+dqqxhJxTwVhtMpDW2ZqUc2I7 1juhrdPS4OWpn8INok8iHYy0B8V2RNjs7EUNhSdWKNWGm2aLCsiRS06ddoXcbkbIfUmi M6BDyTgEXcNC13vJ6u1IxzAQTtJlJYaz17CDj2N40p6lEJC6KEGuqZljJcWQ5ibEkz/P AdAw== X-Gm-Message-State: APjAAAX2mLHY9mD6VCnjWC3g6d+A3kcpjAJ8Vx724/7bXKCl2bB4lgyQ BFJsQNL8usB23RchnxUgotzJCQ== X-Google-Smtp-Source: APXvYqxRvESuFPk6siqL9qo/1/2cXkkp2ceYeSTQ/uCoTGJhGid6usa2pYO6rAddiidPiSORcGRtfQ== X-Received: by 2002:ac8:2bf8:: with SMTP id n53mr5572816qtn.1.1582726185762; Wed, 26 Feb 2020 06:09:45 -0800 (PST) Received: from dhcp-41-57.bos.redhat.com (nat-pool-bos-t.redhat.com. [66.187.233.206]) by smtp.gmail.com with ESMTPSA id b5sm1176402qkg.110.2020.02.26.06.09.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 26 Feb 2020 06:09:44 -0800 (PST) Message-ID: <1582726182.7365.123.camel@lca.pw> Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers From: Qian Cai To: Anshuman Khandual , linux-mm@kvack.org Date: Wed, 26 Feb 2020 09:09:42 -0500 In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> Content-Type: text/plain; charset="UTF-8" X-Mailer: Evolution 3.22.6 (3.22.6-10.el7) Mime-Version: 1.0 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: Catalin Marinas , Heiko Carstens , Paul Mackerras , "H. Peter Anvin" , linux-riscv@lists.infradead.org, Will Deacon , linux-arch@vger.kernel.org, linux-s390@vger.kernel.org, x86@kernel.org, Mike Rapoport , Christian Borntraeger , Ingo Molnar , linux-snps-arc@lists.infradead.org, Vasily Gorbik , Borislav Petkov , Paul Walmsley , "Kirill A . Shutemov" , Thomas Gleixner , linux-arm-kernel@lists.infradead.org, Vineet Gupta , linux-kernel@vger.kernel.org, Palmer Dabbelt , Andrew Morton , linuxppc-dev@lists.ozlabs.org Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" On Mon, 2020-02-17 at 08:47 +0530, Anshuman Khandual wrote: > This adds tests which will validate architecture page table helpers and > other accessors in their compliance with expected generic MM semantics. > This will help various architectures in validating changes to existing > page table helpers or addition of new ones. > > This test covers basic page table entry transformations including but not > limited to old, young, dirty, clean, write, write protect etc at various > level along with populating intermediate entries with next page table page > and validating them. > > Test page table pages are allocated from system memory with required size > and alignments. The mapped pfns at page table levels are derived from a > real pfn representing a valid kernel text symbol. This test gets called > inside kernel_init() right after async_synchronize_full(). > > This test gets built and run when CONFIG_DEBUG_VM_PGTABLE is selected. Any > architecture, which is willing to subscribe this test will need to select > ARCH_HAS_DEBUG_VM_PGTABLE. For now this is limited to arc, arm64, x86, s390 > and ppc32 platforms where the test is known to build and run successfully. > Going forward, other architectures too can subscribe the test after fixing > any build or runtime problems with their page table helpers. Meanwhile for > better platform coverage, the test can also be enabled with CONFIG_EXPERT > even without ARCH_HAS_DEBUG_VM_PGTABLE. > > Folks interested in making sure that a given platform's page table helpers > conform to expected generic MM semantics should enable the above config > which will just trigger this test during boot. Any non conformity here will > be reported as an warning which would need to be fixed. This test will help > catch any changes to the agreed upon semantics expected from generic MM and > enable platforms to accommodate it thereafter. How useful is this that straightly crash the powerpc? [   23.263425][    T1] debug_vm_pgtable: debug_vm_pgtable: Validating architecture page table helpers [   23.263625][    T1] ------------[ cut here ]------------ [   23.263649][    T1] kernel BUG at arch/powerpc/mm/pgtable.c:274! [   23.263675][    T1] Oops: Exception in kernel mode, sig: 5 [#1] [   23.263698][    T1] LE PAGE_SIZE=64K MMU=Radix SMP NR_CPUS=256 DEBUG_PAGEALLOC NUMA PowerNV [   23.263731][    T1] Modules linked in: [   23.263752][    T1] CPU: 4 PID: 1 Comm: swapper/0 Not tainted 5.6.0-rc3-next- 20200226 #1 [   23.263776][    T1] NIP:  c00000000007308c LR: c00000000103dbd8 CTR: 0000000000000000 [   23.263810][    T1] REGS: c00000003ddaf9c0 TRAP: 0700   Not tainted  (5.6.0- rc3-next-20200226) [   23.263846][    T1] MSR:  9000000000029033   CR: 22000228  XER: 00000000 [   23.263888][    T1] CFAR: c000000000073030 IRQMASK: 0  [   23.263888][    T1] GPR00: c00000000103dbd8 c00000003ddafc50 c000000001656f00 c000001d7b4ca080  [   23.263888][    T1] GPR04: 0000000000000000 0000000000000009 c00000003ddafc04 0000000000000000  [   23.263888][    T1] GPR08: f0ffffffffffffff 0000000000000001 c0000000016279d0 00000000000a0000  [   23.263888][    T1] GPR12: 0000000000000000 c000001fffffae00 c000000000010e84 0000000000000000  [   23.263888][    T1] GPR16: 0000000000000000 8000000000000105 0000000000000100 c000000001689a18  [   23.263888][    T1] GPR20: c00020032c660000 c00020032c620000 c000000001716030 c00020032c600000  [   23.263888][    T1] GPR24: 000000000000000d c000000001716030 c000001d7b4ca080 c000000001716040  [   23.263888][    T1] GPR28: c000000001716038 0000000000000000 0000000000000000 0000000000000000  [   23.264122][    T1] NIP [c00000000007308c] assert_pte_locked+0x11c/0x320 [   23.264154][    T1] LR [c00000000103dbd8] debug_vm_pgtable+0x770/0xb7c [   23.264186][    T1] Call Trace: [   23.264206][    T1] [c00000003ddafc50] [c000000000999760] _raw_spin_unlock+0x30/0x70 (unreliable) [   23.264244][    T1] [c00000003ddafcd0] [c00000000103d924] debug_vm_pgtable+0x4bc/0xb7c [   23.264279][    T1] [c00000003ddafdb0] [c000000000010eac] kernel_init+0x30/0x194 [   23.264315][    T1] [c00000003ddafe20] [c00000000000b748] ret_from_kernel_thread+0x5c/0x74 [   23.264349][    T1] Instruction dump: [   23.264368][    T1] 60000000 3be00001 7fbef436 eafa0040 7fffc030 3bffffff 7fff07b4 7ffff038  [   23.264409][    T1] 7bff1f24 7d37f82a 7d290074 7929d182 <0b090000> ebdb0000 e93c0000 7fde4a14  [   23.264460][    T1] ---[ end trace 72d2931022e9ab24 ]--- [   23.627311][    T1]  [   24.627407][    T1] Kernel panic - not syncing: Fatal exception [   26.5 > > Cc: Andrew Morton > Cc: Mike Rapoport > Cc: Vineet Gupta > Cc: Catalin Marinas > Cc: Will Deacon > Cc: Benjamin Herrenschmidt > Cc: Paul Mackerras > Cc: Michael Ellerman > Cc: Heiko Carstens > Cc: Vasily Gorbik > Cc: Christian Borntraeger > Cc: Thomas Gleixner > Cc: Ingo Molnar > Cc: Borislav Petkov > Cc: "H. Peter Anvin" > Cc: Kirill A. Shutemov > Cc: Paul Walmsley > Cc: Palmer Dabbelt > Cc: linux-snps-arc@lists.infradead.org > Cc: linux-arm-kernel@lists.infradead.org > Cc: linuxppc-dev@lists.ozlabs.org > Cc: linux-s390@vger.kernel.org > Cc: linux-riscv@lists.infradead.org > Cc: x86@kernel.org > Cc: linux-arch@vger.kernel.org > Cc: linux-kernel@vger.kernel.org > > Suggested-by: Catalin Marinas > Reviewed-by: Ingo Molnar > Tested-by: Gerald Schaefer # s390 > Tested-by: Christophe Leroy # ppc32 > Signed-off-by: Andrew Morton > Signed-off-by: Christophe Leroy > Signed-off-by: Anshuman Khandual > --- > This adds a test validation for architecture exported page table helpers. > Patch adds basic transformation tests at various levels of the page table. > > This test was originally suggested by Catalin during arm64 THP migration > RFC discussion earlier. Going forward it can include more specific tests > with respect to various generic MM functions like THP, HugeTLB etc and > platform specific tests. > > https://lore.kernel.org/linux-mm/20190628102003.GA56463@arrakis.emea.arm.com/ > > Needs to be applied on linux V5.6-rc2 > > Changes in V14: > > - Disabled DEBUG_VM_PGFLAGS for IA64 and ARM (32 Bit) per Andrew and Christophe > - Updated DEBUG_VM_PGFLAGS documentation wrt EXPERT and disabled platforms > - Updated RANDOM_[OR|NZ]VALUE open encodings with GENMASK() per Catalin > - Updated s390 constraint bits from 12 to 4 (S390_MASK_BITS) per Gerald > - Updated in-code documentation for RANDOM_ORVALUE per Gerald > - Updated pxx_basic_tests() to use invert functions first per Catalin > - Dropped ARCH_HAS_4LEVEL_HACK check from pud_basic_tests() > - Replaced __ARCH_HAS_[4|5]LEVEL_HACK with __PAGETABLE_[PUD|P4D]_FOLDED per Catalin > - Trimmed the CC list on the commit message per Catalin > > Changes in V13: (https://patchwork.kernel.org/project/linux-mm/list/?series=237125) > > - Subscribed s390 platform and updated debug-vm-pgtable/arch-support.txt per Gerald > - Dropped keyword 'extern' from debug_vm_pgtable() declaration per Christophe > - Moved debug_vm_pgtable() declarations to per Christophe > - Moved debug_vm_pgtable() call site into kernel_init() per Christophe > - Changed CONFIG_DEBUG_VM_PGTABLE rules per Christophe > - Updated commit to include new supported platforms and changed config selection > > Changes in V12: (https://patchwork.kernel.org/project/linux-mm/list/?series=233905) > > - Replaced __mmdrop() with mmdrop() > - Enable ARCH_HAS_DEBUG_VM_PGTABLE on X86 for non CONFIG_X86_PAE platforms as the > test procedure interfere with pre-allocated PMDs attached to the PGD resulting > in runtime failures with VM_BUG_ON() > > Changes in V11: (https://patchwork.kernel.org/project/linux-mm/list/?series=221135) > > - Rebased the patch on V5.4 > > Changes in V10: (https://patchwork.kernel.org/project/linux-mm/list/?series=205529) > > - Always enable DEBUG_VM_PGTABLE when DEBUG_VM is enabled per Ingo > - Added tags from Ingo > > Changes in V9: (https://patchwork.kernel.org/project/linux-mm/list/?series=201429) > > - Changed feature support enumeration for powerpc platforms per Christophe > - Changed config wrapper for basic_[pmd|pud]_tests() to enable ARC platform > - Enabled the test on ARC platform > > Changes in V8: (https://patchwork.kernel.org/project/linux-mm/list/?series=194297) > > - Enabled ARCH_HAS_DEBUG_VM_PGTABLE on PPC32 platform per Christophe > - Updated feature documentation as DEBUG_VM_PGTABLE is now enabled on PPC32 platform > - Moved ARCH_HAS_DEBUG_VM_PGTABLE earlier to indent it with DEBUG_VM per Christophe > - Added an information message in debug_vm_pgtable() per Christophe > - Dropped random_vaddr boundary condition checks per Christophe and Qian > - Replaced virt_addr_valid() check with pfn_valid() check in debug_vm_pgtable() > - Slightly changed pr_fmt(fmt) information > > Changes in V7: (https://patchwork.kernel.org/project/linux-mm/list/?series=193051) > > - Memory allocation and free routines for mapped pages have been droped > - Mapped pfns are derived from standard kernel text symbol per Matthew > - Moved debug_vm_pgtaable() after page_alloc_init_late() per Michal and Qian > - Updated the commit message per Michal > - Updated W=1 GCC warning problem on x86 per Qian Cai > - Addition of new alloc_contig_pages() helper has been submitted separately > > Changes in V6: (https://patchwork.kernel.org/project/linux-mm/list/?series=187589) > > - Moved alloc_gigantic_page_order() into mm/page_alloc.c per Michal > - Moved alloc_gigantic_page_order() within CONFIG_CONTIG_ALLOC in the test > - Folded Andrew's include/asm-generic/pgtable.h fix into the test patch 2/2 > > Changes in V5: (https://patchwork.kernel.org/project/linux-mm/list/?series=185991) > > - Redefined and moved X86 mm_p4d_folded() into a different header per Kirill/Ingo > - Updated the config option comment per Ingo and dropped 'kernel module' reference > - Updated the commit message and dropped 'kernel module' reference > - Changed DEBUG_ARCH_PGTABLE_TEST into DEBUG_VM_PGTABLE per Ingo > - Moved config option from mm/Kconfig.debug into lib/Kconfig.debug > - Renamed core test function arch_pgtable_tests() as debug_vm_pgtable() > - Renamed mm/arch_pgtable_test.c as mm/debug_vm_pgtable.c > - debug_vm_pgtable() gets called from kernel_init_freeable() after init_mm_internals() > - Added an entry in Documentation/features/debug/ per Ingo > - Enabled the test on arm64 and x86 platforms for now > > Changes in V4: (https://patchwork.kernel.org/project/linux-mm/list/?series=183465) > > - Disable DEBUG_ARCH_PGTABLE_TEST for ARM and IA64 platforms > > Changes in V3: (https://lore.kernel.org/patchwork/project/lkml/list/?series=411216) > > - Changed test trigger from module format into late_initcall() > - Marked all functions with __init to be freed after completion > - Changed all __PGTABLE_PXX_FOLDED checks as mm_pxx_folded() > - Folded in PPC32 fixes from Christophe > > Changes in V2: > > https://lore.kernel.org/linux-mm/1568268173-31302-1-git-send-email-anshuman.khandual@arm.com/T/#t > > - Fixed small typo error in MODULE_DESCRIPTION() > - Fixed m64k build problems for lvalue concerns in pmd_xxx_tests() > - Fixed dynamic page table level folding problems on x86 as per Kirril > - Fixed second pointers during pxx_populate_tests() per Kirill and Gerald > - Allocate and free pte table with pte_alloc_one/pte_free per Kirill > - Modified pxx_clear_tests() to accommodate s390 lower 12 bits situation > - Changed RANDOM_NZVALUE value from 0xbe to 0xff > - Changed allocation, usage, free sequence for saved_ptep > - Renamed VMA_FLAGS as VMFLAGS > - Implemented a new method for random vaddr generation > - Implemented some other cleanups > - Dropped extern reference to mm_alloc() > - Created and exported new alloc_gigantic_page_order() > - Dropped the custom allocator and used new alloc_gigantic_page_order() > > Changes in V1: > > https://lore.kernel.org/linux-mm/1567497706-8649-1-git-send-email-anshuman.khandual@arm.com/ > > - Added fallback mechanism for PMD aligned memory allocation failure > > Changes in RFC V2: > > https://lore.kernel.org/linux-mm/1565335998-22553-1-git-send-email-anshuman.khandual@arm.com/T/#u > > - Moved test module and it's config from lib/ to mm/ > - Renamed config TEST_ARCH_PGTABLE as DEBUG_ARCH_PGTABLE_TEST > - Renamed file from test_arch_pgtable.c to arch_pgtable_test.c > - Added relevant MODULE_DESCRIPTION() and MODULE_AUTHOR() details > - Dropped loadable module config option > - Basic tests now use memory blocks with required size and alignment > - PUD aligned memory block gets allocated with alloc_contig_range() > - If PUD aligned memory could not be allocated it falls back on PMD aligned > memory block from page allocator and pud_* tests are skipped > - Clear and populate tests now operate on real in memory page table entries > - Dummy mm_struct gets allocated with mm_alloc() > - Dummy page table entries get allocated with [pud|pmd|pte]_alloc_[map]() > - Simplified [p4d|pgd]_basic_tests(), now has random values in the entries > > Original RFC V1: > > https://lore.kernel.org/linux-mm/1564037723-26676-1-git-send-email-anshuman.khandual@arm.com/ > > > .../debug/debug-vm-pgtable/arch-support.txt | 35 ++ > arch/arc/Kconfig | 1 + > arch/arm64/Kconfig | 1 + > arch/powerpc/Kconfig | 1 + > arch/s390/Kconfig | 1 + > arch/x86/Kconfig | 1 + > arch/x86/include/asm/pgtable_64.h | 6 + > include/linux/mmdebug.h | 5 + > init/main.c | 2 + > lib/Kconfig.debug | 26 ++ > mm/Makefile | 1 + > mm/debug_vm_pgtable.c | 389 ++++++++++++++++++ > 12 files changed, 469 insertions(+) > create mode 100644 Documentation/features/debug/debug-vm-pgtable/arch-support.txt > create mode 100644 mm/debug_vm_pgtable.c > > diff --git a/Documentation/features/debug/debug-vm-pgtable/arch-support.txt b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > new file mode 100644 > index 000000000000..64d0f9b15c49 > --- /dev/null > +++ b/Documentation/features/debug/debug-vm-pgtable/arch-support.txt > @@ -0,0 +1,35 @@ > +# > +# Feature name: debug-vm-pgtable > +# Kconfig: ARCH_HAS_DEBUG_VM_PGTABLE > +# description: arch supports pgtable tests for semantics compliance > +# > + ----------------------- > + | arch |status| > + ----------------------- > + | alpha: | TODO | > + | arc: | ok | > + | arm: | TODO | > + | arm64: | ok | > + | c6x: | TODO | > + | csky: | TODO | > + | h8300: | TODO | > + | hexagon: | TODO | > + | ia64: | TODO | > + | m68k: | TODO | > + | microblaze: | TODO | > + | mips: | TODO | > + | nds32: | TODO | > + | nios2: | TODO | > + | openrisc: | TODO | > + | parisc: | TODO | > + | powerpc/32: | ok | > + | powerpc/64: | TODO | > + | riscv: | TODO | > + | s390: | ok | > + | sh: | TODO | > + | sparc: | TODO | > + | um: | TODO | > + | unicore32: | TODO | > + | x86: | ok | > + | xtensa: | TODO | > + ----------------------- > diff --git a/arch/arc/Kconfig b/arch/arc/Kconfig > index ff2a393b635c..3e72e6cf0e42 100644 > --- a/arch/arc/Kconfig > +++ b/arch/arc/Kconfig > @@ -6,6 +6,7 @@ > config ARC > def_bool y > select ARC_TIMERS > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_PTE_SPECIAL > select ARCH_HAS_SETUP_DMA_OPS > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index 0b30e884e088..aaf8ba415145 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -11,6 +11,7 @@ config ARM64 > select ACPI_PPTT if ACPI > select ARCH_CLOCKSOURCE_DATA > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_DMA_PREP_COHERENT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig > index 497b7d0b2d7e..8d5ae14c5d4c 100644 > --- a/arch/powerpc/Kconfig > +++ b/arch/powerpc/Kconfig > @@ -116,6 +116,7 @@ config PPC > # > select ARCH_32BIT_OFF_T if PPC32 > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if PPC32 > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/s390/Kconfig b/arch/s390/Kconfig > index 8abe77536d9d..af284dbb07e7 100644 > --- a/arch/s390/Kconfig > +++ b/arch/s390/Kconfig > @@ -59,6 +59,7 @@ config KASAN_SHADOW_OFFSET > config S390 > def_bool y > select ARCH_BINFMT_ELF_STATE > + select ARCH_HAS_DEBUG_VM_PGTABLE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FORTIFY_SOURCE > diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig > index beea77046f9b..df8a19e52e82 100644 > --- a/arch/x86/Kconfig > +++ b/arch/x86/Kconfig > @@ -61,6 +61,7 @@ config X86 > select ARCH_CLOCKSOURCE_INIT > select ARCH_HAS_ACPI_TABLE_UPGRADE if ACPI > select ARCH_HAS_DEBUG_VIRTUAL > + select ARCH_HAS_DEBUG_VM_PGTABLE if !X86_PAE > select ARCH_HAS_DEVMEM_IS_ALLOWED > select ARCH_HAS_ELF_RANDOMIZE > select ARCH_HAS_FAST_MULTIPLIER > diff --git a/arch/x86/include/asm/pgtable_64.h b/arch/x86/include/asm/pgtable_64.h > index 0b6c4042942a..fb0e76d254b3 100644 > --- a/arch/x86/include/asm/pgtable_64.h > +++ b/arch/x86/include/asm/pgtable_64.h > @@ -53,6 +53,12 @@ static inline void sync_initial_page_table(void) { } > > struct mm_struct; > > +#define mm_p4d_folded mm_p4d_folded > +static inline bool mm_p4d_folded(struct mm_struct *mm) > +{ > + return !pgtable_l5_enabled(); > +} > + > void set_pte_vaddr_p4d(p4d_t *p4d_page, unsigned long vaddr, pte_t new_pte); > void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte); > > diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h > index 2ad72d2c8cc5..5339aa14b749 100644 > --- a/include/linux/mmdebug.h > +++ b/include/linux/mmdebug.h > @@ -64,4 +64,9 @@ void dump_mm(const struct mm_struct *mm); > #define VM_BUG_ON_PGFLAGS(cond, page) BUILD_BUG_ON_INVALID(cond) > #endif > > +#ifdef CONFIG_DEBUG_VM_PGTABLE > +void debug_vm_pgtable(void); > +#else > +static inline void debug_vm_pgtable(void) { } > +#endif > #endif > diff --git a/init/main.c b/init/main.c > index cc0ee4873419..adf37e8b1d69 100644 > --- a/init/main.c > +++ b/init/main.c > @@ -94,6 +94,7 @@ > #include > #include > #include > +#include > > #include > #include > @@ -1323,6 +1324,7 @@ static int __ref kernel_init(void *unused) > kernel_init_freeable(); > /* need to finish all async __init code before freeing the memory */ > async_synchronize_full(); > + debug_vm_pgtable(); > ftrace_free_init_mem(); > free_initmem(); > mark_readonly(); > diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug > index 69def4a9df00..1b5bd9f7c967 100644 > --- a/lib/Kconfig.debug > +++ b/lib/Kconfig.debug > @@ -653,6 +653,12 @@ config SCHED_STACK_END_CHECK > data corruption or a sporadic crash at a later stage once the region > is examined. The runtime overhead introduced is minimal. > > +config ARCH_HAS_DEBUG_VM_PGTABLE > + bool > + help > + An architecture should select this when it can successfully > + build and run DEBUG_VM_PGTABLE. > + > config DEBUG_VM > bool "Debug VM" > depends on DEBUG_KERNEL > @@ -688,6 +694,26 @@ config DEBUG_VM_PGFLAGS > > If unsure, say N. > > +config DEBUG_VM_PGTABLE > + bool "Debug arch page table for semantics compliance" > + depends on MMU > + depends on !IA64 && !ARM > + depends on ARCH_HAS_DEBUG_VM_PGTABLE || EXPERT > + default n if !ARCH_HAS_DEBUG_VM_PGTABLE > + default y if DEBUG_VM > + help > + This option provides a debug method which can be used to test > + architecture page table helper functions on various platforms in > + verifying if they comply with expected generic MM semantics. This > + will help architecture code in making sure that any changes or > + new additions of these helpers still conform to expected > + semantics of the generic MM. Platforms will have to opt in for > + this through ARCH_HAS_DEBUG_VM_PGTABLE. Although it can also be > + enabled through EXPERT without requiring code change. This test > + is disabled on IA64 and ARM platforms where it fails to build. > + > + If unsure, say N. > + > config ARCH_HAS_DEBUG_VIRTUAL > bool > > diff --git a/mm/Makefile b/mm/Makefile > index 272e66039e70..b0692e6a4b58 100644 > --- a/mm/Makefile > +++ b/mm/Makefile > @@ -87,6 +87,7 @@ obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o > obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o > obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak-test.o > obj-$(CONFIG_DEBUG_RODATA_TEST) += rodata_test.o > +obj-$(CONFIG_DEBUG_VM_PGTABLE) += debug_vm_pgtable.o > obj-$(CONFIG_PAGE_OWNER) += page_owner.o > obj-$(CONFIG_CLEANCACHE) += cleancache.o > obj-$(CONFIG_MEMORY_ISOLATION) += page_isolation.o > diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c > new file mode 100644 > index 000000000000..70bf8ed8fd51 > --- /dev/null > +++ b/mm/debug_vm_pgtable.c > @@ -0,0 +1,389 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * This kernel test validates architecture page table helpers and > + * accessors and helps in verifying their continued compliance with > + * expected generic MM semantics. > + * > + * Copyright (C) 2019 ARM Ltd. > + * > + * Author: Anshuman Khandual > + */ > +#define pr_fmt(fmt) "debug_vm_pgtable: %s: " fmt, __func__ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* > + * Basic operations > + * > + * mkold(entry) = An old and not a young entry > + * mkyoung(entry) = A young and not an old entry > + * mkdirty(entry) = A dirty and not a clean entry > + * mkclean(entry) = A clean and not a dirty entry > + * mkwrite(entry) = A write and not a write protected entry > + * wrprotect(entry) = A write protected and not a write entry > + * pxx_bad(entry) = A mapped and non-table entry > + * pxx_same(entry1, entry2) = Both entries hold the exact same value > + */ > +#define VMFLAGS (VM_READ|VM_WRITE|VM_EXEC) > + > +/* > + * On s390 platform, the lower 4 bits are used to identify given page table > + * entry type. But these bits might affect the ability to clear entries with > + * pxx_clear() because of how dynamic page table folding works on s390. So > + * while loading up the entries do not change the lower 4 bits. It does not > + * have affect any other platform. > + */ > +#define S390_MASK_BITS 4 > +#define RANDOM_ORVALUE GENMASK(BITS_PER_LONG - 1, S390_MASK_BITS) > +#define RANDOM_NZVALUE GENMASK(7, 0) > + > +static void __init pte_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pte_t pte = pfn_pte(pfn, prot); > + > + WARN_ON(!pte_same(pte, pte)); > + WARN_ON(!pte_young(pte_mkyoung(pte_mkold(pte)))); > + WARN_ON(!pte_dirty(pte_mkdirty(pte_mkclean(pte)))); > + WARN_ON(!pte_write(pte_mkwrite(pte_wrprotect(pte)))); > + WARN_ON(pte_young(pte_mkold(pte_mkyoung(pte)))); > + WARN_ON(pte_dirty(pte_mkclean(pte_mkdirty(pte)))); > + WARN_ON(pte_write(pte_wrprotect(pte_mkwrite(pte)))); > +} > + > +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pmd_t pmd = pfn_pmd(pfn, prot); > + > + WARN_ON(!pmd_same(pmd, pmd)); > + WARN_ON(!pmd_young(pmd_mkyoung(pmd_mkold(pmd)))); > + WARN_ON(!pmd_dirty(pmd_mkdirty(pmd_mkclean(pmd)))); > + WARN_ON(!pmd_write(pmd_mkwrite(pmd_wrprotect(pmd)))); > + WARN_ON(pmd_young(pmd_mkold(pmd_mkyoung(pmd)))); > + WARN_ON(pmd_dirty(pmd_mkclean(pmd_mkdirty(pmd)))); > + WARN_ON(pmd_write(pmd_wrprotect(pmd_mkwrite(pmd)))); > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pmd_bad(). > + */ > + WARN_ON(!pmd_bad(pmd_mkhuge(pmd))); > +} > + > +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pud_t pud = pfn_pud(pfn, prot); > + > + WARN_ON(!pud_same(pud, pud)); > + WARN_ON(!pud_young(pud_mkyoung(pud_mkold(pud)))); > + WARN_ON(!pud_write(pud_mkwrite(pud_wrprotect(pud)))); > + WARN_ON(pud_write(pud_wrprotect(pud_mkwrite(pud)))); > + WARN_ON(pud_young(pud_mkold(pud_mkyoung(pud)))); > + > + if (mm_pmd_folded(mm)) > + return; > + > + /* > + * A huge page does not point to next level page table > + * entry. Hence this must qualify as pud_bad(). > + */ > + WARN_ON(!pud_bad(pud_mkhuge(pud))); > +} > +#else > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > +#else > +static void __init pmd_basic_tests(unsigned long pfn, pgprot_t prot) { } > +static void __init pud_basic_tests(unsigned long pfn, pgprot_t prot) { } > +#endif > + > +static void __init p4d_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + p4d_t p4d; > + > + memset(&p4d, RANDOM_NZVALUE, sizeof(p4d_t)); > + WARN_ON(!p4d_same(p4d, p4d)); > +} > + > +static void __init pgd_basic_tests(unsigned long pfn, pgprot_t prot) > +{ > + pgd_t pgd; > + > + memset(&pgd, RANDOM_NZVALUE, sizeof(pgd_t)); > + WARN_ON(!pgd_same(pgd, pgd)); > +} > + > +#ifndef __PAGETABLE_PUD_FOLDED > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) > +{ > + pud_t pud = READ_ONCE(*pudp); > + > + if (mm_pmd_folded(mm)) > + return; > + > + pud = __pud(pud_val(pud) | RANDOM_ORVALUE); > + WRITE_ONCE(*pudp, pud); > + pud_clear(pudp); > + pud = READ_ONCE(*pudp); > + WARN_ON(!pud_none(pud)); > +} > + > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > + pud_t pud; > + > + if (mm_pmd_folded(mm)) > + return; > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pud_bad(). > + */ > + pmd_clear(pmdp); > + pud_clear(pudp); > + pud_populate(mm, pudp, pmdp); > + pud = READ_ONCE(*pudp); > + WARN_ON(pud_bad(pud)); > +} > +#else > +static void __init pud_clear_tests(struct mm_struct *mm, pud_t *pudp) { } > +static void __init pud_populate_tests(struct mm_struct *mm, pud_t *pudp, > + pmd_t *pmdp) > +{ > +} > +#endif > + > +#ifndef __PAGETABLE_P4D_FOLDED > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) > +{ > + p4d_t p4d = READ_ONCE(*p4dp); > + > + if (mm_pud_folded(mm)) > + return; > + > + p4d = __p4d(p4d_val(p4d) | RANDOM_ORVALUE); > + WRITE_ONCE(*p4dp, p4d); > + p4d_clear(p4dp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(!p4d_none(p4d)); > +} > + > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > + p4d_t p4d; > + > + if (mm_pud_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as p4d_bad(). > + */ > + pud_clear(pudp); > + p4d_clear(p4dp); > + p4d_populate(mm, p4dp, pudp); > + p4d = READ_ONCE(*p4dp); > + WARN_ON(p4d_bad(p4d)); > +} > + > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) > +{ > + pgd_t pgd = READ_ONCE(*pgdp); > + > + if (mm_p4d_folded(mm)) > + return; > + > + pgd = __pgd(pgd_val(pgd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pgdp, pgd); > + pgd_clear(pgdp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(!pgd_none(pgd)); > +} > + > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > + pgd_t pgd; > + > + if (mm_p4d_folded(mm)) > + return; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pgd_bad(). > + */ > + p4d_clear(p4dp); > + pgd_clear(pgdp); > + pgd_populate(mm, pgdp, p4dp); > + pgd = READ_ONCE(*pgdp); > + WARN_ON(pgd_bad(pgd)); > +} > +#else > +static void __init p4d_clear_tests(struct mm_struct *mm, p4d_t *p4dp) { } > +static void __init pgd_clear_tests(struct mm_struct *mm, pgd_t *pgdp) { } > +static void __init p4d_populate_tests(struct mm_struct *mm, p4d_t *p4dp, > + pud_t *pudp) > +{ > +} > +static void __init pgd_populate_tests(struct mm_struct *mm, pgd_t *pgdp, > + p4d_t *p4dp) > +{ > +} > +#endif > + > +static void __init pte_clear_tests(struct mm_struct *mm, pte_t *ptep) > +{ > + pte_t pte = READ_ONCE(*ptep); > + > + pte = __pte(pte_val(pte) | RANDOM_ORVALUE); > + WRITE_ONCE(*ptep, pte); > + pte_clear(mm, 0, ptep); > + pte = READ_ONCE(*ptep); > + WARN_ON(!pte_none(pte)); > +} > + > +static void __init pmd_clear_tests(struct mm_struct *mm, pmd_t *pmdp) > +{ > + pmd_t pmd = READ_ONCE(*pmdp); > + > + pmd = __pmd(pmd_val(pmd) | RANDOM_ORVALUE); > + WRITE_ONCE(*pmdp, pmd); > + pmd_clear(pmdp); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(!pmd_none(pmd)); > +} > + > +static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, > + pgtable_t pgtable) > +{ > + pmd_t pmd; > + > + /* > + * This entry points to next level page table page. > + * Hence this must not qualify as pmd_bad(). > + */ > + pmd_clear(pmdp); > + pmd_populate(mm, pmdp, pgtable); > + pmd = READ_ONCE(*pmdp); > + WARN_ON(pmd_bad(pmd)); > +} > + > +static unsigned long __init get_random_vaddr(void) > +{ > + unsigned long random_vaddr, random_pages, total_user_pages; > + > + total_user_pages = (TASK_SIZE - FIRST_USER_ADDRESS) / PAGE_SIZE; > + > + random_pages = get_random_long() % total_user_pages; > + random_vaddr = FIRST_USER_ADDRESS + random_pages * PAGE_SIZE; > + > + return random_vaddr; > +} > + > +void __init debug_vm_pgtable(void) > +{ > + struct mm_struct *mm; > + pgd_t *pgdp; > + p4d_t *p4dp, *saved_p4dp; > + pud_t *pudp, *saved_pudp; > + pmd_t *pmdp, *saved_pmdp, pmd; > + pte_t *ptep; > + pgtable_t saved_ptep; > + pgprot_t prot; > + phys_addr_t paddr; > + unsigned long vaddr, pte_aligned, pmd_aligned; > + unsigned long pud_aligned, p4d_aligned, pgd_aligned; > + > + pr_info("Validating architecture page table helpers\n"); > + prot = vm_get_page_prot(VMFLAGS); > + vaddr = get_random_vaddr(); > + mm = mm_alloc(); > + if (!mm) { > + pr_err("mm_struct allocation failed\n"); > + return; > + } > + > + /* > + * PFN for mapping at PTE level is determined from a standard kernel > + * text symbol. But pfns for higher page table levels are derived by > + * masking lower bits of this real pfn. These derived pfns might not > + * exist on the platform but that does not really matter as pfn_pxx() > + * helpers will still create appropriate entries for the test. This > + * helps avoid large memory block allocations to be used for mapping > + * at higher page table levels. > + */ > + paddr = __pa(&start_kernel); > + > + pte_aligned = (paddr & PAGE_MASK) >> PAGE_SHIFT; > + pmd_aligned = (paddr & PMD_MASK) >> PAGE_SHIFT; > + pud_aligned = (paddr & PUD_MASK) >> PAGE_SHIFT; > + p4d_aligned = (paddr & P4D_MASK) >> PAGE_SHIFT; > + pgd_aligned = (paddr & PGDIR_MASK) >> PAGE_SHIFT; > + WARN_ON(!pfn_valid(pte_aligned)); > + > + pgdp = pgd_offset(mm, vaddr); > + p4dp = p4d_alloc(mm, pgdp, vaddr); > + pudp = pud_alloc(mm, p4dp, vaddr); > + pmdp = pmd_alloc(mm, pudp, vaddr); > + ptep = pte_alloc_map(mm, pmdp, vaddr); > + > + /* > + * Save all the page table page addresses as the page table > + * entries will be used for testing with random or garbage > + * values. These saved addresses will be used for freeing > + * page table pages. > + */ > + pmd = READ_ONCE(*pmdp); > + saved_p4dp = p4d_offset(pgdp, 0UL); > + saved_pudp = pud_offset(p4dp, 0UL); > + saved_pmdp = pmd_offset(pudp, 0UL); > + saved_ptep = pmd_pgtable(pmd); > + > + pte_basic_tests(pte_aligned, prot); > + pmd_basic_tests(pmd_aligned, prot); > + pud_basic_tests(pud_aligned, prot); > + p4d_basic_tests(p4d_aligned, prot); > + pgd_basic_tests(pgd_aligned, prot); > + > + pte_clear_tests(mm, ptep); > + pmd_clear_tests(mm, pmdp); > + pud_clear_tests(mm, pudp); > + p4d_clear_tests(mm, p4dp); > + pgd_clear_tests(mm, pgdp); > + > + pte_unmap(ptep); > + > + pmd_populate_tests(mm, pmdp, saved_ptep); > + pud_populate_tests(mm, pudp, saved_pmdp); > + p4d_populate_tests(mm, p4dp, saved_pudp); > + pgd_populate_tests(mm, pgdp, saved_p4dp); > + > + p4d_free(mm, saved_p4dp); > + pud_free(mm, saved_pudp); > + pmd_free(mm, saved_pmdp); > + pte_free(mm, saved_ptep); > + > + mm_dec_nr_puds(mm); > + mm_dec_nr_pmds(mm); > + mm_dec_nr_ptes(mm); > + mmdrop(mm); > +} From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.3 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,USER_AGENT_SANE_2 autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 671E3C4BA17 for ; Wed, 26 Feb 2020 14:09:57 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 33BCD2467B for ; Wed, 26 Feb 2020 14:09:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="fmkN4WQZ"; dkim=fail reason="signature verification failed" (2048-bit key) header.d=lca.pw header.i=@lca.pw header.b="YE3R28K0" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 33BCD2467B Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=lca.pw Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Mime-Version:References:In-Reply-To: Date:To:From:Subject:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=uG7ABdAhIo9OeabXTZzMHL3/nAkNXJc1jtL9b30JYXA=; b=fmkN4WQZmeSIDM 3/EZ1fd98gax3Gyt4hs9kRWw8YfQcckxn4wonQ+5eWcJmACRYAZl6mX67nv5PT4d8RNoX6N9dRGPD v+z3iA8yx/GyRCBMxu2TXTYxmx20lKA3IgVjWMPM+52SpSBmRawJS/81eHOB7X/VfCRqIghEu2yZv zg8BC/Pr6d8jtefcZZV1dZxuNcsw5guxt7Z8jZ5s7/4/YFLqFeX1RIt3voFpK44YgGPuAJsUrdVDp K9x+dtZ1/bw/3Zo5xwbMyCtD4L/Kn1ya6SZcSad0Lq8Pr4+GtVeRZFwW0wlTMysS63LeWI+Kg0KUN q+LmOV7o5JHt57YZIhtQ==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6xNs-0002vt-Qk; Wed, 26 Feb 2020 14:09:56 +0000 Received: from mail-qt1-x841.google.com ([2607:f8b0:4864:20::841]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1j6xNm-0002uX-Ii for linux-arm-kernel@lists.infradead.org; Wed, 26 Feb 2020 14:09:54 +0000 Received: by mail-qt1-x841.google.com with SMTP id d5so2331416qto.0 for ; Wed, 26 Feb 2020 06:09:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lca.pw; s=google; h=message-id:subject:from:to:cc:date:in-reply-to:references :mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=YE3R28K03/OSkKci4pIu5feJz/Gza2peB1lndyCeGfvTr8WSbzxpFaAqlK/20xrBvl 6QpXE5F7H7Vx83KoDdAzQd4b3z0ApO16qPGG/ft6YbvZNOaPkn87uQWs825uQ85pt/4b 6iLpy8Vc4N/vq91uAhMsYpM6abgr85RtDcb3e6GNiUOwS/8MHsgktIWoPXcHIJX382y4 eQPAzmcZV3HPXCrkguoaDLw2qUKIkkBKWsa0lAG3fgRUaEaHdqBmwboSJl5RPi1yeMej b/aMFlj2uh6WPxJMdvcluXKnXEc/lfM/eeQ1zXrVk7RsLNT7Ol7Bgk22NZcLjJQYlBn5 L7MA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:message-id:subject:from:to:cc:date:in-reply-to :references:mime-version:content-transfer-encoding; bh=G9AF7HwBvzniHwSaAO0sGMgRWxAm6d66pGJFYLAcUqk=; b=hsV+VXGKwaOJiR/AQQPuLyWgoETi781TypRyfi2Yn4mEUZUhSM4et25SpFrRFqMnbe z5vIPtyt2Hxsq2JY9MSiSY/zP9pgHyyAPsJdax+tK2hBMC5VFnPYOYb3XKbJfHIkJv1k qIMXFCSKQMqQ2jRcnmcAHmSq1hO7ZjMKWGmdw1gGpSwsLGVNQvS1iz/iQ4Ww9odkJpV/ Il+uMXlO6n7ngP4AqPYCAWZ0b3lBLWinE0lmfIsb0Yf6dAbJdPANJVv4kQ3zbTFov8nO hS24bNjALVaCivTtEOdv9LW8AaQs38UwZrKiR1dUs4wfpEcz37fwDyALwyDUvyteo6Kf opFg== X-Gm-Message-State: APjAAAXgyMsuROd8zAyfxs79JpGojLE6H35UTt/Zz++MXcSllT7QiaYG XxsajYb6t8GHDoO3x0eAqsNhdA== X-Google-Smtp-Source: APXvYqxRvESuFPk6siqL9qo/1/2cXkkp2ceYeSTQ/uCoTGJhGid6usa2pYO6rAddiidPiSORcGRtfQ== X-Received: by 2002:ac8:2bf8:: with SMTP id n53mr5572816qtn.1.1582726185762; Wed, 26 Feb 2020 06:09:45 -0800 (PST) Received: from dhcp-41-57.bos.redhat.com (nat-pool-bos-t.redhat.com. [66.187.233.206]) by smtp.gmail.com with ESMTPSA id b5sm1176402qkg.110.2020.02.26.06.09.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Wed, 26 Feb 2020 06:09:44 -0800 (PST) Message-ID: <1582726182.7365.123.camel@lca.pw> Subject: Re: [PATCH V14] mm/debug: Add tests validating architecture page table helpers From: Qian Cai To: Anshuman Khandual , linux-mm@kvack.org Date: Wed, 26 Feb 2020 09:09:42 -0500 In-Reply-To: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> References: <1581909460-19148-1-git-send-email-anshuman.khandual@arm.com> X-Mailer: Evolution 3.22.6 (3.22.6-10.el7) Mime-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200226_060950_630336_3896449B X-CRM114-Status: GOOD ( 26.23 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Catalin Marinas , Heiko Carstens , Paul Mackerras , "H. Peter Anvin" , linux-riscv@lists.infradead.org, Will Deacon , linux-arch@vger.kernel.org, linux-s390@vger.kernel.org, Michael Ellerman , x86@kernel.org, Mike Rapoport , Christian Borntraeger , Ingo Molnar , Benjamin Herrenschmidt , linux-snps-arc@lists.infradead.org, Vasily Gorbik , Borislav Petkov , Paul Walmsley , "Kirill A . Shutemov" , Thomas Gleixner , linux-arm-kernel@lists.infradead.org, Christophe Leroy , Vineet Gupta , linux-kernel@vger.kernel.org, Palmer Dabbelt , Andrew Morton , linuxppc-dev@lists.ozlabs.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gTW9uLCAyMDIwLTAyLTE3IGF0IDA4OjQ3ICswNTMwLCBBbnNodW1hbiBLaGFuZHVhbCB3cm90 ZToKPiBUaGlzIGFkZHMgdGVzdHMgd2hpY2ggd2lsbCB2YWxpZGF0ZSBhcmNoaXRlY3R1cmUgcGFn ZSB0YWJsZSBoZWxwZXJzIGFuZAo+IG90aGVyIGFjY2Vzc29ycyBpbiB0aGVpciBjb21wbGlhbmNl IHdpdGggZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3MuCj4gVGhpcyB3aWxsIGhlbHAgdmFy aW91cyBhcmNoaXRlY3R1cmVzIGluIHZhbGlkYXRpbmcgY2hhbmdlcyB0byBleGlzdGluZwo+IHBh Z2UgdGFibGUgaGVscGVycyBvciBhZGRpdGlvbiBvZiBuZXcgb25lcy4KPiAKPiBUaGlzIHRlc3Qg Y292ZXJzIGJhc2ljIHBhZ2UgdGFibGUgZW50cnkgdHJhbnNmb3JtYXRpb25zIGluY2x1ZGluZyBi dXQgbm90Cj4gbGltaXRlZCB0byBvbGQsIHlvdW5nLCBkaXJ0eSwgY2xlYW4sIHdyaXRlLCB3cml0 ZSBwcm90ZWN0IGV0YyBhdCB2YXJpb3VzCj4gbGV2ZWwgYWxvbmcgd2l0aCBwb3B1bGF0aW5nIGlu dGVybWVkaWF0ZSBlbnRyaWVzIHdpdGggbmV4dCBwYWdlIHRhYmxlIHBhZ2UKPiBhbmQgdmFsaWRh dGluZyB0aGVtLgo+IAo+IFRlc3QgcGFnZSB0YWJsZSBwYWdlcyBhcmUgYWxsb2NhdGVkIGZyb20g c3lzdGVtIG1lbW9yeSB3aXRoIHJlcXVpcmVkIHNpemUKPiBhbmQgYWxpZ25tZW50cy4gVGhlIG1h cHBlZCBwZm5zIGF0IHBhZ2UgdGFibGUgbGV2ZWxzIGFyZSBkZXJpdmVkIGZyb20gYQo+IHJlYWwg cGZuIHJlcHJlc2VudGluZyBhIHZhbGlkIGtlcm5lbCB0ZXh0IHN5bWJvbC4gVGhpcyB0ZXN0IGdl dHMgY2FsbGVkCj4gaW5zaWRlIGtlcm5lbF9pbml0KCkgcmlnaHQgYWZ0ZXIgYXN5bmNfc3luY2hy b25pemVfZnVsbCgpLgo+IAo+IFRoaXMgdGVzdCBnZXRzIGJ1aWx0IGFuZCBydW4gd2hlbiBDT05G SUdfREVCVUdfVk1fUEdUQUJMRSBpcyBzZWxlY3RlZC4gQW55Cj4gYXJjaGl0ZWN0dXJlLCB3aGlj aCBpcyB3aWxsaW5nIHRvIHN1YnNjcmliZSB0aGlzIHRlc3Qgd2lsbCBuZWVkIHRvIHNlbGVjdAo+ IEFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUuIEZvciBub3cgdGhpcyBpcyBsaW1pdGVkIHRvIGFy YywgYXJtNjQsIHg4NiwgczM5MAo+IGFuZCBwcGMzMiBwbGF0Zm9ybXMgd2hlcmUgdGhlIHRlc3Qg aXMga25vd24gdG8gYnVpbGQgYW5kIHJ1biBzdWNjZXNzZnVsbHkuCj4gR29pbmcgZm9yd2FyZCwg b3RoZXIgYXJjaGl0ZWN0dXJlcyB0b28gY2FuIHN1YnNjcmliZSB0aGUgdGVzdCBhZnRlciBmaXhp bmcKPiBhbnkgYnVpbGQgb3IgcnVudGltZSBwcm9ibGVtcyB3aXRoIHRoZWlyIHBhZ2UgdGFibGUg aGVscGVycy4gTWVhbndoaWxlIGZvcgo+IGJldHRlciBwbGF0Zm9ybSBjb3ZlcmFnZSwgdGhlIHRl c3QgY2FuIGFsc28gYmUgZW5hYmxlZCB3aXRoIENPTkZJR19FWFBFUlQKPiBldmVuIHdpdGhvdXQg QVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRS4KPiAKPiBGb2xrcyBpbnRlcmVzdGVkIGluIG1ha2lu ZyBzdXJlIHRoYXQgYSBnaXZlbiBwbGF0Zm9ybSdzIHBhZ2UgdGFibGUgaGVscGVycwo+IGNvbmZv cm0gdG8gZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3Mgc2hvdWxkIGVuYWJsZSB0aGUgYWJv dmUgY29uZmlnCj4gd2hpY2ggd2lsbCBqdXN0IHRyaWdnZXIgdGhpcyB0ZXN0IGR1cmluZyBib290 LiBBbnkgbm9uIGNvbmZvcm1pdHkgaGVyZSB3aWxsCj4gYmUgcmVwb3J0ZWQgYXMgYW4gd2Fybmlu ZyB3aGljaCB3b3VsZCBuZWVkIHRvIGJlIGZpeGVkLiBUaGlzIHRlc3Qgd2lsbCBoZWxwCj4gY2F0 Y2ggYW55IGNoYW5nZXMgdG8gdGhlIGFncmVlZCB1cG9uIHNlbWFudGljcyBleHBlY3RlZCBmcm9t IGdlbmVyaWMgTU0gYW5kCj4gZW5hYmxlIHBsYXRmb3JtcyB0byBhY2NvbW1vZGF0ZSBpdCB0aGVy ZWFmdGVyLgoKSG93IHVzZWZ1bCBpcyB0aGlzIHRoYXQgc3RyYWlnaHRseSBjcmFzaCB0aGUgcG93 ZXJwYz8KClvCoMKgwqAyMy4yNjM0MjVdW8KgwqDCoMKgVDFdIGRlYnVnX3ZtX3BndGFibGU6IGRl YnVnX3ZtX3BndGFibGU6IFZhbGlkYXRpbmcKYXJjaGl0ZWN0dXJlIHBhZ2UgdGFibGUgaGVscGVy cwpbwqDCoMKgMjMuMjYzNjI1XVvCoMKgwqDCoFQxXSAtLS0tLS0tLS0tLS1bIGN1dCBoZXJlIF0t LS0tLS0tLS0tLS0KW8KgwqDCoDIzLjI2MzY0OV1bwqDCoMKgwqBUMV0ga2VybmVsIEJVRyBhdCBh cmNoL3Bvd2VycGMvbW0vcGd0YWJsZS5jOjI3NCEKW8KgwqDCoDIzLjI2MzY3NV1bwqDCoMKgwqBU MV0gT29wczogRXhjZXB0aW9uIGluIGtlcm5lbCBtb2RlLCBzaWc6IDUgWyMxXQpbwqDCoMKgMjMu MjYzNjk4XVvCoMKgwqDCoFQxXSBMRSBQQUdFX1NJWkU9NjRLIE1NVT1SYWRpeCBTTVAgTlJfQ1BV Uz0yNTYKREVCVUdfUEFHRUFMTE9DIE5VTUEgUG93ZXJOVgpbwqDCoMKgMjMuMjYzNzMxXVvCoMKg wqDCoFQxXSBNb2R1bGVzIGxpbmtlZCBpbjoKW8KgwqDCoDIzLjI2Mzc1Ml1bwqDCoMKgwqBUMV0g Q1BVOiA0IFBJRDogMSBDb21tOiBzd2FwcGVyLzAgTm90IHRhaW50ZWQgNS42LjAtcmMzLW5leHQt CjIwMjAwMjI2ICMxClvCoMKgwqAyMy4yNjM3NzZdW8KgwqDCoMKgVDFdIE5JUDrCoMKgYzAwMDAw MDAwMDA3MzA4YyBMUjogYzAwMDAwMDAwMTAzZGJkOCBDVFI6CjAwMDAwMDAwMDAwMDAwMDAKW8Kg wqDCoDIzLjI2MzgxMF1bwqDCoMKgwqBUMV0gUkVHUzogYzAwMDAwMDAzZGRhZjljMCBUUkFQOiAw NzAwwqDCoMKgTm90IHRhaW50ZWTCoMKgKDUuNi4wLQpyYzMtbmV4dC0yMDIwMDIyNikKW8KgwqDC oDIzLjI2Mzg0Nl1bwqDCoMKgwqBUMV0gTVNSOsKgwqA5MDAwMDAwMDAwMDI5MDMzIDxTRixIVixF RSxNRSxJUixEUixSSSxMRT7CoMKgQ1I6CjIyMDAwMjI4wqDCoFhFUjogMDAwMDAwMDAKW8KgwqDC oDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gQ0ZBUjogYzAwMDAwMDAwMDA3MzAzMCBJUlFNQVNLOiAw wqAKW8KgwqDCoDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gR1BSMDA6IGMwMDAwMDAwMDEwM2RiZDgg YzAwMDAwMDAzZGRhZmM1MCBjMDAwMDAwMDAxNjU2ZjAwCmMwMDAwMDFkN2I0Y2EwODDCoApbwqDC oMKgMjMuMjYzODg4XVvCoMKgwqDCoFQxXSBHUFIwNDogMDAwMDAwMDAwMDAwMDAwMCAwMDAwMDAw MDAwMDAwMDA5IGMwMDAwMDAwM2RkYWZjMDQKMDAwMDAwMDAwMDAwMDAwMMKgClvCoMKgwqAyMy4y NjM4ODhdW8KgwqDCoMKgVDFdIEdQUjA4OiBmMGZmZmZmZmZmZmZmZmZmIDAwMDAwMDAwMDAwMDAw MDEgYzAwMDAwMDAwMTYyNzlkMAowMDAwMDAwMDAwMGEwMDAwwqAKW8KgwqDCoDIzLjI2Mzg4OF1b wqDCoMKgwqBUMV0gR1BSMTI6IDAwMDAwMDAwMDAwMDAwMDAgYzAwMDAwMWZmZmZmYWUwMCBjMDAw MDAwMDAwMDEwZTg0CjAwMDAwMDAwMDAwMDAwMDDCoApbwqDCoMKgMjMuMjYzODg4XVvCoMKgwqDC oFQxXSBHUFIxNjogMDAwMDAwMDAwMDAwMDAwMCA4MDAwMDAwMDAwMDAwMTA1IDAwMDAwMDAwMDAw MDAxMDAKYzAwMDAwMDAwMTY4OWExOMKgClvCoMKgwqAyMy4yNjM4ODhdW8KgwqDCoMKgVDFdIEdQ UjIwOiBjMDAwMjAwMzJjNjYwMDAwIGMwMDAyMDAzMmM2MjAwMDAgYzAwMDAwMDAwMTcxNjAzMApj MDAwMjAwMzJjNjAwMDAwwqAKW8KgwqDCoDIzLjI2Mzg4OF1bwqDCoMKgwqBUMV0gR1BSMjQ6IDAw MDAwMDAwMDAwMDAwMGQgYzAwMDAwMDAwMTcxNjAzMCBjMDAwMDAxZDdiNGNhMDgwCmMwMDAwMDAw MDE3MTYwNDDCoApbwqDCoMKgMjMuMjYzODg4XVvCoMKgwqDCoFQxXSBHUFIyODogYzAwMDAwMDAw MTcxNjAzOCAwMDAwMDAwMDAwMDAwMDAwIDAwMDAwMDAwMDAwMDAwMDAKMDAwMDAwMDAwMDAwMDAw MMKgClvCoMKgwqAyMy4yNjQxMjJdW8KgwqDCoMKgVDFdIE5JUCBbYzAwMDAwMDAwMDA3MzA4Y10g YXNzZXJ0X3B0ZV9sb2NrZWQrMHgxMWMvMHgzMjAKW8KgwqDCoDIzLjI2NDE1NF1bwqDCoMKgwqBU MV0gTFIgW2MwMDAwMDAwMDEwM2RiZDhdIGRlYnVnX3ZtX3BndGFibGUrMHg3NzAvMHhiN2MKW8Kg wqDCoDIzLjI2NDE4Nl1bwqDCoMKgwqBUMV0gQ2FsbCBUcmFjZToKW8KgwqDCoDIzLjI2NDIwNl1b wqDCoMKgwqBUMV0gW2MwMDAwMDAwM2RkYWZjNTBdIFtjMDAwMDAwMDAwOTk5NzYwXQpfcmF3X3Nw aW5fdW5sb2NrKzB4MzAvMHg3MCAodW5yZWxpYWJsZSkKW8KgwqDCoDIzLjI2NDI0NF1bwqDCoMKg wqBUMV0gW2MwMDAwMDAwM2RkYWZjZDBdIFtjMDAwMDAwMDAxMDNkOTI0XQpkZWJ1Z192bV9wZ3Rh YmxlKzB4NGJjLzB4YjdjClvCoMKgwqAyMy4yNjQyNzldW8KgwqDCoMKgVDFdIFtjMDAwMDAwMDNk ZGFmZGIwXSBbYzAwMDAwMDAwMDAxMGVhY10Ka2VybmVsX2luaXQrMHgzMC8weDE5NApbwqDCoMKg MjMuMjY0MzE1XVvCoMKgwqDCoFQxXSBbYzAwMDAwMDAzZGRhZmUyMF0gW2MwMDAwMDAwMDAwMGI3 NDhdCnJldF9mcm9tX2tlcm5lbF90aHJlYWQrMHg1Yy8weDc0ClvCoMKgwqAyMy4yNjQzNDldW8Kg wqDCoMKgVDFdIEluc3RydWN0aW9uIGR1bXA6ClvCoMKgwqAyMy4yNjQzNjhdW8KgwqDCoMKgVDFd IDYwMDAwMDAwIDNiZTAwMDAxIDdmYmVmNDM2IGVhZmEwMDQwIDdmZmZjMDMwIDNiZmZmZmZmCjdm ZmYwN2I0IDdmZmZmMDM4wqAKW8KgwqDCoDIzLjI2NDQwOV1bwqDCoMKgwqBUMV0gN2JmZjFmMjQg N2QzN2Y4MmEgN2QyOTAwNzQgNzkyOWQxODIgPDBiMDkwMDAwPiBlYmRiMDAwMAplOTNjMDAwMCA3 ZmRlNGExNMKgClvCoMKgwqAyMy4yNjQ0NjBdW8KgwqDCoMKgVDFdIC0tLVsgZW5kIHRyYWNlIDcy ZDI5MzEwMjJlOWFiMjQgXS0tLQpbwqDCoMKgMjMuNjI3MzExXVvCoMKgwqDCoFQxXcKgClvCoMKg wqAyNC42Mjc0MDddW8KgwqDCoMKgVDFdIEtlcm5lbCBwYW5pYyAtIG5vdCBzeW5jaW5nOiBGYXRh bCBleGNlcHRpb24KW8KgwqDCoDI2LjUKCj4gCj4gQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGlu dXgtZm91bmRhdGlvbi5vcmc+Cj4gQ2M6IE1pa2UgUmFwb3BvcnQgPHJwcHRAbGludXguaWJtLmNv bT4KPiBDYzogVmluZWV0IEd1cHRhIDx2Z3VwdGFAc3lub3BzeXMuY29tPgo+IENjOiBDYXRhbGlu IE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+IENjOiBXaWxsIERlYWNvbiA8d2ls bEBrZXJuZWwub3JnPgo+IENjOiBCZW5qYW1pbiBIZXJyZW5zY2htaWR0IDxiZW5oQGtlcm5lbC5j cmFzaGluZy5vcmc+Cj4gQ2M6IFBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgo+IENj OiBNaWNoYWVsIEVsbGVybWFuIDxtcGVAZWxsZXJtYW4uaWQuYXU+Cj4gQ2M6IEhlaWtvIENhcnN0 ZW5zIDxoZWlrby5jYXJzdGVuc0BkZS5pYm0uY29tPgo+IENjOiBWYXNpbHkgR29yYmlrIDxnb3JA bGludXguaWJtLmNvbT4KPiBDYzogQ2hyaXN0aWFuIEJvcm50cmFlZ2VyIDxib3JudHJhZWdlckBk ZS5pYm0uY29tPgo+IENjOiBUaG9tYXMgR2xlaXhuZXIgPHRnbHhAbGludXRyb25peC5kZT4KPiBD YzogSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+Cj4gQ2M6IEJvcmlzbGF2IFBldGtvdiA8 YnBAYWxpZW44LmRlPgo+IENjOiAiSC4gUGV0ZXIgQW52aW4iIDxocGFAenl0b3IuY29tPgo+IENj OiBLaXJpbGwgQS4gU2h1dGVtb3YgPGtpcmlsbEBzaHV0ZW1vdi5uYW1lPgo+IENjOiBQYXVsIFdh bG1zbGV5IDxwYXVsLndhbG1zbGV5QHNpZml2ZS5jb20+Cj4gQ2M6IFBhbG1lciBEYWJiZWx0IDxw YWxtZXJAZGFiYmVsdC5jb20+Cj4gQ2M6IGxpbnV4LXNucHMtYXJjQGxpc3RzLmluZnJhZGVhZC5v cmcKPiBDYzogbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCj4gQ2M6IGxpbnV4 cHBjLWRldkBsaXN0cy5vemxhYnMub3JnCj4gQ2M6IGxpbnV4LXMzOTBAdmdlci5rZXJuZWwub3Jn Cj4gQ2M6IGxpbnV4LXJpc2N2QGxpc3RzLmluZnJhZGVhZC5vcmcKPiBDYzogeDg2QGtlcm5lbC5v cmcKPiBDYzogbGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKPiBDYzogbGludXgta2VybmVsQHZn ZXIua2VybmVsLm9yZwo+IAo+IFN1Z2dlc3RlZC1ieTogQ2F0YWxpbiBNYXJpbmFzIDxjYXRhbGlu Lm1hcmluYXNAYXJtLmNvbT4KPiBSZXZpZXdlZC1ieTogSW5nbyBNb2xuYXIgPG1pbmdvQGtlcm5l bC5vcmc+Cj4gVGVzdGVkLWJ5OiBHZXJhbGQgU2NoYWVmZXIgPGdlcmFsZC5zY2hhZWZlckBkZS5p Ym0uY29tPgkjIHMzOTAKPiBUZXN0ZWQtYnk6IENocmlzdG9waGUgTGVyb3kgPGNocmlzdG9waGUu bGVyb3lAYy1zLmZyPgkjIHBwYzMyCj4gU2lnbmVkLW9mZi1ieTogQW5kcmV3IE1vcnRvbiA8YWtw bUBsaW51eC1mb3VuZGF0aW9uLm9yZz4KPiBTaWduZWQtb2ZmLWJ5OiBDaHJpc3RvcGhlIExlcm95 IDxjaHJpc3RvcGhlLmxlcm95QGMtcy5mcj4KPiBTaWduZWQtb2ZmLWJ5OiBBbnNodW1hbiBLaGFu ZHVhbCA8YW5zaHVtYW4ua2hhbmR1YWxAYXJtLmNvbT4KPiAtLS0KPiBUaGlzIGFkZHMgYSB0ZXN0 IHZhbGlkYXRpb24gZm9yIGFyY2hpdGVjdHVyZSBleHBvcnRlZCBwYWdlIHRhYmxlIGhlbHBlcnMu Cj4gUGF0Y2ggYWRkcyBiYXNpYyB0cmFuc2Zvcm1hdGlvbiB0ZXN0cyBhdCB2YXJpb3VzIGxldmVs cyBvZiB0aGUgcGFnZSB0YWJsZS4KPiAKPiBUaGlzIHRlc3Qgd2FzIG9yaWdpbmFsbHkgc3VnZ2Vz dGVkIGJ5IENhdGFsaW4gZHVyaW5nIGFybTY0IFRIUCBtaWdyYXRpb24KPiBSRkMgZGlzY3Vzc2lv biBlYXJsaWVyLiBHb2luZyBmb3J3YXJkIGl0IGNhbiBpbmNsdWRlIG1vcmUgc3BlY2lmaWMgdGVz dHMKPiB3aXRoIHJlc3BlY3QgdG8gdmFyaW91cyBnZW5lcmljIE1NIGZ1bmN0aW9ucyBsaWtlIFRI UCwgSHVnZVRMQiBldGMgYW5kCj4gcGxhdGZvcm0gc3BlY2lmaWMgdGVzdHMuCj4gCj4gaHR0cHM6 Ly9sb3JlLmtlcm5lbC5vcmcvbGludXgtbW0vMjAxOTA2MjgxMDIwMDMuR0E1NjQ2M0BhcnJha2lz LmVtZWEuYXJtLmNvbS8KPiAKPiBOZWVkcyB0byBiZSBhcHBsaWVkIG9uIGxpbnV4IFY1LjYtcmMy Cj4gCj4gQ2hhbmdlcyBpbiBWMTQ6Cj4gCj4gLSBEaXNhYmxlZCBERUJVR19WTV9QR0ZMQUdTIGZv ciBJQTY0IGFuZCBBUk0gKDMyIEJpdCkgcGVyIEFuZHJldyBhbmQgQ2hyaXN0b3BoZQo+IC0gVXBk YXRlZCBERUJVR19WTV9QR0ZMQUdTIGRvY3VtZW50YXRpb24gd3J0IEVYUEVSVCBhbmQgZGlzYWJs ZWQgcGxhdGZvcm1zCj4gLSBVcGRhdGVkIFJBTkRPTV9bT1J8TlpdVkFMVUUgb3BlbiBlbmNvZGlu Z3Mgd2l0aCBHRU5NQVNLKCkgcGVyIENhdGFsaW4KPiAtIFVwZGF0ZWQgczM5MCBjb25zdHJhaW50 IGJpdHMgZnJvbSAxMiB0byA0IChTMzkwX01BU0tfQklUUykgcGVyIEdlcmFsZAo+IC0gVXBkYXRl ZCBpbi1jb2RlIGRvY3VtZW50YXRpb24gZm9yIFJBTkRPTV9PUlZBTFVFIHBlciBHZXJhbGQKPiAt IFVwZGF0ZWQgcHh4X2Jhc2ljX3Rlc3RzKCkgdG8gdXNlIGludmVydCBmdW5jdGlvbnMgZmlyc3Qg cGVyIENhdGFsaW4KPiAtIERyb3BwZWQgQVJDSF9IQVNfNExFVkVMX0hBQ0sgY2hlY2sgZnJvbSBw dWRfYmFzaWNfdGVzdHMoKQo+IC0gUmVwbGFjZWQgX19BUkNIX0hBU19bNHw1XUxFVkVMX0hBQ0sg d2l0aCBfX1BBR0VUQUJMRV9bUFVEfFA0RF1fRk9MREVEIHBlciBDYXRhbGluCj4gLSBUcmltbWVk IHRoZSBDQyBsaXN0IG9uIHRoZSBjb21taXQgbWVzc2FnZSBwZXIgQ2F0YWxpbgo+IAo+IENoYW5n ZXMgaW4gVjEzOiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1t L2xpc3QvP3Nlcmllcz0yMzcxMjUpCj4gCj4gLSBTdWJzY3JpYmVkIHMzOTAgcGxhdGZvcm0gYW5k IHVwZGF0ZWQgZGVidWctdm0tcGd0YWJsZS9hcmNoLXN1cHBvcnQudHh0IHBlciBHZXJhbGQKPiAt IERyb3BwZWQga2V5d29yZCAnZXh0ZXJuJyBmcm9tIGRlYnVnX3ZtX3BndGFibGUoKSBkZWNsYXJh dGlvbiBwZXIgQ2hyaXN0b3BoZQo+IC0gTW92ZWQgZGVidWdfdm1fcGd0YWJsZSgpIGRlY2xhcmF0 aW9ucyB0byA8bGludXgvbW1kZWJ1Zy5oPiBwZXIgQ2hyaXN0b3BoZQo+IC0gTW92ZWQgZGVidWdf dm1fcGd0YWJsZSgpIGNhbGwgc2l0ZSBpbnRvIGtlcm5lbF9pbml0KCkgcGVyIENocmlzdG9waGUK PiAtIENoYW5nZWQgQ09ORklHX0RFQlVHX1ZNX1BHVEFCTEUgcnVsZXMgcGVyIENocmlzdG9waGUK PiAtIFVwZGF0ZWQgY29tbWl0IHRvIGluY2x1ZGUgbmV3IHN1cHBvcnRlZCBwbGF0Zm9ybXMgYW5k IGNoYW5nZWQgY29uZmlnIHNlbGVjdGlvbgo+IAo+IENoYW5nZXMgaW4gVjEyOiAoaHR0cHM6Ly9w YXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xpc3QvP3Nlcmllcz0yMzM5MDUp Cj4gCj4gLSBSZXBsYWNlZCBfX21tZHJvcCgpIHdpdGggbW1kcm9wKCkKPiAtIEVuYWJsZSBBUkNI X0hBU19ERUJVR19WTV9QR1RBQkxFIG9uIFg4NiBmb3Igbm9uIENPTkZJR19YODZfUEFFIHBsYXRm b3JtcyBhcyB0aGUKPiAgIHRlc3QgcHJvY2VkdXJlIGludGVyZmVyZSB3aXRoIHByZS1hbGxvY2F0 ZWQgUE1EcyBhdHRhY2hlZCB0byB0aGUgUEdEIHJlc3VsdGluZwo+ICAgaW4gcnVudGltZSBmYWls dXJlcyB3aXRoIFZNX0JVR19PTigpCj4gCj4gQ2hhbmdlcyBpbiBWMTE6IChodHRwczovL3BhdGNo d29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVzPTIyMTEzNSkKPiAK PiAtIFJlYmFzZWQgdGhlIHBhdGNoIG9uIFY1LjQKPiAKPiBDaGFuZ2VzIGluIFYxMDogKGh0dHBz Oi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJvamVjdC9saW51eC1tbS9saXN0Lz9zZXJpZXM9MjA1 NTI5KQo+IAo+IC0gQWx3YXlzIGVuYWJsZSBERUJVR19WTV9QR1RBQkxFIHdoZW4gREVCVUdfVk0g aXMgZW5hYmxlZCBwZXIgSW5nbwo+IC0gQWRkZWQgdGFncyBmcm9tIEluZ28KPiAKPiBDaGFuZ2Vz IGluIFY5OiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xp c3QvP3Nlcmllcz0yMDE0MjkpCj4gCj4gLSBDaGFuZ2VkIGZlYXR1cmUgc3VwcG9ydCBlbnVtZXJh dGlvbiBmb3IgcG93ZXJwYyBwbGF0Zm9ybXMgcGVyIENocmlzdG9waGUKPiAtIENoYW5nZWQgY29u ZmlnIHdyYXBwZXIgZm9yIGJhc2ljX1twbWR8cHVkXV90ZXN0cygpIHRvIGVuYWJsZSBBUkMgcGxh dGZvcm0KPiAtIEVuYWJsZWQgdGhlIHRlc3Qgb24gQVJDIHBsYXRmb3JtCj4gCj4gQ2hhbmdlcyBp biBWODogKGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJvamVjdC9saW51eC1tbS9saXN0 Lz9zZXJpZXM9MTk0Mjk3KQo+IAo+IC0gRW5hYmxlZCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxF IG9uIFBQQzMyIHBsYXRmb3JtIHBlciBDaHJpc3RvcGhlCj4gLSBVcGRhdGVkIGZlYXR1cmUgZG9j dW1lbnRhdGlvbiBhcyBERUJVR19WTV9QR1RBQkxFIGlzIG5vdyBlbmFibGVkIG9uIFBQQzMyIHBs YXRmb3JtCj4gLSBNb3ZlZCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFIGVhcmxpZXIgdG8gaW5k ZW50IGl0IHdpdGggREVCVUdfVk0gcGVyIENocmlzdG9waGUKPiAtIEFkZGVkIGFuIGluZm9ybWF0 aW9uIG1lc3NhZ2UgaW4gZGVidWdfdm1fcGd0YWJsZSgpIHBlciBDaHJpc3RvcGhlCj4gLSBEcm9w cGVkIHJhbmRvbV92YWRkciBib3VuZGFyeSBjb25kaXRpb24gY2hlY2tzIHBlciBDaHJpc3RvcGhl IGFuZCBRaWFuCj4gLSBSZXBsYWNlZCB2aXJ0X2FkZHJfdmFsaWQoKSBjaGVjayB3aXRoIHBmbl92 YWxpZCgpIGNoZWNrIGluIGRlYnVnX3ZtX3BndGFibGUoKQo+IC0gU2xpZ2h0bHkgY2hhbmdlZCBw cl9mbXQoZm10KSBpbmZvcm1hdGlvbgo+IAo+IENoYW5nZXMgaW4gVjc6IChodHRwczovL3BhdGNo d29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVzPTE5MzA1MSkKPiAK PiAtIE1lbW9yeSBhbGxvY2F0aW9uIGFuZCBmcmVlIHJvdXRpbmVzIGZvciBtYXBwZWQgcGFnZXMg aGF2ZSBiZWVuIGRyb3BlZAo+IC0gTWFwcGVkIHBmbnMgYXJlIGRlcml2ZWQgZnJvbSBzdGFuZGFy ZCBrZXJuZWwgdGV4dCBzeW1ib2wgcGVyIE1hdHRoZXcKPiAtIE1vdmVkIGRlYnVnX3ZtX3BndGFh YmxlKCkgYWZ0ZXIgcGFnZV9hbGxvY19pbml0X2xhdGUoKSBwZXIgTWljaGFsIGFuZCBRaWFuIAo+ IC0gVXBkYXRlZCB0aGUgY29tbWl0IG1lc3NhZ2UgcGVyIE1pY2hhbAo+IC0gVXBkYXRlZCBXPTEg R0NDIHdhcm5pbmcgcHJvYmxlbSBvbiB4ODYgcGVyIFFpYW4gQ2FpCj4gLSBBZGRpdGlvbiBvZiBu ZXcgYWxsb2NfY29udGlnX3BhZ2VzKCkgaGVscGVyIGhhcyBiZWVuIHN1Ym1pdHRlZCBzZXBhcmF0 ZWx5Cj4gCj4gQ2hhbmdlcyBpbiBWNjogKGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcHJv amVjdC9saW51eC1tbS9saXN0Lz9zZXJpZXM9MTg3NTg5KQo+IAo+IC0gTW92ZWQgYWxsb2NfZ2ln YW50aWNfcGFnZV9vcmRlcigpIGludG8gbW0vcGFnZV9hbGxvYy5jIHBlciBNaWNoYWwKPiAtIE1v dmVkIGFsbG9jX2dpZ2FudGljX3BhZ2Vfb3JkZXIoKSB3aXRoaW4gQ09ORklHX0NPTlRJR19BTExP QyBpbiB0aGUgdGVzdAo+IC0gRm9sZGVkIEFuZHJldydzIGluY2x1ZGUvYXNtLWdlbmVyaWMvcGd0 YWJsZS5oIGZpeCBpbnRvIHRoZSB0ZXN0IHBhdGNoIDIvMgo+IAo+IENoYW5nZXMgaW4gVjU6ICho dHRwczovL3BhdGNod29yay5rZXJuZWwub3JnL3Byb2plY3QvbGludXgtbW0vbGlzdC8/c2VyaWVz PTE4NTk5MSkKPiAKPiAtIFJlZGVmaW5lZCBhbmQgbW92ZWQgWDg2IG1tX3A0ZF9mb2xkZWQoKSBp bnRvIGEgZGlmZmVyZW50IGhlYWRlciBwZXIgS2lyaWxsL0luZ28KPiAtIFVwZGF0ZWQgdGhlIGNv bmZpZyBvcHRpb24gY29tbWVudCBwZXIgSW5nbyBhbmQgZHJvcHBlZCAna2VybmVsIG1vZHVsZScg cmVmZXJlbmNlCj4gLSBVcGRhdGVkIHRoZSBjb21taXQgbWVzc2FnZSBhbmQgZHJvcHBlZCAna2Vy bmVsIG1vZHVsZScgcmVmZXJlbmNlCj4gLSBDaGFuZ2VkIERFQlVHX0FSQ0hfUEdUQUJMRV9URVNU IGludG8gREVCVUdfVk1fUEdUQUJMRSBwZXIgSW5nbwo+IC0gTW92ZWQgY29uZmlnIG9wdGlvbiBm cm9tIG1tL0tjb25maWcuZGVidWcgaW50byBsaWIvS2NvbmZpZy5kZWJ1Zwo+IC0gUmVuYW1lZCBj b3JlIHRlc3QgZnVuY3Rpb24gYXJjaF9wZ3RhYmxlX3Rlc3RzKCkgYXMgZGVidWdfdm1fcGd0YWJs ZSgpCj4gLSBSZW5hbWVkIG1tL2FyY2hfcGd0YWJsZV90ZXN0LmMgYXMgbW0vZGVidWdfdm1fcGd0 YWJsZS5jCj4gLSBkZWJ1Z192bV9wZ3RhYmxlKCkgZ2V0cyBjYWxsZWQgZnJvbSBrZXJuZWxfaW5p dF9mcmVlYWJsZSgpIGFmdGVyIGluaXRfbW1faW50ZXJuYWxzKCkKPiAtIEFkZGVkIGFuIGVudHJ5 IGluIERvY3VtZW50YXRpb24vZmVhdHVyZXMvZGVidWcvIHBlciBJbmdvCj4gLSBFbmFibGVkIHRo ZSB0ZXN0IG9uIGFybTY0IGFuZCB4ODYgcGxhdGZvcm1zIGZvciBub3cKPiAKPiBDaGFuZ2VzIGlu IFY0OiAoaHR0cHM6Ly9wYXRjaHdvcmsua2VybmVsLm9yZy9wcm9qZWN0L2xpbnV4LW1tL2xpc3Qv P3Nlcmllcz0xODM0NjUpCj4gCj4gLSBEaXNhYmxlIERFQlVHX0FSQ0hfUEdUQUJMRV9URVNUIGZv ciBBUk0gYW5kIElBNjQgcGxhdGZvcm1zCj4gCj4gQ2hhbmdlcyBpbiBWMzogKGh0dHBzOi8vbG9y ZS5rZXJuZWwub3JnL3BhdGNod29yay9wcm9qZWN0L2xrbWwvbGlzdC8/c2VyaWVzPTQxMTIxNikK PiAKPiAtIENoYW5nZWQgdGVzdCB0cmlnZ2VyIGZyb20gbW9kdWxlIGZvcm1hdCBpbnRvIGxhdGVf aW5pdGNhbGwoKQo+IC0gTWFya2VkIGFsbCBmdW5jdGlvbnMgd2l0aCBfX2luaXQgdG8gYmUgZnJl ZWQgYWZ0ZXIgY29tcGxldGlvbgo+IC0gQ2hhbmdlZCBhbGwgX19QR1RBQkxFX1BYWF9GT0xERUQg Y2hlY2tzIGFzIG1tX3B4eF9mb2xkZWQoKQo+IC0gRm9sZGVkIGluIFBQQzMyIGZpeGVzIGZyb20g Q2hyaXN0b3BoZQo+IAo+IENoYW5nZXMgaW4gVjI6Cj4gCj4gaHR0cHM6Ly9sb3JlLmtlcm5lbC5v cmcvbGludXgtbW0vMTU2ODI2ODE3My0zMTMwMi0xLWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmto YW5kdWFsQGFybS5jb20vVC8jdAo+IAo+IC0gRml4ZWQgc21hbGwgdHlwbyBlcnJvciBpbiBNT0RV TEVfREVTQ1JJUFRJT04oKQo+IC0gRml4ZWQgbTY0ayBidWlsZCBwcm9ibGVtcyBmb3IgbHZhbHVl IGNvbmNlcm5zIGluIHBtZF94eHhfdGVzdHMoKQo+IC0gRml4ZWQgZHluYW1pYyBwYWdlIHRhYmxl IGxldmVsIGZvbGRpbmcgcHJvYmxlbXMgb24geDg2IGFzIHBlciBLaXJyaWwKPiAtIEZpeGVkIHNl Y29uZCBwb2ludGVycyBkdXJpbmcgcHh4X3BvcHVsYXRlX3Rlc3RzKCkgcGVyIEtpcmlsbCBhbmQg R2VyYWxkCj4gLSBBbGxvY2F0ZSBhbmQgZnJlZSBwdGUgdGFibGUgd2l0aCBwdGVfYWxsb2Nfb25l L3B0ZV9mcmVlIHBlciBLaXJpbGwKPiAtIE1vZGlmaWVkIHB4eF9jbGVhcl90ZXN0cygpIHRvIGFj Y29tbW9kYXRlIHMzOTAgbG93ZXIgMTIgYml0cyBzaXR1YXRpb24KPiAtIENoYW5nZWQgUkFORE9N X05aVkFMVUUgdmFsdWUgZnJvbSAweGJlIHRvIDB4ZmYKPiAtIENoYW5nZWQgYWxsb2NhdGlvbiwg dXNhZ2UsIGZyZWUgc2VxdWVuY2UgZm9yIHNhdmVkX3B0ZXAKPiAtIFJlbmFtZWQgVk1BX0ZMQUdT IGFzIFZNRkxBR1MKPiAtIEltcGxlbWVudGVkIGEgbmV3IG1ldGhvZCBmb3IgcmFuZG9tIHZhZGRy IGdlbmVyYXRpb24KPiAtIEltcGxlbWVudGVkIHNvbWUgb3RoZXIgY2xlYW51cHMKPiAtIERyb3Bw ZWQgZXh0ZXJuIHJlZmVyZW5jZSB0byBtbV9hbGxvYygpCj4gLSBDcmVhdGVkIGFuZCBleHBvcnRl ZCBuZXcgYWxsb2NfZ2lnYW50aWNfcGFnZV9vcmRlcigpCj4gLSBEcm9wcGVkIHRoZSBjdXN0b20g YWxsb2NhdG9yIGFuZCB1c2VkIG5ldyBhbGxvY19naWdhbnRpY19wYWdlX29yZGVyKCkKPiAKPiBD aGFuZ2VzIGluIFYxOgo+IAo+IGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xpbnV4LW1tLzE1Njc0 OTc3MDYtODY0OS0xLWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmtoYW5kdWFsQGFybS5jb20vCj4g Cj4gLSBBZGRlZCBmYWxsYmFjayBtZWNoYW5pc20gZm9yIFBNRCBhbGlnbmVkIG1lbW9yeSBhbGxv Y2F0aW9uIGZhaWx1cmUKPiAKPiBDaGFuZ2VzIGluIFJGQyBWMjoKPiAKPiBodHRwczovL2xvcmUu a2VybmVsLm9yZy9saW51eC1tbS8xNTY1MzM1OTk4LTIyNTUzLTEtZ2l0LXNlbmQtZW1haWwtYW5z aHVtYW4ua2hhbmR1YWxAYXJtLmNvbS9ULyN1Cj4gCj4gLSBNb3ZlZCB0ZXN0IG1vZHVsZSBhbmQg aXQncyBjb25maWcgZnJvbSBsaWIvIHRvIG1tLwo+IC0gUmVuYW1lZCBjb25maWcgVEVTVF9BUkNI X1BHVEFCTEUgYXMgREVCVUdfQVJDSF9QR1RBQkxFX1RFU1QKPiAtIFJlbmFtZWQgZmlsZSBmcm9t IHRlc3RfYXJjaF9wZ3RhYmxlLmMgdG8gYXJjaF9wZ3RhYmxlX3Rlc3QuYwo+IC0gQWRkZWQgcmVs ZXZhbnQgTU9EVUxFX0RFU0NSSVBUSU9OKCkgYW5kIE1PRFVMRV9BVVRIT1IoKSBkZXRhaWxzCj4g LSBEcm9wcGVkIGxvYWRhYmxlIG1vZHVsZSBjb25maWcgb3B0aW9uCj4gLSBCYXNpYyB0ZXN0cyBu b3cgdXNlIG1lbW9yeSBibG9ja3Mgd2l0aCByZXF1aXJlZCBzaXplIGFuZCBhbGlnbm1lbnQKPiAt IFBVRCBhbGlnbmVkIG1lbW9yeSBibG9jayBnZXRzIGFsbG9jYXRlZCB3aXRoIGFsbG9jX2NvbnRp Z19yYW5nZSgpCj4gLSBJZiBQVUQgYWxpZ25lZCBtZW1vcnkgY291bGQgbm90IGJlIGFsbG9jYXRl ZCBpdCBmYWxscyBiYWNrIG9uIFBNRCBhbGlnbmVkCj4gICBtZW1vcnkgYmxvY2sgZnJvbSBwYWdl IGFsbG9jYXRvciBhbmQgcHVkXyogdGVzdHMgYXJlIHNraXBwZWQKPiAtIENsZWFyIGFuZCBwb3B1 bGF0ZSB0ZXN0cyBub3cgb3BlcmF0ZSBvbiByZWFsIGluIG1lbW9yeSBwYWdlIHRhYmxlIGVudHJp ZXMKPiAtIER1bW15IG1tX3N0cnVjdCBnZXRzIGFsbG9jYXRlZCB3aXRoIG1tX2FsbG9jKCkKPiAt IER1bW15IHBhZ2UgdGFibGUgZW50cmllcyBnZXQgYWxsb2NhdGVkIHdpdGggW3B1ZHxwbWR8cHRl XV9hbGxvY19bbWFwXSgpCj4gLSBTaW1wbGlmaWVkIFtwNGR8cGdkXV9iYXNpY190ZXN0cygpLCBu b3cgaGFzIHJhbmRvbSB2YWx1ZXMgaW4gdGhlIGVudHJpZXMKPiAKPiBPcmlnaW5hbCBSRkMgVjE6 Cj4gCj4gaHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvbGludXgtbW0vMTU2NDAzNzcyMy0yNjY3Ni0x LWdpdC1zZW5kLWVtYWlsLWFuc2h1bWFuLmtoYW5kdWFsQGFybS5jb20vCj4gCj4gCj4gIC4uLi9k ZWJ1Zy9kZWJ1Zy12bS1wZ3RhYmxlL2FyY2gtc3VwcG9ydC50eHQgICB8ICAzNSArKwo+ICBhcmNo L2FyYy9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L2FybTY0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3Bvd2VycGMvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3MzOTAvS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3g4Ni9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDEgKwo+ICBhcmNo L3g4Ni9pbmNsdWRlL2FzbS9wZ3RhYmxlXzY0LmggICAgICAgICAgICAgfCAgIDYgKwo+ICBpbmNs dWRlL2xpbnV4L21tZGVidWcuaCAgICAgICAgICAgICAgICAgICAgICAgfCAgIDUgKwo+ICBpbml0 L21haW4uYyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDIgKwo+ICBsaWIv S2NvbmZpZy5kZWJ1ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMjYgKysKPiAgbW0v TWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKPiAgbW0v ZGVidWdfdm1fcGd0YWJsZS5jICAgICAgICAgICAgICAgICAgICAgICAgIHwgMzg5ICsrKysrKysr KysrKysrKysrKwo+ICAxMiBmaWxlcyBjaGFuZ2VkLCA0NjkgaW5zZXJ0aW9ucygrKQo+ICBjcmVh dGUgbW9kZSAxMDA2NDQgRG9jdW1lbnRhdGlvbi9mZWF0dXJlcy9kZWJ1Zy9kZWJ1Zy12bS1wZ3Rh YmxlL2FyY2gtc3VwcG9ydC50eHQKPiAgY3JlYXRlIG1vZGUgMTAwNjQ0IG1tL2RlYnVnX3ZtX3Bn dGFibGUuYwo+IAo+IGRpZmYgLS1naXQgYS9Eb2N1bWVudGF0aW9uL2ZlYXR1cmVzL2RlYnVnL2Rl YnVnLXZtLXBndGFibGUvYXJjaC1zdXBwb3J0LnR4dCBiL0RvY3VtZW50YXRpb24vZmVhdHVyZXMv ZGVidWcvZGVidWctdm0tcGd0YWJsZS9hcmNoLXN1cHBvcnQudHh0Cj4gbmV3IGZpbGUgbW9kZSAx MDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAuLjY0ZDBmOWIxNWM0OQo+IC0tLSAvZGV2L251bGwK PiArKysgYi9Eb2N1bWVudGF0aW9uL2ZlYXR1cmVzL2RlYnVnL2RlYnVnLXZtLXBndGFibGUvYXJj aC1zdXBwb3J0LnR4dAo+IEBAIC0wLDAgKzEsMzUgQEAKPiArIwo+ICsjIEZlYXR1cmUgbmFtZTog ICAgICAgICAgZGVidWctdm0tcGd0YWJsZQo+ICsjICAgICAgICAgS2NvbmZpZzogICAgICAgQVJD SF9IQVNfREVCVUdfVk1fUEdUQUJMRQo+ICsjICAgICAgICAgZGVzY3JpcHRpb246ICAgYXJjaCBz dXBwb3J0cyBwZ3RhYmxlIHRlc3RzIGZvciBzZW1hbnRpY3MgY29tcGxpYW5jZQo+ICsjCj4gKyAg ICAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQo+ICsgICAgfCAgICAgICAgIGFyY2ggfHN0YXR1c3wK PiArICAgIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCj4gKyAgICB8ICAgICAgIGFscGhhOiB8IFRP RE8gfAo+ICsgICAgfCAgICAgICAgIGFyYzogfCAgb2sgIHwKPiArICAgIHwgICAgICAgICBhcm06 IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgIGFybTY0OiB8ICBvayAgfAo+ICsgICAgfCAgICAgICAg IGM2eDogfCBUT0RPIHwKPiArICAgIHwgICAgICAgIGNza3k6IHwgVE9ETyB8Cj4gKyAgICB8ICAg ICAgIGg4MzAwOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgaGV4YWdvbjogfCBUT0RPIHwKPiArICAg IHwgICAgICAgIGlhNjQ6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgICBtNjhrOiB8IFRPRE8gfAo+ ICsgICAgfCAgbWljcm9ibGF6ZTogfCBUT0RPIHwKPiArICAgIHwgICAgICAgIG1pcHM6IHwgVE9E TyB8Cj4gKyAgICB8ICAgICAgIG5kczMyOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgICBuaW9zMjog fCBUT0RPIHwKPiArICAgIHwgICAgb3BlbnJpc2M6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgcGFy aXNjOiB8IFRPRE8gfAo+ICsgICAgfCAgcG93ZXJwYy8zMjogfCAgb2sgIHwKPiArICAgIHwgIHBv d2VycGMvNjQ6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgIHJpc2N2OiB8IFRPRE8gfAo+ICsgICAg fCAgICAgICAgczM5MDogfCAgb2sgIHwKPiArICAgIHwgICAgICAgICAgc2g6IHwgVE9ETyB8Cj4g KyAgICB8ICAgICAgIHNwYXJjOiB8IFRPRE8gfAo+ICsgICAgfCAgICAgICAgICB1bTogfCBUT0RP IHwKPiArICAgIHwgICB1bmljb3JlMzI6IHwgVE9ETyB8Cj4gKyAgICB8ICAgICAgICAgeDg2OiB8 ICBvayAgfAo+ICsgICAgfCAgICAgIHh0ZW5zYTogfCBUT0RPIHwKPiArICAgIC0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJjL0tjb25maWcgYi9hcmNoL2FyYy9L Y29uZmlnCj4gaW5kZXggZmYyYTM5M2I2MzVjLi4zZTcyZTZjZjBlNDIgMTAwNjQ0Cj4gLS0tIGEv YXJjaC9hcmMvS2NvbmZpZwo+ICsrKyBiL2FyY2gvYXJjL0tjb25maWcKPiBAQCAtNiw2ICs2LDcg QEAKPiAgY29uZmlnIEFSQwo+ICAJZGVmX2Jvb2wgeQo+ICAJc2VsZWN0IEFSQ19USU1FUlMKPiAr CXNlbGVjdCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gIAlzZWxlY3QgQVJDSF9IQVNfRE1B X1BSRVBfQ09IRVJFTlQKPiAgCXNlbGVjdCBBUkNIX0hBU19QVEVfU1BFQ0lBTAo+ICAJc2VsZWN0 IEFSQ0hfSEFTX1NFVFVQX0RNQV9PUFMKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9LY29uZmln IGIvYXJjaC9hcm02NC9LY29uZmlnCj4gaW5kZXggMGIzMGU4ODRlMDg4Li5hYWY4YmE0MTUxNDUg MTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02NC9LY29uZmlnCj4gKysrIGIvYXJjaC9hcm02NC9LY29u ZmlnCj4gQEAgLTExLDYgKzExLDcgQEAgY29uZmlnIEFSTTY0Cj4gIAlzZWxlY3QgQUNQSV9QUFRU IGlmIEFDUEkKPiAgCXNlbGVjdCBBUkNIX0NMT0NLU09VUkNFX0RBVEEKPiAgCXNlbGVjdCBBUkNI X0hBU19ERUJVR19WSVJUVUFMCj4gKwlzZWxlY3QgQVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRQo+ ICAJc2VsZWN0IEFSQ0hfSEFTX0RFVk1FTV9JU19BTExPV0VECj4gIAlzZWxlY3QgQVJDSF9IQVNf RE1BX1BSRVBfQ09IRVJFTlQKPiAgCXNlbGVjdCBBUkNIX0hBU19BQ1BJX1RBQkxFX1VQR1JBREUg aWYgQUNQSQo+IGRpZmYgLS1naXQgYS9hcmNoL3Bvd2VycGMvS2NvbmZpZyBiL2FyY2gvcG93ZXJw Yy9LY29uZmlnCj4gaW5kZXggNDk3YjdkMGIyZDdlLi44ZDVhZTE0YzVkNGMgMTAwNjQ0Cj4gLS0t IGEvYXJjaC9wb3dlcnBjL0tjb25maWcKPiArKysgYi9hcmNoL3Bvd2VycGMvS2NvbmZpZwo+IEBA IC0xMTYsNiArMTE2LDcgQEAgY29uZmlnIFBQQwo+ICAJIwo+ICAJc2VsZWN0IEFSQ0hfMzJCSVRf T0ZGX1QgaWYgUFBDMzIKPiAgCXNlbGVjdCBBUkNIX0hBU19ERUJVR19WSVJUVUFMCj4gKwlzZWxl Y3QgQVJDSF9IQVNfREVCVUdfVk1fUEdUQUJMRSBpZiBQUEMzMgo+ICAJc2VsZWN0IEFSQ0hfSEFT X0RFVk1FTV9JU19BTExPV0VECj4gIAlzZWxlY3QgQVJDSF9IQVNfRUxGX1JBTkRPTUlaRQo+ICAJ c2VsZWN0IEFSQ0hfSEFTX0ZPUlRJRllfU09VUkNFCj4gZGlmZiAtLWdpdCBhL2FyY2gvczM5MC9L Y29uZmlnIGIvYXJjaC9zMzkwL0tjb25maWcKPiBpbmRleCA4YWJlNzc1MzZkOWQuLmFmMjg0ZGJi MDdlNyAxMDA2NDQKPiAtLS0gYS9hcmNoL3MzOTAvS2NvbmZpZwo+ICsrKyBiL2FyY2gvczM5MC9L Y29uZmlnCj4gQEAgLTU5LDYgKzU5LDcgQEAgY29uZmlnIEtBU0FOX1NIQURPV19PRkZTRVQKPiAg Y29uZmlnIFMzOTAKPiAgCWRlZl9ib29sIHkKPiAgCXNlbGVjdCBBUkNIX0JJTkZNVF9FTEZfU1RB VEUKPiArCXNlbGVjdCBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gIAlzZWxlY3QgQVJDSF9I QVNfREVWTUVNX0lTX0FMTE9XRUQKPiAgCXNlbGVjdCBBUkNIX0hBU19FTEZfUkFORE9NSVpFCj4g IAlzZWxlY3QgQVJDSF9IQVNfRk9SVElGWV9TT1VSQ0UKPiBkaWZmIC0tZ2l0IGEvYXJjaC94ODYv S2NvbmZpZyBiL2FyY2gveDg2L0tjb25maWcKPiBpbmRleCBiZWVhNzcwNDZmOWIuLmRmOGExOWU1 MmU4MiAxMDA2NDQKPiAtLS0gYS9hcmNoL3g4Ni9LY29uZmlnCj4gKysrIGIvYXJjaC94ODYvS2Nv bmZpZwo+IEBAIC02MSw2ICs2MSw3IEBAIGNvbmZpZyBYODYKPiAgCXNlbGVjdCBBUkNIX0NMT0NL U09VUkNFX0lOSVQKPiAgCXNlbGVjdCBBUkNIX0hBU19BQ1BJX1RBQkxFX1VQR1JBREUJaWYgQUNQ SQo+ICAJc2VsZWN0IEFSQ0hfSEFTX0RFQlVHX1ZJUlRVQUwKPiArCXNlbGVjdCBBUkNIX0hBU19E RUJVR19WTV9QR1RBQkxFCWlmICFYODZfUEFFCj4gIAlzZWxlY3QgQVJDSF9IQVNfREVWTUVNX0lT X0FMTE9XRUQKPiAgCXNlbGVjdCBBUkNIX0hBU19FTEZfUkFORE9NSVpFCj4gIAlzZWxlY3QgQVJD SF9IQVNfRkFTVF9NVUxUSVBMSUVSCj4gZGlmZiAtLWdpdCBhL2FyY2gveDg2L2luY2x1ZGUvYXNt L3BndGFibGVfNjQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVfNjQuaAo+IGluZGV4 IDBiNmM0MDQyOTQyYS4uZmIwZTc2ZDI1NGIzIDEwMDY0NAo+IC0tLSBhL2FyY2gveDg2L2luY2x1 ZGUvYXNtL3BndGFibGVfNjQuaAo+ICsrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3BndGFibGVf NjQuaAo+IEBAIC01Myw2ICs1MywxMiBAQCBzdGF0aWMgaW5saW5lIHZvaWQgc3luY19pbml0aWFs X3BhZ2VfdGFibGUodm9pZCkgeyB9Cj4gIAo+ICBzdHJ1Y3QgbW1fc3RydWN0Owo+ICAKPiArI2Rl ZmluZSBtbV9wNGRfZm9sZGVkIG1tX3A0ZF9mb2xkZWQKPiArc3RhdGljIGlubGluZSBib29sIG1t X3A0ZF9mb2xkZWQoc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArCXJldHVybiAhcGd0YWJs ZV9sNV9lbmFibGVkKCk7Cj4gK30KPiArCj4gIHZvaWQgc2V0X3B0ZV92YWRkcl9wNGQocDRkX3Qg KnA0ZF9wYWdlLCB1bnNpZ25lZCBsb25nIHZhZGRyLCBwdGVfdCBuZXdfcHRlKTsKPiAgdm9pZCBz ZXRfcHRlX3ZhZGRyX3B1ZChwdWRfdCAqcHVkX3BhZ2UsIHVuc2lnbmVkIGxvbmcgdmFkZHIsIHB0 ZV90IG5ld19wdGUpOwo+ICAKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbWRlYnVnLmgg Yi9pbmNsdWRlL2xpbnV4L21tZGVidWcuaAo+IGluZGV4IDJhZDcyZDJjOGNjNS4uNTMzOWFhMTRi NzQ5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW1kZWJ1Zy5oCj4gKysrIGIvaW5jbHVk ZS9saW51eC9tbWRlYnVnLmgKPiBAQCAtNjQsNCArNjQsOSBAQCB2b2lkIGR1bXBfbW0oY29uc3Qg c3RydWN0IG1tX3N0cnVjdCAqbW0pOwo+ICAjZGVmaW5lIFZNX0JVR19PTl9QR0ZMQUdTKGNvbmQs IHBhZ2UpIEJVSUxEX0JVR19PTl9JTlZBTElEKGNvbmQpCj4gICNlbmRpZgo+ICAKPiArI2lmZGVm IENPTkZJR19ERUJVR19WTV9QR1RBQkxFCj4gK3ZvaWQgZGVidWdfdm1fcGd0YWJsZSh2b2lkKTsK PiArI2Vsc2UKPiArc3RhdGljIGlubGluZSB2b2lkIGRlYnVnX3ZtX3BndGFibGUodm9pZCkgeyB9 Cj4gKyNlbmRpZgo+ICAjZW5kaWYKPiBkaWZmIC0tZ2l0IGEvaW5pdC9tYWluLmMgYi9pbml0L21h aW4uYwo+IGluZGV4IGNjMGVlNDg3MzQxOS4uYWRmMzdlOGIxZDY5IDEwMDY0NAo+IC0tLSBhL2lu aXQvbWFpbi5jCj4gKysrIGIvaW5pdC9tYWluLmMKPiBAQCAtOTQsNiArOTQsNyBAQAo+ICAjaW5j bHVkZSA8bGludXgvcm9kYXRhX3Rlc3QuaD4KPiAgI2luY2x1ZGUgPGxpbnV4L2p1bXBfbGFiZWwu aD4KPiAgI2luY2x1ZGUgPGxpbnV4L21lbV9lbmNyeXB0Lmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9t bWRlYnVnLmg+Cj4gIAo+ICAjaW5jbHVkZSA8YXNtL2lvLmg+Cj4gICNpbmNsdWRlIDxhc20vYnVn cy5oPgo+IEBAIC0xMzIzLDYgKzEzMjQsNyBAQCBzdGF0aWMgaW50IF9fcmVmIGtlcm5lbF9pbml0 KHZvaWQgKnVudXNlZCkKPiAgCWtlcm5lbF9pbml0X2ZyZWVhYmxlKCk7Cj4gIAkvKiBuZWVkIHRv IGZpbmlzaCBhbGwgYXN5bmMgX19pbml0IGNvZGUgYmVmb3JlIGZyZWVpbmcgdGhlIG1lbW9yeSAq Lwo+ICAJYXN5bmNfc3luY2hyb25pemVfZnVsbCgpOwo+ICsJZGVidWdfdm1fcGd0YWJsZSgpOwo+ ICAJZnRyYWNlX2ZyZWVfaW5pdF9tZW0oKTsKPiAgCWZyZWVfaW5pdG1lbSgpOwo+ICAJbWFya19y ZWFkb25seSgpOwo+IGRpZmYgLS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmln LmRlYnVnCj4gaW5kZXggNjlkZWY0YTlkZjAwLi4xYjViZDlmN2M5NjcgMTAwNjQ0Cj4gLS0tIGEv bGliL0tjb25maWcuZGVidWcKPiArKysgYi9saWIvS2NvbmZpZy5kZWJ1Zwo+IEBAIC02NTMsNiAr NjUzLDEyIEBAIGNvbmZpZyBTQ0hFRF9TVEFDS19FTkRfQ0hFQ0sKPiAgCSAgZGF0YSBjb3JydXB0 aW9uIG9yIGEgc3BvcmFkaWMgY3Jhc2ggYXQgYSBsYXRlciBzdGFnZSBvbmNlIHRoZSByZWdpb24K PiAgCSAgaXMgZXhhbWluZWQuIFRoZSBydW50aW1lIG92ZXJoZWFkIGludHJvZHVjZWQgaXMgbWlu aW1hbC4KPiAgCj4gK2NvbmZpZyBBUkNIX0hBU19ERUJVR19WTV9QR1RBQkxFCj4gKwlib29sCj4g KwloZWxwCj4gKwkgIEFuIGFyY2hpdGVjdHVyZSBzaG91bGQgc2VsZWN0IHRoaXMgd2hlbiBpdCBj YW4gc3VjY2Vzc2Z1bGx5Cj4gKwkgIGJ1aWxkIGFuZCBydW4gREVCVUdfVk1fUEdUQUJMRS4KPiAr Cj4gIGNvbmZpZyBERUJVR19WTQo+ICAJYm9vbCAiRGVidWcgVk0iCj4gIAlkZXBlbmRzIG9uIERF QlVHX0tFUk5FTAo+IEBAIC02ODgsNiArNjk0LDI2IEBAIGNvbmZpZyBERUJVR19WTV9QR0ZMQUdT Cj4gIAo+ICAJICBJZiB1bnN1cmUsIHNheSBOLgo+ICAKPiArY29uZmlnIERFQlVHX1ZNX1BHVEFC TEUKPiArCWJvb2wgIkRlYnVnIGFyY2ggcGFnZSB0YWJsZSBmb3Igc2VtYW50aWNzIGNvbXBsaWFu Y2UiCj4gKwlkZXBlbmRzIG9uIE1NVQo+ICsJZGVwZW5kcyBvbiAhSUE2NCAmJiAhQVJNCj4gKwlk ZXBlbmRzIG9uIEFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUgfHwgRVhQRVJUCj4gKwlkZWZhdWx0 IG4gaWYgIUFSQ0hfSEFTX0RFQlVHX1ZNX1BHVEFCTEUKPiArCWRlZmF1bHQgeSBpZiBERUJVR19W TQo+ICsJaGVscAo+ICsJICBUaGlzIG9wdGlvbiBwcm92aWRlcyBhIGRlYnVnIG1ldGhvZCB3aGlj aCBjYW4gYmUgdXNlZCB0byB0ZXN0Cj4gKwkgIGFyY2hpdGVjdHVyZSBwYWdlIHRhYmxlIGhlbHBl ciBmdW5jdGlvbnMgb24gdmFyaW91cyBwbGF0Zm9ybXMgaW4KPiArCSAgdmVyaWZ5aW5nIGlmIHRo ZXkgY29tcGx5IHdpdGggZXhwZWN0ZWQgZ2VuZXJpYyBNTSBzZW1hbnRpY3MuIFRoaXMKPiArCSAg d2lsbCBoZWxwIGFyY2hpdGVjdHVyZSBjb2RlIGluIG1ha2luZyBzdXJlIHRoYXQgYW55IGNoYW5n ZXMgb3IKPiArCSAgbmV3IGFkZGl0aW9ucyBvZiB0aGVzZSBoZWxwZXJzIHN0aWxsIGNvbmZvcm0g dG8gZXhwZWN0ZWQKPiArCSAgc2VtYW50aWNzIG9mIHRoZSBnZW5lcmljIE1NLiBQbGF0Zm9ybXMg d2lsbCBoYXZlIHRvIG9wdCBpbiBmb3IKPiArCSAgdGhpcyB0aHJvdWdoIEFSQ0hfSEFTX0RFQlVH X1ZNX1BHVEFCTEUuIEFsdGhvdWdoIGl0IGNhbiBhbHNvIGJlCj4gKwkgIGVuYWJsZWQgdGhyb3Vn aCBFWFBFUlQgd2l0aG91dCByZXF1aXJpbmcgY29kZSBjaGFuZ2UuIFRoaXMgdGVzdAo+ICsJICBp cyBkaXNhYmxlZCBvbiBJQTY0IGFuZCBBUk0gcGxhdGZvcm1zIHdoZXJlIGl0IGZhaWxzIHRvIGJ1 aWxkLgo+ICsKPiArCSAgSWYgdW5zdXJlLCBzYXkgTi4KPiArCj4gIGNvbmZpZyBBUkNIX0hBU19E RUJVR19WSVJUVUFMCj4gIAlib29sCj4gIAo+IGRpZmYgLS1naXQgYS9tbS9NYWtlZmlsZSBiL21t L01ha2VmaWxlCj4gaW5kZXggMjcyZTY2MDM5ZTcwLi5iMDY5MmU2YTRiNTggMTAwNjQ0Cj4gLS0t IGEvbW0vTWFrZWZpbGUKPiArKysgYi9tbS9NYWtlZmlsZQo+IEBAIC04Nyw2ICs4Nyw3IEBAIG9i ai0kKENPTkZJR19IV1BPSVNPTl9JTkpFQ1QpICs9IGh3cG9pc29uLWluamVjdC5vCj4gIG9iai0k KENPTkZJR19ERUJVR19LTUVNTEVBSykgKz0ga21lbWxlYWsubwo+ICBvYmotJChDT05GSUdfREVC VUdfS01FTUxFQUtfVEVTVCkgKz0ga21lbWxlYWstdGVzdC5vCj4gIG9iai0kKENPTkZJR19ERUJV R19ST0RBVEFfVEVTVCkgKz0gcm9kYXRhX3Rlc3Qubwo+ICtvYmotJChDT05GSUdfREVCVUdfVk1f UEdUQUJMRSkgKz0gZGVidWdfdm1fcGd0YWJsZS5vCj4gIG9iai0kKENPTkZJR19QQUdFX09XTkVS KSArPSBwYWdlX293bmVyLm8KPiAgb2JqLSQoQ09ORklHX0NMRUFOQ0FDSEUpICs9IGNsZWFuY2Fj aGUubwo+ICBvYmotJChDT05GSUdfTUVNT1JZX0lTT0xBVElPTikgKz0gcGFnZV9pc29sYXRpb24u bwo+IGRpZmYgLS1naXQgYS9tbS9kZWJ1Z192bV9wZ3RhYmxlLmMgYi9tbS9kZWJ1Z192bV9wZ3Rh YmxlLmMKPiBuZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMC4uNzBiZjhl ZDhmZDUxCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBiL21tL2RlYnVnX3ZtX3BndGFibGUuYwo+IEBA IC0wLDAgKzEsMzg5IEBACj4gKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wLW9u bHkKPiArLyoKPiArICogVGhpcyBrZXJuZWwgdGVzdCB2YWxpZGF0ZXMgYXJjaGl0ZWN0dXJlIHBh Z2UgdGFibGUgaGVscGVycyBhbmQKPiArICogYWNjZXNzb3JzIGFuZCBoZWxwcyBpbiB2ZXJpZnlp bmcgdGhlaXIgY29udGludWVkIGNvbXBsaWFuY2Ugd2l0aAo+ICsgKiBleHBlY3RlZCBnZW5lcmlj IE1NIHNlbWFudGljcy4KPiArICoKPiArICogQ29weXJpZ2h0IChDKSAyMDE5IEFSTSBMdGQuCj4g KyAqCj4gKyAqIEF1dGhvcjogQW5zaHVtYW4gS2hhbmR1YWwgPGFuc2h1bWFuLmtoYW5kdWFsQGFy bS5jb20+Cj4gKyAqLwo+ICsjZGVmaW5lIHByX2ZtdChmbXQpICJkZWJ1Z192bV9wZ3RhYmxlOiAl czogIiBmbXQsIF9fZnVuY19fCj4gKwo+ICsjaW5jbHVkZSA8bGludXgvZ2ZwLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9oaWdobWVtLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9odWdldGxiLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L2tjb25maWcuaD4KPiAr I2luY2x1ZGUgPGxpbnV4L21tLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9tbWFuLmg+Cj4gKyNpbmNs dWRlIDxsaW51eC9tbV90eXBlcy5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9wZm5fdC5oPgo+ICsjaW5jbHVkZSA8bGludXgvcHJpbnRrLmg+Cj4gKyNp bmNsdWRlIDxsaW51eC9yYW5kb20uaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zd2FwLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9zd2Fwb3BzLmg+Cj4g KyNpbmNsdWRlIDxsaW51eC9zdGFydF9rZXJuZWwuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3NjaGVk L21tLmg+Cj4gKyNpbmNsdWRlIDxhc20vcGdhbGxvYy5oPgo+ICsjaW5jbHVkZSA8YXNtL3BndGFi bGUuaD4KPiArCj4gKy8qCj4gKyAqIEJhc2ljIG9wZXJhdGlvbnMKPiArICoKPiArICogbWtvbGQo ZW50cnkpCQkJPSBBbiBvbGQgYW5kIG5vdCBhIHlvdW5nIGVudHJ5Cj4gKyAqIG1reW91bmcoZW50 cnkpCQk9IEEgeW91bmcgYW5kIG5vdCBhbiBvbGQgZW50cnkKPiArICogbWtkaXJ0eShlbnRyeSkJ CT0gQSBkaXJ0eSBhbmQgbm90IGEgY2xlYW4gZW50cnkKPiArICogbWtjbGVhbihlbnRyeSkJCT0g QSBjbGVhbiBhbmQgbm90IGEgZGlydHkgZW50cnkKPiArICogbWt3cml0ZShlbnRyeSkJCT0gQSB3 cml0ZSBhbmQgbm90IGEgd3JpdGUgcHJvdGVjdGVkIGVudHJ5Cj4gKyAqIHdycHJvdGVjdChlbnRy eSkJCT0gQSB3cml0ZSBwcm90ZWN0ZWQgYW5kIG5vdCBhIHdyaXRlIGVudHJ5Cj4gKyAqIHB4eF9i YWQoZW50cnkpCQk9IEEgbWFwcGVkIGFuZCBub24tdGFibGUgZW50cnkKPiArICogcHh4X3NhbWUo ZW50cnkxLCBlbnRyeTIpCT0gQm90aCBlbnRyaWVzIGhvbGQgdGhlIGV4YWN0IHNhbWUgdmFsdWUK PiArICovCj4gKyNkZWZpbmUgVk1GTEFHUwkoVk1fUkVBRHxWTV9XUklURXxWTV9FWEVDKQo+ICsK PiArLyoKPiArICogT24gczM5MCBwbGF0Zm9ybSwgdGhlIGxvd2VyIDQgYml0cyBhcmUgdXNlZCB0 byBpZGVudGlmeSBnaXZlbiBwYWdlIHRhYmxlCj4gKyAqIGVudHJ5IHR5cGUuIEJ1dCB0aGVzZSBi aXRzIG1pZ2h0IGFmZmVjdCB0aGUgYWJpbGl0eSB0byBjbGVhciBlbnRyaWVzIHdpdGgKPiArICog cHh4X2NsZWFyKCkgYmVjYXVzZSBvZiBob3cgZHluYW1pYyBwYWdlIHRhYmxlIGZvbGRpbmcgd29y a3Mgb24gczM5MC4gU28KPiArICogd2hpbGUgbG9hZGluZyB1cCB0aGUgZW50cmllcyBkbyBub3Qg Y2hhbmdlIHRoZSBsb3dlciA0IGJpdHMuIEl0IGRvZXMgbm90Cj4gKyAqIGhhdmUgYWZmZWN0IGFu eSBvdGhlciBwbGF0Zm9ybS4KPiArICovCj4gKyNkZWZpbmUgUzM5MF9NQVNLX0JJVFMJNAo+ICsj ZGVmaW5lIFJBTkRPTV9PUlZBTFVFCUdFTk1BU0soQklUU19QRVJfTE9ORyAtIDEsIFMzOTBfTUFT S19CSVRTKQo+ICsjZGVmaW5lIFJBTkRPTV9OWlZBTFVFCUdFTk1BU0soNywgMCkKPiArCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwdGVfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpCj4gK3sKPiArCXB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPiArCj4g KwlXQVJOX09OKCFwdGVfc2FtZShwdGUsIHB0ZSkpOwo+ICsJV0FSTl9PTighcHRlX3lvdW5nKHB0 ZV9ta3lvdW5nKHB0ZV9ta29sZChwdGUpKSkpOwo+ICsJV0FSTl9PTighcHRlX2RpcnR5KHB0ZV9t a2RpcnR5KHB0ZV9ta2NsZWFuKHB0ZSkpKSk7Cj4gKwlXQVJOX09OKCFwdGVfd3JpdGUocHRlX21r d3JpdGUocHRlX3dycHJvdGVjdChwdGUpKSkpOwo+ICsJV0FSTl9PTihwdGVfeW91bmcocHRlX21r b2xkKHB0ZV9ta3lvdW5nKHB0ZSkpKSk7Cj4gKwlXQVJOX09OKHB0ZV9kaXJ0eShwdGVfbWtjbGVh bihwdGVfbWtkaXJ0eShwdGUpKSkpOwo+ICsJV0FSTl9PTihwdGVfd3JpdGUocHRlX3dycHJvdGVj dChwdGVfbWt3cml0ZShwdGUpKSkpOwo+ICt9Cj4gKwo+ICsjaWZkZWYgQ09ORklHX1RSQU5TUEFS RU5UX0hVR0VQQUdFCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfYmFzaWNfdGVzdHModW5zaWdu ZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4gK3sKPiArCXBtZF90IHBtZCA9IHBmbl9wbWQo cGZuLCBwcm90KTsKPiArCj4gKwlXQVJOX09OKCFwbWRfc2FtZShwbWQsIHBtZCkpOwo+ICsJV0FS Tl9PTighcG1kX3lvdW5nKHBtZF9ta3lvdW5nKHBtZF9ta29sZChwbWQpKSkpOwo+ICsJV0FSTl9P TighcG1kX2RpcnR5KHBtZF9ta2RpcnR5KHBtZF9ta2NsZWFuKHBtZCkpKSk7Cj4gKwlXQVJOX09O KCFwbWRfd3JpdGUocG1kX21rd3JpdGUocG1kX3dycHJvdGVjdChwbWQpKSkpOwo+ICsJV0FSTl9P TihwbWRfeW91bmcocG1kX21rb2xkKHBtZF9ta3lvdW5nKHBtZCkpKSk7Cj4gKwlXQVJOX09OKHBt ZF9kaXJ0eShwbWRfbWtjbGVhbihwbWRfbWtkaXJ0eShwbWQpKSkpOwo+ICsJV0FSTl9PTihwbWRf d3JpdGUocG1kX3dycHJvdGVjdChwbWRfbWt3cml0ZShwbWQpKSkpOwo+ICsJLyoKPiArCSAqIEEg aHVnZSBwYWdlIGRvZXMgbm90IHBvaW50IHRvIG5leHQgbGV2ZWwgcGFnZSB0YWJsZQo+ICsJICog ZW50cnkuIEhlbmNlIHRoaXMgbXVzdCBxdWFsaWZ5IGFzIHBtZF9iYWQoKS4KPiArCSAqLwo+ICsJ V0FSTl9PTighcG1kX2JhZChwbWRfbWtodWdlKHBtZCkpKTsKPiArfQo+ICsKPiArI2lmZGVmIENP TkZJR19IQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwdWRfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4g K3sKPiArCXB1ZF90IHB1ZCA9IHBmbl9wdWQocGZuLCBwcm90KTsKPiArCj4gKwlXQVJOX09OKCFw dWRfc2FtZShwdWQsIHB1ZCkpOwo+ICsJV0FSTl9PTighcHVkX3lvdW5nKHB1ZF9ta3lvdW5nKHB1 ZF9ta29sZChwdWQpKSkpOwo+ICsJV0FSTl9PTighcHVkX3dyaXRlKHB1ZF9ta3dyaXRlKHB1ZF93 cnByb3RlY3QocHVkKSkpKTsKPiArCVdBUk5fT04ocHVkX3dyaXRlKHB1ZF93cnByb3RlY3QocHVk X21rd3JpdGUocHVkKSkpKTsKPiArCVdBUk5fT04ocHVkX3lvdW5nKHB1ZF9ta29sZChwdWRfbWt5 b3VuZyhwdWQpKSkpOwo+ICsKPiArCWlmIChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47 Cj4gKwo+ICsJLyoKPiArCSAqIEEgaHVnZSBwYWdlIGRvZXMgbm90IHBvaW50IHRvIG5leHQgbGV2 ZWwgcGFnZSB0YWJsZQo+ICsJICogZW50cnkuIEhlbmNlIHRoaXMgbXVzdCBxdWFsaWZ5IGFzIHB1 ZF9iYWQoKS4KPiArCSAqLwo+ICsJV0FSTl9PTighcHVkX2JhZChwdWRfbWtodWdlKHB1ZCkpKTsK PiArfQo+ICsjZWxzZQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2Jhc2ljX3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPiArI2VuZGlmCj4gKyNlbHNlCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwbWRfYmFzaWNfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpIHsgfQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2Jhc2ljX3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPiArI2VuZGlmCj4gKwo+ICtzdGF0aWMg dm9pZCBfX2luaXQgcDRkX2Jhc2ljX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KQo+ICt7Cj4gKwlwNGRfdCBwNGQ7Cj4gKwo+ICsJbWVtc2V0KCZwNGQsIFJBTkRPTV9OWlZB TFVFLCBzaXplb2YocDRkX3QpKTsKPiArCVdBUk5fT04oIXA0ZF9zYW1lKHA0ZCwgcDRkKSk7Cj4g K30KPiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwZ2RfYmFzaWNfdGVzdHModW5zaWduZWQgbG9u ZyBwZm4sIHBncHJvdF90IHByb3QpCj4gK3sKPiArCXBnZF90IHBnZDsKPiArCj4gKwltZW1zZXQo JnBnZCwgUkFORE9NX05aVkFMVUUsIHNpemVvZihwZ2RfdCkpOwo+ICsJV0FSTl9PTighcGdkX3Nh bWUocGdkLCBwZ2QpKTsKPiArfQo+ICsKPiArI2lmbmRlZiBfX1BBR0VUQUJMRV9QVURfRk9MREVE Cj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdWRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAq bW0sIHB1ZF90ICpwdWRwKQo+ICt7Cj4gKwlwdWRfdCBwdWQgPSBSRUFEX09OQ0UoKnB1ZHApOwo+ ICsKPiArCWlmIChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47Cj4gKwo+ICsJcHVkID0g X19wdWQocHVkX3ZhbChwdWQpIHwgUkFORE9NX09SVkFMVUUpOwo+ICsJV1JJVEVfT05DRSgqcHVk cCwgcHVkKTsKPiArCXB1ZF9jbGVhcihwdWRwKTsKPiArCXB1ZCA9IFJFQURfT05DRSgqcHVkcCk7 Cj4gKwlXQVJOX09OKCFwdWRfbm9uZShwdWQpKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgX19p bml0IHB1ZF9wb3B1bGF0ZV90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcHVkX3QgKnB1ZHAs Cj4gKwkJCQkgICAgICBwbWRfdCAqcG1kcCkKPiArewo+ICsJcHVkX3QgcHVkOwo+ICsKPiArCWlm IChtbV9wbWRfZm9sZGVkKG1tKSkKPiArCQlyZXR1cm47Cj4gKwkvKgo+ICsJICogVGhpcyBlbnRy eSBwb2ludHMgdG8gbmV4dCBsZXZlbCBwYWdlIHRhYmxlIHBhZ2UuCj4gKwkgKiBIZW5jZSB0aGlz IG11c3Qgbm90IHF1YWxpZnkgYXMgcHVkX2JhZCgpLgo+ICsJICovCj4gKwlwbWRfY2xlYXIocG1k cCk7Cj4gKwlwdWRfY2xlYXIocHVkcCk7Cj4gKwlwdWRfcG9wdWxhdGUobW0sIHB1ZHAsIHBtZHAp Owo+ICsJcHVkID0gUkVBRF9PTkNFKCpwdWRwKTsKPiArCVdBUk5fT04ocHVkX2JhZChwdWQpKTsK PiArfQo+ICsjZWxzZQo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX2NsZWFyX3Rlc3RzKHN0cnVj dCBtbV9zdHJ1Y3QgKm1tLCBwdWRfdCAqcHVkcCkgeyB9Cj4gK3N0YXRpYyB2b2lkIF9faW5pdCBw dWRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHB1ZF90ICpwdWRwLAo+ICsJ CQkJICAgICAgcG1kX3QgKnBtZHApCj4gK3sKPiArfQo+ICsjZW5kaWYKPiArCj4gKyNpZm5kZWYg X19QQUdFVEFCTEVfUDREX0ZPTERFRAo+ICtzdGF0aWMgdm9pZCBfX2luaXQgcDRkX2NsZWFyX3Rl c3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwNGRfdCAqcDRkcCkKPiArewo+ICsJcDRkX3QgcDRk ID0gUkVBRF9PTkNFKCpwNGRwKTsKPiArCj4gKwlpZiAobW1fcHVkX2ZvbGRlZChtbSkpCj4gKwkJ cmV0dXJuOwo+ICsKPiArCXA0ZCA9IF9fcDRkKHA0ZF92YWwocDRkKSB8IFJBTkRPTV9PUlZBTFVF KTsKPiArCVdSSVRFX09OQ0UoKnA0ZHAsIHA0ZCk7Cj4gKwlwNGRfY2xlYXIocDRkcCk7Cj4gKwlw NGQgPSBSRUFEX09OQ0UoKnA0ZHApOwo+ICsJV0FSTl9PTighcDRkX25vbmUocDRkKSk7Cj4gK30K PiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwNGRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0 cnVjdCAqbW0sIHA0ZF90ICpwNGRwLAo+ICsJCQkJICAgICAgcHVkX3QgKnB1ZHApCj4gK3sKPiAr CXA0ZF90IHA0ZDsKPiArCj4gKwlpZiAobW1fcHVkX2ZvbGRlZChtbSkpCj4gKwkJcmV0dXJuOwo+ ICsKPiArCS8qCj4gKwkgKiBUaGlzIGVudHJ5IHBvaW50cyB0byBuZXh0IGxldmVsIHBhZ2UgdGFi bGUgcGFnZS4KPiArCSAqIEhlbmNlIHRoaXMgbXVzdCBub3QgcXVhbGlmeSBhcyBwNGRfYmFkKCku Cj4gKwkgKi8KPiArCXB1ZF9jbGVhcihwdWRwKTsKPiArCXA0ZF9jbGVhcihwNGRwKTsKPiArCXA0 ZF9wb3B1bGF0ZShtbSwgcDRkcCwgcHVkcCk7Cj4gKwlwNGQgPSBSRUFEX09OQ0UoKnA0ZHApOwo+ ICsJV0FSTl9PTihwNGRfYmFkKHA0ZCkpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBfX2luaXQg cGdkX2NsZWFyX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwZ2RfdCAqcGdkcCkKPiArewo+ ICsJcGdkX3QgcGdkID0gUkVBRF9PTkNFKCpwZ2RwKTsKPiArCj4gKwlpZiAobW1fcDRkX2ZvbGRl ZChtbSkpCj4gKwkJcmV0dXJuOwo+ICsKPiArCXBnZCA9IF9fcGdkKHBnZF92YWwocGdkKSB8IFJB TkRPTV9PUlZBTFVFKTsKPiArCVdSSVRFX09OQ0UoKnBnZHAsIHBnZCk7Cj4gKwlwZ2RfY2xlYXIo cGdkcCk7Cj4gKwlwZ2QgPSBSRUFEX09OQ0UoKnBnZHApOwo+ICsJV0FSTl9PTighcGdkX25vbmUo cGdkKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwZ2RfcG9wdWxhdGVfdGVzdHMo c3RydWN0IG1tX3N0cnVjdCAqbW0sIHBnZF90ICpwZ2RwLAo+ICsJCQkJICAgICAgcDRkX3QgKnA0 ZHApCj4gK3sKPiArCXBnZF90IHBnZDsKPiArCj4gKwlpZiAobW1fcDRkX2ZvbGRlZChtbSkpCj4g KwkJcmV0dXJuOwo+ICsKPiArCS8qCj4gKwkgKiBUaGlzIGVudHJ5IHBvaW50cyB0byBuZXh0IGxl dmVsIHBhZ2UgdGFibGUgcGFnZS4KPiArCSAqIEhlbmNlIHRoaXMgbXVzdCBub3QgcXVhbGlmeSBh cyBwZ2RfYmFkKCkuCj4gKwkgKi8KPiArCXA0ZF9jbGVhcihwNGRwKTsKPiArCXBnZF9jbGVhcihw Z2RwKTsKPiArCXBnZF9wb3B1bGF0ZShtbSwgcGdkcCwgcDRkcCk7Cj4gKwlwZ2QgPSBSRUFEX09O Q0UoKnBnZHApOwo+ICsJV0FSTl9PTihwZ2RfYmFkKHBnZCkpOwo+ICt9Cj4gKyNlbHNlCj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwNGRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHA0 ZF90ICpwNGRwKSB7IH0KPiArc3RhdGljIHZvaWQgX19pbml0IHBnZF9jbGVhcl90ZXN0cyhzdHJ1 Y3QgbW1fc3RydWN0ICptbSwgcGdkX3QgKnBnZHApIHsgfQo+ICtzdGF0aWMgdm9pZCBfX2luaXQg cDRkX3BvcHVsYXRlX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwNGRfdCAqcDRkcCwKPiAr CQkJCSAgICAgIHB1ZF90ICpwdWRwKQo+ICt7Cj4gK30KPiArc3RhdGljIHZvaWQgX19pbml0IHBn ZF9wb3B1bGF0ZV90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcGdkX3QgKnBnZHAsCj4gKwkJ CQkgICAgICBwNGRfdCAqcDRkcCkKPiArewo+ICt9Cj4gKyNlbmRpZgo+ICsKPiArc3RhdGljIHZv aWQgX19pbml0IHB0ZV9jbGVhcl90ZXN0cyhzdHJ1Y3QgbW1fc3RydWN0ICptbSwgcHRlX3QgKnB0 ZXApCj4gK3sKPiArCXB0ZV90IHB0ZSA9IFJFQURfT05DRSgqcHRlcCk7Cj4gKwo+ICsJcHRlID0g X19wdGUocHRlX3ZhbChwdGUpIHwgUkFORE9NX09SVkFMVUUpOwo+ICsJV1JJVEVfT05DRSgqcHRl cCwgcHRlKTsKPiArCXB0ZV9jbGVhcihtbSwgMCwgcHRlcCk7Cj4gKwlwdGUgPSBSRUFEX09OQ0Uo KnB0ZXApOwo+ICsJV0FSTl9PTighcHRlX25vbmUocHRlKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2 b2lkIF9faW5pdCBwbWRfY2xlYXJfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpw bWRwKQo+ICt7Cj4gKwlwbWRfdCBwbWQgPSBSRUFEX09OQ0UoKnBtZHApOwo+ICsKPiArCXBtZCA9 IF9fcG1kKHBtZF92YWwocG1kKSB8IFJBTkRPTV9PUlZBTFVFKTsKPiArCVdSSVRFX09OQ0UoKnBt ZHAsIHBtZCk7Cj4gKwlwbWRfY2xlYXIocG1kcCk7Cj4gKwlwbWQgPSBSRUFEX09OQ0UoKnBtZHAp Owo+ICsJV0FSTl9PTighcG1kX25vbmUocG1kKSk7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwbWRfcG9wdWxhdGVfdGVzdHMoc3RydWN0IG1tX3N0cnVjdCAqbW0sIHBtZF90ICpwbWRw LAo+ICsJCQkJICAgICAgcGd0YWJsZV90IHBndGFibGUpCj4gK3sKPiArCXBtZF90IHBtZDsKPiAr Cj4gKwkvKgo+ICsJICogVGhpcyBlbnRyeSBwb2ludHMgdG8gbmV4dCBsZXZlbCBwYWdlIHRhYmxl IHBhZ2UuCj4gKwkgKiBIZW5jZSB0aGlzIG11c3Qgbm90IHF1YWxpZnkgYXMgcG1kX2JhZCgpLgo+ ICsJICovCj4gKwlwbWRfY2xlYXIocG1kcCk7Cj4gKwlwbWRfcG9wdWxhdGUobW0sIHBtZHAsIHBn dGFibGUpOwo+ICsJcG1kID0gUkVBRF9PTkNFKCpwbWRwKTsKPiArCVdBUk5fT04ocG1kX2JhZChw bWQpKTsKPiArfQo+ICsKPiArc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0IGdldF9yYW5kb21f dmFkZHIodm9pZCkKPiArewo+ICsJdW5zaWduZWQgbG9uZyByYW5kb21fdmFkZHIsIHJhbmRvbV9w YWdlcywgdG90YWxfdXNlcl9wYWdlczsKPiArCj4gKwl0b3RhbF91c2VyX3BhZ2VzID0gKFRBU0tf U0laRSAtIEZJUlNUX1VTRVJfQUREUkVTUykgLyBQQUdFX1NJWkU7Cj4gKwo+ICsJcmFuZG9tX3Bh Z2VzID0gZ2V0X3JhbmRvbV9sb25nKCkgJSB0b3RhbF91c2VyX3BhZ2VzOwo+ICsJcmFuZG9tX3Zh ZGRyID0gRklSU1RfVVNFUl9BRERSRVNTICsgcmFuZG9tX3BhZ2VzICogUEFHRV9TSVpFOwo+ICsK PiArCXJldHVybiByYW5kb21fdmFkZHI7Cj4gK30KPiArCj4gK3ZvaWQgX19pbml0IGRlYnVnX3Zt X3BndGFibGUodm9pZCkKPiArewo+ICsJc3RydWN0IG1tX3N0cnVjdCAqbW07Cj4gKwlwZ2RfdCAq cGdkcDsKPiArCXA0ZF90ICpwNGRwLCAqc2F2ZWRfcDRkcDsKPiArCXB1ZF90ICpwdWRwLCAqc2F2 ZWRfcHVkcDsKPiArCXBtZF90ICpwbWRwLCAqc2F2ZWRfcG1kcCwgcG1kOwo+ICsJcHRlX3QgKnB0 ZXA7Cj4gKwlwZ3RhYmxlX3Qgc2F2ZWRfcHRlcDsKPiArCXBncHJvdF90IHByb3Q7Cj4gKwlwaHlz X2FkZHJfdCBwYWRkcjsKPiArCXVuc2lnbmVkIGxvbmcgdmFkZHIsIHB0ZV9hbGlnbmVkLCBwbWRf YWxpZ25lZDsKPiArCXVuc2lnbmVkIGxvbmcgcHVkX2FsaWduZWQsIHA0ZF9hbGlnbmVkLCBwZ2Rf YWxpZ25lZDsKPiArCj4gKwlwcl9pbmZvKCJWYWxpZGF0aW5nIGFyY2hpdGVjdHVyZSBwYWdlIHRh YmxlIGhlbHBlcnNcbiIpOwo+ICsJcHJvdCA9IHZtX2dldF9wYWdlX3Byb3QoVk1GTEFHUyk7Cj4g Kwl2YWRkciA9IGdldF9yYW5kb21fdmFkZHIoKTsKPiArCW1tID0gbW1fYWxsb2MoKTsKPiArCWlm ICghbW0pIHsKPiArCQlwcl9lcnIoIm1tX3N0cnVjdCBhbGxvY2F0aW9uIGZhaWxlZFxuIik7Cj4g KwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCS8qCj4gKwkgKiBQRk4gZm9yIG1hcHBpbmcgYXQgUFRF IGxldmVsIGlzIGRldGVybWluZWQgZnJvbSBhIHN0YW5kYXJkIGtlcm5lbAo+ICsJICogdGV4dCBz eW1ib2wuIEJ1dCBwZm5zIGZvciBoaWdoZXIgcGFnZSB0YWJsZSBsZXZlbHMgYXJlIGRlcml2ZWQg YnkKPiArCSAqIG1hc2tpbmcgbG93ZXIgYml0cyBvZiB0aGlzIHJlYWwgcGZuLiBUaGVzZSBkZXJp dmVkIHBmbnMgbWlnaHQgbm90Cj4gKwkgKiBleGlzdCBvbiB0aGUgcGxhdGZvcm0gYnV0IHRoYXQg ZG9lcyBub3QgcmVhbGx5IG1hdHRlciBhcyBwZm5fcHh4KCkKPiArCSAqIGhlbHBlcnMgd2lsbCBz dGlsbCBjcmVhdGUgYXBwcm9wcmlhdGUgZW50cmllcyBmb3IgdGhlIHRlc3QuIFRoaXMKPiArCSAq IGhlbHBzIGF2b2lkIGxhcmdlIG1lbW9yeSBibG9jayBhbGxvY2F0aW9ucyB0byBiZSB1c2VkIGZv ciBtYXBwaW5nCj4gKwkgKiBhdCBoaWdoZXIgcGFnZSB0YWJsZSBsZXZlbHMuCj4gKwkgKi8KPiAr CXBhZGRyID0gX19wYSgmc3RhcnRfa2VybmVsKTsKPiArCj4gKwlwdGVfYWxpZ25lZCA9IChwYWRk ciAmIFBBR0VfTUFTSykgPj4gUEFHRV9TSElGVDsKPiArCXBtZF9hbGlnbmVkID0gKHBhZGRyICYg UE1EX01BU0spID4+IFBBR0VfU0hJRlQ7Cj4gKwlwdWRfYWxpZ25lZCA9IChwYWRkciAmIFBVRF9N QVNLKSA+PiBQQUdFX1NISUZUOwo+ICsJcDRkX2FsaWduZWQgPSAocGFkZHIgJiBQNERfTUFTSykg Pj4gUEFHRV9TSElGVDsKPiArCXBnZF9hbGlnbmVkID0gKHBhZGRyICYgUEdESVJfTUFTSykgPj4g UEFHRV9TSElGVDsKPiArCVdBUk5fT04oIXBmbl92YWxpZChwdGVfYWxpZ25lZCkpOwo+ICsKPiAr CXBnZHAgPSBwZ2Rfb2Zmc2V0KG1tLCB2YWRkcik7Cj4gKwlwNGRwID0gcDRkX2FsbG9jKG1tLCBw Z2RwLCB2YWRkcik7Cj4gKwlwdWRwID0gcHVkX2FsbG9jKG1tLCBwNGRwLCB2YWRkcik7Cj4gKwlw bWRwID0gcG1kX2FsbG9jKG1tLCBwdWRwLCB2YWRkcik7Cj4gKwlwdGVwID0gcHRlX2FsbG9jX21h cChtbSwgcG1kcCwgdmFkZHIpOwo+ICsKPiArCS8qCj4gKwkgKiBTYXZlIGFsbCB0aGUgcGFnZSB0 YWJsZSBwYWdlIGFkZHJlc3NlcyBhcyB0aGUgcGFnZSB0YWJsZQo+ICsJICogZW50cmllcyB3aWxs IGJlIHVzZWQgZm9yIHRlc3Rpbmcgd2l0aCByYW5kb20gb3IgZ2FyYmFnZQo+ICsJICogdmFsdWVz LiBUaGVzZSBzYXZlZCBhZGRyZXNzZXMgd2lsbCBiZSB1c2VkIGZvciBmcmVlaW5nCj4gKwkgKiBw YWdlIHRhYmxlIHBhZ2VzLgo+ICsJICovCj4gKwlwbWQgPSBSRUFEX09OQ0UoKnBtZHApOwo+ICsJ c2F2ZWRfcDRkcCA9IHA0ZF9vZmZzZXQocGdkcCwgMFVMKTsKPiArCXNhdmVkX3B1ZHAgPSBwdWRf b2Zmc2V0KHA0ZHAsIDBVTCk7Cj4gKwlzYXZlZF9wbWRwID0gcG1kX29mZnNldChwdWRwLCAwVUwp Owo+ICsJc2F2ZWRfcHRlcCA9IHBtZF9wZ3RhYmxlKHBtZCk7Cj4gKwo+ICsJcHRlX2Jhc2ljX3Rl c3RzKHB0ZV9hbGlnbmVkLCBwcm90KTsKPiArCXBtZF9iYXNpY190ZXN0cyhwbWRfYWxpZ25lZCwg cHJvdCk7Cj4gKwlwdWRfYmFzaWNfdGVzdHMocHVkX2FsaWduZWQsIHByb3QpOwo+ICsJcDRkX2Jh c2ljX3Rlc3RzKHA0ZF9hbGlnbmVkLCBwcm90KTsKPiArCXBnZF9iYXNpY190ZXN0cyhwZ2RfYWxp Z25lZCwgcHJvdCk7Cj4gKwo+ICsJcHRlX2NsZWFyX3Rlc3RzKG1tLCBwdGVwKTsKPiArCXBtZF9j bGVhcl90ZXN0cyhtbSwgcG1kcCk7Cj4gKwlwdWRfY2xlYXJfdGVzdHMobW0sIHB1ZHApOwo+ICsJ cDRkX2NsZWFyX3Rlc3RzKG1tLCBwNGRwKTsKPiArCXBnZF9jbGVhcl90ZXN0cyhtbSwgcGdkcCk7 Cj4gKwo+ICsJcHRlX3VubWFwKHB0ZXApOwo+ICsKPiArCXBtZF9wb3B1bGF0ZV90ZXN0cyhtbSwg cG1kcCwgc2F2ZWRfcHRlcCk7Cj4gKwlwdWRfcG9wdWxhdGVfdGVzdHMobW0sIHB1ZHAsIHNhdmVk X3BtZHApOwo+ICsJcDRkX3BvcHVsYXRlX3Rlc3RzKG1tLCBwNGRwLCBzYXZlZF9wdWRwKTsKPiAr CXBnZF9wb3B1bGF0ZV90ZXN0cyhtbSwgcGdkcCwgc2F2ZWRfcDRkcCk7Cj4gKwo+ICsJcDRkX2Zy ZWUobW0sIHNhdmVkX3A0ZHApOwo+ICsJcHVkX2ZyZWUobW0sIHNhdmVkX3B1ZHApOwo+ICsJcG1k X2ZyZWUobW0sIHNhdmVkX3BtZHApOwo+ICsJcHRlX2ZyZWUobW0sIHNhdmVkX3B0ZXApOwo+ICsK PiArCW1tX2RlY19ucl9wdWRzKG1tKTsKPiArCW1tX2RlY19ucl9wbWRzKG1tKTsKPiArCW1tX2Rl Y19ucl9wdGVzKG1tKTsKPiArCW1tZHJvcChtbSk7Cj4gK30KCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0 CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK