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=-15.3 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, 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 3AEABC43460 for ; Thu, 15 Apr 2021 04:54:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 17FA961152 for ; Thu, 15 Apr 2021 04:54:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229618AbhDOEyy (ORCPT ); Thu, 15 Apr 2021 00:54:54 -0400 Received: from relay4-d.mail.gandi.net ([217.70.183.196]:57411 "EHLO relay4-d.mail.gandi.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229450AbhDOEyx (ORCPT ); Thu, 15 Apr 2021 00:54:53 -0400 X-Originating-IP: 2.7.49.219 Received: from [192.168.1.100] (lfbn-lyo-1-457-219.w2-7.abo.wanadoo.fr [2.7.49.219]) (Authenticated sender: alex@ghiti.fr) by relay4-d.mail.gandi.net (Postfix) with ESMTPSA id 4BBB7E0002; Thu, 15 Apr 2021 04:54:25 +0000 (UTC) Subject: Re: [PATCH v5 1/3] riscv: Move kernel mapping outside of linear mapping To: Palmer Dabbelt Cc: corbet@lwn.net, Paul Walmsley , aou@eecs.berkeley.edu, Arnd Bergmann , aryabinin@virtuozzo.com, glider@google.com, dvyukov@google.com, linux-doc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, kasan-dev@googlegroups.com, linux-arch@vger.kernel.org, linux-mm@kvack.org References: From: Alex Ghiti Message-ID: <76353fc0-f734-db47-0d0c-f0f379763aa0@ghiti.fr> Date: Thu, 15 Apr 2021 00:54:25 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.9.1 MIME-Version: 1.0 In-Reply-To: Content-Type: text/plain; charset=utf-8; format=flowed Content-Language: fr Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Le 4/15/21 à 12:20 AM, Palmer Dabbelt a écrit : > On Sun, 11 Apr 2021 09:41:44 PDT (-0700), alex@ghiti.fr wrote: >> This is a preparatory patch for relocatable kernel and sv48 support. >> >> The kernel used to be linked at PAGE_OFFSET address therefore we could >> use >> the linear mapping for the kernel mapping. But the relocated kernel base >> address will be different from PAGE_OFFSET and since in the linear >> mapping, >> two different virtual addresses cannot point to the same physical >> address, >> the kernel mapping needs to lie outside the linear mapping so that we >> don't >> have to copy it at the same physical offset. >> >> The kernel mapping is moved to the last 2GB of the address space, BPF >> is now always after the kernel and modules use the 2GB memory range right >> before the kernel, so BPF and modules regions do not overlap. KASLR >> implementation will simply have to move the kernel in the last 2GB range >> and just take care of leaving enough space for BPF. >> >> In addition, by moving the kernel to the end of the address space, both >> sv39 and sv48 kernels will be exactly the same without needing to be >> relocated at runtime. >> >> Suggested-by: Arnd Bergmann >> Signed-off-by: Alexandre Ghiti >> --- >>  arch/riscv/boot/loader.lds.S        |  3 +- >>  arch/riscv/include/asm/page.h       | 17 +++++- >>  arch/riscv/include/asm/pgtable.h    | 37 ++++++++---- >>  arch/riscv/include/asm/set_memory.h |  1 + >>  arch/riscv/kernel/head.S            |  3 +- >>  arch/riscv/kernel/module.c          |  6 +- >>  arch/riscv/kernel/setup.c           |  5 ++ >>  arch/riscv/kernel/vmlinux.lds.S     |  3 +- >>  arch/riscv/mm/fault.c               | 13 +++++ >>  arch/riscv/mm/init.c                | 87 ++++++++++++++++++++++------- >>  arch/riscv/mm/kasan_init.c          |  9 +++ >>  arch/riscv/mm/physaddr.c            |  2 +- >>  12 files changed, 146 insertions(+), 40 deletions(-) >> >> diff --git a/arch/riscv/boot/loader.lds.S b/arch/riscv/boot/loader.lds.S >> index 47a5003c2e28..62d94696a19c 100644 >> --- a/arch/riscv/boot/loader.lds.S >> +++ b/arch/riscv/boot/loader.lds.S >> @@ -1,13 +1,14 @@ >>  /* SPDX-License-Identifier: GPL-2.0 */ >> >>  #include >> +#include >> >>  OUTPUT_ARCH(riscv) >>  ENTRY(_start) >> >>  SECTIONS >>  { >> -    . = PAGE_OFFSET; >> +    . = KERNEL_LINK_ADDR; >> >>      .payload : { >>          *(.payload) >> diff --git a/arch/riscv/include/asm/page.h >> b/arch/riscv/include/asm/page.h >> index adc9d26f3d75..22cfb2be60dc 100644 >> --- a/arch/riscv/include/asm/page.h >> +++ b/arch/riscv/include/asm/page.h >> @@ -90,15 +90,28 @@ typedef struct page *pgtable_t; >> >>  #ifdef CONFIG_MMU >>  extern unsigned long va_pa_offset; >> +extern unsigned long va_kernel_pa_offset; >>  extern unsigned long pfn_base; >>  #define ARCH_PFN_OFFSET        (pfn_base) >>  #else >>  #define va_pa_offset        0 >> +#define va_kernel_pa_offset    0 >>  #define ARCH_PFN_OFFSET        (PAGE_OFFSET >> PAGE_SHIFT) >>  #endif /* CONFIG_MMU */ >> >> -#define __pa_to_va_nodebug(x)    ((void *)((unsigned long) (x) + >> va_pa_offset)) >> -#define __va_to_pa_nodebug(x)    ((unsigned long)(x) - va_pa_offset) >> +extern unsigned long kernel_virt_addr; >> + >> +#define linear_mapping_pa_to_va(x)    ((void *)((unsigned long)(x) + >> va_pa_offset)) >> +#define kernel_mapping_pa_to_va(x)    ((void *)((unsigned long)(x) + >> va_kernel_pa_offset)) >> +#define __pa_to_va_nodebug(x)        linear_mapping_pa_to_va(x) >> + >> +#define linear_mapping_va_to_pa(x)    ((unsigned long)(x) - >> va_pa_offset) >> +#define kernel_mapping_va_to_pa(x)    ((unsigned long)(x) - >> va_kernel_pa_offset) >> +#define __va_to_pa_nodebug(x)    ({                        \ >> +    unsigned long _x = x;                            \ >> +    (_x < kernel_virt_addr) ?                        \ >> +        linear_mapping_va_to_pa(_x) : kernel_mapping_va_to_pa(_x);    \ >> +    }) >> >>  #ifdef CONFIG_DEBUG_VIRTUAL >>  extern phys_addr_t __virt_to_phys(unsigned long x); >> diff --git a/arch/riscv/include/asm/pgtable.h >> b/arch/riscv/include/asm/pgtable.h >> index ebf817c1bdf4..80e63a93e903 100644 >> --- a/arch/riscv/include/asm/pgtable.h >> +++ b/arch/riscv/include/asm/pgtable.h >> @@ -11,23 +11,30 @@ >> >>  #include >> >> -#ifndef __ASSEMBLY__ >> - >> -/* Page Upper Directory not used in RISC-V */ >> -#include >> -#include >> -#include >> -#include >> +#ifndef CONFIG_MMU >> +#define KERNEL_LINK_ADDR    PAGE_OFFSET >> +#else >> >> -#ifdef CONFIG_MMU >> +#define ADDRESS_SPACE_END    (UL(-1)) >> +/* >> + * Leave 2GB for kernel and BPF at the end of the address space >> + */ >> +#define KERNEL_LINK_ADDR    (ADDRESS_SPACE_END - SZ_2G + 1) >> >>  #define VMALLOC_SIZE     (KERN_VIRT_SIZE >> 1) >>  #define VMALLOC_END      (PAGE_OFFSET - 1) >>  #define VMALLOC_START    (PAGE_OFFSET - VMALLOC_SIZE) >> >> +/* KASLR should leave at least 128MB for BPF after the kernel */ >>  #define BPF_JIT_REGION_SIZE    (SZ_128M) >> -#define BPF_JIT_REGION_START    (PAGE_OFFSET - BPF_JIT_REGION_SIZE) >> -#define BPF_JIT_REGION_END    (VMALLOC_END) >> +#define BPF_JIT_REGION_START    PFN_ALIGN((unsigned long)&_end) >> +#define BPF_JIT_REGION_END    (BPF_JIT_REGION_START + >> BPF_JIT_REGION_SIZE) >> + >> +/* Modules always live before the kernel */ >> +#ifdef CONFIG_64BIT >> +#define MODULES_VADDR    (PFN_ALIGN((unsigned long)&_end) - SZ_2G) >> +#define MODULES_END    (PFN_ALIGN((unsigned long)&_start)) >> +#endif >> >>  /* >>   * Roughly size the vmemmap space to be large enough to fit enough >> @@ -57,9 +64,16 @@ >>  #define FIXADDR_SIZE     PGDIR_SIZE >>  #endif >>  #define FIXADDR_START    (FIXADDR_TOP - FIXADDR_SIZE) >> - >>  #endif >> >> +#ifndef __ASSEMBLY__ >> + >> +/* Page Upper Directory not used in RISC-V */ >> +#include >> +#include >> +#include >> +#include >> + >>  #ifdef CONFIG_64BIT >>  #include >>  #else >> @@ -484,6 +498,7 @@ static inline int ptep_clear_flush_young(struct >> vm_area_struct *vma, >> >>  #define kern_addr_valid(addr)   (1) /* FIXME */ >> >> +extern char _start[]; >>  extern void *dtb_early_va; >>  extern uintptr_t dtb_early_pa; >>  void setup_bootmem(void); >> diff --git a/arch/riscv/include/asm/set_memory.h >> b/arch/riscv/include/asm/set_memory.h >> index 6887b3d9f371..a9c56776fa0e 100644 >> --- a/arch/riscv/include/asm/set_memory.h >> +++ b/arch/riscv/include/asm/set_memory.h >> @@ -17,6 +17,7 @@ int set_memory_x(unsigned long addr, int numpages); >>  int set_memory_nx(unsigned long addr, int numpages); >>  int set_memory_rw_nx(unsigned long addr, int numpages); >>  void protect_kernel_text_data(void); >> +void protect_kernel_linear_mapping_text_rodata(void); >>  #else >>  static inline int set_memory_ro(unsigned long addr, int numpages) { >> return 0; } >>  static inline int set_memory_rw(unsigned long addr, int numpages) { >> return 0; } >> diff --git a/arch/riscv/kernel/head.S b/arch/riscv/kernel/head.S >> index f5a9bad86e58..6cb05f22e52a 100644 >> --- a/arch/riscv/kernel/head.S >> +++ b/arch/riscv/kernel/head.S >> @@ -69,7 +69,8 @@ pe_head_start: >>  #ifdef CONFIG_MMU >>  relocate: >>      /* Relocate return address */ >> -    li a1, PAGE_OFFSET >> +    la a1, kernel_virt_addr >> +    REG_L a1, 0(a1) >>      la a2, _start >>      sub a1, a1, a2 >>      add ra, ra, a1 >> diff --git a/arch/riscv/kernel/module.c b/arch/riscv/kernel/module.c >> index 104fba889cf7..ce153771e5e9 100644 >> --- a/arch/riscv/kernel/module.c >> +++ b/arch/riscv/kernel/module.c >> @@ -408,12 +408,10 @@ int apply_relocate_add(Elf_Shdr *sechdrs, const >> char *strtab, >>  } >> >>  #if defined(CONFIG_MMU) && defined(CONFIG_64BIT) >> -#define VMALLOC_MODULE_START \ >> -     max(PFN_ALIGN((unsigned long)&_end - SZ_2G), VMALLOC_START) >>  void *module_alloc(unsigned long size) >>  { >> -    return __vmalloc_node_range(size, 1, VMALLOC_MODULE_START, >> -                    VMALLOC_END, GFP_KERNEL, >> +    return __vmalloc_node_range(size, 1, MODULES_VADDR, >> +                    MODULES_END, GFP_KERNEL, >>                      PAGE_KERNEL_EXEC, 0, NUMA_NO_NODE, >>                      __builtin_return_address(0)); >>  } >> diff --git a/arch/riscv/kernel/setup.c b/arch/riscv/kernel/setup.c >> index e85bacff1b50..30e4af0fd50c 100644 >> --- a/arch/riscv/kernel/setup.c >> +++ b/arch/riscv/kernel/setup.c >> @@ -265,6 +265,11 @@ void __init setup_arch(char **cmdline_p) >> >>      if (IS_ENABLED(CONFIG_STRICT_KERNEL_RWX)) >>          protect_kernel_text_data(); >> + >> +#if defined(CONFIG_64BIT) && defined(CONFIG_MMU) >> +    protect_kernel_linear_mapping_text_rodata(); >> +#endif >> + >>  #ifdef CONFIG_SWIOTLB >>      swiotlb_init(1); >>  #endif >> diff --git a/arch/riscv/kernel/vmlinux.lds.S >> b/arch/riscv/kernel/vmlinux.lds.S >> index de03cb22d0e9..0726c05e0336 100644 >> --- a/arch/riscv/kernel/vmlinux.lds.S >> +++ b/arch/riscv/kernel/vmlinux.lds.S >> @@ -4,7 +4,8 @@ >>   * Copyright (C) 2017 SiFive >>   */ >> >> -#define LOAD_OFFSET PAGE_OFFSET >> +#include >> +#define LOAD_OFFSET KERNEL_LINK_ADDR >>  #include >>  #include >>  #include >> diff --git a/arch/riscv/mm/fault.c b/arch/riscv/mm/fault.c >> index 8f17519208c7..1b14d523a95c 100644 >> --- a/arch/riscv/mm/fault.c >> +++ b/arch/riscv/mm/fault.c >> @@ -231,6 +231,19 @@ asmlinkage void do_page_fault(struct pt_regs *regs) >>          return; >>      } >> >> +#ifdef CONFIG_64BIT >> +    /* >> +     * Modules in 64bit kernels lie in their own virtual region which >> is not >> +     * in the vmalloc region, but dealing with page faults in this >> region >> +     * or the vmalloc region amounts to doing the same thing: >> checking that >> +     * the mapping exists in init_mm.pgd and updating user page >> table, so >> +     * just use vmalloc_fault. >> +     */ >> +    if (unlikely(addr >= MODULES_VADDR && addr < MODULES_END)) { >> +        vmalloc_fault(regs, code, addr); >> +        return; >> +    } >> +#endif >>      /* Enable interrupts if they were enabled in the parent context. */ >>      if (likely(regs->status & SR_PIE)) >>          local_irq_enable(); >> diff --git a/arch/riscv/mm/init.c b/arch/riscv/mm/init.c >> index 7f5036fbee8c..093f3a96ecfc 100644 >> --- a/arch/riscv/mm/init.c >> +++ b/arch/riscv/mm/init.c >> @@ -25,6 +25,9 @@ >> >>  #include "../kernel/head.h" >> >> +unsigned long kernel_virt_addr = KERNEL_LINK_ADDR; >> +EXPORT_SYMBOL(kernel_virt_addr); >> + >>  unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] >>                              __page_aligned_bss; >>  EXPORT_SYMBOL(empty_zero_page); >> @@ -88,6 +91,8 @@ static void print_vm_layout(void) >>            (unsigned long)VMALLOC_END); >>      print_mlm("lowmem", (unsigned long)PAGE_OFFSET, >>            (unsigned long)high_memory); >> +    print_mlm("kernel", (unsigned long)KERNEL_LINK_ADDR, >> +          (unsigned long)ADDRESS_SPACE_END); >>  } >>  #else >>  static void print_vm_layout(void) { } >> @@ -116,8 +121,13 @@ void __init setup_bootmem(void) >>      /* The maximal physical memory size is -PAGE_OFFSET. */ >>      memblock_enforce_memory_limit(-PAGE_OFFSET); >> >> -    /* Reserve from the start of the kernel to the end of the kernel */ >> -    memblock_reserve(vmlinux_start, vmlinux_end - vmlinux_start); >> +    /* >> +     * Reserve from the start of the kernel to the end of the kernel >> +     * and make sure we align the reservation on PMD_SIZE since we will >> +     * map the kernel in the linear mapping as read-only: we do not want >> +     * any allocation to happen between _end and the next pmd aligned >> page. >> +     */ >> +    memblock_reserve(vmlinux_start, (vmlinux_end - vmlinux_start + >> PMD_SIZE - 1) & PMD_MASK); >> >>      /* >>       * memblock allocator is not aware of the fact that last 4K bytes of >> @@ -152,8 +162,12 @@ void __init setup_bootmem(void) >>  #ifdef CONFIG_MMU >>  static struct pt_alloc_ops pt_ops; >> >> +/* Offset between linear mapping virtual address and kernel load >> address */ >>  unsigned long va_pa_offset; >>  EXPORT_SYMBOL(va_pa_offset); >> +/* Offset between kernel mapping virtual address and kernel load >> address */ >> +unsigned long va_kernel_pa_offset; >> +EXPORT_SYMBOL(va_kernel_pa_offset); >>  unsigned long pfn_base; >>  EXPORT_SYMBOL(pfn_base); >> >> @@ -257,7 +271,7 @@ static pmd_t *get_pmd_virt_late(phys_addr_t pa) >> >>  static phys_addr_t __init alloc_pmd_early(uintptr_t va) >>  { >> -    BUG_ON((va - PAGE_OFFSET) >> PGDIR_SHIFT); >> +    BUG_ON((va - kernel_virt_addr) >> PGDIR_SHIFT); >> >>      return (uintptr_t)early_pmd; >>  } >> @@ -372,17 +386,32 @@ static uintptr_t __init >> best_map_size(phys_addr_t base, phys_addr_t size) >>  #error "setup_vm() is called from head.S before relocate so it should >> not use absolute addressing." >>  #endif >> >> +uintptr_t load_pa, load_sz; >> + >> +static void __init create_kernel_page_table(pgd_t *pgdir, uintptr_t >> map_size) >> +{ >> +    uintptr_t va, end_va; >> + >> +    end_va = kernel_virt_addr + load_sz; >> +    for (va = kernel_virt_addr; va < end_va; va += map_size) >> +        create_pgd_mapping(pgdir, va, >> +                   load_pa + (va - kernel_virt_addr), >> +                   map_size, PAGE_KERNEL_EXEC); >> +} >> + >>  asmlinkage void __init setup_vm(uintptr_t dtb_pa) >>  { >> -    uintptr_t va, pa, end_va; >> -    uintptr_t load_pa = (uintptr_t)(&_start); >> -    uintptr_t load_sz = (uintptr_t)(&_end) - load_pa; >> +    uintptr_t pa; >>      uintptr_t map_size; >>  #ifndef __PAGETABLE_PMD_FOLDED >>      pmd_t fix_bmap_spmd, fix_bmap_epmd; >>  #endif >> +    load_pa = (uintptr_t)(&_start); >> +    load_sz = (uintptr_t)(&_end) - load_pa; >> >>      va_pa_offset = PAGE_OFFSET - load_pa; >> +    va_kernel_pa_offset = kernel_virt_addr - load_pa; >> + >>      pfn_base = PFN_DOWN(load_pa); >> >>      /* >> @@ -410,26 +439,22 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) >>      create_pmd_mapping(fixmap_pmd, FIXADDR_START, >>                 (uintptr_t)fixmap_pte, PMD_SIZE, PAGE_TABLE); >>      /* Setup trampoline PGD and PMD */ >> -    create_pgd_mapping(trampoline_pg_dir, PAGE_OFFSET, >> +    create_pgd_mapping(trampoline_pg_dir, kernel_virt_addr, >>                 (uintptr_t)trampoline_pmd, PGDIR_SIZE, PAGE_TABLE); >> -    create_pmd_mapping(trampoline_pmd, PAGE_OFFSET, >> +    create_pmd_mapping(trampoline_pmd, kernel_virt_addr, >>                 load_pa, PMD_SIZE, PAGE_KERNEL_EXEC); >>  #else >>      /* Setup trampoline PGD */ >> -    create_pgd_mapping(trampoline_pg_dir, PAGE_OFFSET, >> +    create_pgd_mapping(trampoline_pg_dir, kernel_virt_addr, >>                 load_pa, PGDIR_SIZE, PAGE_KERNEL_EXEC); >>  #endif >> >>      /* >> -     * Setup early PGD covering entire kernel which will allows >> +     * Setup early PGD covering entire kernel which will allow >>       * us to reach paging_init(). We map all memory banks later >>       * in setup_vm_final() below. >>       */ >> -    end_va = PAGE_OFFSET + load_sz; >> -    for (va = PAGE_OFFSET; va < end_va; va += map_size) >> -        create_pgd_mapping(early_pg_dir, va, >> -                   load_pa + (va - PAGE_OFFSET), >> -                   map_size, PAGE_KERNEL_EXEC); >> +    create_kernel_page_table(early_pg_dir, map_size); >> >>  #ifndef __PAGETABLE_PMD_FOLDED >>      /* Setup early PMD for DTB */ >> @@ -444,7 +469,12 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) >>                 pa + PMD_SIZE, PMD_SIZE, PAGE_KERNEL); >>      dtb_early_va = (void *)DTB_EARLY_BASE_VA + (dtb_pa & (PMD_SIZE - >> 1)); >>  #else /* CONFIG_BUILTIN_DTB */ >> -    dtb_early_va = __va(dtb_pa); >> +    /* >> +     * __va can't be used since it would return a linear mapping address >> +     * whereas dtb_early_va will be used before setup_vm_final installs >> +     * the linear mapping. >> +     */ >> +    dtb_early_va = kernel_mapping_pa_to_va(dtb_pa); >>  #endif /* CONFIG_BUILTIN_DTB */ >>  #else >>  #ifndef CONFIG_BUILTIN_DTB >> @@ -456,7 +486,7 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) >>                 pa + PGDIR_SIZE, PGDIR_SIZE, PAGE_KERNEL); >>      dtb_early_va = (void *)DTB_EARLY_BASE_VA + (dtb_pa & (PGDIR_SIZE >> - 1)); >>  #else /* CONFIG_BUILTIN_DTB */ >> -    dtb_early_va = __va(dtb_pa); >> +    dtb_early_va = kernel_mapping_pa_to_va(dtb_pa); >>  #endif /* CONFIG_BUILTIN_DTB */ >>  #endif >>      dtb_early_pa = dtb_pa; >> @@ -492,6 +522,22 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) >>  #endif >>  } >> >> +#ifdef CONFIG_64BIT >> +void protect_kernel_linear_mapping_text_rodata(void) >> +{ >> +    unsigned long text_start = (unsigned long)lm_alias(_start); >> +    unsigned long init_text_start = (unsigned >> long)lm_alias(__init_text_begin); >> +    unsigned long rodata_start = (unsigned >> long)lm_alias(__start_rodata); >> +    unsigned long data_start = (unsigned long)lm_alias(_data); >> + >> +    set_memory_ro(text_start, (init_text_start - text_start) >> >> PAGE_SHIFT); >> +    set_memory_nx(text_start, (init_text_start - text_start) >> >> PAGE_SHIFT); >> + >> +    set_memory_ro(rodata_start, (data_start - rodata_start) >> >> PAGE_SHIFT); >> +    set_memory_nx(rodata_start, (data_start - rodata_start) >> >> PAGE_SHIFT); >> +} >> +#endif >> + >>  static void __init setup_vm_final(void) >>  { >>      uintptr_t va, map_size; >> @@ -513,7 +559,7 @@ static void __init setup_vm_final(void) >>                 __pa_symbol(fixmap_pgd_next), >>                 PGDIR_SIZE, PAGE_TABLE); >> >> -    /* Map all memory banks */ >> +    /* Map all memory banks in the linear mapping */ >>      for_each_mem_range(i, &start, &end) { >>          if (start >= end) >>              break; >> @@ -525,10 +571,13 @@ static void __init setup_vm_final(void) >>          for (pa = start; pa < end; pa += map_size) { >>              va = (uintptr_t)__va(pa); >>              create_pgd_mapping(swapper_pg_dir, va, pa, >> -                       map_size, PAGE_KERNEL_EXEC); >> +                       map_size, PAGE_KERNEL); >>          } >>      } >> >> +    /* Map the kernel */ >> +    create_kernel_page_table(swapper_pg_dir, PMD_SIZE); >> + >>      /* Clear fixmap PTE and PMD mappings */ >>      clear_fixmap(FIX_PTE); >>      clear_fixmap(FIX_PMD); >> diff --git a/arch/riscv/mm/kasan_init.c b/arch/riscv/mm/kasan_init.c >> index 2c39f0386673..28f4d52cf17e 100644 >> --- a/arch/riscv/mm/kasan_init.c >> +++ b/arch/riscv/mm/kasan_init.c >> @@ -171,6 +171,10 @@ void __init kasan_init(void) >>      phys_addr_t _start, _end; >>      u64 i; >> >> +    /* >> +     * Populate all kernel virtual address space with >> kasan_early_shadow_page >> +     * except for the linear mapping and the modules/kernel/BPF mapping. >> +     */ >>      kasan_populate_early_shadow((void *)KASAN_SHADOW_START, >>                      (void *)kasan_mem_to_shadow((void *) >>                                  VMEMMAP_END)); >> @@ -183,6 +187,7 @@ void __init kasan_init(void) >>              (void *)kasan_mem_to_shadow((void *)VMALLOC_START), >>              (void *)kasan_mem_to_shadow((void *)VMALLOC_END)); >> >> +    /* Populate the linear mapping */ >>      for_each_mem_range(i, &_start, &_end) { >>          void *start = (void *)__va(_start); >>          void *end = (void *)__va(_end); >> @@ -193,6 +198,10 @@ void __init kasan_init(void) >>          kasan_populate(kasan_mem_to_shadow(start), >> kasan_mem_to_shadow(end)); >>      }; >> >> +    /* Populate kernel, BPF, modules mapping */ >> +    kasan_populate(kasan_mem_to_shadow((const void *)MODULES_VADDR), >> +               kasan_mem_to_shadow((const void *)BPF_JIT_REGION_END)); >> + >>      for (i = 0; i < PTRS_PER_PTE; i++) >>          set_pte(&kasan_early_shadow_pte[i], >>              mk_pte(virt_to_page(kasan_early_shadow_page), >> diff --git a/arch/riscv/mm/physaddr.c b/arch/riscv/mm/physaddr.c >> index e8e4dcd39fed..35703d5ef5fd 100644 >> --- a/arch/riscv/mm/physaddr.c >> +++ b/arch/riscv/mm/physaddr.c >> @@ -23,7 +23,7 @@ EXPORT_SYMBOL(__virt_to_phys); >> >>  phys_addr_t __phys_addr_symbol(unsigned long x) >>  { >> -    unsigned long kernel_start = (unsigned long)PAGE_OFFSET; >> +    unsigned long kernel_start = (unsigned long)kernel_virt_addr; >>      unsigned long kernel_end = (unsigned long)_end; >> >>      /* > > This is breaking boot for me with CONFIG_STRICT_KERNEL_RWX=n.  I'm not > even really convinced that's a useful config to support, but it's > currently optional and I'd prefer to avoid breaking it if possible. > > I can't quite figure out what's going on here and I'm pretty much tired > out for tonight.  LMK if you don't have time to look at it and I'll try > to give it another shot. I'm taking a look at that. Thanks, Alex 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=-15.3 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,NICE_REPLY_A,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,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 2BE07C433B4 for ; Thu, 15 Apr 2021 04:54:58 +0000 (UTC) Received: from desiato.infradead.org (desiato.infradead.org [90.155.92.199]) (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 6ED6F6117A for ; Thu, 15 Apr 2021 04:54:57 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 6ED6F6117A Authentication-Results: mail.kernel.org; dmarc=none (p=none dis=none) header.from=ghiti.fr Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=desiato.20200630; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:Date:Message-ID:From: References:Cc:To:Subject:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=wzqzwyYL2KPCmgqJG9DAJhau3lV3VLmBErUQfNsVaM8=; b=jeox4f11nuzMBz5eq4IFwCOxJ ULVLPFQpwbL9g3COlSWeZgaReJ6ozv8J+m6Vt4RWW4Xe66gBkqmmwC6/1Z8aCIZ+qzcSPMWP8gq+v o4p6pvW9/Ajelzq2sK4d6RcV45zwQbZh8oIM5r/SqTvB31J8tGoh2JyzlE5K+BiRWDSvMJwgXRoeK DtLH8W2vGJRD558JsgCWBwR1iNFbOBQQ86rWRZX6F8UEvXbOjzpf/+Y8StnGPphfRQO7uSzLITGCI iFnznyuFoF2siKa0BgnPU8CkcJPvG26V7LXpvxsBl8YXMICi5EjmVlkMZehjDNte/iMMmJTcrA4j+ 3NXPF37yA==; Received: from localhost ([::1] helo=desiato.infradead.org) by desiato.infradead.org with esmtp (Exim 4.94 #2 (Red Hat Linux)) id 1lWu1Y-00Eq3q-7B; Thu, 15 Apr 2021 04:54:40 +0000 Received: from bombadil.infradead.org ([2607:7c80:54:e::133]) by desiato.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lWu1V-00Eq3R-55 for linux-riscv@desiato.infradead.org; Thu, 15 Apr 2021 04:54:37 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=bombadil.20210309; h=Content-Transfer-Encoding: Content-Type:In-Reply-To:MIME-Version:Date:Message-ID:From:References:Cc:To: Subject:Sender:Reply-To:Content-ID:Content-Description; bh=BjAB55AjiF4dV7/D95Y8+hHvuUJlLqRs8hq2wnclMsQ=; b=UoCWNgWABifHV0wT9lzFcUfhKB Y/15pNc29tv/A1AqtdVdybgSuViMo+/qRW5kitkG2V8yUoVn0At8LONnQwvJ1jaBC9UNqjUCWKBC0 Rs+isk0YvicH2g2sdUicMyMeLtW7eBS5WdM9bfgdlGoqdl0T3ZTxQVTo8fB6su4wlCYcAN2ZKJUZH LifDRTmCS7lXp/vOeg7W4n2AE4ld6yU0v/PCjTa6kr7VZYJLBFVEiKXub0S9whv7CYqGkoSJLuouq +CUopW6Vmqj593RQ9SP+pR/JRDqQCdHBWyw7qwuvh6lHXWV5XsbjD35/kzZStv/SkhFOHT+47iSzT GUslbViQ==; Received: from relay4-d.mail.gandi.net ([217.70.183.196]) by bombadil.infradead.org with esmtps (Exim 4.94 #2 (Red Hat Linux)) id 1lWu1Q-008GkZ-MG for linux-riscv@lists.infradead.org; Thu, 15 Apr 2021 04:54:35 +0000 X-Originating-IP: 2.7.49.219 Received: from [192.168.1.100] (lfbn-lyo-1-457-219.w2-7.abo.wanadoo.fr [2.7.49.219]) (Authenticated sender: alex@ghiti.fr) by relay4-d.mail.gandi.net (Postfix) with ESMTPSA id 4BBB7E0002; Thu, 15 Apr 2021 04:54:25 +0000 (UTC) Subject: Re: [PATCH v5 1/3] riscv: Move kernel mapping outside of linear mapping To: Palmer Dabbelt Cc: corbet@lwn.net, Paul Walmsley , aou@eecs.berkeley.edu, Arnd Bergmann , aryabinin@virtuozzo.com, glider@google.com, dvyukov@google.com, linux-doc@vger.kernel.org, linux-riscv@lists.infradead.org, linux-kernel@vger.kernel.org, kasan-dev@googlegroups.com, linux-arch@vger.kernel.org, linux-mm@kvack.org References: From: Alex Ghiti Message-ID: <76353fc0-f734-db47-0d0c-f0f379763aa0@ghiti.fr> Date: Thu, 15 Apr 2021 00:54:25 -0400 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:78.0) Gecko/20100101 Thunderbird/78.9.1 MIME-Version: 1.0 In-Reply-To: Content-Language: fr X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210414_215433_045049_BA3ACE0B X-CRM114-Status: GOOD ( 32.83 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org TGUgNC8xNS8yMSDDoCAxMjoyMCBBTSwgUGFsbWVyIERhYmJlbHQgYSDDqWNyaXTCoDoKPiBPbiBT dW4sIDExIEFwciAyMDIxIDA5OjQxOjQ0IFBEVCAoLTA3MDApLCBhbGV4QGdoaXRpLmZyIHdyb3Rl Ogo+PiBUaGlzIGlzIGEgcHJlcGFyYXRvcnkgcGF0Y2ggZm9yIHJlbG9jYXRhYmxlIGtlcm5lbCBh bmQgc3Y0OCBzdXBwb3J0Lgo+Pgo+PiBUaGUga2VybmVsIHVzZWQgdG8gYmUgbGlua2VkIGF0IFBB R0VfT0ZGU0VUIGFkZHJlc3MgdGhlcmVmb3JlIHdlIGNvdWxkIAo+PiB1c2UKPj4gdGhlIGxpbmVh ciBtYXBwaW5nIGZvciB0aGUga2VybmVsIG1hcHBpbmcuIEJ1dCB0aGUgcmVsb2NhdGVkIGtlcm5l bCBiYXNlCj4+IGFkZHJlc3Mgd2lsbCBiZSBkaWZmZXJlbnQgZnJvbSBQQUdFX09GRlNFVCBhbmQg c2luY2UgaW4gdGhlIGxpbmVhciAKPj4gbWFwcGluZywKPj4gdHdvIGRpZmZlcmVudCB2aXJ0dWFs IGFkZHJlc3NlcyBjYW5ub3QgcG9pbnQgdG8gdGhlIHNhbWUgcGh5c2ljYWwgCj4+IGFkZHJlc3Ms Cj4+IHRoZSBrZXJuZWwgbWFwcGluZyBuZWVkcyB0byBsaWUgb3V0c2lkZSB0aGUgbGluZWFyIG1h cHBpbmcgc28gdGhhdCB3ZSAKPj4gZG9uJ3QKPj4gaGF2ZSB0byBjb3B5IGl0IGF0IHRoZSBzYW1l IHBoeXNpY2FsIG9mZnNldC4KPj4KPj4gVGhlIGtlcm5lbCBtYXBwaW5nIGlzIG1vdmVkIHRvIHRo ZSBsYXN0IDJHQiBvZiB0aGUgYWRkcmVzcyBzcGFjZSwgQlBGCj4+IGlzIG5vdyBhbHdheXMgYWZ0 ZXIgdGhlIGtlcm5lbCBhbmQgbW9kdWxlcyB1c2UgdGhlIDJHQiBtZW1vcnkgcmFuZ2UgcmlnaHQK Pj4gYmVmb3JlIHRoZSBrZXJuZWwsIHNvIEJQRiBhbmQgbW9kdWxlcyByZWdpb25zIGRvIG5vdCBv dmVybGFwLiBLQVNMUgo+PiBpbXBsZW1lbnRhdGlvbiB3aWxsIHNpbXBseSBoYXZlIHRvIG1vdmUg dGhlIGtlcm5lbCBpbiB0aGUgbGFzdCAyR0IgcmFuZ2UKPj4gYW5kIGp1c3QgdGFrZSBjYXJlIG9m IGxlYXZpbmcgZW5vdWdoIHNwYWNlIGZvciBCUEYuCj4+Cj4+IEluIGFkZGl0aW9uLCBieSBtb3Zp bmcgdGhlIGtlcm5lbCB0byB0aGUgZW5kIG9mIHRoZSBhZGRyZXNzIHNwYWNlLCBib3RoCj4+IHN2 MzkgYW5kIHN2NDgga2VybmVscyB3aWxsIGJlIGV4YWN0bHkgdGhlIHNhbWUgd2l0aG91dCBuZWVk aW5nIHRvIGJlCj4+IHJlbG9jYXRlZCBhdCBydW50aW1lLgo+Pgo+PiBTdWdnZXN0ZWQtYnk6IEFy bmQgQmVyZ21hbm4gPGFybmRAYXJuZGIuZGU+Cj4+IFNpZ25lZC1vZmYtYnk6IEFsZXhhbmRyZSBH aGl0aSA8YWxleEBnaGl0aS5mcj4KPj4gLS0tCj4+IMKgYXJjaC9yaXNjdi9ib290L2xvYWRlci5s ZHMuU8KgwqDCoMKgwqDCoMKgIHzCoCAzICstCj4+IMKgYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9w YWdlLmjCoMKgwqDCoMKgwqAgfCAxNyArKysrKy0KPj4gwqBhcmNoL3Jpc2N2L2luY2x1ZGUvYXNt L3BndGFibGUuaMKgwqDCoCB8IDM3ICsrKysrKysrLS0tLQo+PiDCoGFyY2gvcmlzY3YvaW5jbHVk ZS9hc20vc2V0X21lbW9yeS5oIHzCoCAxICsKPj4gwqBhcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlPC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIHzCoCAzICstCj4+IMKgYXJjaC9yaXNjdi9rZXJuZWwvbW9k dWxlLmPCoMKgwqDCoMKgwqDCoMKgwqAgfMKgIDYgKy0KPj4gwqBhcmNoL3Jpc2N2L2tlcm5lbC9z ZXR1cC5jwqDCoMKgwqDCoMKgwqDCoMKgwqAgfMKgIDUgKysKPj4gwqBhcmNoL3Jpc2N2L2tlcm5l bC92bWxpbnV4Lmxkcy5TwqDCoMKgwqAgfMKgIDMgKy0KPj4gwqBhcmNoL3Jpc2N2L21tL2ZhdWx0 LmPCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHwgMTMgKysrKysKPj4gwqBhcmNoL3Jpc2N2 L21tL2luaXQuY8KgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCB8IDg3ICsrKysrKysrKysr KysrKysrKysrKystLS0tLS0tCj4+IMKgYXJjaC9yaXNjdi9tbS9rYXNhbl9pbml0LmPCoMKgwqDC oMKgwqDCoMKgwqAgfMKgIDkgKysrCj4+IMKgYXJjaC9yaXNjdi9tbS9waHlzYWRkci5jwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCB8wqAgMiArLQo+PiDCoDEyIGZpbGVzIGNoYW5nZWQsIDE0NiBpbnNl cnRpb25zKCspLCA0MCBkZWxldGlvbnMoLSkKPj4KPj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yv Ym9vdC9sb2FkZXIubGRzLlMgYi9hcmNoL3Jpc2N2L2Jvb3QvbG9hZGVyLmxkcy5TCj4+IGluZGV4 IDQ3YTUwMDNjMmUyOC4uNjJkOTQ2OTZhMTljIDEwMDY0NAo+PiAtLS0gYS9hcmNoL3Jpc2N2L2Jv b3QvbG9hZGVyLmxkcy5TCj4+ICsrKyBiL2FyY2gvcmlzY3YvYm9vdC9sb2FkZXIubGRzLlMKPj4g QEAgLTEsMTMgKzEsMTQgQEAKPj4gwqAvKiBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIu MCAqLwo+Pgo+PiDCoCNpbmNsdWRlIDxhc20vcGFnZS5oPgo+PiArI2luY2x1ZGUgPGFzbS9wZ3Rh YmxlLmg+Cj4+Cj4+IMKgT1VUUFVUX0FSQ0gocmlzY3YpCj4+IMKgRU5UUlkoX3N0YXJ0KQo+Pgo+ PiDCoFNFQ1RJT05TCj4+IMKgewo+PiAtwqDCoMKgIC4gPSBQQUdFX09GRlNFVDsKPj4gK8KgwqDC oCAuID0gS0VSTkVMX0xJTktfQUREUjsKPj4KPj4gwqDCoMKgwqAgLnBheWxvYWQgOiB7Cj4+IMKg wqDCoMKgwqDCoMKgwqAgKigucGF5bG9hZCkKPj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvaW5j bHVkZS9hc20vcGFnZS5oIAo+PiBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vcGFnZS5oCj4+IGlu ZGV4IGFkYzlkMjZmM2Q3NS4uMjJjZmIyYmU2MGRjIDEwMDY0NAo+PiAtLS0gYS9hcmNoL3Jpc2N2 L2luY2x1ZGUvYXNtL3BhZ2UuaAo+PiArKysgYi9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BhZ2Uu aAo+PiBAQCAtOTAsMTUgKzkwLDI4IEBAIHR5cGVkZWYgc3RydWN0IHBhZ2UgKnBndGFibGVfdDsK Pj4KPj4gwqAjaWZkZWYgQ09ORklHX01NVQo+PiDCoGV4dGVybiB1bnNpZ25lZCBsb25nIHZhX3Bh X29mZnNldDsKPj4gK2V4dGVybiB1bnNpZ25lZCBsb25nIHZhX2tlcm5lbF9wYV9vZmZzZXQ7Cj4+ IMKgZXh0ZXJuIHVuc2lnbmVkIGxvbmcgcGZuX2Jhc2U7Cj4+IMKgI2RlZmluZSBBUkNIX1BGTl9P RkZTRVTCoMKgwqDCoMKgwqDCoCAocGZuX2Jhc2UpCj4+IMKgI2Vsc2UKPj4gwqAjZGVmaW5lIHZh X3BhX29mZnNldMKgwqDCoMKgwqDCoMKgIDAKPj4gKyNkZWZpbmUgdmFfa2VybmVsX3BhX29mZnNl dMKgwqDCoCAwCj4+IMKgI2RlZmluZSBBUkNIX1BGTl9PRkZTRVTCoMKgwqDCoMKgwqDCoCAoUEFH RV9PRkZTRVQgPj4gUEFHRV9TSElGVCkKPj4gwqAjZW5kaWYgLyogQ09ORklHX01NVSAqLwo+Pgo+ PiAtI2RlZmluZSBfX3BhX3RvX3ZhX25vZGVidWcoeCnCoMKgwqAgKCh2b2lkICopKCh1bnNpZ25l ZCBsb25nKSAoeCkgKyAKPj4gdmFfcGFfb2Zmc2V0KSkKPj4gLSNkZWZpbmUgX192YV90b19wYV9u b2RlYnVnKHgpwqDCoMKgICgodW5zaWduZWQgbG9uZykoeCkgLSB2YV9wYV9vZmZzZXQpCj4+ICtl eHRlcm4gdW5zaWduZWQgbG9uZyBrZXJuZWxfdmlydF9hZGRyOwo+PiArCj4+ICsjZGVmaW5lIGxp bmVhcl9tYXBwaW5nX3BhX3RvX3ZhKHgpwqDCoMKgICgodm9pZCAqKSgodW5zaWduZWQgbG9uZyko eCkgKyAKPj4gdmFfcGFfb2Zmc2V0KSkKPj4gKyNkZWZpbmUga2VybmVsX21hcHBpbmdfcGFfdG9f dmEoeCnCoMKgwqAgKCh2b2lkICopKCh1bnNpZ25lZCBsb25nKSh4KSArIAo+PiB2YV9rZXJuZWxf cGFfb2Zmc2V0KSkKPj4gKyNkZWZpbmUgX19wYV90b192YV9ub2RlYnVnKHgpwqDCoMKgwqDCoMKg wqAgbGluZWFyX21hcHBpbmdfcGFfdG9fdmEoeCkKPj4gKwo+PiArI2RlZmluZSBsaW5lYXJfbWFw cGluZ192YV90b19wYSh4KcKgwqDCoCAoKHVuc2lnbmVkIGxvbmcpKHgpIC0gCj4+IHZhX3BhX29m ZnNldCkKPj4gKyNkZWZpbmUga2VybmVsX21hcHBpbmdfdmFfdG9fcGEoeCnCoMKgwqAgKCh1bnNp Z25lZCBsb25nKSh4KSAtIAo+PiB2YV9rZXJuZWxfcGFfb2Zmc2V0KQo+PiArI2RlZmluZSBfX3Zh X3RvX3BhX25vZGVidWcoeCnCoMKgwqAgKHvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgIFwKPj4gK8KgwqDCoCB1bnNpZ25lZCBsb25nIF94ID0geDvCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgXAo+PiArwqDC oMKgIChfeCA8IGtlcm5lbF92aXJ0X2FkZHIpID/CoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIFwKPj4gK8KgwqDCoMKgwqDCoMKgIGxpbmVhcl9tYXBwaW5nX3Zh X3RvX3BhKF94KSA6IGtlcm5lbF9tYXBwaW5nX3ZhX3RvX3BhKF94KTvCoMKgwqAgXAo+PiArwqDC oMKgIH0pCj4+Cj4+IMKgI2lmZGVmIENPTkZJR19ERUJVR19WSVJUVUFMCj4+IMKgZXh0ZXJuIHBo eXNfYWRkcl90IF9fdmlydF90b19waHlzKHVuc2lnbmVkIGxvbmcgeCk7Cj4+IGRpZmYgLS1naXQg YS9hcmNoL3Jpc2N2L2luY2x1ZGUvYXNtL3BndGFibGUuaCAKPj4gYi9hcmNoL3Jpc2N2L2luY2x1 ZGUvYXNtL3BndGFibGUuaAo+PiBpbmRleCBlYmY4MTdjMWJkZjQuLjgwZTYzYTkzZTkwMyAxMDA2 NDQKPj4gLS0tIGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9wZ3RhYmxlLmgKPj4gKysrIGIvYXJj aC9yaXNjdi9pbmNsdWRlL2FzbS9wZ3RhYmxlLmgKPj4gQEAgLTExLDIzICsxMSwzMCBAQAo+Pgo+ PiDCoCNpbmNsdWRlIDxhc20vcGd0YWJsZS1iaXRzLmg+Cj4+Cj4+IC0jaWZuZGVmIF9fQVNTRU1C TFlfXwo+PiAtCj4+IC0vKiBQYWdlIFVwcGVyIERpcmVjdG9yeSBub3QgdXNlZCBpbiBSSVNDLVYg Ki8KPj4gLSNpbmNsdWRlIDxhc20tZ2VuZXJpYy9wZ3RhYmxlLW5vcHVkLmg+Cj4+IC0jaW5jbHVk ZSA8YXNtL3BhZ2UuaD4KPj4gLSNpbmNsdWRlIDxhc20vdGxiZmx1c2guaD4KPj4gLSNpbmNsdWRl IDxsaW51eC9tbV90eXBlcy5oPgo+PiArI2lmbmRlZiBDT05GSUdfTU1VCj4+ICsjZGVmaW5lIEtF Uk5FTF9MSU5LX0FERFLCoMKgwqAgUEFHRV9PRkZTRVQKPj4gKyNlbHNlCj4+Cj4+IC0jaWZkZWYg Q09ORklHX01NVQo+PiArI2RlZmluZSBBRERSRVNTX1NQQUNFX0VORMKgwqDCoCAoVUwoLTEpKQo+ PiArLyoKPj4gKyAqIExlYXZlIDJHQiBmb3Iga2VybmVsIGFuZCBCUEYgYXQgdGhlIGVuZCBvZiB0 aGUgYWRkcmVzcyBzcGFjZQo+PiArICovCj4+ICsjZGVmaW5lIEtFUk5FTF9MSU5LX0FERFLCoMKg wqAgKEFERFJFU1NfU1BBQ0VfRU5EIC0gU1pfMkcgKyAxKQo+Pgo+PiDCoCNkZWZpbmUgVk1BTExP Q19TSVpFwqDCoMKgwqAgKEtFUk5fVklSVF9TSVpFID4+IDEpCj4+IMKgI2RlZmluZSBWTUFMTE9D X0VORMKgwqDCoMKgwqAgKFBBR0VfT0ZGU0VUIC0gMSkKPj4gwqAjZGVmaW5lIFZNQUxMT0NfU1RB UlTCoMKgwqAgKFBBR0VfT0ZGU0VUIC0gVk1BTExPQ19TSVpFKQo+Pgo+PiArLyogS0FTTFIgc2hv dWxkIGxlYXZlIGF0IGxlYXN0IDEyOE1CIGZvciBCUEYgYWZ0ZXIgdGhlIGtlcm5lbCAqLwo+PiDC oCNkZWZpbmUgQlBGX0pJVF9SRUdJT05fU0laRcKgwqDCoCAoU1pfMTI4TSkKPj4gLSNkZWZpbmUg QlBGX0pJVF9SRUdJT05fU1RBUlTCoMKgwqAgKFBBR0VfT0ZGU0VUIC0gQlBGX0pJVF9SRUdJT05f U0laRSkKPj4gLSNkZWZpbmUgQlBGX0pJVF9SRUdJT05fRU5EwqDCoMKgIChWTUFMTE9DX0VORCkK Pj4gKyNkZWZpbmUgQlBGX0pJVF9SRUdJT05fU1RBUlTCoMKgwqAgUEZOX0FMSUdOKCh1bnNpZ25l ZCBsb25nKSZfZW5kKQo+PiArI2RlZmluZSBCUEZfSklUX1JFR0lPTl9FTkTCoMKgwqAgKEJQRl9K SVRfUkVHSU9OX1NUQVJUICsgCj4+IEJQRl9KSVRfUkVHSU9OX1NJWkUpCj4+ICsKPj4gKy8qIE1v ZHVsZXMgYWx3YXlzIGxpdmUgYmVmb3JlIHRoZSBrZXJuZWwgKi8KPj4gKyNpZmRlZiBDT05GSUdf NjRCSVQKPj4gKyNkZWZpbmUgTU9EVUxFU19WQUREUsKgwqDCoCAoUEZOX0FMSUdOKCh1bnNpZ25l ZCBsb25nKSZfZW5kKSAtIFNaXzJHKQo+PiArI2RlZmluZSBNT0RVTEVTX0VORMKgwqDCoCAoUEZO X0FMSUdOKCh1bnNpZ25lZCBsb25nKSZfc3RhcnQpKQo+PiArI2VuZGlmCj4+Cj4+IMKgLyoKPj4g wqAgKiBSb3VnaGx5IHNpemUgdGhlIHZtZW1tYXAgc3BhY2UgdG8gYmUgbGFyZ2UgZW5vdWdoIHRv IGZpdCBlbm91Z2gKPj4gQEAgLTU3LDkgKzY0LDE2IEBACj4+IMKgI2RlZmluZSBGSVhBRERSX1NJ WkXCoMKgwqDCoCBQR0RJUl9TSVpFCj4+IMKgI2VuZGlmCj4+IMKgI2RlZmluZSBGSVhBRERSX1NU QVJUwqDCoMKgIChGSVhBRERSX1RPUCAtIEZJWEFERFJfU0laRSkKPj4gLQo+PiDCoCNlbmRpZgo+ Pgo+PiArI2lmbmRlZiBfX0FTU0VNQkxZX18KPj4gKwo+PiArLyogUGFnZSBVcHBlciBEaXJlY3Rv cnkgbm90IHVzZWQgaW4gUklTQy1WICovCj4+ICsjaW5jbHVkZSA8YXNtLWdlbmVyaWMvcGd0YWJs ZS1ub3B1ZC5oPgo+PiArI2luY2x1ZGUgPGFzbS9wYWdlLmg+Cj4+ICsjaW5jbHVkZSA8YXNtL3Rs YmZsdXNoLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvbW1fdHlwZXMuaD4KPj4gKwo+PiDCoCNpZmRl ZiBDT05GSUdfNjRCSVQKPj4gwqAjaW5jbHVkZSA8YXNtL3BndGFibGUtNjQuaD4KPj4gwqAjZWxz ZQo+PiBAQCAtNDg0LDYgKzQ5OCw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IHB0ZXBfY2xlYXJfZmx1 c2hfeW91bmcoc3RydWN0IAo+PiB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+Pgo+PiDCoCNkZWZpbmUg a2Vybl9hZGRyX3ZhbGlkKGFkZHIpwqDCoCAoMSkgLyogRklYTUUgKi8KPj4KPj4gK2V4dGVybiBj aGFyIF9zdGFydFtdOwo+PiDCoGV4dGVybiB2b2lkICpkdGJfZWFybHlfdmE7Cj4+IMKgZXh0ZXJu IHVpbnRwdHJfdCBkdGJfZWFybHlfcGE7Cj4+IMKgdm9pZCBzZXR1cF9ib290bWVtKHZvaWQpOwo+ PiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zZXRfbWVtb3J5LmggCj4+IGIv YXJjaC9yaXNjdi9pbmNsdWRlL2FzbS9zZXRfbWVtb3J5LmgKPj4gaW5kZXggNjg4N2IzZDlmMzcx Li5hOWM1Njc3NmZhMGUgMTAwNjQ0Cj4+IC0tLSBhL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2V0 X21lbW9yeS5oCj4+ICsrKyBiL2FyY2gvcmlzY3YvaW5jbHVkZS9hc20vc2V0X21lbW9yeS5oCj4+ IEBAIC0xNyw2ICsxNyw3IEBAIGludCBzZXRfbWVtb3J5X3godW5zaWduZWQgbG9uZyBhZGRyLCBp bnQgbnVtcGFnZXMpOwo+PiDCoGludCBzZXRfbWVtb3J5X254KHVuc2lnbmVkIGxvbmcgYWRkciwg aW50IG51bXBhZ2VzKTsKPj4gwqBpbnQgc2V0X21lbW9yeV9yd19ueCh1bnNpZ25lZCBsb25nIGFk ZHIsIGludCBudW1wYWdlcyk7Cj4+IMKgdm9pZCBwcm90ZWN0X2tlcm5lbF90ZXh0X2RhdGEodm9p ZCk7Cj4+ICt2b2lkIHByb3RlY3Rfa2VybmVsX2xpbmVhcl9tYXBwaW5nX3RleHRfcm9kYXRhKHZv aWQpOwo+PiDCoCNlbHNlCj4+IMKgc3RhdGljIGlubGluZSBpbnQgc2V0X21lbW9yeV9ybyh1bnNp Z25lZCBsb25nIGFkZHIsIGludCBudW1wYWdlcykgeyAKPj4gcmV0dXJuIDA7IH0KPj4gwqBzdGF0 aWMgaW5saW5lIGludCBzZXRfbWVtb3J5X3J3KHVuc2lnbmVkIGxvbmcgYWRkciwgaW50IG51bXBh Z2VzKSB7IAo+PiByZXR1cm4gMDsgfQo+PiBkaWZmIC0tZ2l0IGEvYXJjaC9yaXNjdi9rZXJuZWwv aGVhZC5TIGIvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TCj4+IGluZGV4IGY1YTliYWQ4NmU1OC4u NmNiMDVmMjJlNTJhIDEwMDY0NAo+PiAtLS0gYS9hcmNoL3Jpc2N2L2tlcm5lbC9oZWFkLlMKPj4g KysrIGIvYXJjaC9yaXNjdi9rZXJuZWwvaGVhZC5TCj4+IEBAIC02OSw3ICs2OSw4IEBAIHBlX2hl YWRfc3RhcnQ6Cj4+IMKgI2lmZGVmIENPTkZJR19NTVUKPj4gwqByZWxvY2F0ZToKPj4gwqDCoMKg wqAgLyogUmVsb2NhdGUgcmV0dXJuIGFkZHJlc3MgKi8KPj4gLcKgwqDCoCBsaSBhMSwgUEFHRV9P RkZTRVQKPj4gK8KgwqDCoCBsYSBhMSwga2VybmVsX3ZpcnRfYWRkcgo+PiArwqDCoMKgIFJFR19M IGExLCAwKGExKQo+PiDCoMKgwqDCoCBsYSBhMiwgX3N0YXJ0Cj4+IMKgwqDCoMKgIHN1YiBhMSwg YTEsIGEyCj4+IMKgwqDCoMKgIGFkZCByYSwgcmEsIGExCj4+IGRpZmYgLS1naXQgYS9hcmNoL3Jp c2N2L2tlcm5lbC9tb2R1bGUuYyBiL2FyY2gvcmlzY3Yva2VybmVsL21vZHVsZS5jCj4+IGluZGV4 IDEwNGZiYTg4OWNmNy4uY2UxNTM3NzFlNWU5IDEwMDY0NAo+PiAtLS0gYS9hcmNoL3Jpc2N2L2tl cm5lbC9tb2R1bGUuYwo+PiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9tb2R1bGUuYwo+PiBAQCAt NDA4LDEyICs0MDgsMTAgQEAgaW50IGFwcGx5X3JlbG9jYXRlX2FkZChFbGZfU2hkciAqc2VjaGRy cywgY29uc3QgCj4+IGNoYXIgKnN0cnRhYiwKPj4gwqB9Cj4+Cj4+IMKgI2lmIGRlZmluZWQoQ09O RklHX01NVSkgJiYgZGVmaW5lZChDT05GSUdfNjRCSVQpCj4+IC0jZGVmaW5lIFZNQUxMT0NfTU9E VUxFX1NUQVJUIFwKPj4gLcKgwqDCoMKgIG1heChQRk5fQUxJR04oKHVuc2lnbmVkIGxvbmcpJl9l bmQgLSBTWl8yRyksIFZNQUxMT0NfU1RBUlQpCj4+IMKgdm9pZCAqbW9kdWxlX2FsbG9jKHVuc2ln bmVkIGxvbmcgc2l6ZSkKPj4gwqB7Cj4+IC3CoMKgwqAgcmV0dXJuIF9fdm1hbGxvY19ub2RlX3Jh bmdlKHNpemUsIDEsIFZNQUxMT0NfTU9EVUxFX1NUQVJULAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgVk1BTExPQ19FTkQsIEdGUF9LRVJORUwsCj4+ICvCoMKgwqAg cmV0dXJuIF9fdm1hbGxvY19ub2RlX3JhbmdlKHNpemUsIDEsIE1PRFVMRVNfVkFERFIsCj4+ICvC oMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBNT0RVTEVTX0VORCwgR0ZQX0tF Uk5FTCwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBQQUdFX0tF Uk5FTF9FWEVDLCAwLCBOVU1BX05PX05PREUsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqAgX19idWlsdGluX3JldHVybl9hZGRyZXNzKDApKTsKPj4gwqB9Cj4+IGRp ZmYgLS1naXQgYS9hcmNoL3Jpc2N2L2tlcm5lbC9zZXR1cC5jIGIvYXJjaC9yaXNjdi9rZXJuZWwv c2V0dXAuYwo+PiBpbmRleCBlODViYWNmZjFiNTAuLjMwZTRhZjBmZDUwYyAxMDA2NDQKPj4gLS0t IGEvYXJjaC9yaXNjdi9rZXJuZWwvc2V0dXAuYwo+PiArKysgYi9hcmNoL3Jpc2N2L2tlcm5lbC9z ZXR1cC5jCj4+IEBAIC0yNjUsNiArMjY1LDExIEBAIHZvaWQgX19pbml0IHNldHVwX2FyY2goY2hh ciAqKmNtZGxpbmVfcCkKPj4KPj4gwqDCoMKgwqAgaWYgKElTX0VOQUJMRUQoQ09ORklHX1NUUklD VF9LRVJORUxfUldYKSkKPj4gwqDCoMKgwqDCoMKgwqDCoCBwcm90ZWN0X2tlcm5lbF90ZXh0X2Rh dGEoKTsKPj4gKwo+PiArI2lmIGRlZmluZWQoQ09ORklHXzY0QklUKSAmJiBkZWZpbmVkKENPTkZJ R19NTVUpCj4+ICvCoMKgwqAgcHJvdGVjdF9rZXJuZWxfbGluZWFyX21hcHBpbmdfdGV4dF9yb2Rh dGEoKTsKPj4gKyNlbmRpZgo+PiArCj4+IMKgI2lmZGVmIENPTkZJR19TV0lPVExCCj4+IMKgwqDC oMKgIHN3aW90bGJfaW5pdCgxKTsKPj4gwqAjZW5kaWYKPj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlz Y3Yva2VybmVsL3ZtbGludXgubGRzLlMgCj4+IGIvYXJjaC9yaXNjdi9rZXJuZWwvdm1saW51eC5s ZHMuUwo+PiBpbmRleCBkZTAzY2IyMmQwZTkuLjA3MjZjMDVlMDMzNiAxMDA2NDQKPj4gLS0tIGEv YXJjaC9yaXNjdi9rZXJuZWwvdm1saW51eC5sZHMuUwo+PiArKysgYi9hcmNoL3Jpc2N2L2tlcm5l bC92bWxpbnV4Lmxkcy5TCj4+IEBAIC00LDcgKzQsOCBAQAo+PiDCoCAqIENvcHlyaWdodCAoQykg MjAxNyBTaUZpdmUKPj4gwqAgKi8KPj4KPj4gLSNkZWZpbmUgTE9BRF9PRkZTRVQgUEFHRV9PRkZT RVQKPj4gKyNpbmNsdWRlIDxhc20vcGd0YWJsZS5oPgo+PiArI2RlZmluZSBMT0FEX09GRlNFVCBL RVJORUxfTElOS19BRERSCj4+IMKgI2luY2x1ZGUgPGFzbS92bWxpbnV4Lmxkcy5oPgo+PiDCoCNp bmNsdWRlIDxhc20vcGFnZS5oPgo+PiDCoCNpbmNsdWRlIDxhc20vY2FjaGUuaD4KPj4gZGlmZiAt LWdpdCBhL2FyY2gvcmlzY3YvbW0vZmF1bHQuYyBiL2FyY2gvcmlzY3YvbW0vZmF1bHQuYwo+PiBp bmRleCA4ZjE3NTE5MjA4YzcuLjFiMTRkNTIzYTk1YyAxMDA2NDQKPj4gLS0tIGEvYXJjaC9yaXNj di9tbS9mYXVsdC5jCj4+ICsrKyBiL2FyY2gvcmlzY3YvbW0vZmF1bHQuYwo+PiBAQCAtMjMxLDYg KzIzMSwxOSBAQCBhc21saW5rYWdlIHZvaWQgZG9fcGFnZV9mYXVsdChzdHJ1Y3QgcHRfcmVncyAq cmVncykKPj4gwqDCoMKgwqDCoMKgwqDCoCByZXR1cm47Cj4+IMKgwqDCoMKgIH0KPj4KPj4gKyNp ZmRlZiBDT05GSUdfNjRCSVQKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAgKiBNb2R1bGVzIGlu IDY0Yml0IGtlcm5lbHMgbGllIGluIHRoZWlyIG93biB2aXJ0dWFsIHJlZ2lvbiB3aGljaCAKPj4g aXMgbm90Cj4+ICvCoMKgwqDCoCAqIGluIHRoZSB2bWFsbG9jIHJlZ2lvbiwgYnV0IGRlYWxpbmcg d2l0aCBwYWdlIGZhdWx0cyBpbiB0aGlzIAo+PiByZWdpb24KPj4gK8KgwqDCoMKgICogb3IgdGhl IHZtYWxsb2MgcmVnaW9uIGFtb3VudHMgdG8gZG9pbmcgdGhlIHNhbWUgdGhpbmc6IAo+PiBjaGVj a2luZyB0aGF0Cj4+ICvCoMKgwqDCoCAqIHRoZSBtYXBwaW5nIGV4aXN0cyBpbiBpbml0X21tLnBn ZCBhbmQgdXBkYXRpbmcgdXNlciBwYWdlIAo+PiB0YWJsZSwgc28KPj4gK8KgwqDCoMKgICoganVz dCB1c2Ugdm1hbGxvY19mYXVsdC4KPj4gK8KgwqDCoMKgICovCj4+ICvCoMKgwqAgaWYgKHVubGlr ZWx5KGFkZHIgPj0gTU9EVUxFU19WQUREUiAmJiBhZGRyIDwgTU9EVUxFU19FTkQpKSB7Cj4+ICvC oMKgwqDCoMKgwqDCoCB2bWFsbG9jX2ZhdWx0KHJlZ3MsIGNvZGUsIGFkZHIpOwo+PiArwqDCoMKg wqDCoMKgwqAgcmV0dXJuOwo+PiArwqDCoMKgIH0KPj4gKyNlbmRpZgo+PiDCoMKgwqDCoCAvKiBF bmFibGUgaW50ZXJydXB0cyBpZiB0aGV5IHdlcmUgZW5hYmxlZCBpbiB0aGUgcGFyZW50IGNvbnRl eHQuICovCj4+IMKgwqDCoMKgIGlmIChsaWtlbHkocmVncy0+c3RhdHVzICYgU1JfUElFKSkKPj4g wqDCoMKgwqDCoMKgwqDCoCBsb2NhbF9pcnFfZW5hYmxlKCk7Cj4+IGRpZmYgLS1naXQgYS9hcmNo L3Jpc2N2L21tL2luaXQuYyBiL2FyY2gvcmlzY3YvbW0vaW5pdC5jCj4+IGluZGV4IDdmNTAzNmZi ZWU4Yy4uMDkzZjNhOTZlY2ZjIDEwMDY0NAo+PiAtLS0gYS9hcmNoL3Jpc2N2L21tL2luaXQuYwo+ PiArKysgYi9hcmNoL3Jpc2N2L21tL2luaXQuYwo+PiBAQCAtMjUsNiArMjUsOSBAQAo+Pgo+PiDC oCNpbmNsdWRlICIuLi9rZXJuZWwvaGVhZC5oIgo+Pgo+PiArdW5zaWduZWQgbG9uZyBrZXJuZWxf dmlydF9hZGRyID0gS0VSTkVMX0xJTktfQUREUjsKPj4gK0VYUE9SVF9TWU1CT0woa2VybmVsX3Zp cnRfYWRkcik7Cj4+ICsKPj4gwqB1bnNpZ25lZCBsb25nIGVtcHR5X3plcm9fcGFnZVtQQUdFX1NJ WkUgLyBzaXplb2YodW5zaWduZWQgbG9uZyldCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIF9fcGFnZV9hbGlnbmVkX2JzczsKPj4gwqBF WFBPUlRfU1lNQk9MKGVtcHR5X3plcm9fcGFnZSk7Cj4+IEBAIC04OCw2ICs5MSw4IEBAIHN0YXRp YyB2b2lkIHByaW50X3ZtX2xheW91dCh2b2lkKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoCAodW5z aWduZWQgbG9uZylWTUFMTE9DX0VORCk7Cj4+IMKgwqDCoMKgIHByaW50X21sbSgibG93bWVtIiwg KHVuc2lnbmVkIGxvbmcpUEFHRV9PRkZTRVQsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgICh1bnNp Z25lZCBsb25nKWhpZ2hfbWVtb3J5KTsKPj4gK8KgwqDCoCBwcmludF9tbG0oImtlcm5lbCIsICh1 bnNpZ25lZCBsb25nKUtFUk5FTF9MSU5LX0FERFIsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqAgKHVu c2lnbmVkIGxvbmcpQUREUkVTU19TUEFDRV9FTkQpOwo+PiDCoH0KPj4gwqAjZWxzZQo+PiDCoHN0 YXRpYyB2b2lkIHByaW50X3ZtX2xheW91dCh2b2lkKSB7IH0KPj4gQEAgLTExNiw4ICsxMjEsMTMg QEAgdm9pZCBfX2luaXQgc2V0dXBfYm9vdG1lbSh2b2lkKQo+PiDCoMKgwqDCoCAvKiBUaGUgbWF4 aW1hbCBwaHlzaWNhbCBtZW1vcnkgc2l6ZSBpcyAtUEFHRV9PRkZTRVQuICovCj4+IMKgwqDCoMKg IG1lbWJsb2NrX2VuZm9yY2VfbWVtb3J5X2xpbWl0KC1QQUdFX09GRlNFVCk7Cj4+Cj4+IC3CoMKg wqAgLyogUmVzZXJ2ZSBmcm9tIHRoZSBzdGFydCBvZiB0aGUga2VybmVsIHRvIHRoZSBlbmQgb2Yg dGhlIGtlcm5lbCAqLwo+PiAtwqDCoMKgIG1lbWJsb2NrX3Jlc2VydmUodm1saW51eF9zdGFydCwg dm1saW51eF9lbmQgLSB2bWxpbnV4X3N0YXJ0KTsKPj4gK8KgwqDCoCAvKgo+PiArwqDCoMKgwqAg KiBSZXNlcnZlIGZyb20gdGhlIHN0YXJ0IG9mIHRoZSBrZXJuZWwgdG8gdGhlIGVuZCBvZiB0aGUg a2VybmVsCj4+ICvCoMKgwqDCoCAqIGFuZCBtYWtlIHN1cmUgd2UgYWxpZ24gdGhlIHJlc2VydmF0 aW9uIG9uIFBNRF9TSVpFIHNpbmNlIHdlIHdpbGwKPj4gK8KgwqDCoMKgICogbWFwIHRoZSBrZXJu ZWwgaW4gdGhlIGxpbmVhciBtYXBwaW5nIGFzIHJlYWQtb25seTogd2UgZG8gbm90IHdhbnQKPj4g K8KgwqDCoMKgICogYW55IGFsbG9jYXRpb24gdG8gaGFwcGVuIGJldHdlZW4gX2VuZCBhbmQgdGhl IG5leHQgcG1kIGFsaWduZWQgCj4+IHBhZ2UuCj4+ICvCoMKgwqDCoCAqLwo+PiArwqDCoMKgIG1l bWJsb2NrX3Jlc2VydmUodm1saW51eF9zdGFydCwgKHZtbGludXhfZW5kIC0gdm1saW51eF9zdGFy dCArIAo+PiBQTURfU0laRSAtIDEpICYgUE1EX01BU0spOwo+Pgo+PiDCoMKgwqDCoCAvKgo+PiDC oMKgwqDCoMKgICogbWVtYmxvY2sgYWxsb2NhdG9yIGlzIG5vdCBhd2FyZSBvZiB0aGUgZmFjdCB0 aGF0IGxhc3QgNEsgYnl0ZXMgb2YKPj4gQEAgLTE1Miw4ICsxNjIsMTIgQEAgdm9pZCBfX2luaXQg c2V0dXBfYm9vdG1lbSh2b2lkKQo+PiDCoCNpZmRlZiBDT05GSUdfTU1VCj4+IMKgc3RhdGljIHN0 cnVjdCBwdF9hbGxvY19vcHMgcHRfb3BzOwo+Pgo+PiArLyogT2Zmc2V0IGJldHdlZW4gbGluZWFy IG1hcHBpbmcgdmlydHVhbCBhZGRyZXNzIGFuZCBrZXJuZWwgbG9hZCAKPj4gYWRkcmVzcyAqLwo+ PiDCoHVuc2lnbmVkIGxvbmcgdmFfcGFfb2Zmc2V0Owo+PiDCoEVYUE9SVF9TWU1CT0wodmFfcGFf b2Zmc2V0KTsKPj4gKy8qIE9mZnNldCBiZXR3ZWVuIGtlcm5lbCBtYXBwaW5nIHZpcnR1YWwgYWRk cmVzcyBhbmQga2VybmVsIGxvYWQgCj4+IGFkZHJlc3MgKi8KPj4gK3Vuc2lnbmVkIGxvbmcgdmFf a2VybmVsX3BhX29mZnNldDsKPj4gK0VYUE9SVF9TWU1CT0wodmFfa2VybmVsX3BhX29mZnNldCk7 Cj4+IMKgdW5zaWduZWQgbG9uZyBwZm5fYmFzZTsKPj4gwqBFWFBPUlRfU1lNQk9MKHBmbl9iYXNl KTsKPj4KPj4gQEAgLTI1Nyw3ICsyNzEsNyBAQCBzdGF0aWMgcG1kX3QgKmdldF9wbWRfdmlydF9s YXRlKHBoeXNfYWRkcl90IHBhKQo+Pgo+PiDCoHN0YXRpYyBwaHlzX2FkZHJfdCBfX2luaXQgYWxs b2NfcG1kX2Vhcmx5KHVpbnRwdHJfdCB2YSkKPj4gwqB7Cj4+IC3CoMKgwqAgQlVHX09OKCh2YSAt IFBBR0VfT0ZGU0VUKSA+PiBQR0RJUl9TSElGVCk7Cj4+ICvCoMKgwqAgQlVHX09OKCh2YSAtIGtl cm5lbF92aXJ0X2FkZHIpID4+IFBHRElSX1NISUZUKTsKPj4KPj4gwqDCoMKgwqAgcmV0dXJuICh1 aW50cHRyX3QpZWFybHlfcG1kOwo+PiDCoH0KPj4gQEAgLTM3MiwxNyArMzg2LDMyIEBAIHN0YXRp YyB1aW50cHRyX3QgX19pbml0IAo+PiBiZXN0X21hcF9zaXplKHBoeXNfYWRkcl90IGJhc2UsIHBo eXNfYWRkcl90IHNpemUpCj4+IMKgI2Vycm9yICJzZXR1cF92bSgpIGlzIGNhbGxlZCBmcm9tIGhl YWQuUyBiZWZvcmUgcmVsb2NhdGUgc28gaXQgc2hvdWxkIAo+PiBub3QgdXNlIGFic29sdXRlIGFk ZHJlc3NpbmcuIgo+PiDCoCNlbmRpZgo+Pgo+PiArdWludHB0cl90IGxvYWRfcGEsIGxvYWRfc3o7 Cj4+ICsKPj4gK3N0YXRpYyB2b2lkIF9faW5pdCBjcmVhdGVfa2VybmVsX3BhZ2VfdGFibGUocGdk X3QgKnBnZGlyLCB1aW50cHRyX3QgCj4+IG1hcF9zaXplKQo+PiArewo+PiArwqDCoMKgIHVpbnRw dHJfdCB2YSwgZW5kX3ZhOwo+PiArCj4+ICvCoMKgwqAgZW5kX3ZhID0ga2VybmVsX3ZpcnRfYWRk ciArIGxvYWRfc3o7Cj4+ICvCoMKgwqAgZm9yICh2YSA9IGtlcm5lbF92aXJ0X2FkZHI7IHZhIDwg ZW5kX3ZhOyB2YSArPSBtYXBfc2l6ZSkKPj4gK8KgwqDCoMKgwqDCoMKgIGNyZWF0ZV9wZ2RfbWFw cGluZyhwZ2RpciwgdmEsCj4+ICvCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg bG9hZF9wYSArICh2YSAtIGtlcm5lbF92aXJ0X2FkZHIpLAo+PiArwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIG1hcF9zaXplLCBQQUdFX0tFUk5FTF9FWEVDKTsKPj4gK30KPj4g Kwo+PiDCoGFzbWxpbmthZ2Ugdm9pZCBfX2luaXQgc2V0dXBfdm0odWludHB0cl90IGR0Yl9wYSkK Pj4gwqB7Cj4+IC3CoMKgwqAgdWludHB0cl90IHZhLCBwYSwgZW5kX3ZhOwo+PiAtwqDCoMKgIHVp bnRwdHJfdCBsb2FkX3BhID0gKHVpbnRwdHJfdCkoJl9zdGFydCk7Cj4+IC3CoMKgwqAgdWludHB0 cl90IGxvYWRfc3ogPSAodWludHB0cl90KSgmX2VuZCkgLSBsb2FkX3BhOwo+PiArwqDCoMKgIHVp bnRwdHJfdCBwYTsKPj4gwqDCoMKgwqAgdWludHB0cl90IG1hcF9zaXplOwo+PiDCoCNpZm5kZWYg X19QQUdFVEFCTEVfUE1EX0ZPTERFRAo+PiDCoMKgwqDCoCBwbWRfdCBmaXhfYm1hcF9zcG1kLCBm aXhfYm1hcF9lcG1kOwo+PiDCoCNlbmRpZgo+PiArwqDCoMKgIGxvYWRfcGEgPSAodWludHB0cl90 KSgmX3N0YXJ0KTsKPj4gK8KgwqDCoCBsb2FkX3N6ID0gKHVpbnRwdHJfdCkoJl9lbmQpIC0gbG9h ZF9wYTsKPj4KPj4gwqDCoMKgwqAgdmFfcGFfb2Zmc2V0ID0gUEFHRV9PRkZTRVQgLSBsb2FkX3Bh Owo+PiArwqDCoMKgIHZhX2tlcm5lbF9wYV9vZmZzZXQgPSBrZXJuZWxfdmlydF9hZGRyIC0gbG9h ZF9wYTsKPj4gKwo+PiDCoMKgwqDCoCBwZm5fYmFzZSA9IFBGTl9ET1dOKGxvYWRfcGEpOwo+Pgo+ PiDCoMKgwqDCoCAvKgo+PiBAQCAtNDEwLDI2ICs0MzksMjIgQEAgYXNtbGlua2FnZSB2b2lkIF9f aW5pdCBzZXR1cF92bSh1aW50cHRyX3QgZHRiX3BhKQo+PiDCoMKgwqDCoCBjcmVhdGVfcG1kX21h cHBpbmcoZml4bWFwX3BtZCwgRklYQUREUl9TVEFSVCwKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgICh1aW50cHRyX3QpZml4bWFwX3B0ZSwgUE1EX1NJWkUsIFBBR0VfVEFCTEUpOwo+ PiDCoMKgwqDCoCAvKiBTZXR1cCB0cmFtcG9saW5lIFBHRCBhbmQgUE1EICovCj4+IC3CoMKgwqAg Y3JlYXRlX3BnZF9tYXBwaW5nKHRyYW1wb2xpbmVfcGdfZGlyLCBQQUdFX09GRlNFVCwKPj4gK8Kg wqDCoCBjcmVhdGVfcGdkX21hcHBpbmcodHJhbXBvbGluZV9wZ19kaXIsIGtlcm5lbF92aXJ0X2Fk ZHIsCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCAodWludHB0cl90KXRyYW1wb2xp bmVfcG1kLCBQR0RJUl9TSVpFLCBQQUdFX1RBQkxFKTsKPj4gLcKgwqDCoCBjcmVhdGVfcG1kX21h cHBpbmcodHJhbXBvbGluZV9wbWQsIFBBR0VfT0ZGU0VULAo+PiArwqDCoMKgIGNyZWF0ZV9wbWRf bWFwcGluZyh0cmFtcG9saW5lX3BtZCwga2VybmVsX3ZpcnRfYWRkciwKPj4gwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgIGxvYWRfcGEsIFBNRF9TSVpFLCBQQUdFX0tFUk5FTF9FWEVDKTsK Pj4gwqAjZWxzZQo+PiDCoMKgwqDCoCAvKiBTZXR1cCB0cmFtcG9saW5lIFBHRCAqLwo+PiAtwqDC oMKgIGNyZWF0ZV9wZ2RfbWFwcGluZyh0cmFtcG9saW5lX3BnX2RpciwgUEFHRV9PRkZTRVQsCj4+ ICvCoMKgwqAgY3JlYXRlX3BnZF9tYXBwaW5nKHRyYW1wb2xpbmVfcGdfZGlyLCBrZXJuZWxfdmly dF9hZGRyLAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgbG9hZF9wYSwgUEdESVJf U0laRSwgUEFHRV9LRVJORUxfRVhFQyk7Cj4+IMKgI2VuZGlmCj4+Cj4+IMKgwqDCoMKgIC8qCj4+ IC3CoMKgwqDCoCAqIFNldHVwIGVhcmx5IFBHRCBjb3ZlcmluZyBlbnRpcmUga2VybmVsIHdoaWNo IHdpbGwgYWxsb3dzCj4+ICvCoMKgwqDCoCAqIFNldHVwIGVhcmx5IFBHRCBjb3ZlcmluZyBlbnRp cmUga2VybmVsIHdoaWNoIHdpbGwgYWxsb3cKPj4gwqDCoMKgwqDCoCAqIHVzIHRvIHJlYWNoIHBh Z2luZ19pbml0KCkuIFdlIG1hcCBhbGwgbWVtb3J5IGJhbmtzIGxhdGVyCj4+IMKgwqDCoMKgwqAg KiBpbiBzZXR1cF92bV9maW5hbCgpIGJlbG93Lgo+PiDCoMKgwqDCoMKgICovCj4+IC3CoMKgwqAg ZW5kX3ZhID0gUEFHRV9PRkZTRVQgKyBsb2FkX3N6Owo+PiAtwqDCoMKgIGZvciAodmEgPSBQQUdF X09GRlNFVDsgdmEgPCBlbmRfdmE7IHZhICs9IG1hcF9zaXplKQo+PiAtwqDCoMKgwqDCoMKgwqAg Y3JlYXRlX3BnZF9tYXBwaW5nKGVhcmx5X3BnX2RpciwgdmEsCj4+IC3CoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgbG9hZF9wYSArICh2YSAtIFBBR0VfT0ZGU0VUKSwKPj4gLcKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBtYXBfc2l6ZSwgUEFHRV9LRVJORUxf RVhFQyk7Cj4+ICvCoMKgwqAgY3JlYXRlX2tlcm5lbF9wYWdlX3RhYmxlKGVhcmx5X3BnX2Rpciwg bWFwX3NpemUpOwo+Pgo+PiDCoCNpZm5kZWYgX19QQUdFVEFCTEVfUE1EX0ZPTERFRAo+PiDCoMKg wqDCoCAvKiBTZXR1cCBlYXJseSBQTUQgZm9yIERUQiAqLwo+PiBAQCAtNDQ0LDcgKzQ2OSwxMiBA QCBhc21saW5rYWdlIHZvaWQgX19pbml0IHNldHVwX3ZtKHVpbnRwdHJfdCBkdGJfcGEpCj4+IMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBwYSArIFBNRF9TSVpFLCBQTURfU0laRSwgUEFH RV9LRVJORUwpOwo+PiDCoMKgwqDCoCBkdGJfZWFybHlfdmEgPSAodm9pZCAqKURUQl9FQVJMWV9C QVNFX1ZBICsgKGR0Yl9wYSAmIChQTURfU0laRSAtIAo+PiAxKSk7Cj4+IMKgI2Vsc2UgLyogQ09O RklHX0JVSUxUSU5fRFRCICovCj4+IC3CoMKgwqAgZHRiX2Vhcmx5X3ZhID0gX192YShkdGJfcGEp Owo+PiArwqDCoMKgIC8qCj4+ICvCoMKgwqDCoCAqIF9fdmEgY2FuJ3QgYmUgdXNlZCBzaW5jZSBp dCB3b3VsZCByZXR1cm4gYSBsaW5lYXIgbWFwcGluZyBhZGRyZXNzCj4+ICvCoMKgwqDCoCAqIHdo ZXJlYXMgZHRiX2Vhcmx5X3ZhIHdpbGwgYmUgdXNlZCBiZWZvcmUgc2V0dXBfdm1fZmluYWwgaW5z dGFsbHMKPj4gK8KgwqDCoMKgICogdGhlIGxpbmVhciBtYXBwaW5nLgo+PiArwqDCoMKgwqAgKi8K Pj4gK8KgwqDCoCBkdGJfZWFybHlfdmEgPSBrZXJuZWxfbWFwcGluZ19wYV90b192YShkdGJfcGEp Owo+PiDCoCNlbmRpZiAvKiBDT05GSUdfQlVJTFRJTl9EVEIgKi8KPj4gwqAjZWxzZQo+PiDCoCNp Zm5kZWYgQ09ORklHX0JVSUxUSU5fRFRCCj4+IEBAIC00NTYsNyArNDg2LDcgQEAgYXNtbGlua2Fn ZSB2b2lkIF9faW5pdCBzZXR1cF92bSh1aW50cHRyX3QgZHRiX3BhKQo+PiDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqAgcGEgKyBQR0RJUl9TSVpFLCBQR0RJUl9TSVpFLCBQQUdFX0tFUk5F TCk7Cj4+IMKgwqDCoMKgIGR0Yl9lYXJseV92YSA9ICh2b2lkICopRFRCX0VBUkxZX0JBU0VfVkEg KyAoZHRiX3BhICYgKFBHRElSX1NJWkUgCj4+IC0gMSkpOwo+PiDCoCNlbHNlIC8qIENPTkZJR19C VUlMVElOX0RUQiAqLwo+PiAtwqDCoMKgIGR0Yl9lYXJseV92YSA9IF9fdmEoZHRiX3BhKTsKPj4g K8KgwqDCoCBkdGJfZWFybHlfdmEgPSBrZXJuZWxfbWFwcGluZ19wYV90b192YShkdGJfcGEpOwo+ PiDCoCNlbmRpZiAvKiBDT05GSUdfQlVJTFRJTl9EVEIgKi8KPj4gwqAjZW5kaWYKPj4gwqDCoMKg wqAgZHRiX2Vhcmx5X3BhID0gZHRiX3BhOwo+PiBAQCAtNDkyLDYgKzUyMiwyMiBAQCBhc21saW5r YWdlIHZvaWQgX19pbml0IHNldHVwX3ZtKHVpbnRwdHJfdCBkdGJfcGEpCj4+IMKgI2VuZGlmCj4+ IMKgfQo+Pgo+PiArI2lmZGVmIENPTkZJR182NEJJVAo+PiArdm9pZCBwcm90ZWN0X2tlcm5lbF9s aW5lYXJfbWFwcGluZ190ZXh0X3JvZGF0YSh2b2lkKQo+PiArewo+PiArwqDCoMKgIHVuc2lnbmVk IGxvbmcgdGV4dF9zdGFydCA9ICh1bnNpZ25lZCBsb25nKWxtX2FsaWFzKF9zdGFydCk7Cj4+ICvC oMKgwqAgdW5zaWduZWQgbG9uZyBpbml0X3RleHRfc3RhcnQgPSAodW5zaWduZWQgCj4+IGxvbmcp bG1fYWxpYXMoX19pbml0X3RleHRfYmVnaW4pOwo+PiArwqDCoMKgIHVuc2lnbmVkIGxvbmcgcm9k YXRhX3N0YXJ0ID0gKHVuc2lnbmVkIAo+PiBsb25nKWxtX2FsaWFzKF9fc3RhcnRfcm9kYXRhKTsK Pj4gK8KgwqDCoCB1bnNpZ25lZCBsb25nIGRhdGFfc3RhcnQgPSAodW5zaWduZWQgbG9uZylsbV9h bGlhcyhfZGF0YSk7Cj4+ICsKPj4gK8KgwqDCoCBzZXRfbWVtb3J5X3JvKHRleHRfc3RhcnQsIChp bml0X3RleHRfc3RhcnQgLSB0ZXh0X3N0YXJ0KSA+PiAKPj4gUEFHRV9TSElGVCk7Cj4+ICvCoMKg wqAgc2V0X21lbW9yeV9ueCh0ZXh0X3N0YXJ0LCAoaW5pdF90ZXh0X3N0YXJ0IC0gdGV4dF9zdGFy dCkgPj4gCj4+IFBBR0VfU0hJRlQpOwo+PiArCj4+ICvCoMKgwqAgc2V0X21lbW9yeV9ybyhyb2Rh dGFfc3RhcnQsIChkYXRhX3N0YXJ0IC0gcm9kYXRhX3N0YXJ0KSA+PiAKPj4gUEFHRV9TSElGVCk7 Cj4+ICvCoMKgwqAgc2V0X21lbW9yeV9ueChyb2RhdGFfc3RhcnQsIChkYXRhX3N0YXJ0IC0gcm9k YXRhX3N0YXJ0KSA+PiAKPj4gUEFHRV9TSElGVCk7Cj4+ICt9Cj4+ICsjZW5kaWYKPj4gKwo+PiDC oHN0YXRpYyB2b2lkIF9faW5pdCBzZXR1cF92bV9maW5hbCh2b2lkKQo+PiDCoHsKPj4gwqDCoMKg wqAgdWludHB0cl90IHZhLCBtYXBfc2l6ZTsKPj4gQEAgLTUxMyw3ICs1NTksNyBAQCBzdGF0aWMg dm9pZCBfX2luaXQgc2V0dXBfdm1fZmluYWwodm9pZCkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDC oMKgwqDCoMKgIF9fcGFfc3ltYm9sKGZpeG1hcF9wZ2RfbmV4dCksCj4+IMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoCBQR0RJUl9TSVpFLCBQQUdFX1RBQkxFKTsKPj4KPj4gLcKgwqDCoCAv KiBNYXAgYWxsIG1lbW9yeSBiYW5rcyAqLwo+PiArwqDCoMKgIC8qIE1hcCBhbGwgbWVtb3J5IGJh bmtzIGluIHRoZSBsaW5lYXIgbWFwcGluZyAqLwo+PiDCoMKgwqDCoCBmb3JfZWFjaF9tZW1fcmFu Z2UoaSwgJnN0YXJ0LCAmZW5kKSB7Cj4+IMKgwqDCoMKgwqDCoMKgwqAgaWYgKHN0YXJ0ID49IGVu ZCkKPj4gwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIGJyZWFrOwo+PiBAQCAtNTI1LDEwICs1NzEs MTMgQEAgc3RhdGljIHZvaWQgX19pbml0IHNldHVwX3ZtX2ZpbmFsKHZvaWQpCj4+IMKgwqDCoMKg wqDCoMKgwqAgZm9yIChwYSA9IHN0YXJ0OyBwYSA8IGVuZDsgcGEgKz0gbWFwX3NpemUpIHsKPj4g wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIHZhID0gKHVpbnRwdHJfdClfX3ZhKHBhKTsKPj4gwqDC oMKgwqDCoMKgwqDCoMKgwqDCoMKgIGNyZWF0ZV9wZ2RfbWFwcGluZyhzd2FwcGVyX3BnX2Rpciwg dmEsIHBhLAo+PiAtwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAg bWFwX3NpemUsIFBBR0VfS0VSTkVMX0VYRUMpOwo+PiArwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqAgbWFwX3NpemUsIFBBR0VfS0VSTkVMKTsKPj4gwqDCoMKgwqDC oMKgwqDCoCB9Cj4+IMKgwqDCoMKgIH0KPj4KPj4gK8KgwqDCoCAvKiBNYXAgdGhlIGtlcm5lbCAq Lwo+PiArwqDCoMKgIGNyZWF0ZV9rZXJuZWxfcGFnZV90YWJsZShzd2FwcGVyX3BnX2RpciwgUE1E X1NJWkUpOwo+PiArCj4+IMKgwqDCoMKgIC8qIENsZWFyIGZpeG1hcCBQVEUgYW5kIFBNRCBtYXBw aW5ncyAqLwo+PiDCoMKgwqDCoCBjbGVhcl9maXhtYXAoRklYX1BURSk7Cj4+IMKgwqDCoMKgIGNs ZWFyX2ZpeG1hcChGSVhfUE1EKTsKPj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvbW0va2FzYW5f aW5pdC5jIGIvYXJjaC9yaXNjdi9tbS9rYXNhbl9pbml0LmMKPj4gaW5kZXggMmMzOWYwMzg2Njcz Li4yOGY0ZDUyY2YxN2UgMTAwNjQ0Cj4+IC0tLSBhL2FyY2gvcmlzY3YvbW0va2FzYW5faW5pdC5j Cj4+ICsrKyBiL2FyY2gvcmlzY3YvbW0va2FzYW5faW5pdC5jCj4+IEBAIC0xNzEsNiArMTcxLDEw IEBAIHZvaWQgX19pbml0IGthc2FuX2luaXQodm9pZCkKPj4gwqDCoMKgwqAgcGh5c19hZGRyX3Qg X3N0YXJ0LCBfZW5kOwo+PiDCoMKgwqDCoCB1NjQgaTsKPj4KPj4gK8KgwqDCoCAvKgo+PiArwqDC oMKgwqAgKiBQb3B1bGF0ZSBhbGwga2VybmVsIHZpcnR1YWwgYWRkcmVzcyBzcGFjZSB3aXRoIAo+ PiBrYXNhbl9lYXJseV9zaGFkb3dfcGFnZQo+PiArwqDCoMKgwqAgKiBleGNlcHQgZm9yIHRoZSBs aW5lYXIgbWFwcGluZyBhbmQgdGhlIG1vZHVsZXMva2VybmVsL0JQRiBtYXBwaW5nLgo+PiArwqDC oMKgwqAgKi8KPj4gwqDCoMKgwqAga2FzYW5fcG9wdWxhdGVfZWFybHlfc2hhZG93KCh2b2lkICop S0FTQU5fU0hBRE9XX1NUQVJULAo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKg wqDCoMKgICh2b2lkICopa2FzYW5fbWVtX3RvX3NoYWRvdygodm9pZCAqKQo+PiDCoMKgwqDCoMKg wqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgIFZN RU1NQVBfRU5EKSk7Cj4+IEBAIC0xODMsNiArMTg3LDcgQEAgdm9pZCBfX2luaXQga2FzYW5faW5p dCh2b2lkKQo+PiDCoMKgwqDCoMKgwqDCoMKgwqDCoMKgwqAgKHZvaWQgKilrYXNhbl9tZW1fdG9f c2hhZG93KCh2b2lkICopVk1BTExPQ19TVEFSVCksCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDC oCAodm9pZCAqKWthc2FuX21lbV90b19zaGFkb3coKHZvaWQgKilWTUFMTE9DX0VORCkpOwo+Pgo+ PiArwqDCoMKgIC8qIFBvcHVsYXRlIHRoZSBsaW5lYXIgbWFwcGluZyAqLwo+PiDCoMKgwqDCoCBm b3JfZWFjaF9tZW1fcmFuZ2UoaSwgJl9zdGFydCwgJl9lbmQpIHsKPj4gwqDCoMKgwqDCoMKgwqDC oCB2b2lkICpzdGFydCA9ICh2b2lkICopX192YShfc3RhcnQpOwo+PiDCoMKgwqDCoMKgwqDCoMKg IHZvaWQgKmVuZCA9ICh2b2lkICopX192YShfZW5kKTsKPj4gQEAgLTE5Myw2ICsxOTgsMTAgQEAg dm9pZCBfX2luaXQga2FzYW5faW5pdCh2b2lkKQo+PiDCoMKgwqDCoMKgwqDCoMKgIGthc2FuX3Bv cHVsYXRlKGthc2FuX21lbV90b19zaGFkb3coc3RhcnQpLCAKPj4ga2FzYW5fbWVtX3RvX3NoYWRv dyhlbmQpKTsKPj4gwqDCoMKgwqAgfTsKPj4KPj4gK8KgwqDCoCAvKiBQb3B1bGF0ZSBrZXJuZWws IEJQRiwgbW9kdWxlcyBtYXBwaW5nICovCj4+ICvCoMKgwqAga2FzYW5fcG9wdWxhdGUoa2FzYW5f bWVtX3RvX3NoYWRvdygoY29uc3Qgdm9pZCAqKU1PRFVMRVNfVkFERFIpLAo+PiArwqDCoMKgwqDC oMKgwqDCoMKgwqDCoMKgwqDCoCBrYXNhbl9tZW1fdG9fc2hhZG93KChjb25zdCB2b2lkICopQlBG X0pJVF9SRUdJT05fRU5EKSk7Cj4+ICsKPj4gwqDCoMKgwqAgZm9yIChpID0gMDsgaSA8IFBUUlNf UEVSX1BURTsgaSsrKQo+PiDCoMKgwqDCoMKgwqDCoMKgIHNldF9wdGUoJmthc2FuX2Vhcmx5X3No YWRvd19wdGVbaV0sCj4+IMKgwqDCoMKgwqDCoMKgwqDCoMKgwqDCoCBta19wdGUodmlydF90b19w YWdlKGthc2FuX2Vhcmx5X3NoYWRvd19wYWdlKSwKPj4gZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3Yv bW0vcGh5c2FkZHIuYyBiL2FyY2gvcmlzY3YvbW0vcGh5c2FkZHIuYwo+PiBpbmRleCBlOGU0ZGNk MzlmZWQuLjM1NzAzZDVlZjVmZCAxMDA2NDQKPj4gLS0tIGEvYXJjaC9yaXNjdi9tbS9waHlzYWRk ci5jCj4+ICsrKyBiL2FyY2gvcmlzY3YvbW0vcGh5c2FkZHIuYwo+PiBAQCAtMjMsNyArMjMsNyBA QCBFWFBPUlRfU1lNQk9MKF9fdmlydF90b19waHlzKTsKPj4KPj4gwqBwaHlzX2FkZHJfdCBfX3Bo eXNfYWRkcl9zeW1ib2wodW5zaWduZWQgbG9uZyB4KQo+PiDCoHsKPj4gLcKgwqDCoCB1bnNpZ25l ZCBsb25nIGtlcm5lbF9zdGFydCA9ICh1bnNpZ25lZCBsb25nKVBBR0VfT0ZGU0VUOwo+PiArwqDC oMKgIHVuc2lnbmVkIGxvbmcga2VybmVsX3N0YXJ0ID0gKHVuc2lnbmVkIGxvbmcpa2VybmVsX3Zp cnRfYWRkcjsKPj4gwqDCoMKgwqAgdW5zaWduZWQgbG9uZyBrZXJuZWxfZW5kID0gKHVuc2lnbmVk IGxvbmcpX2VuZDsKPj4KPj4gwqDCoMKgwqAgLyoKPiAKPiBUaGlzIGlzIGJyZWFraW5nIGJvb3Qg Zm9yIG1lIHdpdGggQ09ORklHX1NUUklDVF9LRVJORUxfUldYPW4uwqAgSSdtIG5vdCAKPiBldmVu IHJlYWxseSBjb252aW5jZWQgdGhhdCdzIGEgdXNlZnVsIGNvbmZpZyB0byBzdXBwb3J0LCBidXQg aXQncyAKPiBjdXJyZW50bHkgb3B0aW9uYWwgYW5kIEknZCBwcmVmZXIgdG8gYXZvaWQgYnJlYWtp bmcgaXQgaWYgcG9zc2libGUuCj4gCj4gSSBjYW4ndCBxdWl0ZSBmaWd1cmUgb3V0IHdoYXQncyBn b2luZyBvbiBoZXJlIGFuZCBJJ20gcHJldHR5IG11Y2ggdGlyZWQgCj4gb3V0IGZvciB0b25pZ2h0 LsKgIExNSyBpZiB5b3UgZG9uJ3QgaGF2ZSB0aW1lIHRvIGxvb2sgYXQgaXQgYW5kIEknbGwgdHJ5 IAo+IHRvIGdpdmUgaXQgYW5vdGhlciBzaG90LgoKSSdtIHRha2luZyBhIGxvb2sgYXQgdGhhdC4K ClRoYW5rcywKCkFsZXgKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRl YWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgt cmlzY3YK