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=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, USER_AGENT_SANE_1 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 8D24DC3F2CE for ; Mon, 2 Mar 2020 03:23:03 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 5C6E7246B6 for ; Mon, 2 Mar 2020 03:23:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726809AbgCBDXB (ORCPT ); Sun, 1 Mar 2020 22:23:01 -0500 Received: from foss.arm.com ([217.140.110.172]:55956 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726720AbgCBDXA (ORCPT ); Sun, 1 Mar 2020 22:23:00 -0500 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 259AEFEC; Sun, 1 Mar 2020 19:22:59 -0800 (PST) Received: from [10.163.1.119] (unknown [10.163.1.119]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BBB5D3F6CF; Sun, 1 Mar 2020 19:22:50 -0800 (PST) From: Anshuman Khandual Subject: Re: [PATCH] mm/debug: Add tests validating arch page table helpers for core features To: Christophe Leroy , linux-mm@kvack.org Cc: 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 , Catalin Marinas , 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 References: <1582799637-11786-1-git-send-email-anshuman.khandual@arm.com> <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Message-ID: <4343eda9-7df2-a13c-0125-cf784c81ce14@arm.com> Date: Mon, 2 Mar 2020 08:52:52 +0530 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Content-Type: text/plain; charset=utf-8 Content-Language: en-US Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 02/27/2020 04:59 PM, Christophe Leroy wrote: > > > Le 27/02/2020 à 11:33, Anshuman Khandual a écrit : >> This adds new tests validating arch page table helpers for these following >> core memory features. These tests create and test specific mapping types at >> various page table levels. >> >> * SPECIAL mapping >> * PROTNONE mapping >> * DEVMAP mapping >> * SOFTDIRTY mapping >> * SWAP mapping >> * MIGRATION mapping >> * HUGETLB mapping >> * THP mapping >> >> 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 >> Signed-off-by: Anshuman Khandual >> --- >> Tested on arm64 and x86 platforms without any test failures. But this has >> only been built tested on several other platforms. Individual tests need >> to be verified on all current enabling platforms for the test i.e s390, >> ppc32, arc etc. >> >> This patch must be applied on v5.6-rc3 after these patches >> >> 1. https://patchwork.kernel.org/patch/11385057/ >> 2. https://patchwork.kernel.org/patch/11407715/ >> >> OR >> >> This patch must be applied on linux-next (next-20200227) after this patch >> >> 2. https://patchwork.kernel.org/patch/11407715/ >> >>   mm/debug_vm_pgtable.c | 310 +++++++++++++++++++++++++++++++++++++++++- >>   1 file changed, 309 insertions(+), 1 deletion(-) >> >> diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c >> index 96dd7d574cef..3fb90d5b604e 100644 >> --- a/mm/debug_vm_pgtable.c >> +++ b/mm/debug_vm_pgtable.c >> @@ -41,6 +41,44 @@ >>    * 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 >> + * >> + * Specific feature operations >> + * >> + * pte_mkspecial(entry)        = Creates a special entry at PTE level >> + * pte_special(entry)        = Tests a special entry at PTE level >> + * >> + * pte_protnone(entry)        = Tests a no access entry at PTE level >> + * pmd_protnone(entry)        = Tests a no access entry at PMD level >> + * >> + * pte_mkdevmap(entry)        = Creates a device entry at PTE level >> + * pmd_mkdevmap(entry)        = Creates a device entry at PMD level >> + * pud_mkdevmap(entry)        = Creates a device entry at PUD level >> + * pte_devmap(entry)        = Tests a device entry at PTE level >> + * pmd_devmap(entry)        = Tests a device entry at PMD level >> + * pud_devmap(entry)        = Tests a device entry at PUD level >> + * >> + * pte_mksoft_dirty(entry)    = Creates a soft dirty entry at PTE level >> + * pmd_mksoft_dirty(entry)    = Creates a soft dirty entry at PMD level >> + * pte_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PTE level >> + * pmd_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PMD level >> + * pte_soft_dirty(entry)    = Tests a soft dirty entry at PTE level >> + * pmd_soft_dirty(entry)    = Tests a soft dirty entry at PMD level >> + * pte_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PTE level >> + * pmd_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PMD level >> + * pte_clear_soft_dirty(entry)       = Clears a soft dirty entry at PTE level >> + * pmd_clear_soft_dirty(entry)       = Clears a soft dirty entry at PMD level >> + * pte_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PTE level >> + * pmd_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PMD level >> + * >> + * pte_mkhuge(entry)        = Creates a HugeTLB entry at given level >> + * pte_huge(entry)        = Tests a HugeTLB entry at given level >> + * >> + * pmd_trans_huge(entry)    = Tests a trans huge page at PMD level >> + * pud_trans_huge(entry)    = Tests a trans huge page at PUD level >> + * pmd_present(entry)        = Tests an entry points to memory at PMD level >> + * pud_present(entry)        = Tests an entry points to memory at PUD level >> + * pmd_mknotpresent(entry)    = Invalidates an PMD entry for MMU >> + * pud_mknotpresent(entry)    = Invalidates an PUD entry for MMU >>    */ >>   #define VMFLAGS    (VM_READ|VM_WRITE|VM_EXEC) >>   @@ -287,6 +325,233 @@ static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, >>       WARN_ON(pmd_bad(pmd)); >>   } >>   +#ifdef CONFIG_ARCH_HAS_PTE_SPECIAL > > Can we avoid ifdefs unless necessary ? > > In mm/memory.c I see things like the following, it means pte_special() always exist and a #ifdef is not necessary. True, #ifdef here can be dropped here, done. > >     if (IS_ENABLED(CONFIG_ARCH_HAS_PTE_SPECIAL)) { >         if (likely(!pte_special(pte))) >             goto check_pfn; >         if (vma->vm_ops && vma->vm_ops->find_special_page) >             return vma->vm_ops->find_special_page(vma, addr); >         if (vma->vm_flags & (VM_PFNMAP | VM_MIXEDMAP)) >             return NULL; >         if (is_zero_pfn(pfn)) >             return NULL; >         if (pte_devmap(pte)) >             return NULL; > >         print_bad_pte(vma, addr, pte, NULL); >         return NULL; >     } > >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_special(pte_mkspecial(pte))); >> +} >> +#else >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_NUMA_BALANCING > > Same here, this ifdef shouldn't be necessary because in /include/asm-generic/pgtable.h we have the following, so a if (IS_ENABLED()) should be enough. > > #ifndef CONFIG_NUMA_BALANCING > /* >  * Technically a PTE can be PROTNONE even when not doing NUMA balancing but >  * the only case the kernel cares is for NUMA balancing and is only ever set >  * when the VMA is accessible. For PROT_NONE VMAs, the PTEs are not marked >  * _PAGE_PROTNONE so by by default, implement the helper as "always no". It >  * is the responsibility of the caller to distinguish between PROT_NONE >  * protections and NUMA hinting fault protections. >  */ > static inline int pte_protnone(pte_t pte) > { >     return 0; > } > > static inline int pmd_protnone(pmd_t pmd) > { >     return 0; > } > #endif /* CONFIG_NUMA_BALANCING */ True, #ifdef here can be dropped, done. There is something I had missed before, pfn_pmd() requires #ifdef CONFIG_TRANSPARENT_HUGEPAGE instead. We need a pmd_t here with given prot. We cannot go via pfn_pte() followed by pte_pmd(), as the later is platform specific and not available in general. > >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_protnone(pte)); >> +    WARN_ON(!pte_present(pte)); >> +} >> + >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_protnone(pmd)); >> +    WARN_ON(!pmd_present(pmd)); >> +} >> +#else >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP > > Same here, in include/linux/mm.h we have: > > #ifndef CONFIG_ARCH_HAS_PTE_DEVMAP > static inline int pte_devmap(pte_t pte) > { >     return 0; > } > #endif > > >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_devmap(pte_mkdevmap(pte))); >> +} >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same. In inlude/asm-generic/pgtables.h you have: > > #if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE) > static inline int pmd_devmap(pmd_t pmd) > { >     return 0; > } > static inline int pud_devmap(pud_t pud) > { >     return 0; > } > static inline int pgd_devmap(pgd_t pgd) > { >     return 0; > } > #endif > >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_devmap(pmd_mkdevmap(pmd))); >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same, see above Even though pxx_devmap() fallback definitions are present, pxx_mkdevmap() ones are still missing. We will have to add them first as a pre-requisite patch (which might not be popular without any non-debug use case) in order to drop these #ifdefs here. > >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud = pfn_pud(pfn, prot); >> + >> +    WARN_ON(!pud_devmap(pud_mkdevmap(pud))); >> +} >> +#else >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MEM_SOFT_DIRTY > > Same, they always exist, see include/asm-generic/pgtable.h Yeah, this can be dropped. Though will have to again add TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_soft_dirty(pte_mksoft_dirty(pte))); >> +    WARN_ON(pte_soft_dirty(pte_clear_soft_dirty(pte))); >> +} >> + >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_swp_soft_dirty(pte_swp_mksoft_dirty(pte))); >> +    WARN_ON(pte_swp_soft_dirty(pte_swp_clear_soft_dirty(pte))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION > > Same True, #ifdef here can be dropped, done. > >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_soft_dirty(pmd_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_soft_dirty(pmd_clear_soft_dirty(pmd))); >> +} >> + >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_swp_soft_dirty(pmd_swp_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_swp_soft_dirty(pmd_swp_clear_soft_dirty(pmd))); >> +} >> +#else >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> +#else >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> + >> +static void __init pte_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pte_t pte; >> + >> +    pte = pfn_pte(pfn, prot); >> +    swp = __pte_to_swp_entry(pte); >> +    WARN_ON(!pte_same(pte, __swp_entry_to_pte(swp))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pmd_t pmd; >> + >> +    pmd = pfn_pmd(pfn, prot); >> +    swp = __pmd_to_swp_entry(pmd); >> +    WARN_ON(!pmd_same(pmd, __swp_entry_to_pmd(swp))); >> +} >> +#else >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MIGRATION > > Same. See include/linux/swapops.h True, #ifdef here can be dropped, done. Though will have to again add back TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init swap_migration_tests(struct page *page) >> +{ >> +    swp_entry_t swp; >> + >> +    /* >> +     * make_migration_entry() expects given page to be >> +     * locked, otherwise it stumbles upon a BUG_ON(). >> +     */ >> +    __SetPageLocked(page); >> +    swp = make_migration_entry(page, 1); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(!is_write_migration_entry(swp)); >> + >> +    make_migration_entry_read(&swp); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> + >> +    swp = make_migration_entry(page, 0); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> +    __ClearPageLocked(page); >> +} >> +#else >> +static void __init swap_migration_tests(struct page *page) { } >> +#endif >> + >> +#ifdef CONFIG_HUGETLB_PAGE >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +#ifdef CONFIG_ARCH_WANT_GENERAL_HUGETLB >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_huge(pte_mkhuge(pte))); > > We also need tests on hugepd stuff Sure, but lets discuss this on the other thread. > >> +#endif >> +} >> +#else >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same, see include/asm-generic/pgtable.h This is required to protect pxx_mknotpresent() which does not have a fall back and pfn_pmd()/pfn_pud() helpers have similar situation as well. > >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd; >> + >> +    /* >> +     * pmd_trans_huge() and pmd_present() must return negative >> +     * after MMU invalidation with pmd_mknotpresent(). >> +     */ >> +    pmd = pfn_pmd(pfn, prot); >> +    WARN_ON(!pmd_trans_huge(pmd_mkhuge(pmd))); >> + >> +    /* >> +     * Though platform specific test exclusions are not ideal, >> +     * in this case S390 does not define pmd_mknotpresent() >> +     * which should be tested on other platforms enabling THP. >> +     */ >> +#ifndef CONFIG_S390 >> +    WARN_ON(pmd_trans_huge(pmd_mknotpresent(pmd))); >> +    WARN_ON(pmd_present(pmd_mknotpresent(pmd))); >> +#endif > > Can we add a stub on S390 instead ? Actually we dont have to. pmd_mknotpresent() is required for platforms that do not have __HAVE_ARCH_PMDP_INVALIDATE. Hence can wrap this code with !__HAVE_ARCH_PMDP_INVALIDATE to prevent build failures on such platforms like s390. > >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same ? The problem is, neither pud_mknotpresent() nor pfn_pud() have a generic fallback definition. So will have to keep this #ifdef. > >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud; >> + >> +    /* >> +     * pud_trans_huge() and pud_present() must return negative >> +     * after MMU invalidation with pud_mknotpresent(). >> +     */ >> +    pud = pfn_pud(pfn, prot); >> +    WARN_ON(!pud_trans_huge(pud_mkhuge(pud))); >> +    WARN_ON(pud_trans_huge(pud_mknotpresent(pud))); >> +    WARN_ON(pud_present(pud_mknotpresent(pud))); >> +} >> +#else >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >>   static unsigned long __init get_random_vaddr(void) >>   { >>       unsigned long random_vaddr, random_pages, total_user_pages; >> @@ -302,13 +567,14 @@ static unsigned long __init get_random_vaddr(void) >>   void __init debug_vm_pgtable(void) >>   { >>       struct mm_struct *mm; >> +    struct page *page; >>       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; >> +    pgprot_t prot, protnone; >>       phys_addr_t paddr; >>       unsigned long vaddr, pte_aligned, pmd_aligned; >>       unsigned long pud_aligned, p4d_aligned, pgd_aligned; >> @@ -322,6 +588,25 @@ void __init debug_vm_pgtable(void) >>           return; >>       } >>   +    /* >> +     * swap_migration_tests() requires a dedicated page as it needs to >> +     * be locked before creating a migration entry from it. Locking the >> +     * page that actually maps kernel text ('start_kernel') can be real >> +     * problematic. Lets allocate a dedicated page explicitly for this >> +     * purpose that will be freed later. >> +     */ >> +    page = alloc_page(GFP_KERNEL); > > Can we do the page allocation and freeing in swap_migration_tests() instead ? Although all the resources used in the helpers have been allocated in the main function itself before being passed down and later freed. But may be just an exception could be made for swap_migration_tests() function as the allocated page is being exclusively used here. Later on if we need this page for some other future tests, then will have to move it back to debug_vm_pgtable(). From mboxrd@z Thu Jan 1 00:00:00 1970 From: Anshuman Khandual Subject: Re: [PATCH] mm/debug: Add tests validating arch page table helpers for core features Date: Mon, 2 Mar 2020 08:52:52 +0530 Message-ID: <4343eda9-7df2-a13c-0125-cf784c81ce14@arm.com> References: <1582799637-11786-1-git-send-email-anshuman.khandual@arm.com> <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org To: Christophe Leroy , linux-mm@kvack.org Cc: 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 , Catalin Marinas , 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 List-Id: linux-arch.vger.kernel.org On 02/27/2020 04:59 PM, Christophe Leroy wrote: > > > Le 27/02/2020 à 11:33, Anshuman Khandual a écrit : >> This adds new tests validating arch page table helpers for these following >> core memory features. These tests create and test specific mapping types at >> various page table levels. >> >> * SPECIAL mapping >> * PROTNONE mapping >> * DEVMAP mapping >> * SOFTDIRTY mapping >> * SWAP mapping >> * MIGRATION mapping >> * HUGETLB mapping >> * THP mapping >> >> 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 >> Signed-off-by: Anshuman Khandual >> --- >> Tested on arm64 and x86 platforms without any test failures. But this has >> only been built tested on several other platforms. Individual tests need >> to be verified on all current enabling platforms for the test i.e s390, >> ppc32, arc etc. >> >> This patch must be applied on v5.6-rc3 after these patches >> >> 1. https://patchwork.kernel.org/patch/11385057/ >> 2. https://patchwork.kernel.org/patch/11407715/ >> >> OR >> >> This patch must be applied on linux-next (next-20200227) after this patch >> >> 2. https://patchwork.kernel.org/patch/11407715/ >> >>   mm/debug_vm_pgtable.c | 310 +++++++++++++++++++++++++++++++++++++++++- >>   1 file changed, 309 insertions(+), 1 deletion(-) >> >> diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c >> index 96dd7d574cef..3fb90d5b604e 100644 >> --- a/mm/debug_vm_pgtable.c >> +++ b/mm/debug_vm_pgtable.c >> @@ -41,6 +41,44 @@ >>    * 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 >> + * >> + * Specific feature operations >> + * >> + * pte_mkspecial(entry)        = Creates a special entry at PTE level >> + * pte_special(entry)        = Tests a special entry at PTE level >> + * >> + * pte_protnone(entry)        = Tests a no access entry at PTE level >> + * pmd_protnone(entry)        = Tests a no access entry at PMD level >> + * >> + * pte_mkdevmap(entry)        = Creates a device entry at PTE level >> + * pmd_mkdevmap(entry)        = Creates a device entry at PMD level >> + * pud_mkdevmap(entry)        = Creates a device entry at PUD level >> + * pte_devmap(entry)        = Tests a device entry at PTE level >> + * pmd_devmap(entry)        = Tests a device entry at PMD level >> + * pud_devmap(entry)        = Tests a device entry at PUD level >> + * >> + * pte_mksoft_dirty(entry)    = Creates a soft dirty entry at PTE level >> + * pmd_mksoft_dirty(entry)    = Creates a soft dirty entry at PMD level >> + * pte_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PTE level >> + * pmd_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PMD level >> + * pte_soft_dirty(entry)    = Tests a soft dirty entry at PTE level >> + * pmd_soft_dirty(entry)    = Tests a soft dirty entry at PMD level >> + * pte_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PTE level >> + * pmd_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PMD level >> + * pte_clear_soft_dirty(entry)       = Clears a soft dirty entry at PTE level >> + * pmd_clear_soft_dirty(entry)       = Clears a soft dirty entry at PMD level >> + * pte_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PTE level >> + * pmd_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PMD level >> + * >> + * pte_mkhuge(entry)        = Creates a HugeTLB entry at given level >> + * pte_huge(entry)        = Tests a HugeTLB entry at given level >> + * >> + * pmd_trans_huge(entry)    = Tests a trans huge page at PMD level >> + * pud_trans_huge(entry)    = Tests a trans huge page at PUD level >> + * pmd_present(entry)        = Tests an entry points to memory at PMD level >> + * pud_present(entry)        = Tests an entry points to memory at PUD level >> + * pmd_mknotpresent(entry)    = Invalidates an PMD entry for MMU >> + * pud_mknotpresent(entry)    = Invalidates an PUD entry for MMU >>    */ >>   #define VMFLAGS    (VM_READ|VM_WRITE|VM_EXEC) >>   @@ -287,6 +325,233 @@ static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, >>       WARN_ON(pmd_bad(pmd)); >>   } >>   +#ifdef CONFIG_ARCH_HAS_PTE_SPECIAL > > Can we avoid ifdefs unless necessary ? > > In mm/memory.c I see things like the following, it means pte_special() always exist and a #ifdef is not necessary. True, #ifdef here can be dropped here, done. > >     if (IS_ENABLED(CONFIG_ARCH_HAS_PTE_SPECIAL)) { >         if (likely(!pte_special(pte))) >             goto check_pfn; >         if (vma->vm_ops && vma->vm_ops->find_special_page) >             return vma->vm_ops->find_special_page(vma, addr); >         if (vma->vm_flags & (VM_PFNMAP | VM_MIXEDMAP)) >             return NULL; >         if (is_zero_pfn(pfn)) >             return NULL; >         if (pte_devmap(pte)) >             return NULL; > >         print_bad_pte(vma, addr, pte, NULL); >         return NULL; >     } > >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_special(pte_mkspecial(pte))); >> +} >> +#else >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_NUMA_BALANCING > > Same here, this ifdef shouldn't be necessary because in /include/asm-generic/pgtable.h we have the following, so a if (IS_ENABLED()) should be enough. > > #ifndef CONFIG_NUMA_BALANCING > /* >  * Technically a PTE can be PROTNONE even when not doing NUMA balancing but >  * the only case the kernel cares is for NUMA balancing and is only ever set >  * when the VMA is accessible. For PROT_NONE VMAs, the PTEs are not marked >  * _PAGE_PROTNONE so by by default, implement the helper as "always no". It >  * is the responsibility of the caller to distinguish between PROT_NONE >  * protections and NUMA hinting fault protections. >  */ > static inline int pte_protnone(pte_t pte) > { >     return 0; > } > > static inline int pmd_protnone(pmd_t pmd) > { >     return 0; > } > #endif /* CONFIG_NUMA_BALANCING */ True, #ifdef here can be dropped, done. There is something I had missed before, pfn_pmd() requires #ifdef CONFIG_TRANSPARENT_HUGEPAGE instead. We need a pmd_t here with given prot. We cannot go via pfn_pte() followed by pte_pmd(), as the later is platform specific and not available in general. > >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_protnone(pte)); >> +    WARN_ON(!pte_present(pte)); >> +} >> + >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_protnone(pmd)); >> +    WARN_ON(!pmd_present(pmd)); >> +} >> +#else >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP > > Same here, in include/linux/mm.h we have: > > #ifndef CONFIG_ARCH_HAS_PTE_DEVMAP > static inline int pte_devmap(pte_t pte) > { >     return 0; > } > #endif > > >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_devmap(pte_mkdevmap(pte))); >> +} >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same. In inlude/asm-generic/pgtables.h you have: > > #if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE) > static inline int pmd_devmap(pmd_t pmd) > { >     return 0; > } > static inline int pud_devmap(pud_t pud) > { >     return 0; > } > static inline int pgd_devmap(pgd_t pgd) > { >     return 0; > } > #endif > >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_devmap(pmd_mkdevmap(pmd))); >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same, see above Even though pxx_devmap() fallback definitions are present, pxx_mkdevmap() ones are still missing. We will have to add them first as a pre-requisite patch (which might not be popular without any non-debug use case) in order to drop these #ifdefs here. > >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud = pfn_pud(pfn, prot); >> + >> +    WARN_ON(!pud_devmap(pud_mkdevmap(pud))); >> +} >> +#else >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MEM_SOFT_DIRTY > > Same, they always exist, see include/asm-generic/pgtable.h Yeah, this can be dropped. Though will have to again add TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_soft_dirty(pte_mksoft_dirty(pte))); >> +    WARN_ON(pte_soft_dirty(pte_clear_soft_dirty(pte))); >> +} >> + >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_swp_soft_dirty(pte_swp_mksoft_dirty(pte))); >> +    WARN_ON(pte_swp_soft_dirty(pte_swp_clear_soft_dirty(pte))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION > > Same True, #ifdef here can be dropped, done. > >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_soft_dirty(pmd_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_soft_dirty(pmd_clear_soft_dirty(pmd))); >> +} >> + >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_swp_soft_dirty(pmd_swp_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_swp_soft_dirty(pmd_swp_clear_soft_dirty(pmd))); >> +} >> +#else >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> +#else >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> + >> +static void __init pte_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pte_t pte; >> + >> +    pte = pfn_pte(pfn, prot); >> +    swp = __pte_to_swp_entry(pte); >> +    WARN_ON(!pte_same(pte, __swp_entry_to_pte(swp))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pmd_t pmd; >> + >> +    pmd = pfn_pmd(pfn, prot); >> +    swp = __pmd_to_swp_entry(pmd); >> +    WARN_ON(!pmd_same(pmd, __swp_entry_to_pmd(swp))); >> +} >> +#else >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MIGRATION > > Same. See include/linux/swapops.h True, #ifdef here can be dropped, done. Though will have to again add back TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init swap_migration_tests(struct page *page) >> +{ >> +    swp_entry_t swp; >> + >> +    /* >> +     * make_migration_entry() expects given page to be >> +     * locked, otherwise it stumbles upon a BUG_ON(). >> +     */ >> +    __SetPageLocked(page); >> +    swp = make_migration_entry(page, 1); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(!is_write_migration_entry(swp)); >> + >> +    make_migration_entry_read(&swp); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> + >> +    swp = make_migration_entry(page, 0); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> +    __ClearPageLocked(page); >> +} >> +#else >> +static void __init swap_migration_tests(struct page *page) { } >> +#endif >> + >> +#ifdef CONFIG_HUGETLB_PAGE >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +#ifdef CONFIG_ARCH_WANT_GENERAL_HUGETLB >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_huge(pte_mkhuge(pte))); > > We also need tests on hugepd stuff Sure, but lets discuss this on the other thread. > >> +#endif >> +} >> +#else >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same, see include/asm-generic/pgtable.h This is required to protect pxx_mknotpresent() which does not have a fall back and pfn_pmd()/pfn_pud() helpers have similar situation as well. > >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd; >> + >> +    /* >> +     * pmd_trans_huge() and pmd_present() must return negative >> +     * after MMU invalidation with pmd_mknotpresent(). >> +     */ >> +    pmd = pfn_pmd(pfn, prot); >> +    WARN_ON(!pmd_trans_huge(pmd_mkhuge(pmd))); >> + >> +    /* >> +     * Though platform specific test exclusions are not ideal, >> +     * in this case S390 does not define pmd_mknotpresent() >> +     * which should be tested on other platforms enabling THP. >> +     */ >> +#ifndef CONFIG_S390 >> +    WARN_ON(pmd_trans_huge(pmd_mknotpresent(pmd))); >> +    WARN_ON(pmd_present(pmd_mknotpresent(pmd))); >> +#endif > > Can we add a stub on S390 instead ? Actually we dont have to. pmd_mknotpresent() is required for platforms that do not have __HAVE_ARCH_PMDP_INVALIDATE. Hence can wrap this code with !__HAVE_ARCH_PMDP_INVALIDATE to prevent build failures on such platforms like s390. > >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same ? The problem is, neither pud_mknotpresent() nor pfn_pud() have a generic fallback definition. So will have to keep this #ifdef. > >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud; >> + >> +    /* >> +     * pud_trans_huge() and pud_present() must return negative >> +     * after MMU invalidation with pud_mknotpresent(). >> +     */ >> +    pud = pfn_pud(pfn, prot); >> +    WARN_ON(!pud_trans_huge(pud_mkhuge(pud))); >> +    WARN_ON(pud_trans_huge(pud_mknotpresent(pud))); >> +    WARN_ON(pud_present(pud_mknotpresent(pud))); >> +} >> +#else >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >>   static unsigned long __init get_random_vaddr(void) >>   { >>       unsigned long random_vaddr, random_pages, total_user_pages; >> @@ -302,13 +567,14 @@ static unsigned long __init get_random_vaddr(void) >>   void __init debug_vm_pgtable(void) >>   { >>       struct mm_struct *mm; >> +    struct page *page; >>       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; >> +    pgprot_t prot, protnone; >>       phys_addr_t paddr; >>       unsigned long vaddr, pte_aligned, pmd_aligned; >>       unsigned long pud_aligned, p4d_aligned, pgd_aligned; >> @@ -322,6 +588,25 @@ void __init debug_vm_pgtable(void) >>           return; >>       } >>   +    /* >> +     * swap_migration_tests() requires a dedicated page as it needs to >> +     * be locked before creating a migration entry from it. Locking the >> +     * page that actually maps kernel text ('start_kernel') can be real >> +     * problematic. Lets allocate a dedicated page explicitly for this >> +     * purpose that will be freed later. >> +     */ >> +    page = alloc_page(GFP_KERNEL); > > Can we do the page allocation and freeing in swap_migration_tests() instead ? Although all the resources used in the helpers have been allocated in the main function itself before being passed down and later freed. But may be just an exception could be made for swap_migration_tests() function as the allocated page is being exclusively used here. Later on if we need this page for some other future tests, then will have to move it back to debug_vm_pgtable(). From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Anshuman Khandual Subject: Re: [PATCH] mm/debug: Add tests validating arch page table helpers for core features References: <1582799637-11786-1-git-send-email-anshuman.khandual@arm.com> <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Message-ID: <4343eda9-7df2-a13c-0125-cf784c81ce14@arm.com> Date: Mon, 2 Mar 2020 08:52:52 +0530 MIME-Version: 1.0 In-Reply-To: <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Content-Type: text/plain; charset=utf-8 Content-Language: en-US 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: Christophe Leroy , 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, 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 List-ID: Message-ID: <20200302032252.WUF2MlQwxXCQzkIGxyYx9YfTj12rTFgFoOVWsTSPUSo@z> On 02/27/2020 04:59 PM, Christophe Leroy wrote: > > > Le 27/02/2020 à 11:33, Anshuman Khandual a écrit : >> This adds new tests validating arch page table helpers for these following >> core memory features. These tests create and test specific mapping types at >> various page table levels. >> >> * SPECIAL mapping >> * PROTNONE mapping >> * DEVMAP mapping >> * SOFTDIRTY mapping >> * SWAP mapping >> * MIGRATION mapping >> * HUGETLB mapping >> * THP mapping >> >> 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 >> Signed-off-by: Anshuman Khandual >> --- >> Tested on arm64 and x86 platforms without any test failures. But this has >> only been built tested on several other platforms. Individual tests need >> to be verified on all current enabling platforms for the test i.e s390, >> ppc32, arc etc. >> >> This patch must be applied on v5.6-rc3 after these patches >> >> 1. https://patchwork.kernel.org/patch/11385057/ >> 2. https://patchwork.kernel.org/patch/11407715/ >> >> OR >> >> This patch must be applied on linux-next (next-20200227) after this patch >> >> 2. https://patchwork.kernel.org/patch/11407715/ >> >>   mm/debug_vm_pgtable.c | 310 +++++++++++++++++++++++++++++++++++++++++- >>   1 file changed, 309 insertions(+), 1 deletion(-) >> >> diff --git a/mm/debug_vm_pgtable.c b/mm/debug_vm_pgtable.c >> index 96dd7d574cef..3fb90d5b604e 100644 >> --- a/mm/debug_vm_pgtable.c >> +++ b/mm/debug_vm_pgtable.c >> @@ -41,6 +41,44 @@ >>    * 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 >> + * >> + * Specific feature operations >> + * >> + * pte_mkspecial(entry)        = Creates a special entry at PTE level >> + * pte_special(entry)        = Tests a special entry at PTE level >> + * >> + * pte_protnone(entry)        = Tests a no access entry at PTE level >> + * pmd_protnone(entry)        = Tests a no access entry at PMD level >> + * >> + * pte_mkdevmap(entry)        = Creates a device entry at PTE level >> + * pmd_mkdevmap(entry)        = Creates a device entry at PMD level >> + * pud_mkdevmap(entry)        = Creates a device entry at PUD level >> + * pte_devmap(entry)        = Tests a device entry at PTE level >> + * pmd_devmap(entry)        = Tests a device entry at PMD level >> + * pud_devmap(entry)        = Tests a device entry at PUD level >> + * >> + * pte_mksoft_dirty(entry)    = Creates a soft dirty entry at PTE level >> + * pmd_mksoft_dirty(entry)    = Creates a soft dirty entry at PMD level >> + * pte_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PTE level >> + * pmd_swp_mksoft_dirty(entry)    = Creates a soft dirty swap entry at PMD level >> + * pte_soft_dirty(entry)    = Tests a soft dirty entry at PTE level >> + * pmd_soft_dirty(entry)    = Tests a soft dirty entry at PMD level >> + * pte_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PTE level >> + * pmd_swp_soft_dirty(entry)    = Tests a soft dirty swap entry at PMD level >> + * pte_clear_soft_dirty(entry)       = Clears a soft dirty entry at PTE level >> + * pmd_clear_soft_dirty(entry)       = Clears a soft dirty entry at PMD level >> + * pte_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PTE level >> + * pmd_swp_clear_soft_dirty(entry) = Clears a soft dirty swap entry at PMD level >> + * >> + * pte_mkhuge(entry)        = Creates a HugeTLB entry at given level >> + * pte_huge(entry)        = Tests a HugeTLB entry at given level >> + * >> + * pmd_trans_huge(entry)    = Tests a trans huge page at PMD level >> + * pud_trans_huge(entry)    = Tests a trans huge page at PUD level >> + * pmd_present(entry)        = Tests an entry points to memory at PMD level >> + * pud_present(entry)        = Tests an entry points to memory at PUD level >> + * pmd_mknotpresent(entry)    = Invalidates an PMD entry for MMU >> + * pud_mknotpresent(entry)    = Invalidates an PUD entry for MMU >>    */ >>   #define VMFLAGS    (VM_READ|VM_WRITE|VM_EXEC) >>   @@ -287,6 +325,233 @@ static void __init pmd_populate_tests(struct mm_struct *mm, pmd_t *pmdp, >>       WARN_ON(pmd_bad(pmd)); >>   } >>   +#ifdef CONFIG_ARCH_HAS_PTE_SPECIAL > > Can we avoid ifdefs unless necessary ? > > In mm/memory.c I see things like the following, it means pte_special() always exist and a #ifdef is not necessary. True, #ifdef here can be dropped here, done. > >     if (IS_ENABLED(CONFIG_ARCH_HAS_PTE_SPECIAL)) { >         if (likely(!pte_special(pte))) >             goto check_pfn; >         if (vma->vm_ops && vma->vm_ops->find_special_page) >             return vma->vm_ops->find_special_page(vma, addr); >         if (vma->vm_flags & (VM_PFNMAP | VM_MIXEDMAP)) >             return NULL; >         if (is_zero_pfn(pfn)) >             return NULL; >         if (pte_devmap(pte)) >             return NULL; > >         print_bad_pte(vma, addr, pte, NULL); >         return NULL; >     } > >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_special(pte_mkspecial(pte))); >> +} >> +#else >> +static void __init pte_special_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_NUMA_BALANCING > > Same here, this ifdef shouldn't be necessary because in /include/asm-generic/pgtable.h we have the following, so a if (IS_ENABLED()) should be enough. > > #ifndef CONFIG_NUMA_BALANCING > /* >  * Technically a PTE can be PROTNONE even when not doing NUMA balancing but >  * the only case the kernel cares is for NUMA balancing and is only ever set >  * when the VMA is accessible. For PROT_NONE VMAs, the PTEs are not marked >  * _PAGE_PROTNONE so by by default, implement the helper as "always no". It >  * is the responsibility of the caller to distinguish between PROT_NONE >  * protections and NUMA hinting fault protections. >  */ > static inline int pte_protnone(pte_t pte) > { >     return 0; > } > > static inline int pmd_protnone(pmd_t pmd) > { >     return 0; > } > #endif /* CONFIG_NUMA_BALANCING */ True, #ifdef here can be dropped, done. There is something I had missed before, pfn_pmd() requires #ifdef CONFIG_TRANSPARENT_HUGEPAGE instead. We need a pmd_t here with given prot. We cannot go via pfn_pte() followed by pte_pmd(), as the later is platform specific and not available in general. > >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_protnone(pte)); >> +    WARN_ON(!pte_present(pte)); >> +} >> + >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_protnone(pmd)); >> +    WARN_ON(!pmd_present(pmd)); >> +} >> +#else >> +static void __init pte_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_protnone_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP > > Same here, in include/linux/mm.h we have: > > #ifndef CONFIG_ARCH_HAS_PTE_DEVMAP > static inline int pte_devmap(pte_t pte) > { >     return 0; > } > #endif > > >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_devmap(pte_mkdevmap(pte))); >> +} >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same. In inlude/asm-generic/pgtables.h you have: > > #if !defined(CONFIG_ARCH_HAS_PTE_DEVMAP) || !defined(CONFIG_TRANSPARENT_HUGEPAGE) > static inline int pmd_devmap(pmd_t pmd) > { >     return 0; > } > static inline int pud_devmap(pud_t pud) > { >     return 0; > } > static inline int pgd_devmap(pgd_t pgd) > { >     return 0; > } > #endif > >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_devmap(pmd_mkdevmap(pmd))); >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same, see above Even though pxx_devmap() fallback definitions are present, pxx_mkdevmap() ones are still missing. We will have to add them first as a pre-requisite patch (which might not be popular without any non-debug use case) in order to drop these #ifdefs here. > >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud = pfn_pud(pfn, prot); >> + >> +    WARN_ON(!pud_devmap(pud_mkdevmap(pud))); >> +} >> +#else >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pte_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_devmap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MEM_SOFT_DIRTY > > Same, they always exist, see include/asm-generic/pgtable.h Yeah, this can be dropped. Though will have to again add TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_soft_dirty(pte_mksoft_dirty(pte))); >> +    WARN_ON(pte_soft_dirty(pte_clear_soft_dirty(pte))); >> +} >> + >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_swp_soft_dirty(pte_swp_mksoft_dirty(pte))); >> +    WARN_ON(pte_swp_soft_dirty(pte_swp_clear_soft_dirty(pte))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION > > Same True, #ifdef here can be dropped, done. > >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_soft_dirty(pmd_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_soft_dirty(pmd_clear_soft_dirty(pmd))); >> +} >> + >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd = pfn_pmd(pfn, prot); >> + >> +    WARN_ON(!pmd_swp_soft_dirty(pmd_swp_mksoft_dirty(pmd))); >> +    WARN_ON(pmd_swp_soft_dirty(pmd_swp_clear_soft_dirty(pmd))); >> +} >> +#else >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> +#else >> +static void __init pte_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pmd_soft_dirty_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pte_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +static void __init pmd_swap_soft_dirty_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +} >> +#endif >> + >> +static void __init pte_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pte_t pte; >> + >> +    pte = pfn_pte(pfn, prot); >> +    swp = __pte_to_swp_entry(pte); >> +    WARN_ON(!pte_same(pte, __swp_entry_to_pte(swp))); >> +} >> + >> +#ifdef CONFIG_ARCH_ENABLE_THP_MIGRATION >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    swp_entry_t swp; >> +    pmd_t pmd; >> + >> +    pmd = pfn_pmd(pfn, prot); >> +    swp = __pmd_to_swp_entry(pmd); >> +    WARN_ON(!pmd_same(pmd, __swp_entry_to_pmd(swp))); >> +} >> +#else >> +static void __init pmd_swap_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_MIGRATION > > Same. See include/linux/swapops.h True, #ifdef here can be dropped, done. Though will have to again add back TRANSPARENT_HUGEPAGE to protect pfn_pmd() as explained before. > >> +static void __init swap_migration_tests(struct page *page) >> +{ >> +    swp_entry_t swp; >> + >> +    /* >> +     * make_migration_entry() expects given page to be >> +     * locked, otherwise it stumbles upon a BUG_ON(). >> +     */ >> +    __SetPageLocked(page); >> +    swp = make_migration_entry(page, 1); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(!is_write_migration_entry(swp)); >> + >> +    make_migration_entry_read(&swp); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> + >> +    swp = make_migration_entry(page, 0); >> +    WARN_ON(!is_migration_entry(swp)); >> +    WARN_ON(is_write_migration_entry(swp)); >> +    __ClearPageLocked(page); >> +} >> +#else >> +static void __init swap_migration_tests(struct page *page) { } >> +#endif >> + >> +#ifdef CONFIG_HUGETLB_PAGE >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +#ifdef CONFIG_ARCH_WANT_GENERAL_HUGETLB >> +    pte_t pte = pfn_pte(pfn, prot); >> + >> +    WARN_ON(!pte_huge(pte_mkhuge(pte))); > > We also need tests on hugepd stuff Sure, but lets discuss this on the other thread. > >> +#endif >> +} >> +#else >> +static void __init hugetlb_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >> +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > > Same, see include/asm-generic/pgtable.h This is required to protect pxx_mknotpresent() which does not have a fall back and pfn_pmd()/pfn_pud() helpers have similar situation as well. > >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pmd_t pmd; >> + >> +    /* >> +     * pmd_trans_huge() and pmd_present() must return negative >> +     * after MMU invalidation with pmd_mknotpresent(). >> +     */ >> +    pmd = pfn_pmd(pfn, prot); >> +    WARN_ON(!pmd_trans_huge(pmd_mkhuge(pmd))); >> + >> +    /* >> +     * Though platform specific test exclusions are not ideal, >> +     * in this case S390 does not define pmd_mknotpresent() >> +     * which should be tested on other platforms enabling THP. >> +     */ >> +#ifndef CONFIG_S390 >> +    WARN_ON(pmd_trans_huge(pmd_mknotpresent(pmd))); >> +    WARN_ON(pmd_present(pmd_mknotpresent(pmd))); >> +#endif > > Can we add a stub on S390 instead ? Actually we dont have to. pmd_mknotpresent() is required for platforms that do not have __HAVE_ARCH_PMDP_INVALIDATE. Hence can wrap this code with !__HAVE_ARCH_PMDP_INVALIDATE to prevent build failures on such platforms like s390. > >> +} >> + >> +#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD > > Same ? The problem is, neither pud_mknotpresent() nor pfn_pud() have a generic fallback definition. So will have to keep this #ifdef. > >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) >> +{ >> +    pud_t pud; >> + >> +    /* >> +     * pud_trans_huge() and pud_present() must return negative >> +     * after MMU invalidation with pud_mknotpresent(). >> +     */ >> +    pud = pfn_pud(pfn, prot); >> +    WARN_ON(!pud_trans_huge(pud_mkhuge(pud))); >> +    WARN_ON(pud_trans_huge(pud_mknotpresent(pud))); >> +    WARN_ON(pud_present(pud_mknotpresent(pud))); >> +} >> +#else >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> +#else >> +static void __init pmd_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +static void __init pud_thp_tests(unsigned long pfn, pgprot_t prot) { } >> +#endif >> + >>   static unsigned long __init get_random_vaddr(void) >>   { >>       unsigned long random_vaddr, random_pages, total_user_pages; >> @@ -302,13 +567,14 @@ static unsigned long __init get_random_vaddr(void) >>   void __init debug_vm_pgtable(void) >>   { >>       struct mm_struct *mm; >> +    struct page *page; >>       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; >> +    pgprot_t prot, protnone; >>       phys_addr_t paddr; >>       unsigned long vaddr, pte_aligned, pmd_aligned; >>       unsigned long pud_aligned, p4d_aligned, pgd_aligned; >> @@ -322,6 +588,25 @@ void __init debug_vm_pgtable(void) >>           return; >>       } >>   +    /* >> +     * swap_migration_tests() requires a dedicated page as it needs to >> +     * be locked before creating a migration entry from it. Locking the >> +     * page that actually maps kernel text ('start_kernel') can be real >> +     * problematic. Lets allocate a dedicated page explicitly for this >> +     * purpose that will be freed later. >> +     */ >> +    page = alloc_page(GFP_KERNEL); > > Can we do the page allocation and freeing in swap_migration_tests() instead ? Although all the resources used in the helpers have been allocated in the main function itself before being passed down and later freed. But may be just an exception could be made for swap_migration_tests() function as the allocated page is being exclusively used here. Later on if we need this page for some other future tests, then will have to move it back to debug_vm_pgtable(). 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_1 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 DF7ECC3F2CE for ; Mon, 2 Mar 2020 03:23:26 +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 AB46E24699 for ; Mon, 2 Mar 2020 03:23:26 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="p26S6+xS" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org AB46E24699 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com 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:In-Reply-To:MIME-Version:Date: Message-ID:References:To:Subject:From:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=XgStvN1WKeHRjPUrGn3gFIbh1HJx33txK+vTJMm8aAQ=; b=p26S6+xS3eGMCh sRRjeLy+a+8OB9hi0JiqRIYtN6Uc3dk0BlYEcOnw6U4GHY5ny22A8GUFkC4XFSv7gZTLT0SmKhwyt ZBGkzLoPcG9eyeErX6nF0tGVNFskdHfIY/OR8rWVLbVvPHV9GGo9U1PQBnr2oxFAf9hZteNKF/q26 LP5rnBk5l3QpehM3E11z6p+3qKWpPdiG+gMJ1TerG47CqFns/fNBLt8oP5YvK2q+DXQXYEfK2CcG8 mPWTj2nmTSaxItH7U8Y31+PfqCONqzaORxX7Hs5YiuzPL6Dxi/4BXT+e4KebcwQUBHDVwHLpCGtVZ XxvkJtbQf7OybLoeSZkQ==; 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 1j8bfw-0000jF-HP; Mon, 02 Mar 2020 03:23:24 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j8bfa-0000Ti-6Y; Mon, 02 Mar 2020 03:23:04 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 259AEFEC; Sun, 1 Mar 2020 19:22:59 -0800 (PST) Received: from [10.163.1.119] (unknown [10.163.1.119]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BBB5D3F6CF; Sun, 1 Mar 2020 19:22:50 -0800 (PST) From: Anshuman Khandual Subject: Re: [PATCH] mm/debug: Add tests validating arch page table helpers for core features To: Christophe Leroy , linux-mm@kvack.org References: <1582799637-11786-1-git-send-email-anshuman.khandual@arm.com> <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Message-ID: <4343eda9-7df2-a13c-0125-cf784c81ce14@arm.com> Date: Mon, 2 Mar 2020 08:52:52 +0530 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200301_192302_335624_0FC3D4C9 X-CRM114-Status: GOOD ( 26.21 ) 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, 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 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 T24gMDIvMjcvMjAyMCAwNDo1OSBQTSwgQ2hyaXN0b3BoZSBMZXJveSB3cm90ZToKPiAKPiAKPiBM ZSAyNy8wMi8yMDIwIMOgIDExOjMzLCBBbnNodW1hbiBLaGFuZHVhbCBhIMOpY3JpdMKgOgo+PiBU aGlzIGFkZHMgbmV3IHRlc3RzIHZhbGlkYXRpbmcgYXJjaCBwYWdlIHRhYmxlIGhlbHBlcnMgZm9y IHRoZXNlIGZvbGxvd2luZwo+PiBjb3JlIG1lbW9yeSBmZWF0dXJlcy4gVGhlc2UgdGVzdHMgY3Jl YXRlIGFuZCB0ZXN0IHNwZWNpZmljIG1hcHBpbmcgdHlwZXMgYXQKPj4gdmFyaW91cyBwYWdlIHRh YmxlIGxldmVscy4KPj4KPj4gKiBTUEVDSUFMIG1hcHBpbmcKPj4gKiBQUk9UTk9ORSBtYXBwaW5n Cj4+ICogREVWTUFQIG1hcHBpbmcKPj4gKiBTT0ZURElSVFkgbWFwcGluZwo+PiAqIFNXQVAgbWFw cGluZwo+PiAqIE1JR1JBVElPTiBtYXBwaW5nCj4+ICogSFVHRVRMQiBtYXBwaW5nCj4+ICogVEhQ IG1hcHBpbmcKPj4KPj4gQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRhdGlvbi5v cmc+Cj4+IENjOiBNaWtlIFJhcG9wb3J0IDxycHB0QGxpbnV4LmlibS5jb20+Cj4+IENjOiBWaW5l ZXQgR3VwdGEgPHZndXB0YUBzeW5vcHN5cy5jb20+Cj4+IENjOiBDYXRhbGluIE1hcmluYXMgPGNh dGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+PiBDYzogV2lsbCBEZWFjb24gPHdpbGxAa2VybmVsLm9y Zz4KPj4gQ2M6IEJlbmphbWluIEhlcnJlbnNjaG1pZHQgPGJlbmhAa2VybmVsLmNyYXNoaW5nLm9y Zz4KPj4gQ2M6IFBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgo+PiBDYzogTWljaGFl bCBFbGxlcm1hbiA8bXBlQGVsbGVybWFuLmlkLmF1Pgo+PiBDYzogSGVpa28gQ2Fyc3RlbnMgPGhl aWtvLmNhcnN0ZW5zQGRlLmlibS5jb20+Cj4+IENjOiBWYXNpbHkgR29yYmlrIDxnb3JAbGludXgu aWJtLmNvbT4KPj4gQ2M6IENocmlzdGlhbiBCb3JudHJhZWdlciA8Ym9ybnRyYWVnZXJAZGUuaWJt LmNvbT4KPj4gQ2M6IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgo+PiBDYzog SW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+Cj4+IENjOiBCb3Jpc2xhdiBQZXRrb3YgPGJw QGFsaWVuOC5kZT4KPj4gQ2M6ICJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5jb20+Cj4+IENj OiBLaXJpbGwgQS4gU2h1dGVtb3YgPGtpcmlsbEBzaHV0ZW1vdi5uYW1lPgo+PiBDYzogUGF1bCBX YWxtc2xleSA8cGF1bC53YWxtc2xleUBzaWZpdmUuY29tPgo+PiBDYzogUGFsbWVyIERhYmJlbHQg PHBhbG1lckBkYWJiZWx0LmNvbT4KPj4gQ2M6IGxpbnV4LXNucHMtYXJjQGxpc3RzLmluZnJhZGVh ZC5vcmcKPj4gQ2M6IGxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwo+PiBDYzog bGludXhwcGMtZGV2QGxpc3RzLm96bGFicy5vcmcKPj4gQ2M6IGxpbnV4LXMzOTBAdmdlci5rZXJu ZWwub3JnCj4+IENjOiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCj4+IENjOiB4ODZA a2VybmVsLm9yZwo+PiBDYzogbGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGxpbnV4 LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gU3VnZ2VzdGVkLWJ5OiBDYXRhbGluIE1hcmluYXMg PGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+PiBTaWduZWQtb2ZmLWJ5OiBBbnNodW1hbiBLaGFu ZHVhbCA8YW5zaHVtYW4ua2hhbmR1YWxAYXJtLmNvbT4KPj4gLS0tCj4+IFRlc3RlZCBvbiBhcm02 NCBhbmQgeDg2IHBsYXRmb3JtcyB3aXRob3V0IGFueSB0ZXN0IGZhaWx1cmVzLiBCdXQgdGhpcyBo YXMKPj4gb25seSBiZWVuIGJ1aWx0IHRlc3RlZCBvbiBzZXZlcmFsIG90aGVyIHBsYXRmb3Jtcy4g SW5kaXZpZHVhbCB0ZXN0cyBuZWVkCj4+IHRvIGJlIHZlcmlmaWVkIG9uIGFsbCBjdXJyZW50IGVu YWJsaW5nIHBsYXRmb3JtcyBmb3IgdGhlIHRlc3QgaS5lIHMzOTAsCj4+IHBwYzMyLCBhcmMgZXRj Lgo+Pgo+PiBUaGlzIHBhdGNoIG11c3QgYmUgYXBwbGllZCBvbiB2NS42LXJjMyBhZnRlciB0aGVz ZSBwYXRjaGVzCj4+Cj4+IDEuIGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTEz ODUwNTcvCj4+IDIuIGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTE0MDc3MTUv Cj4+Cj4+IE9SCj4+Cj4+IFRoaXMgcGF0Y2ggbXVzdCBiZSBhcHBsaWVkIG9uIGxpbnV4LW5leHQg KG5leHQtMjAyMDAyMjcpIGFmdGVyIHRoaXMgcGF0Y2gKPj4KPj4gMi4gaHR0cHM6Ly9wYXRjaHdv cmsua2VybmVsLm9yZy9wYXRjaC8xMTQwNzcxNS8KPj4KPj4gwqAgbW0vZGVidWdfdm1fcGd0YWJs ZS5jIHwgMzEwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+PiDC oCAxIGZpbGUgY2hhbmdlZCwgMzA5IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPj4KPj4g ZGlmZiAtLWdpdCBhL21tL2RlYnVnX3ZtX3BndGFibGUuYyBiL21tL2RlYnVnX3ZtX3BndGFibGUu Ywo+PiBpbmRleCA5NmRkN2Q1NzRjZWYuLjNmYjkwZDViNjA0ZSAxMDA2NDQKPj4gLS0tIGEvbW0v ZGVidWdfdm1fcGd0YWJsZS5jCj4+ICsrKyBiL21tL2RlYnVnX3ZtX3BndGFibGUuYwo+PiBAQCAt NDEsNiArNDEsNDQgQEAKPj4gwqDCoCAqIHdycHJvdGVjdChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IEEgd3JpdGUgcHJvdGVjdGVkIGFuZCBub3QgYSB3cml0ZSBlbnRyeQo+PiDCoMKgICogcHh4X2Jh ZChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IEEgbWFwcGVkIGFuZCBub24tdGFibGUgZW50cnkKPj4g wqDCoCAqIHB4eF9zYW1lKGVudHJ5MSwgZW50cnkyKcKgwqDCoCA9IEJvdGggZW50cmllcyBob2xk IHRoZSBleGFjdCBzYW1lIHZhbHVlCj4+ICsgKgo+PiArICogU3BlY2lmaWMgZmVhdHVyZSBvcGVy YXRpb25zCj4+ICsgKgo+PiArICogcHRlX21rc3BlY2lhbChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IENyZWF0ZXMgYSBzcGVjaWFsIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcHRlX3NwZWNpYWwo ZW50cnkpwqDCoMKgwqDCoMKgwqAgPSBUZXN0cyBhIHNwZWNpYWwgZW50cnkgYXQgUFRFIGxldmVs Cj4+ICsgKgo+PiArICogcHRlX3Byb3Rub25lKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVzdHMg YSBubyBhY2Nlc3MgZW50cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfcHJvdG5vbmUoZW50cnkp wqDCoMKgwqDCoMKgwqAgPSBUZXN0cyBhIG5vIGFjY2VzcyBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4g KyAqCj4+ICsgKiBwdGVfbWtkZXZtYXAoZW50cnkpwqDCoMKgwqDCoMKgwqAgPSBDcmVhdGVzIGEg ZGV2aWNlIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcG1kX21rZGV2bWFwKGVudHJ5KcKgwqDC oMKgwqDCoMKgID0gQ3JlYXRlcyBhIGRldmljZSBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB1 ZF9ta2Rldm1hcChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IENyZWF0ZXMgYSBkZXZpY2UgZW50cnkg YXQgUFVEIGxldmVsCj4+ICsgKiBwdGVfZGV2bWFwKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVz dHMgYSBkZXZpY2UgZW50cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfZGV2bWFwKGVudHJ5KcKg wqDCoMKgwqDCoMKgID0gVGVzdHMgYSBkZXZpY2UgZW50cnkgYXQgUE1EIGxldmVsCj4+ICsgKiBw dWRfZGV2bWFwKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVzdHMgYSBkZXZpY2UgZW50cnkgYXQg UFVEIGxldmVsCj4+ICsgKgo+PiArICogcHRlX21rc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBD cmVhdGVzIGEgc29mdCBkaXJ0eSBlbnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9ta3NvZnRf ZGlydHkoZW50cnkpwqDCoMKgID0gQ3JlYXRlcyBhIHNvZnQgZGlydHkgZW50cnkgYXQgUE1EIGxl dmVsCj4+ICsgKiBwdGVfc3dwX21rc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBDcmVhdGVzIGEg c29mdCBkaXJ0eSBzd2FwIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcG1kX3N3cF9ta3NvZnRf ZGlydHkoZW50cnkpwqDCoMKgID0gQ3JlYXRlcyBhIHNvZnQgZGlydHkgc3dhcCBlbnRyeSBhdCBQ TUQgbGV2ZWwKPj4gKyAqIHB0ZV9zb2Z0X2RpcnR5KGVudHJ5KcKgwqDCoCA9IFRlc3RzIGEgc29m dCBkaXJ0eSBlbnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zb2Z0X2RpcnR5KGVudHJ5KcKg wqDCoCA9IFRlc3RzIGEgc29mdCBkaXJ0eSBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB0ZV9z d3Bfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBUZXN0cyBhIHNvZnQgZGlydHkgc3dhcCBlbnRy eSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zd3Bfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBU ZXN0cyBhIHNvZnQgZGlydHkgc3dhcCBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB0ZV9jbGVh cl9zb2Z0X2RpcnR5KGVudHJ5KcKgwqDCoMKgwqDCoCA9IENsZWFycyBhIHNvZnQgZGlydHkgZW50 cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfY2xlYXJfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqDC oMKgwqAgPSBDbGVhcnMgYSBzb2Z0IGRpcnR5IGVudHJ5IGF0IFBNRCBsZXZlbAo+PiArICogcHRl X3N3cF9jbGVhcl9zb2Z0X2RpcnR5KGVudHJ5KSA9IENsZWFycyBhIHNvZnQgZGlydHkgc3dhcCBl bnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zd3BfY2xlYXJfc29mdF9kaXJ0eShlbnRyeSkg PSBDbGVhcnMgYSBzb2Z0IGRpcnR5IHN3YXAgZW50cnkgYXQgUE1EIGxldmVsCj4+ICsgKgo+PiAr ICogcHRlX21raHVnZShlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IENyZWF0ZXMgYSBIdWdlVExCIGVu dHJ5IGF0IGdpdmVuIGxldmVsCj4+ICsgKiBwdGVfaHVnZShlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IFRlc3RzIGEgSHVnZVRMQiBlbnRyeSBhdCBnaXZlbiBsZXZlbAo+PiArICoKPj4gKyAqIHBtZF90 cmFuc19odWdlKGVudHJ5KcKgwqDCoCA9IFRlc3RzIGEgdHJhbnMgaHVnZSBwYWdlIGF0IFBNRCBs ZXZlbAo+PiArICogcHVkX3RyYW5zX2h1Z2UoZW50cnkpwqDCoMKgID0gVGVzdHMgYSB0cmFucyBo dWdlIHBhZ2UgYXQgUFVEIGxldmVsCj4+ICsgKiBwbWRfcHJlc2VudChlbnRyeSnCoMKgwqDCoMKg wqDCoCA9IFRlc3RzIGFuIGVudHJ5IHBvaW50cyB0byBtZW1vcnkgYXQgUE1EIGxldmVsCj4+ICsg KiBwdWRfcHJlc2VudChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IFRlc3RzIGFuIGVudHJ5IHBvaW50 cyB0byBtZW1vcnkgYXQgUFVEIGxldmVsCj4+ICsgKiBwbWRfbWtub3RwcmVzZW50KGVudHJ5KcKg wqDCoCA9IEludmFsaWRhdGVzIGFuIFBNRCBlbnRyeSBmb3IgTU1VCj4+ICsgKiBwdWRfbWtub3Rw cmVzZW50KGVudHJ5KcKgwqDCoCA9IEludmFsaWRhdGVzIGFuIFBVRCBlbnRyeSBmb3IgTU1VCj4+ IMKgwqAgKi8KPj4gwqAgI2RlZmluZSBWTUZMQUdTwqDCoMKgIChWTV9SRUFEfFZNX1dSSVRFfFZN X0VYRUMpCj4+IMKgIEBAIC0yODcsNiArMzI1LDIzMyBAQCBzdGF0aWMgdm9pZCBfX2luaXQgcG1k X3BvcHVsYXRlX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwbWRfdCAqcG1kcCwKPj4gwqDC oMKgwqDCoCBXQVJOX09OKHBtZF9iYWQocG1kKSk7Cj4+IMKgIH0KPj4gwqAgKyNpZmRlZiBDT05G SUdfQVJDSF9IQVNfUFRFX1NQRUNJQUwKPiAKPiBDYW4gd2UgYXZvaWQgaWZkZWZzIHVubGVzcyBu ZWNlc3NhcnkgPwo+IAo+IEluIG1tL21lbW9yeS5jIEkgc2VlIHRoaW5ncyBsaWtlIHRoZSBmb2xs b3dpbmcsIGl0IG1lYW5zIHB0ZV9zcGVjaWFsKCkgYWx3YXlzIGV4aXN0IGFuZCBhICNpZmRlZiBp cyBub3QgbmVjZXNzYXJ5LgoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2FuIGJlIGRyb3BwZWQgaGVyZSwg ZG9uZS4KCj4gCj4gwqDCoMKgwqBpZiAoSVNfRU5BQkxFRChDT05GSUdfQVJDSF9IQVNfUFRFX1NQ RUNJQUwpKSB7Cj4gwqDCoMKgwqDCoMKgwqAgaWYgKGxpa2VseSghcHRlX3NwZWNpYWwocHRlKSkp Cj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIGNoZWNrX3BmbjsKPiDCoMKgwqDCoMKgwqDC oCBpZiAodm1hLT52bV9vcHMgJiYgdm1hLT52bV9vcHMtPmZpbmRfc3BlY2lhbF9wYWdlKQo+IMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIHZtYS0+dm1fb3BzLT5maW5kX3NwZWNpYWxfcGFn ZSh2bWEsIGFkZHIpOwo+IMKgwqDCoMKgwqDCoMKgIGlmICh2bWEtPnZtX2ZsYWdzICYgKFZNX1BG Tk1BUCB8IFZNX01JWEVETUFQKSkKPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBOVUxM Owo+IMKgwqDCoMKgwqDCoMKgIGlmIChpc196ZXJvX3BmbihwZm4pKQo+IMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgcmV0dXJuIE5VTEw7Cj4gwqDCoMKgwqDCoMKgwqAgaWYgKHB0ZV9kZXZtYXAocHRl KSkKPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBOVUxMOwo+IAo+IMKgwqDCoMKgwqDC oMKgIHByaW50X2JhZF9wdGUodm1hLCBhZGRyLCBwdGUsIE5VTEwpOwo+IMKgwqDCoMKgwqDCoMKg IHJldHVybiBOVUxMOwo+IMKgwqDCoMKgfQo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHB0ZV9z cGVjaWFsX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiAr wqDCoMKgIHB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdB Uk5fT04oIXB0ZV9zcGVjaWFsKHB0ZV9ta3NwZWNpYWwocHRlKSkpOwo+PiArfQo+PiArI2Vsc2UK Pj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3BlY2lhbF90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkgeyB9Cj4+ICsjZW5kaWYKPj4gKwo+PiArI2lmZGVmIENPTkZJR19O VU1BX0JBTEFOQ0lORwo+IAo+IFNhbWUgaGVyZSwgdGhpcyBpZmRlZiBzaG91bGRuJ3QgYmUgbmVj ZXNzYXJ5IGJlY2F1c2UgaW4gL2luY2x1ZGUvYXNtLWdlbmVyaWMvcGd0YWJsZS5oIHdlIGhhdmUg dGhlIGZvbGxvd2luZywgc28gYSBpZiAoSVNfRU5BQkxFRCgpKSBzaG91bGQgYmUgZW5vdWdoLgo+ IAo+ICNpZm5kZWYgQ09ORklHX05VTUFfQkFMQU5DSU5HCj4gLyoKPiDCoCogVGVjaG5pY2FsbHkg YSBQVEUgY2FuIGJlIFBST1ROT05FIGV2ZW4gd2hlbiBub3QgZG9pbmcgTlVNQSBiYWxhbmNpbmcg YnV0Cj4gwqAqIHRoZSBvbmx5IGNhc2UgdGhlIGtlcm5lbCBjYXJlcyBpcyBmb3IgTlVNQSBiYWxh bmNpbmcgYW5kIGlzIG9ubHkgZXZlciBzZXQKPiDCoCogd2hlbiB0aGUgVk1BIGlzIGFjY2Vzc2li bGUuIEZvciBQUk9UX05PTkUgVk1BcywgdGhlIFBURXMgYXJlIG5vdCBtYXJrZWQKPiDCoCogX1BB R0VfUFJPVE5PTkUgc28gYnkgYnkgZGVmYXVsdCwgaW1wbGVtZW50IHRoZSBoZWxwZXIgYXMgImFs d2F5cyBubyIuIEl0Cj4gwqAqIGlzIHRoZSByZXNwb25zaWJpbGl0eSBvZiB0aGUgY2FsbGVyIHRv IGRpc3Rpbmd1aXNoIGJldHdlZW4gUFJPVF9OT05FCj4gwqAqIHByb3RlY3Rpb25zIGFuZCBOVU1B IGhpbnRpbmcgZmF1bHQgcHJvdGVjdGlvbnMuCj4gwqAqLwo+IHN0YXRpYyBpbmxpbmUgaW50IHB0 ZV9wcm90bm9uZShwdGVfdCBwdGUpCj4gewo+IMKgwqDCoMKgcmV0dXJuIDA7Cj4gfQo+IAo+IHN0 YXRpYyBpbmxpbmUgaW50IHBtZF9wcm90bm9uZShwbWRfdCBwbWQpCj4gewo+IMKgwqDCoMKgcmV0 dXJuIDA7Cj4gfQo+ICNlbmRpZiAvKiBDT05GSUdfTlVNQV9CQUxBTkNJTkcgKi8KClRydWUsICAj aWZkZWYgaGVyZSBjYW4gYmUgZHJvcHBlZCwgZG9uZS4gVGhlcmUgaXMgc29tZXRoaW5nIEkgaGFk IG1pc3NlZApiZWZvcmUsIHBmbl9wbWQoKSByZXF1aXJlcyAjaWZkZWYgQ09ORklHX1RSQU5TUEFS RU5UX0hVR0VQQUdFIGluc3RlYWQuIFdlCm5lZWQgYSBwbWRfdCBoZXJlIHdpdGggZ2l2ZW4gcHJv dC4gV2UgY2Fubm90IGdvIHZpYSBwZm5fcHRlKCkgZm9sbG93ZWQgYnkKcHRlX3BtZCgpLCBhcyB0 aGUgbGF0ZXIgaXMgcGxhdGZvcm0gc3BlY2lmaWMgYW5kIG5vdCBhdmFpbGFibGUgaW4gZ2VuZXJh bC4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHRlX3Byb3Rub25lX3Rlc3RzKHVuc2lnbmVk IGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHB0ZV90IHB0ZSA9IHBm bl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXB0ZV9wcm90bm9uZShw dGUpKTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwdGVfcHJlc2VudChwdGUpKTsKPj4gK30KPj4gKwo+ PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9wcm90bm9uZV90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwbWRfdCBwbWQgPSBwZm5fcG1kKHBm biwgcHJvdCk7Cj4+ICsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfcHJvdG5vbmUocG1kKSk7Cj4+ ICvCoMKgwqAgV0FSTl9PTighcG1kX3ByZXNlbnQocG1kKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiAr c3RhdGljIHZvaWQgX19pbml0IHB0ZV9wcm90bm9uZV90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwg cGdwcm90X3QgcHJvdCkgeyB9Cj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcG1kX3Byb3Rub25lX3Rl c3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gKyNlbmRpZgo+PiAr Cj4+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1BURV9ERVZNQVAKPiAKPiBTYW1lIGhlcmUsIGlu IGluY2x1ZGUvbGludXgvbW0uaCB3ZSBoYXZlOgo+IAo+ICNpZm5kZWYgQ09ORklHX0FSQ0hfSEFT X1BURV9ERVZNQVAKPiBzdGF0aWMgaW5saW5lIGludCBwdGVfZGV2bWFwKHB0ZV90IHB0ZSkKPiB7 Cj4gwqDCoMKgwqByZXR1cm4gMDsKPiB9Cj4gI2VuZGlmCj4gCj4gCj4+ICtzdGF0aWMgdm9pZCBf X2luaXQgcHRlX2Rldm1hcF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkK Pj4gK3sKPj4gK8KgwqDCoCBwdGVfdCBwdGUgPSBwZm5fcHRlKHBmbiwgcHJvdCk7Cj4+ICsKPj4g K8KgwqDCoCBXQVJOX09OKCFwdGVfZGV2bWFwKHB0ZV9ta2Rldm1hcChwdGUpKSk7Cj4+ICt9Cj4+ ICsKPj4gKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKPiAKPiBTYW1lLiBJbiBp bmx1ZGUvYXNtLWdlbmVyaWMvcGd0YWJsZXMuaCB5b3UgaGF2ZToKPiAKPiAjaWYgIWRlZmluZWQo Q09ORklHX0FSQ0hfSEFTX1BURV9ERVZNQVApIHx8ICFkZWZpbmVkKENPTkZJR19UUkFOU1BBUkVO VF9IVUdFUEFHRSkKPiBzdGF0aWMgaW5saW5lIGludCBwbWRfZGV2bWFwKHBtZF90IHBtZCkKPiB7 Cj4gwqDCoMKgwqByZXR1cm4gMDsKPiB9Cj4gc3RhdGljIGlubGluZSBpbnQgcHVkX2Rldm1hcChw dWRfdCBwdWQpCj4gewo+IMKgwqDCoMKgcmV0dXJuIDA7Cj4gfQo+IHN0YXRpYyBpbmxpbmUgaW50 IHBnZF9kZXZtYXAocGdkX3QgcGdkKQo+IHsKPiDCoMKgwqDCoHJldHVybiAwOwo+IH0KPiAjZW5k aWYKPiAKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxv bmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHBtZF90IHBtZCA9IHBmbl9w bWQocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXBtZF9kZXZtYXAocG1kX21r ZGV2bWFwKHBtZCkpKTsKPj4gK30KPj4gKwo+PiArI2lmZGVmIENPTkZJR19IQVZFX0FSQ0hfVFJB TlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gCj4gU2FtZSwgc2VlIGFib3ZlCgpFdmVuIHRob3VnaCBw eHhfZGV2bWFwKCkgZmFsbGJhY2sgZGVmaW5pdGlvbnMgYXJlIHByZXNlbnQsIHB4eF9ta2Rldm1h cCgpCm9uZXMgYXJlIHN0aWxsIG1pc3NpbmcuIFdlIHdpbGwgaGF2ZSB0byBhZGQgdGhlbSBmaXJz dCBhcyBhIHByZS1yZXF1aXNpdGUKcGF0Y2ggKHdoaWNoIG1pZ2h0IG5vdCBiZSBwb3B1bGFyIHdp dGhvdXQgYW55IG5vbi1kZWJ1ZyB1c2UgY2FzZSkgaW4gb3JkZXIKdG8gZHJvcCB0aGVzZSAjaWZk ZWZzIGhlcmUuCgo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHB1ZF9kZXZtYXBfdGVzdHModW5z aWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4+ICt7Cj4+ICvCoMKgwqAgcHVkX3QgcHVk ID0gcGZuX3B1ZChwZm4sIHByb3QpOwo+PiArCj4+ICvCoMKgwqAgV0FSTl9PTighcHVkX2Rldm1h cChwdWRfbWtkZXZtYXAocHVkKSkpOwo+PiArfQo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7 IH0KPj4gKyNlbmRpZgo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFw X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2 b2lkIF9faW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KSB7IH0KPj4gKyNlbmRpZgo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVf ZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3By b3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVu c2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gKyNlbmRpZgo+PiArCj4+ICsj aWZkZWYgQ09ORklHX01FTV9TT0ZUX0RJUlRZCj4gCj4gU2FtZSwgdGhleSBhbHdheXMgZXhpc3Qs IHNlZSBpbmNsdWRlL2FzbS1nZW5lcmljL3BndGFibGUuaAoKWWVhaCwgdGhpcyBjYW4gYmUgZHJv cHBlZC4gVGhvdWdoIHdpbGwgaGF2ZSB0byBhZ2FpbiBhZGQgVFJBTlNQQVJFTlRfSFVHRVBBR0UK dG8gcHJvdGVjdCBwZm5fcG1kKCkgYXMgZXhwbGFpbmVkIGJlZm9yZS4KCj4gCj4+ICtzdGF0aWMg dm9pZCBfX2luaXQgcHRlX3NvZnRfZGlydHlfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpCj4+ICt7Cj4+ICvCoMKgwqAgcHRlX3QgcHRlID0gcGZuX3B0ZShwZm4sIHByb3Qp Owo+PiArCj4+ICvCoMKgwqAgV0FSTl9PTighcHRlX3NvZnRfZGlydHkocHRlX21rc29mdF9kaXJ0 eShwdGUpKSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwdGVfc29mdF9kaXJ0eShwdGVfY2xlYXJfc29m dF9kaXJ0eShwdGUpKSk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3dh cF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiAr ewo+PiArwqDCoMKgIHB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDC oMKgIFdBUk5fT04oIXB0ZV9zd3Bfc29mdF9kaXJ0eShwdGVfc3dwX21rc29mdF9kaXJ0eShwdGUp KSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwdGVfc3dwX3NvZnRfZGlydHkocHRlX3N3cF9jbGVhcl9z b2Z0X2RpcnR5KHB0ZSkpKTsKPj4gK30KPj4gKwo+PiArI2lmZGVmIENPTkZJR19BUkNIX0VOQUJM RV9USFBfTUlHUkFUSU9OCj4gCj4gU2FtZQoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2FuIGJlIGRyb3Bw ZWQsIGRvbmUuCgo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9zb2Z0X2RpcnR5X3Rlc3Rz KHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHBtZF90 IHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXBtZF9z b2Z0X2RpcnR5KHBtZF9ta3NvZnRfZGlydHkocG1kKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocG1k X3NvZnRfZGlydHkocG1kX2NsZWFyX3NvZnRfZGlydHkocG1kKSkpOwo+PiArfQo+PiArCj4+ICtz dGF0aWMgdm9pZCBfX2luaXQgcG1kX3N3YXBfc29mdF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25n IHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwbWRfdCBwbWQgPSBwZm5fcG1k KHBmbiwgcHJvdCk7Cj4+ICsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfc3dwX3NvZnRfZGlydHko cG1kX3N3cF9ta3NvZnRfZGlydHkocG1kKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocG1kX3N3cF9z b2Z0X2RpcnR5KHBtZF9zd3BfY2xlYXJfc29mdF9kaXJ0eShwbWQpKSk7Cj4+ICt9Cj4+ICsjZWxz ZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxv bmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc3dh cF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiAr ewo+PiArfQo+PiArI2VuZGlmCj4+ICsjZWxzZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHB0ZV9z b2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4g K3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc29mdF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkgeyB9Cj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHRlX3N3YXBfc29m dF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4g K30KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc3dhcF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArfQo+PiArI2VuZGlmCj4+ICsK Pj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3dhcF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwg cGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBzd3BfZW50cnlfdCBzd3A7Cj4+ICvCoMKg wqAgcHRlX3QgcHRlOwo+PiArCj4+ICvCoMKgwqAgcHRlID0gcGZuX3B0ZShwZm4sIHByb3QpOwo+ PiArwqDCoMKgIHN3cCA9IF9fcHRlX3RvX3N3cF9lbnRyeShwdGUpOwo+PiArwqDCoMKgIFdBUk5f T04oIXB0ZV9zYW1lKHB0ZSwgX19zd3BfZW50cnlfdG9fcHRlKHN3cCkpKTsKPj4gK30KPj4gKwo+ PiArI2lmZGVmIENPTkZJR19BUkNIX0VOQUJMRV9USFBfTUlHUkFUSU9OCj4+ICtzdGF0aWMgdm9p ZCBfX2luaXQgcG1kX3N3YXBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3Qp Cj4+ICt7Cj4+ICvCoMKgwqAgc3dwX2VudHJ5X3Qgc3dwOwo+PiArwqDCoMKgIHBtZF90IHBtZDsK Pj4gKwo+PiArwqDCoMKgIHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gK8KgwqDCoCBzd3Ag PSBfX3BtZF90b19zd3BfZW50cnkocG1kKTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfc2FtZShw bWQsIF9fc3dwX2VudHJ5X3RvX3BtZChzd3ApKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHBtZF9zd2FwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KSB7IH0KPj4gKyNlbmRpZgo+PiArCj4+ICsjaWZkZWYgQ09ORklHX01JR1JBVElPTgo+IAo+ IFNhbWUuIFNlZSBpbmNsdWRlL2xpbnV4L3N3YXBvcHMuaAoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2Fu IGJlIGRyb3BwZWQsIGRvbmUuIFRob3VnaCB3aWxsIGhhdmUgdG8gYWdhaW4gYWRkCmJhY2sgVFJB TlNQQVJFTlRfSFVHRVBBR0UgdG8gcHJvdGVjdCBwZm5fcG1kKCkgYXMgZXhwbGFpbmVkIGJlZm9y ZS4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgc3dhcF9taWdyYXRpb25fdGVzdHMoc3RydWN0 IHBhZ2UgKnBhZ2UpCj4+ICt7Cj4+ICvCoMKgwqAgc3dwX2VudHJ5X3Qgc3dwOwo+PiArCj4+ICvC oMKgwqAgLyoKPj4gK8KgwqDCoMKgICogbWFrZV9taWdyYXRpb25fZW50cnkoKSBleHBlY3RzIGdp dmVuIHBhZ2UgdG8gYmUKPj4gK8KgwqDCoMKgICogbG9ja2VkLCBvdGhlcndpc2UgaXQgc3R1bWJs ZXMgdXBvbiBhIEJVR19PTigpLgo+PiArwqDCoMKgwqAgKi8KPj4gK8KgwqDCoCBfX1NldFBhZ2VM b2NrZWQocGFnZSk7Cj4+ICvCoMKgwqAgc3dwID0gbWFrZV9taWdyYXRpb25fZW50cnkocGFnZSwg MSk7Cj4+ICvCoMKgwqAgV0FSTl9PTighaXNfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArwqDC oMKgIFdBUk5fT04oIWlzX3dyaXRlX21pZ3JhdGlvbl9lbnRyeShzd3ApKTsKPj4gKwo+PiArwqDC oMKgIG1ha2VfbWlncmF0aW9uX2VudHJ5X3JlYWQoJnN3cCk7Cj4+ICvCoMKgwqAgV0FSTl9PTigh aXNfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArwqDCoMKgIFdBUk5fT04oaXNfd3JpdGVfbWln cmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArCj4+ICvCoMKgwqAgc3dwID0gbWFrZV9taWdyYXRpb25f ZW50cnkocGFnZSwgMCk7Cj4+ICvCoMKgwqAgV0FSTl9PTighaXNfbWlncmF0aW9uX2VudHJ5KHN3 cCkpOwo+PiArwqDCoMKgIFdBUk5fT04oaXNfd3JpdGVfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+ PiArwqDCoMKgIF9fQ2xlYXJQYWdlTG9ja2VkKHBhZ2UpOwo+PiArfQo+PiArI2Vsc2UKPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBzd2FwX21pZ3JhdGlvbl90ZXN0cyhzdHJ1Y3QgcGFnZSAqcGFnZSkg eyB9Cj4+ICsjZW5kaWYKPj4gKwo+PiArI2lmZGVmIENPTkZJR19IVUdFVExCX1BBR0UKPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBodWdldGxiX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3Rf dCBwcm90KQo+PiArewo+PiArI2lmZGVmIENPTkZJR19BUkNIX1dBTlRfR0VORVJBTF9IVUdFVExC Cj4+ICvCoMKgwqAgcHRlX3QgcHRlID0gcGZuX3B0ZShwZm4sIHByb3QpOwo+PiArCj4+ICvCoMKg wqAgV0FSTl9PTighcHRlX2h1Z2UocHRlX21raHVnZShwdGUpKSk7Cj4gCj4gV2UgYWxzbyBuZWVk IHRlc3RzIG9uIGh1Z2VwZCBzdHVmZgoKU3VyZSwgYnV0IGxldHMgZGlzY3VzcyB0aGlzIG9uIHRo ZSBvdGhlciB0aHJlYWQuCgo+IAo+PiArI2VuZGlmCj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IGh1Z2V0bGJfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsKPj4gKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVH RVBBR0UKPiAKPiBTYW1lLCBzZWUgaW5jbHVkZS9hc20tZ2VuZXJpYy9wZ3RhYmxlLmgKClRoaXMg aXMgcmVxdWlyZWQgdG8gcHJvdGVjdCBweHhfbWtub3RwcmVzZW50KCkgd2hpY2ggZG9lcyBub3Qg aGF2ZSBhCmZhbGwgYmFjayBhbmQgcGZuX3BtZCgpL3Bmbl9wdWQoKSBoZWxwZXJzIGhhdmUgc2lt aWxhciBzaXR1YXRpb24gYXMKd2VsbC4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcG1kX3Ro cF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDC oCBwbWRfdCBwbWQ7Cj4+ICsKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBwbWRfdHJhbnNf aHVnZSgpIGFuZCBwbWRfcHJlc2VudCgpIG11c3QgcmV0dXJuIG5lZ2F0aXZlCj4+ICvCoMKgwqDC oCAqIGFmdGVyIE1NVSBpbnZhbGlkYXRpb24gd2l0aCBwbWRfbWtub3RwcmVzZW50KCkuCj4+ICvC oMKgwqDCoCAqLwo+PiArwqDCoMKgIHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gK8KgwqDC oCBXQVJOX09OKCFwbWRfdHJhbnNfaHVnZShwbWRfbWtodWdlKHBtZCkpKTsKPj4gKwo+PiArwqDC oMKgIC8qCj4+ICvCoMKgwqDCoCAqIFRob3VnaCBwbGF0Zm9ybSBzcGVjaWZpYyB0ZXN0IGV4Y2x1 c2lvbnMgYXJlIG5vdCBpZGVhbCwKPj4gK8KgwqDCoMKgICogaW4gdGhpcyBjYXNlIFMzOTAgZG9l cyBub3QgZGVmaW5lIHBtZF9ta25vdHByZXNlbnQoKQo+PiArwqDCoMKgwqAgKiB3aGljaCBzaG91 bGQgYmUgdGVzdGVkIG9uIG90aGVyIHBsYXRmb3JtcyBlbmFibGluZyBUSFAuCj4+ICvCoMKgwqDC oCAqLwo+PiArI2lmbmRlZiBDT05GSUdfUzM5MAo+PiArwqDCoMKgIFdBUk5fT04ocG1kX3RyYW5z X2h1Z2UocG1kX21rbm90cHJlc2VudChwbWQpKSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwbWRfcHJl c2VudChwbWRfbWtub3RwcmVzZW50KHBtZCkpKTsKPj4gKyNlbmRpZgo+IAo+IENhbiB3ZSBhZGQg YSBzdHViIG9uIFMzOTAgaW5zdGVhZCA/CgpBY3R1YWxseSB3ZSBkb250IGhhdmUgdG8uIHBtZF9t a25vdHByZXNlbnQoKSBpcyByZXF1aXJlZCBmb3IgcGxhdGZvcm1zCnRoYXQgZG8gbm90IGhhdmUg X19IQVZFX0FSQ0hfUE1EUF9JTlZBTElEQVRFLiBIZW5jZSBjYW4gd3JhcCB0aGlzIGNvZGUKd2l0 aCAhX19IQVZFX0FSQ0hfUE1EUF9JTlZBTElEQVRFIHRvIHByZXZlbnQgYnVpbGQgZmFpbHVyZXMg b24gc3VjaApwbGF0Zm9ybXMgbGlrZSBzMzkwLgoKPiAKPj4gK30KPj4gKwo+PiArI2lmZGVmIENP TkZJR19IQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gCj4gU2FtZSA/CgpUaGUg cHJvYmxlbSBpcywgbmVpdGhlciBwdWRfbWtub3RwcmVzZW50KCkgbm9yIHBmbl9wdWQoKSBoYXZl IGEgZ2VuZXJpYwpmYWxsYmFjayBkZWZpbml0aW9uLiBTbyB3aWxsIGhhdmUgdG8ga2VlcCB0aGlz ICNpZmRlZi4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX3RocF90ZXN0cyh1bnNpZ25l ZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwdWRfdCBwdWQ7Cj4+ ICsKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBwdWRfdHJhbnNfaHVnZSgpIGFuZCBwdWRf cHJlc2VudCgpIG11c3QgcmV0dXJuIG5lZ2F0aXZlCj4+ICvCoMKgwqDCoCAqIGFmdGVyIE1NVSBp bnZhbGlkYXRpb24gd2l0aCBwdWRfbWtub3RwcmVzZW50KCkuCj4+ICvCoMKgwqDCoCAqLwo+PiAr wqDCoMKgIHB1ZCA9IHBmbl9wdWQocGZuLCBwcm90KTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwdWRf dHJhbnNfaHVnZShwdWRfbWtodWdlKHB1ZCkpKTsKPj4gK8KgwqDCoCBXQVJOX09OKHB1ZF90cmFu c19odWdlKHB1ZF9ta25vdHByZXNlbnQocHVkKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocHVkX3By ZXNlbnQocHVkX21rbm90cHJlc2VudChwdWQpKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHB1ZF90aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsjZWxzZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF90 aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpIHsgfQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHB1ZF90aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsKPj4gwqAgc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0 IGdldF9yYW5kb21fdmFkZHIodm9pZCkKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHVuc2lnbmVkIGxv bmcgcmFuZG9tX3ZhZGRyLCByYW5kb21fcGFnZXMsIHRvdGFsX3VzZXJfcGFnZXM7Cj4+IEBAIC0z MDIsMTMgKzU2NywxNCBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBfX2luaXQgZ2V0X3JhbmRvbV92 YWRkcih2b2lkKQo+PiDCoCB2b2lkIF9faW5pdCBkZWJ1Z192bV9wZ3RhYmxlKHZvaWQpCj4+IMKg IHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgbW1fc3RydWN0ICptbTsKPj4gK8KgwqDCoCBzdHJ1Y3Qg cGFnZSAqcGFnZTsKPj4gwqDCoMKgwqDCoCBwZ2RfdCAqcGdkcDsKPj4gwqDCoMKgwqDCoCBwNGRf dCAqcDRkcCwgKnNhdmVkX3A0ZHA7Cj4+IMKgwqDCoMKgwqAgcHVkX3QgKnB1ZHAsICpzYXZlZF9w dWRwOwo+PiDCoMKgwqDCoMKgIHBtZF90ICpwbWRwLCAqc2F2ZWRfcG1kcCwgcG1kOwo+PiDCoMKg wqDCoMKgIHB0ZV90ICpwdGVwOwo+PiDCoMKgwqDCoMKgIHBndGFibGVfdCBzYXZlZF9wdGVwOwo+ PiAtwqDCoMKgIHBncHJvdF90IHByb3Q7Cj4+ICvCoMKgwqAgcGdwcm90X3QgcHJvdCwgcHJvdG5v bmU7Cj4+IMKgwqDCoMKgwqAgcGh5c19hZGRyX3QgcGFkZHI7Cj4+IMKgwqDCoMKgwqAgdW5zaWdu ZWQgbG9uZyB2YWRkciwgcHRlX2FsaWduZWQsIHBtZF9hbGlnbmVkOwo+PiDCoMKgwqDCoMKgIHVu c2lnbmVkIGxvbmcgcHVkX2FsaWduZWQsIHA0ZF9hbGlnbmVkLCBwZ2RfYWxpZ25lZDsKPj4gQEAg LTMyMiw2ICs1ODgsMjUgQEAgdm9pZCBfX2luaXQgZGVidWdfdm1fcGd0YWJsZSh2b2lkKQo+PiDC oMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuOwo+PiDCoMKgwqDCoMKgIH0KPj4gwqAgK8KgwqDCoCAv Kgo+PiArwqDCoMKgwqAgKiBzd2FwX21pZ3JhdGlvbl90ZXN0cygpIHJlcXVpcmVzIGEgZGVkaWNh dGVkIHBhZ2UgYXMgaXQgbmVlZHMgdG8KPj4gK8KgwqDCoMKgICogYmUgbG9ja2VkIGJlZm9yZSBj cmVhdGluZyBhIG1pZ3JhdGlvbiBlbnRyeSBmcm9tIGl0LiBMb2NraW5nIHRoZQo+PiArwqDCoMKg wqAgKiBwYWdlIHRoYXQgYWN0dWFsbHkgbWFwcyBrZXJuZWwgdGV4dCAoJ3N0YXJ0X2tlcm5lbCcp IGNhbiBiZSByZWFsCj4+ICvCoMKgwqDCoCAqIHByb2JsZW1hdGljLiBMZXRzIGFsbG9jYXRlIGEg ZGVkaWNhdGVkIHBhZ2UgZXhwbGljaXRseSBmb3IgdGhpcwo+PiArwqDCoMKgwqAgKiBwdXJwb3Nl IHRoYXQgd2lsbCBiZSBmcmVlZCBsYXRlci4KPj4gK8KgwqDCoMKgICovCj4+ICvCoMKgwqAgcGFn ZSA9IGFsbG9jX3BhZ2UoR0ZQX0tFUk5FTCk7Cj4gCj4gQ2FuIHdlIGRvIHRoZSBwYWdlIGFsbG9j YXRpb24gYW5kIGZyZWVpbmcgaW4gc3dhcF9taWdyYXRpb25fdGVzdHMoKSBpbnN0ZWFkID8KCkFs dGhvdWdoIGFsbCB0aGUgcmVzb3VyY2VzIHVzZWQgaW4gdGhlIGhlbHBlcnMgaGF2ZSBiZWVuIGFs bG9jYXRlZCBpbiB0aGUgbWFpbgpmdW5jdGlvbiBpdHNlbGYgYmVmb3JlIGJlaW5nIHBhc3NlZCBk b3duIGFuZCBsYXRlciBmcmVlZC4gQnV0IG1heSBiZSBqdXN0IGFuCmV4Y2VwdGlvbiBjb3VsZCBi ZSBtYWRlIGZvciBzd2FwX21pZ3JhdGlvbl90ZXN0cygpIGZ1bmN0aW9uIGFzIHRoZSBhbGxvY2F0 ZWQKcGFnZSBpcyBiZWluZyBleGNsdXNpdmVseSB1c2VkIGhlcmUuIExhdGVyIG9uIGlmIHdlIG5l ZWQgdGhpcyBwYWdlIGZvciBzb21lCm90aGVyIGZ1dHVyZSB0ZXN0cywgdGhlbiB3aWxsIGhhdmUg dG8gbW92ZSBpdCBiYWNrIHRvIGRlYnVnX3ZtX3BndGFibGUoKS4KCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LXNucHMtYXJjIG1haWxpbmcgbGlz dApsaW51eC1zbnBzLWFyY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRl YWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtc25wcy1hcmMK 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_1 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 7D791C3F2D4 for ; Mon, 2 Mar 2020 03:23:07 +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 4E7C2246B6 for ; Mon, 2 Mar 2020 03:23:07 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="tJrzEwpQ" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 4E7C2246B6 Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=arm.com 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:In-Reply-To:MIME-Version:Date: Message-ID:References:To:Subject:From:Reply-To:Content-ID:Content-Description :Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=kLpczWWdH5s3DyJvY1r7khZGM7OPL/MnpfkEHfIHvfw=; b=tJrzEwpQciem1F na7z4G53oN+TUi1gT/lq9UM2CNa6WrWgz8EEElAArB5G267avaeufuNuXvdLF1lBz8/LLaL6+2sKD /OqcmeTf8sXgs/EXEOgGeNc3SmhEc4xD6/kCJ3Te7miLEEvOYjR52vxBKDeruRdi83h8CzOq9IlTV myMWXKIND0kP7bPDchps31/KTz/gBQs8aeuWwz72inuiEzTqzcMKBicROnOo4+/fl6OV+86+VIHAA AINaSYorYHEkXs+MxyHisaU5JqpT2p2jIY/CtY88xL0UzVQDSR+4nNGaDMczbX8qmFwB9IfYPJRfK YsF9QpelXkeGhwlW7I7A==; 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 1j8bfe-0000UO-RG; Mon, 02 Mar 2020 03:23:06 +0000 Received: from foss.arm.com ([217.140.110.172]) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1j8bfa-0000Ti-6Y; Mon, 02 Mar 2020 03:23:04 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 259AEFEC; Sun, 1 Mar 2020 19:22:59 -0800 (PST) Received: from [10.163.1.119] (unknown [10.163.1.119]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id BBB5D3F6CF; Sun, 1 Mar 2020 19:22:50 -0800 (PST) From: Anshuman Khandual Subject: Re: [PATCH] mm/debug: Add tests validating arch page table helpers for core features To: Christophe Leroy , linux-mm@kvack.org References: <1582799637-11786-1-git-send-email-anshuman.khandual@arm.com> <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Message-ID: <4343eda9-7df2-a13c-0125-cf784c81ce14@arm.com> Date: Mon, 2 Mar 2020 08:52:52 +0530 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.9.1 MIME-Version: 1.0 In-Reply-To: <2be41c29-500c-50af-f915-1493846ae9e5@c-s.fr> Content-Language: en-US X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200301_192302_335624_0FC3D4C9 X-CRM114-Status: GOOD ( 26.21 ) 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, 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 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 T24gMDIvMjcvMjAyMCAwNDo1OSBQTSwgQ2hyaXN0b3BoZSBMZXJveSB3cm90ZToKPiAKPiAKPiBM ZSAyNy8wMi8yMDIwIMOgIDExOjMzLCBBbnNodW1hbiBLaGFuZHVhbCBhIMOpY3JpdMKgOgo+PiBU aGlzIGFkZHMgbmV3IHRlc3RzIHZhbGlkYXRpbmcgYXJjaCBwYWdlIHRhYmxlIGhlbHBlcnMgZm9y IHRoZXNlIGZvbGxvd2luZwo+PiBjb3JlIG1lbW9yeSBmZWF0dXJlcy4gVGhlc2UgdGVzdHMgY3Jl YXRlIGFuZCB0ZXN0IHNwZWNpZmljIG1hcHBpbmcgdHlwZXMgYXQKPj4gdmFyaW91cyBwYWdlIHRh YmxlIGxldmVscy4KPj4KPj4gKiBTUEVDSUFMIG1hcHBpbmcKPj4gKiBQUk9UTk9ORSBtYXBwaW5n Cj4+ICogREVWTUFQIG1hcHBpbmcKPj4gKiBTT0ZURElSVFkgbWFwcGluZwo+PiAqIFNXQVAgbWFw cGluZwo+PiAqIE1JR1JBVElPTiBtYXBwaW5nCj4+ICogSFVHRVRMQiBtYXBwaW5nCj4+ICogVEhQ IG1hcHBpbmcKPj4KPj4gQ2M6IEFuZHJldyBNb3J0b24gPGFrcG1AbGludXgtZm91bmRhdGlvbi5v cmc+Cj4+IENjOiBNaWtlIFJhcG9wb3J0IDxycHB0QGxpbnV4LmlibS5jb20+Cj4+IENjOiBWaW5l ZXQgR3VwdGEgPHZndXB0YUBzeW5vcHN5cy5jb20+Cj4+IENjOiBDYXRhbGluIE1hcmluYXMgPGNh dGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+PiBDYzogV2lsbCBEZWFjb24gPHdpbGxAa2VybmVsLm9y Zz4KPj4gQ2M6IEJlbmphbWluIEhlcnJlbnNjaG1pZHQgPGJlbmhAa2VybmVsLmNyYXNoaW5nLm9y Zz4KPj4gQ2M6IFBhdWwgTWFja2VycmFzIDxwYXVsdXNAc2FtYmEub3JnPgo+PiBDYzogTWljaGFl bCBFbGxlcm1hbiA8bXBlQGVsbGVybWFuLmlkLmF1Pgo+PiBDYzogSGVpa28gQ2Fyc3RlbnMgPGhl aWtvLmNhcnN0ZW5zQGRlLmlibS5jb20+Cj4+IENjOiBWYXNpbHkgR29yYmlrIDxnb3JAbGludXgu aWJtLmNvbT4KPj4gQ2M6IENocmlzdGlhbiBCb3JudHJhZWdlciA8Ym9ybnRyYWVnZXJAZGUuaWJt LmNvbT4KPj4gQ2M6IFRob21hcyBHbGVpeG5lciA8dGdseEBsaW51dHJvbml4LmRlPgo+PiBDYzog SW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+Cj4+IENjOiBCb3Jpc2xhdiBQZXRrb3YgPGJw QGFsaWVuOC5kZT4KPj4gQ2M6ICJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5jb20+Cj4+IENj OiBLaXJpbGwgQS4gU2h1dGVtb3YgPGtpcmlsbEBzaHV0ZW1vdi5uYW1lPgo+PiBDYzogUGF1bCBX YWxtc2xleSA8cGF1bC53YWxtc2xleUBzaWZpdmUuY29tPgo+PiBDYzogUGFsbWVyIERhYmJlbHQg PHBhbG1lckBkYWJiZWx0LmNvbT4KPj4gQ2M6IGxpbnV4LXNucHMtYXJjQGxpc3RzLmluZnJhZGVh ZC5vcmcKPj4gQ2M6IGxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwo+PiBDYzog bGludXhwcGMtZGV2QGxpc3RzLm96bGFicy5vcmcKPj4gQ2M6IGxpbnV4LXMzOTBAdmdlci5rZXJu ZWwub3JnCj4+IENjOiBsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3JnCj4+IENjOiB4ODZA a2VybmVsLm9yZwo+PiBDYzogbGludXgtYXJjaEB2Z2VyLmtlcm5lbC5vcmcKPj4gQ2M6IGxpbnV4 LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmcKPj4gU3VnZ2VzdGVkLWJ5OiBDYXRhbGluIE1hcmluYXMg PGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29tPgo+PiBTaWduZWQtb2ZmLWJ5OiBBbnNodW1hbiBLaGFu ZHVhbCA8YW5zaHVtYW4ua2hhbmR1YWxAYXJtLmNvbT4KPj4gLS0tCj4+IFRlc3RlZCBvbiBhcm02 NCBhbmQgeDg2IHBsYXRmb3JtcyB3aXRob3V0IGFueSB0ZXN0IGZhaWx1cmVzLiBCdXQgdGhpcyBo YXMKPj4gb25seSBiZWVuIGJ1aWx0IHRlc3RlZCBvbiBzZXZlcmFsIG90aGVyIHBsYXRmb3Jtcy4g SW5kaXZpZHVhbCB0ZXN0cyBuZWVkCj4+IHRvIGJlIHZlcmlmaWVkIG9uIGFsbCBjdXJyZW50IGVu YWJsaW5nIHBsYXRmb3JtcyBmb3IgdGhlIHRlc3QgaS5lIHMzOTAsCj4+IHBwYzMyLCBhcmMgZXRj Lgo+Pgo+PiBUaGlzIHBhdGNoIG11c3QgYmUgYXBwbGllZCBvbiB2NS42LXJjMyBhZnRlciB0aGVz ZSBwYXRjaGVzCj4+Cj4+IDEuIGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTEz ODUwNTcvCj4+IDIuIGh0dHBzOi8vcGF0Y2h3b3JrLmtlcm5lbC5vcmcvcGF0Y2gvMTE0MDc3MTUv Cj4+Cj4+IE9SCj4+Cj4+IFRoaXMgcGF0Y2ggbXVzdCBiZSBhcHBsaWVkIG9uIGxpbnV4LW5leHQg KG5leHQtMjAyMDAyMjcpIGFmdGVyIHRoaXMgcGF0Y2gKPj4KPj4gMi4gaHR0cHM6Ly9wYXRjaHdv cmsua2VybmVsLm9yZy9wYXRjaC8xMTQwNzcxNS8KPj4KPj4gwqAgbW0vZGVidWdfdm1fcGd0YWJs ZS5jIHwgMzEwICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+PiDC oCAxIGZpbGUgY2hhbmdlZCwgMzA5IGluc2VydGlvbnMoKyksIDEgZGVsZXRpb24oLSkKPj4KPj4g ZGlmZiAtLWdpdCBhL21tL2RlYnVnX3ZtX3BndGFibGUuYyBiL21tL2RlYnVnX3ZtX3BndGFibGUu Ywo+PiBpbmRleCA5NmRkN2Q1NzRjZWYuLjNmYjkwZDViNjA0ZSAxMDA2NDQKPj4gLS0tIGEvbW0v ZGVidWdfdm1fcGd0YWJsZS5jCj4+ICsrKyBiL21tL2RlYnVnX3ZtX3BndGFibGUuYwo+PiBAQCAt NDEsNiArNDEsNDQgQEAKPj4gwqDCoCAqIHdycHJvdGVjdChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IEEgd3JpdGUgcHJvdGVjdGVkIGFuZCBub3QgYSB3cml0ZSBlbnRyeQo+PiDCoMKgICogcHh4X2Jh ZChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IEEgbWFwcGVkIGFuZCBub24tdGFibGUgZW50cnkKPj4g wqDCoCAqIHB4eF9zYW1lKGVudHJ5MSwgZW50cnkyKcKgwqDCoCA9IEJvdGggZW50cmllcyBob2xk IHRoZSBleGFjdCBzYW1lIHZhbHVlCj4+ICsgKgo+PiArICogU3BlY2lmaWMgZmVhdHVyZSBvcGVy YXRpb25zCj4+ICsgKgo+PiArICogcHRlX21rc3BlY2lhbChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IENyZWF0ZXMgYSBzcGVjaWFsIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcHRlX3NwZWNpYWwo ZW50cnkpwqDCoMKgwqDCoMKgwqAgPSBUZXN0cyBhIHNwZWNpYWwgZW50cnkgYXQgUFRFIGxldmVs Cj4+ICsgKgo+PiArICogcHRlX3Byb3Rub25lKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVzdHMg YSBubyBhY2Nlc3MgZW50cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfcHJvdG5vbmUoZW50cnkp wqDCoMKgwqDCoMKgwqAgPSBUZXN0cyBhIG5vIGFjY2VzcyBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4g KyAqCj4+ICsgKiBwdGVfbWtkZXZtYXAoZW50cnkpwqDCoMKgwqDCoMKgwqAgPSBDcmVhdGVzIGEg ZGV2aWNlIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcG1kX21rZGV2bWFwKGVudHJ5KcKgwqDC oMKgwqDCoMKgID0gQ3JlYXRlcyBhIGRldmljZSBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB1 ZF9ta2Rldm1hcChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IENyZWF0ZXMgYSBkZXZpY2UgZW50cnkg YXQgUFVEIGxldmVsCj4+ICsgKiBwdGVfZGV2bWFwKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVz dHMgYSBkZXZpY2UgZW50cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfZGV2bWFwKGVudHJ5KcKg wqDCoMKgwqDCoMKgID0gVGVzdHMgYSBkZXZpY2UgZW50cnkgYXQgUE1EIGxldmVsCj4+ICsgKiBw dWRfZGV2bWFwKGVudHJ5KcKgwqDCoMKgwqDCoMKgID0gVGVzdHMgYSBkZXZpY2UgZW50cnkgYXQg UFVEIGxldmVsCj4+ICsgKgo+PiArICogcHRlX21rc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBD cmVhdGVzIGEgc29mdCBkaXJ0eSBlbnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9ta3NvZnRf ZGlydHkoZW50cnkpwqDCoMKgID0gQ3JlYXRlcyBhIHNvZnQgZGlydHkgZW50cnkgYXQgUE1EIGxl dmVsCj4+ICsgKiBwdGVfc3dwX21rc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBDcmVhdGVzIGEg c29mdCBkaXJ0eSBzd2FwIGVudHJ5IGF0IFBURSBsZXZlbAo+PiArICogcG1kX3N3cF9ta3NvZnRf ZGlydHkoZW50cnkpwqDCoMKgID0gQ3JlYXRlcyBhIHNvZnQgZGlydHkgc3dhcCBlbnRyeSBhdCBQ TUQgbGV2ZWwKPj4gKyAqIHB0ZV9zb2Z0X2RpcnR5KGVudHJ5KcKgwqDCoCA9IFRlc3RzIGEgc29m dCBkaXJ0eSBlbnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zb2Z0X2RpcnR5KGVudHJ5KcKg wqDCoCA9IFRlc3RzIGEgc29mdCBkaXJ0eSBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB0ZV9z d3Bfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBUZXN0cyBhIHNvZnQgZGlydHkgc3dhcCBlbnRy eSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zd3Bfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqAgPSBU ZXN0cyBhIHNvZnQgZGlydHkgc3dhcCBlbnRyeSBhdCBQTUQgbGV2ZWwKPj4gKyAqIHB0ZV9jbGVh cl9zb2Z0X2RpcnR5KGVudHJ5KcKgwqDCoMKgwqDCoCA9IENsZWFycyBhIHNvZnQgZGlydHkgZW50 cnkgYXQgUFRFIGxldmVsCj4+ICsgKiBwbWRfY2xlYXJfc29mdF9kaXJ0eShlbnRyeSnCoMKgwqDC oMKgwqAgPSBDbGVhcnMgYSBzb2Z0IGRpcnR5IGVudHJ5IGF0IFBNRCBsZXZlbAo+PiArICogcHRl X3N3cF9jbGVhcl9zb2Z0X2RpcnR5KGVudHJ5KSA9IENsZWFycyBhIHNvZnQgZGlydHkgc3dhcCBl bnRyeSBhdCBQVEUgbGV2ZWwKPj4gKyAqIHBtZF9zd3BfY2xlYXJfc29mdF9kaXJ0eShlbnRyeSkg PSBDbGVhcnMgYSBzb2Z0IGRpcnR5IHN3YXAgZW50cnkgYXQgUE1EIGxldmVsCj4+ICsgKgo+PiAr ICogcHRlX21raHVnZShlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IENyZWF0ZXMgYSBIdWdlVExCIGVu dHJ5IGF0IGdpdmVuIGxldmVsCj4+ICsgKiBwdGVfaHVnZShlbnRyeSnCoMKgwqDCoMKgwqDCoCA9 IFRlc3RzIGEgSHVnZVRMQiBlbnRyeSBhdCBnaXZlbiBsZXZlbAo+PiArICoKPj4gKyAqIHBtZF90 cmFuc19odWdlKGVudHJ5KcKgwqDCoCA9IFRlc3RzIGEgdHJhbnMgaHVnZSBwYWdlIGF0IFBNRCBs ZXZlbAo+PiArICogcHVkX3RyYW5zX2h1Z2UoZW50cnkpwqDCoMKgID0gVGVzdHMgYSB0cmFucyBo dWdlIHBhZ2UgYXQgUFVEIGxldmVsCj4+ICsgKiBwbWRfcHJlc2VudChlbnRyeSnCoMKgwqDCoMKg wqDCoCA9IFRlc3RzIGFuIGVudHJ5IHBvaW50cyB0byBtZW1vcnkgYXQgUE1EIGxldmVsCj4+ICsg KiBwdWRfcHJlc2VudChlbnRyeSnCoMKgwqDCoMKgwqDCoCA9IFRlc3RzIGFuIGVudHJ5IHBvaW50 cyB0byBtZW1vcnkgYXQgUFVEIGxldmVsCj4+ICsgKiBwbWRfbWtub3RwcmVzZW50KGVudHJ5KcKg wqDCoCA9IEludmFsaWRhdGVzIGFuIFBNRCBlbnRyeSBmb3IgTU1VCj4+ICsgKiBwdWRfbWtub3Rw cmVzZW50KGVudHJ5KcKgwqDCoCA9IEludmFsaWRhdGVzIGFuIFBVRCBlbnRyeSBmb3IgTU1VCj4+ IMKgwqAgKi8KPj4gwqAgI2RlZmluZSBWTUZMQUdTwqDCoMKgIChWTV9SRUFEfFZNX1dSSVRFfFZN X0VYRUMpCj4+IMKgIEBAIC0yODcsNiArMzI1LDIzMyBAQCBzdGF0aWMgdm9pZCBfX2luaXQgcG1k X3BvcHVsYXRlX3Rlc3RzKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tLCBwbWRfdCAqcG1kcCwKPj4gwqDC oMKgwqDCoCBXQVJOX09OKHBtZF9iYWQocG1kKSk7Cj4+IMKgIH0KPj4gwqAgKyNpZmRlZiBDT05G SUdfQVJDSF9IQVNfUFRFX1NQRUNJQUwKPiAKPiBDYW4gd2UgYXZvaWQgaWZkZWZzIHVubGVzcyBu ZWNlc3NhcnkgPwo+IAo+IEluIG1tL21lbW9yeS5jIEkgc2VlIHRoaW5ncyBsaWtlIHRoZSBmb2xs b3dpbmcsIGl0IG1lYW5zIHB0ZV9zcGVjaWFsKCkgYWx3YXlzIGV4aXN0IGFuZCBhICNpZmRlZiBp cyBub3QgbmVjZXNzYXJ5LgoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2FuIGJlIGRyb3BwZWQgaGVyZSwg ZG9uZS4KCj4gCj4gwqDCoMKgwqBpZiAoSVNfRU5BQkxFRChDT05GSUdfQVJDSF9IQVNfUFRFX1NQ RUNJQUwpKSB7Cj4gwqDCoMKgwqDCoMKgwqAgaWYgKGxpa2VseSghcHRlX3NwZWNpYWwocHRlKSkp Cj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBnb3RvIGNoZWNrX3BmbjsKPiDCoMKgwqDCoMKgwqDC oCBpZiAodm1hLT52bV9vcHMgJiYgdm1hLT52bV9vcHMtPmZpbmRfc3BlY2lhbF9wYWdlKQo+IMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuIHZtYS0+dm1fb3BzLT5maW5kX3NwZWNpYWxfcGFn ZSh2bWEsIGFkZHIpOwo+IMKgwqDCoMKgwqDCoMKgIGlmICh2bWEtPnZtX2ZsYWdzICYgKFZNX1BG Tk1BUCB8IFZNX01JWEVETUFQKSkKPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBOVUxM Owo+IMKgwqDCoMKgwqDCoMKgIGlmIChpc196ZXJvX3BmbihwZm4pKQo+IMKgwqDCoMKgwqDCoMKg wqDCoMKgwqAgcmV0dXJuIE5VTEw7Cj4gwqDCoMKgwqDCoMKgwqAgaWYgKHB0ZV9kZXZtYXAocHRl KSkKPiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHJldHVybiBOVUxMOwo+IAo+IMKgwqDCoMKgwqDC oMKgIHByaW50X2JhZF9wdGUodm1hLCBhZGRyLCBwdGUsIE5VTEwpOwo+IMKgwqDCoMKgwqDCoMKg IHJldHVybiBOVUxMOwo+IMKgwqDCoMKgfQo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHB0ZV9z cGVjaWFsX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiAr wqDCoMKgIHB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdB Uk5fT04oIXB0ZV9zcGVjaWFsKHB0ZV9ta3NwZWNpYWwocHRlKSkpOwo+PiArfQo+PiArI2Vsc2UK Pj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3BlY2lhbF90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkgeyB9Cj4+ICsjZW5kaWYKPj4gKwo+PiArI2lmZGVmIENPTkZJR19O VU1BX0JBTEFOQ0lORwo+IAo+IFNhbWUgaGVyZSwgdGhpcyBpZmRlZiBzaG91bGRuJ3QgYmUgbmVj ZXNzYXJ5IGJlY2F1c2UgaW4gL2luY2x1ZGUvYXNtLWdlbmVyaWMvcGd0YWJsZS5oIHdlIGhhdmUg dGhlIGZvbGxvd2luZywgc28gYSBpZiAoSVNfRU5BQkxFRCgpKSBzaG91bGQgYmUgZW5vdWdoLgo+ IAo+ICNpZm5kZWYgQ09ORklHX05VTUFfQkFMQU5DSU5HCj4gLyoKPiDCoCogVGVjaG5pY2FsbHkg YSBQVEUgY2FuIGJlIFBST1ROT05FIGV2ZW4gd2hlbiBub3QgZG9pbmcgTlVNQSBiYWxhbmNpbmcg YnV0Cj4gwqAqIHRoZSBvbmx5IGNhc2UgdGhlIGtlcm5lbCBjYXJlcyBpcyBmb3IgTlVNQSBiYWxh bmNpbmcgYW5kIGlzIG9ubHkgZXZlciBzZXQKPiDCoCogd2hlbiB0aGUgVk1BIGlzIGFjY2Vzc2li bGUuIEZvciBQUk9UX05PTkUgVk1BcywgdGhlIFBURXMgYXJlIG5vdCBtYXJrZWQKPiDCoCogX1BB R0VfUFJPVE5PTkUgc28gYnkgYnkgZGVmYXVsdCwgaW1wbGVtZW50IHRoZSBoZWxwZXIgYXMgImFs d2F5cyBubyIuIEl0Cj4gwqAqIGlzIHRoZSByZXNwb25zaWJpbGl0eSBvZiB0aGUgY2FsbGVyIHRv IGRpc3Rpbmd1aXNoIGJldHdlZW4gUFJPVF9OT05FCj4gwqAqIHByb3RlY3Rpb25zIGFuZCBOVU1B IGhpbnRpbmcgZmF1bHQgcHJvdGVjdGlvbnMuCj4gwqAqLwo+IHN0YXRpYyBpbmxpbmUgaW50IHB0 ZV9wcm90bm9uZShwdGVfdCBwdGUpCj4gewo+IMKgwqDCoMKgcmV0dXJuIDA7Cj4gfQo+IAo+IHN0 YXRpYyBpbmxpbmUgaW50IHBtZF9wcm90bm9uZShwbWRfdCBwbWQpCj4gewo+IMKgwqDCoMKgcmV0 dXJuIDA7Cj4gfQo+ICNlbmRpZiAvKiBDT05GSUdfTlVNQV9CQUxBTkNJTkcgKi8KClRydWUsICAj aWZkZWYgaGVyZSBjYW4gYmUgZHJvcHBlZCwgZG9uZS4gVGhlcmUgaXMgc29tZXRoaW5nIEkgaGFk IG1pc3NlZApiZWZvcmUsIHBmbl9wbWQoKSByZXF1aXJlcyAjaWZkZWYgQ09ORklHX1RSQU5TUEFS RU5UX0hVR0VQQUdFIGluc3RlYWQuIFdlCm5lZWQgYSBwbWRfdCBoZXJlIHdpdGggZ2l2ZW4gcHJv dC4gV2UgY2Fubm90IGdvIHZpYSBwZm5fcHRlKCkgZm9sbG93ZWQgYnkKcHRlX3BtZCgpLCBhcyB0 aGUgbGF0ZXIgaXMgcGxhdGZvcm0gc3BlY2lmaWMgYW5kIG5vdCBhdmFpbGFibGUgaW4gZ2VuZXJh bC4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHRlX3Byb3Rub25lX3Rlc3RzKHVuc2lnbmVk IGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHB0ZV90IHB0ZSA9IHBm bl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXB0ZV9wcm90bm9uZShw dGUpKTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwdGVfcHJlc2VudChwdGUpKTsKPj4gK30KPj4gKwo+ PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9wcm90bm9uZV90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwbWRfdCBwbWQgPSBwZm5fcG1kKHBm biwgcHJvdCk7Cj4+ICsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfcHJvdG5vbmUocG1kKSk7Cj4+ ICvCoMKgwqAgV0FSTl9PTighcG1kX3ByZXNlbnQocG1kKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiAr c3RhdGljIHZvaWQgX19pbml0IHB0ZV9wcm90bm9uZV90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwg cGdwcm90X3QgcHJvdCkgeyB9Cj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcG1kX3Byb3Rub25lX3Rl c3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gKyNlbmRpZgo+PiAr Cj4+ICsjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1BURV9ERVZNQVAKPiAKPiBTYW1lIGhlcmUsIGlu IGluY2x1ZGUvbGludXgvbW0uaCB3ZSBoYXZlOgo+IAo+ICNpZm5kZWYgQ09ORklHX0FSQ0hfSEFT X1BURV9ERVZNQVAKPiBzdGF0aWMgaW5saW5lIGludCBwdGVfZGV2bWFwKHB0ZV90IHB0ZSkKPiB7 Cj4gwqDCoMKgwqByZXR1cm4gMDsKPiB9Cj4gI2VuZGlmCj4gCj4gCj4+ICtzdGF0aWMgdm9pZCBf X2luaXQgcHRlX2Rldm1hcF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkK Pj4gK3sKPj4gK8KgwqDCoCBwdGVfdCBwdGUgPSBwZm5fcHRlKHBmbiwgcHJvdCk7Cj4+ICsKPj4g K8KgwqDCoCBXQVJOX09OKCFwdGVfZGV2bWFwKHB0ZV9ta2Rldm1hcChwdGUpKSk7Cj4+ICt9Cj4+ ICsKPj4gKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVHRVBBR0UKPiAKPiBTYW1lLiBJbiBp bmx1ZGUvYXNtLWdlbmVyaWMvcGd0YWJsZXMuaCB5b3UgaGF2ZToKPiAKPiAjaWYgIWRlZmluZWQo Q09ORklHX0FSQ0hfSEFTX1BURV9ERVZNQVApIHx8ICFkZWZpbmVkKENPTkZJR19UUkFOU1BBUkVO VF9IVUdFUEFHRSkKPiBzdGF0aWMgaW5saW5lIGludCBwbWRfZGV2bWFwKHBtZF90IHBtZCkKPiB7 Cj4gwqDCoMKgwqByZXR1cm4gMDsKPiB9Cj4gc3RhdGljIGlubGluZSBpbnQgcHVkX2Rldm1hcChw dWRfdCBwdWQpCj4gewo+IMKgwqDCoMKgcmV0dXJuIDA7Cj4gfQo+IHN0YXRpYyBpbmxpbmUgaW50 IHBnZF9kZXZtYXAocGdkX3QgcGdkKQo+IHsKPiDCoMKgwqDCoHJldHVybiAwOwo+IH0KPiAjZW5k aWYKPiAKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxv bmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHBtZF90IHBtZCA9IHBmbl9w bWQocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXBtZF9kZXZtYXAocG1kX21r ZGV2bWFwKHBtZCkpKTsKPj4gK30KPj4gKwo+PiArI2lmZGVmIENPTkZJR19IQVZFX0FSQ0hfVFJB TlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gCj4gU2FtZSwgc2VlIGFib3ZlCgpFdmVuIHRob3VnaCBw eHhfZGV2bWFwKCkgZmFsbGJhY2sgZGVmaW5pdGlvbnMgYXJlIHByZXNlbnQsIHB4eF9ta2Rldm1h cCgpCm9uZXMgYXJlIHN0aWxsIG1pc3NpbmcuIFdlIHdpbGwgaGF2ZSB0byBhZGQgdGhlbSBmaXJz dCBhcyBhIHByZS1yZXF1aXNpdGUKcGF0Y2ggKHdoaWNoIG1pZ2h0IG5vdCBiZSBwb3B1bGFyIHdp dGhvdXQgYW55IG5vbi1kZWJ1ZyB1c2UgY2FzZSkgaW4gb3JkZXIKdG8gZHJvcCB0aGVzZSAjaWZk ZWZzIGhlcmUuCgo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHB1ZF9kZXZtYXBfdGVzdHModW5z aWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpCj4+ICt7Cj4+ICvCoMKgwqAgcHVkX3QgcHVk ID0gcGZuX3B1ZChwZm4sIHByb3QpOwo+PiArCj4+ICvCoMKgwqAgV0FSTl9PTighcHVkX2Rldm1h cChwdWRfbWtkZXZtYXAocHVkKSkpOwo+PiArfQo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9f aW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7 IH0KPj4gKyNlbmRpZgo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFw X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2 b2lkIF9faW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KSB7IH0KPj4gKyNlbmRpZgo+PiArI2Vsc2UKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVf ZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBwbWRfZGV2bWFwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3By b3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdWRfZGV2bWFwX3Rlc3RzKHVu c2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gKyNlbmRpZgo+PiArCj4+ICsj aWZkZWYgQ09ORklHX01FTV9TT0ZUX0RJUlRZCj4gCj4gU2FtZSwgdGhleSBhbHdheXMgZXhpc3Qs IHNlZSBpbmNsdWRlL2FzbS1nZW5lcmljL3BndGFibGUuaAoKWWVhaCwgdGhpcyBjYW4gYmUgZHJv cHBlZC4gVGhvdWdoIHdpbGwgaGF2ZSB0byBhZ2FpbiBhZGQgVFJBTlNQQVJFTlRfSFVHRVBBR0UK dG8gcHJvdGVjdCBwZm5fcG1kKCkgYXMgZXhwbGFpbmVkIGJlZm9yZS4KCj4gCj4+ICtzdGF0aWMg dm9pZCBfX2luaXQgcHRlX3NvZnRfZGlydHlfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJv dF90IHByb3QpCj4+ICt7Cj4+ICvCoMKgwqAgcHRlX3QgcHRlID0gcGZuX3B0ZShwZm4sIHByb3Qp Owo+PiArCj4+ICvCoMKgwqAgV0FSTl9PTighcHRlX3NvZnRfZGlydHkocHRlX21rc29mdF9kaXJ0 eShwdGUpKSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwdGVfc29mdF9kaXJ0eShwdGVfY2xlYXJfc29m dF9kaXJ0eShwdGUpKSk7Cj4+ICt9Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3dh cF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiAr ewo+PiArwqDCoMKgIHB0ZV90IHB0ZSA9IHBmbl9wdGUocGZuLCBwcm90KTsKPj4gKwo+PiArwqDC oMKgIFdBUk5fT04oIXB0ZV9zd3Bfc29mdF9kaXJ0eShwdGVfc3dwX21rc29mdF9kaXJ0eShwdGUp KSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwdGVfc3dwX3NvZnRfZGlydHkocHRlX3N3cF9jbGVhcl9z b2Z0X2RpcnR5KHB0ZSkpKTsKPj4gK30KPj4gKwo+PiArI2lmZGVmIENPTkZJR19BUkNIX0VOQUJM RV9USFBfTUlHUkFUSU9OCj4gCj4gU2FtZQoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2FuIGJlIGRyb3Bw ZWQsIGRvbmUuCgo+IAo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9zb2Z0X2RpcnR5X3Rlc3Rz KHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArwqDCoMKgIHBtZF90 IHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gKwo+PiArwqDCoMKgIFdBUk5fT04oIXBtZF9z b2Z0X2RpcnR5KHBtZF9ta3NvZnRfZGlydHkocG1kKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocG1k X3NvZnRfZGlydHkocG1kX2NsZWFyX3NvZnRfZGlydHkocG1kKSkpOwo+PiArfQo+PiArCj4+ICtz dGF0aWMgdm9pZCBfX2luaXQgcG1kX3N3YXBfc29mdF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25n IHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwbWRfdCBwbWQgPSBwZm5fcG1k KHBmbiwgcHJvdCk7Cj4+ICsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfc3dwX3NvZnRfZGlydHko cG1kX3N3cF9ta3NvZnRfZGlydHkocG1kKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocG1kX3N3cF9z b2Z0X2RpcnR5KHBtZF9zd3BfY2xlYXJfc29mdF9kaXJ0eShwbWQpKSk7Cj4+ICt9Cj4+ICsjZWxz ZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxv bmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc3dh cF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiAr ewo+PiArfQo+PiArI2VuZGlmCj4+ICsjZWxzZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHB0ZV9z b2Z0X2RpcnR5X3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KSB7IH0KPj4g K3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc29mdF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25nIHBm biwgcGdwcm90X3QgcHJvdCkgeyB9Cj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHRlX3N3YXBfc29m dF9kaXJ0eV90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4g K30KPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwbWRfc3dhcF9zb2Z0X2RpcnR5X3Rlc3RzKHVuc2ln bmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBwcm90KQo+PiArewo+PiArfQo+PiArI2VuZGlmCj4+ICsK Pj4gK3N0YXRpYyB2b2lkIF9faW5pdCBwdGVfc3dhcF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwg cGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBzd3BfZW50cnlfdCBzd3A7Cj4+ICvCoMKg wqAgcHRlX3QgcHRlOwo+PiArCj4+ICvCoMKgwqAgcHRlID0gcGZuX3B0ZShwZm4sIHByb3QpOwo+ PiArwqDCoMKgIHN3cCA9IF9fcHRlX3RvX3N3cF9lbnRyeShwdGUpOwo+PiArwqDCoMKgIFdBUk5f T04oIXB0ZV9zYW1lKHB0ZSwgX19zd3BfZW50cnlfdG9fcHRlKHN3cCkpKTsKPj4gK30KPj4gKwo+ PiArI2lmZGVmIENPTkZJR19BUkNIX0VOQUJMRV9USFBfTUlHUkFUSU9OCj4+ICtzdGF0aWMgdm9p ZCBfX2luaXQgcG1kX3N3YXBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3Qp Cj4+ICt7Cj4+ICvCoMKgwqAgc3dwX2VudHJ5X3Qgc3dwOwo+PiArwqDCoMKgIHBtZF90IHBtZDsK Pj4gKwo+PiArwqDCoMKgIHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gK8KgwqDCoCBzd3Ag PSBfX3BtZF90b19zd3BfZW50cnkocG1kKTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwbWRfc2FtZShw bWQsIF9fc3dwX2VudHJ5X3RvX3BtZChzd3ApKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHBtZF9zd2FwX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3RfdCBw cm90KSB7IH0KPj4gKyNlbmRpZgo+PiArCj4+ICsjaWZkZWYgQ09ORklHX01JR1JBVElPTgo+IAo+ IFNhbWUuIFNlZSBpbmNsdWRlL2xpbnV4L3N3YXBvcHMuaAoKVHJ1ZSwgI2lmZGVmIGhlcmUgY2Fu IGJlIGRyb3BwZWQsIGRvbmUuIFRob3VnaCB3aWxsIGhhdmUgdG8gYWdhaW4gYWRkCmJhY2sgVFJB TlNQQVJFTlRfSFVHRVBBR0UgdG8gcHJvdGVjdCBwZm5fcG1kKCkgYXMgZXhwbGFpbmVkIGJlZm9y ZS4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgc3dhcF9taWdyYXRpb25fdGVzdHMoc3RydWN0 IHBhZ2UgKnBhZ2UpCj4+ICt7Cj4+ICvCoMKgwqAgc3dwX2VudHJ5X3Qgc3dwOwo+PiArCj4+ICvC oMKgwqAgLyoKPj4gK8KgwqDCoMKgICogbWFrZV9taWdyYXRpb25fZW50cnkoKSBleHBlY3RzIGdp dmVuIHBhZ2UgdG8gYmUKPj4gK8KgwqDCoMKgICogbG9ja2VkLCBvdGhlcndpc2UgaXQgc3R1bWJs ZXMgdXBvbiBhIEJVR19PTigpLgo+PiArwqDCoMKgwqAgKi8KPj4gK8KgwqDCoCBfX1NldFBhZ2VM b2NrZWQocGFnZSk7Cj4+ICvCoMKgwqAgc3dwID0gbWFrZV9taWdyYXRpb25fZW50cnkocGFnZSwg MSk7Cj4+ICvCoMKgwqAgV0FSTl9PTighaXNfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArwqDC oMKgIFdBUk5fT04oIWlzX3dyaXRlX21pZ3JhdGlvbl9lbnRyeShzd3ApKTsKPj4gKwo+PiArwqDC oMKgIG1ha2VfbWlncmF0aW9uX2VudHJ5X3JlYWQoJnN3cCk7Cj4+ICvCoMKgwqAgV0FSTl9PTigh aXNfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArwqDCoMKgIFdBUk5fT04oaXNfd3JpdGVfbWln cmF0aW9uX2VudHJ5KHN3cCkpOwo+PiArCj4+ICvCoMKgwqAgc3dwID0gbWFrZV9taWdyYXRpb25f ZW50cnkocGFnZSwgMCk7Cj4+ICvCoMKgwqAgV0FSTl9PTighaXNfbWlncmF0aW9uX2VudHJ5KHN3 cCkpOwo+PiArwqDCoMKgIFdBUk5fT04oaXNfd3JpdGVfbWlncmF0aW9uX2VudHJ5KHN3cCkpOwo+ PiArwqDCoMKgIF9fQ2xlYXJQYWdlTG9ja2VkKHBhZ2UpOwo+PiArfQo+PiArI2Vsc2UKPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBzd2FwX21pZ3JhdGlvbl90ZXN0cyhzdHJ1Y3QgcGFnZSAqcGFnZSkg eyB9Cj4+ICsjZW5kaWYKPj4gKwo+PiArI2lmZGVmIENPTkZJR19IVUdFVExCX1BBR0UKPj4gK3N0 YXRpYyB2b2lkIF9faW5pdCBodWdldGxiX3Rlc3RzKHVuc2lnbmVkIGxvbmcgcGZuLCBwZ3Byb3Rf dCBwcm90KQo+PiArewo+PiArI2lmZGVmIENPTkZJR19BUkNIX1dBTlRfR0VORVJBTF9IVUdFVExC Cj4+ICvCoMKgwqAgcHRlX3QgcHRlID0gcGZuX3B0ZShwZm4sIHByb3QpOwo+PiArCj4+ICvCoMKg wqAgV0FSTl9PTighcHRlX2h1Z2UocHRlX21raHVnZShwdGUpKSk7Cj4gCj4gV2UgYWxzbyBuZWVk IHRlc3RzIG9uIGh1Z2VwZCBzdHVmZgoKU3VyZSwgYnV0IGxldHMgZGlzY3VzcyB0aGlzIG9uIHRo ZSBvdGhlciB0aHJlYWQuCgo+IAo+PiArI2VuZGlmCj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IGh1Z2V0bGJfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsKPj4gKyNpZmRlZiBDT05GSUdfVFJBTlNQQVJFTlRfSFVH RVBBR0UKPiAKPiBTYW1lLCBzZWUgaW5jbHVkZS9hc20tZ2VuZXJpYy9wZ3RhYmxlLmgKClRoaXMg aXMgcmVxdWlyZWQgdG8gcHJvdGVjdCBweHhfbWtub3RwcmVzZW50KCkgd2hpY2ggZG9lcyBub3Qg aGF2ZSBhCmZhbGwgYmFjayBhbmQgcGZuX3BtZCgpL3Bmbl9wdWQoKSBoZWxwZXJzIGhhdmUgc2lt aWxhciBzaXR1YXRpb24gYXMKd2VsbC4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcG1kX3Ro cF90ZXN0cyh1bnNpZ25lZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDC oCBwbWRfdCBwbWQ7Cj4+ICsKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBwbWRfdHJhbnNf aHVnZSgpIGFuZCBwbWRfcHJlc2VudCgpIG11c3QgcmV0dXJuIG5lZ2F0aXZlCj4+ICvCoMKgwqDC oCAqIGFmdGVyIE1NVSBpbnZhbGlkYXRpb24gd2l0aCBwbWRfbWtub3RwcmVzZW50KCkuCj4+ICvC oMKgwqDCoCAqLwo+PiArwqDCoMKgIHBtZCA9IHBmbl9wbWQocGZuLCBwcm90KTsKPj4gK8KgwqDC oCBXQVJOX09OKCFwbWRfdHJhbnNfaHVnZShwbWRfbWtodWdlKHBtZCkpKTsKPj4gKwo+PiArwqDC oMKgIC8qCj4+ICvCoMKgwqDCoCAqIFRob3VnaCBwbGF0Zm9ybSBzcGVjaWZpYyB0ZXN0IGV4Y2x1 c2lvbnMgYXJlIG5vdCBpZGVhbCwKPj4gK8KgwqDCoMKgICogaW4gdGhpcyBjYXNlIFMzOTAgZG9l cyBub3QgZGVmaW5lIHBtZF9ta25vdHByZXNlbnQoKQo+PiArwqDCoMKgwqAgKiB3aGljaCBzaG91 bGQgYmUgdGVzdGVkIG9uIG90aGVyIHBsYXRmb3JtcyBlbmFibGluZyBUSFAuCj4+ICvCoMKgwqDC oCAqLwo+PiArI2lmbmRlZiBDT05GSUdfUzM5MAo+PiArwqDCoMKgIFdBUk5fT04ocG1kX3RyYW5z X2h1Z2UocG1kX21rbm90cHJlc2VudChwbWQpKSk7Cj4+ICvCoMKgwqAgV0FSTl9PTihwbWRfcHJl c2VudChwbWRfbWtub3RwcmVzZW50KHBtZCkpKTsKPj4gKyNlbmRpZgo+IAo+IENhbiB3ZSBhZGQg YSBzdHViIG9uIFMzOTAgaW5zdGVhZCA/CgpBY3R1YWxseSB3ZSBkb250IGhhdmUgdG8uIHBtZF9t a25vdHByZXNlbnQoKSBpcyByZXF1aXJlZCBmb3IgcGxhdGZvcm1zCnRoYXQgZG8gbm90IGhhdmUg X19IQVZFX0FSQ0hfUE1EUF9JTlZBTElEQVRFLiBIZW5jZSBjYW4gd3JhcCB0aGlzIGNvZGUKd2l0 aCAhX19IQVZFX0FSQ0hfUE1EUF9JTlZBTElEQVRFIHRvIHByZXZlbnQgYnVpbGQgZmFpbHVyZXMg b24gc3VjaApwbGF0Zm9ybXMgbGlrZSBzMzkwLgoKPiAKPj4gK30KPj4gKwo+PiArI2lmZGVmIENP TkZJR19IQVZFX0FSQ0hfVFJBTlNQQVJFTlRfSFVHRVBBR0VfUFVECj4gCj4gU2FtZSA/CgpUaGUg cHJvYmxlbSBpcywgbmVpdGhlciBwdWRfbWtub3RwcmVzZW50KCkgbm9yIHBmbl9wdWQoKSBoYXZl IGEgZ2VuZXJpYwpmYWxsYmFjayBkZWZpbml0aW9uLiBTbyB3aWxsIGhhdmUgdG8ga2VlcCB0aGlz ICNpZmRlZi4KCj4gCj4+ICtzdGF0aWMgdm9pZCBfX2luaXQgcHVkX3RocF90ZXN0cyh1bnNpZ25l ZCBsb25nIHBmbiwgcGdwcm90X3QgcHJvdCkKPj4gK3sKPj4gK8KgwqDCoCBwdWRfdCBwdWQ7Cj4+ ICsKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBwdWRfdHJhbnNfaHVnZSgpIGFuZCBwdWRf cHJlc2VudCgpIG11c3QgcmV0dXJuIG5lZ2F0aXZlCj4+ICvCoMKgwqDCoCAqIGFmdGVyIE1NVSBp bnZhbGlkYXRpb24gd2l0aCBwdWRfbWtub3RwcmVzZW50KCkuCj4+ICvCoMKgwqDCoCAqLwo+PiAr wqDCoMKgIHB1ZCA9IHBmbl9wdWQocGZuLCBwcm90KTsKPj4gK8KgwqDCoCBXQVJOX09OKCFwdWRf dHJhbnNfaHVnZShwdWRfbWtodWdlKHB1ZCkpKTsKPj4gK8KgwqDCoCBXQVJOX09OKHB1ZF90cmFu c19odWdlKHB1ZF9ta25vdHByZXNlbnQocHVkKSkpOwo+PiArwqDCoMKgIFdBUk5fT04ocHVkX3By ZXNlbnQocHVkX21rbm90cHJlc2VudChwdWQpKSk7Cj4+ICt9Cj4+ICsjZWxzZQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHB1ZF90aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsjZWxzZQo+PiArc3RhdGljIHZvaWQgX19pbml0IHBtZF90 aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHByb3QpIHsgfQo+PiArc3RhdGlj IHZvaWQgX19pbml0IHB1ZF90aHBfdGVzdHModW5zaWduZWQgbG9uZyBwZm4sIHBncHJvdF90IHBy b3QpIHsgfQo+PiArI2VuZGlmCj4+ICsKPj4gwqAgc3RhdGljIHVuc2lnbmVkIGxvbmcgX19pbml0 IGdldF9yYW5kb21fdmFkZHIodm9pZCkKPj4gwqAgewo+PiDCoMKgwqDCoMKgIHVuc2lnbmVkIGxv bmcgcmFuZG9tX3ZhZGRyLCByYW5kb21fcGFnZXMsIHRvdGFsX3VzZXJfcGFnZXM7Cj4+IEBAIC0z MDIsMTMgKzU2NywxNCBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBfX2luaXQgZ2V0X3JhbmRvbV92 YWRkcih2b2lkKQo+PiDCoCB2b2lkIF9faW5pdCBkZWJ1Z192bV9wZ3RhYmxlKHZvaWQpCj4+IMKg IHsKPj4gwqDCoMKgwqDCoCBzdHJ1Y3QgbW1fc3RydWN0ICptbTsKPj4gK8KgwqDCoCBzdHJ1Y3Qg cGFnZSAqcGFnZTsKPj4gwqDCoMKgwqDCoCBwZ2RfdCAqcGdkcDsKPj4gwqDCoMKgwqDCoCBwNGRf dCAqcDRkcCwgKnNhdmVkX3A0ZHA7Cj4+IMKgwqDCoMKgwqAgcHVkX3QgKnB1ZHAsICpzYXZlZF9w dWRwOwo+PiDCoMKgwqDCoMKgIHBtZF90ICpwbWRwLCAqc2F2ZWRfcG1kcCwgcG1kOwo+PiDCoMKg wqDCoMKgIHB0ZV90ICpwdGVwOwo+PiDCoMKgwqDCoMKgIHBndGFibGVfdCBzYXZlZF9wdGVwOwo+ PiAtwqDCoMKgIHBncHJvdF90IHByb3Q7Cj4+ICvCoMKgwqAgcGdwcm90X3QgcHJvdCwgcHJvdG5v bmU7Cj4+IMKgwqDCoMKgwqAgcGh5c19hZGRyX3QgcGFkZHI7Cj4+IMKgwqDCoMKgwqAgdW5zaWdu ZWQgbG9uZyB2YWRkciwgcHRlX2FsaWduZWQsIHBtZF9hbGlnbmVkOwo+PiDCoMKgwqDCoMKgIHVu c2lnbmVkIGxvbmcgcHVkX2FsaWduZWQsIHA0ZF9hbGlnbmVkLCBwZ2RfYWxpZ25lZDsKPj4gQEAg LTMyMiw2ICs1ODgsMjUgQEAgdm9pZCBfX2luaXQgZGVidWdfdm1fcGd0YWJsZSh2b2lkKQo+PiDC oMKgwqDCoMKgwqDCoMKgwqAgcmV0dXJuOwo+PiDCoMKgwqDCoMKgIH0KPj4gwqAgK8KgwqDCoCAv Kgo+PiArwqDCoMKgwqAgKiBzd2FwX21pZ3JhdGlvbl90ZXN0cygpIHJlcXVpcmVzIGEgZGVkaWNh dGVkIHBhZ2UgYXMgaXQgbmVlZHMgdG8KPj4gK8KgwqDCoMKgICogYmUgbG9ja2VkIGJlZm9yZSBj cmVhdGluZyBhIG1pZ3JhdGlvbiBlbnRyeSBmcm9tIGl0LiBMb2NraW5nIHRoZQo+PiArwqDCoMKg wqAgKiBwYWdlIHRoYXQgYWN0dWFsbHkgbWFwcyBrZXJuZWwgdGV4dCAoJ3N0YXJ0X2tlcm5lbCcp IGNhbiBiZSByZWFsCj4+ICvCoMKgwqDCoCAqIHByb2JsZW1hdGljLiBMZXRzIGFsbG9jYXRlIGEg ZGVkaWNhdGVkIHBhZ2UgZXhwbGljaXRseSBmb3IgdGhpcwo+PiArwqDCoMKgwqAgKiBwdXJwb3Nl IHRoYXQgd2lsbCBiZSBmcmVlZCBsYXRlci4KPj4gK8KgwqDCoMKgICovCj4+ICvCoMKgwqAgcGFn ZSA9IGFsbG9jX3BhZ2UoR0ZQX0tFUk5FTCk7Cj4gCj4gQ2FuIHdlIGRvIHRoZSBwYWdlIGFsbG9j YXRpb24gYW5kIGZyZWVpbmcgaW4gc3dhcF9taWdyYXRpb25fdGVzdHMoKSBpbnN0ZWFkID8KCkFs dGhvdWdoIGFsbCB0aGUgcmVzb3VyY2VzIHVzZWQgaW4gdGhlIGhlbHBlcnMgaGF2ZSBiZWVuIGFs bG9jYXRlZCBpbiB0aGUgbWFpbgpmdW5jdGlvbiBpdHNlbGYgYmVmb3JlIGJlaW5nIHBhc3NlZCBk b3duIGFuZCBsYXRlciBmcmVlZC4gQnV0IG1heSBiZSBqdXN0IGFuCmV4Y2VwdGlvbiBjb3VsZCBi ZSBtYWRlIGZvciBzd2FwX21pZ3JhdGlvbl90ZXN0cygpIGZ1bmN0aW9uIGFzIHRoZSBhbGxvY2F0 ZWQKcGFnZSBpcyBiZWluZyBleGNsdXNpdmVseSB1c2VkIGhlcmUuIExhdGVyIG9uIGlmIHdlIG5l ZWQgdGhpcyBwYWdlIGZvciBzb21lCm90aGVyIGZ1dHVyZSB0ZXN0cywgdGhlbiB3aWxsIGhhdmUg dG8gbW92ZSBpdCBiYWNrIHRvIGRlYnVnX3ZtX3BndGFibGUoKS4KCl9fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBs aXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5m cmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK