From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id AA30EC433EF for ; Thu, 9 Jun 2022 05:33:43 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S238424AbiFIFdl (ORCPT ); Thu, 9 Jun 2022 01:33:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59706 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238450AbiFIFda (ORCPT ); Thu, 9 Jun 2022 01:33:30 -0400 Received: from out30-130.freemail.mail.aliyun.com (out30-130.freemail.mail.aliyun.com [115.124.30.130]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id D84A75A145; Wed, 8 Jun 2022 22:33:25 -0700 (PDT) X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R721e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=ay29a033018046059;MF=zhongjiang-ali@linux.alibaba.com;NM=1;PH=DS;RN=38;SR=0;TI=SMTPD_---0VFrC0JA_1654752794; Received: from 30.225.24.138(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0VFrC0JA_1654752794) by smtp.aliyun-inc.com; Thu, 09 Jun 2022 13:33:17 +0800 Message-ID: <0f0bbb29-868d-1548-35f1-f446b65113ad@linux.alibaba.com> Date: Thu, 9 Jun 2022 13:33:14 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:101.0) Gecko/20100101 Thunderbird/101.0 Subject: Re: [PATCH v11 05/14] mm: multi-gen LRU: groundwork Content-Language: en-US To: Yu Zhao , Andrew Morton , linux-mm@kvack.org Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Peter Zijlstra , Tejun Heo , Vlastimil Babka , Will Deacon , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, page-reclaim@google.com, Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , =?UTF-8?Q?Holger_Hoffst=c3=a4tte?= , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain References: <20220518014632.922072-1-yuzhao@google.com> <20220518014632.922072-6-yuzhao@google.com> From: zhong jiang In-Reply-To: <20220518014632.922072-6-yuzhao@google.com> Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On 2022/5/18 9:46 上午, Yu Zhao wrote: > Evictable pages are divided into multiple generations for each lruvec. > The youngest generation number is stored in lrugen->max_seq for both > anon and file types as they are aged on an equal footing. The oldest > generation numbers are stored in lrugen->min_seq[] separately for anon > and file types as clean file pages can be evicted regardless of swap > constraints. These three variables are monotonically increasing. > > Generation numbers are truncated into order_base_2(MAX_NR_GENS+1) bits > in order to fit into the gen counter in folio->flags. Each truncated > generation number is an index to lrugen->lists[]. The sliding window > technique is used to track at least MIN_NR_GENS and at most > MAX_NR_GENS generations. The gen counter stores a value within [1, > MAX_NR_GENS] while a page is on one of lrugen->lists[]. Otherwise it > stores 0. > > There are two conceptually independent procedures: "the aging", which > produces young generations, and "the eviction", which consumes old > generations. They form a closed-loop system, i.e., "the page reclaim". > Both procedures can be invoked from userspace for the purposes of > working set estimation and proactive reclaim. These techniques are > commonly used to optimize job scheduling (bin packing) in data > centers [1][2]. > > To avoid confusion, the terms "hot" and "cold" will be applied to the > multi-gen LRU, as a new convention; the terms "active" and "inactive" > will be applied to the active/inactive LRU, as usual. > > The protection of hot pages and the selection of cold pages are based > on page access channels and patterns. There are two access channels: > one through page tables and the other through file descriptors. The > protection of the former channel is by design stronger because: > 1. The uncertainty in determining the access patterns of the former > channel is higher due to the approximation of the accessed bit. > 2. The cost of evicting the former channel is higher due to the TLB > flushes required and the likelihood of encountering the dirty bit. > 3. The penalty of underprotecting the former channel is higher because > applications usually do not prepare themselves for major page > faults like they do for blocked I/O. E.g., GUI applications > commonly use dedicated I/O threads to avoid blocking the rendering > threads. > There are also two access patterns: one with temporal locality and the > other without. For the reasons listed above, the former channel is > assumed to follow the former pattern unless VM_SEQ_READ or > VM_RAND_READ is present; the latter channel is assumed to follow the > latter pattern unless outlying refaults have been observed [3][4]. > > The next patch will address the "outlying refaults". Three macros, > i.e., LRU_REFS_WIDTH, LRU_REFS_PGOFF and LRU_REFS_MASK, used later are > added in this patch to make the entire patchset less diffy. > > A page is added to the youngest generation on faulting. The aging > needs to check the accessed bit at least twice before handing this > page over to the eviction. The first check takes care of the accessed > bit set on the initial fault; the second check makes sure this page > has not been used since then. This protocol, AKA second chance, > requires a minimum of two generations, hence MIN_NR_GENS. > > [1] https://dl.acm.org/doi/10.1145/3297858.3304053 > [2] https://dl.acm.org/doi/10.1145/3503222.3507731 > [3] https://lwn.net/Articles/495543/ > [4] https://lwn.net/Articles/815342/ > > Signed-off-by: Yu Zhao > Acked-by: Brian Geffon > Acked-by: Jan Alexander Steffens (heftig) > Acked-by: Oleksandr Natalenko > Acked-by: Steven Barrett > Acked-by: Suleiman Souhlal > Tested-by: Daniel Byrne > Tested-by: Donald Carr > Tested-by: Holger Hoffstätte > Tested-by: Konstantin Kharlamov > Tested-by: Shuang Zhai > Tested-by: Sofia Trinh > Tested-by: Vaibhav Jain > --- > fs/fuse/dev.c | 3 +- > include/linux/mm.h | 2 + > include/linux/mm_inline.h | 180 ++++++++++++++++++++++++++++++ > include/linux/mmzone.h | 98 ++++++++++++++++ > include/linux/page-flags-layout.h | 13 ++- > include/linux/page-flags.h | 4 +- > include/linux/sched.h | 4 + > kernel/bounds.c | 5 + > mm/Kconfig | 8 ++ > mm/huge_memory.c | 3 +- > mm/memcontrol.c | 2 + > mm/memory.c | 25 +++++ > mm/mm_init.c | 6 +- > mm/mmzone.c | 2 + > mm/swap.c | 9 +- > mm/vmscan.c | 75 +++++++++++++ > 16 files changed, 426 insertions(+), 13 deletions(-) > > diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c > index 0e537e580dc1..5d36015071d2 100644 > --- a/fs/fuse/dev.c > +++ b/fs/fuse/dev.c > @@ -777,7 +777,8 @@ static int fuse_check_page(struct page *page) > 1 << PG_active | > 1 << PG_workingset | > 1 << PG_reclaim | > - 1 << PG_waiters))) { > + 1 << PG_waiters | > + LRU_GEN_MASK | LRU_REFS_MASK))) { > dump_page(page, "fuse: trying to steal weird page"); > return 1; > } > diff --git a/include/linux/mm.h b/include/linux/mm.h > index 9f44254af8ce..894c289c2c06 100644 > --- a/include/linux/mm.h > +++ b/include/linux/mm.h > @@ -1060,6 +1060,8 @@ vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf); > #define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH) > #define LAST_CPUPID_PGOFF (ZONES_PGOFF - LAST_CPUPID_WIDTH) > #define KASAN_TAG_PGOFF (LAST_CPUPID_PGOFF - KASAN_TAG_WIDTH) > +#define LRU_GEN_PGOFF (KASAN_TAG_PGOFF - LRU_GEN_WIDTH) > +#define LRU_REFS_PGOFF (LRU_GEN_PGOFF - LRU_REFS_WIDTH) > > /* > * Define the bit shifts to access each section. For non-existent > diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h > index 7c9c2157e9a8..98ae22bfaf12 100644 > --- a/include/linux/mm_inline.h > +++ b/include/linux/mm_inline.h > @@ -38,6 +38,9 @@ static __always_inline void __update_lru_size(struct lruvec *lruvec, > { > struct pglist_data *pgdat = lruvec_pgdat(lruvec); > > + lockdep_assert_held(&lruvec->lru_lock); > + WARN_ON_ONCE(nr_pages != (int)nr_pages); > + > __mod_lruvec_state(lruvec, NR_LRU_BASE + lru, nr_pages); > __mod_zone_page_state(&pgdat->node_zones[zid], > NR_ZONE_LRU_BASE + lru, nr_pages); > @@ -99,11 +102,182 @@ static __always_inline enum lru_list folio_lru_list(struct folio *folio) > return lru; > } > > +#ifdef CONFIG_LRU_GEN > + > +static inline bool lru_gen_enabled(void) > +{ > + return true; > +} > + > +static inline bool lru_gen_in_fault(void) > +{ > + return current->in_lru_fault; > +} > + > +static inline int lru_gen_from_seq(unsigned long seq) > +{ > + return seq % MAX_NR_GENS; > +} > + > +static inline int folio_lru_gen(struct folio *folio) > +{ > + unsigned long flags = READ_ONCE(folio->flags); > + > + return ((flags & LRU_GEN_MASK) >> LRU_GEN_PGOFF) - 1; > +} > + > +static inline bool lru_gen_is_active(struct lruvec *lruvec, int gen) > +{ > + unsigned long max_seq = lruvec->lrugen.max_seq; > + > + VM_WARN_ON_ONCE(gen >= MAX_NR_GENS); > + > + /* see the comment on MIN_NR_GENS */ > + return gen == lru_gen_from_seq(max_seq) || gen == lru_gen_from_seq(max_seq - 1); > +} > + > +static inline void lru_gen_update_size(struct lruvec *lruvec, struct folio *folio, > + int old_gen, int new_gen) > +{ > + int type = folio_is_file_lru(folio); > + int zone = folio_zonenum(folio); > + int delta = folio_nr_pages(folio); > + enum lru_list lru = type * LRU_INACTIVE_FILE; > + struct lru_gen_struct *lrugen = &lruvec->lrugen; > + > + VM_WARN_ON_ONCE(old_gen != -1 && old_gen >= MAX_NR_GENS); > + VM_WARN_ON_ONCE(new_gen != -1 && new_gen >= MAX_NR_GENS); > + VM_WARN_ON_ONCE(old_gen == -1 && new_gen == -1); > + > + if (old_gen >= 0) > + WRITE_ONCE(lrugen->nr_pages[old_gen][type][zone], > + lrugen->nr_pages[old_gen][type][zone] - delta); > + if (new_gen >= 0) > + WRITE_ONCE(lrugen->nr_pages[new_gen][type][zone], > + lrugen->nr_pages[new_gen][type][zone] + delta); > + > + /* addition */ > + if (old_gen < 0) { > + if (lru_gen_is_active(lruvec, new_gen)) > + lru += LRU_ACTIVE; > + __update_lru_size(lruvec, lru, zone, delta); > + return; > + } > + > + /* deletion */ > + if (new_gen < 0) { > + if (lru_gen_is_active(lruvec, old_gen)) > + lru += LRU_ACTIVE; > + __update_lru_size(lruvec, lru, zone, -delta); > + return; > + } > +} > + > +static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming) > +{ > + unsigned long mask, flags; > + int gen = folio_lru_gen(folio); > + int type = folio_is_file_lru(folio); > + int zone = folio_zonenum(folio); > + struct lru_gen_struct *lrugen = &lruvec->lrugen; > + > + VM_WARN_ON_ONCE_FOLIO(gen != -1, folio); > + > + if (folio_test_unevictable(folio)) > + return false; > + /* > + * There are three common cases for this page: > + * 1. If it's hot, e.g., freshly faulted in or previously hot and > + * migrated, add it to the youngest generation. > + * 2. If it's cold but can't be evicted immediately, i.e., an anon page > + * not in swapcache or a dirty page pending writeback, add it to the > + * second oldest generation. > + * 3. Everything else (clean, cold) is added to the oldest generation. > + */ > + if (folio_test_active(folio)) > + gen = lru_gen_from_seq(lrugen->max_seq); > + else if ((type == LRU_GEN_ANON && !folio_test_swapcache(folio)) || > + (folio_test_reclaim(folio) && > + (folio_test_dirty(folio) || folio_test_writeback(folio)))) > + gen = lru_gen_from_seq(lrugen->min_seq[type] + 1); > + else > + gen = lru_gen_from_seq(lrugen->min_seq[type]); > + > + /* see the comment on MIN_NR_GENS */ > + mask = LRU_GEN_MASK | BIT(PG_active); > + flags = (gen + 1UL) << LRU_GEN_PGOFF; > + set_mask_bits(&folio->flags, mask, flags); > + > + lru_gen_update_size(lruvec, folio, -1, gen); > + /* for folio_rotate_reclaimable() */ > + if (reclaiming) > + list_add_tail(&folio->lru, &lrugen->lists[gen][type][zone]); > + else > + list_add(&folio->lru, &lrugen->lists[gen][type][zone]); > + > + return true; > +} > + > +static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming) > +{ > + unsigned long mask, flags; > + int gen = folio_lru_gen(folio); > + > + if (gen < 0) > + return false; > + > + VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio); > + VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio); > + > + mask = LRU_GEN_MASK; > + flags = 0; It always to keep the reference of page unless folios update the gen,  which is the difference between v10 and v11. I agree that. > > + /* for shrink_page_list() or folio_migrate_flags() */ > + if (reclaiming) > + mask |= BIT(PG_referenced) | BIT(PG_reclaim); > + else if (lru_gen_is_active(lruvec, gen)) > + flags |= BIT(PG_active); > + > + flags = set_mask_bits(&folio->flags, mask, flags); > + gen = ((flags & LRU_GEN_MASK) >> LRU_GEN_PGOFF) - 1; > + the flags has remove the LRU_GEN_MASK by set_mask_bits,  hence the gen will always be -1,  it will fails to decrease the specified lru size.  Am I missing something? > + lru_gen_update_size(lruvec, folio, gen, -1); > + list_del(&folio->lru); > + > + return true; > +} > + > +#else > + > +static inline bool lru_gen_enabled(void) > +{ > + return false; > +} > + > +static inline bool lru_gen_in_fault(void) > +{ > + return false; > +} > + > +static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming) > +{ > + return false; > +} > + > +static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *folio, bool reclaiming) > +{ > + return false; > +} > + > +#endif /* CONFIG_LRU_GEN */ > + > static __always_inline > void lruvec_add_folio(struct lruvec *lruvec, struct folio *folio) > { > enum lru_list lru = folio_lru_list(folio); > > + if (lru_gen_add_folio(lruvec, folio, false)) > + return; > + > update_lru_size(lruvec, lru, folio_zonenum(folio), > folio_nr_pages(folio)); > if (lru != LRU_UNEVICTABLE) > @@ -121,6 +295,9 @@ void lruvec_add_folio_tail(struct lruvec *lruvec, struct folio *folio) > { > enum lru_list lru = folio_lru_list(folio); > > + if (lru_gen_add_folio(lruvec, folio, true)) > + return; > + > update_lru_size(lruvec, lru, folio_zonenum(folio), > folio_nr_pages(folio)); > /* This is not expected to be used on LRU_UNEVICTABLE */ > @@ -138,6 +315,9 @@ void lruvec_del_folio(struct lruvec *lruvec, struct folio *folio) > { > enum lru_list lru = folio_lru_list(folio); > > + if (lru_gen_del_folio(lruvec, folio, false)) > + return; > + > if (lru != LRU_UNEVICTABLE) > list_del(&folio->lru); > update_lru_size(lruvec, lru, folio_zonenum(folio), > diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h > index 46ffab808f03..6994acef63cb 100644 > --- a/include/linux/mmzone.h > +++ b/include/linux/mmzone.h > @@ -317,6 +317,100 @@ enum lruvec_flags { > */ > }; > > +#endif /* !__GENERATING_BOUNDS_H */ > + > +/* > + * Evictable pages are divided into multiple generations. The youngest and the > + * oldest generation numbers, max_seq and min_seq, are monotonically increasing. > + * They form a sliding window of a variable size [MIN_NR_GENS, MAX_NR_GENS]. An > + * offset within MAX_NR_GENS, i.e., gen, indexes the LRU list of the > + * corresponding generation. The gen counter in folio->flags stores gen+1 while > + * a page is on one of lrugen->lists[]. Otherwise it stores 0. > + * > + * A page is added to the youngest generation on faulting. The aging needs to > + * check the accessed bit at least twice before handing this page over to the > + * eviction. The first check takes care of the accessed bit set on the initial > + * fault; the second check makes sure this page hasn't been used since then. > + * This process, AKA second chance, requires a minimum of two generations, > + * hence MIN_NR_GENS. And to maintain ABI compatibility with the active/inactive > + * LRU, e.g., /proc/vmstat, these two generations are considered active; the > + * rest of generations, if they exist, are considered inactive. See > + * lru_gen_is_active(). PG_active is always cleared while a page is on one of > + * lrugen->lists[] so that the aging needs not to worry about it. And it's set > + * again when a page considered active is isolated for non-reclaiming purposes, > + * e.g., migration. See lru_gen_add_folio() and lru_gen_del_folio(). > + * > + * MAX_NR_GENS is set to 4 so that the multi-gen LRU can support twice the > + * number of categories of the active/inactive LRU when keeping track of > + * accesses through page tables. It requires order_base_2(MAX_NR_GENS+1) bits in > + * folio->flags (LRU_GEN_MASK). > + */ > +#define MIN_NR_GENS 2U > +#define MAX_NR_GENS 4U > + > +#ifndef __GENERATING_BOUNDS_H > + > +struct lruvec; > + > +#define LRU_GEN_MASK ((BIT(LRU_GEN_WIDTH) - 1) << LRU_GEN_PGOFF) > +#define LRU_REFS_MASK ((BIT(LRU_REFS_WIDTH) - 1) << LRU_REFS_PGOFF) > + > +#ifdef CONFIG_LRU_GEN > + > +enum { > + LRU_GEN_ANON, > + LRU_GEN_FILE, > +}; > + > +/* > + * The youngest generation number is stored in max_seq for both anon and file > + * types as they are aged on an equal footing. The oldest generation numbers are > + * stored in min_seq[] separately for anon and file types as clean file pages > + * can be evicted regardless of swap constraints. > + * > + * Normally anon and file min_seq are in sync. But if swapping is constrained, > + * e.g., out of swap space, file min_seq is allowed to advance and leave anon > + * min_seq behind. > + * > + * nr_pages[] are eventually consistent and therefore can be transiently > + * negative. > + */ > +struct lru_gen_struct { > + /* the aging increments the youngest generation number */ > + unsigned long max_seq; > + /* the eviction increments the oldest generation numbers */ > + unsigned long min_seq[ANON_AND_FILE]; > + /* the multi-gen LRU lists */ > + struct list_head lists[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_ZONES]; > + /* the sizes of the above lists */ > + long nr_pages[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_ZONES]; > +}; > + > +void lru_gen_init_lruvec(struct lruvec *lruvec); > + > +#ifdef CONFIG_MEMCG > +void lru_gen_init_memcg(struct mem_cgroup *memcg); > +void lru_gen_exit_memcg(struct mem_cgroup *memcg); > +#endif > + > +#else /* !CONFIG_LRU_GEN */ > + > +static inline void lru_gen_init_lruvec(struct lruvec *lruvec) > +{ > +} > + > +#ifdef CONFIG_MEMCG > +static inline void lru_gen_init_memcg(struct mem_cgroup *memcg) > +{ > +} > + > +static inline void lru_gen_exit_memcg(struct mem_cgroup *memcg) > +{ > +} > +#endif > + > +#endif /* CONFIG_LRU_GEN */ > + > struct lruvec { > struct list_head lists[NR_LRU_LISTS]; > /* per lruvec lru_lock for memcg */ > @@ -334,6 +428,10 @@ struct lruvec { > unsigned long refaults[ANON_AND_FILE]; > /* Various lruvec state flags (enum lruvec_flags) */ > unsigned long flags; > +#ifdef CONFIG_LRU_GEN > + /* evictable pages divided into generations */ > + struct lru_gen_struct lrugen; > +#endif > #ifdef CONFIG_MEMCG > struct pglist_data *pgdat; > #endif > diff --git a/include/linux/page-flags-layout.h b/include/linux/page-flags-layout.h > index ef1e3e736e14..240905407a18 100644 > --- a/include/linux/page-flags-layout.h > +++ b/include/linux/page-flags-layout.h > @@ -55,7 +55,8 @@ > #define SECTIONS_WIDTH 0 > #endif > > -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS > +#if ZONES_WIDTH + LRU_GEN_WIDTH + SECTIONS_WIDTH + NODES_SHIFT \ > + <= BITS_PER_LONG - NR_PAGEFLAGS > #define NODES_WIDTH NODES_SHIFT > #elif defined(CONFIG_SPARSEMEM_VMEMMAP) > #error "Vmemmap: No space for nodes field in page flags" > @@ -89,8 +90,8 @@ > #define LAST_CPUPID_SHIFT 0 > #endif > > -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + KASAN_TAG_WIDTH + LAST_CPUPID_SHIFT \ > - <= BITS_PER_LONG - NR_PAGEFLAGS > +#if ZONES_WIDTH + LRU_GEN_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + \ > + KASAN_TAG_WIDTH + LAST_CPUPID_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS > #define LAST_CPUPID_WIDTH LAST_CPUPID_SHIFT > #else > #define LAST_CPUPID_WIDTH 0 > @@ -100,10 +101,12 @@ > #define LAST_CPUPID_NOT_IN_PAGE_FLAGS > #endif > > -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + KASAN_TAG_WIDTH + LAST_CPUPID_WIDTH \ > - > BITS_PER_LONG - NR_PAGEFLAGS > +#if ZONES_WIDTH + LRU_GEN_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + \ > + KASAN_TAG_WIDTH + LAST_CPUPID_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS > #error "Not enough bits in page flags" > #endif > > +#define LRU_REFS_WIDTH 0 > + > #endif > #endif /* _LINUX_PAGE_FLAGS_LAYOUT */ > diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h > index 9d8eeaa67d05..5cbde013ce66 100644 > --- a/include/linux/page-flags.h > +++ b/include/linux/page-flags.h > @@ -1017,7 +1017,7 @@ PAGEFLAG(Isolated, isolated, PF_ANY); > 1UL << PG_private | 1UL << PG_private_2 | \ > 1UL << PG_writeback | 1UL << PG_reserved | \ > 1UL << PG_slab | 1UL << PG_active | \ > - 1UL << PG_unevictable | __PG_MLOCKED) > + 1UL << PG_unevictable | __PG_MLOCKED | LRU_GEN_MASK) > > /* > * Flags checked when a page is prepped for return by the page allocator. > @@ -1028,7 +1028,7 @@ PAGEFLAG(Isolated, isolated, PF_ANY); > * alloc-free cycle to prevent from reusing the page. > */ > #define PAGE_FLAGS_CHECK_AT_PREP \ > - (PAGEFLAGS_MASK & ~__PG_HWPOISON) > + ((PAGEFLAGS_MASK & ~__PG_HWPOISON) | LRU_GEN_MASK | LRU_REFS_MASK) > > #define PAGE_FLAGS_PRIVATE \ > (1UL << PG_private | 1UL << PG_private_2) > diff --git a/include/linux/sched.h b/include/linux/sched.h > index a8911b1f35aa..448e75a5acc5 100644 > --- a/include/linux/sched.h > +++ b/include/linux/sched.h > @@ -914,6 +914,10 @@ struct task_struct { > #ifdef CONFIG_MEMCG > unsigned in_user_fault:1; > #endif > +#ifdef CONFIG_LRU_GEN > + /* whether the LRU algorithm may apply to this access */ > + unsigned in_lru_fault:1; > +#endif > #ifdef CONFIG_COMPAT_BRK > unsigned brk_randomized:1; > #endif > diff --git a/kernel/bounds.c b/kernel/bounds.c > index 9795d75b09b2..5ee60777d8e4 100644 > --- a/kernel/bounds.c > +++ b/kernel/bounds.c > @@ -22,6 +22,11 @@ int main(void) > DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS)); > #endif > DEFINE(SPINLOCK_SIZE, sizeof(spinlock_t)); > +#ifdef CONFIG_LRU_GEN > + DEFINE(LRU_GEN_WIDTH, order_base_2(MAX_NR_GENS + 1)); > +#else > + DEFINE(LRU_GEN_WIDTH, 0); > +#endif > /* End of constants */ > > return 0; > diff --git a/mm/Kconfig b/mm/Kconfig > index 034d87953600..e62bd501082b 100644 > --- a/mm/Kconfig > +++ b/mm/Kconfig > @@ -909,6 +909,14 @@ config ANON_VMA_NAME > area from being merged with adjacent virtual memory areas due to the > difference in their name. > > +config LRU_GEN > + bool "Multi-Gen LRU" > + depends on MMU > + # make sure folio->flags has enough spare bits > + depends on 64BIT || !SPARSEMEM || SPARSEMEM_VMEMMAP > + help > + A high performance LRU implementation to overcommit memory. > + > source "mm/damon/Kconfig" > > endmenu > diff --git a/mm/huge_memory.c b/mm/huge_memory.c > index 910a138e9859..a090514f2bf3 100644 > --- a/mm/huge_memory.c > +++ b/mm/huge_memory.c > @@ -2320,7 +2320,8 @@ static void __split_huge_page_tail(struct page *head, int tail, > #ifdef CONFIG_64BIT > (1L << PG_arch_2) | > #endif > - (1L << PG_dirty))); > + (1L << PG_dirty) | > + LRU_GEN_MASK | LRU_REFS_MASK)); > > /* ->mapping in first tail page is compound_mapcount */ > VM_BUG_ON_PAGE(tail > 2 && page_tail->mapping != TAIL_MAPPING, > diff --git a/mm/memcontrol.c b/mm/memcontrol.c > index 598fece89e2b..2ee074f80e72 100644 > --- a/mm/memcontrol.c > +++ b/mm/memcontrol.c > @@ -5072,6 +5072,7 @@ static void __mem_cgroup_free(struct mem_cgroup *memcg) > > static void mem_cgroup_free(struct mem_cgroup *memcg) > { > + lru_gen_exit_memcg(memcg); > memcg_wb_domain_exit(memcg); > __mem_cgroup_free(memcg); > } > @@ -5130,6 +5131,7 @@ static struct mem_cgroup *mem_cgroup_alloc(void) > memcg->deferred_split_queue.split_queue_len = 0; > #endif > idr_replace(&mem_cgroup_idr, memcg, memcg->id.id); > + lru_gen_init_memcg(memcg); > return memcg; > fail: > mem_cgroup_id_remove(memcg); > diff --git a/mm/memory.c b/mm/memory.c > index 44a1ec7a2cac..6df27b84c5aa 100644 > --- a/mm/memory.c > +++ b/mm/memory.c > @@ -4812,6 +4812,27 @@ static inline void mm_account_fault(struct pt_regs *regs, > perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address); > } > > +#ifdef CONFIG_LRU_GEN > +static void lru_gen_enter_fault(struct vm_area_struct *vma) > +{ > + /* the LRU algorithm doesn't apply to sequential or random reads */ > + current->in_lru_fault = !(vma->vm_flags & (VM_SEQ_READ | VM_RAND_READ)); > +} > + > +static void lru_gen_exit_fault(void) > +{ > + current->in_lru_fault = false; > +} > +#else > +static void lru_gen_enter_fault(struct vm_area_struct *vma) > +{ > +} > + > +static void lru_gen_exit_fault(void) > +{ > +} > +#endif /* CONFIG_LRU_GEN */ > + > /* > * By the time we get here, we already hold the mm semaphore > * > @@ -4843,11 +4864,15 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *vma, unsigned long address, > if (flags & FAULT_FLAG_USER) > mem_cgroup_enter_user_fault(); > > + lru_gen_enter_fault(vma); > + > if (unlikely(is_vm_hugetlb_page(vma))) > ret = hugetlb_fault(vma->vm_mm, vma, address, flags); > else > ret = __handle_mm_fault(vma, address, flags); > > + lru_gen_exit_fault(); > + > if (flags & FAULT_FLAG_USER) { > mem_cgroup_exit_user_fault(); > /* > diff --git a/mm/mm_init.c b/mm/mm_init.c > index 9ddaf0e1b0ab..0d7b2bd2454a 100644 > --- a/mm/mm_init.c > +++ b/mm/mm_init.c > @@ -65,14 +65,16 @@ void __init mminit_verify_pageflags_layout(void) > > shift = 8 * sizeof(unsigned long); > width = shift - SECTIONS_WIDTH - NODES_WIDTH - ZONES_WIDTH > - - LAST_CPUPID_SHIFT - KASAN_TAG_WIDTH; > + - LAST_CPUPID_SHIFT - KASAN_TAG_WIDTH - LRU_GEN_WIDTH - LRU_REFS_WIDTH; > mminit_dprintk(MMINIT_TRACE, "pageflags_layout_widths", > - "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d Flags %d\n", > + "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d Gen %d Tier %d Flags %d\n", > SECTIONS_WIDTH, > NODES_WIDTH, > ZONES_WIDTH, > LAST_CPUPID_WIDTH, > KASAN_TAG_WIDTH, > + LRU_GEN_WIDTH, > + LRU_REFS_WIDTH, > NR_PAGEFLAGS); > mminit_dprintk(MMINIT_TRACE, "pageflags_layout_shifts", > "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d\n", > diff --git a/mm/mmzone.c b/mm/mmzone.c > index 0ae7571e35ab..68e1511be12d 100644 > --- a/mm/mmzone.c > +++ b/mm/mmzone.c > @@ -88,6 +88,8 @@ void lruvec_init(struct lruvec *lruvec) > * Poison its list head, so that any operations on it would crash. > */ > list_del(&lruvec->lists[LRU_UNEVICTABLE]); > + > + lru_gen_init_lruvec(lruvec); > } > > #if defined(CONFIG_NUMA_BALANCING) && !defined(LAST_CPUPID_NOT_IN_PAGE_FLAGS) > diff --git a/mm/swap.c b/mm/swap.c > index 7e320ec08c6a..a6870ba0bd83 100644 > --- a/mm/swap.c > +++ b/mm/swap.c > @@ -460,6 +460,11 @@ void folio_add_lru(struct folio *folio) > VM_BUG_ON_FOLIO(folio_test_active(folio) && folio_test_unevictable(folio), folio); > VM_BUG_ON_FOLIO(folio_test_lru(folio), folio); > > + /* see the comment in lru_gen_add_folio() */ > + if (lru_gen_enabled() && !folio_test_unevictable(folio) && > + lru_gen_in_fault() && !(current->flags & PF_MEMALLOC)) > + folio_set_active(folio); > + > folio_get(folio); > local_lock(&lru_pvecs.lock); > pvec = this_cpu_ptr(&lru_pvecs.lru_add); > @@ -551,7 +556,7 @@ static void lru_deactivate_file_fn(struct page *page, struct lruvec *lruvec) > > static void lru_deactivate_fn(struct page *page, struct lruvec *lruvec) > { > - if (PageActive(page) && !PageUnevictable(page)) { > + if (!PageUnevictable(page) && (PageActive(page) || lru_gen_enabled())) { > int nr_pages = thp_nr_pages(page); > > del_page_from_lru_list(page, lruvec); > @@ -666,7 +671,7 @@ void deactivate_file_folio(struct folio *folio) > */ > void deactivate_page(struct page *page) > { > - if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) { > + if (PageLRU(page) && !PageUnevictable(page) && (PageActive(page) || lru_gen_enabled())) { > struct pagevec *pvec; > > local_lock(&lru_pvecs.lock); > diff --git a/mm/vmscan.c b/mm/vmscan.c > index 2232cb55af41..b41ff9765cc7 100644 > --- a/mm/vmscan.c > +++ b/mm/vmscan.c > @@ -2968,6 +2968,81 @@ static bool can_age_anon_pages(struct pglist_data *pgdat, > return can_demote(pgdat->node_id, sc); > } > > +#ifdef CONFIG_LRU_GEN > + > +/****************************************************************************** > + * shorthand helpers > + ******************************************************************************/ > + > +#define for_each_gen_type_zone(gen, type, zone) \ > + for ((gen) = 0; (gen) < MAX_NR_GENS; (gen)++) \ > + for ((type) = 0; (type) < ANON_AND_FILE; (type)++) \ > + for ((zone) = 0; (zone) < MAX_NR_ZONES; (zone)++) > + > +static struct lruvec __maybe_unused *get_lruvec(struct mem_cgroup *memcg, int nid) > +{ > + struct pglist_data *pgdat = NODE_DATA(nid); > + > +#ifdef CONFIG_MEMCG > + if (memcg) { > + struct lruvec *lruvec = &memcg->nodeinfo[nid]->lruvec; > + > + /* for hotadd_new_pgdat() */ > + if (!lruvec->pgdat) > + lruvec->pgdat = pgdat; > + > + return lruvec; > + } > +#endif > + VM_WARN_ON_ONCE(!mem_cgroup_disabled()); > + > + return pgdat ? &pgdat->__lruvec : NULL; > +} > + > +/****************************************************************************** > + * initialization > + ******************************************************************************/ > + > +void lru_gen_init_lruvec(struct lruvec *lruvec) > +{ > + int gen, type, zone; > + struct lru_gen_struct *lrugen = &lruvec->lrugen; > + > + lrugen->max_seq = MIN_NR_GENS + 1; > + > + for_each_gen_type_zone(gen, type, zone) > + INIT_LIST_HEAD(&lrugen->lists[gen][type][zone]); > +} > + > +#ifdef CONFIG_MEMCG > +void lru_gen_init_memcg(struct mem_cgroup *memcg) > +{ > +} > + > +void lru_gen_exit_memcg(struct mem_cgroup *memcg) > +{ > + int nid; > + > + for_each_node(nid) { > + struct lruvec *lruvec = get_lruvec(memcg, nid); > + > + VM_WARN_ON_ONCE(memchr_inv(lruvec->lrugen.nr_pages, 0, > + sizeof(lruvec->lrugen.nr_pages))); > + } > +} > +#endif > + > +static int __init init_lru_gen(void) > +{ > + BUILD_BUG_ON(MIN_NR_GENS + 1 >= MAX_NR_GENS); > + BUILD_BUG_ON(BIT(LRU_GEN_WIDTH) <= MAX_NR_GENS); > + > + return 0; > +}; > +late_initcall(init_lru_gen); > + > +#endif /* CONFIG_LRU_GEN */ > + > static void shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc) > { > unsigned long nr[NR_LRU_LISTS]; From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id B352EC433EF for ; Thu, 9 Jun 2022 05:35:03 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender:Content-Type: Content-Transfer-Encoding:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:In-Reply-To:From:References:Cc:To:Subject: MIME-Version:Date:Message-ID:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=CI1bFot/buDGm81dTCSzddPs036k8/n+PlzO85kbaVY=; b=TYQaihOAocrECE KxW4SjhqoO+KW7r9Qsk/ID+95+GV027yIVOZYl/9g1JWEVYy36yMUZm9qVZGVwKU7jxHN8/T7dNsF x5nXUKwGUCjNli9vn8cZTxB3jpqsI5iIpkONfFW7kIDiVOSDy37XLs2VXqeQXMllJqsUigrSIeMRY 3ETYt6Biq6x2g8XEDeeIS7/OUoDMaeOY4acNg+hsf5unbeaFXYFl+VihSx843mf8qClQx3lEZ7EQj oRtK+nWd96ruBYDyb6/e5ZiCvvttPMX/AlK2udi7/Y57VJBTUhHEIAKGEDMdm+MK34Px0JcWRM5yF 25lLdhzYbQBJ8EcaqiqQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzAnZ-00GqEw-Oy; Thu, 09 Jun 2022 05:33:37 +0000 Received: from out30-131.freemail.mail.aliyun.com ([115.124.30.131]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nzAnS-00GqCt-45 for linux-arm-kernel@lists.infradead.org; Thu, 09 Jun 2022 05:33:35 +0000 X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R721e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=ay29a033018046059;MF=zhongjiang-ali@linux.alibaba.com;NM=1;PH=DS;RN=38;SR=0;TI=SMTPD_---0VFrC0JA_1654752794; Received: from 30.225.24.138(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0VFrC0JA_1654752794) by smtp.aliyun-inc.com; Thu, 09 Jun 2022 13:33:17 +0800 Message-ID: <0f0bbb29-868d-1548-35f1-f446b65113ad@linux.alibaba.com> Date: Thu, 9 Jun 2022 13:33:14 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:101.0) Gecko/20100101 Thunderbird/101.0 Subject: Re: [PATCH v11 05/14] mm: multi-gen LRU: groundwork Content-Language: en-US To: Yu Zhao , Andrew Morton , linux-mm@kvack.org Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Peter Zijlstra , Tejun Heo , Vlastimil Babka , Will Deacon , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, page-reclaim@google.com, Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , =?UTF-8?Q?Holger_Hoffst=c3=a4tte?= , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain References: <20220518014632.922072-1-yuzhao@google.com> <20220518014632.922072-6-yuzhao@google.com> From: zhong jiang In-Reply-To: <20220518014632.922072-6-yuzhao@google.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220608_223331_472400_066A4A96 X-CRM114-Status: GOOD ( 47.01 ) 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-Transfer-Encoding: base64 Content-Type: text/plain; charset="utf-8"; Format="flowed" Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Ck9uIDIwMjIvNS8xOCA5OjQ2IOS4iuWNiCwgWXUgWmhhbyB3cm90ZToKPiBFdmljdGFibGUgcGFn ZXMgYXJlIGRpdmlkZWQgaW50byBtdWx0aXBsZSBnZW5lcmF0aW9ucyBmb3IgZWFjaCBscnV2ZWMu Cj4gVGhlIHlvdW5nZXN0IGdlbmVyYXRpb24gbnVtYmVyIGlzIHN0b3JlZCBpbiBscnVnZW4tPm1h eF9zZXEgZm9yIGJvdGgKPiBhbm9uIGFuZCBmaWxlIHR5cGVzIGFzIHRoZXkgYXJlIGFnZWQgb24g YW4gZXF1YWwgZm9vdGluZy4gVGhlIG9sZGVzdAo+IGdlbmVyYXRpb24gbnVtYmVycyBhcmUgc3Rv cmVkIGluIGxydWdlbi0+bWluX3NlcVtdIHNlcGFyYXRlbHkgZm9yIGFub24KPiBhbmQgZmlsZSB0 eXBlcyBhcyBjbGVhbiBmaWxlIHBhZ2VzIGNhbiBiZSBldmljdGVkIHJlZ2FyZGxlc3Mgb2Ygc3dh cAo+IGNvbnN0cmFpbnRzLiBUaGVzZSB0aHJlZSB2YXJpYWJsZXMgYXJlIG1vbm90b25pY2FsbHkg aW5jcmVhc2luZy4KPgo+IEdlbmVyYXRpb24gbnVtYmVycyBhcmUgdHJ1bmNhdGVkIGludG8gb3Jk ZXJfYmFzZV8yKE1BWF9OUl9HRU5TKzEpIGJpdHMKPiBpbiBvcmRlciB0byBmaXQgaW50byB0aGUg Z2VuIGNvdW50ZXIgaW4gZm9saW8tPmZsYWdzLiBFYWNoIHRydW5jYXRlZAo+IGdlbmVyYXRpb24g bnVtYmVyIGlzIGFuIGluZGV4IHRvIGxydWdlbi0+bGlzdHNbXS4gVGhlIHNsaWRpbmcgd2luZG93 Cj4gdGVjaG5pcXVlIGlzIHVzZWQgdG8gdHJhY2sgYXQgbGVhc3QgTUlOX05SX0dFTlMgYW5kIGF0 IG1vc3QKPiBNQVhfTlJfR0VOUyBnZW5lcmF0aW9ucy4gVGhlIGdlbiBjb3VudGVyIHN0b3JlcyBh IHZhbHVlIHdpdGhpbiBbMSwKPiBNQVhfTlJfR0VOU10gd2hpbGUgYSBwYWdlIGlzIG9uIG9uZSBv ZiBscnVnZW4tPmxpc3RzW10uIE90aGVyd2lzZSBpdAo+IHN0b3JlcyAwLgo+Cj4gVGhlcmUgYXJl IHR3byBjb25jZXB0dWFsbHkgaW5kZXBlbmRlbnQgcHJvY2VkdXJlczogInRoZSBhZ2luZyIsIHdo aWNoCj4gcHJvZHVjZXMgeW91bmcgZ2VuZXJhdGlvbnMsIGFuZCAidGhlIGV2aWN0aW9uIiwgd2hp Y2ggY29uc3VtZXMgb2xkCj4gZ2VuZXJhdGlvbnMuIFRoZXkgZm9ybSBhIGNsb3NlZC1sb29wIHN5 c3RlbSwgaS5lLiwgInRoZSBwYWdlIHJlY2xhaW0iLgo+IEJvdGggcHJvY2VkdXJlcyBjYW4gYmUg aW52b2tlZCBmcm9tIHVzZXJzcGFjZSBmb3IgdGhlIHB1cnBvc2VzIG9mCj4gd29ya2luZyBzZXQg ZXN0aW1hdGlvbiBhbmQgcHJvYWN0aXZlIHJlY2xhaW0uIFRoZXNlIHRlY2huaXF1ZXMgYXJlCj4g Y29tbW9ubHkgdXNlZCB0byBvcHRpbWl6ZSBqb2Igc2NoZWR1bGluZyAoYmluIHBhY2tpbmcpIGlu IGRhdGEKPiBjZW50ZXJzIFsxXVsyXS4KPgo+IFRvIGF2b2lkIGNvbmZ1c2lvbiwgdGhlIHRlcm1z ICJob3QiIGFuZCAiY29sZCIgd2lsbCBiZSBhcHBsaWVkIHRvIHRoZQo+IG11bHRpLWdlbiBMUlUs IGFzIGEgbmV3IGNvbnZlbnRpb247IHRoZSB0ZXJtcyAiYWN0aXZlIiBhbmQgImluYWN0aXZlIgo+ IHdpbGwgYmUgYXBwbGllZCB0byB0aGUgYWN0aXZlL2luYWN0aXZlIExSVSwgYXMgdXN1YWwuCj4K PiBUaGUgcHJvdGVjdGlvbiBvZiBob3QgcGFnZXMgYW5kIHRoZSBzZWxlY3Rpb24gb2YgY29sZCBw YWdlcyBhcmUgYmFzZWQKPiBvbiBwYWdlIGFjY2VzcyBjaGFubmVscyBhbmQgcGF0dGVybnMuIFRo ZXJlIGFyZSB0d28gYWNjZXNzIGNoYW5uZWxzOgo+IG9uZSB0aHJvdWdoIHBhZ2UgdGFibGVzIGFu ZCB0aGUgb3RoZXIgdGhyb3VnaCBmaWxlIGRlc2NyaXB0b3JzLiBUaGUKPiBwcm90ZWN0aW9uIG9m IHRoZSBmb3JtZXIgY2hhbm5lbCBpcyBieSBkZXNpZ24gc3Ryb25nZXIgYmVjYXVzZToKPiAxLiBU aGUgdW5jZXJ0YWludHkgaW4gZGV0ZXJtaW5pbmcgdGhlIGFjY2VzcyBwYXR0ZXJucyBvZiB0aGUg Zm9ybWVyCj4gICAgIGNoYW5uZWwgaXMgaGlnaGVyIGR1ZSB0byB0aGUgYXBwcm94aW1hdGlvbiBv ZiB0aGUgYWNjZXNzZWQgYml0Lgo+IDIuIFRoZSBjb3N0IG9mIGV2aWN0aW5nIHRoZSBmb3JtZXIg Y2hhbm5lbCBpcyBoaWdoZXIgZHVlIHRvIHRoZSBUTEIKPiAgICAgZmx1c2hlcyByZXF1aXJlZCBh bmQgdGhlIGxpa2VsaWhvb2Qgb2YgZW5jb3VudGVyaW5nIHRoZSBkaXJ0eSBiaXQuCj4gMy4gVGhl IHBlbmFsdHkgb2YgdW5kZXJwcm90ZWN0aW5nIHRoZSBmb3JtZXIgY2hhbm5lbCBpcyBoaWdoZXIg YmVjYXVzZQo+ICAgICBhcHBsaWNhdGlvbnMgdXN1YWxseSBkbyBub3QgcHJlcGFyZSB0aGVtc2Vs dmVzIGZvciBtYWpvciBwYWdlCj4gICAgIGZhdWx0cyBsaWtlIHRoZXkgZG8gZm9yIGJsb2NrZWQg SS9PLiBFLmcuLCBHVUkgYXBwbGljYXRpb25zCj4gICAgIGNvbW1vbmx5IHVzZSBkZWRpY2F0ZWQg SS9PIHRocmVhZHMgdG8gYXZvaWQgYmxvY2tpbmcgdGhlIHJlbmRlcmluZwo+ICAgICB0aHJlYWRz Lgo+IFRoZXJlIGFyZSBhbHNvIHR3byBhY2Nlc3MgcGF0dGVybnM6IG9uZSB3aXRoIHRlbXBvcmFs IGxvY2FsaXR5IGFuZCB0aGUKPiBvdGhlciB3aXRob3V0LiBGb3IgdGhlIHJlYXNvbnMgbGlzdGVk IGFib3ZlLCB0aGUgZm9ybWVyIGNoYW5uZWwgaXMKPiBhc3N1bWVkIHRvIGZvbGxvdyB0aGUgZm9y bWVyIHBhdHRlcm4gdW5sZXNzIFZNX1NFUV9SRUFEIG9yCj4gVk1fUkFORF9SRUFEIGlzIHByZXNl bnQ7IHRoZSBsYXR0ZXIgY2hhbm5lbCBpcyBhc3N1bWVkIHRvIGZvbGxvdyB0aGUKPiBsYXR0ZXIg cGF0dGVybiB1bmxlc3Mgb3V0bHlpbmcgcmVmYXVsdHMgaGF2ZSBiZWVuIG9ic2VydmVkIFszXVs0 XS4KPgo+IFRoZSBuZXh0IHBhdGNoIHdpbGwgYWRkcmVzcyB0aGUgIm91dGx5aW5nIHJlZmF1bHRz Ii4gVGhyZWUgbWFjcm9zLAo+IGkuZS4sIExSVV9SRUZTX1dJRFRILCBMUlVfUkVGU19QR09GRiBh bmQgTFJVX1JFRlNfTUFTSywgdXNlZCBsYXRlciBhcmUKPiBhZGRlZCBpbiB0aGlzIHBhdGNoIHRv IG1ha2UgdGhlIGVudGlyZSBwYXRjaHNldCBsZXNzIGRpZmZ5Lgo+Cj4gQSBwYWdlIGlzIGFkZGVk IHRvIHRoZSB5b3VuZ2VzdCBnZW5lcmF0aW9uIG9uIGZhdWx0aW5nLiBUaGUgYWdpbmcKPiBuZWVk cyB0byBjaGVjayB0aGUgYWNjZXNzZWQgYml0IGF0IGxlYXN0IHR3aWNlIGJlZm9yZSBoYW5kaW5n IHRoaXMKPiBwYWdlIG92ZXIgdG8gdGhlIGV2aWN0aW9uLiBUaGUgZmlyc3QgY2hlY2sgdGFrZXMg Y2FyZSBvZiB0aGUgYWNjZXNzZWQKPiBiaXQgc2V0IG9uIHRoZSBpbml0aWFsIGZhdWx0OyB0aGUg c2Vjb25kIGNoZWNrIG1ha2VzIHN1cmUgdGhpcyBwYWdlCj4gaGFzIG5vdCBiZWVuIHVzZWQgc2lu Y2UgdGhlbi4gVGhpcyBwcm90b2NvbCwgQUtBIHNlY29uZCBjaGFuY2UsCj4gcmVxdWlyZXMgYSBt aW5pbXVtIG9mIHR3byBnZW5lcmF0aW9ucywgaGVuY2UgTUlOX05SX0dFTlMuCj4KPiBbMV0gaHR0 cHM6Ly9kbC5hY20ub3JnL2RvaS8xMC4xMTQ1LzMyOTc4NTguMzMwNDA1Mwo+IFsyXSBodHRwczov L2RsLmFjbS5vcmcvZG9pLzEwLjExNDUvMzUwMzIyMi4zNTA3NzMxCj4gWzNdIGh0dHBzOi8vbHdu Lm5ldC9BcnRpY2xlcy80OTU1NDMvCj4gWzRdIGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy84MTUz NDIvCj4KPiBTaWduZWQtb2ZmLWJ5OiBZdSBaaGFvIDx5dXpoYW9AZ29vZ2xlLmNvbT4KPiBBY2tl ZC1ieTogQnJpYW4gR2VmZm9uIDxiZ2VmZm9uQGdvb2dsZS5jb20+Cj4gQWNrZWQtYnk6IEphbiBB bGV4YW5kZXIgU3RlZmZlbnMgKGhlZnRpZykgPGhlZnRpZ0BhcmNobGludXgub3JnPgo+IEFja2Vk LWJ5OiBPbGVrc2FuZHIgTmF0YWxlbmtvIDxvbGVrc2FuZHJAbmF0YWxlbmtvLm5hbWU+Cj4gQWNr ZWQtYnk6IFN0ZXZlbiBCYXJyZXR0IDxzdGV2ZW5AbGlxdW9yaXgubmV0Pgo+IEFja2VkLWJ5OiBT dWxlaW1hbiBTb3VobGFsIDxzdWxlaW1hbkBnb29nbGUuY29tPgo+IFRlc3RlZC1ieTogRGFuaWVs IEJ5cm5lIDxkamJ5cm5lQG10dS5lZHU+Cj4gVGVzdGVkLWJ5OiBEb25hbGQgQ2FyciA8ZEBjaGFv cy1yZWlucy5jb20+Cj4gVGVzdGVkLWJ5OiBIb2xnZXIgSG9mZnN0w6R0dGUgPGhvbGdlckBhcHBs aWVkLWFzeW5jaHJvbnkuY29tPgo+IFRlc3RlZC1ieTogS29uc3RhbnRpbiBLaGFybGFtb3YgPEhp LUFuZ2VsQHlhbmRleC5ydT4KPiBUZXN0ZWQtYnk6IFNodWFuZyBaaGFpIDxzemhhaTJAY3Mucm9j aGVzdGVyLmVkdT4KPiBUZXN0ZWQtYnk6IFNvZmlhIFRyaW5oIDxzb2ZpYS50cmluaEBlZGkud29y a3M+Cj4gVGVzdGVkLWJ5OiBWYWliaGF2IEphaW4gPHZhaWJoYXZAbGludXguaWJtLmNvbT4KPiAt LS0KPiAgIGZzL2Z1c2UvZGV2LmMgICAgICAgICAgICAgICAgICAgICB8ICAgMyArLQo+ICAgaW5j bHVkZS9saW51eC9tbS5oICAgICAgICAgICAgICAgIHwgICAyICsKPiAgIGluY2x1ZGUvbGludXgv bW1faW5saW5lLmggICAgICAgICB8IDE4MCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK PiAgIGluY2x1ZGUvbGludXgvbW16b25lLmggICAgICAgICAgICB8ICA5OCArKysrKysrKysrKysr KysrCj4gICBpbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MtbGF5b3V0LmggfCAgMTMgKystCj4gICBp bmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaCAgICAgICAgfCAgIDQgKy0KPiAgIGluY2x1ZGUvbGlu dXgvc2NoZWQuaCAgICAgICAgICAgICB8ICAgNCArCj4gICBrZXJuZWwvYm91bmRzLmMgICAgICAg ICAgICAgICAgICAgfCAgIDUgKwo+ICAgbW0vS2NvbmZpZyAgICAgICAgICAgICAgICAgICAgICAg IHwgICA4ICsrCj4gICBtbS9odWdlX21lbW9yeS5jICAgICAgICAgICAgICAgICAgfCAgIDMgKy0K PiAgIG1tL21lbWNvbnRyb2wuYyAgICAgICAgICAgICAgICAgICB8ICAgMiArCj4gICBtbS9tZW1v cnkuYyAgICAgICAgICAgICAgICAgICAgICAgfCAgMjUgKysrKysKPiAgIG1tL21tX2luaXQuYyAg ICAgICAgICAgICAgICAgICAgICB8ICAgNiArLQo+ICAgbW0vbW16b25lLmMgICAgICAgICAgICAg ICAgICAgICAgIHwgICAyICsKPiAgIG1tL3N3YXAuYyAgICAgICAgICAgICAgICAgICAgICAgICB8 ICAgOSArLQo+ICAgbW0vdm1zY2FuLmMgICAgICAgICAgICAgICAgICAgICAgIHwgIDc1ICsrKysr KysrKysrKysKPiAgIDE2IGZpbGVzIGNoYW5nZWQsIDQyNiBpbnNlcnRpb25zKCspLCAxMyBkZWxl dGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9mcy9mdXNlL2Rldi5jIGIvZnMvZnVzZS9kZXYuYwo+ IGluZGV4IDBlNTM3ZTU4MGRjMS4uNWQzNjAxNTA3MWQyIDEwMDY0NAo+IC0tLSBhL2ZzL2Z1c2Uv ZGV2LmMKPiArKysgYi9mcy9mdXNlL2Rldi5jCj4gQEAgLTc3Nyw3ICs3NzcsOCBAQCBzdGF0aWMg aW50IGZ1c2VfY2hlY2tfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKPiAgIAkgICAgICAgMSA8PCBQ R19hY3RpdmUgfAo+ICAgCSAgICAgICAxIDw8IFBHX3dvcmtpbmdzZXQgfAo+ICAgCSAgICAgICAx IDw8IFBHX3JlY2xhaW0gfAo+IC0JICAgICAgIDEgPDwgUEdfd2FpdGVycykpKSB7Cj4gKwkgICAg ICAgMSA8PCBQR193YWl0ZXJzIHwKPiArCSAgICAgICBMUlVfR0VOX01BU0sgfCBMUlVfUkVGU19N QVNLKSkpIHsKPiAgIAkJZHVtcF9wYWdlKHBhZ2UsICJmdXNlOiB0cnlpbmcgdG8gc3RlYWwgd2Vp cmQgcGFnZSIpOwo+ICAgCQlyZXR1cm4gMTsKPiAgIAl9Cj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUv bGludXgvbW0uaCBiL2luY2x1ZGUvbGludXgvbW0uaAo+IGluZGV4IDlmNDQyNTRhZjhjZS4uODk0 YzI4OWMyYzA2IDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW0uaAo+ICsrKyBiL2luY2x1 ZGUvbGludXgvbW0uaAo+IEBAIC0xMDYwLDYgKzEwNjAsOCBAQCB2bV9mYXVsdF90IGZpbmlzaF9t a3dyaXRlX2ZhdWx0KHN0cnVjdCB2bV9mYXVsdCAqdm1mKTsKPiAgICNkZWZpbmUgWk9ORVNfUEdP RkYJCShOT0RFU19QR09GRiAtIFpPTkVTX1dJRFRIKQo+ICAgI2RlZmluZSBMQVNUX0NQVVBJRF9Q R09GRgkoWk9ORVNfUEdPRkYgLSBMQVNUX0NQVVBJRF9XSURUSCkKPiAgICNkZWZpbmUgS0FTQU5f VEFHX1BHT0ZGCQkoTEFTVF9DUFVQSURfUEdPRkYgLSBLQVNBTl9UQUdfV0lEVEgpCj4gKyNkZWZp bmUgTFJVX0dFTl9QR09GRgkJKEtBU0FOX1RBR19QR09GRiAtIExSVV9HRU5fV0lEVEgpCj4gKyNk ZWZpbmUgTFJVX1JFRlNfUEdPRkYJCShMUlVfR0VOX1BHT0ZGIC0gTFJVX1JFRlNfV0lEVEgpCj4g ICAKPiAgIC8qCj4gICAgKiBEZWZpbmUgdGhlIGJpdCBzaGlmdHMgdG8gYWNjZXNzIGVhY2ggc2Vj dGlvbi4gIEZvciBub24tZXhpc3RlbnQKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbV9p bmxpbmUuaCBiL2luY2x1ZGUvbGludXgvbW1faW5saW5lLmgKPiBpbmRleCA3YzljMjE1N2U5YTgu Ljk4YWUyMmJmYWYxMiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L21tX2lubGluZS5oCj4g KysrIGIvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaAo+IEBAIC0zOCw2ICszOCw5IEBAIHN0YXRp YyBfX2Fsd2F5c19pbmxpbmUgdm9pZCBfX3VwZGF0ZV9scnVfc2l6ZShzdHJ1Y3QgbHJ1dmVjICps cnV2ZWMsCj4gICB7Cj4gICAJc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCA9IGxydXZlY19wZ2Rh dChscnV2ZWMpOwo+ICAgCj4gKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZscnV2ZWMtPmxydV9sb2Nr KTsKPiArCVdBUk5fT05fT05DRShucl9wYWdlcyAhPSAoaW50KW5yX3BhZ2VzKTsKPiArCj4gICAJ X19tb2RfbHJ1dmVjX3N0YXRlKGxydXZlYywgTlJfTFJVX0JBU0UgKyBscnUsIG5yX3BhZ2VzKTsK PiAgIAlfX21vZF96b25lX3BhZ2Vfc3RhdGUoJnBnZGF0LT5ub2RlX3pvbmVzW3ppZF0sCj4gICAJ CQkJTlJfWk9ORV9MUlVfQkFTRSArIGxydSwgbnJfcGFnZXMpOwo+IEBAIC05OSwxMSArMTAyLDE4 MiBAQCBzdGF0aWMgX19hbHdheXNfaW5saW5lIGVudW0gbHJ1X2xpc3QgZm9saW9fbHJ1X2xpc3Qo c3RydWN0IGZvbGlvICpmb2xpbykKPiAgIAlyZXR1cm4gbHJ1Owo+ICAgfQo+ICAgCj4gKyNpZmRl ZiBDT05GSUdfTFJVX0dFTgo+ICsKPiArc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fZW5hYmxl ZCh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gdHJ1ZTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSBi b29sIGxydV9nZW5faW5fZmF1bHQodm9pZCkKPiArewo+ICsJcmV0dXJuIGN1cnJlbnQtPmluX2xy dV9mYXVsdDsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSBpbnQgbHJ1X2dlbl9mcm9tX3NlcSh1 bnNpZ25lZCBsb25nIHNlcSkKPiArewo+ICsJcmV0dXJuIHNlcSAlIE1BWF9OUl9HRU5TOwo+ICt9 Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCBmb2xpb19scnVfZ2VuKHN0cnVjdCBmb2xpbyAqZm9s aW8pCj4gK3sKPiArCXVuc2lnbmVkIGxvbmcgZmxhZ3MgPSBSRUFEX09OQ0UoZm9saW8tPmZsYWdz KTsKPiArCj4gKwlyZXR1cm4gKChmbGFncyAmIExSVV9HRU5fTUFTSykgPj4gTFJVX0dFTl9QR09G RikgLSAxOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9pc19hY3RpdmUo c3RydWN0IGxydXZlYyAqbHJ1dmVjLCBpbnQgZ2VuKQo+ICt7Cj4gKwl1bnNpZ25lZCBsb25nIG1h eF9zZXEgPSBscnV2ZWMtPmxydWdlbi5tYXhfc2VxOwo+ICsKPiArCVZNX1dBUk5fT05fT05DRShn ZW4gPj0gTUFYX05SX0dFTlMpOwo+ICsKPiArCS8qIHNlZSB0aGUgY29tbWVudCBvbiBNSU5fTlJf R0VOUyAqLwo+ICsJcmV0dXJuIGdlbiA9PSBscnVfZ2VuX2Zyb21fc2VxKG1heF9zZXEpIHx8IGdl biA9PSBscnVfZ2VuX2Zyb21fc2VxKG1heF9zZXEgLSAxKTsKPiArfQo+ICsKPiArc3RhdGljIGlu bGluZSB2b2lkIGxydV9nZW5fdXBkYXRlX3NpemUoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1 Y3QgZm9saW8gKmZvbGlvLAo+ICsJCQkJICAgICAgIGludCBvbGRfZ2VuLCBpbnQgbmV3X2dlbikK PiArewo+ICsJaW50IHR5cGUgPSBmb2xpb19pc19maWxlX2xydShmb2xpbyk7Cj4gKwlpbnQgem9u ZSA9IGZvbGlvX3pvbmVudW0oZm9saW8pOwo+ICsJaW50IGRlbHRhID0gZm9saW9fbnJfcGFnZXMo Zm9saW8pOwo+ICsJZW51bSBscnVfbGlzdCBscnUgPSB0eXBlICogTFJVX0lOQUNUSVZFX0ZJTEU7 Cj4gKwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZscnV2ZWMtPmxydWdlbjsKPiAr Cj4gKwlWTV9XQVJOX09OX09OQ0Uob2xkX2dlbiAhPSAtMSAmJiBvbGRfZ2VuID49IE1BWF9OUl9H RU5TKTsKPiArCVZNX1dBUk5fT05fT05DRShuZXdfZ2VuICE9IC0xICYmIG5ld19nZW4gPj0gTUFY X05SX0dFTlMpOwo+ICsJVk1fV0FSTl9PTl9PTkNFKG9sZF9nZW4gPT0gLTEgJiYgbmV3X2dlbiA9 PSAtMSk7Cj4gKwo+ICsJaWYgKG9sZF9nZW4gPj0gMCkKPiArCQlXUklURV9PTkNFKGxydWdlbi0+ bnJfcGFnZXNbb2xkX2dlbl1bdHlwZV1bem9uZV0sCj4gKwkJCSAgIGxydWdlbi0+bnJfcGFnZXNb b2xkX2dlbl1bdHlwZV1bem9uZV0gLSBkZWx0YSk7Cj4gKwlpZiAobmV3X2dlbiA+PSAwKQo+ICsJ CVdSSVRFX09OQ0UobHJ1Z2VuLT5ucl9wYWdlc1tuZXdfZ2VuXVt0eXBlXVt6b25lXSwKPiArCQkJ ICAgbHJ1Z2VuLT5ucl9wYWdlc1tuZXdfZ2VuXVt0eXBlXVt6b25lXSArIGRlbHRhKTsKPiArCj4g KwkvKiBhZGRpdGlvbiAqLwo+ICsJaWYgKG9sZF9nZW4gPCAwKSB7Cj4gKwkJaWYgKGxydV9nZW5f aXNfYWN0aXZlKGxydXZlYywgbmV3X2dlbikpCj4gKwkJCWxydSArPSBMUlVfQUNUSVZFOwo+ICsJ CV9fdXBkYXRlX2xydV9zaXplKGxydXZlYywgbHJ1LCB6b25lLCBkZWx0YSk7Cj4gKwkJcmV0dXJu Owo+ICsJfQo+ICsKPiArCS8qIGRlbGV0aW9uICovCj4gKwlpZiAobmV3X2dlbiA8IDApIHsKPiAr CQlpZiAobHJ1X2dlbl9pc19hY3RpdmUobHJ1dmVjLCBvbGRfZ2VuKSkKPiArCQkJbHJ1ICs9IExS VV9BQ1RJVkU7Cj4gKwkJX191cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIHpvbmUsIC1kZWx0 YSk7Cj4gKwkJcmV0dXJuOwo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgbHJ1 X2dlbl9hZGRfZm9saW8oc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlv LCBib29sIHJlY2xhaW1pbmcpCj4gK3sKPiArCXVuc2lnbmVkIGxvbmcgbWFzaywgZmxhZ3M7Cj4g KwlpbnQgZ2VuID0gZm9saW9fbHJ1X2dlbihmb2xpbyk7Cj4gKwlpbnQgdHlwZSA9IGZvbGlvX2lz X2ZpbGVfbHJ1KGZvbGlvKTsKPiArCWludCB6b25lID0gZm9saW9fem9uZW51bShmb2xpbyk7Cj4g KwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZscnV2ZWMtPmxydWdlbjsKPiArCj4g KwlWTV9XQVJOX09OX09OQ0VfRk9MSU8oZ2VuICE9IC0xLCBmb2xpbyk7Cj4gKwo+ICsJaWYgKGZv bGlvX3Rlc3RfdW5ldmljdGFibGUoZm9saW8pKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCS8qCj4g KwkgKiBUaGVyZSBhcmUgdGhyZWUgY29tbW9uIGNhc2VzIGZvciB0aGlzIHBhZ2U6Cj4gKwkgKiAx LiBJZiBpdCdzIGhvdCwgZS5nLiwgZnJlc2hseSBmYXVsdGVkIGluIG9yIHByZXZpb3VzbHkgaG90 IGFuZAo+ICsJICogICAgbWlncmF0ZWQsIGFkZCBpdCB0byB0aGUgeW91bmdlc3QgZ2VuZXJhdGlv bi4KPiArCSAqIDIuIElmIGl0J3MgY29sZCBidXQgY2FuJ3QgYmUgZXZpY3RlZCBpbW1lZGlhdGVs eSwgaS5lLiwgYW4gYW5vbiBwYWdlCj4gKwkgKiAgICBub3QgaW4gc3dhcGNhY2hlIG9yIGEgZGly dHkgcGFnZSBwZW5kaW5nIHdyaXRlYmFjaywgYWRkIGl0IHRvIHRoZQo+ICsJICogICAgc2Vjb25k IG9sZGVzdCBnZW5lcmF0aW9uLgo+ICsJICogMy4gRXZlcnl0aGluZyBlbHNlIChjbGVhbiwgY29s ZCkgaXMgYWRkZWQgdG8gdGhlIG9sZGVzdCBnZW5lcmF0aW9uLgo+ICsJICovCj4gKwlpZiAoZm9s aW9fdGVzdF9hY3RpdmUoZm9saW8pKQo+ICsJCWdlbiA9IGxydV9nZW5fZnJvbV9zZXEobHJ1Z2Vu LT5tYXhfc2VxKTsKPiArCWVsc2UgaWYgKCh0eXBlID09IExSVV9HRU5fQU5PTiAmJiAhZm9saW9f dGVzdF9zd2FwY2FjaGUoZm9saW8pKSB8fAo+ICsJCSAoZm9saW9fdGVzdF9yZWNsYWltKGZvbGlv KSAmJgo+ICsJCSAgKGZvbGlvX3Rlc3RfZGlydHkoZm9saW8pIHx8IGZvbGlvX3Rlc3Rfd3JpdGVi YWNrKGZvbGlvKSkpKQo+ICsJCWdlbiA9IGxydV9nZW5fZnJvbV9zZXEobHJ1Z2VuLT5taW5fc2Vx W3R5cGVdICsgMSk7Cj4gKwllbHNlCj4gKwkJZ2VuID0gbHJ1X2dlbl9mcm9tX3NlcShscnVnZW4t Pm1pbl9zZXFbdHlwZV0pOwo+ICsKPiArCS8qIHNlZSB0aGUgY29tbWVudCBvbiBNSU5fTlJfR0VO UyAqLwo+ICsJbWFzayA9IExSVV9HRU5fTUFTSyB8IEJJVChQR19hY3RpdmUpOwo+ICsJZmxhZ3Mg PSAoZ2VuICsgMVVMKSA8PCBMUlVfR0VOX1BHT0ZGOwo+ICsJc2V0X21hc2tfYml0cygmZm9saW8t PmZsYWdzLCBtYXNrLCBmbGFncyk7Cj4gKwo+ICsJbHJ1X2dlbl91cGRhdGVfc2l6ZShscnV2ZWMs IGZvbGlvLCAtMSwgZ2VuKTsKPiArCS8qIGZvciBmb2xpb19yb3RhdGVfcmVjbGFpbWFibGUoKSAq Lwo+ICsJaWYgKHJlY2xhaW1pbmcpCj4gKwkJbGlzdF9hZGRfdGFpbCgmZm9saW8tPmxydSwgJmxy dWdlbi0+bGlzdHNbZ2VuXVt0eXBlXVt6b25lXSk7Cj4gKwllbHNlCj4gKwkJbGlzdF9hZGQoJmZv bGlvLT5scnUsICZscnVnZW4tPmxpc3RzW2dlbl1bdHlwZV1bem9uZV0pOwo+ICsKPiArCXJldHVy biB0cnVlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9kZWxfZm9saW8o c3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlvLCBib29sIHJlY2xhaW1p bmcpCj4gK3sKPiArCXVuc2lnbmVkIGxvbmcgbWFzaywgZmxhZ3M7Cj4gKwlpbnQgZ2VuID0gZm9s aW9fbHJ1X2dlbihmb2xpbyk7Cj4gKwo+ICsJaWYgKGdlbiA8IDApCj4gKwkJcmV0dXJuIGZhbHNl Owo+ICsKPiArCVZNX1dBUk5fT05fT05DRV9GT0xJTyhmb2xpb190ZXN0X2FjdGl2ZShmb2xpbyks IGZvbGlvKTsKPiArCVZNX1dBUk5fT05fT05DRV9GT0xJTyhmb2xpb190ZXN0X3VuZXZpY3RhYmxl KGZvbGlvKSwgZm9saW8pOwo+ICsKPiArCW1hc2sgPSBMUlVfR0VOX01BU0s7Cj4gKwlmbGFncyA9 IDA7CgpJdCBhbHdheXMgdG8ga2VlcCB0aGUgcmVmZXJlbmNlIG9mIHBhZ2UgdW5sZXNzIGZvbGlv cyB1cGRhdGUgdGhlIGdlbizCoCAKd2hpY2ggaXMgdGhlIGRpZmZlcmVuY2UgYmV0d2VlbiB2MTAg YW5kIHYxMS4KCkkgYWdyZWUgdGhhdC4KCj4gICAKPiArCS8qIGZvciBzaHJpbmtfcGFnZV9saXN0 KCkgb3IgZm9saW9fbWlncmF0ZV9mbGFncygpICovCj4gKwlpZiAocmVjbGFpbWluZykKPiArCQlt YXNrIHw9IEJJVChQR19yZWZlcmVuY2VkKSB8IEJJVChQR19yZWNsYWltKTsKPiArCWVsc2UgaWYg KGxydV9nZW5faXNfYWN0aXZlKGxydXZlYywgZ2VuKSkKPiArCQlmbGFncyB8PSBCSVQoUEdfYWN0 aXZlKTsKPiArCj4gKwlmbGFncyA9IHNldF9tYXNrX2JpdHMoJmZvbGlvLT5mbGFncywgbWFzaywg ZmxhZ3MpOwo+ICsJZ2VuID0gKChmbGFncyAmIExSVV9HRU5fTUFTSykgPj4gTFJVX0dFTl9QR09G RikgLSAxOwo+ICsKCnRoZSBmbGFncyBoYXMgcmVtb3ZlIHRoZSBMUlVfR0VOX01BU0sgYnkgc2V0 X21hc2tfYml0cyzCoCBoZW5jZSB0aGUgZ2VuIAp3aWxsIGFsd2F5cyBiZSAtMSzCoCBpdCB3aWxs IGZhaWxzCgp0byBkZWNyZWFzZSB0aGUgc3BlY2lmaWVkIGxydSBzaXplLsKgIEFtIEkgbWlzc2lu ZyBzb21ldGhpbmc/Cgo+ICsJbHJ1X2dlbl91cGRhdGVfc2l6ZShscnV2ZWMsIGZvbGlvLCBnZW4s IC0xKTsKPiArCWxpc3RfZGVsKCZmb2xpby0+bHJ1KTsKPiArCj4gKwlyZXR1cm4gdHJ1ZTsKPiAr fQo+ICsKPiArI2Vsc2UKPiArCj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2VuYWJsZWQo dm9pZCkKPiArewo+ICsJcmV0dXJuIGZhbHNlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGJv b2wgbHJ1X2dlbl9pbl9mYXVsdCh2b2lkKQo+ICt7Cj4gKwlyZXR1cm4gZmFsc2U7Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2FkZF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICps cnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sIGJvb2wgcmVjbGFpbWluZykKPiArewo+ICsJcmV0 dXJuIGZhbHNlOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9kZWxfZm9s aW8oc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlvLCBib29sIHJlY2xh aW1pbmcpCj4gK3sKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArI2VuZGlmIC8qIENPTkZJ R19MUlVfR0VOICovCj4gKwo+ICAgc3RhdGljIF9fYWx3YXlzX2lubGluZQo+ICAgdm9pZCBscnV2 ZWNfYWRkX2ZvbGlvKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IGZvbGlvICpmb2xpbykK PiAgIHsKPiAgIAllbnVtIGxydV9saXN0IGxydSA9IGZvbGlvX2xydV9saXN0KGZvbGlvKTsKPiAg IAo+ICsJaWYgKGxydV9nZW5fYWRkX2ZvbGlvKGxydXZlYywgZm9saW8sIGZhbHNlKSkKPiArCQly ZXR1cm47Cj4gKwo+ICAgCXVwZGF0ZV9scnVfc2l6ZShscnV2ZWMsIGxydSwgZm9saW9fem9uZW51 bShmb2xpbyksCj4gICAJCQlmb2xpb19ucl9wYWdlcyhmb2xpbykpOwo+ICAgCWlmIChscnUgIT0g TFJVX1VORVZJQ1RBQkxFKQo+IEBAIC0xMjEsNiArMjk1LDkgQEAgdm9pZCBscnV2ZWNfYWRkX2Zv bGlvX3RhaWwoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlvKQo+ICAg ewo+ICAgCWVudW0gbHJ1X2xpc3QgbHJ1ID0gZm9saW9fbHJ1X2xpc3QoZm9saW8pOwo+ICAgCj4g KwlpZiAobHJ1X2dlbl9hZGRfZm9saW8obHJ1dmVjLCBmb2xpbywgdHJ1ZSkpCj4gKwkJcmV0dXJu Owo+ICsKPiAgIAl1cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIGZvbGlvX3pvbmVudW0oZm9s aW8pLAo+ICAgCQkJZm9saW9fbnJfcGFnZXMoZm9saW8pKTsKPiAgIAkvKiBUaGlzIGlzIG5vdCBl eHBlY3RlZCB0byBiZSB1c2VkIG9uIExSVV9VTkVWSUNUQUJMRSAqLwo+IEBAIC0xMzgsNiArMzE1 LDkgQEAgdm9pZCBscnV2ZWNfZGVsX2ZvbGlvKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0 IGZvbGlvICpmb2xpbykKPiAgIHsKPiAgIAllbnVtIGxydV9saXN0IGxydSA9IGZvbGlvX2xydV9s aXN0KGZvbGlvKTsKPiAgIAo+ICsJaWYgKGxydV9nZW5fZGVsX2ZvbGlvKGxydXZlYywgZm9saW8s IGZhbHNlKSkKPiArCQlyZXR1cm47Cj4gKwo+ICAgCWlmIChscnUgIT0gTFJVX1VORVZJQ1RBQkxF KQo+ICAgCQlsaXN0X2RlbCgmZm9saW8tPmxydSk7Cj4gICAJdXBkYXRlX2xydV9zaXplKGxydXZl YywgbHJ1LCBmb2xpb196b25lbnVtKGZvbGlvKSwKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9tbXpvbmUuaCBiL2luY2x1ZGUvbGludXgvbW16b25lLmgKPiBpbmRleCA0NmZmYWI4MDhmMDMu LjY5OTRhY2VmNjNjYiAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L21tem9uZS5oCj4gKysr IGIvaW5jbHVkZS9saW51eC9tbXpvbmUuaAo+IEBAIC0zMTcsNiArMzE3LDEwMCBAQCBlbnVtIGxy dXZlY19mbGFncyB7Cj4gICAJCQkJCSAqLwo+ICAgfTsKPiAgIAo+ICsjZW5kaWYgLyogIV9fR0VO RVJBVElOR19CT1VORFNfSCAqLwo+ICsKPiArLyoKPiArICogRXZpY3RhYmxlIHBhZ2VzIGFyZSBk aXZpZGVkIGludG8gbXVsdGlwbGUgZ2VuZXJhdGlvbnMuIFRoZSB5b3VuZ2VzdCBhbmQgdGhlCj4g KyAqIG9sZGVzdCBnZW5lcmF0aW9uIG51bWJlcnMsIG1heF9zZXEgYW5kIG1pbl9zZXEsIGFyZSBt b25vdG9uaWNhbGx5IGluY3JlYXNpbmcuCj4gKyAqIFRoZXkgZm9ybSBhIHNsaWRpbmcgd2luZG93 IG9mIGEgdmFyaWFibGUgc2l6ZSBbTUlOX05SX0dFTlMsIE1BWF9OUl9HRU5TXS4gQW4KPiArICog b2Zmc2V0IHdpdGhpbiBNQVhfTlJfR0VOUywgaS5lLiwgZ2VuLCBpbmRleGVzIHRoZSBMUlUgbGlz dCBvZiB0aGUKPiArICogY29ycmVzcG9uZGluZyBnZW5lcmF0aW9uLiBUaGUgZ2VuIGNvdW50ZXIg aW4gZm9saW8tPmZsYWdzIHN0b3JlcyBnZW4rMSB3aGlsZQo+ICsgKiBhIHBhZ2UgaXMgb24gb25l IG9mIGxydWdlbi0+bGlzdHNbXS4gT3RoZXJ3aXNlIGl0IHN0b3JlcyAwLgo+ICsgKgo+ICsgKiBB IHBhZ2UgaXMgYWRkZWQgdG8gdGhlIHlvdW5nZXN0IGdlbmVyYXRpb24gb24gZmF1bHRpbmcuIFRo ZSBhZ2luZyBuZWVkcyB0bwo+ICsgKiBjaGVjayB0aGUgYWNjZXNzZWQgYml0IGF0IGxlYXN0IHR3 aWNlIGJlZm9yZSBoYW5kaW5nIHRoaXMgcGFnZSBvdmVyIHRvIHRoZQo+ICsgKiBldmljdGlvbi4g VGhlIGZpcnN0IGNoZWNrIHRha2VzIGNhcmUgb2YgdGhlIGFjY2Vzc2VkIGJpdCBzZXQgb24gdGhl IGluaXRpYWwKPiArICogZmF1bHQ7IHRoZSBzZWNvbmQgY2hlY2sgbWFrZXMgc3VyZSB0aGlzIHBh Z2UgaGFzbid0IGJlZW4gdXNlZCBzaW5jZSB0aGVuLgo+ICsgKiBUaGlzIHByb2Nlc3MsIEFLQSBz ZWNvbmQgY2hhbmNlLCByZXF1aXJlcyBhIG1pbmltdW0gb2YgdHdvIGdlbmVyYXRpb25zLAo+ICsg KiBoZW5jZSBNSU5fTlJfR0VOUy4gQW5kIHRvIG1haW50YWluIEFCSSBjb21wYXRpYmlsaXR5IHdp dGggdGhlIGFjdGl2ZS9pbmFjdGl2ZQo+ICsgKiBMUlUsIGUuZy4sIC9wcm9jL3Ztc3RhdCwgdGhl c2UgdHdvIGdlbmVyYXRpb25zIGFyZSBjb25zaWRlcmVkIGFjdGl2ZTsgdGhlCj4gKyAqIHJlc3Qg b2YgZ2VuZXJhdGlvbnMsIGlmIHRoZXkgZXhpc3QsIGFyZSBjb25zaWRlcmVkIGluYWN0aXZlLiBT ZWUKPiArICogbHJ1X2dlbl9pc19hY3RpdmUoKS4gUEdfYWN0aXZlIGlzIGFsd2F5cyBjbGVhcmVk IHdoaWxlIGEgcGFnZSBpcyBvbiBvbmUgb2YKPiArICogbHJ1Z2VuLT5saXN0c1tdIHNvIHRoYXQg dGhlIGFnaW5nIG5lZWRzIG5vdCB0byB3b3JyeSBhYm91dCBpdC4gQW5kIGl0J3Mgc2V0Cj4gKyAq IGFnYWluIHdoZW4gYSBwYWdlIGNvbnNpZGVyZWQgYWN0aXZlIGlzIGlzb2xhdGVkIGZvciBub24t cmVjbGFpbWluZyBwdXJwb3NlcywKPiArICogZS5nLiwgbWlncmF0aW9uLiBTZWUgbHJ1X2dlbl9h ZGRfZm9saW8oKSBhbmQgbHJ1X2dlbl9kZWxfZm9saW8oKS4KPiArICoKPiArICogTUFYX05SX0dF TlMgaXMgc2V0IHRvIDQgc28gdGhhdCB0aGUgbXVsdGktZ2VuIExSVSBjYW4gc3VwcG9ydCB0d2lj ZSB0aGUKPiArICogbnVtYmVyIG9mIGNhdGVnb3JpZXMgb2YgdGhlIGFjdGl2ZS9pbmFjdGl2ZSBM UlUgd2hlbiBrZWVwaW5nIHRyYWNrIG9mCj4gKyAqIGFjY2Vzc2VzIHRocm91Z2ggcGFnZSB0YWJs ZXMuIEl0IHJlcXVpcmVzIG9yZGVyX2Jhc2VfMihNQVhfTlJfR0VOUysxKSBiaXRzIGluCj4gKyAq IGZvbGlvLT5mbGFncyAoTFJVX0dFTl9NQVNLKS4KPiArICovCj4gKyNkZWZpbmUgTUlOX05SX0dF TlMJCTJVCj4gKyNkZWZpbmUgTUFYX05SX0dFTlMJCTRVCj4gKwo+ICsjaWZuZGVmIF9fR0VORVJB VElOR19CT1VORFNfSAo+ICsKPiArc3RydWN0IGxydXZlYzsKPiArCj4gKyNkZWZpbmUgTFJVX0dF Tl9NQVNLCQkoKEJJVChMUlVfR0VOX1dJRFRIKSAtIDEpIDw8IExSVV9HRU5fUEdPRkYpCj4gKyNk ZWZpbmUgTFJVX1JFRlNfTUFTSwkJKChCSVQoTFJVX1JFRlNfV0lEVEgpIC0gMSkgPDwgTFJVX1JF RlNfUEdPRkYpCj4gKwo+ICsjaWZkZWYgQ09ORklHX0xSVV9HRU4KPiArCj4gK2VudW0gewo+ICsJ TFJVX0dFTl9BTk9OLAo+ICsJTFJVX0dFTl9GSUxFLAo+ICt9Owo+ICsKPiArLyoKPiArICogVGhl IHlvdW5nZXN0IGdlbmVyYXRpb24gbnVtYmVyIGlzIHN0b3JlZCBpbiBtYXhfc2VxIGZvciBib3Ro IGFub24gYW5kIGZpbGUKPiArICogdHlwZXMgYXMgdGhleSBhcmUgYWdlZCBvbiBhbiBlcXVhbCBm b290aW5nLiBUaGUgb2xkZXN0IGdlbmVyYXRpb24gbnVtYmVycyBhcmUKPiArICogc3RvcmVkIGlu IG1pbl9zZXFbXSBzZXBhcmF0ZWx5IGZvciBhbm9uIGFuZCBmaWxlIHR5cGVzIGFzIGNsZWFuIGZp bGUgcGFnZXMKPiArICogY2FuIGJlIGV2aWN0ZWQgcmVnYXJkbGVzcyBvZiBzd2FwIGNvbnN0cmFp bnRzLgo+ICsgKgo+ICsgKiBOb3JtYWxseSBhbm9uIGFuZCBmaWxlIG1pbl9zZXEgYXJlIGluIHN5 bmMuIEJ1dCBpZiBzd2FwcGluZyBpcyBjb25zdHJhaW5lZCwKPiArICogZS5nLiwgb3V0IG9mIHN3 YXAgc3BhY2UsIGZpbGUgbWluX3NlcSBpcyBhbGxvd2VkIHRvIGFkdmFuY2UgYW5kIGxlYXZlIGFu b24KPiArICogbWluX3NlcSBiZWhpbmQuCj4gKyAqCj4gKyAqIG5yX3BhZ2VzW10gYXJlIGV2ZW50 dWFsbHkgY29uc2lzdGVudCBhbmQgdGhlcmVmb3JlIGNhbiBiZSB0cmFuc2llbnRseQo+ICsgKiBu ZWdhdGl2ZS4KPiArICovCj4gK3N0cnVjdCBscnVfZ2VuX3N0cnVjdCB7Cj4gKwkvKiB0aGUgYWdp bmcgaW5jcmVtZW50cyB0aGUgeW91bmdlc3QgZ2VuZXJhdGlvbiBudW1iZXIgKi8KPiArCXVuc2ln bmVkIGxvbmcgbWF4X3NlcTsKPiArCS8qIHRoZSBldmljdGlvbiBpbmNyZW1lbnRzIHRoZSBvbGRl c3QgZ2VuZXJhdGlvbiBudW1iZXJzICovCj4gKwl1bnNpZ25lZCBsb25nIG1pbl9zZXFbQU5PTl9B TkRfRklMRV07Cj4gKwkvKiB0aGUgbXVsdGktZ2VuIExSVSBsaXN0cyAqLwo+ICsJc3RydWN0IGxp c3RfaGVhZCBsaXN0c1tNQVhfTlJfR0VOU11bQU5PTl9BTkRfRklMRV1bTUFYX05SX1pPTkVTXTsK PiArCS8qIHRoZSBzaXplcyBvZiB0aGUgYWJvdmUgbGlzdHMgKi8KPiArCWxvbmcgbnJfcGFnZXNb TUFYX05SX0dFTlNdW0FOT05fQU5EX0ZJTEVdW01BWF9OUl9aT05FU107Cj4gK307Cj4gKwo+ICt2 b2lkIGxydV9nZW5faW5pdF9scnV2ZWMoc3RydWN0IGxydXZlYyAqbHJ1dmVjKTsKPiArCj4gKyNp ZmRlZiBDT05GSUdfTUVNQ0cKPiArdm9pZCBscnVfZ2VuX2luaXRfbWVtY2coc3RydWN0IG1lbV9j Z3JvdXAgKm1lbWNnKTsKPiArdm9pZCBscnVfZ2VuX2V4aXRfbWVtY2coc3RydWN0IG1lbV9jZ3Jv dXAgKm1lbWNnKTsKPiArI2VuZGlmCj4gKwo+ICsjZWxzZSAvKiAhQ09ORklHX0xSVV9HRU4gKi8K PiArCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbHJ1dmVjKHN0cnVjdCBscnV2 ZWMgKmxydXZlYykKPiArewo+ICt9Cj4gKwo+ICsjaWZkZWYgQ09ORklHX01FTUNHCj4gK3N0YXRp YyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbWVtY2coc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNn KQo+ICt7Cj4gK30KPiArCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2V4aXRfbWVtY2co c3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQo+ICt7Cj4gK30KPiArI2VuZGlmCj4gKwo+ICsjZW5k aWYgLyogQ09ORklHX0xSVV9HRU4gKi8KPiArCj4gICBzdHJ1Y3QgbHJ1dmVjIHsKPiAgIAlzdHJ1 Y3QgbGlzdF9oZWFkCQlsaXN0c1tOUl9MUlVfTElTVFNdOwo+ICAgCS8qIHBlciBscnV2ZWMgbHJ1 X2xvY2sgZm9yIG1lbWNnICovCj4gQEAgLTMzNCw2ICs0MjgsMTAgQEAgc3RydWN0IGxydXZlYyB7 Cj4gICAJdW5zaWduZWQgbG9uZwkJCXJlZmF1bHRzW0FOT05fQU5EX0ZJTEVdOwo+ICAgCS8qIFZh cmlvdXMgbHJ1dmVjIHN0YXRlIGZsYWdzIChlbnVtIGxydXZlY19mbGFncykgKi8KPiAgIAl1bnNp Z25lZCBsb25nCQkJZmxhZ3M7Cj4gKyNpZmRlZiBDT05GSUdfTFJVX0dFTgo+ICsJLyogZXZpY3Rh YmxlIHBhZ2VzIGRpdmlkZWQgaW50byBnZW5lcmF0aW9ucyAqLwo+ICsJc3RydWN0IGxydV9nZW5f c3RydWN0CQlscnVnZW47Cj4gKyNlbmRpZgo+ICAgI2lmZGVmIENPTkZJR19NRU1DRwo+ICAgCXN0 cnVjdCBwZ2xpc3RfZGF0YSAqcGdkYXQ7Cj4gICAjZW5kaWYKPiBkaWZmIC0tZ2l0IGEvaW5jbHVk ZS9saW51eC9wYWdlLWZsYWdzLWxheW91dC5oIGIvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxh eW91dC5oCj4gaW5kZXggZWYxZTNlNzM2ZTE0Li4yNDA5MDU0MDdhMTggMTAwNjQ0Cj4gLS0tIGEv aW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxheW91dC5oCj4gKysrIGIvaW5jbHVkZS9saW51eC9w YWdlLWZsYWdzLWxheW91dC5oCj4gQEAgLTU1LDcgKzU1LDggQEAKPiAgICNkZWZpbmUgU0VDVElP TlNfV0lEVEgJCTAKPiAgICNlbmRpZgo+ICAgCj4gLSNpZiBaT05FU19XSURUSCArIFNFQ1RJT05T X1dJRFRIICsgTk9ERVNfU0hJRlQgPD0gQklUU19QRVJfTE9ORyAtIE5SX1BBR0VGTEFHUwo+ICsj aWYgWk9ORVNfV0lEVEggKyBMUlVfR0VOX1dJRFRIICsgU0VDVElPTlNfV0lEVEggKyBOT0RFU19T SElGVCBcCj4gKwk8PSBCSVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdTCj4gICAjZGVmaW5lIE5P REVTX1dJRFRICQlOT0RFU19TSElGVAo+ICAgI2VsaWYgZGVmaW5lZChDT05GSUdfU1BBUlNFTUVN X1ZNRU1NQVApCj4gICAjZXJyb3IgIlZtZW1tYXA6IE5vIHNwYWNlIGZvciBub2RlcyBmaWVsZCBp biBwYWdlIGZsYWdzIgo+IEBAIC04OSw4ICs5MCw4IEBACj4gICAjZGVmaW5lIExBU1RfQ1BVUElE X1NISUZUIDAKPiAgICNlbmRpZgo+ICAgCj4gLSNpZiBaT05FU19XSURUSCArIFNFQ1RJT05TX1dJ RFRIICsgTk9ERVNfV0lEVEggKyBLQVNBTl9UQUdfV0lEVEggKyBMQVNUX0NQVVBJRF9TSElGVCBc Cj4gLQk8PSBCSVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdTCj4gKyNpZiBaT05FU19XSURUSCAr IExSVV9HRU5fV0lEVEggKyBTRUNUSU9OU19XSURUSCArIE5PREVTX1dJRFRIICsgXAo+ICsJS0FT QU5fVEFHX1dJRFRIICsgTEFTVF9DUFVQSURfU0hJRlQgPD0gQklUU19QRVJfTE9ORyAtIE5SX1BB R0VGTEFHUwo+ICAgI2RlZmluZSBMQVNUX0NQVVBJRF9XSURUSCBMQVNUX0NQVVBJRF9TSElGVAo+ ICAgI2Vsc2UKPiAgICNkZWZpbmUgTEFTVF9DUFVQSURfV0lEVEggMAo+IEBAIC0xMDAsMTAgKzEw MSwxMiBAQAo+ICAgI2RlZmluZSBMQVNUX0NQVVBJRF9OT1RfSU5fUEFHRV9GTEFHUwo+ICAgI2Vu ZGlmCj4gICAKPiAtI2lmIFpPTkVTX1dJRFRIICsgU0VDVElPTlNfV0lEVEggKyBOT0RFU19XSURU SCArIEtBU0FOX1RBR19XSURUSCArIExBU1RfQ1BVUElEX1dJRFRIIFwKPiAtCT4gQklUU19QRVJf TE9ORyAtIE5SX1BBR0VGTEFHUwo+ICsjaWYgWk9ORVNfV0lEVEggKyBMUlVfR0VOX1dJRFRIICsg U0VDVElPTlNfV0lEVEggKyBOT0RFU19XSURUSCArIFwKPiArCUtBU0FOX1RBR19XSURUSCArIExB U1RfQ1BVUElEX1dJRFRIID4gQklUU19QRVJfTE9ORyAtIE5SX1BBR0VGTEFHUwo+ICAgI2Vycm9y ICJOb3QgZW5vdWdoIGJpdHMgaW4gcGFnZSBmbGFncyIKPiAgICNlbmRpZgo+ICAgCj4gKyNkZWZp bmUgTFJVX1JFRlNfV0lEVEgJMAo+ICsKPiAgICNlbmRpZgo+ICAgI2VuZGlmIC8qIF9MSU5VWF9Q QUdFX0ZMQUdTX0xBWU9VVCAqLwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxh Z3MuaCBiL2luY2x1ZGUvbGludXgvcGFnZS1mbGFncy5oCj4gaW5kZXggOWQ4ZWVhYTY3ZDA1Li41 Y2JkZTAxM2NlNjYgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLmgKPiAr KysgYi9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaAo+IEBAIC0xMDE3LDcgKzEwMTcsNyBAQCBQ QUdFRkxBRyhJc29sYXRlZCwgaXNvbGF0ZWQsIFBGX0FOWSk7Cj4gICAJIDFVTCA8PCBQR19wcml2 YXRlCXwgMVVMIDw8IFBHX3ByaXZhdGVfMgl8CVwKPiAgIAkgMVVMIDw8IFBHX3dyaXRlYmFjawl8 IDFVTCA8PCBQR19yZXNlcnZlZAl8CVwKPiAgIAkgMVVMIDw8IFBHX3NsYWIJCXwgMVVMIDw8IFBH X2FjdGl2ZSAJfAlcCj4gLQkgMVVMIDw8IFBHX3VuZXZpY3RhYmxlCXwgX19QR19NTE9DS0VEKQo+ ICsJIDFVTCA8PCBQR191bmV2aWN0YWJsZQl8IF9fUEdfTUxPQ0tFRCB8IExSVV9HRU5fTUFTSykK PiAgIAo+ICAgLyoKPiAgICAqIEZsYWdzIGNoZWNrZWQgd2hlbiBhIHBhZ2UgaXMgcHJlcHBlZCBm b3IgcmV0dXJuIGJ5IHRoZSBwYWdlIGFsbG9jYXRvci4KPiBAQCAtMTAyOCw3ICsxMDI4LDcgQEAg UEFHRUZMQUcoSXNvbGF0ZWQsIGlzb2xhdGVkLCBQRl9BTlkpOwo+ICAgICogYWxsb2MtZnJlZSBj eWNsZSB0byBwcmV2ZW50IGZyb20gcmV1c2luZyB0aGUgcGFnZS4KPiAgICAqLwo+ICAgI2RlZmlu ZSBQQUdFX0ZMQUdTX0NIRUNLX0FUX1BSRVAJXAo+IC0JKFBBR0VGTEFHU19NQVNLICYgfl9fUEdf SFdQT0lTT04pCj4gKwkoKFBBR0VGTEFHU19NQVNLICYgfl9fUEdfSFdQT0lTT04pIHwgTFJVX0dF Tl9NQVNLIHwgTFJVX1JFRlNfTUFTSykKPiAgIAo+ICAgI2RlZmluZSBQQUdFX0ZMQUdTX1BSSVZB VEUJCQkJXAo+ICAgCSgxVUwgPDwgUEdfcHJpdmF0ZSB8IDFVTCA8PCBQR19wcml2YXRlXzIpCj4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc2NoZWQuaCBiL2luY2x1ZGUvbGludXgvc2NoZWQu aAo+IGluZGV4IGE4OTExYjFmMzVhYS4uNDQ4ZTc1YTVhY2M1IDEwMDY0NAo+IC0tLSBhL2luY2x1 ZGUvbGludXgvc2NoZWQuaAo+ICsrKyBiL2luY2x1ZGUvbGludXgvc2NoZWQuaAo+IEBAIC05MTQs NiArOTE0LDEwIEBAIHN0cnVjdCB0YXNrX3N0cnVjdCB7Cj4gICAjaWZkZWYgQ09ORklHX01FTUNH Cj4gICAJdW5zaWduZWQJCQlpbl91c2VyX2ZhdWx0OjE7Cj4gICAjZW5kaWYKPiArI2lmZGVmIENP TkZJR19MUlVfR0VOCj4gKwkvKiB3aGV0aGVyIHRoZSBMUlUgYWxnb3JpdGhtIG1heSBhcHBseSB0 byB0aGlzIGFjY2VzcyAqLwo+ICsJdW5zaWduZWQJCQlpbl9scnVfZmF1bHQ6MTsKPiArI2VuZGlm Cj4gICAjaWZkZWYgQ09ORklHX0NPTVBBVF9CUksKPiAgIAl1bnNpZ25lZAkJCWJya19yYW5kb21p emVkOjE7Cj4gICAjZW5kaWYKPiBkaWZmIC0tZ2l0IGEva2VybmVsL2JvdW5kcy5jIGIva2VybmVs L2JvdW5kcy5jCj4gaW5kZXggOTc5NWQ3NWIwOWIyLi41ZWU2MDc3N2Q4ZTQgMTAwNjQ0Cj4gLS0t IGEva2VybmVsL2JvdW5kcy5jCj4gKysrIGIva2VybmVsL2JvdW5kcy5jCj4gQEAgLTIyLDYgKzIy LDExIEBAIGludCBtYWluKHZvaWQpCj4gICAJREVGSU5FKE5SX0NQVVNfQklUUywgaWxvZzIoQ09O RklHX05SX0NQVVMpKTsKPiAgICNlbmRpZgo+ICAgCURFRklORShTUElOTE9DS19TSVpFLCBzaXpl b2Yoc3BpbmxvY2tfdCkpOwo+ICsjaWZkZWYgQ09ORklHX0xSVV9HRU4KPiArCURFRklORShMUlVf R0VOX1dJRFRILCBvcmRlcl9iYXNlXzIoTUFYX05SX0dFTlMgKyAxKSk7Cj4gKyNlbHNlCj4gKwlE RUZJTkUoTFJVX0dFTl9XSURUSCwgMCk7Cj4gKyNlbmRpZgo+ICAgCS8qIEVuZCBvZiBjb25zdGFu dHMgKi8KPiAgIAo+ICAgCXJldHVybiAwOwo+IGRpZmYgLS1naXQgYS9tbS9LY29uZmlnIGIvbW0v S2NvbmZpZwo+IGluZGV4IDAzNGQ4Nzk1MzYwMC4uZTYyYmQ1MDEwODJiIDEwMDY0NAo+IC0tLSBh L21tL0tjb25maWcKPiArKysgYi9tbS9LY29uZmlnCj4gQEAgLTkwOSw2ICs5MDksMTQgQEAgY29u ZmlnIEFOT05fVk1BX05BTUUKPiAgIAkgIGFyZWEgZnJvbSBiZWluZyBtZXJnZWQgd2l0aCBhZGph Y2VudCB2aXJ0dWFsIG1lbW9yeSBhcmVhcyBkdWUgdG8gdGhlCj4gICAJICBkaWZmZXJlbmNlIGlu IHRoZWlyIG5hbWUuCj4gICAKPiArY29uZmlnIExSVV9HRU4KPiArCWJvb2wgIk11bHRpLUdlbiBM UlUiCj4gKwlkZXBlbmRzIG9uIE1NVQo+ICsJIyBtYWtlIHN1cmUgZm9saW8tPmZsYWdzIGhhcyBl bm91Z2ggc3BhcmUgYml0cwo+ICsJZGVwZW5kcyBvbiA2NEJJVCB8fCAhU1BBUlNFTUVNIHx8IFNQ QVJTRU1FTV9WTUVNTUFQCj4gKwloZWxwCj4gKwkgIEEgaGlnaCBwZXJmb3JtYW5jZSBMUlUgaW1w bGVtZW50YXRpb24gdG8gb3ZlcmNvbW1pdCBtZW1vcnkuCj4gKwo+ICAgc291cmNlICJtbS9kYW1v bi9LY29uZmlnIgo+ICAgCj4gICBlbmRtZW51Cj4gZGlmZiAtLWdpdCBhL21tL2h1Z2VfbWVtb3J5 LmMgYi9tbS9odWdlX21lbW9yeS5jCj4gaW5kZXggOTEwYTEzOGU5ODU5Li5hMDkwNTE0ZjJiZjMg MTAwNjQ0Cj4gLS0tIGEvbW0vaHVnZV9tZW1vcnkuYwo+ICsrKyBiL21tL2h1Z2VfbWVtb3J5LmMK PiBAQCAtMjMyMCw3ICsyMzIwLDggQEAgc3RhdGljIHZvaWQgX19zcGxpdF9odWdlX3BhZ2VfdGFp bChzdHJ1Y3QgcGFnZSAqaGVhZCwgaW50IHRhaWwsCj4gICAjaWZkZWYgQ09ORklHXzY0QklUCj4g ICAJCQkgKDFMIDw8IFBHX2FyY2hfMikgfAo+ICAgI2VuZGlmCj4gLQkJCSAoMUwgPDwgUEdfZGly dHkpKSk7Cj4gKwkJCSAoMUwgPDwgUEdfZGlydHkpIHwKPiArCQkJIExSVV9HRU5fTUFTSyB8IExS VV9SRUZTX01BU0spKTsKPiAgIAo+ICAgCS8qIC0+bWFwcGluZyBpbiBmaXJzdCB0YWlsIHBhZ2Ug aXMgY29tcG91bmRfbWFwY291bnQgKi8KPiAgIAlWTV9CVUdfT05fUEFHRSh0YWlsID4gMiAmJiBw YWdlX3RhaWwtPm1hcHBpbmcgIT0gVEFJTF9NQVBQSU5HLAo+IGRpZmYgLS1naXQgYS9tbS9tZW1j b250cm9sLmMgYi9tbS9tZW1jb250cm9sLmMKPiBpbmRleCA1OThmZWNlODllMmIuLjJlZTA3NGY4 MGU3MiAxMDA2NDQKPiAtLS0gYS9tbS9tZW1jb250cm9sLmMKPiArKysgYi9tbS9tZW1jb250cm9s LmMKPiBAQCAtNTA3Miw2ICs1MDcyLDcgQEAgc3RhdGljIHZvaWQgX19tZW1fY2dyb3VwX2ZyZWUo c3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQo+ICAgCj4gICBzdGF0aWMgdm9pZCBtZW1fY2dyb3Vw X2ZyZWUoc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQo+ICAgewo+ICsJbHJ1X2dlbl9leGl0X21l bWNnKG1lbWNnKTsKPiAgIAltZW1jZ193Yl9kb21haW5fZXhpdChtZW1jZyk7Cj4gICAJX19tZW1f Y2dyb3VwX2ZyZWUobWVtY2cpOwo+ICAgfQo+IEBAIC01MTMwLDYgKzUxMzEsNyBAQCBzdGF0aWMg c3RydWN0IG1lbV9jZ3JvdXAgKm1lbV9jZ3JvdXBfYWxsb2Modm9pZCkKPiAgIAltZW1jZy0+ZGVm ZXJyZWRfc3BsaXRfcXVldWUuc3BsaXRfcXVldWVfbGVuID0gMDsKPiAgICNlbmRpZgo+ICAgCWlk cl9yZXBsYWNlKCZtZW1fY2dyb3VwX2lkciwgbWVtY2csIG1lbWNnLT5pZC5pZCk7Cj4gKwlscnVf Z2VuX2luaXRfbWVtY2cobWVtY2cpOwo+ICAgCXJldHVybiBtZW1jZzsKPiAgIGZhaWw6Cj4gICAJ bWVtX2Nncm91cF9pZF9yZW1vdmUobWVtY2cpOwo+IGRpZmYgLS1naXQgYS9tbS9tZW1vcnkuYyBi L21tL21lbW9yeS5jCj4gaW5kZXggNDRhMWVjN2EyY2FjLi42ZGYyN2I4NGM1YWEgMTAwNjQ0Cj4g LS0tIGEvbW0vbWVtb3J5LmMKPiArKysgYi9tbS9tZW1vcnkuYwo+IEBAIC00ODEyLDYgKzQ4MTIs MjcgQEAgc3RhdGljIGlubGluZSB2b2lkIG1tX2FjY291bnRfZmF1bHQoc3RydWN0IHB0X3JlZ3Mg KnJlZ3MsCj4gICAJCXBlcmZfc3dfZXZlbnQoUEVSRl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NSU4s IDEsIHJlZ3MsIGFkZHJlc3MpOwo+ICAgfQo+ICAgCj4gKyNpZmRlZiBDT05GSUdfTFJVX0dFTgo+ ICtzdGF0aWMgdm9pZCBscnVfZ2VuX2VudGVyX2ZhdWx0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAq dm1hKQo+ICt7Cj4gKwkvKiB0aGUgTFJVIGFsZ29yaXRobSBkb2Vzbid0IGFwcGx5IHRvIHNlcXVl bnRpYWwgb3IgcmFuZG9tIHJlYWRzICovCj4gKwljdXJyZW50LT5pbl9scnVfZmF1bHQgPSAhKHZt YS0+dm1fZmxhZ3MgJiAoVk1fU0VRX1JFQUQgfCBWTV9SQU5EX1JFQUQpKTsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgbHJ1X2dlbl9leGl0X2ZhdWx0KHZvaWQpCj4gK3sKPiArCWN1cnJlbnQtPmlu X2xydV9mYXVsdCA9IGZhbHNlOwo+ICt9Cj4gKyNlbHNlCj4gK3N0YXRpYyB2b2lkIGxydV9nZW5f ZW50ZXJfZmF1bHQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCj4gK3sKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgbHJ1X2dlbl9leGl0X2ZhdWx0KHZvaWQpCj4gK3sKPiArfQo+ICsjZW5kaWYg LyogQ09ORklHX0xSVV9HRU4gKi8KPiArCj4gICAvKgo+ICAgICogQnkgdGhlIHRpbWUgd2UgZ2V0 IGhlcmUsIHdlIGFscmVhZHkgaG9sZCB0aGUgbW0gc2VtYXBob3JlCj4gICAgKgo+IEBAIC00ODQz LDExICs0ODY0LDE1IEBAIHZtX2ZhdWx0X3QgaGFuZGxlX21tX2ZhdWx0KHN0cnVjdCB2bV9hcmVh X3N0cnVjdCAqdm1hLCB1bnNpZ25lZCBsb25nIGFkZHJlc3MsCj4gICAJaWYgKGZsYWdzICYgRkFV TFRfRkxBR19VU0VSKQo+ICAgCQltZW1fY2dyb3VwX2VudGVyX3VzZXJfZmF1bHQoKTsKPiAgIAo+ ICsJbHJ1X2dlbl9lbnRlcl9mYXVsdCh2bWEpOwo+ICsKPiAgIAlpZiAodW5saWtlbHkoaXNfdm1f aHVnZXRsYl9wYWdlKHZtYSkpKQo+ICAgCQlyZXQgPSBodWdldGxiX2ZhdWx0KHZtYS0+dm1fbW0s IHZtYSwgYWRkcmVzcywgZmxhZ3MpOwo+ICAgCWVsc2UKPiAgIAkJcmV0ID0gX19oYW5kbGVfbW1f ZmF1bHQodm1hLCBhZGRyZXNzLCBmbGFncyk7Cj4gICAKPiArCWxydV9nZW5fZXhpdF9mYXVsdCgp Owo+ICsKPiAgIAlpZiAoZmxhZ3MgJiBGQVVMVF9GTEFHX1VTRVIpIHsKPiAgIAkJbWVtX2Nncm91 cF9leGl0X3VzZXJfZmF1bHQoKTsKPiAgIAkJLyoKPiBkaWZmIC0tZ2l0IGEvbW0vbW1faW5pdC5j IGIvbW0vbW1faW5pdC5jCj4gaW5kZXggOWRkYWYwZTFiMGFiLi4wZDdiMmJkMjQ1NGEgMTAwNjQ0 Cj4gLS0tIGEvbW0vbW1faW5pdC5jCj4gKysrIGIvbW0vbW1faW5pdC5jCj4gQEAgLTY1LDE0ICs2 NSwxNiBAQCB2b2lkIF9faW5pdCBtbWluaXRfdmVyaWZ5X3BhZ2VmbGFnc19sYXlvdXQodm9pZCkK PiAgIAo+ICAgCXNoaWZ0ID0gOCAqIHNpemVvZih1bnNpZ25lZCBsb25nKTsKPiAgIAl3aWR0aCA9 IHNoaWZ0IC0gU0VDVElPTlNfV0lEVEggLSBOT0RFU19XSURUSCAtIFpPTkVTX1dJRFRICj4gLQkJ LSBMQVNUX0NQVVBJRF9TSElGVCAtIEtBU0FOX1RBR19XSURUSDsKPiArCQktIExBU1RfQ1BVUElE X1NISUZUIC0gS0FTQU5fVEFHX1dJRFRIIC0gTFJVX0dFTl9XSURUSCAtIExSVV9SRUZTX1dJRFRI Owo+ICAgCW1taW5pdF9kcHJpbnRrKE1NSU5JVF9UUkFDRSwgInBhZ2VmbGFnc19sYXlvdXRfd2lk dGhzIiwKPiAtCQkiU2VjdGlvbiAlZCBOb2RlICVkIFpvbmUgJWQgTGFzdGNwdXBpZCAlZCBLYXNh bnRhZyAlZCBGbGFncyAlZFxuIiwKPiArCQkiU2VjdGlvbiAlZCBOb2RlICVkIFpvbmUgJWQgTGFz dGNwdXBpZCAlZCBLYXNhbnRhZyAlZCBHZW4gJWQgVGllciAlZCBGbGFncyAlZFxuIiwKPiAgIAkJ U0VDVElPTlNfV0lEVEgsCj4gICAJCU5PREVTX1dJRFRILAo+ICAgCQlaT05FU19XSURUSCwKPiAg IAkJTEFTVF9DUFVQSURfV0lEVEgsCj4gICAJCUtBU0FOX1RBR19XSURUSCwKPiArCQlMUlVfR0VO X1dJRFRILAo+ICsJCUxSVV9SRUZTX1dJRFRILAo+ICAgCQlOUl9QQUdFRkxBR1MpOwo+ICAgCW1t aW5pdF9kcHJpbnRrKE1NSU5JVF9UUkFDRSwgInBhZ2VmbGFnc19sYXlvdXRfc2hpZnRzIiwKPiAg IAkJIlNlY3Rpb24gJWQgTm9kZSAlZCBab25lICVkIExhc3RjcHVwaWQgJWQgS2FzYW50YWcgJWRc biIsCj4gZGlmZiAtLWdpdCBhL21tL21tem9uZS5jIGIvbW0vbW16b25lLmMKPiBpbmRleCAwYWU3 NTcxZTM1YWIuLjY4ZTE1MTFiZTEyZCAxMDA2NDQKPiAtLS0gYS9tbS9tbXpvbmUuYwo+ICsrKyBi L21tL21tem9uZS5jCj4gQEAgLTg4LDYgKzg4LDggQEAgdm9pZCBscnV2ZWNfaW5pdChzdHJ1Y3Qg bHJ1dmVjICpscnV2ZWMpCj4gICAJICogUG9pc29uIGl0cyBsaXN0IGhlYWQsIHNvIHRoYXQgYW55 IG9wZXJhdGlvbnMgb24gaXQgd291bGQgY3Jhc2guCj4gICAJICovCj4gICAJbGlzdF9kZWwoJmxy dXZlYy0+bGlzdHNbTFJVX1VORVZJQ1RBQkxFXSk7Cj4gKwo+ICsJbHJ1X2dlbl9pbml0X2xydXZl YyhscnV2ZWMpOwo+ICAgfQo+ICAgCj4gICAjaWYgZGVmaW5lZChDT05GSUdfTlVNQV9CQUxBTkNJ TkcpICYmICFkZWZpbmVkKExBU1RfQ1BVUElEX05PVF9JTl9QQUdFX0ZMQUdTKQo+IGRpZmYgLS1n aXQgYS9tbS9zd2FwLmMgYi9tbS9zd2FwLmMKPiBpbmRleCA3ZTMyMGVjMDhjNmEuLmE2ODcwYmEw YmQ4MyAxMDA2NDQKPiAtLS0gYS9tbS9zd2FwLmMKPiArKysgYi9tbS9zd2FwLmMKPiBAQCAtNDYw LDYgKzQ2MCwxMSBAQCB2b2lkIGZvbGlvX2FkZF9scnUoc3RydWN0IGZvbGlvICpmb2xpbykKPiAg IAlWTV9CVUdfT05fRk9MSU8oZm9saW9fdGVzdF9hY3RpdmUoZm9saW8pICYmIGZvbGlvX3Rlc3Rf dW5ldmljdGFibGUoZm9saW8pLCBmb2xpbyk7Cj4gICAJVk1fQlVHX09OX0ZPTElPKGZvbGlvX3Rl c3RfbHJ1KGZvbGlvKSwgZm9saW8pOwo+ICAgCj4gKwkvKiBzZWUgdGhlIGNvbW1lbnQgaW4gbHJ1 X2dlbl9hZGRfZm9saW8oKSAqLwo+ICsJaWYgKGxydV9nZW5fZW5hYmxlZCgpICYmICFmb2xpb190 ZXN0X3VuZXZpY3RhYmxlKGZvbGlvKSAmJgo+ICsJICAgIGxydV9nZW5faW5fZmF1bHQoKSAmJiAh KGN1cnJlbnQtPmZsYWdzICYgUEZfTUVNQUxMT0MpKQo+ICsJCWZvbGlvX3NldF9hY3RpdmUoZm9s aW8pOwo+ICsKPiAgIAlmb2xpb19nZXQoZm9saW8pOwo+ICAgCWxvY2FsX2xvY2soJmxydV9wdmVj cy5sb2NrKTsKPiAgIAlwdmVjID0gdGhpc19jcHVfcHRyKCZscnVfcHZlY3MubHJ1X2FkZCk7Cj4g QEAgLTU1MSw3ICs1NTYsNyBAQCBzdGF0aWMgdm9pZCBscnVfZGVhY3RpdmF0ZV9maWxlX2ZuKHN0 cnVjdCBwYWdlICpwYWdlLCBzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMpCj4gICAKPiAgIHN0YXRpYyB2 b2lkIGxydV9kZWFjdGl2YXRlX2ZuKHN0cnVjdCBwYWdlICpwYWdlLCBzdHJ1Y3QgbHJ1dmVjICps cnV2ZWMpCj4gICB7Cj4gLQlpZiAoUGFnZUFjdGl2ZShwYWdlKSAmJiAhUGFnZVVuZXZpY3RhYmxl KHBhZ2UpKSB7Cj4gKwlpZiAoIVBhZ2VVbmV2aWN0YWJsZShwYWdlKSAmJiAoUGFnZUFjdGl2ZShw YWdlKSB8fCBscnVfZ2VuX2VuYWJsZWQoKSkpIHsKPiAgIAkJaW50IG5yX3BhZ2VzID0gdGhwX25y X3BhZ2VzKHBhZ2UpOwo+ICAgCj4gICAJCWRlbF9wYWdlX2Zyb21fbHJ1X2xpc3QocGFnZSwgbHJ1 dmVjKTsKPiBAQCAtNjY2LDcgKzY3MSw3IEBAIHZvaWQgZGVhY3RpdmF0ZV9maWxlX2ZvbGlvKHN0 cnVjdCBmb2xpbyAqZm9saW8pCj4gICAgKi8KPiAgIHZvaWQgZGVhY3RpdmF0ZV9wYWdlKHN0cnVj dCBwYWdlICpwYWdlKQo+ICAgewo+IC0JaWYgKFBhZ2VMUlUocGFnZSkgJiYgUGFnZUFjdGl2ZShw YWdlKSAmJiAhUGFnZVVuZXZpY3RhYmxlKHBhZ2UpKSB7Cj4gKwlpZiAoUGFnZUxSVShwYWdlKSAm JiAhUGFnZVVuZXZpY3RhYmxlKHBhZ2UpICYmIChQYWdlQWN0aXZlKHBhZ2UpIHx8IGxydV9nZW5f ZW5hYmxlZCgpKSkgewo+ICAgCQlzdHJ1Y3QgcGFnZXZlYyAqcHZlYzsKPiAgIAo+ICAgCQlsb2Nh bF9sb2NrKCZscnVfcHZlY3MubG9jayk7Cj4gZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0v dm1zY2FuLmMKPiBpbmRleCAyMjMyY2I1NWFmNDEuLmI0MWZmOTc2NWNjNyAxMDA2NDQKPiAtLS0g YS9tbS92bXNjYW4uYwo+ICsrKyBiL21tL3Ztc2Nhbi5jCj4gQEAgLTI5NjgsNiArMjk2OCw4MSBA QCBzdGF0aWMgYm9vbCBjYW5fYWdlX2Fub25fcGFnZXMoc3RydWN0IHBnbGlzdF9kYXRhICpwZ2Rh dCwKPiAgIAlyZXR1cm4gY2FuX2RlbW90ZShwZ2RhdC0+bm9kZV9pZCwgc2MpOwo+ICAgfQo+ICAg Cj4gKyNpZmRlZiBDT05GSUdfTFJVX0dFTgo+ICsKPiArLyoqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgo+ ICsgKiAgICAgICAgICAgICAgICAgICAgICAgICAgc2hvcnRoYW5kIGhlbHBlcnMKPiArICoqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKi8KPiArCj4gKyNkZWZpbmUgZm9yX2VhY2hfZ2VuX3R5cGVfem9uZShn ZW4sIHR5cGUsIHpvbmUpCQkJCVwKPiArCWZvciAoKGdlbikgPSAwOyAoZ2VuKSA8IE1BWF9OUl9H RU5TOyAoZ2VuKSsrKQkJCVwKPiArCQlmb3IgKCh0eXBlKSA9IDA7ICh0eXBlKSA8IEFOT05fQU5E X0ZJTEU7ICh0eXBlKSsrKQlcCj4gKwkJCWZvciAoKHpvbmUpID0gMDsgKHpvbmUpIDwgTUFYX05S X1pPTkVTOyAoem9uZSkrKykKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgbHJ1dmVjIF9fbWF5YmVfdW51 c2VkICpnZXRfbHJ1dmVjKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZywgaW50IG5pZCkKPiArewo+ ICsJc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCA9IE5PREVfREFUQShuaWQpOwo+ICsKPiArI2lm ZGVmIENPTkZJR19NRU1DRwo+ICsJaWYgKG1lbWNnKSB7Cj4gKwkJc3RydWN0IGxydXZlYyAqbHJ1 dmVjID0gJm1lbWNnLT5ub2RlaW5mb1tuaWRdLT5scnV2ZWM7Cj4gKwo+ICsJCS8qIGZvciBob3Rh ZGRfbmV3X3BnZGF0KCkgKi8KPiArCQlpZiAoIWxydXZlYy0+cGdkYXQpCj4gKwkJCWxydXZlYy0+ cGdkYXQgPSBwZ2RhdDsKPiArCj4gKwkJcmV0dXJuIGxydXZlYzsKPiArCX0KPiArI2VuZGlmCj4g KwlWTV9XQVJOX09OX09OQ0UoIW1lbV9jZ3JvdXBfZGlzYWJsZWQoKSk7Cj4gKwo+ICsJcmV0dXJu IHBnZGF0ID8gJnBnZGF0LT5fX2xydXZlYyA6IE5VTEw7Cj4gK30KPiArCj4gKy8qKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioKPiArICogICAgICAgICAgICAgICAgICAgICAgICAgIGluaXRpYWxpemF0aW9u Cj4gKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKiovCj4gKwo+ICt2b2lkIGxydV9nZW5faW5pdF9scnV2 ZWMoc3RydWN0IGxydXZlYyAqbHJ1dmVjKQo+ICt7Cj4gKwlpbnQgZ2VuLCB0eXBlLCB6b25lOwo+ ICsJc3RydWN0IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAmbHJ1dmVjLT5scnVnZW47Cj4gKwo+ ICsJbHJ1Z2VuLT5tYXhfc2VxID0gTUlOX05SX0dFTlMgKyAxOwo+ICsKPiArCWZvcl9lYWNoX2dl bl90eXBlX3pvbmUoZ2VuLCB0eXBlLCB6b25lKQo+ICsJCUlOSVRfTElTVF9IRUFEKCZscnVnZW4t Pmxpc3RzW2dlbl1bdHlwZV1bem9uZV0pOwo+ICt9Cj4gKwo+ICsjaWZkZWYgQ09ORklHX01FTUNH Cj4gK3ZvaWQgbHJ1X2dlbl9pbml0X21lbWNnKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKPiAr ewo+ICt9Cj4gKwo+ICt2b2lkIGxydV9nZW5fZXhpdF9tZW1jZyhzdHJ1Y3QgbWVtX2Nncm91cCAq bWVtY2cpCj4gK3sKPiArCWludCBuaWQ7Cj4gKwo+ICsJZm9yX2VhY2hfbm9kZShuaWQpIHsKPiAr CQlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMgPSBnZXRfbHJ1dmVjKG1lbWNnLCBuaWQpOwo+ICsKPiAr CQlWTV9XQVJOX09OX09OQ0UobWVtY2hyX2ludihscnV2ZWMtPmxydWdlbi5ucl9wYWdlcywgMCwK PiArCQkJCQkgICBzaXplb2YobHJ1dmVjLT5scnVnZW4ubnJfcGFnZXMpKSk7Cj4gKwl9Cj4gK30K PiArI2VuZGlmCj4gKwo+ICtzdGF0aWMgaW50IF9faW5pdCBpbml0X2xydV9nZW4odm9pZCkKPiAr ewo+ICsJQlVJTERfQlVHX09OKE1JTl9OUl9HRU5TICsgMSA+PSBNQVhfTlJfR0VOUyk7Cj4gKwlC VUlMRF9CVUdfT04oQklUKExSVV9HRU5fV0lEVEgpIDw9IE1BWF9OUl9HRU5TKTsKPiArCj4gKwly ZXR1cm4gMDsKPiArfTsKPiArbGF0ZV9pbml0Y2FsbChpbml0X2xydV9nZW4pOwo+ICsKPiArI2Vu ZGlmIC8qIENPTkZJR19MUlVfR0VOICovCj4gKwo+ICAgc3RhdGljIHZvaWQgc2hyaW5rX2xydXZl YyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjKQo+ICAgewo+ ICAgCXVuc2lnbmVkIGxvbmcgbnJbTlJfTFJVX0xJU1RTXTsKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0 CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK