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,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 7CD20C11F66 for ; Mon, 12 Jul 2021 23:56:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 68BFA610A7 for ; Mon, 12 Jul 2021 23:56:25 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233505AbhGLX7I (ORCPT ); Mon, 12 Jul 2021 19:59:08 -0400 Received: from mga01.intel.com ([192.55.52.88]:3170 "EHLO mga01.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232562AbhGLX7D (ORCPT ); Mon, 12 Jul 2021 19:59:03 -0400 X-IronPort-AV: E=McAfee;i="6200,9189,10043"; a="231868182" X-IronPort-AV: E=Sophos;i="5.84,235,1620716400"; d="scan'208";a="231868182" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 16:56:12 -0700 X-IronPort-AV: E=Sophos;i="5.84,235,1620716400"; d="scan'208";a="429846783" Received: from iweiny-desk2.sc.intel.com (HELO localhost) ([10.3.52.147]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 16:56:11 -0700 Date: Mon, 12 Jul 2021 16:56:11 -0700 From: Ira Weiny To: Christoph Hellwig Cc: Linus Torvalds , Andrew Morton , "James E.J. Bottomley" , Russell King , Guo Ren , Thomas Bogendoerfer , Nick Hu , Greentime Hu , Vincent Chen , Helge Deller , Yoshinori Sato , Rich Felker , Geoff Levand , Paul Cercueil , Ulf Hansson , Alex Shi , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-csky@vger.kernel.org, linux-mips@vger.kernel.org, linux-parisc@vger.kernel.org, linux-sh@vger.kernel.org, linux-mmc@vger.kernel.org, linux-scsi@vger.kernel.org, linux-mm@kvack.org, linux-doc@vger.kernel.org Subject: Re: [PATCH 6/6] mm: remove flush_kernel_dcache_page Message-ID: <20210712235611.GC3169279@iweiny-DESK2.sc.intel.com> References: <20210712060928.4161649-1-hch@lst.de> <20210712060928.4161649-7-hch@lst.de> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20210712060928.4161649-7-hch@lst.de> User-Agent: Mutt/1.11.1 (2018-12-01) Precedence: bulk List-ID: X-Mailing-List: linux-sh@vger.kernel.org On Mon, Jul 12, 2021 at 08:09:28AM +0200, Christoph Hellwig wrote: > flush_kernel_dcache_page is a rather confusing interface that implements > a subset of flush_dcache_page by not being able to properly handle page > cache mapped pages. > > The only callers left are in the exec code as all other previous callers > were incorrect as they could have dealt with page cache pages. Replace > the calls to flush_kernel_dcache_page with calls to > flush_kernel_dcache_page, which for all architectures does either ^^^^^^^^^^^^^^^^^^^^^^^^ flush_dcache_page Other than that, for the series: Reviewed-by: Ira Weiny > exactly the same thing, can contains one or more of the following: > > 1) an optimization to defer the cache flush for page cache pages not > mapped into userspace > 2) additional flushing for mapped page cache pages if cache aliases > are possible > > Signed-off-by: Christoph Hellwig > --- > Documentation/core-api/cachetlb.rst | 86 ++++++++----------- > .../translations/zh_CN/core-api/cachetlb.rst | 9 -- > arch/arm/include/asm/cacheflush.h | 4 +- > arch/arm/mm/flush.c | 33 ------- > arch/arm/mm/nommu.c | 6 -- > arch/csky/abiv1/cacheflush.c | 11 --- > arch/csky/abiv1/inc/abi/cacheflush.h | 4 +- > arch/mips/include/asm/cacheflush.h | 8 +- > arch/nds32/include/asm/cacheflush.h | 3 +- > arch/nds32/mm/cacheflush.c | 9 -- > arch/parisc/include/asm/cacheflush.h | 8 +- > arch/parisc/kernel/cache.c | 3 +- > arch/sh/include/asm/cacheflush.h | 8 +- > block/blk-map.c | 2 +- > fs/exec.c | 6 +- > include/linux/highmem.h | 5 +- > tools/testing/scatterlist/linux/mm.h | 1 - > 17 files changed, 51 insertions(+), 155 deletions(-) > > diff --git a/Documentation/core-api/cachetlb.rst b/Documentation/core-api/cachetlb.rst > index fe4290e26729..8aed9103e48a 100644 > --- a/Documentation/core-api/cachetlb.rst > +++ b/Documentation/core-api/cachetlb.rst > @@ -271,10 +271,15 @@ maps this page at its virtual address. > > ``void flush_dcache_page(struct page *page)`` > > - Any time the kernel writes to a page cache page, _OR_ > - the kernel is about to read from a page cache page and > - user space shared/writable mappings of this page potentially > - exist, this routine is called. > + This routines must be called when: > + > + a) the kernel did write to a page that is in the page cache page > + and / or in high memory > + b) the kernel is about to read from a page cache page and user space > + shared/writable mappings of this page potentially exist. Note > + that {get,pin}_user_pages{_fast} already call flush_dcache_page > + on any page found in the user address space and thus driver > + code rarely needs to take this into account. > > .. note:: > > @@ -284,38 +289,34 @@ maps this page at its virtual address. > handling vfs symlinks in the page cache need not call > this interface at all. > > - The phrase "kernel writes to a page cache page" means, > - specifically, that the kernel executes store instructions > - that dirty data in that page at the page->virtual mapping > - of that page. It is important to flush here to handle > - D-cache aliasing, to make sure these kernel stores are > - visible to user space mappings of that page. > - > - The corollary case is just as important, if there are users > - which have shared+writable mappings of this file, we must make > - sure that kernel reads of these pages will see the most recent > - stores done by the user. > - > - If D-cache aliasing is not an issue, this routine may > - simply be defined as a nop on that architecture. > - > - There is a bit set aside in page->flags (PG_arch_1) as > - "architecture private". The kernel guarantees that, > - for pagecache pages, it will clear this bit when such > - a page first enters the pagecache. > - > - This allows these interfaces to be implemented much more > - efficiently. It allows one to "defer" (perhaps indefinitely) > - the actual flush if there are currently no user processes > - mapping this page. See sparc64's flush_dcache_page and > - update_mmu_cache implementations for an example of how to go > - about doing this. > - > - The idea is, first at flush_dcache_page() time, if > - page->mapping->i_mmap is an empty tree, just mark the architecture > - private page flag bit. Later, in update_mmu_cache(), a check is > - made of this flag bit, and if set the flush is done and the flag > - bit is cleared. > + The phrase "kernel writes to a page cache page" means, specifically, > + that the kernel executes store instructions that dirty data in that > + page at the page->virtual mapping of that page. It is important to > + flush here to handle D-cache aliasing, to make sure these kernel stores > + are visible to user space mappings of that page. > + > + The corollary case is just as important, if there are users which have > + shared+writable mappings of this file, we must make sure that kernel > + reads of these pages will see the most recent stores done by the user. > + > + If D-cache aliasing is not an issue, this routine may simply be defined > + as a nop on that architecture. > + > + There is a bit set aside in page->flags (PG_arch_1) as "architecture > + private". The kernel guarantees that, for pagecache pages, it will > + clear this bit when such a page first enters the pagecache. > + > + This allows these interfaces to be implemented much more efficiently. > + It allows one to "defer" (perhaps indefinitely) the actual flush if > + there are currently no user processes mapping this page. See sparc64's > + flush_dcache_page and update_mmu_cache implementations for an example > + of how to go about doing this. > + > + The idea is, first at flush_dcache_page() time, if page_file_mapping() > + returns a mapping, and mapping_mapped on that mapping returns %false, > + just mark the architecture private page flag bit. Later, in > + update_mmu_cache(), a check is made of this flag bit, and if set the > + flush is done and the flag bit is cleared. > > .. important:: > > @@ -351,19 +352,6 @@ maps this page at its virtual address. > architectures). For incoherent architectures, it should flush > the cache of the page at vmaddr. > > - ``void flush_kernel_dcache_page(struct page *page)`` > - > - When the kernel needs to modify a user page is has obtained > - with kmap, it calls this function after all modifications are > - complete (but before kunmapping it) to bring the underlying > - page up to date. It is assumed here that the user has no > - incoherent cached copies (i.e. the original page was obtained > - from a mechanism like get_user_pages()). The default > - implementation is a nop and should remain so on all coherent > - architectures. On incoherent architectures, this should flush > - the kernel cache for page (using page_address(page)). > - > - > ``void flush_icache_range(unsigned long start, unsigned long end)`` > > When the kernel stores into addresses that it will execute > diff --git a/Documentation/translations/zh_CN/core-api/cachetlb.rst b/Documentation/translations/zh_CN/core-api/cachetlb.rst > index 8376485a534d..55827b8a7c53 100644 > --- a/Documentation/translations/zh_CN/core-api/cachetlb.rst > +++ b/Documentation/translations/zh_CN/core-api/cachetlb.rst > @@ -298,15 +298,6 @@ HyperSparc cpu就是这样一个具有这种属性的cpu。 > 用。默认的实现是nop（对于所有相干的架构应该保持这样）。对于不一致性 > 的架构，它应该刷新vmaddr处的页面缓存。 > > - ``void flush_kernel_dcache_page(struct page *page)`` > - > - 当内核需要修改一个用kmap获得的用户页时，它会在所有修改完成后（但在 > - kunmapping之前）调用这个函数，以使底层页面达到最新状态。这里假定用 > - 户没有不一致性的缓存副本（即原始页面是从类似get_user_pages()的机制 > - 中获得的）。默认的实现是一个nop，在所有相干的架构上都应该如此。在不 > - 一致性的架构上，这应该刷新内核缓存中的页面（使用page_address(page)）。 > - > - > ``void flush_icache_range(unsigned long start, unsigned long end)`` > > 当内核存储到它将执行的地址中时（例如在加载模块时），这个函数被调用。 > diff --git a/arch/arm/include/asm/cacheflush.h b/arch/arm/include/asm/cacheflush.h > index 2e24e765e6d3..5e56288e343b 100644 > --- a/arch/arm/include/asm/cacheflush.h > +++ b/arch/arm/include/asm/cacheflush.h > @@ -291,6 +291,7 @@ extern void flush_cache_page(struct vm_area_struct *vma, unsigned long user_addr > #define ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE 1 > extern void flush_dcache_page(struct page *); > > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > static inline void flush_kernel_vmap_range(void *addr, int size) > { > if ((cache_is_vivt() || cache_is_vipt_aliasing())) > @@ -312,9 +313,6 @@ static inline void flush_anon_page(struct vm_area_struct *vma, > __flush_anon_page(vma, page, vmaddr); > } > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -extern void flush_kernel_dcache_page(struct page *); > - > #define flush_dcache_mmap_lock(mapping) xa_lock_irq(&mapping->i_pages) > #define flush_dcache_mmap_unlock(mapping) xa_unlock_irq(&mapping->i_pages) > > diff --git a/arch/arm/mm/flush.c b/arch/arm/mm/flush.c > index 6d89db7895d1..7ff9feea13a6 100644 > --- a/arch/arm/mm/flush.c > +++ b/arch/arm/mm/flush.c > @@ -345,39 +345,6 @@ void flush_dcache_page(struct page *page) > } > EXPORT_SYMBOL(flush_dcache_page); > > -/* > - * Ensure cache coherency for the kernel mapping of this page. We can > - * assume that the page is pinned via kmap. > - * > - * If the page only exists in the page cache and there are no user > - * space mappings, this is a no-op since the page was already marked > - * dirty at creation. Otherwise, we need to flush the dirty kernel > - * cache lines directly. > - */ > -void flush_kernel_dcache_page(struct page *page) > -{ > - if (cache_is_vivt() || cache_is_vipt_aliasing()) { > - struct address_space *mapping; > - > - mapping = page_mapping_file(page); > - > - if (!mapping || mapping_mapped(mapping)) { > - void *addr; > - > - addr = page_address(page); > - /* > - * kmap_atomic() doesn't set the page virtual > - * address for highmem pages, and > - * kunmap_atomic() takes care of cache > - * flushing already. > - */ > - if (!IS_ENABLED(CONFIG_HIGHMEM) || addr) > - __cpuc_flush_dcache_area(addr, PAGE_SIZE); > - } > - } > -} > -EXPORT_SYMBOL(flush_kernel_dcache_page); > - > /* > * Flush an anonymous page so that users of get_user_pages() > * can safely access the data. The expected sequence is: > diff --git a/arch/arm/mm/nommu.c b/arch/arm/mm/nommu.c > index 8b3d7191e2b8..2658f52903da 100644 > --- a/arch/arm/mm/nommu.c > +++ b/arch/arm/mm/nommu.c > @@ -166,12 +166,6 @@ void flush_dcache_page(struct page *page) > } > EXPORT_SYMBOL(flush_dcache_page); > > -void flush_kernel_dcache_page(struct page *page) > -{ > - __cpuc_flush_dcache_area(page_address(page), PAGE_SIZE); > -} > -EXPORT_SYMBOL(flush_kernel_dcache_page); > - > void copy_to_user_page(struct vm_area_struct *vma, struct page *page, > unsigned long uaddr, void *dst, const void *src, > unsigned long len) > diff --git a/arch/csky/abiv1/cacheflush.c b/arch/csky/abiv1/cacheflush.c > index 07ff17ea33de..fb91b069dc69 100644 > --- a/arch/csky/abiv1/cacheflush.c > +++ b/arch/csky/abiv1/cacheflush.c > @@ -56,17 +56,6 @@ void update_mmu_cache(struct vm_area_struct *vma, unsigned long addr, > } > } > > -void flush_kernel_dcache_page(struct page *page) > -{ > - struct address_space *mapping; > - > - mapping = page_mapping_file(page); > - > - if (!mapping || mapping_mapped(mapping)) > - dcache_wbinv_all(); > -} > -EXPORT_SYMBOL(flush_kernel_dcache_page); > - > void flush_cache_range(struct vm_area_struct *vma, unsigned long start, > unsigned long end) > { > diff --git a/arch/csky/abiv1/inc/abi/cacheflush.h b/arch/csky/abiv1/inc/abi/cacheflush.h > index 6cab7afae962..ed62e2066ba7 100644 > --- a/arch/csky/abiv1/inc/abi/cacheflush.h > +++ b/arch/csky/abiv1/inc/abi/cacheflush.h > @@ -14,12 +14,10 @@ extern void flush_dcache_page(struct page *); > #define flush_cache_page(vma, page, pfn) cache_wbinv_all() > #define flush_cache_dup_mm(mm) cache_wbinv_all() > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -extern void flush_kernel_dcache_page(struct page *); > - > #define flush_dcache_mmap_lock(mapping) xa_lock_irq(&mapping->i_pages) > #define flush_dcache_mmap_unlock(mapping) xa_unlock_irq(&mapping->i_pages) > > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > static inline void flush_kernel_vmap_range(void *addr, int size) > { > dcache_wbinv_all(); > diff --git a/arch/mips/include/asm/cacheflush.h b/arch/mips/include/asm/cacheflush.h > index d687b40b9fbb..b3dc9c589442 100644 > --- a/arch/mips/include/asm/cacheflush.h > +++ b/arch/mips/include/asm/cacheflush.h > @@ -125,13 +125,7 @@ static inline void kunmap_noncoherent(void) > kunmap_coherent(); > } > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -static inline void flush_kernel_dcache_page(struct page *page) > -{ > - BUG_ON(cpu_has_dc_aliases && PageHighMem(page)); > - flush_dcache_page(page); > -} > - > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > /* > * For now flush_kernel_vmap_range and invalidate_kernel_vmap_range both do a > * cache writeback and invalidate operation. > diff --git a/arch/nds32/include/asm/cacheflush.h b/arch/nds32/include/asm/cacheflush.h > index 7d6824f7c0e8..c2a222ebfa2a 100644 > --- a/arch/nds32/include/asm/cacheflush.h > +++ b/arch/nds32/include/asm/cacheflush.h > @@ -36,8 +36,7 @@ void copy_from_user_page(struct vm_area_struct *vma, struct page *page, > void flush_anon_page(struct vm_area_struct *vma, > struct page *page, unsigned long vaddr); > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -void flush_kernel_dcache_page(struct page *page); > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > void flush_kernel_vmap_range(void *addr, int size); > void invalidate_kernel_vmap_range(void *addr, int size); > #define flush_dcache_mmap_lock(mapping) xa_lock_irq(&(mapping)->i_pages) > diff --git a/arch/nds32/mm/cacheflush.c b/arch/nds32/mm/cacheflush.c > index ad5344ef5d33..07aac65d1cab 100644 > --- a/arch/nds32/mm/cacheflush.c > +++ b/arch/nds32/mm/cacheflush.c > @@ -318,15 +318,6 @@ void flush_anon_page(struct vm_area_struct *vma, > local_irq_restore(flags); > } > > -void flush_kernel_dcache_page(struct page *page) > -{ > - unsigned long flags; > - local_irq_save(flags); > - cpu_dcache_wbinval_page((unsigned long)page_address(page)); > - local_irq_restore(flags); > -} > -EXPORT_SYMBOL(flush_kernel_dcache_page); > - > void flush_kernel_vmap_range(void *addr, int size) > { > unsigned long flags; > diff --git a/arch/parisc/include/asm/cacheflush.h b/arch/parisc/include/asm/cacheflush.h > index 99663fc1f997..eef0096db5f8 100644 > --- a/arch/parisc/include/asm/cacheflush.h > +++ b/arch/parisc/include/asm/cacheflush.h > @@ -36,16 +36,12 @@ void flush_cache_all_local(void); > void flush_cache_all(void); > void flush_cache_mm(struct mm_struct *mm); > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > void flush_kernel_dcache_page_addr(void *addr); > -static inline void flush_kernel_dcache_page(struct page *page) > -{ > - flush_kernel_dcache_page_addr(page_address(page)); > -} > > #define flush_kernel_dcache_range(start,size) \ > flush_kernel_dcache_range_asm((start), (start)+(size)); > > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > void flush_kernel_vmap_range(void *vaddr, int size); > void invalidate_kernel_vmap_range(void *vaddr, int size); > > @@ -59,7 +55,7 @@ extern void flush_dcache_page(struct page *page); > #define flush_dcache_mmap_unlock(mapping) xa_unlock_irq(&mapping->i_pages) > > #define flush_icache_page(vma,page) do { \ > - flush_kernel_dcache_page(page); \ > + flush_kernel_dcache_page_addr(page_address(page)); \ > flush_kernel_icache_page(page_address(page)); \ > } while (0) > > diff --git a/arch/parisc/kernel/cache.c b/arch/parisc/kernel/cache.c > index 86a1a63563fd..39e02227e231 100644 > --- a/arch/parisc/kernel/cache.c > +++ b/arch/parisc/kernel/cache.c > @@ -334,7 +334,7 @@ void flush_dcache_page(struct page *page) > return; > } > > - flush_kernel_dcache_page(page); > + flush_kernel_dcache_page_addr(page_address(page)); > > if (!mapping) > return; > @@ -375,7 +375,6 @@ EXPORT_SYMBOL(flush_dcache_page); > > /* Defined in arch/parisc/kernel/pacache.S */ > EXPORT_SYMBOL(flush_kernel_dcache_range_asm); > -EXPORT_SYMBOL(flush_kernel_dcache_page_asm); > EXPORT_SYMBOL(flush_data_cache_local); > EXPORT_SYMBOL(flush_kernel_icache_range_asm); > > diff --git a/arch/sh/include/asm/cacheflush.h b/arch/sh/include/asm/cacheflush.h > index 4486a865ff62..372afa82fee6 100644 > --- a/arch/sh/include/asm/cacheflush.h > +++ b/arch/sh/include/asm/cacheflush.h > @@ -63,6 +63,8 @@ static inline void flush_anon_page(struct vm_area_struct *vma, > if (boot_cpu_data.dcache.n_aliases && PageAnon(page)) > __flush_anon_page(page, vmaddr); > } > + > +#define ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE 1 > static inline void flush_kernel_vmap_range(void *addr, int size) > { > __flush_wback_region(addr, size); > @@ -72,12 +74,6 @@ static inline void invalidate_kernel_vmap_range(void *addr, int size) > __flush_invalidate_region(addr, size); > } > > -#define ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -static inline void flush_kernel_dcache_page(struct page *page) > -{ > - flush_dcache_page(page); > -} > - > extern void copy_to_user_page(struct vm_area_struct *vma, > struct page *page, unsigned long vaddr, void *dst, const void *src, > unsigned long len); > diff --git a/block/blk-map.c b/block/blk-map.c > index 3743158ddaeb..4639bc6b5c62 100644 > --- a/block/blk-map.c > +++ b/block/blk-map.c > @@ -309,7 +309,7 @@ static int bio_map_user_iov(struct request *rq, struct iov_iter *iter, > > static void bio_invalidate_vmalloc_pages(struct bio *bio) > { > -#ifdef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > +#ifdef ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE > if (bio->bi_private && !op_is_write(bio_op(bio))) { > unsigned long i, len = 0; > > diff --git a/fs/exec.c b/fs/exec.c > index 38f63451b928..41a888d4edde 100644 > --- a/fs/exec.c > +++ b/fs/exec.c > @@ -574,7 +574,7 @@ static int copy_strings(int argc, struct user_arg_ptr argv, > } > > if (kmapped_page) { > - flush_kernel_dcache_page(kmapped_page); > + flush_dcache_page(kmapped_page); > kunmap(kmapped_page); > put_arg_page(kmapped_page); > } > @@ -592,7 +592,7 @@ static int copy_strings(int argc, struct user_arg_ptr argv, > ret = 0; > out: > if (kmapped_page) { > - flush_kernel_dcache_page(kmapped_page); > + flush_dcache_page(kmapped_page); > kunmap(kmapped_page); > put_arg_page(kmapped_page); > } > @@ -634,7 +634,7 @@ int copy_string_kernel(const char *arg, struct linux_binprm *bprm) > kaddr = kmap_atomic(page); > flush_arg_page(bprm, pos & PAGE_MASK, page); > memcpy(kaddr + offset_in_page(pos), arg, bytes_to_copy); > - flush_kernel_dcache_page(page); > + flush_dcache_page(page); > kunmap_atomic(kaddr); > put_arg_page(page); > } > diff --git a/include/linux/highmem.h b/include/linux/highmem.h > index 8c6e8e996c87..e95551bf99e9 100644 > --- a/include/linux/highmem.h > +++ b/include/linux/highmem.h > @@ -130,10 +130,7 @@ static inline void flush_anon_page(struct vm_area_struct *vma, struct page *page > } > #endif > > -#ifndef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE > -static inline void flush_kernel_dcache_page(struct page *page) > -{ > -} > +#ifndef ARCH_IMPLEMENTS_FLUSH_KERNEL_VMAP_RANGE > static inline void flush_kernel_vmap_range(void *vaddr, int size) > { > } > diff --git a/tools/testing/scatterlist/linux/mm.h b/tools/testing/scatterlist/linux/mm.h > index f9a12005fcea..16ec895bbe5f 100644 > --- a/tools/testing/scatterlist/linux/mm.h > +++ b/tools/testing/scatterlist/linux/mm.h > @@ -127,7 +127,6 @@ kmalloc_array(unsigned int n, unsigned int size, unsigned int flags) > #define kmemleak_free(a) > > #define PageSlab(p) (0) > -#define flush_kernel_dcache_page(p) > > #define MAX_ERRNO 4095 > > -- > 2.30.2 > > 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.9 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,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 65959C07E9A for ; Mon, 12 Jul 2021 23:59: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 277D0610A7 for ; Mon, 12 Jul 2021 23:59:07 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 277D0610A7 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+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.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:In-Reply-To:MIME-Version:References: Message-ID:Subject:Cc:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=Gp+Um4NoxasXmNWPwuwW0fjw6gxMilLLvnhf/VyluLI=; b=2d+2Ven9XVSPFd rRlrl8aq5rRnY7V0jw9op/hHTghJTSuyRqPQfj2W+2ZYt1kf3jxzezwD0Vh8X1fGMypyTWZRbT8JD RXT4BlKkJZfCuzLSJD80HwSKdm7zvMCfvpvULRZ9CbMCXmHHlWsp3r2hXaeCbVpveEpcWb8llzURq sQ1nvoLf+kAE/bZp2g0/Llz4/8Ev5Z8MqHw3XgIIBP7WHgLgKFcQGrQYRXqx1yuVEdULqH9PMwXTR 2TZk8ahWbfn0R4Aq2ipXKGAkdQy5s7j83tQOVnIWTk0IJRFyjWuGgVHi62ZkDtJVQtIgW2CWVFDEF uKmFsQG4TnmcgmdU4wEg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m35me-008mPn-S7; Mon, 12 Jul 2021 23:56:21 +0000 Received: from mga02.intel.com ([134.134.136.20]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m35ma-008mOJ-6A for linux-arm-kernel@lists.infradead.org; Mon, 12 Jul 2021 23:56:18 +0000 X-IronPort-AV: E=McAfee;i="6200,9189,10043"; a="197256161" X-IronPort-AV: E=Sophos;i="5.84,235,1620716400"; d="scan'208";a="197256161" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga101.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 16:56:12 -0700 X-IronPort-AV: E=Sophos;i="5.84,235,1620716400"; d="scan'208";a="429846783" Received: from iweiny-desk2.sc.intel.com (HELO localhost) ([10.3.52.147]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 12 Jul 2021 16:56:11 -0700 Date: Mon, 12 Jul 2021 16:56:11 -0700 From: Ira Weiny To: Christoph Hellwig Cc: Linus Torvalds , Andrew Morton , "James E.J. Bottomley" , Russell King , Guo Ren , Thomas Bogendoerfer , Nick Hu , Greentime Hu , Vincent Chen , Helge Deller , Yoshinori Sato , Rich Felker , Geoff Levand , Paul Cercueil , Ulf Hansson , Alex Shi , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-csky@vger.kernel.org, linux-mips@vger.kernel.org, linux-parisc@vger.kernel.org, linux-sh@vger.kernel.org, linux-mmc@vger.kernel.org, linux-scsi@vger.kernel.org, linux-mm@kvack.org, linux-doc@vger.kernel.org Subject: Re: [PATCH 6/6] mm: remove flush_kernel_dcache_page Message-ID: <20210712235611.GC3169279@iweiny-DESK2.sc.intel.com> References: <20210712060928.4161649-1-hch@lst.de> <20210712060928.4161649-7-hch@lst.de> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <20210712060928.4161649-7-hch@lst.de> User-Agent: Mutt/1.11.1 (2018-12-01) X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210712_165616_349464_D7AA9208 X-CRM114-Status: GOOD ( 61.10 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org T24gTW9uLCBKdWwgMTIsIDIwMjEgYXQgMDg6MDk6MjhBTSArMDIwMCwgQ2hyaXN0b3BoIEhlbGx3 aWcgd3JvdGU6Cj4gZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlIGlzIGEgcmF0aGVyIGNvbmZ1c2lu ZyBpbnRlcmZhY2UgdGhhdCBpbXBsZW1lbnRzCj4gYSBzdWJzZXQgb2YgZmx1c2hfZGNhY2hlX3Bh Z2UgYnkgbm90IGJlaW5nIGFibGUgdG8gcHJvcGVybHkgaGFuZGxlIHBhZ2UKPiBjYWNoZSBtYXBw ZWQgcGFnZXMuCj4gCj4gVGhlIG9ubHkgY2FsbGVycyBsZWZ0IGFyZSBpbiB0aGUgZXhlYyBjb2Rl IGFzIGFsbCBvdGhlciBwcmV2aW91cyBjYWxsZXJzCj4gd2VyZSBpbmNvcnJlY3QgYXMgdGhleSBj b3VsZCBoYXZlIGRlYWx0IHdpdGggcGFnZSBjYWNoZSBwYWdlcy4gIFJlcGxhY2UKPiB0aGUgY2Fs bHMgdG8gZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlIHdpdGggY2FsbHMgdG8KPiBmbHVzaF9rZXJu ZWxfZGNhY2hlX3BhZ2UsIHdoaWNoIGZvciBhbGwgYXJjaGl0ZWN0dXJlcyBkb2VzIGVpdGhlcgog IF5eXl5eXl5eXl5eXl5eXl5eXl5eXl5eXgogIGZsdXNoX2RjYWNoZV9wYWdlCgoKT3RoZXIgdGhh biB0aGF0LCBmb3IgdGhlIHNlcmllczoKClJldmlld2VkLWJ5OiBJcmEgV2VpbnkgPGlyYS53ZWlu eUBpbnRlbC5jb20+Cgo+IGV4YWN0bHkgdGhlIHNhbWUgdGhpbmcsIGNhbiBjb250YWlucyBvbmUg b3IgbW9yZSBvZiB0aGUgZm9sbG93aW5nOgo+IAo+ICAxKSBhbiBvcHRpbWl6YXRpb24gdG8gZGVm ZXIgdGhlIGNhY2hlIGZsdXNoIGZvciBwYWdlIGNhY2hlIHBhZ2VzIG5vdAo+ICAgICBtYXBwZWQg aW50byB1c2Vyc3BhY2UKPiAgMikgYWRkaXRpb25hbCBmbHVzaGluZyBmb3IgbWFwcGVkIHBhZ2Ug Y2FjaGUgcGFnZXMgaWYgY2FjaGUgYWxpYXNlcwo+ICAgICBhcmUgcG9zc2libGUKPiAKPiBTaWdu ZWQtb2ZmLWJ5OiBDaHJpc3RvcGggSGVsbHdpZyA8aGNoQGxzdC5kZT4KPiAtLS0KPiAgRG9jdW1l bnRhdGlvbi9jb3JlLWFwaS9jYWNoZXRsYi5yc3QgICAgICAgICAgIHwgODYgKysrKysrKystLS0t LS0tLS0tLQo+ICAuLi4vdHJhbnNsYXRpb25zL3poX0NOL2NvcmUtYXBpL2NhY2hldGxiLnJzdCAg fCAgOSAtLQo+ICBhcmNoL2FybS9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmggICAgICAgICAgICAg fCAgNCArLQo+ICBhcmNoL2FybS9tbS9mbHVzaC5jICAgICAgICAgICAgICAgICAgICAgICAgICAg fCAzMyAtLS0tLS0tCj4gIGFyY2gvYXJtL21tL25vbW11LmMgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICA2IC0tCj4gIGFyY2gvY3NreS9hYml2MS9jYWNoZWZsdXNoLmMgICAgICAgICAgICAg ICAgICB8IDExIC0tLQo+ICBhcmNoL2Nza3kvYWJpdjEvaW5jL2FiaS9jYWNoZWZsdXNoLmggICAg ICAgICAgfCAgNCArLQo+ICBhcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oICAgICAg ICAgICAgfCAgOCArLQo+ICBhcmNoL25kczMyL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCAgICAg ICAgICAgfCAgMyArLQo+ICBhcmNoL25kczMyL21tL2NhY2hlZmx1c2guYyAgICAgICAgICAgICAg ICAgICAgfCAgOSAtLQo+ICBhcmNoL3BhcmlzYy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmggICAg ICAgICAgfCAgOCArLQo+ICBhcmNoL3BhcmlzYy9rZXJuZWwvY2FjaGUuYyAgICAgICAgICAgICAg ICAgICAgfCAgMyArLQo+ICBhcmNoL3NoL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCAgICAgICAg ICAgICAgfCAgOCArLQo+ICBibG9jay9ibGstbWFwLmMgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgMiArLQo+ICBmcy9leGVjLmMgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgfCAgNiArLQo+ICBpbmNsdWRlL2xpbnV4L2hpZ2htZW0uaCAgICAgICAgICAgICAgICAg ICAgICAgfCAgNSArLQo+ICB0b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xpbnV4L21tLmggICAg ICAgICAgfCAgMSAtCj4gIDE3IGZpbGVzIGNoYW5nZWQsIDUxIGluc2VydGlvbnMoKyksIDE1NSBk ZWxldGlvbnMoLSkKPiAKPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9jYWNo ZXRsYi5yc3QgYi9Eb2N1bWVudGF0aW9uL2NvcmUtYXBpL2NhY2hldGxiLnJzdAo+IGluZGV4IGZl NDI5MGUyNjcyOS4uOGFlZDkxMDNlNDhhIDEwMDY0NAo+IC0tLSBhL0RvY3VtZW50YXRpb24vY29y ZS1hcGkvY2FjaGV0bGIucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi9jb3JlLWFwaS9jYWNoZXRs Yi5yc3QKPiBAQCAtMjcxLDEwICsyNzEsMTUgQEAgbWFwcyB0aGlzIHBhZ2UgYXQgaXRzIHZpcnR1 YWwgYWRkcmVzcy4KPiAgCj4gICAgYGB2b2lkIGZsdXNoX2RjYWNoZV9wYWdlKHN0cnVjdCBwYWdl ICpwYWdlKWBgCj4gIAo+IC0JQW55IHRpbWUgdGhlIGtlcm5lbCB3cml0ZXMgdG8gYSBwYWdlIGNh Y2hlIHBhZ2UsIF9PUl8KPiAtCXRoZSBrZXJuZWwgaXMgYWJvdXQgdG8gcmVhZCBmcm9tIGEgcGFn ZSBjYWNoZSBwYWdlIGFuZAo+IC0JdXNlciBzcGFjZSBzaGFyZWQvd3JpdGFibGUgbWFwcGluZ3Mg b2YgdGhpcyBwYWdlIHBvdGVudGlhbGx5Cj4gLQlleGlzdCwgdGhpcyByb3V0aW5lIGlzIGNhbGxl ZC4KPiArICAgICAgICBUaGlzIHJvdXRpbmVzIG11c3QgYmUgY2FsbGVkIHdoZW46Cj4gKwo+ICsJ ICBhKSB0aGUga2VybmVsIGRpZCB3cml0ZSB0byBhIHBhZ2UgdGhhdCBpcyBpbiB0aGUgcGFnZSBj YWNoZSBwYWdlCj4gKwkgICAgIGFuZCAvIG9yIGluIGhpZ2ggbWVtb3J5Cj4gKwkgIGIpIHRoZSBr ZXJuZWwgaXMgYWJvdXQgdG8gcmVhZCBmcm9tIGEgcGFnZSBjYWNoZSBwYWdlIGFuZCB1c2VyIHNw YWNlCj4gKwkgICAgIHNoYXJlZC93cml0YWJsZSBtYXBwaW5ncyBvZiB0aGlzIHBhZ2UgcG90ZW50 aWFsbHkgZXhpc3QuICBOb3RlCj4gKwkgICAgIHRoYXQge2dldCxwaW59X3VzZXJfcGFnZXN7X2Zh c3R9IGFscmVhZHkgY2FsbCBmbHVzaF9kY2FjaGVfcGFnZQo+ICsJICAgICBvbiBhbnkgcGFnZSBm b3VuZCBpbiB0aGUgdXNlciBhZGRyZXNzIHNwYWNlIGFuZCB0aHVzIGRyaXZlcgo+ICsJICAgICBj b2RlIHJhcmVseSBuZWVkcyB0byB0YWtlIHRoaXMgaW50byBhY2NvdW50Lgo+ICAKPiAgCS4uIG5v dGU6Ogo+ICAKPiBAQCAtMjg0LDM4ICsyODksMzQgQEAgbWFwcyB0aGlzIHBhZ2UgYXQgaXRzIHZp cnR1YWwgYWRkcmVzcy4KPiAgCSAgICAgIGhhbmRsaW5nIHZmcyBzeW1saW5rcyBpbiB0aGUgcGFn ZSBjYWNoZSBuZWVkIG5vdCBjYWxsCj4gIAkgICAgICB0aGlzIGludGVyZmFjZSBhdCBhbGwuCj4g IAo+IC0JVGhlIHBocmFzZSAia2VybmVsIHdyaXRlcyB0byBhIHBhZ2UgY2FjaGUgcGFnZSIgbWVh bnMsCj4gLQlzcGVjaWZpY2FsbHksIHRoYXQgdGhlIGtlcm5lbCBleGVjdXRlcyBzdG9yZSBpbnN0 cnVjdGlvbnMKPiAtCXRoYXQgZGlydHkgZGF0YSBpbiB0aGF0IHBhZ2UgYXQgdGhlIHBhZ2UtPnZp cnR1YWwgbWFwcGluZwo+IC0Jb2YgdGhhdCBwYWdlLiAgSXQgaXMgaW1wb3J0YW50IHRvIGZsdXNo IGhlcmUgdG8gaGFuZGxlCj4gLQlELWNhY2hlIGFsaWFzaW5nLCB0byBtYWtlIHN1cmUgdGhlc2Ug a2VybmVsIHN0b3JlcyBhcmUKPiAtCXZpc2libGUgdG8gdXNlciBzcGFjZSBtYXBwaW5ncyBvZiB0 aGF0IHBhZ2UuCj4gLQo+IC0JVGhlIGNvcm9sbGFyeSBjYXNlIGlzIGp1c3QgYXMgaW1wb3J0YW50 LCBpZiB0aGVyZSBhcmUgdXNlcnMKPiAtCXdoaWNoIGhhdmUgc2hhcmVkK3dyaXRhYmxlIG1hcHBp bmdzIG9mIHRoaXMgZmlsZSwgd2UgbXVzdCBtYWtlCj4gLQlzdXJlIHRoYXQga2VybmVsIHJlYWRz IG9mIHRoZXNlIHBhZ2VzIHdpbGwgc2VlIHRoZSBtb3N0IHJlY2VudAo+IC0Jc3RvcmVzIGRvbmUg YnkgdGhlIHVzZXIuCj4gLQo+IC0JSWYgRC1jYWNoZSBhbGlhc2luZyBpcyBub3QgYW4gaXNzdWUs IHRoaXMgcm91dGluZSBtYXkKPiAtCXNpbXBseSBiZSBkZWZpbmVkIGFzIGEgbm9wIG9uIHRoYXQg YXJjaGl0ZWN0dXJlLgo+IC0KPiAtICAgICAgICBUaGVyZSBpcyBhIGJpdCBzZXQgYXNpZGUgaW4g cGFnZS0+ZmxhZ3MgKFBHX2FyY2hfMSkgYXMKPiAtCSJhcmNoaXRlY3R1cmUgcHJpdmF0ZSIuICBU aGUga2VybmVsIGd1YXJhbnRlZXMgdGhhdCwKPiAtCWZvciBwYWdlY2FjaGUgcGFnZXMsIGl0IHdp bGwgY2xlYXIgdGhpcyBiaXQgd2hlbiBzdWNoCj4gLQlhIHBhZ2UgZmlyc3QgZW50ZXJzIHRoZSBw YWdlY2FjaGUuCj4gLQo+IC0JVGhpcyBhbGxvd3MgdGhlc2UgaW50ZXJmYWNlcyB0byBiZSBpbXBs ZW1lbnRlZCBtdWNoIG1vcmUKPiAtCWVmZmljaWVudGx5LiAgSXQgYWxsb3dzIG9uZSB0byAiZGVm ZXIiIChwZXJoYXBzIGluZGVmaW5pdGVseSkKPiAtCXRoZSBhY3R1YWwgZmx1c2ggaWYgdGhlcmUg YXJlIGN1cnJlbnRseSBubyB1c2VyIHByb2Nlc3Nlcwo+IC0JbWFwcGluZyB0aGlzIHBhZ2UuICBT ZWUgc3BhcmM2NCdzIGZsdXNoX2RjYWNoZV9wYWdlIGFuZAo+IC0JdXBkYXRlX21tdV9jYWNoZSBp bXBsZW1lbnRhdGlvbnMgZm9yIGFuIGV4YW1wbGUgb2YgaG93IHRvIGdvCj4gLQlhYm91dCBkb2lu ZyB0aGlzLgo+IC0KPiAtCVRoZSBpZGVhIGlzLCBmaXJzdCBhdCBmbHVzaF9kY2FjaGVfcGFnZSgp IHRpbWUsIGlmCj4gLQlwYWdlLT5tYXBwaW5nLT5pX21tYXAgaXMgYW4gZW1wdHkgdHJlZSwganVz dCBtYXJrIHRoZSBhcmNoaXRlY3R1cmUKPiAtCXByaXZhdGUgcGFnZSBmbGFnIGJpdC4gIExhdGVy LCBpbiB1cGRhdGVfbW11X2NhY2hlKCksIGEgY2hlY2sgaXMKPiAtCW1hZGUgb2YgdGhpcyBmbGFn IGJpdCwgYW5kIGlmIHNldCB0aGUgZmx1c2ggaXMgZG9uZSBhbmQgdGhlIGZsYWcKPiAtCWJpdCBp cyBjbGVhcmVkLgo+ICsJVGhlIHBocmFzZSAia2VybmVsIHdyaXRlcyB0byBhIHBhZ2UgY2FjaGUg cGFnZSIgbWVhbnMsIHNwZWNpZmljYWxseSwKPiArCXRoYXQgdGhlIGtlcm5lbCBleGVjdXRlcyBz dG9yZSBpbnN0cnVjdGlvbnMgdGhhdCBkaXJ0eSBkYXRhIGluIHRoYXQKPiArCXBhZ2UgYXQgdGhl IHBhZ2UtPnZpcnR1YWwgbWFwcGluZyBvZiB0aGF0IHBhZ2UuICBJdCBpcyBpbXBvcnRhbnQgdG8K PiArCWZsdXNoIGhlcmUgdG8gaGFuZGxlIEQtY2FjaGUgYWxpYXNpbmcsIHRvIG1ha2Ugc3VyZSB0 aGVzZSBrZXJuZWwgc3RvcmVzCj4gKwlhcmUgdmlzaWJsZSB0byB1c2VyIHNwYWNlIG1hcHBpbmdz IG9mIHRoYXQgcGFnZS4KPiArCj4gKwlUaGUgY29yb2xsYXJ5IGNhc2UgaXMganVzdCBhcyBpbXBv cnRhbnQsIGlmIHRoZXJlIGFyZSB1c2VycyB3aGljaCBoYXZlCj4gKwlzaGFyZWQrd3JpdGFibGUg bWFwcGluZ3Mgb2YgdGhpcyBmaWxlLCB3ZSBtdXN0IG1ha2Ugc3VyZSB0aGF0IGtlcm5lbAo+ICsJ cmVhZHMgb2YgdGhlc2UgcGFnZXMgd2lsbCBzZWUgdGhlIG1vc3QgcmVjZW50IHN0b3JlcyBkb25l IGJ5IHRoZSB1c2VyLgo+ICsKPiArCUlmIEQtY2FjaGUgYWxpYXNpbmcgaXMgbm90IGFuIGlzc3Vl LCB0aGlzIHJvdXRpbmUgbWF5IHNpbXBseSBiZSBkZWZpbmVkCj4gKwlhcyBhIG5vcCBvbiB0aGF0 IGFyY2hpdGVjdHVyZS4KPiArCj4gKyAgICAgICAgVGhlcmUgaXMgYSBiaXQgc2V0IGFzaWRlIGlu IHBhZ2UtPmZsYWdzIChQR19hcmNoXzEpIGFzICJhcmNoaXRlY3R1cmUKPiArCXByaXZhdGUiLiAg VGhlIGtlcm5lbCBndWFyYW50ZWVzIHRoYXQsIGZvciBwYWdlY2FjaGUgcGFnZXMsIGl0IHdpbGwK PiArCWNsZWFyIHRoaXMgYml0IHdoZW4gc3VjaCBhIHBhZ2UgZmlyc3QgZW50ZXJzIHRoZSBwYWdl Y2FjaGUuCj4gKwo+ICsJVGhpcyBhbGxvd3MgdGhlc2UgaW50ZXJmYWNlcyB0byBiZSBpbXBsZW1l bnRlZCBtdWNoIG1vcmUgZWZmaWNpZW50bHkuCj4gKwlJdCBhbGxvd3Mgb25lIHRvICJkZWZlciIg KHBlcmhhcHMgaW5kZWZpbml0ZWx5KSB0aGUgYWN0dWFsIGZsdXNoIGlmCj4gKwl0aGVyZSBhcmUg Y3VycmVudGx5IG5vIHVzZXIgcHJvY2Vzc2VzIG1hcHBpbmcgdGhpcyBwYWdlLiAgU2VlIHNwYXJj NjQncwo+ICsJZmx1c2hfZGNhY2hlX3BhZ2UgYW5kIHVwZGF0ZV9tbXVfY2FjaGUgaW1wbGVtZW50 YXRpb25zIGZvciBhbiBleGFtcGxlCj4gKwlvZiBob3cgdG8gZ28gYWJvdXQgZG9pbmcgdGhpcy4K PiArCj4gKwlUaGUgaWRlYSBpcywgZmlyc3QgYXQgZmx1c2hfZGNhY2hlX3BhZ2UoKSB0aW1lLCBp ZiBwYWdlX2ZpbGVfbWFwcGluZygpCj4gKwlyZXR1cm5zIGEgbWFwcGluZywgYW5kIG1hcHBpbmdf bWFwcGVkIG9uIHRoYXQgbWFwcGluZyByZXR1cm5zICVmYWxzZSwKPiArCWp1c3QgbWFyayB0aGUg YXJjaGl0ZWN0dXJlIHByaXZhdGUgcGFnZSBmbGFnIGJpdC4gIExhdGVyLCBpbgo+ICsJdXBkYXRl X21tdV9jYWNoZSgpLCBhIGNoZWNrIGlzIG1hZGUgb2YgdGhpcyBmbGFnIGJpdCwgYW5kIGlmIHNl dCB0aGUKPiArCWZsdXNoIGlzIGRvbmUgYW5kIHRoZSBmbGFnIGJpdCBpcyBjbGVhcmVkLgo+ICAK PiAgCS4uIGltcG9ydGFudDo6Cj4gIAo+IEBAIC0zNTEsMTkgKzM1Miw2IEBAIG1hcHMgdGhpcyBw YWdlIGF0IGl0cyB2aXJ0dWFsIGFkZHJlc3MuCj4gIAlhcmNoaXRlY3R1cmVzKS4gIEZvciBpbmNv aGVyZW50IGFyY2hpdGVjdHVyZXMsIGl0IHNob3VsZCBmbHVzaAo+ICAJdGhlIGNhY2hlIG9mIHRo ZSBwYWdlIGF0IHZtYWRkci4KPiAgCj4gLSAgYGB2b2lkIGZsdXNoX2tlcm5lbF9kY2FjaGVfcGFn ZShzdHJ1Y3QgcGFnZSAqcGFnZSlgYAo+IC0KPiAtCVdoZW4gdGhlIGtlcm5lbCBuZWVkcyB0byBt b2RpZnkgYSB1c2VyIHBhZ2UgaXMgaGFzIG9idGFpbmVkCj4gLQl3aXRoIGttYXAsIGl0IGNhbGxz IHRoaXMgZnVuY3Rpb24gYWZ0ZXIgYWxsIG1vZGlmaWNhdGlvbnMgYXJlCj4gLQljb21wbGV0ZSAo YnV0IGJlZm9yZSBrdW5tYXBwaW5nIGl0KSB0byBicmluZyB0aGUgdW5kZXJseWluZwo+IC0JcGFn ZSB1cCB0byBkYXRlLiAgSXQgaXMgYXNzdW1lZCBoZXJlIHRoYXQgdGhlIHVzZXIgaGFzIG5vCj4g LQlpbmNvaGVyZW50IGNhY2hlZCBjb3BpZXMgKGkuZS4gdGhlIG9yaWdpbmFsIHBhZ2Ugd2FzIG9i dGFpbmVkCj4gLQlmcm9tIGEgbWVjaGFuaXNtIGxpa2UgZ2V0X3VzZXJfcGFnZXMoKSkuICBUaGUg ZGVmYXVsdAo+IC0JaW1wbGVtZW50YXRpb24gaXMgYSBub3AgYW5kIHNob3VsZCByZW1haW4gc28g b24gYWxsIGNvaGVyZW50Cj4gLQlhcmNoaXRlY3R1cmVzLiAgT24gaW5jb2hlcmVudCBhcmNoaXRl Y3R1cmVzLCB0aGlzIHNob3VsZCBmbHVzaAo+IC0JdGhlIGtlcm5lbCBjYWNoZSBmb3IgcGFnZSAo dXNpbmcgcGFnZV9hZGRyZXNzKHBhZ2UpKS4KPiAtCj4gLQo+ICAgIGBgdm9pZCBmbHVzaF9pY2Fj aGVfcmFuZ2UodW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQpYGAKPiAgCj4g ICAgCVdoZW4gdGhlIGtlcm5lbCBzdG9yZXMgaW50byBhZGRyZXNzZXMgdGhhdCBpdCB3aWxsIGV4 ZWN1dGUKPiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vY29y ZS1hcGkvY2FjaGV0bGIucnN0IGIvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vY29y ZS1hcGkvY2FjaGV0bGIucnN0Cj4gaW5kZXggODM3NjQ4NWE1MzRkLi41NTgyN2I4YTdjNTMgMTAw NjQ0Cj4gLS0tIGEvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vY29yZS1hcGkvY2Fj aGV0bGIucnN0Cj4gKysrIGIvRG9jdW1lbnRhdGlvbi90cmFuc2xhdGlvbnMvemhfQ04vY29yZS1h cGkvY2FjaGV0bGIucnN0Cj4gQEAgLTI5OCwxNSArMjk4LDYgQEAgSHlwZXJTcGFyYyBjcHXlsLHm mK/ov5nmoLfkuIDkuKrlhbfmnInov5nnp43lsZ7mgKfnmoRjcHXjgIIKPiAgCeeUqOOAgum7mOiu pOeahOWunueOsOaYr25vcO+8iOWvueS6juaJgOacieebuOW5sueahOaetuaehOW6lOivpeS/neaM gei/meagt++8ieOAguWvueS6juS4jeS4gOiHtOaApwo+ICAJ55qE5p625p6E77yM5a6D5bqU6K+l 5Yi35pawdm1hZGRy5aSE55qE6aG16Z2i57yT5a2Y44CCCj4gIAo+IC0gIGBgdm9pZCBmbHVzaF9r ZXJuZWxfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpYGAKPiAtCj4gLQnlvZPlhoXmoLjp nIDopoHkv67mlLnkuIDkuKrnlKhrbWFw6I635b6X55qE55So5oi36aG15pe277yM5a6D5Lya5Zyo 5omA5pyJ5L+u5pS55a6M5oiQ5ZCO77yI5L2G5ZyoCj4gLQlrdW5tYXBwaW5n5LmL5YmN77yJ6LCD 55So6L+Z5Liq5Ye95pWw77yM5Lul5L2/5bqV5bGC6aG16Z2i6L6+5Yiw5pyA5paw54q25oCB44CC 6L+Z6YeM5YGH5a6a55SoCj4gLQnmiLfmsqHmnInkuI3kuIDoh7TmgKfnmoTnvJPlrZjlia/mnKzv vIjljbPljp/lp4vpobXpnaLmmK/ku47nsbvkvLxnZXRfdXNlcl9wYWdlcygp55qE5py65Yi2Cj4g LQnkuK3ojrflvpfnmoTvvInjgILpu5jorqTnmoTlrp7njrDmmK/kuIDkuKpub3DvvIzlnKjmiYDm nInnm7jlubLnmoTmnrbmnoTkuIrpg73lupTor6XlpoLmraTjgILlnKjkuI0KPiAtCeS4gOiHtOaA p+eahOaetuaehOS4iu+8jOi/meW6lOivpeWIt+aWsOWGheaguOe8k+WtmOS4reeahOmhtemdou+8 iOS9v+eUqHBhZ2VfYWRkcmVzcyhwYWdlKe+8ieOAggo+IC0KPiAtCj4gICAgYGB2b2lkIGZsdXNo X2ljYWNoZV9yYW5nZSh1bnNpZ25lZCBsb25nIHN0YXJ0LCB1bnNpZ25lZCBsb25nIGVuZClgYAo+ ICAKPiAgCeW9k+WGheaguOWtmOWCqOWIsOWug+WwhuaJp+ihjOeahOWcsOWdgOS4reaXtu+8iOS+ i+WmguWcqOWKoOi9veaooeWdl+aXtu+8ie+8jOi/meS4quWHveaVsOiiq+iwg+eUqOOAggo+IGRp ZmYgLS1naXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmggYi9hcmNoL2FybS9p bmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKPiBpbmRleCAyZTI0ZTc2NWU2ZDMuLjVlNTYyODhlMzQz YiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKPiArKysg Yi9hcmNoL2FybS9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKPiBAQCAtMjkxLDYgKzI5MSw3IEBA IGV4dGVybiB2b2lkIGZsdXNoX2NhY2hlX3BhZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEs IHVuc2lnbmVkIGxvbmcgdXNlcl9hZGRyCj4gICNkZWZpbmUgQVJDSF9JTVBMRU1FTlRTX0ZMVVNI X0RDQUNIRV9QQUdFIDEKPiAgZXh0ZXJuIHZvaWQgZmx1c2hfZGNhY2hlX3BhZ2Uoc3RydWN0IHBh Z2UgKik7Cj4gIAo+ICsjZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9LRVJORUxfVk1BUF9S QU5HRSAxCj4gIHN0YXRpYyBpbmxpbmUgdm9pZCBmbHVzaF9rZXJuZWxfdm1hcF9yYW5nZSh2b2lk ICphZGRyLCBpbnQgc2l6ZSkKPiAgewo+ICAJaWYgKChjYWNoZV9pc192aXZ0KCkgfHwgY2FjaGVf aXNfdmlwdF9hbGlhc2luZygpKSkKPiBAQCAtMzEyLDkgKzMxMyw2IEBAIHN0YXRpYyBpbmxpbmUg dm9pZCBmbHVzaF9hbm9uX3BhZ2Uoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gIAkJX19m bHVzaF9hbm9uX3BhZ2Uodm1hLCBwYWdlLCB2bWFkZHIpOwo+ICB9Cj4gIAo+IC0jZGVmaW5lIEFS Q0hfSEFTX0ZMVVNIX0tFUk5FTF9EQ0FDSEVfUEFHRQo+IC1leHRlcm4gdm9pZCBmbHVzaF9rZXJu ZWxfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKik7Cj4gLQo+ICAjZGVmaW5lIGZsdXNoX2RjYWNo ZV9tbWFwX2xvY2sobWFwcGluZykJCXhhX2xvY2tfaXJxKCZtYXBwaW5nLT5pX3BhZ2VzKQo+ICAj ZGVmaW5lIGZsdXNoX2RjYWNoZV9tbWFwX3VubG9jayhtYXBwaW5nKQl4YV91bmxvY2tfaXJxKCZt YXBwaW5nLT5pX3BhZ2VzKQo+ICAKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vZmx1c2guYyBi L2FyY2gvYXJtL21tL2ZsdXNoLmMKPiBpbmRleCA2ZDg5ZGI3ODk1ZDEuLjdmZjlmZWVhMTNhNiAx MDA2NDQKPiAtLS0gYS9hcmNoL2FybS9tbS9mbHVzaC5jCj4gKysrIGIvYXJjaC9hcm0vbW0vZmx1 c2guYwo+IEBAIC0zNDUsMzkgKzM0NSw2IEBAIHZvaWQgZmx1c2hfZGNhY2hlX3BhZ2Uoc3RydWN0 IHBhZ2UgKnBhZ2UpCj4gIH0KPiAgRVhQT1JUX1NZTUJPTChmbHVzaF9kY2FjaGVfcGFnZSk7Cj4g IAo+IC0vKgo+IC0gKiBFbnN1cmUgY2FjaGUgY29oZXJlbmN5IGZvciB0aGUga2VybmVsIG1hcHBp bmcgb2YgdGhpcyBwYWdlLiBXZSBjYW4KPiAtICogYXNzdW1lIHRoYXQgdGhlIHBhZ2UgaXMgcGlu bmVkIHZpYSBrbWFwLgo+IC0gKgo+IC0gKiBJZiB0aGUgcGFnZSBvbmx5IGV4aXN0cyBpbiB0aGUg cGFnZSBjYWNoZSBhbmQgdGhlcmUgYXJlIG5vIHVzZXIKPiAtICogc3BhY2UgbWFwcGluZ3MsIHRo aXMgaXMgYSBuby1vcCBzaW5jZSB0aGUgcGFnZSB3YXMgYWxyZWFkeSBtYXJrZWQKPiAtICogZGly dHkgYXQgY3JlYXRpb24uICBPdGhlcndpc2UsIHdlIG5lZWQgdG8gZmx1c2ggdGhlIGRpcnR5IGtl cm5lbAo+IC0gKiBjYWNoZSBsaW5lcyBkaXJlY3RseS4KPiAtICovCj4gLXZvaWQgZmx1c2hfa2Vy bmVsX2RjYWNoZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKQo+IC17Cj4gLQlpZiAoY2FjaGVfaXNf dml2dCgpIHx8IGNhY2hlX2lzX3ZpcHRfYWxpYXNpbmcoKSkgewo+IC0JCXN0cnVjdCBhZGRyZXNz X3NwYWNlICptYXBwaW5nOwo+IC0KPiAtCQltYXBwaW5nID0gcGFnZV9tYXBwaW5nX2ZpbGUocGFn ZSk7Cj4gLQo+IC0JCWlmICghbWFwcGluZyB8fCBtYXBwaW5nX21hcHBlZChtYXBwaW5nKSkgewo+ IC0JCQl2b2lkICphZGRyOwo+IC0KPiAtCQkJYWRkciA9IHBhZ2VfYWRkcmVzcyhwYWdlKTsKPiAt CQkJLyoKPiAtCQkJICoga21hcF9hdG9taWMoKSBkb2Vzbid0IHNldCB0aGUgcGFnZSB2aXJ0dWFs Cj4gLQkJCSAqIGFkZHJlc3MgZm9yIGhpZ2htZW0gcGFnZXMsIGFuZAo+IC0JCQkgKiBrdW5tYXBf YXRvbWljKCkgdGFrZXMgY2FyZSBvZiBjYWNoZQo+IC0JCQkgKiBmbHVzaGluZyBhbHJlYWR5Lgo+ IC0JCQkgKi8KPiAtCQkJaWYgKCFJU19FTkFCTEVEKENPTkZJR19ISUdITUVNKSB8fCBhZGRyKQo+ IC0JCQkJX19jcHVjX2ZsdXNoX2RjYWNoZV9hcmVhKGFkZHIsIFBBR0VfU0laRSk7Cj4gLQkJfQo+ IC0JfQo+IC19Cj4gLUVYUE9SVF9TWU1CT0woZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlKTsKPiAt Cj4gIC8qCj4gICAqIEZsdXNoIGFuIGFub255bW91cyBwYWdlIHNvIHRoYXQgdXNlcnMgb2YgZ2V0 X3VzZXJfcGFnZXMoKQo+ICAgKiBjYW4gc2FmZWx5IGFjY2VzcyB0aGUgZGF0YS4gIFRoZSBleHBl Y3RlZCBzZXF1ZW5jZSBpczoKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vbW0vbm9tbXUuYyBiL2Fy Y2gvYXJtL21tL25vbW11LmMKPiBpbmRleCA4YjNkNzE5MWUyYjguLjI2NThmNTI5MDNkYSAxMDA2 NDQKPiAtLS0gYS9hcmNoL2FybS9tbS9ub21tdS5jCj4gKysrIGIvYXJjaC9hcm0vbW0vbm9tbXUu Ywo+IEBAIC0xNjYsMTIgKzE2Niw2IEBAIHZvaWQgZmx1c2hfZGNhY2hlX3BhZ2Uoc3RydWN0IHBh Z2UgKnBhZ2UpCj4gIH0KPiAgRVhQT1JUX1NZTUJPTChmbHVzaF9kY2FjaGVfcGFnZSk7Cj4gIAo+ IC12b2lkIGZsdXNoX2tlcm5lbF9kY2FjaGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAtewo+ IC0JX19jcHVjX2ZsdXNoX2RjYWNoZV9hcmVhKHBhZ2VfYWRkcmVzcyhwYWdlKSwgUEFHRV9TSVpF KTsKPiAtfQo+IC1FWFBPUlRfU1lNQk9MKGZsdXNoX2tlcm5lbF9kY2FjaGVfcGFnZSk7Cj4gLQo+ ICB2b2lkIGNvcHlfdG9fdXNlcl9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBzdHJ1 Y3QgcGFnZSAqcGFnZSwKPiAgCQkgICAgICAgdW5zaWduZWQgbG9uZyB1YWRkciwgdm9pZCAqZHN0 LCBjb25zdCB2b2lkICpzcmMsCj4gIAkJICAgICAgIHVuc2lnbmVkIGxvbmcgbGVuKQo+IGRpZmYg LS1naXQgYS9hcmNoL2Nza3kvYWJpdjEvY2FjaGVmbHVzaC5jIGIvYXJjaC9jc2t5L2FiaXYxL2Nh Y2hlZmx1c2guYwo+IGluZGV4IDA3ZmYxN2VhMzNkZS4uZmI5MWIwNjlkYzY5IDEwMDY0NAo+IC0t LSBhL2FyY2gvY3NreS9hYml2MS9jYWNoZWZsdXNoLmMKPiArKysgYi9hcmNoL2Nza3kvYWJpdjEv Y2FjaGVmbHVzaC5jCj4gQEAgLTU2LDE3ICs1Niw2IEBAIHZvaWQgdXBkYXRlX21tdV9jYWNoZShz dHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRyLAo+ICAJfQo+ICB9 Cj4gIAo+IC12b2lkIGZsdXNoX2tlcm5lbF9kY2FjaGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkK PiAtewo+IC0Jc3RydWN0IGFkZHJlc3Nfc3BhY2UgKm1hcHBpbmc7Cj4gLQo+IC0JbWFwcGluZyA9 IHBhZ2VfbWFwcGluZ19maWxlKHBhZ2UpOwo+IC0KPiAtCWlmICghbWFwcGluZyB8fCBtYXBwaW5n X21hcHBlZChtYXBwaW5nKSkKPiAtCQlkY2FjaGVfd2JpbnZfYWxsKCk7Cj4gLX0KPiAtRVhQT1JU X1NZTUJPTChmbHVzaF9rZXJuZWxfZGNhY2hlX3BhZ2UpOwo+IC0KPiAgdm9pZCBmbHVzaF9jYWNo ZV9yYW5nZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBzdGFydCwK PiAgCXVuc2lnbmVkIGxvbmcgZW5kKQo+ICB7Cj4gZGlmZiAtLWdpdCBhL2FyY2gvY3NreS9hYml2 MS9pbmMvYWJpL2NhY2hlZmx1c2guaCBiL2FyY2gvY3NreS9hYml2MS9pbmMvYWJpL2NhY2hlZmx1 c2guaAo+IGluZGV4IDZjYWI3YWZhZTk2Mi4uZWQ2MmUyMDY2YmE3IDEwMDY0NAo+IC0tLSBhL2Fy Y2gvY3NreS9hYml2MS9pbmMvYWJpL2NhY2hlZmx1c2guaAo+ICsrKyBiL2FyY2gvY3NreS9hYml2 MS9pbmMvYWJpL2NhY2hlZmx1c2guaAo+IEBAIC0xNCwxMiArMTQsMTAgQEAgZXh0ZXJuIHZvaWQg Zmx1c2hfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKik7Cj4gICNkZWZpbmUgZmx1c2hfY2FjaGVf cGFnZSh2bWEsIHBhZ2UsIHBmbikJY2FjaGVfd2JpbnZfYWxsKCkKPiAgI2RlZmluZSBmbHVzaF9j YWNoZV9kdXBfbW0obW0pCQkJY2FjaGVfd2JpbnZfYWxsKCkKPiAgCj4gLSNkZWZpbmUgQVJDSF9I QVNfRkxVU0hfS0VSTkVMX0RDQUNIRV9QQUdFCj4gLWV4dGVybiB2b2lkIGZsdXNoX2tlcm5lbF9k Y2FjaGVfcGFnZShzdHJ1Y3QgcGFnZSAqKTsKPiAtCj4gICNkZWZpbmUgZmx1c2hfZGNhY2hlX21t YXBfbG9jayhtYXBwaW5nKQkJeGFfbG9ja19pcnEoJm1hcHBpbmctPmlfcGFnZXMpCj4gICNkZWZp bmUgZmx1c2hfZGNhY2hlX21tYXBfdW5sb2NrKG1hcHBpbmcpCXhhX3VubG9ja19pcnEoJm1hcHBp bmctPmlfcGFnZXMpCj4gIAo+ICsjZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9LRVJORUxf Vk1BUF9SQU5HRSAxCj4gIHN0YXRpYyBpbmxpbmUgdm9pZCBmbHVzaF9rZXJuZWxfdm1hcF9yYW5n ZSh2b2lkICphZGRyLCBpbnQgc2l6ZSkKPiAgewo+ICAJZGNhY2hlX3diaW52X2FsbCgpOwo+IGRp ZmYgLS1naXQgYS9hcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oIGIvYXJjaC9taXBz L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+IGluZGV4IGQ2ODdiNDBiOWZiYi4uYjNkYzljNTg5 NDQyIDEwMDY0NAo+IC0tLSBhL2FyY2gvbWlwcy9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKPiAr KysgYi9hcmNoL21pcHMvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCj4gQEAgLTEyNSwxMyArMTI1 LDcgQEAgc3RhdGljIGlubGluZSB2b2lkIGt1bm1hcF9ub25jb2hlcmVudCh2b2lkKQo+ICAJa3Vu bWFwX2NvaGVyZW50KCk7Cj4gIH0KPiAgCj4gLSNkZWZpbmUgQVJDSF9IQVNfRkxVU0hfS0VSTkVM X0RDQUNIRV9QQUdFCj4gLXN0YXRpYyBpbmxpbmUgdm9pZCBmbHVzaF9rZXJuZWxfZGNhY2hlX3Bh Z2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gLXsKPiAtCUJVR19PTihjcHVfaGFzX2RjX2FsaWFzZXMg JiYgUGFnZUhpZ2hNZW0ocGFnZSkpOwo+IC0JZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7Cj4gLX0K PiAtCj4gKyNkZWZpbmUgQVJDSF9JTVBMRU1FTlRTX0ZMVVNIX0tFUk5FTF9WTUFQX1JBTkdFIDEK PiAgLyoKPiAgICogRm9yIG5vdyBmbHVzaF9rZXJuZWxfdm1hcF9yYW5nZSBhbmQgaW52YWxpZGF0 ZV9rZXJuZWxfdm1hcF9yYW5nZSBib3RoIGRvIGEKPiAgICogY2FjaGUgd3JpdGViYWNrIGFuZCBp bnZhbGlkYXRlIG9wZXJhdGlvbi4KPiBkaWZmIC0tZ2l0IGEvYXJjaC9uZHMzMi9pbmNsdWRlL2Fz bS9jYWNoZWZsdXNoLmggYi9hcmNoL25kczMyL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+IGlu ZGV4IDdkNjgyNGY3YzBlOC4uYzJhMjIyZWJmYTJhIDEwMDY0NAo+IC0tLSBhL2FyY2gvbmRzMzIv aW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCj4gKysrIGIvYXJjaC9uZHMzMi9pbmNsdWRlL2FzbS9j YWNoZWZsdXNoLmgKPiBAQCAtMzYsOCArMzYsNyBAQCB2b2lkIGNvcHlfZnJvbV91c2VyX3BhZ2Uo c3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsIHN0cnVjdCBwYWdlICpwYWdlLAo+ICB2b2lkIGZs dXNoX2Fub25fcGFnZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiAgCQkgICAgIHN0cnVj dCBwYWdlICpwYWdlLCB1bnNpZ25lZCBsb25nIHZhZGRyKTsKPiAgCj4gLSNkZWZpbmUgQVJDSF9I QVNfRkxVU0hfS0VSTkVMX0RDQUNIRV9QQUdFCj4gLXZvaWQgZmx1c2hfa2VybmVsX2RjYWNoZV9w YWdlKHN0cnVjdCBwYWdlICpwYWdlKTsKPiArI2RlZmluZSBBUkNIX0lNUExFTUVOVFNfRkxVU0hf S0VSTkVMX1ZNQVBfUkFOR0UgMQo+ICB2b2lkIGZsdXNoX2tlcm5lbF92bWFwX3JhbmdlKHZvaWQg KmFkZHIsIGludCBzaXplKTsKPiAgdm9pZCBpbnZhbGlkYXRlX2tlcm5lbF92bWFwX3JhbmdlKHZv aWQgKmFkZHIsIGludCBzaXplKTsKPiAgI2RlZmluZSBmbHVzaF9kY2FjaGVfbW1hcF9sb2NrKG1h cHBpbmcpICAgeGFfbG9ja19pcnEoJihtYXBwaW5nKS0+aV9wYWdlcykKPiBkaWZmIC0tZ2l0IGEv YXJjaC9uZHMzMi9tbS9jYWNoZWZsdXNoLmMgYi9hcmNoL25kczMyL21tL2NhY2hlZmx1c2guYwo+ IGluZGV4IGFkNTM0NGVmNWQzMy4uMDdhYWM2NWQxY2FiIDEwMDY0NAo+IC0tLSBhL2FyY2gvbmRz MzIvbW0vY2FjaGVmbHVzaC5jCj4gKysrIGIvYXJjaC9uZHMzMi9tbS9jYWNoZWZsdXNoLmMKPiBA QCAtMzE4LDE1ICszMTgsNiBAQCB2b2lkIGZsdXNoX2Fub25fcGFnZShzdHJ1Y3Qgdm1fYXJlYV9z dHJ1Y3QgKnZtYSwKPiAgCWxvY2FsX2lycV9yZXN0b3JlKGZsYWdzKTsKPiAgfQo+ICAKPiAtdm9p ZCBmbHVzaF9rZXJuZWxfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2UpCj4gLXsKPiAtCXVu c2lnbmVkIGxvbmcgZmxhZ3M7Cj4gLQlsb2NhbF9pcnFfc2F2ZShmbGFncyk7Cj4gLQljcHVfZGNh Y2hlX3diaW52YWxfcGFnZSgodW5zaWduZWQgbG9uZylwYWdlX2FkZHJlc3MocGFnZSkpOwo+IC0J bG9jYWxfaXJxX3Jlc3RvcmUoZmxhZ3MpOwo+IC19Cj4gLUVYUE9SVF9TWU1CT0woZmx1c2hfa2Vy bmVsX2RjYWNoZV9wYWdlKTsKPiAtCj4gIHZvaWQgZmx1c2hfa2VybmVsX3ZtYXBfcmFuZ2Uodm9p ZCAqYWRkciwgaW50IHNpemUpCj4gIHsKPiAgCXVuc2lnbmVkIGxvbmcgZmxhZ3M7Cj4gZGlmZiAt LWdpdCBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaCBiL2FyY2gvcGFyaXNj L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+IGluZGV4IDk5NjYzZmMxZjk5Ny4uZWVmMDA5NmRi NWY4IDEwMDY0NAo+IC0tLSBhL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+ ICsrKyBiL2FyY2gvcGFyaXNjL2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+IEBAIC0zNiwxNiAr MzYsMTIgQEAgdm9pZCBmbHVzaF9jYWNoZV9hbGxfbG9jYWwodm9pZCk7Cj4gIHZvaWQgZmx1c2hf Y2FjaGVfYWxsKHZvaWQpOwo+ICB2b2lkIGZsdXNoX2NhY2hlX21tKHN0cnVjdCBtbV9zdHJ1Y3Qg Km1tKTsKPiAgCj4gLSNkZWZpbmUgQVJDSF9IQVNfRkxVU0hfS0VSTkVMX0RDQUNIRV9QQUdFCj4g IHZvaWQgZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlX2FkZHIodm9pZCAqYWRkcik7Cj4gLXN0YXRp YyBpbmxpbmUgdm9pZCBmbHVzaF9rZXJuZWxfZGNhY2hlX3BhZ2Uoc3RydWN0IHBhZ2UgKnBhZ2Up Cj4gLXsKPiAtCWZsdXNoX2tlcm5lbF9kY2FjaGVfcGFnZV9hZGRyKHBhZ2VfYWRkcmVzcyhwYWdl KSk7Cj4gLX0KPiAgCj4gICNkZWZpbmUgZmx1c2hfa2VybmVsX2RjYWNoZV9yYW5nZShzdGFydCxz aXplKSBcCj4gIAlmbHVzaF9rZXJuZWxfZGNhY2hlX3JhbmdlX2FzbSgoc3RhcnQpLCAoc3RhcnQp KyhzaXplKSk7Cj4gIAo+ICsjZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9LRVJORUxfVk1B UF9SQU5HRSAxCj4gIHZvaWQgZmx1c2hfa2VybmVsX3ZtYXBfcmFuZ2Uodm9pZCAqdmFkZHIsIGlu dCBzaXplKTsKPiAgdm9pZCBpbnZhbGlkYXRlX2tlcm5lbF92bWFwX3JhbmdlKHZvaWQgKnZhZGRy LCBpbnQgc2l6ZSk7Cj4gIAo+IEBAIC01OSw3ICs1NSw3IEBAIGV4dGVybiB2b2lkIGZsdXNoX2Rj YWNoZV9wYWdlKHN0cnVjdCBwYWdlICpwYWdlKTsKPiAgI2RlZmluZSBmbHVzaF9kY2FjaGVfbW1h cF91bmxvY2sobWFwcGluZykJeGFfdW5sb2NrX2lycSgmbWFwcGluZy0+aV9wYWdlcykKPiAgCj4g ICNkZWZpbmUgZmx1c2hfaWNhY2hlX3BhZ2Uodm1hLHBhZ2UpCWRvIHsgCQlcCj4gLQlmbHVzaF9r ZXJuZWxfZGNhY2hlX3BhZ2UocGFnZSk7CQkJXAo+ICsJZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdl X2FkZHIocGFnZV9hZGRyZXNzKHBhZ2UpKTsgXAo+ICAJZmx1c2hfa2VybmVsX2ljYWNoZV9wYWdl KHBhZ2VfYWRkcmVzcyhwYWdlKSk7IAlcCj4gIH0gd2hpbGUgKDApCj4gIAo+IGRpZmYgLS1naXQg YS9hcmNoL3BhcmlzYy9rZXJuZWwvY2FjaGUuYyBiL2FyY2gvcGFyaXNjL2tlcm5lbC9jYWNoZS5j Cj4gaW5kZXggODZhMWE2MzU2M2ZkLi4zOWUwMjIyN2UyMzEgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9w YXJpc2Mva2VybmVsL2NhY2hlLmMKPiArKysgYi9hcmNoL3BhcmlzYy9rZXJuZWwvY2FjaGUuYwo+ IEBAIC0zMzQsNyArMzM0LDcgQEAgdm9pZCBmbHVzaF9kY2FjaGVfcGFnZShzdHJ1Y3QgcGFnZSAq cGFnZSkKPiAgCQlyZXR1cm47Cj4gIAl9Cj4gIAo+IC0JZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdl KHBhZ2UpOwo+ICsJZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlX2FkZHIocGFnZV9hZGRyZXNzKHBh Z2UpKTsKPiAgCj4gIAlpZiAoIW1hcHBpbmcpCj4gIAkJcmV0dXJuOwo+IEBAIC0zNzUsNyArMzc1 LDYgQEAgRVhQT1JUX1NZTUJPTChmbHVzaF9kY2FjaGVfcGFnZSk7Cj4gIAo+ICAvKiBEZWZpbmVk IGluIGFyY2gvcGFyaXNjL2tlcm5lbC9wYWNhY2hlLlMgKi8KPiAgRVhQT1JUX1NZTUJPTChmbHVz aF9rZXJuZWxfZGNhY2hlX3JhbmdlX2FzbSk7Cj4gLUVYUE9SVF9TWU1CT0woZmx1c2hfa2VybmVs X2RjYWNoZV9wYWdlX2FzbSk7Cj4gIEVYUE9SVF9TWU1CT0woZmx1c2hfZGF0YV9jYWNoZV9sb2Nh bCk7Cj4gIEVYUE9SVF9TWU1CT0woZmx1c2hfa2VybmVsX2ljYWNoZV9yYW5nZV9hc20pOwo+ICAK PiBkaWZmIC0tZ2l0IGEvYXJjaC9zaC9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmggYi9hcmNoL3No L2luY2x1ZGUvYXNtL2NhY2hlZmx1c2guaAo+IGluZGV4IDQ0ODZhODY1ZmY2Mi4uMzcyYWZhODJm ZWU2IDEwMDY0NAo+IC0tLSBhL2FyY2gvc2gvaW5jbHVkZS9hc20vY2FjaGVmbHVzaC5oCj4gKysr IGIvYXJjaC9zaC9pbmNsdWRlL2FzbS9jYWNoZWZsdXNoLmgKPiBAQCAtNjMsNiArNjMsOCBAQCBz dGF0aWMgaW5saW5lIHZvaWQgZmx1c2hfYW5vbl9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAq dm1hLAo+ICAJaWYgKGJvb3RfY3B1X2RhdGEuZGNhY2hlLm5fYWxpYXNlcyAmJiBQYWdlQW5vbihw YWdlKSkKPiAgCQlfX2ZsdXNoX2Fub25fcGFnZShwYWdlLCB2bWFkZHIpOwo+ICB9Cj4gKwo+ICsj ZGVmaW5lIEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9LRVJORUxfVk1BUF9SQU5HRSAxCj4gIHN0YXRp YyBpbmxpbmUgdm9pZCBmbHVzaF9rZXJuZWxfdm1hcF9yYW5nZSh2b2lkICphZGRyLCBpbnQgc2l6 ZSkKPiAgewo+ICAJX19mbHVzaF93YmFja19yZWdpb24oYWRkciwgc2l6ZSk7Cj4gQEAgLTcyLDEy ICs3NCw2IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBpbnZhbGlkYXRlX2tlcm5lbF92bWFwX3Jhbmdl KHZvaWQgKmFkZHIsIGludCBzaXplKQo+ICAJX19mbHVzaF9pbnZhbGlkYXRlX3JlZ2lvbihhZGRy LCBzaXplKTsKPiAgfQo+ICAKPiAtI2RlZmluZSBBUkNIX0hBU19GTFVTSF9LRVJORUxfRENBQ0hF X1BBR0UKPiAtc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2tlcm5lbF9kY2FjaGVfcGFnZShzdHJ1 Y3QgcGFnZSAqcGFnZSkKPiAtewo+IC0JZmx1c2hfZGNhY2hlX3BhZ2UocGFnZSk7Cj4gLX0KPiAt Cj4gIGV4dGVybiB2b2lkIGNvcHlfdG9fdXNlcl9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAq dm1hLAo+ICAJc3RydWN0IHBhZ2UgKnBhZ2UsIHVuc2lnbmVkIGxvbmcgdmFkZHIsIHZvaWQgKmRz dCwgY29uc3Qgdm9pZCAqc3JjLAo+ICAJdW5zaWduZWQgbG9uZyBsZW4pOwo+IGRpZmYgLS1naXQg YS9ibG9jay9ibGstbWFwLmMgYi9ibG9jay9ibGstbWFwLmMKPiBpbmRleCAzNzQzMTU4ZGRhZWIu LjQ2MzliYzZiNWM2MiAxMDA2NDQKPiAtLS0gYS9ibG9jay9ibGstbWFwLmMKPiArKysgYi9ibG9j ay9ibGstbWFwLmMKPiBAQCAtMzA5LDcgKzMwOSw3IEBAIHN0YXRpYyBpbnQgYmlvX21hcF91c2Vy X2lvdihzdHJ1Y3QgcmVxdWVzdCAqcnEsIHN0cnVjdCBpb3ZfaXRlciAqaXRlciwKPiAgCj4gIHN0 YXRpYyB2b2lkIGJpb19pbnZhbGlkYXRlX3ZtYWxsb2NfcGFnZXMoc3RydWN0IGJpbyAqYmlvKQo+ ICB7Cj4gLSNpZmRlZiBBUkNIX0hBU19GTFVTSF9LRVJORUxfRENBQ0hFX1BBR0UKPiArI2lmZGVm IEFSQ0hfSU1QTEVNRU5UU19GTFVTSF9LRVJORUxfVk1BUF9SQU5HRQo+ICAJaWYgKGJpby0+Ymlf cHJpdmF0ZSAmJiAhb3BfaXNfd3JpdGUoYmlvX29wKGJpbykpKSB7Cj4gIAkJdW5zaWduZWQgbG9u ZyBpLCBsZW4gPSAwOwo+ICAKPiBkaWZmIC0tZ2l0IGEvZnMvZXhlYy5jIGIvZnMvZXhlYy5jCj4g aW5kZXggMzhmNjM0NTFiOTI4Li40MWE4ODhkNGVkZGUgMTAwNjQ0Cj4gLS0tIGEvZnMvZXhlYy5j Cj4gKysrIGIvZnMvZXhlYy5jCj4gQEAgLTU3NCw3ICs1NzQsNyBAQCBzdGF0aWMgaW50IGNvcHlf c3RyaW5ncyhpbnQgYXJnYywgc3RydWN0IHVzZXJfYXJnX3B0ciBhcmd2LAo+ICAJCQkJfQo+ICAK PiAgCQkJCWlmIChrbWFwcGVkX3BhZ2UpIHsKPiAtCQkJCQlmbHVzaF9rZXJuZWxfZGNhY2hlX3Bh Z2Uoa21hcHBlZF9wYWdlKTsKPiArCQkJCQlmbHVzaF9kY2FjaGVfcGFnZShrbWFwcGVkX3BhZ2Up Owo+ICAJCQkJCWt1bm1hcChrbWFwcGVkX3BhZ2UpOwo+ICAJCQkJCXB1dF9hcmdfcGFnZShrbWFw cGVkX3BhZ2UpOwo+ICAJCQkJfQo+IEBAIC01OTIsNyArNTkyLDcgQEAgc3RhdGljIGludCBjb3B5 X3N0cmluZ3MoaW50IGFyZ2MsIHN0cnVjdCB1c2VyX2FyZ19wdHIgYXJndiwKPiAgCXJldCA9IDA7 Cj4gIG91dDoKPiAgCWlmIChrbWFwcGVkX3BhZ2UpIHsKPiAtCQlmbHVzaF9rZXJuZWxfZGNhY2hl X3BhZ2Uoa21hcHBlZF9wYWdlKTsKPiArCQlmbHVzaF9kY2FjaGVfcGFnZShrbWFwcGVkX3BhZ2Up Owo+ICAJCWt1bm1hcChrbWFwcGVkX3BhZ2UpOwo+ICAJCXB1dF9hcmdfcGFnZShrbWFwcGVkX3Bh Z2UpOwo+ICAJfQo+IEBAIC02MzQsNyArNjM0LDcgQEAgaW50IGNvcHlfc3RyaW5nX2tlcm5lbChj b25zdCBjaGFyICphcmcsIHN0cnVjdCBsaW51eF9iaW5wcm0gKmJwcm0pCj4gIAkJa2FkZHIgPSBr bWFwX2F0b21pYyhwYWdlKTsKPiAgCQlmbHVzaF9hcmdfcGFnZShicHJtLCBwb3MgJiBQQUdFX01B U0ssIHBhZ2UpOwo+ICAJCW1lbWNweShrYWRkciArIG9mZnNldF9pbl9wYWdlKHBvcyksIGFyZywg Ynl0ZXNfdG9fY29weSk7Cj4gLQkJZmx1c2hfa2VybmVsX2RjYWNoZV9wYWdlKHBhZ2UpOwo+ICsJ CWZsdXNoX2RjYWNoZV9wYWdlKHBhZ2UpOwo+ICAJCWt1bm1hcF9hdG9taWMoa2FkZHIpOwo+ICAJ CXB1dF9hcmdfcGFnZShwYWdlKTsKPiAgCX0KPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9o aWdobWVtLmggYi9pbmNsdWRlL2xpbnV4L2hpZ2htZW0uaAo+IGluZGV4IDhjNmU4ZTk5NmM4Ny4u ZTk1NTUxYmY5OWU5IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvaGlnaG1lbS5oCj4gKysr IGIvaW5jbHVkZS9saW51eC9oaWdobWVtLmgKPiBAQCAtMTMwLDEwICsxMzAsNyBAQCBzdGF0aWMg aW5saW5lIHZvaWQgZmx1c2hfYW5vbl9wYWdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCBz dHJ1Y3QgcGFnZSAqcGFnZQo+ICB9Cj4gICNlbmRpZgo+ICAKPiAtI2lmbmRlZiBBUkNIX0hBU19G TFVTSF9LRVJORUxfRENBQ0hFX1BBR0UKPiAtc3RhdGljIGlubGluZSB2b2lkIGZsdXNoX2tlcm5l bF9kY2FjaGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAtewo+IC19Cj4gKyNpZm5kZWYgQVJD SF9JTVBMRU1FTlRTX0ZMVVNIX0tFUk5FTF9WTUFQX1JBTkdFCj4gIHN0YXRpYyBpbmxpbmUgdm9p ZCBmbHVzaF9rZXJuZWxfdm1hcF9yYW5nZSh2b2lkICp2YWRkciwgaW50IHNpemUpCj4gIHsKPiAg fQo+IGRpZmYgLS1naXQgYS90b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xpbnV4L21tLmggYi90 b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xpbnV4L21tLmgKPiBpbmRleCBmOWExMjAwNWZjZWEu LjE2ZWM4OTViYmU1ZiAxMDA2NDQKPiAtLS0gYS90b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xp bnV4L21tLmgKPiArKysgYi90b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xpbnV4L21tLmgKPiBA QCAtMTI3LDcgKzEyNyw2IEBAIGttYWxsb2NfYXJyYXkodW5zaWduZWQgaW50IG4sIHVuc2lnbmVk IGludCBzaXplLCB1bnNpZ25lZCBpbnQgZmxhZ3MpCj4gICNkZWZpbmUga21lbWxlYWtfZnJlZShh KQo+ICAKPiAgI2RlZmluZSBQYWdlU2xhYihwKSAoMCkKPiAtI2RlZmluZSBmbHVzaF9rZXJuZWxf ZGNhY2hlX3BhZ2UocCkKPiAgCj4gICNkZWZpbmUgTUFYX0VSUk5PCTQwOTUKPiAgCj4gLS0gCj4g Mi4zMC4yCj4gCj4gCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9saW51eC1hcm0ta2VybmVsCg==