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 CC9F8C433EF for ; Fri, 29 Apr 2022 14:10:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1345701AbiD2OOI (ORCPT ); Fri, 29 Apr 2022 10:14:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:41598 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S238151AbiD2OOC (ORCPT ); Fri, 29 Apr 2022 10:14:02 -0400 Received: from out30-45.freemail.mail.aliyun.com (out30-45.freemail.mail.aliyun.com [115.124.30.45]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 215021A836; Fri, 29 Apr 2022 07:10:38 -0700 (PDT) X-Alimail-AntiSpam: AC=PASS;BC=-1|-1;BR=01201311R151e4;CH=green;DM=||false|;DS=||;FP=0|-1|-1|-1|0|-1|-1|-1;HT=e01e04400;MF=zhongjiang-ali@linux.alibaba.com;NM=1;PH=DS;RN=41;SR=0;TI=SMTPD_---0VBi52YN_1651241427; Received: from 30.225.24.120(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0VBi52YN_1651241427) by smtp.aliyun-inc.com(127.0.0.1); Fri, 29 Apr 2022 22:10:29 +0800 Message-ID: Date: Fri, 29 Apr 2022 22:10:27 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:100.0) Gecko/20100101 Thunderbird/100.0 Subject: Re: [PATCH v10 08/14] mm: multi-gen LRU: support page table walks Content-Language: en-US To: Yu Zhao , Stephen Rothwell , linux-mm@kvack.org Cc: Andi Kleen , Andrew Morton , Aneesh Kumar , Barry Song <21cnbao@gmail.com>, Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, page-reclaim@google.com, x86@kernel.org, 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: <20220407031525.2368067-1-yuzhao@google.com> <20220407031525.2368067-9-yuzhao@google.com> From: zhong jiang In-Reply-To: <20220407031525.2368067-9-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/4/7 11:15 上午, Yu Zhao wrote: > To further exploit spatial locality, the aging prefers to walk page > tables to search for young PTEs and promote hot pages. A kill switch > will be added in the next patch to disable this behavior. When > disabled, the aging relies on the rmap only. > > NB: this behavior has nothing similar with the page table scanning in > the 2.4 kernel [1], which searches page tables for old PTEs, adds cold > pages to swapcache and unmaps them. > > To avoid confusion, the term "iteration" specifically means the > traversal of an entire mm_struct list; the term "walk" will be applied > to page tables and the rmap, as usual. > > An mm_struct list is maintained for each memcg, and an mm_struct > follows its owner task to the new memcg when this task is migrated. > Given an lruvec, the aging iterates lruvec_memcg()->mm_list and calls > walk_page_range() with each mm_struct on this list to promote hot > pages before it increments max_seq. > > When multiple page table walkers iterate the same list, each of them > gets a unique mm_struct; therefore they can run concurrently. Page > table walkers ignore any misplaced pages, e.g., if an mm_struct was > migrated, pages it left in the previous memcg will not be promoted > when its current memcg is under reclaim. Similarly, page table walkers > will not promote pages from nodes other than the one under reclaim. > > This patch uses the following optimizations when walking page tables: > 1. It tracks the usage of mm_struct's between context switches so that > page table walkers can skip processes that have been sleeping since > the last iteration. > 2. It uses generational Bloom filters to record populated branches so > that page table walkers can reduce their search space based on the > query results, e.g., to skip page tables containing mostly holes or > misplaced pages. > 3. It takes advantage of the accessed bit in non-leaf PMD entries when > CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG=y. > 4. It does not zigzag between a PGD table and the same PMD table > spanning multiple VMAs. IOW, it finishes all the VMAs within the > range of the same PMD table before it returns to a PGD table. This > improves the cache performance for workloads that have large > numbers of tiny VMAs [2], especially when CONFIG_PGTABLE_LEVELS=5. > > Server benchmark results: > Single workload: > fio (buffered I/O): no change > > Single workload: > memcached (anon): +[8, 10]% > Ops/sec KB/sec > patch1-7: 1193918.93 46438.15 > patch1-8: 1301954.44 50640.27 > > Configurations: > no change > > Client benchmark results: > kswapd profiles: > patch1-7 > 45.90% lzo1x_1_do_compress (real work) > 9.14% page_vma_mapped_walk > 6.81% _raw_spin_unlock_irq > 2.80% ptep_clear_flush > 2.34% __zram_bvec_write > 2.29% do_raw_spin_lock > 1.84% lru_gen_look_around > 1.78% memmove > 1.74% obj_malloc > 1.50% free_unref_page_list > > patch1-8 > 46.96% lzo1x_1_do_compress (real work) > 7.55% page_vma_mapped_walk > 5.89% _raw_spin_unlock_irq > 3.33% walk_pte_range > 2.65% ptep_clear_flush > 2.23% __zram_bvec_write > 2.08% do_raw_spin_lock > 1.83% memmove > 1.65% obj_malloc > 1.47% free_unref_page_list > > Configurations: > no change > > [1] https://lwn.net/Articles/23732/ > [2] https://source.android.com/devices/tech/debug/scudo > > 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/exec.c | 2 + > include/linux/memcontrol.h | 5 + > include/linux/mm_types.h | 78 +++ > include/linux/mmzone.h | 59 +++ > include/linux/swap.h | 4 + > kernel/exit.c | 1 + > kernel/fork.c | 9 + > kernel/sched/core.c | 1 + > mm/memcontrol.c | 24 + > mm/vmscan.c | 975 ++++++++++++++++++++++++++++++++++++- > 10 files changed, 1144 insertions(+), 14 deletions(-) > > diff --git a/fs/exec.c b/fs/exec.c > index e3e55d5e0be1..bba8fc44926f 100644 > --- a/fs/exec.c > +++ b/fs/exec.c > @@ -1011,6 +1011,7 @@ static int exec_mmap(struct mm_struct *mm) > active_mm = tsk->active_mm; > tsk->active_mm = mm; > tsk->mm = mm; > + lru_gen_add_mm(mm); > /* > * This prevents preemption while active_mm is being loaded and > * it and mm are being updated, which could cause problems for > @@ -1023,6 +1024,7 @@ static int exec_mmap(struct mm_struct *mm) > activate_mm(active_mm, mm); > if (IS_ENABLED(CONFIG_ARCH_WANT_IRQS_OFF_ACTIVATE_MM)) > local_irq_enable(); > + lru_gen_use_mm(mm); > tsk->mm->vmacache_seqnum = 0; > vmacache_flush(tsk); > task_unlock(tsk); > diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h > index 463168fa1670..954c54652736 100644 > --- a/include/linux/memcontrol.h > +++ b/include/linux/memcontrol.h > @@ -344,6 +344,11 @@ struct mem_cgroup { > struct deferred_split deferred_split_queue; > #endif > > +#ifdef CONFIG_LRU_GEN > + /* per-memcg mm_struct list */ > + struct lru_gen_mm_list mm_list; > +#endif > + > struct mem_cgroup_per_node *nodeinfo[]; > }; > > diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h > index 8834e38c06a4..eee29f700fab 100644 > --- a/include/linux/mm_types.h > +++ b/include/linux/mm_types.h > @@ -3,6 +3,7 @@ > #define _LINUX_MM_TYPES_H > > #include > +#include > > #include > #include > @@ -17,6 +18,8 @@ > #include > #include > #include > +#include > +#include > > #include > > @@ -655,6 +658,22 @@ struct mm_struct { > #ifdef CONFIG_IOMMU_SVA > u32 pasid; > #endif > +#ifdef CONFIG_LRU_GEN > + struct { > + /* this mm_struct is on lru_gen_mm_list */ > + struct list_head list; > +#ifdef CONFIG_MEMCG > + /* points to the memcg of "owner" above */ > + struct mem_cgroup *memcg; > +#endif > + /* > + * Set when switching to this mm_struct, as a hint of > + * whether it has been used since the last time per-node > + * page table walkers cleared the corresponding bits. > + */ > + nodemask_t nodes; > + } lru_gen; > +#endif /* CONFIG_LRU_GEN */ > } __randomize_layout; > > /* > @@ -681,6 +700,65 @@ static inline cpumask_t *mm_cpumask(struct mm_struct *mm) > return (struct cpumask *)&mm->cpu_bitmap; > } > > +#ifdef CONFIG_LRU_GEN > + > +struct lru_gen_mm_list { > + /* mm_struct list for page table walkers */ > + struct list_head fifo; > + /* protects the list above */ > + spinlock_t lock; > +}; > + > +void lru_gen_add_mm(struct mm_struct *mm); > +void lru_gen_del_mm(struct mm_struct *mm); > +#ifdef CONFIG_MEMCG > +void lru_gen_migrate_mm(struct mm_struct *mm); > +#endif > + > +static inline void lru_gen_init_mm(struct mm_struct *mm) > +{ > + INIT_LIST_HEAD(&mm->lru_gen.list); > +#ifdef CONFIG_MEMCG > + mm->lru_gen.memcg = NULL; > +#endif > + nodes_clear(mm->lru_gen.nodes); > +} > + > +static inline void lru_gen_use_mm(struct mm_struct *mm) > +{ > + /* unlikely but not a bug when racing with lru_gen_migrate_mm() */ > + VM_WARN_ON(list_empty(&mm->lru_gen.list)); > + > + if (!(current->flags & PF_KTHREAD) && !nodes_full(mm->lru_gen.nodes)) > + nodes_setall(mm->lru_gen.nodes); > +} > + > +#else /* !CONFIG_LRU_GEN */ > + > +static inline void lru_gen_add_mm(struct mm_struct *mm) > +{ > +} > + > +static inline void lru_gen_del_mm(struct mm_struct *mm) > +{ > +} > + > +#ifdef CONFIG_MEMCG > +static inline void lru_gen_migrate_mm(struct mm_struct *mm) > +{ > +} > +#endif > + > +static inline void lru_gen_init_mm(struct mm_struct *mm) > +{ > +} > + > +static inline void lru_gen_use_mm(struct mm_struct *mm) > +{ > +} > + > +#endif /* CONFIG_LRU_GEN */ > + > struct mmu_gather; > extern void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm); > extern void tlb_gather_mmu_fullmm(struct mmu_gather *tlb, struct mm_struct *mm); > diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h > index c69589ad2b05..a1a99971ff9c 100644 > --- a/include/linux/mmzone.h > +++ b/include/linux/mmzone.h > @@ -424,6 +424,58 @@ struct lru_gen_struct { > atomic_long_t refaulted[NR_HIST_GENS][ANON_AND_FILE][MAX_NR_TIERS]; > }; > > +enum { > + MM_PTE_TOTAL, /* total leaf entries */ > + MM_PTE_OLD, /* old leaf entries */ > + MM_PTE_YOUNG, /* young leaf entries */ > + MM_PMD_TOTAL, /* total non-leaf entries */ > + MM_PMD_FOUND, /* non-leaf entries found in Bloom filters */ > + MM_PMD_ADDED, /* non-leaf entries added to Bloom filters */ > + NR_MM_STATS > +}; > + > +/* mnemonic codes for the mm stats above */ > +#define MM_STAT_CODES "toydfa" > + > +/* double-buffering Bloom filters */ > +#define NR_BLOOM_FILTERS 2 > + > +struct lru_gen_mm_state { > + /* set to max_seq after each iteration */ > + unsigned long seq; > + /* where the current iteration starts (inclusive) */ > + struct list_head *head; > + /* where the last iteration ends (exclusive) */ > + struct list_head *tail; > + /* to wait for the last page table walker to finish */ > + struct wait_queue_head wait; > + /* Bloom filters flip after each iteration */ > + unsigned long *filters[NR_BLOOM_FILTERS]; > + /* the mm stats for debugging */ > + unsigned long stats[NR_HIST_GENS][NR_MM_STATS]; > + /* the number of concurrent page table walkers */ > + int nr_walkers; > +}; > + > +struct lru_gen_mm_walk { > + /* the lruvec under reclaim */ > + struct lruvec *lruvec; > + /* unstable max_seq from lru_gen_struct */ > + unsigned long max_seq; > + /* the next address within an mm to scan */ > + unsigned long next_addr; > + /* to batch page table entries */ > + unsigned long bitmap[BITS_TO_LONGS(MIN_LRU_BATCH)]; > + /* to batch promoted pages */ > + int nr_pages[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_ZONES]; > + /* to batch the mm stats */ > + int mm_stats[NR_MM_STATS]; > + /* total batched items */ > + int batched; > + bool can_swap; > + bool full_scan; > +}; > + > void lru_gen_init_lruvec(struct lruvec *lruvec); > void lru_gen_look_around(struct page_vma_mapped_walk *pvmw); > > @@ -474,6 +526,8 @@ struct lruvec { > #ifdef CONFIG_LRU_GEN > /* evictable pages divided into generations */ > struct lru_gen_struct lrugen; > + /* to concurrently iterate lru_gen_mm_list */ > + struct lru_gen_mm_state mm_state; > #endif > #ifdef CONFIG_MEMCG > struct pglist_data *pgdat; > @@ -1067,6 +1121,11 @@ typedef struct pglist_data { > > unsigned long flags; > > +#ifdef CONFIG_LRU_GEN > + /* kswap mm walk data */ > + struct lru_gen_mm_walk mm_walk; > +#endif > + > ZONE_PADDING(_pad2_) > > /* Per-node vmstats */ > diff --git a/include/linux/swap.h b/include/linux/swap.h > index 27093b477c5f..7bdd7bcb135d 100644 > --- a/include/linux/swap.h > +++ b/include/linux/swap.h > @@ -137,6 +137,10 @@ union swap_header { > */ > struct reclaim_state { > unsigned long reclaimed_slab; > +#ifdef CONFIG_LRU_GEN > + /* per-thread mm walk data */ > + struct lru_gen_mm_walk *mm_walk; > +#endif > }; > > #ifdef __KERNEL__ > diff --git a/kernel/exit.c b/kernel/exit.c > index f072959fcab7..f2d4d48ea790 100644 > --- a/kernel/exit.c > +++ b/kernel/exit.c > @@ -466,6 +466,7 @@ void mm_update_next_owner(struct mm_struct *mm) > goto retry; > } > WRITE_ONCE(mm->owner, c); > + lru_gen_migrate_mm(mm); > task_unlock(c); > put_task_struct(c); > } > diff --git a/kernel/fork.c b/kernel/fork.c > index 9796897560ab..d14297ce1151 100644 > --- a/kernel/fork.c > +++ b/kernel/fork.c > @@ -1148,6 +1148,7 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p, > goto fail_nocontext; > > mm->user_ns = get_user_ns(user_ns); > + lru_gen_init_mm(mm); > return mm; > > fail_nocontext: > @@ -1191,6 +1192,7 @@ static inline void __mmput(struct mm_struct *mm) > if (mm->binfmt) > module_put(mm->binfmt->module); > mm_pasid_drop(mm); > + lru_gen_del_mm(mm); > mmdrop(mm); > } > > @@ -2660,6 +2662,13 @@ pid_t kernel_clone(struct kernel_clone_args *args) > get_task_struct(p); > } > > + if (IS_ENABLED(CONFIG_LRU_GEN) && !(clone_flags & CLONE_VM)) { > + /* lock the task to synchronize with memcg migration */ > + task_lock(p); > + lru_gen_add_mm(p->mm); > + task_unlock(p); > + } > + > wake_up_new_task(p); > > /* forking complete and child started to run, tell ptracer */ > diff --git a/kernel/sched/core.c b/kernel/sched/core.c > index d575b4914925..88193a0f6d2b 100644 > --- a/kernel/sched/core.c > +++ b/kernel/sched/core.c > @@ -5057,6 +5057,7 @@ context_switch(struct rq *rq, struct task_struct *prev, > * finish_task_switch()'s mmdrop(). > */ > switch_mm_irqs_off(prev->active_mm, next->mm, next); > + lru_gen_use_mm(next->mm); > > if (!prev->mm) { // from kernel > /* will mmdrop() in finish_task_switch(). */ > diff --git a/mm/memcontrol.c b/mm/memcontrol.c > index 8069b58f2422..6a76152614c5 100644 > --- a/mm/memcontrol.c > +++ b/mm/memcontrol.c > @@ -6083,6 +6083,29 @@ static void mem_cgroup_move_task(void) > } > #endif > > +#ifdef CONFIG_LRU_GEN > +static void mem_cgroup_attach(struct cgroup_taskset *tset) > +{ > + struct cgroup_subsys_state *css; > + struct task_struct *task = NULL; > + > + cgroup_taskset_for_each_leader(task, css, tset) > + break; > + > + if (!task) > + return; > + > + task_lock(task); > + if (task->mm && task->mm->owner == task) > + lru_gen_migrate_mm(task->mm); > + task_unlock(task); > +} > +#else > +static void mem_cgroup_attach(struct cgroup_taskset *tset) > +{ > +} > +#endif /* CONFIG_LRU_GEN */ > + > static int seq_puts_memcg_tunable(struct seq_file *m, unsigned long value) > { > if (value == PAGE_COUNTER_MAX) > @@ -6428,6 +6451,7 @@ struct cgroup_subsys memory_cgrp_subsys = { > .css_reset = mem_cgroup_css_reset, > .css_rstat_flush = mem_cgroup_css_rstat_flush, > .can_attach = mem_cgroup_can_attach, > + .attach = mem_cgroup_attach, > .cancel_attach = mem_cgroup_cancel_attach, > .post_attach = mem_cgroup_move_task, > .dfl_cftypes = memory_files, > diff --git a/mm/vmscan.c b/mm/vmscan.c > index f4dd3c3c589b..9e2810a230a4 100644 > --- a/mm/vmscan.c > +++ b/mm/vmscan.c > @@ -50,6 +50,8 @@ > #include > #include > #include > +#include > +#include > > #include > #include > @@ -3016,7 +3018,7 @@ static int folio_lru_tier(struct folio *folio) > return lru_tier_from_refs(refs); > } > > -static struct lruvec __maybe_unused *get_lruvec(struct mem_cgroup *memcg, int nid) > +static struct lruvec *get_lruvec(struct mem_cgroup *memcg, int nid) > { > struct pglist_data *pgdat = NODE_DATA(nid); > > @@ -3061,6 +3063,374 @@ static bool __maybe_unused seq_is_valid(struct lruvec *lruvec) > get_nr_gens(lruvec, LRU_GEN_ANON) <= MAX_NR_GENS; > } > > +/****************************************************************************** > + * mm_struct list > + ******************************************************************************/ > + > +static struct lru_gen_mm_list *get_mm_list(struct mem_cgroup *memcg) > +{ > + static struct lru_gen_mm_list mm_list = { > + .fifo = LIST_HEAD_INIT(mm_list.fifo), > + .lock = __SPIN_LOCK_UNLOCKED(mm_list.lock), > + }; > + > +#ifdef CONFIG_MEMCG > + if (memcg) > + return &memcg->mm_list; > +#endif > + VM_BUG_ON(!mem_cgroup_disabled()); > + > + return &mm_list; > +} > + > +void lru_gen_add_mm(struct mm_struct *mm) > +{ > + int nid; > + struct mem_cgroup *memcg = get_mem_cgroup_from_mm(mm); > + struct lru_gen_mm_list *mm_list = get_mm_list(memcg); > + > + VM_BUG_ON_MM(!list_empty(&mm->lru_gen.list), mm); > +#ifdef CONFIG_MEMCG > + VM_BUG_ON_MM(mm->lru_gen.memcg, mm); > + mm->lru_gen.memcg = memcg; > +#endif > + spin_lock(&mm_list->lock); > + > + for_each_node_state(nid, N_MEMORY) { > + struct lruvec *lruvec = get_lruvec(memcg, nid); > + > + if (!lruvec) > + continue; > + > + if (lruvec->mm_state.tail == &mm_list->fifo) > + lruvec->mm_state.tail = &mm->lru_gen.list; > + } > + > + list_add_tail(&mm->lru_gen.list, &mm_list->fifo); > + > + spin_unlock(&mm_list->lock); > +} > + > +void lru_gen_del_mm(struct mm_struct *mm) > +{ > + int nid; > + struct lru_gen_mm_list *mm_list; > + struct mem_cgroup *memcg = NULL; > + > + if (list_empty(&mm->lru_gen.list)) > + return; > + > +#ifdef CONFIG_MEMCG > + memcg = mm->lru_gen.memcg; > +#endif > + mm_list = get_mm_list(memcg); > + > + spin_lock(&mm_list->lock); > + > + for_each_node(nid) { > + struct lruvec *lruvec = get_lruvec(memcg, nid); > + > + if (!lruvec) > + continue; > + > + if (lruvec->mm_state.tail == &mm->lru_gen.list) > + lruvec->mm_state.tail = lruvec->mm_state.tail->next; > + > + if (lruvec->mm_state.head != &mm->lru_gen.list) > + continue; > + > + lruvec->mm_state.head = lruvec->mm_state.head->next; > + if (lruvec->mm_state.head == &mm_list->fifo) > + WRITE_ONCE(lruvec->mm_state.seq, lruvec->mm_state.seq + 1); > + } > + > + list_del_init(&mm->lru_gen.list); > + > + spin_unlock(&mm_list->lock); > + > +#ifdef CONFIG_MEMCG > + mem_cgroup_put(mm->lru_gen.memcg); > + mm->lru_gen.memcg = NULL; > +#endif > +} > + > +#ifdef CONFIG_MEMCG > +void lru_gen_migrate_mm(struct mm_struct *mm) > +{ > + struct mem_cgroup *memcg; > + > + lockdep_assert_held(&mm->owner->alloc_lock); > + > + /* for mm_update_next_owner() */ > + if (mem_cgroup_disabled()) > + return; > + > + rcu_read_lock(); > + memcg = mem_cgroup_from_task(mm->owner); > + rcu_read_unlock(); > + if (memcg == mm->lru_gen.memcg) > + return; > + > + VM_BUG_ON_MM(!mm->lru_gen.memcg, mm); > + VM_BUG_ON_MM(list_empty(&mm->lru_gen.list), mm); > + > + lru_gen_del_mm(mm); > + lru_gen_add_mm(mm); > +} > +#endif > + > +/* > + * Bloom filters with m=1<<15, k=2 and the false positive rates of ~1/5 when > + * n=10,000 and ~1/2 when n=20,000, where, conventionally, m is the number of > + * bits in a bitmap, k is the number of hash functions and n is the number of > + * inserted items. > + * > + * Page table walkers use one of the two filters to reduce their search space. > + * To get rid of non-leaf entries that no longer have enough leaf entries, the > + * aging uses the double-buffering technique to flip to the other filter each > + * time it produces a new generation. For non-leaf entries that have enough > + * leaf entries, the aging carries them over to the next generation in > + * walk_pmd_range(); the eviction also report them when walking the rmap > + * in lru_gen_look_around(). > + * > + * For future optimizations: > + * 1. It's not necessary to keep both filters all the time. The spare one can be > + * freed after the RCU grace period and reallocated if needed again. > + * 2. And when reallocating, it's worth scaling its size according to the number > + * of inserted entries in the other filter, to reduce the memory overhead on > + * small systems and false positives on large systems. > + * 3. Jenkins' hash function is an alternative to Knuth's. > + */ > +#define BLOOM_FILTER_SHIFT 15 > + > +static inline int filter_gen_from_seq(unsigned long seq) > +{ > + return seq % NR_BLOOM_FILTERS; > +} > + > +static void get_item_key(void *item, int *key) > +{ > + u32 hash = hash_ptr(item, BLOOM_FILTER_SHIFT * 2); > + > + BUILD_BUG_ON(BLOOM_FILTER_SHIFT * 2 > BITS_PER_TYPE(u32)); > + > + key[0] = hash & (BIT(BLOOM_FILTER_SHIFT) - 1); > + key[1] = hash >> BLOOM_FILTER_SHIFT; > +} > + > +static void reset_bloom_filter(struct lruvec *lruvec, unsigned long seq) > +{ > + unsigned long *filter; > + int gen = filter_gen_from_seq(seq); > + > + lockdep_assert_held(&get_mm_list(lruvec_memcg(lruvec))->lock); > + > + filter = lruvec->mm_state.filters[gen]; > + if (filter) { > + bitmap_clear(filter, 0, BIT(BLOOM_FILTER_SHIFT)); > + return; > + } > + > + filter = bitmap_zalloc(BIT(BLOOM_FILTER_SHIFT), GFP_ATOMIC); > + WRITE_ONCE(lruvec->mm_state.filters[gen], filter); > +} > + > +static void update_bloom_filter(struct lruvec *lruvec, unsigned long seq, void *item) > +{ > + int key[2]; > + unsigned long *filter; > + int gen = filter_gen_from_seq(seq); > + > + filter = READ_ONCE(lruvec->mm_state.filters[gen]); > + if (!filter) > + return; > + > + get_item_key(item, key); > + > + if (!test_bit(key[0], filter)) > + set_bit(key[0], filter); > + if (!test_bit(key[1], filter)) > + set_bit(key[1], filter); > +} > + > +static bool test_bloom_filter(struct lruvec *lruvec, unsigned long seq, void *item) > +{ > + int key[2]; > + unsigned long *filter; > + int gen = filter_gen_from_seq(seq); > + > + filter = READ_ONCE(lruvec->mm_state.filters[gen]); > + if (!filter) > + return true; > + > + get_item_key(item, key); > + > + return test_bit(key[0], filter) && test_bit(key[1], filter); > +} > + > +static void reset_mm_stats(struct lruvec *lruvec, struct lru_gen_mm_walk *walk, bool last) > +{ > + int i; > + int hist; > + > + lockdep_assert_held(&get_mm_list(lruvec_memcg(lruvec))->lock); > + > + if (walk) { > + hist = lru_hist_from_seq(walk->max_seq); > + > + for (i = 0; i < NR_MM_STATS; i++) { > + WRITE_ONCE(lruvec->mm_state.stats[hist][i], > + lruvec->mm_state.stats[hist][i] + walk->mm_stats[i]); > + walk->mm_stats[i] = 0; > + } > + } > + > + if (NR_HIST_GENS > 1 && last) { > + hist = lru_hist_from_seq(lruvec->mm_state.seq + 1); > + > + for (i = 0; i < NR_MM_STATS; i++) > + WRITE_ONCE(lruvec->mm_state.stats[hist][i], 0); > + } > +} > + > +static bool should_skip_mm(struct mm_struct *mm, struct lru_gen_mm_walk *walk) > +{ > + int type; > + unsigned long size = 0; > + struct pglist_data *pgdat = lruvec_pgdat(walk->lruvec); > + > + if (!walk->full_scan && cpumask_empty(mm_cpumask(mm)) && > + !node_isset(pgdat->node_id, mm->lru_gen.nodes)) > + return true; > + > + node_clear(pgdat->node_id, mm->lru_gen.nodes); > + > + for (type = !walk->can_swap; type < ANON_AND_FILE; type++) { > + size += type ? get_mm_counter(mm, MM_FILEPAGES) : > + get_mm_counter(mm, MM_ANONPAGES) + > + get_mm_counter(mm, MM_SHMEMPAGES); > + } > + > + if (size < MIN_LRU_BATCH) > + return true; > + > + if (mm_is_oom_victim(mm)) > + return true; > + > + return !mmget_not_zero(mm); > +} > + > +static bool iterate_mm_list(struct lruvec *lruvec, struct lru_gen_mm_walk *walk, > + struct mm_struct **iter) > +{ > + bool first = false; > + bool last = true; > + struct mm_struct *mm = NULL; > + struct mem_cgroup *memcg = lruvec_memcg(lruvec); > + struct lru_gen_mm_list *mm_list = get_mm_list(memcg); > + struct lru_gen_mm_state *mm_state = &lruvec->mm_state; > + > + /* > + * There are four interesting cases for this page table walker: > + * 1. It tries to start a new iteration of mm_list with a stale max_seq; > + * there is nothing to be done. > + * 2. It's the first of the current generation, and it needs to reset > + * the Bloom filter for the next generation. > + * 3. It reaches the end of mm_list, and it needs to increment > + * mm_state->seq; the iteration is done. > + * 4. It's the last of the current generation, and it needs to reset the > + * mm stats counters for the next generation. > + */ > + if (*iter) > + mmput_async(*iter); > + else if (walk->max_seq <= READ_ONCE(mm_state->seq)) > + return false; > + > + spin_lock(&mm_list->lock); > + > + VM_BUG_ON(mm_state->seq + 1 < walk->max_seq); > + VM_BUG_ON(*iter && mm_state->seq > walk->max_seq); > + VM_BUG_ON(*iter && !mm_state->nr_walkers); > + > + if (walk->max_seq <= mm_state->seq) { > + if (!*iter) > + last = false; > + goto done; > + } > + > + if (!mm_state->nr_walkers) { > + VM_BUG_ON(mm_state->head && mm_state->head != &mm_list->fifo); > + > + mm_state->head = mm_list->fifo.next; > + first = true; > + } > + > + while (!mm && mm_state->head != &mm_list->fifo) { > + mm = list_entry(mm_state->head, struct mm_struct, lru_gen.list); > + > + mm_state->head = mm_state->head->next; > + > + /* full scan for those added after the last iteration */ > + if (!mm_state->tail || mm_state->tail == &mm->lru_gen.list) { > + mm_state->tail = mm_state->head; > + walk->full_scan = true; > + } > + The full_scan seems to be alway true.   because mm_state->tail points to the first item in mm_list,  hence the walker's condition mm_state->tail == &mm->lru_gen.list alway equal.  Am I missing something? Thanks, > + if (should_skip_mm(mm, walk)) > + mm = NULL; > + } > + > + if (mm_state->head == &mm_list->fifo) > + WRITE_ONCE(mm_state->seq, mm_state->seq + 1); > +done: > + if (*iter && !mm) > + mm_state->nr_walkers--; > + if (!*iter && mm) > + mm_state->nr_walkers++; > + > + if (mm_state->nr_walkers) > + last = false; > + > + if (mm && first) > + reset_bloom_filter(lruvec, walk->max_seq + 1); > + > + if (*iter || last) > + reset_mm_stats(lruvec, walk, last); > + > + spin_unlock(&mm_list->lock); > + > + *iter = mm; > + > + return last; > +} > + > +static bool iterate_mm_list_nowalk(struct lruvec *lruvec, unsigned long max_seq) > +{ > + bool success = false; > + struct mem_cgroup *memcg = lruvec_memcg(lruvec); > + struct lru_gen_mm_list *mm_list = get_mm_list(memcg); > + struct lru_gen_mm_state *mm_state = &lruvec->mm_state; > + > + if (max_seq <= READ_ONCE(mm_state->seq)) > + return false; > + > + spin_lock(&mm_list->lock); > + > + VM_BUG_ON(mm_state->seq + 1 < max_seq); > + > + if (max_seq > mm_state->seq && !mm_state->nr_walkers) { > + VM_BUG_ON(mm_state->head && mm_state->head != &mm_list->fifo); > + > + WRITE_ONCE(mm_state->seq, mm_state->seq + 1); > + reset_mm_stats(lruvec, NULL, true); > + success = true; > + } > + > + spin_unlock(&mm_list->lock); > + > + return success; > +} > + > /****************************************************************************** > * refault feedback loop > ******************************************************************************/ > @@ -3214,6 +3584,476 @@ static int folio_inc_gen(struct lruvec *lruvec, struct folio *folio, bool reclai > return new_gen; > } > > +static void update_batch_size(struct lru_gen_mm_walk *walk, 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); > + > + VM_BUG_ON(old_gen >= MAX_NR_GENS); > + VM_BUG_ON(new_gen >= MAX_NR_GENS); > + > + walk->batched++; > + > + walk->nr_pages[old_gen][type][zone] -= delta; > + walk->nr_pages[new_gen][type][zone] += delta; > +} > + > +static void reset_batch_size(struct lruvec *lruvec, struct lru_gen_mm_walk *walk) > +{ > + int gen, type, zone; > + struct lru_gen_struct *lrugen = &lruvec->lrugen; > + > + walk->batched = 0; > + > + for_each_gen_type_zone(gen, type, zone) { > + enum lru_list lru = type * LRU_INACTIVE_FILE; > + int delta = walk->nr_pages[gen][type][zone]; > + > + if (!delta) > + continue; > + > + walk->nr_pages[gen][type][zone] = 0; > + WRITE_ONCE(lrugen->nr_pages[gen][type][zone], > + lrugen->nr_pages[gen][type][zone] + delta); > + > + if (lru_gen_is_active(lruvec, gen)) > + lru += LRU_ACTIVE; > + __update_lru_size(lruvec, lru, zone, delta); > + } > +} > + > +static int should_skip_vma(unsigned long start, unsigned long end, struct mm_walk *walk) > +{ > + struct address_space *mapping; > + struct vm_area_struct *vma = walk->vma; > + struct lru_gen_mm_walk *priv = walk->private; > + > + if (!vma_is_accessible(vma) || is_vm_hugetlb_page(vma) || > + (vma->vm_flags & (VM_LOCKED | VM_SPECIAL | VM_SEQ_READ | VM_RAND_READ)) || > + vma == get_gate_vma(vma->vm_mm)) > + return true; > + > + if (vma_is_anonymous(vma)) > + return !priv->can_swap; > + > + if (WARN_ON_ONCE(!vma->vm_file || !vma->vm_file->f_mapping)) > + return true; > + > + mapping = vma->vm_file->f_mapping; > + if (mapping_unevictable(mapping)) > + return true; > + > + /* check readpage to exclude special mappings like dax, etc. */ > + return shmem_mapping(mapping) ? !priv->can_swap : !mapping->a_ops->readpage; > +} > + > +/* > + * Some userspace memory allocators map many single-page VMAs. Instead of > + * returning back to the PGD table for each of such VMAs, finish an entire PMD > + * table to reduce zigzags and improve cache performance. > + */ > +static bool get_next_vma(struct mm_walk *walk, unsigned long mask, unsigned long size, > + unsigned long *start, unsigned long *end) > +{ > + unsigned long next = round_up(*end, size); > + > + VM_BUG_ON(mask & size); > + VM_BUG_ON(*start >= *end); > + VM_BUG_ON((next & mask) != (*start & mask)); > + > + while (walk->vma) { > + if (next >= walk->vma->vm_end) { > + walk->vma = walk->vma->vm_next; > + continue; > + } > + > + if ((next & mask) != (walk->vma->vm_start & mask)) > + return false; > + > + if (should_skip_vma(walk->vma->vm_start, walk->vma->vm_end, walk)) { > + walk->vma = walk->vma->vm_next; > + continue; > + } > + > + *start = max(next, walk->vma->vm_start); > + next = (next | ~mask) + 1; > + /* rounded-up boundaries can wrap to 0 */ > + *end = next && next < walk->vma->vm_end ? next : walk->vma->vm_end; > + > + return true; > + } > + > + return false; > +} > + > +static bool suitable_to_scan(int total, int young) > +{ > + int n = clamp_t(int, cache_line_size() / sizeof(pte_t), 2, 8); > + > + /* suitable if the average number of young PTEs per cacheline is >=1 */ > + return young * n >= total; > +} > + > +static bool walk_pte_range(pmd_t *pmd, unsigned long start, unsigned long end, > + struct mm_walk *walk) > +{ > + int i; > + pte_t *pte; > + spinlock_t *ptl; > + unsigned long addr; > + int total = 0; > + int young = 0; > + struct lru_gen_mm_walk *priv = walk->private; > + struct mem_cgroup *memcg = lruvec_memcg(priv->lruvec); > + struct pglist_data *pgdat = lruvec_pgdat(priv->lruvec); > + int old_gen, new_gen = lru_gen_from_seq(priv->max_seq); > + > + VM_BUG_ON(pmd_leaf(*pmd)); > + > + ptl = pte_lockptr(walk->mm, pmd); > + if (!spin_trylock(ptl)) > + return false; > + > + arch_enter_lazy_mmu_mode(); > + > + pte = pte_offset_map(pmd, start & PMD_MASK); > +restart: > + for (i = pte_index(start), addr = start; addr != end; i++, addr += PAGE_SIZE) { > + struct folio *folio; > + unsigned long pfn = pte_pfn(pte[i]); > + > + VM_BUG_ON(addr < walk->vma->vm_start || addr >= walk->vma->vm_end); > + > + total++; > + priv->mm_stats[MM_PTE_TOTAL]++; > + > + if (!pte_present(pte[i]) || is_zero_pfn(pfn)) > + continue; > + > + if (WARN_ON_ONCE(pte_devmap(pte[i]) || pte_special(pte[i]))) > + continue; > + > + if (!pte_young(pte[i])) { > + priv->mm_stats[MM_PTE_OLD]++; > + continue; > + } > + > + VM_BUG_ON(!pfn_valid(pfn)); > + if (pfn < pgdat->node_start_pfn || pfn >= pgdat_end_pfn(pgdat)) > + continue; > + > + folio = pfn_folio(pfn); > + if (folio_nid(folio) != pgdat->node_id) > + continue; > + > + if (folio_memcg_rcu(folio) != memcg) > + continue; > + > + if (!ptep_test_and_clear_young(walk->vma, addr, pte + i)) > + continue; > + > + young++; > + priv->mm_stats[MM_PTE_YOUNG]++; > + > + if (pte_dirty(pte[i]) && !folio_test_dirty(folio) && > + !(folio_test_anon(folio) && folio_test_swapbacked(folio) && > + !folio_test_swapcache(folio))) > + folio_mark_dirty(folio); > + > + old_gen = folio_update_gen(folio, new_gen); > + if (old_gen >= 0 && old_gen != new_gen) > + update_batch_size(priv, folio, old_gen, new_gen); > + } > + > + if (i < PTRS_PER_PTE && get_next_vma(walk, PMD_MASK, PAGE_SIZE, &start, &end)) > + goto restart; > + > + pte_unmap(pte); > + > + arch_leave_lazy_mmu_mode(); > + spin_unlock(ptl); > + > + return suitable_to_scan(total, young); > +} > + > +#if defined(CONFIG_TRANSPARENT_HUGEPAGE) || defined(CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG) > +static void walk_pmd_range_locked(pud_t *pud, unsigned long next, struct vm_area_struct *vma, > + struct mm_walk *walk, unsigned long *start) > +{ > + int i; > + pmd_t *pmd; > + spinlock_t *ptl; > + struct lru_gen_mm_walk *priv = walk->private; > + struct mem_cgroup *memcg = lruvec_memcg(priv->lruvec); > + struct pglist_data *pgdat = lruvec_pgdat(priv->lruvec); > + int old_gen, new_gen = lru_gen_from_seq(priv->max_seq); > + > + VM_BUG_ON(pud_leaf(*pud)); > + > + /* try to batch at most 1+MIN_LRU_BATCH+1 entries */ > + if (*start == -1) { > + *start = next; > + return; > + } > + > + i = next == -1 ? 0 : pmd_index(next) - pmd_index(*start); > + if (i && i <= MIN_LRU_BATCH) { > + __set_bit(i - 1, priv->bitmap); > + return; > + } > + > + pmd = pmd_offset(pud, *start); > + > + ptl = pmd_lockptr(walk->mm, pmd); > + if (!spin_trylock(ptl)) > + goto done; > + > + arch_enter_lazy_mmu_mode(); > + > + do { > + struct folio *folio; > + unsigned long pfn = pmd_pfn(pmd[i]); > + unsigned long addr = i ? (*start & PMD_MASK) + i * PMD_SIZE : *start; > + > + VM_BUG_ON(addr < vma->vm_start || addr >= vma->vm_end); > + > + if (!pmd_present(pmd[i]) || is_huge_zero_pmd(pmd[i])) > + goto next; > + > + if (WARN_ON_ONCE(pmd_devmap(pmd[i]))) > + goto next; > + > + if (!pmd_trans_huge(pmd[i])) { > + if (IS_ENABLED(CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG)) > + pmdp_test_and_clear_young(vma, addr, pmd + i); > + goto next; > + } > + > + VM_BUG_ON(!pfn_valid(pfn)); > + if (pfn < pgdat->node_start_pfn || pfn >= pgdat_end_pfn(pgdat)) > + goto next; > + > + folio = pfn_folio(pfn); > + if (folio_nid(folio) != pgdat->node_id) > + goto next; > + > + if (folio_memcg_rcu(folio) != memcg) > + goto next; > + > + if (!pmdp_test_and_clear_young(vma, addr, pmd + i)) > + goto next; > + > + priv->mm_stats[MM_PTE_YOUNG]++; > + > + if (pmd_dirty(pmd[i]) && !folio_test_dirty(folio) && > + !(folio_test_anon(folio) && folio_test_swapbacked(folio) && > + !folio_test_swapcache(folio))) > + folio_mark_dirty(folio); > + > + old_gen = folio_update_gen(folio, new_gen); > + if (old_gen >= 0 && old_gen != new_gen) > + update_batch_size(priv, folio, old_gen, new_gen); > +next: > + i = i > MIN_LRU_BATCH ? 0 : > + find_next_bit(priv->bitmap, MIN_LRU_BATCH, i) + 1; > + } while (i <= MIN_LRU_BATCH); > + > + arch_leave_lazy_mmu_mode(); > + spin_unlock(ptl); > +done: > + *start = -1; > + bitmap_zero(priv->bitmap, MIN_LRU_BATCH); > +} > +#else > +static void walk_pmd_range_locked(pud_t *pud, unsigned long next, struct vm_area_struct *vma, > + struct mm_walk *walk, unsigned long *start) > +{ > +} > +#endif > + > +static void walk_pmd_range(pud_t *pud, unsigned long start, unsigned long end, > + struct mm_walk *walk) > +{ > + int i; > + pmd_t *pmd; > + unsigned long next; > + unsigned long addr; > + struct vm_area_struct *vma; > + unsigned long pos = -1; > + struct lru_gen_mm_walk *priv = walk->private; > + > + VM_BUG_ON(pud_leaf(*pud)); > + > + /* > + * Finish an entire PMD in two passes: the first only reaches to PTE > + * tables to avoid taking the PMD lock; the second, if necessary, takes > + * the PMD lock to clear the accessed bit in PMD entries. > + */ > + pmd = pmd_offset(pud, start & PUD_MASK); > +restart: > + /* walk_pte_range() may call get_next_vma() */ > + vma = walk->vma; > + for (i = pmd_index(start), addr = start; addr != end; i++, addr = next) { > + pmd_t val = pmd_read_atomic(pmd + i); > + > + /* for pmd_read_atomic() */ > + barrier(); > + > + next = pmd_addr_end(addr, end); > + > + if (!pmd_present(val)) { > + priv->mm_stats[MM_PTE_TOTAL]++; > + continue; > + } > + > +#ifdef CONFIG_TRANSPARENT_HUGEPAGE > + if (pmd_trans_huge(val)) { > + unsigned long pfn = pmd_pfn(val); > + struct pglist_data *pgdat = lruvec_pgdat(priv->lruvec); > + > + priv->mm_stats[MM_PTE_TOTAL]++; > + > + if (is_huge_zero_pmd(val)) > + continue; > + > + if (!pmd_young(val)) { > + priv->mm_stats[MM_PTE_OLD]++; > + continue; > + } > + > + if (pfn < pgdat->node_start_pfn || pfn >= pgdat_end_pfn(pgdat)) > + continue; > + > + walk_pmd_range_locked(pud, addr, vma, walk, &pos); > + continue; > + } > +#endif > + priv->mm_stats[MM_PMD_TOTAL]++; > + > +#ifdef CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG > + if (!pmd_young(val)) > + continue; > + > + walk_pmd_range_locked(pud, addr, vma, walk, &pos); > +#endif > + if (!priv->full_scan && !test_bloom_filter(priv->lruvec, priv->max_seq, pmd + i)) > + continue; > + > + priv->mm_stats[MM_PMD_FOUND]++; > + > + if (!walk_pte_range(&val, addr, next, walk)) > + continue; > + > + priv->mm_stats[MM_PMD_ADDED]++; > + > + /* carry over to the next generation */ > + update_bloom_filter(priv->lruvec, priv->max_seq + 1, pmd + i); > + } > + > + walk_pmd_range_locked(pud, -1, vma, walk, &pos); > + > + if (i < PTRS_PER_PMD && get_next_vma(walk, PUD_MASK, PMD_SIZE, &start, &end)) > + goto restart; > +} > + > +static int walk_pud_range(p4d_t *p4d, unsigned long start, unsigned long end, > + struct mm_walk *walk) > +{ > + int i; > + pud_t *pud; > + unsigned long addr; > + unsigned long next; > + struct lru_gen_mm_walk *priv = walk->private; > + > + VM_BUG_ON(p4d_leaf(*p4d)); > + > + pud = pud_offset(p4d, start & P4D_MASK); > +restart: > + for (i = pud_index(start), addr = start; addr != end; i++, addr = next) { > + pud_t val = READ_ONCE(pud[i]); > + > + next = pud_addr_end(addr, end); > + > + if (!pud_present(val) || WARN_ON_ONCE(pud_leaf(val))) > + continue; > + > + walk_pmd_range(&val, addr, next, walk); > + > + if (priv->batched >= MAX_LRU_BATCH) { > + end = (addr | ~PUD_MASK) + 1; > + goto done; > + } > + } > + > + if (i < PTRS_PER_PUD && get_next_vma(walk, P4D_MASK, PUD_SIZE, &start, &end)) > + goto restart; > + > + end = round_up(end, P4D_SIZE); > +done: > + /* rounded-up boundaries can wrap to 0 */ > + priv->next_addr = end && walk->vma ? max(end, walk->vma->vm_start) : 0; > + > + return -EAGAIN; > +} > + > +static void walk_mm(struct lruvec *lruvec, struct mm_struct *mm, struct lru_gen_mm_walk *walk) > +{ > + static const struct mm_walk_ops mm_walk_ops = { > + .test_walk = should_skip_vma, > + .p4d_entry = walk_pud_range, > + }; > + > + int err; > + struct mem_cgroup *memcg = lruvec_memcg(lruvec); > + > + walk->next_addr = FIRST_USER_ADDRESS; > + > + do { > + err = -EBUSY; > + > + /* folio_update_gen() requires stable folio_memcg() */ > + if (!mem_cgroup_trylock_pages(memcg)) > + break; > + > + /* the caller might be holding the lock for write */ > + if (mmap_read_trylock(mm)) { > + unsigned long start = walk->next_addr; > + unsigned long end = mm->highest_vm_end; > + > + err = walk_page_range(mm, start, end, &mm_walk_ops, walk); > + > + mmap_read_unlock(mm); > + > + if (walk->batched) { > + spin_lock_irq(&lruvec->lru_lock); > + reset_batch_size(lruvec, walk); > + spin_unlock_irq(&lruvec->lru_lock); > + } > + } > + > + mem_cgroup_unlock_pages(); > + > + cond_resched(); > + } while (err == -EAGAIN && walk->next_addr && !mm_is_oom_victim(mm)); > +} > + > +static struct lru_gen_mm_walk *alloc_mm_walk(void) > +{ > + if (current->reclaim_state && current->reclaim_state->mm_walk) > + return current->reclaim_state->mm_walk; > + > + return kzalloc(sizeof(struct lru_gen_mm_walk), > + __GFP_HIGH | __GFP_NOMEMALLOC | __GFP_NOWARN); > +} > + > +static void free_mm_walk(struct lru_gen_mm_walk *walk) > +{ > + if (!current->reclaim_state || !current->reclaim_state->mm_walk) > + kfree(walk); > +} > + > static void inc_min_seq(struct lruvec *lruvec) > { > int type; > @@ -3272,7 +4112,7 @@ static bool try_to_inc_min_seq(struct lruvec *lruvec, bool can_swap) > return success; > } > > -static void inc_max_seq(struct lruvec *lruvec, unsigned long max_seq) > +static void inc_max_seq(struct lruvec *lruvec) > { > int prev, next; > int type, zone; > @@ -3282,9 +4122,6 @@ static void inc_max_seq(struct lruvec *lruvec, unsigned long max_seq) > > VM_BUG_ON(!seq_is_valid(lruvec)); > > - if (max_seq != lrugen->max_seq) > - goto unlock; > - > inc_min_seq(lruvec); > > /* > @@ -3316,10 +4153,72 @@ static void inc_max_seq(struct lruvec *lruvec, unsigned long max_seq) > > /* make sure preceding modifications appear */ > smp_store_release(&lrugen->max_seq, lrugen->max_seq + 1); > -unlock: > + > spin_unlock_irq(&lruvec->lru_lock); > } > > +static bool try_to_inc_max_seq(struct lruvec *lruvec, unsigned long max_seq, > + struct scan_control *sc, bool can_swap, bool full_scan) > +{ > + bool success; > + struct lru_gen_mm_walk *walk; > + struct mm_struct *mm = NULL; > + struct lru_gen_struct *lrugen = &lruvec->lrugen; > + > + VM_BUG_ON(max_seq > READ_ONCE(lrugen->max_seq)); > + > + /* > + * If the hardware doesn't automatically set the accessed bit, fallback > + * to lru_gen_look_around(), which only clears the accessed bit in a > + * handful of PTEs. Spreading the work out over a period of time usually > + * is less efficient, but it avoids bursty page faults. > + */ > + if (!full_scan && !arch_has_hw_pte_young()) { > + success = iterate_mm_list_nowalk(lruvec, max_seq); > + goto done; > + } > + > + walk = alloc_mm_walk(); > + if (!walk) { > + success = iterate_mm_list_nowalk(lruvec, max_seq); > + goto done; > + } > + > + walk->lruvec = lruvec; > + walk->max_seq = max_seq; > + walk->can_swap = can_swap; > + walk->full_scan = full_scan; > + > + do { > + success = iterate_mm_list(lruvec, walk, &mm); > + if (mm) > + walk_mm(lruvec, mm, walk); > + > + cond_resched(); > + } while (mm); > + > + free_mm_walk(walk); > +done: > + if (!success) { > + if (!current_is_kswapd() && !sc->priority) > + wait_event_killable(lruvec->mm_state.wait, > + max_seq < READ_ONCE(lrugen->max_seq)); > + > + return max_seq < READ_ONCE(lrugen->max_seq); > + } > + > + VM_BUG_ON(max_seq != READ_ONCE(lrugen->max_seq)); > + > + inc_max_seq(lruvec); > + /* either this sees any waiters or they will see updated max_seq */ > + if (wq_has_sleeper(&lruvec->mm_state.wait)) > + wake_up_all(&lruvec->mm_state.wait); > + > + wakeup_flusher_threads(WB_REASON_VMSCAN); > + > + return true; > +} > + > static long get_nr_evictable(struct lruvec *lruvec, unsigned long max_seq, > unsigned long *min_seq, bool can_swap, bool *need_aging) > { > @@ -3401,7 +4300,7 @@ static void age_lruvec(struct lruvec *lruvec, struct scan_control *sc) > nr_to_scan++; > > if (nr_to_scan && need_aging && (!mem_cgroup_below_low(memcg) || sc->memcg_low_reclaim)) > - inc_max_seq(lruvec, max_seq); > + try_to_inc_max_seq(lruvec, max_seq, sc, swappiness, false); > } > > static void lru_gen_age_node(struct pglist_data *pgdat, struct scan_control *sc) > @@ -3410,6 +4309,8 @@ static void lru_gen_age_node(struct pglist_data *pgdat, struct scan_control *sc) > > VM_BUG_ON(!current_is_kswapd()); > > + current->reclaim_state->mm_walk = &pgdat->mm_walk; > + > memcg = mem_cgroup_iter(NULL, NULL, NULL); > do { > struct lruvec *lruvec = mem_cgroup_lruvec(memcg, pgdat); > @@ -3418,11 +4319,16 @@ static void lru_gen_age_node(struct pglist_data *pgdat, struct scan_control *sc) > > cond_resched(); > } while ((memcg = mem_cgroup_iter(NULL, memcg, NULL))); > + > + current->reclaim_state->mm_walk = NULL; > } > > /* > * This function exploits spatial locality when shrink_page_list() walks the > * rmap. It scans the adjacent PTEs of a young PTE and promotes hot pages. > + * If the scan was done cacheline efficiently, it adds the PMD entry pointing > + * to the PTE table to the Bloom filter. This process is a feedback loop from > + * the eviction to the aging. > */ > void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > { > @@ -3431,6 +4337,8 @@ void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > unsigned long start; > unsigned long end; > unsigned long addr; > + struct lru_gen_mm_walk *walk; > + int young = 0; > unsigned long bitmap[BITS_TO_LONGS(MIN_LRU_BATCH)] = {}; > struct folio *folio = pfn_folio(pvmw->pfn); > struct mem_cgroup *memcg = folio_memcg(folio); > @@ -3492,6 +4400,8 @@ void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > if (!ptep_test_and_clear_young(pvmw->vma, addr, pte + i)) > continue; > > + young++; > + > if (pte_dirty(pte[i]) && !folio_test_dirty(folio) && > !(folio_test_anon(folio) && folio_test_swapbacked(folio) && > !folio_test_swapcache(folio))) > @@ -3507,7 +4417,13 @@ void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > arch_leave_lazy_mmu_mode(); > rcu_read_unlock(); > > - if (bitmap_weight(bitmap, MIN_LRU_BATCH) < PAGEVEC_SIZE) { > + /* feedback from rmap walkers to page table walkers */ > + if (suitable_to_scan(i, young)) > + update_bloom_filter(lruvec, max_seq, pvmw->pmd); > + > + walk = current->reclaim_state ? current->reclaim_state->mm_walk : NULL; > + > + if (!walk && bitmap_weight(bitmap, MIN_LRU_BATCH) < PAGEVEC_SIZE) { > for_each_set_bit(i, bitmap, MIN_LRU_BATCH) { > folio = pfn_folio(pte_pfn(pte[i])); > folio_activate(folio); > @@ -3519,8 +4435,10 @@ void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > if (!mem_cgroup_trylock_pages(memcg)) > return; > > - spin_lock_irq(&lruvec->lru_lock); > - new_gen = lru_gen_from_seq(lruvec->lrugen.max_seq); > + if (!walk) { > + spin_lock_irq(&lruvec->lru_lock); > + new_gen = lru_gen_from_seq(lruvec->lrugen.max_seq); > + } > > for_each_set_bit(i, bitmap, MIN_LRU_BATCH) { > folio = pfn_folio(pte_pfn(pte[i])); > @@ -3531,10 +4449,14 @@ void lru_gen_look_around(struct page_vma_mapped_walk *pvmw) > if (old_gen < 0 || old_gen == new_gen) > continue; > > - lru_gen_update_size(lruvec, folio, old_gen, new_gen); > + if (walk) > + update_batch_size(walk, folio, old_gen, new_gen); > + else > + lru_gen_update_size(lruvec, folio, old_gen, new_gen); > } > > - spin_unlock_irq(&lruvec->lru_lock); > + if (!walk) > + spin_unlock_irq(&lruvec->lru_lock); > > mem_cgroup_unlock_pages(); > } > @@ -3801,6 +4723,7 @@ static int evict_folios(struct lruvec *lruvec, struct scan_control *sc, int swap > struct folio *folio; > enum vm_event_item item; > struct reclaim_stat stat; > + struct lru_gen_mm_walk *walk; > struct mem_cgroup *memcg = lruvec_memcg(lruvec); > struct pglist_data *pgdat = lruvec_pgdat(lruvec); > > @@ -3840,6 +4763,10 @@ static int evict_folios(struct lruvec *lruvec, struct scan_control *sc, int swap > > move_pages_to_lru(lruvec, &list); > > + walk = current->reclaim_state ? current->reclaim_state->mm_walk : NULL; > + if (walk && walk->batched) > + reset_batch_size(lruvec, walk); > + > item = current_is_kswapd() ? PGSTEAL_KSWAPD : PGSTEAL_DIRECT; > if (!cgroup_reclaim(sc)) > __count_vm_events(item, reclaimed); > @@ -3894,20 +4821,25 @@ static long get_nr_to_scan(struct lruvec *lruvec, struct scan_control *sc, bool > return 0; > } > > - inc_max_seq(lruvec, max_seq); > + if (try_to_inc_max_seq(lruvec, max_seq, sc, can_swap, false)) > + return nr_to_scan; > > - return nr_to_scan; > + return min_seq[LRU_GEN_FILE] + MIN_NR_GENS <= max_seq ? nr_to_scan : 0; > } > > static void lru_gen_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc) > { > struct blk_plug plug; > long scanned = 0; > + struct pglist_data *pgdat = lruvec_pgdat(lruvec); > > lru_add_drain(); > > blk_start_plug(&plug); > > + if (current_is_kswapd()) > + current->reclaim_state->mm_walk = &pgdat->mm_walk; > + > while (true) { > int delta; > int swappiness; > @@ -3935,6 +4867,9 @@ static void lru_gen_shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc > cond_resched(); > } > > + if (current_is_kswapd()) > + current->reclaim_state->mm_walk = NULL; > + > blk_finish_plug(&plug); > } > > @@ -3951,15 +4886,21 @@ void lru_gen_init_lruvec(struct lruvec *lruvec) > > for_each_gen_type_zone(gen, type, zone) > INIT_LIST_HEAD(&lrugen->lists[gen][type][zone]); > + > + lruvec->mm_state.seq = MIN_NR_GENS; > + init_waitqueue_head(&lruvec->mm_state.wait); > } > > #ifdef CONFIG_MEMCG > void lru_gen_init_memcg(struct mem_cgroup *memcg) > { > + INIT_LIST_HEAD(&memcg->mm_list.fifo); > + spin_lock_init(&memcg->mm_list.lock); > } > > void lru_gen_exit_memcg(struct mem_cgroup *memcg) > { > + int i; > int nid; > > for_each_node(nid) { > @@ -3967,6 +4908,11 @@ void lru_gen_exit_memcg(struct mem_cgroup *memcg) > > VM_BUG_ON(memchr_inv(lruvec->lrugen.nr_pages, 0, > sizeof(lruvec->lrugen.nr_pages))); > + > + for (i = 0; i < NR_BLOOM_FILTERS; i++) { > + bitmap_free(lruvec->mm_state.filters[i]); > + lruvec->mm_state.filters[i] = NULL; > + } > } > } > #endif > @@ -3975,6 +4921,7 @@ 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); > + BUILD_BUG_ON(sizeof(MM_STAT_CODES) != NR_MM_STATS + 1); > > return 0; > }; 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 3AF5EC433EF for ; Fri, 29 Apr 2022 14:12:31 +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=pb4/Yzza26636c49qpfXwaq7B3UjEySEYGDXtaGboSM=; b=iXzeLVk6FWJySB gG1OMvFh3kk0NJ5sMnafqHyyd3BOcidN0sgO7/rWonpR/yNgtI43Mu11VQgYbT5Z5y+tuHQ4CqYSR 0rATgdh/P/b+pXYD79N/Zb07yxpAiOxOxat96wq6RwgEw2cuU6cXr0Xfx7zef7WGYJTw9aFakMkIU EhkgM09vXHh6J4vtoMXnogV7weC+m2xjpRUdESkwIZzXSE0DenLMNfVoi19wBEEGmAe0jI3cNcTgB +mhSccPzSCBxwBbbwolMk+fVFZDrtZK5b3Dq6TWglnO3lfEaW3emPvwG6gtmHBRgcZNOTXwKt0h1h 2yEu38rFqv/ILjX6xkHw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nkRKf-00BVMC-41; Fri, 29 Apr 2022 14:10:53 +0000 Received: from out30-44.freemail.mail.aliyun.com ([115.124.30.44]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nkRKW-00BVKB-S7 for linux-arm-kernel@lists.infradead.org; Fri, 29 Apr 2022 14:10:51 +0000 X-Alimail-AntiSpam: AC=PASS; BC=-1|-1; BR=01201311R151e4; CH=green; DM=||false|; DS=||; FP=0|-1|-1|-1|0|-1|-1|-1; HT=e01e04400; MF=zhongjiang-ali@linux.alibaba.com; NM=1; PH=DS; RN=41; SR=0; TI=SMTPD_---0VBi52YN_1651241427; Received: from 30.225.24.120(mailfrom:zhongjiang-ali@linux.alibaba.com fp:SMTPD_---0VBi52YN_1651241427) by smtp.aliyun-inc.com(127.0.0.1); Fri, 29 Apr 2022 22:10:29 +0800 Message-ID: Date: Fri, 29 Apr 2022 22:10:27 +0800 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:100.0) Gecko/20100101 Thunderbird/100.0 Subject: Re: [PATCH v10 08/14] mm: multi-gen LRU: support page table walks Content-Language: en-US To: Yu Zhao , Stephen Rothwell , linux-mm@kvack.org Cc: Andi Kleen , Andrew Morton , Aneesh Kumar , Barry Song <21cnbao@gmail.com>, Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Jesse Barnes , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Rik van Riel , Vlastimil Babka , Will Deacon , Ying Huang , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, page-reclaim@google.com, x86@kernel.org, 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: <20220407031525.2368067-1-yuzhao@google.com> <20220407031525.2368067-9-yuzhao@google.com> From: zhong jiang In-Reply-To: <20220407031525.2368067-9-yuzhao@google.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220429_071045_561061_F6F3EC27 X-CRM114-Status: GOOD ( 44.67 ) 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 Ck9uIDIwMjIvNC83IDExOjE1IOS4iuWNiCwgWXUgWmhhbyB3cm90ZToKPiBUbyBmdXJ0aGVyIGV4 cGxvaXQgc3BhdGlhbCBsb2NhbGl0eSwgdGhlIGFnaW5nIHByZWZlcnMgdG8gd2FsayBwYWdlCj4g dGFibGVzIHRvIHNlYXJjaCBmb3IgeW91bmcgUFRFcyBhbmQgcHJvbW90ZSBob3QgcGFnZXMuIEEg a2lsbCBzd2l0Y2gKPiB3aWxsIGJlIGFkZGVkIGluIHRoZSBuZXh0IHBhdGNoIHRvIGRpc2FibGUg dGhpcyBiZWhhdmlvci4gV2hlbgo+IGRpc2FibGVkLCB0aGUgYWdpbmcgcmVsaWVzIG9uIHRoZSBy bWFwIG9ubHkuCj4KPiBOQjogdGhpcyBiZWhhdmlvciBoYXMgbm90aGluZyBzaW1pbGFyIHdpdGgg dGhlIHBhZ2UgdGFibGUgc2Nhbm5pbmcgaW4KPiB0aGUgMi40IGtlcm5lbCBbMV0sIHdoaWNoIHNl YXJjaGVzIHBhZ2UgdGFibGVzIGZvciBvbGQgUFRFcywgYWRkcyBjb2xkCj4gcGFnZXMgdG8gc3dh cGNhY2hlIGFuZCB1bm1hcHMgdGhlbS4KPgo+IFRvIGF2b2lkIGNvbmZ1c2lvbiwgdGhlIHRlcm0g Iml0ZXJhdGlvbiIgc3BlY2lmaWNhbGx5IG1lYW5zIHRoZQo+IHRyYXZlcnNhbCBvZiBhbiBlbnRp cmUgbW1fc3RydWN0IGxpc3Q7IHRoZSB0ZXJtICJ3YWxrIiB3aWxsIGJlIGFwcGxpZWQKPiB0byBw YWdlIHRhYmxlcyBhbmQgdGhlIHJtYXAsIGFzIHVzdWFsLgo+Cj4gQW4gbW1fc3RydWN0IGxpc3Qg aXMgbWFpbnRhaW5lZCBmb3IgZWFjaCBtZW1jZywgYW5kIGFuIG1tX3N0cnVjdAo+IGZvbGxvd3Mg aXRzIG93bmVyIHRhc2sgdG8gdGhlIG5ldyBtZW1jZyB3aGVuIHRoaXMgdGFzayBpcyBtaWdyYXRl ZC4KPiBHaXZlbiBhbiBscnV2ZWMsIHRoZSBhZ2luZyBpdGVyYXRlcyBscnV2ZWNfbWVtY2coKS0+ bW1fbGlzdCBhbmQgY2FsbHMKPiB3YWxrX3BhZ2VfcmFuZ2UoKSB3aXRoIGVhY2ggbW1fc3RydWN0 IG9uIHRoaXMgbGlzdCB0byBwcm9tb3RlIGhvdAo+IHBhZ2VzIGJlZm9yZSBpdCBpbmNyZW1lbnRz IG1heF9zZXEuCj4KPiBXaGVuIG11bHRpcGxlIHBhZ2UgdGFibGUgd2Fsa2VycyBpdGVyYXRlIHRo ZSBzYW1lIGxpc3QsIGVhY2ggb2YgdGhlbQo+IGdldHMgYSB1bmlxdWUgbW1fc3RydWN0OyB0aGVy ZWZvcmUgdGhleSBjYW4gcnVuIGNvbmN1cnJlbnRseS4gUGFnZQo+IHRhYmxlIHdhbGtlcnMgaWdu b3JlIGFueSBtaXNwbGFjZWQgcGFnZXMsIGUuZy4sIGlmIGFuIG1tX3N0cnVjdCB3YXMKPiBtaWdy YXRlZCwgcGFnZXMgaXQgbGVmdCBpbiB0aGUgcHJldmlvdXMgbWVtY2cgd2lsbCBub3QgYmUgcHJv bW90ZWQKPiB3aGVuIGl0cyBjdXJyZW50IG1lbWNnIGlzIHVuZGVyIHJlY2xhaW0uIFNpbWlsYXJs eSwgcGFnZSB0YWJsZSB3YWxrZXJzCj4gd2lsbCBub3QgcHJvbW90ZSBwYWdlcyBmcm9tIG5vZGVz IG90aGVyIHRoYW4gdGhlIG9uZSB1bmRlciByZWNsYWltLgo+Cj4gVGhpcyBwYXRjaCB1c2VzIHRo ZSBmb2xsb3dpbmcgb3B0aW1pemF0aW9ucyB3aGVuIHdhbGtpbmcgcGFnZSB0YWJsZXM6Cj4gMS4g SXQgdHJhY2tzIHRoZSB1c2FnZSBvZiBtbV9zdHJ1Y3QncyBiZXR3ZWVuIGNvbnRleHQgc3dpdGNo ZXMgc28gdGhhdAo+ICAgICBwYWdlIHRhYmxlIHdhbGtlcnMgY2FuIHNraXAgcHJvY2Vzc2VzIHRo YXQgaGF2ZSBiZWVuIHNsZWVwaW5nIHNpbmNlCj4gICAgIHRoZSBsYXN0IGl0ZXJhdGlvbi4KPiAy LiBJdCB1c2VzIGdlbmVyYXRpb25hbCBCbG9vbSBmaWx0ZXJzIHRvIHJlY29yZCBwb3B1bGF0ZWQg YnJhbmNoZXMgc28KPiAgICAgdGhhdCBwYWdlIHRhYmxlIHdhbGtlcnMgY2FuIHJlZHVjZSB0aGVp ciBzZWFyY2ggc3BhY2UgYmFzZWQgb24gdGhlCj4gICAgIHF1ZXJ5IHJlc3VsdHMsIGUuZy4sIHRv IHNraXAgcGFnZSB0YWJsZXMgY29udGFpbmluZyBtb3N0bHkgaG9sZXMgb3IKPiAgICAgbWlzcGxh Y2VkIHBhZ2VzLgo+IDMuIEl0IHRha2VzIGFkdmFudGFnZSBvZiB0aGUgYWNjZXNzZWQgYml0IGlu IG5vbi1sZWFmIFBNRCBlbnRyaWVzIHdoZW4KPiAgICAgQ09ORklHX0FSQ0hfSEFTX05PTkxFQUZf UE1EX1lPVU5HPXkuCj4gNC4gSXQgZG9lcyBub3QgemlnemFnIGJldHdlZW4gYSBQR0QgdGFibGUg YW5kIHRoZSBzYW1lIFBNRCB0YWJsZQo+ICAgICBzcGFubmluZyBtdWx0aXBsZSBWTUFzLiBJT1cs IGl0IGZpbmlzaGVzIGFsbCB0aGUgVk1BcyB3aXRoaW4gdGhlCj4gICAgIHJhbmdlIG9mIHRoZSBz YW1lIFBNRCB0YWJsZSBiZWZvcmUgaXQgcmV0dXJucyB0byBhIFBHRCB0YWJsZS4gVGhpcwo+ICAg ICBpbXByb3ZlcyB0aGUgY2FjaGUgcGVyZm9ybWFuY2UgZm9yIHdvcmtsb2FkcyB0aGF0IGhhdmUg bGFyZ2UKPiAgICAgbnVtYmVycyBvZiB0aW55IFZNQXMgWzJdLCBlc3BlY2lhbGx5IHdoZW4gQ09O RklHX1BHVEFCTEVfTEVWRUxTPTUuCj4KPiBTZXJ2ZXIgYmVuY2htYXJrIHJlc3VsdHM6Cj4gICAg U2luZ2xlIHdvcmtsb2FkOgo+ICAgICAgZmlvIChidWZmZXJlZCBJL08pOiBubyBjaGFuZ2UKPgo+ ICAgIFNpbmdsZSB3b3JrbG9hZDoKPiAgICAgIG1lbWNhY2hlZCAoYW5vbik6ICtbOCwgMTBdJQo+ ICAgICAgICAgICAgICAgICAgT3BzL3NlYyAgICAgIEtCL3NlYwo+ICAgICAgICBwYXRjaDEtNzog MTE5MzkxOC45MyAgIDQ2NDM4LjE1Cj4gICAgICAgIHBhdGNoMS04OiAxMzAxOTU0LjQ0ICAgNTA2 NDAuMjcKPgo+ICAgIENvbmZpZ3VyYXRpb25zOgo+ICAgICAgbm8gY2hhbmdlCj4KPiBDbGllbnQg YmVuY2htYXJrIHJlc3VsdHM6Cj4gICAga3N3YXBkIHByb2ZpbGVzOgo+ICAgICAgcGF0Y2gxLTcK PiAgICAgICAgNDUuOTAlICBsem8xeF8xX2RvX2NvbXByZXNzIChyZWFsIHdvcmspCj4gICAgICAg ICA5LjE0JSAgcGFnZV92bWFfbWFwcGVkX3dhbGsKPiAgICAgICAgIDYuODElICBfcmF3X3NwaW5f dW5sb2NrX2lycQo+ICAgICAgICAgMi44MCUgIHB0ZXBfY2xlYXJfZmx1c2gKPiAgICAgICAgIDIu MzQlICBfX3pyYW1fYnZlY193cml0ZQo+ICAgICAgICAgMi4yOSUgIGRvX3Jhd19zcGluX2xvY2sK PiAgICAgICAgIDEuODQlICBscnVfZ2VuX2xvb2tfYXJvdW5kCj4gICAgICAgICAxLjc4JSAgbWVt bW92ZQo+ICAgICAgICAgMS43NCUgIG9ial9tYWxsb2MKPiAgICAgICAgIDEuNTAlICBmcmVlX3Vu cmVmX3BhZ2VfbGlzdAo+Cj4gICAgICBwYXRjaDEtOAo+ICAgICAgICA0Ni45NiUgIGx6bzF4XzFf ZG9fY29tcHJlc3MgKHJlYWwgd29yaykKPiAgICAgICAgIDcuNTUlICBwYWdlX3ZtYV9tYXBwZWRf d2Fsawo+ICAgICAgICAgNS44OSUgIF9yYXdfc3Bpbl91bmxvY2tfaXJxCj4gICAgICAgICAzLjMz JSAgd2Fsa19wdGVfcmFuZ2UKPiAgICAgICAgIDIuNjUlICBwdGVwX2NsZWFyX2ZsdXNoCj4gICAg ICAgICAyLjIzJSAgX196cmFtX2J2ZWNfd3JpdGUKPiAgICAgICAgIDIuMDglICBkb19yYXdfc3Bp bl9sb2NrCj4gICAgICAgICAxLjgzJSAgbWVtbW92ZQo+ICAgICAgICAgMS42NSUgIG9ial9tYWxs b2MKPiAgICAgICAgIDEuNDclICBmcmVlX3VucmVmX3BhZ2VfbGlzdAo+Cj4gICAgQ29uZmlndXJh dGlvbnM6Cj4gICAgICBubyBjaGFuZ2UKPgo+IFsxXSBodHRwczovL2x3bi5uZXQvQXJ0aWNsZXMv MjM3MzIvCj4gWzJdIGh0dHBzOi8vc291cmNlLmFuZHJvaWQuY29tL2RldmljZXMvdGVjaC9kZWJ1 Zy9zY3Vkbwo+Cj4gU2lnbmVkLW9mZi1ieTogWXUgWmhhbyA8eXV6aGFvQGdvb2dsZS5jb20+Cj4g QWNrZWQtYnk6IEJyaWFuIEdlZmZvbiA8YmdlZmZvbkBnb29nbGUuY29tPgo+IEFja2VkLWJ5OiBK YW4gQWxleGFuZGVyIFN0ZWZmZW5zIChoZWZ0aWcpIDxoZWZ0aWdAYXJjaGxpbnV4Lm9yZz4KPiBB Y2tlZC1ieTogT2xla3NhbmRyIE5hdGFsZW5rbyA8b2xla3NhbmRyQG5hdGFsZW5rby5uYW1lPgo+ IEFja2VkLWJ5OiBTdGV2ZW4gQmFycmV0dCA8c3RldmVuQGxpcXVvcml4Lm5ldD4KPiBBY2tlZC1i eTogU3VsZWltYW4gU291aGxhbCA8c3VsZWltYW5AZ29vZ2xlLmNvbT4KPiBUZXN0ZWQtYnk6IERh bmllbCBCeXJuZSA8ZGpieXJuZUBtdHUuZWR1Pgo+IFRlc3RlZC1ieTogRG9uYWxkIENhcnIgPGRA Y2hhb3MtcmVpbnMuY29tPgo+IFRlc3RlZC1ieTogSG9sZ2VyIEhvZmZzdMOkdHRlIDxob2xnZXJA YXBwbGllZC1hc3luY2hyb255LmNvbT4KPiBUZXN0ZWQtYnk6IEtvbnN0YW50aW4gS2hhcmxhbW92 IDxIaS1BbmdlbEB5YW5kZXgucnU+Cj4gVGVzdGVkLWJ5OiBTaHVhbmcgWmhhaSA8c3poYWkyQGNz LnJvY2hlc3Rlci5lZHU+Cj4gVGVzdGVkLWJ5OiBTb2ZpYSBUcmluaCA8c29maWEudHJpbmhAZWRp LndvcmtzPgo+IFRlc3RlZC1ieTogVmFpYmhhdiBKYWluIDx2YWliaGF2QGxpbnV4LmlibS5jb20+ Cj4gLS0tCj4gICBmcy9leGVjLmMgICAgICAgICAgICAgICAgICB8ICAgMiArCj4gICBpbmNsdWRl L2xpbnV4L21lbWNvbnRyb2wuaCB8ICAgNSArCj4gICBpbmNsdWRlL2xpbnV4L21tX3R5cGVzLmgg ICB8ICA3OCArKysKPiAgIGluY2x1ZGUvbGludXgvbW16b25lLmggICAgIHwgIDU5ICsrKwo+ICAg aW5jbHVkZS9saW51eC9zd2FwLmggICAgICAgfCAgIDQgKwo+ICAga2VybmVsL2V4aXQuYyAgICAg ICAgICAgICAgfCAgIDEgKwo+ICAga2VybmVsL2ZvcmsuYyAgICAgICAgICAgICAgfCAgIDkgKwo+ ICAga2VybmVsL3NjaGVkL2NvcmUuYyAgICAgICAgfCAgIDEgKwo+ICAgbW0vbWVtY29udHJvbC5j ICAgICAgICAgICAgfCAgMjQgKwo+ICAgbW0vdm1zY2FuLmMgICAgICAgICAgICAgICAgfCA5NzUg KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLQo+ICAgMTAgZmlsZXMgY2hhbmdl ZCwgMTE0NCBpbnNlcnRpb25zKCspLCAxNCBkZWxldGlvbnMoLSkKPgo+IGRpZmYgLS1naXQgYS9m cy9leGVjLmMgYi9mcy9leGVjLmMKPiBpbmRleCBlM2U1NWQ1ZTBiZTEuLmJiYThmYzQ0OTI2ZiAx MDA2NDQKPiAtLS0gYS9mcy9leGVjLmMKPiArKysgYi9mcy9leGVjLmMKPiBAQCAtMTAxMSw2ICsx MDExLDcgQEAgc3RhdGljIGludCBleGVjX21tYXAoc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gICAJ YWN0aXZlX21tID0gdHNrLT5hY3RpdmVfbW07Cj4gICAJdHNrLT5hY3RpdmVfbW0gPSBtbTsKPiAg IAl0c2stPm1tID0gbW07Cj4gKwlscnVfZ2VuX2FkZF9tbShtbSk7Cj4gICAJLyoKPiAgIAkgKiBU aGlzIHByZXZlbnRzIHByZWVtcHRpb24gd2hpbGUgYWN0aXZlX21tIGlzIGJlaW5nIGxvYWRlZCBh bmQKPiAgIAkgKiBpdCBhbmQgbW0gYXJlIGJlaW5nIHVwZGF0ZWQsIHdoaWNoIGNvdWxkIGNhdXNl IHByb2JsZW1zIGZvcgo+IEBAIC0xMDIzLDYgKzEwMjQsNyBAQCBzdGF0aWMgaW50IGV4ZWNfbW1h cChzdHJ1Y3QgbW1fc3RydWN0ICptbSkKPiAgIAlhY3RpdmF0ZV9tbShhY3RpdmVfbW0sIG1tKTsK PiAgIAlpZiAoSVNfRU5BQkxFRChDT05GSUdfQVJDSF9XQU5UX0lSUVNfT0ZGX0FDVElWQVRFX01N KSkKPiAgIAkJbG9jYWxfaXJxX2VuYWJsZSgpOwo+ICsJbHJ1X2dlbl91c2VfbW0obW0pOwo+ICAg CXRzay0+bW0tPnZtYWNhY2hlX3NlcW51bSA9IDA7Cj4gICAJdm1hY2FjaGVfZmx1c2godHNrKTsK PiAgIAl0YXNrX3VubG9jayh0c2spOwo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21lbWNv bnRyb2wuaCBiL2luY2x1ZGUvbGludXgvbWVtY29udHJvbC5oCj4gaW5kZXggNDYzMTY4ZmExNjcw Li45NTRjNTQ2NTI3MzYgMTAwNjQ0Cj4gLS0tIGEvaW5jbHVkZS9saW51eC9tZW1jb250cm9sLmgK PiArKysgYi9pbmNsdWRlL2xpbnV4L21lbWNvbnRyb2wuaAo+IEBAIC0zNDQsNiArMzQ0LDExIEBA IHN0cnVjdCBtZW1fY2dyb3VwIHsKPiAgIAlzdHJ1Y3QgZGVmZXJyZWRfc3BsaXQgZGVmZXJyZWRf c3BsaXRfcXVldWU7Cj4gICAjZW5kaWYKPiAgIAo+ICsjaWZkZWYgQ09ORklHX0xSVV9HRU4KPiAr CS8qIHBlci1tZW1jZyBtbV9zdHJ1Y3QgbGlzdCAqLwo+ICsJc3RydWN0IGxydV9nZW5fbW1fbGlz dCBtbV9saXN0Owo+ICsjZW5kaWYKPiArCj4gICAJc3RydWN0IG1lbV9jZ3JvdXBfcGVyX25vZGUg Km5vZGVpbmZvW107Cj4gICB9Owo+ICAgCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW1f dHlwZXMuaCBiL2luY2x1ZGUvbGludXgvbW1fdHlwZXMuaAo+IGluZGV4IDg4MzRlMzhjMDZhNC4u ZWVlMjlmNzAwZmFiIDEwMDY0NAo+IC0tLSBhL2luY2x1ZGUvbGludXgvbW1fdHlwZXMuaAo+ICsr KyBiL2luY2x1ZGUvbGludXgvbW1fdHlwZXMuaAo+IEBAIC0zLDYgKzMsNyBAQAo+ICAgI2RlZmlu ZSBfTElOVVhfTU1fVFlQRVNfSAo+ICAgCj4gICAjaW5jbHVkZSA8bGludXgvbW1fdHlwZXNfdGFz ay5oPgo+ICsjaW5jbHVkZSA8bGludXgvc2NoZWQuaD4KPiAgIAo+ICAgI2luY2x1ZGUgPGxpbnV4 L2F1eHZlYy5oPgo+ICAgI2luY2x1ZGUgPGxpbnV4L2tyZWYuaD4KPiBAQCAtMTcsNiArMTgsOCBA QAo+ICAgI2luY2x1ZGUgPGxpbnV4L3BhZ2UtZmxhZ3MtbGF5b3V0Lmg+Cj4gICAjaW5jbHVkZSA8 bGludXgvd29ya3F1ZXVlLmg+Cj4gICAjaW5jbHVkZSA8bGludXgvc2VxbG9jay5oPgo+ICsjaW5j bHVkZSA8bGludXgvbm9kZW1hc2suaD4KPiArI2luY2x1ZGUgPGxpbnV4L21tZGVidWcuaD4KPiAg IAo+ICAgI2luY2x1ZGUgPGFzbS9tbXUuaD4KPiAgIAo+IEBAIC02NTUsNiArNjU4LDIyIEBAIHN0 cnVjdCBtbV9zdHJ1Y3Qgewo+ICAgI2lmZGVmIENPTkZJR19JT01NVV9TVkEKPiAgIAkJdTMyIHBh c2lkOwo+ICAgI2VuZGlmCj4gKyNpZmRlZiBDT05GSUdfTFJVX0dFTgo+ICsJCXN0cnVjdCB7Cj4g KwkJCS8qIHRoaXMgbW1fc3RydWN0IGlzIG9uIGxydV9nZW5fbW1fbGlzdCAqLwo+ICsJCQlzdHJ1 Y3QgbGlzdF9oZWFkIGxpc3Q7Cj4gKyNpZmRlZiBDT05GSUdfTUVNQ0cKPiArCQkJLyogcG9pbnRz IHRvIHRoZSBtZW1jZyBvZiAib3duZXIiIGFib3ZlICovCj4gKwkJCXN0cnVjdCBtZW1fY2dyb3Vw ICptZW1jZzsKPiArI2VuZGlmCj4gKwkJCS8qCj4gKwkJCSAqIFNldCB3aGVuIHN3aXRjaGluZyB0 byB0aGlzIG1tX3N0cnVjdCwgYXMgYSBoaW50IG9mCj4gKwkJCSAqIHdoZXRoZXIgaXQgaGFzIGJl ZW4gdXNlZCBzaW5jZSB0aGUgbGFzdCB0aW1lIHBlci1ub2RlCj4gKwkJCSAqIHBhZ2UgdGFibGUg d2Fsa2VycyBjbGVhcmVkIHRoZSBjb3JyZXNwb25kaW5nIGJpdHMuCj4gKwkJCSAqLwo+ICsJCQlu b2RlbWFza190IG5vZGVzOwo+ICsJCX0gbHJ1X2dlbjsKPiArI2VuZGlmIC8qIENPTkZJR19MUlVf R0VOICovCj4gICAJfSBfX3JhbmRvbWl6ZV9sYXlvdXQ7Cj4gICAKPiAgIAkvKgo+IEBAIC02ODEs NiArNzAwLDY1IEBAIHN0YXRpYyBpbmxpbmUgY3B1bWFza190ICptbV9jcHVtYXNrKHN0cnVjdCBt bV9zdHJ1Y3QgKm1tKQo+ICAgCXJldHVybiAoc3RydWN0IGNwdW1hc2sgKikmbW0tPmNwdV9iaXRt YXA7Cj4gICB9Cj4gICAKPiArI2lmZGVmIENPTkZJR19MUlVfR0VOCj4gKwo+ICtzdHJ1Y3QgbHJ1 X2dlbl9tbV9saXN0IHsKPiArCS8qIG1tX3N0cnVjdCBsaXN0IGZvciBwYWdlIHRhYmxlIHdhbGtl cnMgKi8KPiArCXN0cnVjdCBsaXN0X2hlYWQgZmlmbzsKPiArCS8qIHByb3RlY3RzIHRoZSBsaXN0 IGFib3ZlICovCj4gKwlzcGlubG9ja190IGxvY2s7Cj4gK307Cj4gKwo+ICt2b2lkIGxydV9nZW5f YWRkX21tKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKPiArdm9pZCBscnVfZ2VuX2RlbF9tbShzdHJ1 Y3QgbW1fc3RydWN0ICptbSk7Cj4gKyNpZmRlZiBDT05GSUdfTUVNQ0cKPiArdm9pZCBscnVfZ2Vu X21pZ3JhdGVfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pOwo+ICsjZW5kaWYKPiArCj4gK3N0YXRp YyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sK PiArCUlOSVRfTElTVF9IRUFEKCZtbS0+bHJ1X2dlbi5saXN0KTsKPiArI2lmZGVmIENPTkZJR19N RU1DRwo+ICsJbW0tPmxydV9nZW4ubWVtY2cgPSBOVUxMOwo+ICsjZW5kaWYKPiArCW5vZGVzX2Ns ZWFyKG1tLT5scnVfZ2VuLm5vZGVzKTsKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIGxy dV9nZW5fdXNlX21tKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+ICt7Cj4gKwkvKiB1bmxpa2VseSBi dXQgbm90IGEgYnVnIHdoZW4gcmFjaW5nIHdpdGggbHJ1X2dlbl9taWdyYXRlX21tKCkgKi8KPiAr CVZNX1dBUk5fT04obGlzdF9lbXB0eSgmbW0tPmxydV9nZW4ubGlzdCkpOwo+ICsKPiArCWlmICgh KGN1cnJlbnQtPmZsYWdzICYgUEZfS1RIUkVBRCkgJiYgIW5vZGVzX2Z1bGwobW0tPmxydV9nZW4u bm9kZXMpKQo+ICsJCW5vZGVzX3NldGFsbChtbS0+bHJ1X2dlbi5ub2Rlcyk7Cj4gK30KPiArCj4g KyNlbHNlIC8qICFDT05GSUdfTFJVX0dFTiAqLwo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIGxy dV9nZW5fYWRkX21tKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+ICt7Cj4gK30KPiArCj4gK3N0YXRp YyBpbmxpbmUgdm9pZCBscnVfZ2VuX2RlbF9tbShzdHJ1Y3QgbW1fc3RydWN0ICptbSkKPiArewo+ ICt9Cj4gKwo+ICsjaWZkZWYgQ09ORklHX01FTUNHCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVf Z2VuX21pZ3JhdGVfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArfQo+ICsjZW5kaWYK PiArCj4gK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbW0oc3RydWN0IG1tX3N0cnVj dCAqbW0pCj4gK3sKPiArfQo+ICsKPiArc3RhdGljIGlubGluZSB2b2lkIGxydV9nZW5fdXNlX21t KHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+ICt7Cj4gK30KPiArCj4gKyNlbmRpZiAvKiBDT05GSUdf TFJVX0dFTiAqLwo+ICsKPiAgIHN0cnVjdCBtbXVfZ2F0aGVyOwo+ICAgZXh0ZXJuIHZvaWQgdGxi X2dhdGhlcl9tbXUoc3RydWN0IG1tdV9nYXRoZXIgKnRsYiwgc3RydWN0IG1tX3N0cnVjdCAqbW0p Owo+ICAgZXh0ZXJuIHZvaWQgdGxiX2dhdGhlcl9tbXVfZnVsbG1tKHN0cnVjdCBtbXVfZ2F0aGVy ICp0bGIsIHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKTsKPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9tbXpvbmUuaCBiL2luY2x1ZGUvbGludXgvbW16b25lLmgKPiBpbmRleCBjNjk1ODlhZDJiMDUu LmExYTk5OTcxZmY5YyAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L21tem9uZS5oCj4gKysr IGIvaW5jbHVkZS9saW51eC9tbXpvbmUuaAo+IEBAIC00MjQsNiArNDI0LDU4IEBAIHN0cnVjdCBs cnVfZ2VuX3N0cnVjdCB7Cj4gICAJYXRvbWljX2xvbmdfdCByZWZhdWx0ZWRbTlJfSElTVF9HRU5T XVtBTk9OX0FORF9GSUxFXVtNQVhfTlJfVElFUlNdOwo+ICAgfTsKPiAgIAo+ICtlbnVtIHsKPiAr CU1NX1BURV9UT1RBTCwJLyogdG90YWwgbGVhZiBlbnRyaWVzICovCj4gKwlNTV9QVEVfT0xELAkv KiBvbGQgbGVhZiBlbnRyaWVzICovCj4gKwlNTV9QVEVfWU9VTkcsCS8qIHlvdW5nIGxlYWYgZW50 cmllcyAqLwo+ICsJTU1fUE1EX1RPVEFMLAkvKiB0b3RhbCBub24tbGVhZiBlbnRyaWVzICovCj4g KwlNTV9QTURfRk9VTkQsCS8qIG5vbi1sZWFmIGVudHJpZXMgZm91bmQgaW4gQmxvb20gZmlsdGVy cyAqLwo+ICsJTU1fUE1EX0FEREVELAkvKiBub24tbGVhZiBlbnRyaWVzIGFkZGVkIHRvIEJsb29t IGZpbHRlcnMgKi8KPiArCU5SX01NX1NUQVRTCj4gK307Cj4gKwo+ICsvKiBtbmVtb25pYyBjb2Rl cyBmb3IgdGhlIG1tIHN0YXRzIGFib3ZlICovCj4gKyNkZWZpbmUgTU1fU1RBVF9DT0RFUwkJInRv eWRmYSIKPiArCj4gKy8qIGRvdWJsZS1idWZmZXJpbmcgQmxvb20gZmlsdGVycyAqLwo+ICsjZGVm aW5lIE5SX0JMT09NX0ZJTFRFUlMJMgo+ICsKPiArc3RydWN0IGxydV9nZW5fbW1fc3RhdGUgewo+ ICsJLyogc2V0IHRvIG1heF9zZXEgYWZ0ZXIgZWFjaCBpdGVyYXRpb24gKi8KPiArCXVuc2lnbmVk IGxvbmcgc2VxOwo+ICsJLyogd2hlcmUgdGhlIGN1cnJlbnQgaXRlcmF0aW9uIHN0YXJ0cyAoaW5j bHVzaXZlKSAqLwo+ICsJc3RydWN0IGxpc3RfaGVhZCAqaGVhZDsKPiArCS8qIHdoZXJlIHRoZSBs YXN0IGl0ZXJhdGlvbiBlbmRzIChleGNsdXNpdmUpICovCj4gKwlzdHJ1Y3QgbGlzdF9oZWFkICp0 YWlsOwo+ICsJLyogdG8gd2FpdCBmb3IgdGhlIGxhc3QgcGFnZSB0YWJsZSB3YWxrZXIgdG8gZmlu aXNoICovCj4gKwlzdHJ1Y3Qgd2FpdF9xdWV1ZV9oZWFkIHdhaXQ7Cj4gKwkvKiBCbG9vbSBmaWx0 ZXJzIGZsaXAgYWZ0ZXIgZWFjaCBpdGVyYXRpb24gKi8KPiArCXVuc2lnbmVkIGxvbmcgKmZpbHRl cnNbTlJfQkxPT01fRklMVEVSU107Cj4gKwkvKiB0aGUgbW0gc3RhdHMgZm9yIGRlYnVnZ2luZyAq Lwo+ICsJdW5zaWduZWQgbG9uZyBzdGF0c1tOUl9ISVNUX0dFTlNdW05SX01NX1NUQVRTXTsKPiAr CS8qIHRoZSBudW1iZXIgb2YgY29uY3VycmVudCBwYWdlIHRhYmxlIHdhbGtlcnMgKi8KPiArCWlu dCBucl93YWxrZXJzOwo+ICt9Owo+ICsKPiArc3RydWN0IGxydV9nZW5fbW1fd2FsayB7Cj4gKwkv KiB0aGUgbHJ1dmVjIHVuZGVyIHJlY2xhaW0gKi8KPiArCXN0cnVjdCBscnV2ZWMgKmxydXZlYzsK PiArCS8qIHVuc3RhYmxlIG1heF9zZXEgZnJvbSBscnVfZ2VuX3N0cnVjdCAqLwo+ICsJdW5zaWdu ZWQgbG9uZyBtYXhfc2VxOwo+ICsJLyogdGhlIG5leHQgYWRkcmVzcyB3aXRoaW4gYW4gbW0gdG8g c2NhbiAqLwo+ICsJdW5zaWduZWQgbG9uZyBuZXh0X2FkZHI7Cj4gKwkvKiB0byBiYXRjaCBwYWdl IHRhYmxlIGVudHJpZXMgKi8KPiArCXVuc2lnbmVkIGxvbmcgYml0bWFwW0JJVFNfVE9fTE9OR1Mo TUlOX0xSVV9CQVRDSCldOwo+ICsJLyogdG8gYmF0Y2ggcHJvbW90ZWQgcGFnZXMgKi8KPiArCWlu dCBucl9wYWdlc1tNQVhfTlJfR0VOU11bQU5PTl9BTkRfRklMRV1bTUFYX05SX1pPTkVTXTsKPiAr CS8qIHRvIGJhdGNoIHRoZSBtbSBzdGF0cyAqLwo+ICsJaW50IG1tX3N0YXRzW05SX01NX1NUQVRT XTsKPiArCS8qIHRvdGFsIGJhdGNoZWQgaXRlbXMgKi8KPiArCWludCBiYXRjaGVkOwo+ICsJYm9v bCBjYW5fc3dhcDsKPiArCWJvb2wgZnVsbF9zY2FuOwo+ICt9Owo+ICsKPiAgIHZvaWQgbHJ1X2dl bl9pbml0X2xydXZlYyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMpOwo+ICAgdm9pZCBscnVfZ2VuX2xv b2tfYXJvdW5kKHN0cnVjdCBwYWdlX3ZtYV9tYXBwZWRfd2FsayAqcHZtdyk7Cj4gICAKPiBAQCAt NDc0LDYgKzUyNiw4IEBAIHN0cnVjdCBscnV2ZWMgewo+ICAgI2lmZGVmIENPTkZJR19MUlVfR0VO Cj4gICAJLyogZXZpY3RhYmxlIHBhZ2VzIGRpdmlkZWQgaW50byBnZW5lcmF0aW9ucyAqLwo+ICAg CXN0cnVjdCBscnVfZ2VuX3N0cnVjdAkJbHJ1Z2VuOwo+ICsJLyogdG8gY29uY3VycmVudGx5IGl0 ZXJhdGUgbHJ1X2dlbl9tbV9saXN0ICovCj4gKwlzdHJ1Y3QgbHJ1X2dlbl9tbV9zdGF0ZQkJbW1f c3RhdGU7Cj4gICAjZW5kaWYKPiAgICNpZmRlZiBDT05GSUdfTUVNQ0cKPiAgIAlzdHJ1Y3QgcGds aXN0X2RhdGEgKnBnZGF0Owo+IEBAIC0xMDY3LDYgKzExMjEsMTEgQEAgdHlwZWRlZiBzdHJ1Y3Qg cGdsaXN0X2RhdGEgewo+ICAgCj4gICAJdW5zaWduZWQgbG9uZwkJZmxhZ3M7Cj4gICAKPiArI2lm ZGVmIENPTkZJR19MUlVfR0VOCj4gKwkvKiBrc3dhcCBtbSB3YWxrIGRhdGEgKi8KPiArCXN0cnVj dCBscnVfZ2VuX21tX3dhbGsJbW1fd2FsazsKPiArI2VuZGlmCj4gKwo+ICAgCVpPTkVfUEFERElO RyhfcGFkMl8pCj4gICAKPiAgIAkvKiBQZXItbm9kZSB2bXN0YXRzICovCj4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvbGludXgvc3dhcC5oIGIvaW5jbHVkZS9saW51eC9zd2FwLmgKPiBpbmRleCAyNzA5 M2I0NzdjNWYuLjdiZGQ3YmNiMTM1ZCAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2xpbnV4L3N3YXAu aAo+ICsrKyBiL2luY2x1ZGUvbGludXgvc3dhcC5oCj4gQEAgLTEzNyw2ICsxMzcsMTAgQEAgdW5p b24gc3dhcF9oZWFkZXIgewo+ICAgICovCj4gICBzdHJ1Y3QgcmVjbGFpbV9zdGF0ZSB7Cj4gICAJ dW5zaWduZWQgbG9uZyByZWNsYWltZWRfc2xhYjsKPiArI2lmZGVmIENPTkZJR19MUlVfR0VOCj4g KwkvKiBwZXItdGhyZWFkIG1tIHdhbGsgZGF0YSAqLwo+ICsJc3RydWN0IGxydV9nZW5fbW1fd2Fs ayAqbW1fd2FsazsKPiArI2VuZGlmCj4gICB9Owo+ICAgCj4gICAjaWZkZWYgX19LRVJORUxfXwo+ IGRpZmYgLS1naXQgYS9rZXJuZWwvZXhpdC5jIGIva2VybmVsL2V4aXQuYwo+IGluZGV4IGYwNzI5 NTlmY2FiNy4uZjJkNGQ0OGVhNzkwIDEwMDY0NAo+IC0tLSBhL2tlcm5lbC9leGl0LmMKPiArKysg Yi9rZXJuZWwvZXhpdC5jCj4gQEAgLTQ2Niw2ICs0NjYsNyBAQCB2b2lkIG1tX3VwZGF0ZV9uZXh0 X293bmVyKHN0cnVjdCBtbV9zdHJ1Y3QgKm1tKQo+ICAgCQlnb3RvIHJldHJ5Owo+ICAgCX0KPiAg IAlXUklURV9PTkNFKG1tLT5vd25lciwgYyk7Cj4gKwlscnVfZ2VuX21pZ3JhdGVfbW0obW0pOwo+ ICAgCXRhc2tfdW5sb2NrKGMpOwo+ICAgCXB1dF90YXNrX3N0cnVjdChjKTsKPiAgIH0KPiBkaWZm IC0tZ2l0IGEva2VybmVsL2ZvcmsuYyBiL2tlcm5lbC9mb3JrLmMKPiBpbmRleCA5Nzk2ODk3NTYw YWIuLmQxNDI5N2NlMTE1MSAxMDA2NDQKPiAtLS0gYS9rZXJuZWwvZm9yay5jCj4gKysrIGIva2Vy bmVsL2ZvcmsuYwo+IEBAIC0xMTQ4LDYgKzExNDgsNyBAQCBzdGF0aWMgc3RydWN0IG1tX3N0cnVj dCAqbW1faW5pdChzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IHRhc2tfc3RydWN0ICpwLAo+ ICAgCQlnb3RvIGZhaWxfbm9jb250ZXh0Owo+ICAgCj4gICAJbW0tPnVzZXJfbnMgPSBnZXRfdXNl cl9ucyh1c2VyX25zKTsKPiArCWxydV9nZW5faW5pdF9tbShtbSk7Cj4gICAJcmV0dXJuIG1tOwo+ ICAgCj4gICBmYWlsX25vY29udGV4dDoKPiBAQCAtMTE5MSw2ICsxMTkyLDcgQEAgc3RhdGljIGlu bGluZSB2b2lkIF9fbW1wdXQoc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gICAJaWYgKG1tLT5iaW5m bXQpCj4gICAJCW1vZHVsZV9wdXQobW0tPmJpbmZtdC0+bW9kdWxlKTsKPiAgIAltbV9wYXNpZF9k cm9wKG1tKTsKPiArCWxydV9nZW5fZGVsX21tKG1tKTsKPiAgIAltbWRyb3AobW0pOwo+ICAgfQo+ ICAgCj4gQEAgLTI2NjAsNiArMjY2MiwxMyBAQCBwaWRfdCBrZXJuZWxfY2xvbmUoc3RydWN0IGtl cm5lbF9jbG9uZV9hcmdzICphcmdzKQo+ICAgCQlnZXRfdGFza19zdHJ1Y3QocCk7Cj4gICAJfQo+ ICAgCj4gKwlpZiAoSVNfRU5BQkxFRChDT05GSUdfTFJVX0dFTikgJiYgIShjbG9uZV9mbGFncyAm IENMT05FX1ZNKSkgewo+ICsJCS8qIGxvY2sgdGhlIHRhc2sgdG8gc3luY2hyb25pemUgd2l0aCBt ZW1jZyBtaWdyYXRpb24gKi8KPiArCQl0YXNrX2xvY2socCk7Cj4gKwkJbHJ1X2dlbl9hZGRfbW0o cC0+bW0pOwo+ICsJCXRhc2tfdW5sb2NrKHApOwo+ICsJfQo+ICsKPiAgIAl3YWtlX3VwX25ld190 YXNrKHApOwo+ICAgCj4gICAJLyogZm9ya2luZyBjb21wbGV0ZSBhbmQgY2hpbGQgc3RhcnRlZCB0 byBydW4sIHRlbGwgcHRyYWNlciAqLwo+IGRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQvY29yZS5j IGIva2VybmVsL3NjaGVkL2NvcmUuYwo+IGluZGV4IGQ1NzViNDkxNDkyNS4uODgxOTNhMGY2ZDJi IDEwMDY0NAo+IC0tLSBhL2tlcm5lbC9zY2hlZC9jb3JlLmMKPiArKysgYi9rZXJuZWwvc2NoZWQv Y29yZS5jCj4gQEAgLTUwNTcsNiArNTA1Nyw3IEBAIGNvbnRleHRfc3dpdGNoKHN0cnVjdCBycSAq cnEsIHN0cnVjdCB0YXNrX3N0cnVjdCAqcHJldiwKPiAgIAkJICogZmluaXNoX3Rhc2tfc3dpdGNo KCkncyBtbWRyb3AoKS4KPiAgIAkJICovCj4gICAJCXN3aXRjaF9tbV9pcnFzX29mZihwcmV2LT5h Y3RpdmVfbW0sIG5leHQtPm1tLCBuZXh0KTsKPiArCQlscnVfZ2VuX3VzZV9tbShuZXh0LT5tbSk7 Cj4gICAKPiAgIAkJaWYgKCFwcmV2LT5tbSkgeyAgICAgICAgICAgICAgICAgICAgICAgIC8vIGZy b20ga2VybmVsCj4gICAJCQkvKiB3aWxsIG1tZHJvcCgpIGluIGZpbmlzaF90YXNrX3N3aXRjaCgp LiAqLwo+IGRpZmYgLS1naXQgYS9tbS9tZW1jb250cm9sLmMgYi9tbS9tZW1jb250cm9sLmMKPiBp bmRleCA4MDY5YjU4ZjI0MjIuLjZhNzYxNTI2MTRjNSAxMDA2NDQKPiAtLS0gYS9tbS9tZW1jb250 cm9sLmMKPiArKysgYi9tbS9tZW1jb250cm9sLmMKPiBAQCAtNjA4Myw2ICs2MDgzLDI5IEBAIHN0 YXRpYyB2b2lkIG1lbV9jZ3JvdXBfbW92ZV90YXNrKHZvaWQpCj4gICB9Cj4gICAjZW5kaWYKPiAg IAo+ICsjaWZkZWYgQ09ORklHX0xSVV9HRU4KPiArc3RhdGljIHZvaWQgbWVtX2Nncm91cF9hdHRh Y2goc3RydWN0IGNncm91cF90YXNrc2V0ICp0c2V0KQo+ICt7Cj4gKwlzdHJ1Y3QgY2dyb3VwX3N1 YnN5c19zdGF0ZSAqY3NzOwo+ICsJc3RydWN0IHRhc2tfc3RydWN0ICp0YXNrID0gTlVMTDsKPiAr Cj4gKwljZ3JvdXBfdGFza3NldF9mb3JfZWFjaF9sZWFkZXIodGFzaywgY3NzLCB0c2V0KQo+ICsJ CWJyZWFrOwo+ICsKPiArCWlmICghdGFzaykKPiArCQlyZXR1cm47Cj4gKwo+ICsJdGFza19sb2Nr KHRhc2spOwo+ICsJaWYgKHRhc2stPm1tICYmIHRhc2stPm1tLT5vd25lciA9PSB0YXNrKQo+ICsJ CWxydV9nZW5fbWlncmF0ZV9tbSh0YXNrLT5tbSk7Cj4gKwl0YXNrX3VubG9jayh0YXNrKTsKPiAr fQo+ICsjZWxzZQo+ICtzdGF0aWMgdm9pZCBtZW1fY2dyb3VwX2F0dGFjaChzdHJ1Y3QgY2dyb3Vw X3Rhc2tzZXQgKnRzZXQpCj4gK3sKPiArfQo+ICsjZW5kaWYgLyogQ09ORklHX0xSVV9HRU4gKi8K PiArCj4gICBzdGF0aWMgaW50IHNlcV9wdXRzX21lbWNnX3R1bmFibGUoc3RydWN0IHNlcV9maWxl ICptLCB1bnNpZ25lZCBsb25nIHZhbHVlKQo+ICAgewo+ICAgCWlmICh2YWx1ZSA9PSBQQUdFX0NP VU5URVJfTUFYKQo+IEBAIC02NDI4LDYgKzY0NTEsNyBAQCBzdHJ1Y3QgY2dyb3VwX3N1YnN5cyBt ZW1vcnlfY2dycF9zdWJzeXMgPSB7Cj4gICAJLmNzc19yZXNldCA9IG1lbV9jZ3JvdXBfY3NzX3Jl c2V0LAo+ICAgCS5jc3NfcnN0YXRfZmx1c2ggPSBtZW1fY2dyb3VwX2Nzc19yc3RhdF9mbHVzaCwK PiAgIAkuY2FuX2F0dGFjaCA9IG1lbV9jZ3JvdXBfY2FuX2F0dGFjaCwKPiArCS5hdHRhY2ggPSBt ZW1fY2dyb3VwX2F0dGFjaCwKPiAgIAkuY2FuY2VsX2F0dGFjaCA9IG1lbV9jZ3JvdXBfY2FuY2Vs X2F0dGFjaCwKPiAgIAkucG9zdF9hdHRhY2ggPSBtZW1fY2dyb3VwX21vdmVfdGFzaywKPiAgIAku ZGZsX2NmdHlwZXMgPSBtZW1vcnlfZmlsZXMsCj4gZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIv bW0vdm1zY2FuLmMKPiBpbmRleCBmNGRkM2MzYzU4OWIuLjllMjgxMGEyMzBhNCAxMDA2NDQKPiAt LS0gYS9tbS92bXNjYW4uYwo+ICsrKyBiL21tL3Ztc2Nhbi5jCj4gQEAgLTUwLDYgKzUwLDggQEAK PiAgICNpbmNsdWRlIDxsaW51eC9wcmludGsuaD4KPiAgICNpbmNsdWRlIDxsaW51eC9kYXguaD4K PiAgICNpbmNsdWRlIDxsaW51eC9wc2kuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3BhZ2V3YWxrLmg+ Cj4gKyNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgo+ICAgCj4gICAjaW5jbHVkZSA8YXNtL3Rs YmZsdXNoLmg+Cj4gICAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+Cj4gQEAgLTMwMTYsNyArMzAxOCw3 IEBAIHN0YXRpYyBpbnQgZm9saW9fbHJ1X3RpZXIoc3RydWN0IGZvbGlvICpmb2xpbykKPiAgIAly ZXR1cm4gbHJ1X3RpZXJfZnJvbV9yZWZzKHJlZnMpOwo+ICAgfQo+ICAgCj4gLXN0YXRpYyBzdHJ1 Y3QgbHJ1dmVjIF9fbWF5YmVfdW51c2VkICpnZXRfbHJ1dmVjKHN0cnVjdCBtZW1fY2dyb3VwICpt ZW1jZywgaW50IG5pZCkKPiArc3RhdGljIHN0cnVjdCBscnV2ZWMgKmdldF9scnV2ZWMoc3RydWN0 IG1lbV9jZ3JvdXAgKm1lbWNnLCBpbnQgbmlkKQo+ICAgewo+ICAgCXN0cnVjdCBwZ2xpc3RfZGF0 YSAqcGdkYXQgPSBOT0RFX0RBVEEobmlkKTsKPiAgIAo+IEBAIC0zMDYxLDYgKzMwNjMsMzc0IEBA IHN0YXRpYyBib29sIF9fbWF5YmVfdW51c2VkIHNlcV9pc192YWxpZChzdHJ1Y3QgbHJ1dmVjICps cnV2ZWMpCj4gICAJICAgICAgIGdldF9ucl9nZW5zKGxydXZlYywgTFJVX0dFTl9BTk9OKSA8PSBN QVhfTlJfR0VOUzsKPiAgIH0KPiAgIAo+ICsvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCj4gKyAqICAg ICAgICAgICAgICAgICAgICAgICAgICBtbV9zdHJ1Y3QgbGlzdAo+ICsgKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqLwo+ICsKPiArc3RhdGljIHN0cnVjdCBscnVfZ2VuX21tX2xpc3QgKmdldF9tbV9saXN0 KHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKPiArewo+ICsJc3RhdGljIHN0cnVjdCBscnVfZ2Vu X21tX2xpc3QgbW1fbGlzdCA9IHsKPiArCQkuZmlmbyA9IExJU1RfSEVBRF9JTklUKG1tX2xpc3Qu ZmlmbyksCj4gKwkJLmxvY2sgPSBfX1NQSU5fTE9DS19VTkxPQ0tFRChtbV9saXN0LmxvY2spLAo+ ICsJfTsKPiArCj4gKyNpZmRlZiBDT05GSUdfTUVNQ0cKPiArCWlmIChtZW1jZykKPiArCQlyZXR1 cm4gJm1lbWNnLT5tbV9saXN0Owo+ICsjZW5kaWYKPiArCVZNX0JVR19PTighbWVtX2Nncm91cF9k aXNhYmxlZCgpKTsKPiArCj4gKwlyZXR1cm4gJm1tX2xpc3Q7Cj4gK30KPiArCj4gK3ZvaWQgbHJ1 X2dlbl9hZGRfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArCWludCBuaWQ7Cj4gKwlz dHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cgPSBnZXRfbWVtX2Nncm91cF9mcm9tX21tKG1tKTsKPiAr CXN0cnVjdCBscnVfZ2VuX21tX2xpc3QgKm1tX2xpc3QgPSBnZXRfbW1fbGlzdChtZW1jZyk7Cj4g Kwo+ICsJVk1fQlVHX09OX01NKCFsaXN0X2VtcHR5KCZtbS0+bHJ1X2dlbi5saXN0KSwgbW0pOwo+ ICsjaWZkZWYgQ09ORklHX01FTUNHCj4gKwlWTV9CVUdfT05fTU0obW0tPmxydV9nZW4ubWVtY2cs IG1tKTsKPiArCW1tLT5scnVfZ2VuLm1lbWNnID0gbWVtY2c7Cj4gKyNlbmRpZgo+ICsJc3Bpbl9s b2NrKCZtbV9saXN0LT5sb2NrKTsKPiArCj4gKwlmb3JfZWFjaF9ub2RlX3N0YXRlKG5pZCwgTl9N RU1PUlkpIHsKPiArCQlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMgPSBnZXRfbHJ1dmVjKG1lbWNnLCBu aWQpOwo+ICsKPiArCQlpZiAoIWxydXZlYykKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWlmIChs cnV2ZWMtPm1tX3N0YXRlLnRhaWwgPT0gJm1tX2xpc3QtPmZpZm8pCj4gKwkJCWxydXZlYy0+bW1f c3RhdGUudGFpbCA9ICZtbS0+bHJ1X2dlbi5saXN0Owo+ICsJfQo+ICsKPiArCWxpc3RfYWRkX3Rh aWwoJm1tLT5scnVfZ2VuLmxpc3QsICZtbV9saXN0LT5maWZvKTsKPiArCj4gKwlzcGluX3VubG9j aygmbW1fbGlzdC0+bG9jayk7Cj4gK30KPiArCj4gK3ZvaWQgbHJ1X2dlbl9kZWxfbW0oc3RydWN0 IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArCWludCBuaWQ7Cj4gKwlzdHJ1Y3QgbHJ1X2dlbl9tbV9s aXN0ICptbV9saXN0Owo+ICsJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0gTlVMTDsKPiArCj4g KwlpZiAobGlzdF9lbXB0eSgmbW0tPmxydV9nZW4ubGlzdCkpCj4gKwkJcmV0dXJuOwo+ICsKPiAr I2lmZGVmIENPTkZJR19NRU1DRwo+ICsJbWVtY2cgPSBtbS0+bHJ1X2dlbi5tZW1jZzsKPiArI2Vu ZGlmCj4gKwltbV9saXN0ID0gZ2V0X21tX2xpc3QobWVtY2cpOwo+ICsKPiArCXNwaW5fbG9jaygm bW1fbGlzdC0+bG9jayk7Cj4gKwo+ICsJZm9yX2VhY2hfbm9kZShuaWQpIHsKPiArCQlzdHJ1Y3Qg bHJ1dmVjICpscnV2ZWMgPSBnZXRfbHJ1dmVjKG1lbWNnLCBuaWQpOwo+ICsKPiArCQlpZiAoIWxy dXZlYykKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWlmIChscnV2ZWMtPm1tX3N0YXRlLnRhaWwg PT0gJm1tLT5scnVfZ2VuLmxpc3QpCj4gKwkJCWxydXZlYy0+bW1fc3RhdGUudGFpbCA9IGxydXZl Yy0+bW1fc3RhdGUudGFpbC0+bmV4dDsKPiArCj4gKwkJaWYgKGxydXZlYy0+bW1fc3RhdGUuaGVh ZCAhPSAmbW0tPmxydV9nZW4ubGlzdCkKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWxydXZlYy0+ bW1fc3RhdGUuaGVhZCA9IGxydXZlYy0+bW1fc3RhdGUuaGVhZC0+bmV4dDsKPiArCQlpZiAobHJ1 dmVjLT5tbV9zdGF0ZS5oZWFkID09ICZtbV9saXN0LT5maWZvKQo+ICsJCQlXUklURV9PTkNFKGxy dXZlYy0+bW1fc3RhdGUuc2VxLCBscnV2ZWMtPm1tX3N0YXRlLnNlcSArIDEpOwo+ICsJfQo+ICsK PiArCWxpc3RfZGVsX2luaXQoJm1tLT5scnVfZ2VuLmxpc3QpOwo+ICsKPiArCXNwaW5fdW5sb2Nr KCZtbV9saXN0LT5sb2NrKTsKPiArCj4gKyNpZmRlZiBDT05GSUdfTUVNQ0cKPiArCW1lbV9jZ3Jv dXBfcHV0KG1tLT5scnVfZ2VuLm1lbWNnKTsKPiArCW1tLT5scnVfZ2VuLm1lbWNnID0gTlVMTDsK PiArI2VuZGlmCj4gK30KPiArCj4gKyNpZmRlZiBDT05GSUdfTUVNQ0cKPiArdm9pZCBscnVfZ2Vu X21pZ3JhdGVfbW0oc3RydWN0IG1tX3N0cnVjdCAqbW0pCj4gK3sKPiArCXN0cnVjdCBtZW1fY2dy b3VwICptZW1jZzsKPiArCj4gKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZtbS0+b3duZXItPmFsbG9j X2xvY2spOwo+ICsKPiArCS8qIGZvciBtbV91cGRhdGVfbmV4dF9vd25lcigpICovCj4gKwlpZiAo bWVtX2Nncm91cF9kaXNhYmxlZCgpKQo+ICsJCXJldHVybjsKPiArCj4gKwlyY3VfcmVhZF9sb2Nr KCk7Cj4gKwltZW1jZyA9IG1lbV9jZ3JvdXBfZnJvbV90YXNrKG1tLT5vd25lcik7Cj4gKwlyY3Vf cmVhZF91bmxvY2soKTsKPiArCWlmIChtZW1jZyA9PSBtbS0+bHJ1X2dlbi5tZW1jZykKPiArCQly ZXR1cm47Cj4gKwo+ICsJVk1fQlVHX09OX01NKCFtbS0+bHJ1X2dlbi5tZW1jZywgbW0pOwo+ICsJ Vk1fQlVHX09OX01NKGxpc3RfZW1wdHkoJm1tLT5scnVfZ2VuLmxpc3QpLCBtbSk7Cj4gKwo+ICsJ bHJ1X2dlbl9kZWxfbW0obW0pOwo+ICsJbHJ1X2dlbl9hZGRfbW0obW0pOwo+ICt9Cj4gKyNlbmRp Zgo+ICsKPiArLyoKPiArICogQmxvb20gZmlsdGVycyB3aXRoIG09MTw8MTUsIGs9MiBhbmQgdGhl IGZhbHNlIHBvc2l0aXZlIHJhdGVzIG9mIH4xLzUgd2hlbgo+ICsgKiBuPTEwLDAwMCBhbmQgfjEv MiB3aGVuIG49MjAsMDAwLCB3aGVyZSwgY29udmVudGlvbmFsbHksIG0gaXMgdGhlIG51bWJlciBv Zgo+ICsgKiBiaXRzIGluIGEgYml0bWFwLCBrIGlzIHRoZSBudW1iZXIgb2YgaGFzaCBmdW5jdGlv bnMgYW5kIG4gaXMgdGhlIG51bWJlciBvZgo+ICsgKiBpbnNlcnRlZCBpdGVtcy4KPiArICoKPiAr ICogUGFnZSB0YWJsZSB3YWxrZXJzIHVzZSBvbmUgb2YgdGhlIHR3byBmaWx0ZXJzIHRvIHJlZHVj ZSB0aGVpciBzZWFyY2ggc3BhY2UuCj4gKyAqIFRvIGdldCByaWQgb2Ygbm9uLWxlYWYgZW50cmll cyB0aGF0IG5vIGxvbmdlciBoYXZlIGVub3VnaCBsZWFmIGVudHJpZXMsIHRoZQo+ICsgKiBhZ2lu ZyB1c2VzIHRoZSBkb3VibGUtYnVmZmVyaW5nIHRlY2huaXF1ZSB0byBmbGlwIHRvIHRoZSBvdGhl ciBmaWx0ZXIgZWFjaAo+ICsgKiB0aW1lIGl0IHByb2R1Y2VzIGEgbmV3IGdlbmVyYXRpb24uIEZv ciBub24tbGVhZiBlbnRyaWVzIHRoYXQgaGF2ZSBlbm91Z2gKPiArICogbGVhZiBlbnRyaWVzLCB0 aGUgYWdpbmcgY2FycmllcyB0aGVtIG92ZXIgdG8gdGhlIG5leHQgZ2VuZXJhdGlvbiBpbgo+ICsg KiB3YWxrX3BtZF9yYW5nZSgpOyB0aGUgZXZpY3Rpb24gYWxzbyByZXBvcnQgdGhlbSB3aGVuIHdh bGtpbmcgdGhlIHJtYXAKPiArICogaW4gbHJ1X2dlbl9sb29rX2Fyb3VuZCgpLgo+ICsgKgo+ICsg KiBGb3IgZnV0dXJlIG9wdGltaXphdGlvbnM6Cj4gKyAqIDEuIEl0J3Mgbm90IG5lY2Vzc2FyeSB0 byBrZWVwIGJvdGggZmlsdGVycyBhbGwgdGhlIHRpbWUuIFRoZSBzcGFyZSBvbmUgY2FuIGJlCj4g KyAqICAgIGZyZWVkIGFmdGVyIHRoZSBSQ1UgZ3JhY2UgcGVyaW9kIGFuZCByZWFsbG9jYXRlZCBp ZiBuZWVkZWQgYWdhaW4uCj4gKyAqIDIuIEFuZCB3aGVuIHJlYWxsb2NhdGluZywgaXQncyB3b3J0 aCBzY2FsaW5nIGl0cyBzaXplIGFjY29yZGluZyB0byB0aGUgbnVtYmVyCj4gKyAqICAgIG9mIGlu c2VydGVkIGVudHJpZXMgaW4gdGhlIG90aGVyIGZpbHRlciwgdG8gcmVkdWNlIHRoZSBtZW1vcnkg b3ZlcmhlYWQgb24KPiArICogICAgc21hbGwgc3lzdGVtcyBhbmQgZmFsc2UgcG9zaXRpdmVzIG9u IGxhcmdlIHN5c3RlbXMuCj4gKyAqIDMuIEplbmtpbnMnIGhhc2ggZnVuY3Rpb24gaXMgYW4gYWx0 ZXJuYXRpdmUgdG8gS251dGgncy4KPiArICovCj4gKyNkZWZpbmUgQkxPT01fRklMVEVSX1NISUZU CTE1Cj4gKwo+ICtzdGF0aWMgaW5saW5lIGludCBmaWx0ZXJfZ2VuX2Zyb21fc2VxKHVuc2lnbmVk IGxvbmcgc2VxKQo+ICt7Cj4gKwlyZXR1cm4gc2VxICUgTlJfQkxPT01fRklMVEVSUzsKPiArfQo+ ICsKPiArc3RhdGljIHZvaWQgZ2V0X2l0ZW1fa2V5KHZvaWQgKml0ZW0sIGludCAqa2V5KQo+ICt7 Cj4gKwl1MzIgaGFzaCA9IGhhc2hfcHRyKGl0ZW0sIEJMT09NX0ZJTFRFUl9TSElGVCAqIDIpOwo+ ICsKPiArCUJVSUxEX0JVR19PTihCTE9PTV9GSUxURVJfU0hJRlQgKiAyID4gQklUU19QRVJfVFlQ RSh1MzIpKTsKPiArCj4gKwlrZXlbMF0gPSBoYXNoICYgKEJJVChCTE9PTV9GSUxURVJfU0hJRlQp IC0gMSk7Cj4gKwlrZXlbMV0gPSBoYXNoID4+IEJMT09NX0ZJTFRFUl9TSElGVDsKPiArfQo+ICsK PiArc3RhdGljIHZvaWQgcmVzZXRfYmxvb21fZmlsdGVyKHN0cnVjdCBscnV2ZWMgKmxydXZlYywg dW5zaWduZWQgbG9uZyBzZXEpCj4gK3sKPiArCXVuc2lnbmVkIGxvbmcgKmZpbHRlcjsKPiArCWlu dCBnZW4gPSBmaWx0ZXJfZ2VuX2Zyb21fc2VxKHNlcSk7Cj4gKwo+ICsJbG9ja2RlcF9hc3NlcnRf aGVsZCgmZ2V0X21tX2xpc3QobHJ1dmVjX21lbWNnKGxydXZlYykpLT5sb2NrKTsKPiArCj4gKwlm aWx0ZXIgPSBscnV2ZWMtPm1tX3N0YXRlLmZpbHRlcnNbZ2VuXTsKPiArCWlmIChmaWx0ZXIpIHsK PiArCQliaXRtYXBfY2xlYXIoZmlsdGVyLCAwLCBCSVQoQkxPT01fRklMVEVSX1NISUZUKSk7Cj4g KwkJcmV0dXJuOwo+ICsJfQo+ICsKPiArCWZpbHRlciA9IGJpdG1hcF96YWxsb2MoQklUKEJMT09N X0ZJTFRFUl9TSElGVCksIEdGUF9BVE9NSUMpOwo+ICsJV1JJVEVfT05DRShscnV2ZWMtPm1tX3N0 YXRlLmZpbHRlcnNbZ2VuXSwgZmlsdGVyKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdXBkYXRl X2Jsb29tX2ZpbHRlcihzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHVuc2lnbmVkIGxvbmcgc2VxLCB2 b2lkICppdGVtKQo+ICt7Cj4gKwlpbnQga2V5WzJdOwo+ICsJdW5zaWduZWQgbG9uZyAqZmlsdGVy Owo+ICsJaW50IGdlbiA9IGZpbHRlcl9nZW5fZnJvbV9zZXEoc2VxKTsKPiArCj4gKwlmaWx0ZXIg PSBSRUFEX09OQ0UobHJ1dmVjLT5tbV9zdGF0ZS5maWx0ZXJzW2dlbl0pOwo+ICsJaWYgKCFmaWx0 ZXIpCj4gKwkJcmV0dXJuOwo+ICsKPiArCWdldF9pdGVtX2tleShpdGVtLCBrZXkpOwo+ICsKPiAr CWlmICghdGVzdF9iaXQoa2V5WzBdLCBmaWx0ZXIpKQo+ICsJCXNldF9iaXQoa2V5WzBdLCBmaWx0 ZXIpOwo+ICsJaWYgKCF0ZXN0X2JpdChrZXlbMV0sIGZpbHRlcikpCj4gKwkJc2V0X2JpdChrZXlb MV0sIGZpbHRlcik7Cj4gK30KPiArCj4gK3N0YXRpYyBib29sIHRlc3RfYmxvb21fZmlsdGVyKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBzZXEsIHZvaWQgKml0ZW0pCj4gK3sK PiArCWludCBrZXlbMl07Cj4gKwl1bnNpZ25lZCBsb25nICpmaWx0ZXI7Cj4gKwlpbnQgZ2VuID0g ZmlsdGVyX2dlbl9mcm9tX3NlcShzZXEpOwo+ICsKPiArCWZpbHRlciA9IFJFQURfT05DRShscnV2 ZWMtPm1tX3N0YXRlLmZpbHRlcnNbZ2VuXSk7Cj4gKwlpZiAoIWZpbHRlcikKPiArCQlyZXR1cm4g dHJ1ZTsKPiArCj4gKwlnZXRfaXRlbV9rZXkoaXRlbSwga2V5KTsKPiArCj4gKwlyZXR1cm4gdGVz dF9iaXQoa2V5WzBdLCBmaWx0ZXIpICYmIHRlc3RfYml0KGtleVsxXSwgZmlsdGVyKTsKPiArfQo+ ICsKPiArc3RhdGljIHZvaWQgcmVzZXRfbW1fc3RhdHMoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBz dHJ1Y3QgbHJ1X2dlbl9tbV93YWxrICp3YWxrLCBib29sIGxhc3QpCj4gK3sKPiArCWludCBpOwo+ ICsJaW50IGhpc3Q7Cj4gKwo+ICsJbG9ja2RlcF9hc3NlcnRfaGVsZCgmZ2V0X21tX2xpc3QobHJ1 dmVjX21lbWNnKGxydXZlYykpLT5sb2NrKTsKPiArCj4gKwlpZiAod2Fsaykgewo+ICsJCWhpc3Qg PSBscnVfaGlzdF9mcm9tX3NlcSh3YWxrLT5tYXhfc2VxKTsKPiArCj4gKwkJZm9yIChpID0gMDsg aSA8IE5SX01NX1NUQVRTOyBpKyspIHsKPiArCQkJV1JJVEVfT05DRShscnV2ZWMtPm1tX3N0YXRl LnN0YXRzW2hpc3RdW2ldLAo+ICsJCQkJICAgbHJ1dmVjLT5tbV9zdGF0ZS5zdGF0c1toaXN0XVtp XSArIHdhbGstPm1tX3N0YXRzW2ldKTsKPiArCQkJd2Fsay0+bW1fc3RhdHNbaV0gPSAwOwo+ICsJ CX0KPiArCX0KPiArCj4gKwlpZiAoTlJfSElTVF9HRU5TID4gMSAmJiBsYXN0KSB7Cj4gKwkJaGlz dCA9IGxydV9oaXN0X2Zyb21fc2VxKGxydXZlYy0+bW1fc3RhdGUuc2VxICsgMSk7Cj4gKwo+ICsJ CWZvciAoaSA9IDA7IGkgPCBOUl9NTV9TVEFUUzsgaSsrKQo+ICsJCQlXUklURV9PTkNFKGxydXZl Yy0+bW1fc3RhdGUuc3RhdHNbaGlzdF1baV0sIDApOwo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMg Ym9vbCBzaG91bGRfc2tpcF9tbShzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IGxydV9nZW5f bW1fd2FsayAqd2FsaykKPiArewo+ICsJaW50IHR5cGU7Cj4gKwl1bnNpZ25lZCBsb25nIHNpemUg PSAwOwo+ICsJc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCA9IGxydXZlY19wZ2RhdCh3YWxrLT5s cnV2ZWMpOwo+ICsKPiArCWlmICghd2Fsay0+ZnVsbF9zY2FuICYmIGNwdW1hc2tfZW1wdHkobW1f Y3B1bWFzayhtbSkpICYmCj4gKwkgICAgIW5vZGVfaXNzZXQocGdkYXQtPm5vZGVfaWQsIG1tLT5s cnVfZ2VuLm5vZGVzKSkKPiArCQlyZXR1cm4gdHJ1ZTsKPiArCj4gKwlub2RlX2NsZWFyKHBnZGF0 LT5ub2RlX2lkLCBtbS0+bHJ1X2dlbi5ub2Rlcyk7Cj4gKwo+ICsJZm9yICh0eXBlID0gIXdhbGst PmNhbl9zd2FwOyB0eXBlIDwgQU5PTl9BTkRfRklMRTsgdHlwZSsrKSB7Cj4gKwkJc2l6ZSArPSB0 eXBlID8gZ2V0X21tX2NvdW50ZXIobW0sIE1NX0ZJTEVQQUdFUykgOgo+ICsJCQkgICAgICAgZ2V0 X21tX2NvdW50ZXIobW0sIE1NX0FOT05QQUdFUykgKwo+ICsJCQkgICAgICAgZ2V0X21tX2NvdW50 ZXIobW0sIE1NX1NITUVNUEFHRVMpOwo+ICsJfQo+ICsKPiArCWlmIChzaXplIDwgTUlOX0xSVV9C QVRDSCkKPiArCQlyZXR1cm4gdHJ1ZTsKPiArCj4gKwlpZiAobW1faXNfb29tX3ZpY3RpbShtbSkp Cj4gKwkJcmV0dXJuIHRydWU7Cj4gKwo+ICsJcmV0dXJuICFtbWdldF9ub3RfemVybyhtbSk7Cj4g K30KPiArCj4gK3N0YXRpYyBib29sIGl0ZXJhdGVfbW1fbGlzdChzdHJ1Y3QgbHJ1dmVjICpscnV2 ZWMsIHN0cnVjdCBscnVfZ2VuX21tX3dhbGsgKndhbGssCj4gKwkJCSAgICBzdHJ1Y3QgbW1fc3Ry dWN0ICoqaXRlcikKPiArewo+ICsJYm9vbCBmaXJzdCA9IGZhbHNlOwo+ICsJYm9vbCBsYXN0ID0g dHJ1ZTsKPiArCXN0cnVjdCBtbV9zdHJ1Y3QgKm1tID0gTlVMTDsKPiArCXN0cnVjdCBtZW1fY2dy b3VwICptZW1jZyA9IGxydXZlY19tZW1jZyhscnV2ZWMpOwo+ICsJc3RydWN0IGxydV9nZW5fbW1f bGlzdCAqbW1fbGlzdCA9IGdldF9tbV9saXN0KG1lbWNnKTsKPiArCXN0cnVjdCBscnVfZ2VuX21t X3N0YXRlICptbV9zdGF0ZSA9ICZscnV2ZWMtPm1tX3N0YXRlOwo+ICsKPiArCS8qCj4gKwkgKiBU aGVyZSBhcmUgZm91ciBpbnRlcmVzdGluZyBjYXNlcyBmb3IgdGhpcyBwYWdlIHRhYmxlIHdhbGtl cjoKPiArCSAqIDEuIEl0IHRyaWVzIHRvIHN0YXJ0IGEgbmV3IGl0ZXJhdGlvbiBvZiBtbV9saXN0 IHdpdGggYSBzdGFsZSBtYXhfc2VxOwo+ICsJICogICAgdGhlcmUgaXMgbm90aGluZyB0byBiZSBk b25lLgo+ICsJICogMi4gSXQncyB0aGUgZmlyc3Qgb2YgdGhlIGN1cnJlbnQgZ2VuZXJhdGlvbiwg YW5kIGl0IG5lZWRzIHRvIHJlc2V0Cj4gKwkgKiAgICB0aGUgQmxvb20gZmlsdGVyIGZvciB0aGUg bmV4dCBnZW5lcmF0aW9uLgo+ICsJICogMy4gSXQgcmVhY2hlcyB0aGUgZW5kIG9mIG1tX2xpc3Qs IGFuZCBpdCBuZWVkcyB0byBpbmNyZW1lbnQKPiArCSAqICAgIG1tX3N0YXRlLT5zZXE7IHRoZSBp dGVyYXRpb24gaXMgZG9uZS4KPiArCSAqIDQuIEl0J3MgdGhlIGxhc3Qgb2YgdGhlIGN1cnJlbnQg Z2VuZXJhdGlvbiwgYW5kIGl0IG5lZWRzIHRvIHJlc2V0IHRoZQo+ICsJICogICAgbW0gc3RhdHMg Y291bnRlcnMgZm9yIHRoZSBuZXh0IGdlbmVyYXRpb24uCj4gKwkgKi8KPiArCWlmICgqaXRlcikK PiArCQltbXB1dF9hc3luYygqaXRlcik7Cj4gKwllbHNlIGlmICh3YWxrLT5tYXhfc2VxIDw9IFJF QURfT05DRShtbV9zdGF0ZS0+c2VxKSkKPiArCQlyZXR1cm4gZmFsc2U7Cj4gKwo+ICsJc3Bpbl9s b2NrKCZtbV9saXN0LT5sb2NrKTsKPiArCj4gKwlWTV9CVUdfT04obW1fc3RhdGUtPnNlcSArIDEg PCB3YWxrLT5tYXhfc2VxKTsKPiArCVZNX0JVR19PTigqaXRlciAmJiBtbV9zdGF0ZS0+c2VxID4g d2Fsay0+bWF4X3NlcSk7Cj4gKwlWTV9CVUdfT04oKml0ZXIgJiYgIW1tX3N0YXRlLT5ucl93YWxr ZXJzKTsKPiArCj4gKwlpZiAod2Fsay0+bWF4X3NlcSA8PSBtbV9zdGF0ZS0+c2VxKSB7Cj4gKwkJ aWYgKCEqaXRlcikKPiArCQkJbGFzdCA9IGZhbHNlOwo+ICsJCWdvdG8gZG9uZTsKPiArCX0KPiAr Cj4gKwlpZiAoIW1tX3N0YXRlLT5ucl93YWxrZXJzKSB7Cj4gKwkJVk1fQlVHX09OKG1tX3N0YXRl LT5oZWFkICYmIG1tX3N0YXRlLT5oZWFkICE9ICZtbV9saXN0LT5maWZvKTsKPiArCj4gKwkJbW1f c3RhdGUtPmhlYWQgPSBtbV9saXN0LT5maWZvLm5leHQ7Cj4gKwkJZmlyc3QgPSB0cnVlOwo+ICsJ fQo+ICsKPiArCXdoaWxlICghbW0gJiYgbW1fc3RhdGUtPmhlYWQgIT0gJm1tX2xpc3QtPmZpZm8p IHsKPiArCQltbSA9IGxpc3RfZW50cnkobW1fc3RhdGUtPmhlYWQsIHN0cnVjdCBtbV9zdHJ1Y3Qs IGxydV9nZW4ubGlzdCk7Cj4gKwo+ICsJCW1tX3N0YXRlLT5oZWFkID0gbW1fc3RhdGUtPmhlYWQt Pm5leHQ7Cj4gKwo+ICsJCS8qIGZ1bGwgc2NhbiBmb3IgdGhvc2UgYWRkZWQgYWZ0ZXIgdGhlIGxh c3QgaXRlcmF0aW9uICovCj4gKwkJaWYgKCFtbV9zdGF0ZS0+dGFpbCB8fCBtbV9zdGF0ZS0+dGFp bCA9PSAmbW0tPmxydV9nZW4ubGlzdCkgewo+ICsJCQltbV9zdGF0ZS0+dGFpbCA9IG1tX3N0YXRl LT5oZWFkOwo+ICsJCQl3YWxrLT5mdWxsX3NjYW4gPSB0cnVlOwo+ICsJCX0KPiArCgpUaGUgZnVs bF9zY2FuIHNlZW1zIHRvIGJlIGFsd2F5IHRydWUuwqDCoCBiZWNhdXNlIG1tX3N0YXRlLT50YWls IHBvaW50cyB0byAKdGhlIGZpcnN0IGl0ZW0gaW4gbW1fbGlzdCzCoCBoZW5jZSB0aGUgd2Fsa2Vy J3MKCmNvbmRpdGlvbiBtbV9zdGF0ZS0+dGFpbCA9PSAmbW0tPmxydV9nZW4ubGlzdCBhbHdheSBl cXVhbC7CoCBBbSBJIG1pc3NpbmcgCnNvbWV0aGluZz8KCgpUaGFua3MsCgo+ICsJCWlmIChzaG91 bGRfc2tpcF9tbShtbSwgd2FsaykpCj4gKwkJCW1tID0gTlVMTDsKPiArCX0KPiArCj4gKwlpZiAo bW1fc3RhdGUtPmhlYWQgPT0gJm1tX2xpc3QtPmZpZm8pCj4gKwkJV1JJVEVfT05DRShtbV9zdGF0 ZS0+c2VxLCBtbV9zdGF0ZS0+c2VxICsgMSk7Cj4gK2RvbmU6Cj4gKwlpZiAoKml0ZXIgJiYgIW1t KQo+ICsJCW1tX3N0YXRlLT5ucl93YWxrZXJzLS07Cj4gKwlpZiAoISppdGVyICYmIG1tKQo+ICsJ CW1tX3N0YXRlLT5ucl93YWxrZXJzKys7Cj4gKwo+ICsJaWYgKG1tX3N0YXRlLT5ucl93YWxrZXJz KQo+ICsJCWxhc3QgPSBmYWxzZTsKPiArCj4gKwlpZiAobW0gJiYgZmlyc3QpCj4gKwkJcmVzZXRf Ymxvb21fZmlsdGVyKGxydXZlYywgd2Fsay0+bWF4X3NlcSArIDEpOwo+ICsKPiArCWlmICgqaXRl ciB8fCBsYXN0KQo+ICsJCXJlc2V0X21tX3N0YXRzKGxydXZlYywgd2FsaywgbGFzdCk7Cj4gKwo+ ICsJc3Bpbl91bmxvY2soJm1tX2xpc3QtPmxvY2spOwo+ICsKPiArCSppdGVyID0gbW07Cj4gKwo+ ICsJcmV0dXJuIGxhc3Q7Cj4gK30KPiArCj4gK3N0YXRpYyBib29sIGl0ZXJhdGVfbW1fbGlzdF9u b3dhbGsoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCB1bnNpZ25lZCBsb25nIG1heF9zZXEpCj4gK3sK PiArCWJvb2wgc3VjY2VzcyA9IGZhbHNlOwo+ICsJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0g bHJ1dmVjX21lbWNnKGxydXZlYyk7Cj4gKwlzdHJ1Y3QgbHJ1X2dlbl9tbV9saXN0ICptbV9saXN0 ID0gZ2V0X21tX2xpc3QobWVtY2cpOwo+ICsJc3RydWN0IGxydV9nZW5fbW1fc3RhdGUgKm1tX3N0 YXRlID0gJmxydXZlYy0+bW1fc3RhdGU7Cj4gKwo+ICsJaWYgKG1heF9zZXEgPD0gUkVBRF9PTkNF KG1tX3N0YXRlLT5zZXEpKQo+ICsJCXJldHVybiBmYWxzZTsKPiArCj4gKwlzcGluX2xvY2soJm1t X2xpc3QtPmxvY2spOwo+ICsKPiArCVZNX0JVR19PTihtbV9zdGF0ZS0+c2VxICsgMSA8IG1heF9z ZXEpOwo+ICsKPiArCWlmIChtYXhfc2VxID4gbW1fc3RhdGUtPnNlcSAmJiAhbW1fc3RhdGUtPm5y X3dhbGtlcnMpIHsKPiArCQlWTV9CVUdfT04obW1fc3RhdGUtPmhlYWQgJiYgbW1fc3RhdGUtPmhl YWQgIT0gJm1tX2xpc3QtPmZpZm8pOwo+ICsKPiArCQlXUklURV9PTkNFKG1tX3N0YXRlLT5zZXEs IG1tX3N0YXRlLT5zZXEgKyAxKTsKPiArCQlyZXNldF9tbV9zdGF0cyhscnV2ZWMsIE5VTEwsIHRy dWUpOwo+ICsJCXN1Y2Nlc3MgPSB0cnVlOwo+ICsJfQo+ICsKPiArCXNwaW5fdW5sb2NrKCZtbV9s aXN0LT5sb2NrKTsKPiArCj4gKwlyZXR1cm4gc3VjY2VzczsKPiArfQo+ICsKPiAgIC8qKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioKPiAgICAqICAgICAgICAgICAgICAgICAgICAgICAgICByZWZhdWx0IGZl ZWRiYWNrIGxvb3AKPiAgICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCj4gQEAgLTMyMTQsNiArMzU4 NCw0NzYgQEAgc3RhdGljIGludCBmb2xpb19pbmNfZ2VuKHN0cnVjdCBscnV2ZWMgKmxydXZlYywg c3RydWN0IGZvbGlvICpmb2xpbywgYm9vbCByZWNsYWkKPiAgIAlyZXR1cm4gbmV3X2dlbjsKPiAg IH0KPiAgIAo+ICtzdGF0aWMgdm9pZCB1cGRhdGVfYmF0Y2hfc2l6ZShzdHJ1Y3QgbHJ1X2dlbl9t bV93YWxrICp3YWxrLCBzdHJ1Y3QgZm9saW8gKmZvbGlvLAo+ICsJCQkgICAgICBpbnQgb2xkX2dl biwgaW50IG5ld19nZW4pCj4gK3sKPiArCWludCB0eXBlID0gZm9saW9faXNfZmlsZV9scnUoZm9s aW8pOwo+ICsJaW50IHpvbmUgPSBmb2xpb196b25lbnVtKGZvbGlvKTsKPiArCWludCBkZWx0YSA9 IGZvbGlvX25yX3BhZ2VzKGZvbGlvKTsKPiArCj4gKwlWTV9CVUdfT04ob2xkX2dlbiA+PSBNQVhf TlJfR0VOUyk7Cj4gKwlWTV9CVUdfT04obmV3X2dlbiA+PSBNQVhfTlJfR0VOUyk7Cj4gKwo+ICsJ d2Fsay0+YmF0Y2hlZCsrOwo+ICsKPiArCXdhbGstPm5yX3BhZ2VzW29sZF9nZW5dW3R5cGVdW3pv bmVdIC09IGRlbHRhOwo+ICsJd2Fsay0+bnJfcGFnZXNbbmV3X2dlbl1bdHlwZV1bem9uZV0gKz0g ZGVsdGE7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHJlc2V0X2JhdGNoX3NpemUoc3RydWN0IGxy dXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgbHJ1X2dlbl9tbV93YWxrICp3YWxrKQo+ICt7Cj4gKwlpbnQg Z2VuLCB0eXBlLCB6b25lOwo+ICsJc3RydWN0IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAmbHJ1 dmVjLT5scnVnZW47Cj4gKwo+ICsJd2Fsay0+YmF0Y2hlZCA9IDA7Cj4gKwo+ICsJZm9yX2VhY2hf Z2VuX3R5cGVfem9uZShnZW4sIHR5cGUsIHpvbmUpIHsKPiArCQllbnVtIGxydV9saXN0IGxydSA9 IHR5cGUgKiBMUlVfSU5BQ1RJVkVfRklMRTsKPiArCQlpbnQgZGVsdGEgPSB3YWxrLT5ucl9wYWdl c1tnZW5dW3R5cGVdW3pvbmVdOwo+ICsKPiArCQlpZiAoIWRlbHRhKQo+ICsJCQljb250aW51ZTsK PiArCj4gKwkJd2Fsay0+bnJfcGFnZXNbZ2VuXVt0eXBlXVt6b25lXSA9IDA7Cj4gKwkJV1JJVEVf T05DRShscnVnZW4tPm5yX3BhZ2VzW2dlbl1bdHlwZV1bem9uZV0sCj4gKwkJCSAgIGxydWdlbi0+ bnJfcGFnZXNbZ2VuXVt0eXBlXVt6b25lXSArIGRlbHRhKTsKPiArCj4gKwkJaWYgKGxydV9nZW5f aXNfYWN0aXZlKGxydXZlYywgZ2VuKSkKPiArCQkJbHJ1ICs9IExSVV9BQ1RJVkU7Cj4gKwkJX191 cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIHpvbmUsIGRlbHRhKTsKPiArCX0KPiArfQo+ICsK PiArc3RhdGljIGludCBzaG91bGRfc2tpcF92bWEodW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWdu ZWQgbG9uZyBlbmQsIHN0cnVjdCBtbV93YWxrICp3YWxrKQo+ICt7Cj4gKwlzdHJ1Y3QgYWRkcmVz c19zcGFjZSAqbWFwcGluZzsKPiArCXN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hID0gd2Fsay0+ dm1hOwo+ICsJc3RydWN0IGxydV9nZW5fbW1fd2FsayAqcHJpdiA9IHdhbGstPnByaXZhdGU7Cj4g Kwo+ICsJaWYgKCF2bWFfaXNfYWNjZXNzaWJsZSh2bWEpIHx8IGlzX3ZtX2h1Z2V0bGJfcGFnZSh2 bWEpIHx8Cj4gKwkgICAgKHZtYS0+dm1fZmxhZ3MgJiAoVk1fTE9DS0VEIHwgVk1fU1BFQ0lBTCB8 IFZNX1NFUV9SRUFEIHwgVk1fUkFORF9SRUFEKSkgfHwKPiArCSAgICB2bWEgPT0gZ2V0X2dhdGVf dm1hKHZtYS0+dm1fbW0pKQo+ICsJCXJldHVybiB0cnVlOwo+ICsKPiArCWlmICh2bWFfaXNfYW5v bnltb3VzKHZtYSkpCj4gKwkJcmV0dXJuICFwcml2LT5jYW5fc3dhcDsKPiArCj4gKwlpZiAoV0FS Tl9PTl9PTkNFKCF2bWEtPnZtX2ZpbGUgfHwgIXZtYS0+dm1fZmlsZS0+Zl9tYXBwaW5nKSkKPiAr CQlyZXR1cm4gdHJ1ZTsKPiArCj4gKwltYXBwaW5nID0gdm1hLT52bV9maWxlLT5mX21hcHBpbmc7 Cj4gKwlpZiAobWFwcGluZ191bmV2aWN0YWJsZShtYXBwaW5nKSkKPiArCQlyZXR1cm4gdHJ1ZTsK PiArCj4gKwkvKiBjaGVjayByZWFkcGFnZSB0byBleGNsdWRlIHNwZWNpYWwgbWFwcGluZ3MgbGlr ZSBkYXgsIGV0Yy4gKi8KPiArCXJldHVybiBzaG1lbV9tYXBwaW5nKG1hcHBpbmcpID8gIXByaXYt PmNhbl9zd2FwIDogIW1hcHBpbmctPmFfb3BzLT5yZWFkcGFnZTsKPiArfQo+ICsKPiArLyoKPiAr ICogU29tZSB1c2Vyc3BhY2UgbWVtb3J5IGFsbG9jYXRvcnMgbWFwIG1hbnkgc2luZ2xlLXBhZ2Ug Vk1Bcy4gSW5zdGVhZCBvZgo+ICsgKiByZXR1cm5pbmcgYmFjayB0byB0aGUgUEdEIHRhYmxlIGZv ciBlYWNoIG9mIHN1Y2ggVk1BcywgZmluaXNoIGFuIGVudGlyZSBQTUQKPiArICogdGFibGUgdG8g cmVkdWNlIHppZ3phZ3MgYW5kIGltcHJvdmUgY2FjaGUgcGVyZm9ybWFuY2UuCj4gKyAqLwo+ICtz dGF0aWMgYm9vbCBnZXRfbmV4dF92bWEoc3RydWN0IG1tX3dhbGsgKndhbGssIHVuc2lnbmVkIGxv bmcgbWFzaywgdW5zaWduZWQgbG9uZyBzaXplLAo+ICsJCQkgdW5zaWduZWQgbG9uZyAqc3RhcnQs IHVuc2lnbmVkIGxvbmcgKmVuZCkKPiArewo+ICsJdW5zaWduZWQgbG9uZyBuZXh0ID0gcm91bmRf dXAoKmVuZCwgc2l6ZSk7Cj4gKwo+ICsJVk1fQlVHX09OKG1hc2sgJiBzaXplKTsKPiArCVZNX0JV R19PTigqc3RhcnQgPj0gKmVuZCk7Cj4gKwlWTV9CVUdfT04oKG5leHQgJiBtYXNrKSAhPSAoKnN0 YXJ0ICYgbWFzaykpOwo+ICsKPiArCXdoaWxlICh3YWxrLT52bWEpIHsKPiArCQlpZiAobmV4dCA+ PSB3YWxrLT52bWEtPnZtX2VuZCkgewo+ICsJCQl3YWxrLT52bWEgPSB3YWxrLT52bWEtPnZtX25l eHQ7Cj4gKwkJCWNvbnRpbnVlOwo+ICsJCX0KPiArCj4gKwkJaWYgKChuZXh0ICYgbWFzaykgIT0g KHdhbGstPnZtYS0+dm1fc3RhcnQgJiBtYXNrKSkKPiArCQkJcmV0dXJuIGZhbHNlOwo+ICsKPiAr CQlpZiAoc2hvdWxkX3NraXBfdm1hKHdhbGstPnZtYS0+dm1fc3RhcnQsIHdhbGstPnZtYS0+dm1f ZW5kLCB3YWxrKSkgewo+ICsJCQl3YWxrLT52bWEgPSB3YWxrLT52bWEtPnZtX25leHQ7Cj4gKwkJ CWNvbnRpbnVlOwo+ICsJCX0KPiArCj4gKwkJKnN0YXJ0ID0gbWF4KG5leHQsIHdhbGstPnZtYS0+ dm1fc3RhcnQpOwo+ICsJCW5leHQgPSAobmV4dCB8IH5tYXNrKSArIDE7Cj4gKwkJLyogcm91bmRl ZC11cCBib3VuZGFyaWVzIGNhbiB3cmFwIHRvIDAgKi8KPiArCQkqZW5kID0gbmV4dCAmJiBuZXh0 IDwgd2Fsay0+dm1hLT52bV9lbmQgPyBuZXh0IDogd2Fsay0+dm1hLT52bV9lbmQ7Cj4gKwo+ICsJ CXJldHVybiB0cnVlOwo+ICsJfQo+ICsKPiArCXJldHVybiBmYWxzZTsKPiArfQo+ICsKPiArc3Rh dGljIGJvb2wgc3VpdGFibGVfdG9fc2NhbihpbnQgdG90YWwsIGludCB5b3VuZykKPiArewo+ICsJ aW50IG4gPSBjbGFtcF90KGludCwgY2FjaGVfbGluZV9zaXplKCkgLyBzaXplb2YocHRlX3QpLCAy LCA4KTsKPiArCj4gKwkvKiBzdWl0YWJsZSBpZiB0aGUgYXZlcmFnZSBudW1iZXIgb2YgeW91bmcg UFRFcyBwZXIgY2FjaGVsaW5lIGlzID49MSAqLwo+ICsJcmV0dXJuIHlvdW5nICogbiA+PSB0b3Rh bDsKPiArfQo+ICsKPiArc3RhdGljIGJvb2wgd2Fsa19wdGVfcmFuZ2UocG1kX3QgKnBtZCwgdW5z aWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCj4gKwkJCSAgIHN0cnVjdCBtbV93 YWxrICp3YWxrKQo+ICt7Cj4gKwlpbnQgaTsKPiArCXB0ZV90ICpwdGU7Cj4gKwlzcGlubG9ja190 ICpwdGw7Cj4gKwl1bnNpZ25lZCBsb25nIGFkZHI7Cj4gKwlpbnQgdG90YWwgPSAwOwo+ICsJaW50 IHlvdW5nID0gMDsKPiArCXN0cnVjdCBscnVfZ2VuX21tX3dhbGsgKnByaXYgPSB3YWxrLT5wcml2 YXRlOwo+ICsJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0gbHJ1dmVjX21lbWNnKHByaXYtPmxy dXZlYyk7Cj4gKwlzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0ID0gbHJ1dmVjX3BnZGF0KHByaXYt PmxydXZlYyk7Cj4gKwlpbnQgb2xkX2dlbiwgbmV3X2dlbiA9IGxydV9nZW5fZnJvbV9zZXEocHJp di0+bWF4X3NlcSk7Cj4gKwo+ICsJVk1fQlVHX09OKHBtZF9sZWFmKCpwbWQpKTsKPiArCj4gKwlw dGwgPSBwdGVfbG9ja3B0cih3YWxrLT5tbSwgcG1kKTsKPiArCWlmICghc3Bpbl90cnlsb2NrKHB0 bCkpCj4gKwkJcmV0dXJuIGZhbHNlOwo+ICsKPiArCWFyY2hfZW50ZXJfbGF6eV9tbXVfbW9kZSgp Owo+ICsKPiArCXB0ZSA9IHB0ZV9vZmZzZXRfbWFwKHBtZCwgc3RhcnQgJiBQTURfTUFTSyk7Cj4g K3Jlc3RhcnQ6Cj4gKwlmb3IgKGkgPSBwdGVfaW5kZXgoc3RhcnQpLCBhZGRyID0gc3RhcnQ7IGFk ZHIgIT0gZW5kOyBpKyssIGFkZHIgKz0gUEFHRV9TSVpFKSB7Cj4gKwkJc3RydWN0IGZvbGlvICpm b2xpbzsKPiArCQl1bnNpZ25lZCBsb25nIHBmbiA9IHB0ZV9wZm4ocHRlW2ldKTsKPiArCj4gKwkJ Vk1fQlVHX09OKGFkZHIgPCB3YWxrLT52bWEtPnZtX3N0YXJ0IHx8IGFkZHIgPj0gd2Fsay0+dm1h LT52bV9lbmQpOwo+ICsKPiArCQl0b3RhbCsrOwo+ICsJCXByaXYtPm1tX3N0YXRzW01NX1BURV9U T1RBTF0rKzsKPiArCj4gKwkJaWYgKCFwdGVfcHJlc2VudChwdGVbaV0pIHx8IGlzX3plcm9fcGZu KHBmbikpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlpZiAoV0FSTl9PTl9PTkNFKHB0ZV9kZXZt YXAocHRlW2ldKSB8fCBwdGVfc3BlY2lhbChwdGVbaV0pKSkKPiArCQkJY29udGludWU7Cj4gKwo+ ICsJCWlmICghcHRlX3lvdW5nKHB0ZVtpXSkpIHsKPiArCQkJcHJpdi0+bW1fc3RhdHNbTU1fUFRF X09MRF0rKzsKPiArCQkJY29udGludWU7Cj4gKwkJfQo+ICsKPiArCQlWTV9CVUdfT04oIXBmbl92 YWxpZChwZm4pKTsKPiArCQlpZiAocGZuIDwgcGdkYXQtPm5vZGVfc3RhcnRfcGZuIHx8IHBmbiA+ PSBwZ2RhdF9lbmRfcGZuKHBnZGF0KSkKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWZvbGlvID0g cGZuX2ZvbGlvKHBmbik7Cj4gKwkJaWYgKGZvbGlvX25pZChmb2xpbykgIT0gcGdkYXQtPm5vZGVf aWQpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlpZiAoZm9saW9fbWVtY2dfcmN1KGZvbGlvKSAh PSBtZW1jZykKPiArCQkJY29udGludWU7Cj4gKwo+ICsJCWlmICghcHRlcF90ZXN0X2FuZF9jbGVh cl95b3VuZyh3YWxrLT52bWEsIGFkZHIsIHB0ZSArIGkpKQo+ICsJCQljb250aW51ZTsKPiArCj4g KwkJeW91bmcrKzsKPiArCQlwcml2LT5tbV9zdGF0c1tNTV9QVEVfWU9VTkddKys7Cj4gKwo+ICsJ CWlmIChwdGVfZGlydHkocHRlW2ldKSAmJiAhZm9saW9fdGVzdF9kaXJ0eShmb2xpbykgJiYKPiAr CQkgICAgIShmb2xpb190ZXN0X2Fub24oZm9saW8pICYmIGZvbGlvX3Rlc3Rfc3dhcGJhY2tlZChm b2xpbykgJiYKPiArCQkgICAgICAhZm9saW9fdGVzdF9zd2FwY2FjaGUoZm9saW8pKSkKPiArCQkJ Zm9saW9fbWFya19kaXJ0eShmb2xpbyk7Cj4gKwo+ICsJCW9sZF9nZW4gPSBmb2xpb191cGRhdGVf Z2VuKGZvbGlvLCBuZXdfZ2VuKTsKPiArCQlpZiAob2xkX2dlbiA+PSAwICYmIG9sZF9nZW4gIT0g bmV3X2dlbikKPiArCQkJdXBkYXRlX2JhdGNoX3NpemUocHJpdiwgZm9saW8sIG9sZF9nZW4sIG5l d19nZW4pOwo+ICsJfQo+ICsKPiArCWlmIChpIDwgUFRSU19QRVJfUFRFICYmIGdldF9uZXh0X3Zt YSh3YWxrLCBQTURfTUFTSywgUEFHRV9TSVpFLCAmc3RhcnQsICZlbmQpKQo+ICsJCWdvdG8gcmVz dGFydDsKPiArCj4gKwlwdGVfdW5tYXAocHRlKTsKPiArCj4gKwlhcmNoX2xlYXZlX2xhenlfbW11 X21vZGUoKTsKPiArCXNwaW5fdW5sb2NrKHB0bCk7Cj4gKwo+ICsJcmV0dXJuIHN1aXRhYmxlX3Rv X3NjYW4odG90YWwsIHlvdW5nKTsKPiArfQo+ICsKPiArI2lmIGRlZmluZWQoQ09ORklHX1RSQU5T UEFSRU5UX0hVR0VQQUdFKSB8fCBkZWZpbmVkKENPTkZJR19BUkNIX0hBU19OT05MRUFGX1BNRF9Z T1VORykKPiArc3RhdGljIHZvaWQgd2Fsa19wbWRfcmFuZ2VfbG9ja2VkKHB1ZF90ICpwdWQsIHVu c2lnbmVkIGxvbmcgbmV4dCwgc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gKwkJCQkgIHN0 cnVjdCBtbV93YWxrICp3YWxrLCB1bnNpZ25lZCBsb25nICpzdGFydCkKPiArewo+ICsJaW50IGk7 Cj4gKwlwbWRfdCAqcG1kOwo+ICsJc3BpbmxvY2tfdCAqcHRsOwo+ICsJc3RydWN0IGxydV9nZW5f bW1fd2FsayAqcHJpdiA9IHdhbGstPnByaXZhdGU7Cj4gKwlzdHJ1Y3QgbWVtX2Nncm91cCAqbWVt Y2cgPSBscnV2ZWNfbWVtY2cocHJpdi0+bHJ1dmVjKTsKPiArCXN0cnVjdCBwZ2xpc3RfZGF0YSAq cGdkYXQgPSBscnV2ZWNfcGdkYXQocHJpdi0+bHJ1dmVjKTsKPiArCWludCBvbGRfZ2VuLCBuZXdf Z2VuID0gbHJ1X2dlbl9mcm9tX3NlcShwcml2LT5tYXhfc2VxKTsKPiArCj4gKwlWTV9CVUdfT04o cHVkX2xlYWYoKnB1ZCkpOwo+ICsKPiArCS8qIHRyeSB0byBiYXRjaCBhdCBtb3N0IDErTUlOX0xS VV9CQVRDSCsxIGVudHJpZXMgKi8KPiArCWlmICgqc3RhcnQgPT0gLTEpIHsKPiArCQkqc3RhcnQg PSBuZXh0Owo+ICsJCXJldHVybjsKPiArCX0KPiArCj4gKwlpID0gbmV4dCA9PSAtMSA/IDAgOiBw bWRfaW5kZXgobmV4dCkgLSBwbWRfaW5kZXgoKnN0YXJ0KTsKPiArCWlmIChpICYmIGkgPD0gTUlO X0xSVV9CQVRDSCkgewo+ICsJCV9fc2V0X2JpdChpIC0gMSwgcHJpdi0+Yml0bWFwKTsKPiArCQly ZXR1cm47Cj4gKwl9Cj4gKwo+ICsJcG1kID0gcG1kX29mZnNldChwdWQsICpzdGFydCk7Cj4gKwo+ ICsJcHRsID0gcG1kX2xvY2twdHIod2Fsay0+bW0sIHBtZCk7Cj4gKwlpZiAoIXNwaW5fdHJ5bG9j ayhwdGwpKQo+ICsJCWdvdG8gZG9uZTsKPiArCj4gKwlhcmNoX2VudGVyX2xhenlfbW11X21vZGUo KTsKPiArCj4gKwlkbyB7Cj4gKwkJc3RydWN0IGZvbGlvICpmb2xpbzsKPiArCQl1bnNpZ25lZCBs b25nIHBmbiA9IHBtZF9wZm4ocG1kW2ldKTsKPiArCQl1bnNpZ25lZCBsb25nIGFkZHIgPSBpID8g KCpzdGFydCAmIFBNRF9NQVNLKSArIGkgKiBQTURfU0laRSA6ICpzdGFydDsKPiArCj4gKwkJVk1f QlVHX09OKGFkZHIgPCB2bWEtPnZtX3N0YXJ0IHx8IGFkZHIgPj0gdm1hLT52bV9lbmQpOwo+ICsK PiArCQlpZiAoIXBtZF9wcmVzZW50KHBtZFtpXSkgfHwgaXNfaHVnZV96ZXJvX3BtZChwbWRbaV0p KQo+ICsJCQlnb3RvIG5leHQ7Cj4gKwo+ICsJCWlmIChXQVJOX09OX09OQ0UocG1kX2Rldm1hcChw bWRbaV0pKSkKPiArCQkJZ290byBuZXh0Owo+ICsKPiArCQlpZiAoIXBtZF90cmFuc19odWdlKHBt ZFtpXSkpIHsKPiArCQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX0FSQ0hfSEFTX05PTkxFQUZfUE1E X1lPVU5HKSkKPiArCQkJCXBtZHBfdGVzdF9hbmRfY2xlYXJfeW91bmcodm1hLCBhZGRyLCBwbWQg KyBpKTsKPiArCQkJZ290byBuZXh0Owo+ICsJCX0KPiArCj4gKwkJVk1fQlVHX09OKCFwZm5fdmFs aWQocGZuKSk7Cj4gKwkJaWYgKHBmbiA8IHBnZGF0LT5ub2RlX3N0YXJ0X3BmbiB8fCBwZm4gPj0g cGdkYXRfZW5kX3BmbihwZ2RhdCkpCj4gKwkJCWdvdG8gbmV4dDsKPiArCj4gKwkJZm9saW8gPSBw Zm5fZm9saW8ocGZuKTsKPiArCQlpZiAoZm9saW9fbmlkKGZvbGlvKSAhPSBwZ2RhdC0+bm9kZV9p ZCkKPiArCQkJZ290byBuZXh0Owo+ICsKPiArCQlpZiAoZm9saW9fbWVtY2dfcmN1KGZvbGlvKSAh PSBtZW1jZykKPiArCQkJZ290byBuZXh0Owo+ICsKPiArCQlpZiAoIXBtZHBfdGVzdF9hbmRfY2xl YXJfeW91bmcodm1hLCBhZGRyLCBwbWQgKyBpKSkKPiArCQkJZ290byBuZXh0Owo+ICsKPiArCQlw cml2LT5tbV9zdGF0c1tNTV9QVEVfWU9VTkddKys7Cj4gKwo+ICsJCWlmIChwbWRfZGlydHkocG1k W2ldKSAmJiAhZm9saW9fdGVzdF9kaXJ0eShmb2xpbykgJiYKPiArCQkgICAgIShmb2xpb190ZXN0 X2Fub24oZm9saW8pICYmIGZvbGlvX3Rlc3Rfc3dhcGJhY2tlZChmb2xpbykgJiYKPiArCQkgICAg ICAhZm9saW9fdGVzdF9zd2FwY2FjaGUoZm9saW8pKSkKPiArCQkJZm9saW9fbWFya19kaXJ0eShm b2xpbyk7Cj4gKwo+ICsJCW9sZF9nZW4gPSBmb2xpb191cGRhdGVfZ2VuKGZvbGlvLCBuZXdfZ2Vu KTsKPiArCQlpZiAob2xkX2dlbiA+PSAwICYmIG9sZF9nZW4gIT0gbmV3X2dlbikKPiArCQkJdXBk YXRlX2JhdGNoX3NpemUocHJpdiwgZm9saW8sIG9sZF9nZW4sIG5ld19nZW4pOwo+ICtuZXh0Ogo+ ICsJCWkgPSBpID4gTUlOX0xSVV9CQVRDSCA/IDAgOgo+ICsJCSAgICBmaW5kX25leHRfYml0KHBy aXYtPmJpdG1hcCwgTUlOX0xSVV9CQVRDSCwgaSkgKyAxOwo+ICsJfSB3aGlsZSAoaSA8PSBNSU5f TFJVX0JBVENIKTsKPiArCj4gKwlhcmNoX2xlYXZlX2xhenlfbW11X21vZGUoKTsKPiArCXNwaW5f dW5sb2NrKHB0bCk7Cj4gK2RvbmU6Cj4gKwkqc3RhcnQgPSAtMTsKPiArCWJpdG1hcF96ZXJvKHBy aXYtPmJpdG1hcCwgTUlOX0xSVV9CQVRDSCk7Cj4gK30KPiArI2Vsc2UKPiArc3RhdGljIHZvaWQg d2Fsa19wbWRfcmFuZ2VfbG9ja2VkKHB1ZF90ICpwdWQsIHVuc2lnbmVkIGxvbmcgbmV4dCwgc3Ry dWN0IHZtX2FyZWFfc3RydWN0ICp2bWEsCj4gKwkJCQkgIHN0cnVjdCBtbV93YWxrICp3YWxrLCB1 bnNpZ25lZCBsb25nICpzdGFydCkKPiArewo+ICt9Cj4gKyNlbmRpZgo+ICsKPiArc3RhdGljIHZv aWQgd2Fsa19wbWRfcmFuZ2UocHVkX3QgKnB1ZCwgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWdu ZWQgbG9uZyBlbmQsCj4gKwkJCSAgIHN0cnVjdCBtbV93YWxrICp3YWxrKQo+ICt7Cj4gKwlpbnQg aTsKPiArCXBtZF90ICpwbWQ7Cj4gKwl1bnNpZ25lZCBsb25nIG5leHQ7Cj4gKwl1bnNpZ25lZCBs b25nIGFkZHI7Cj4gKwlzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYTsKPiArCXVuc2lnbmVkIGxv bmcgcG9zID0gLTE7Cj4gKwlzdHJ1Y3QgbHJ1X2dlbl9tbV93YWxrICpwcml2ID0gd2Fsay0+cHJp dmF0ZTsKPiArCj4gKwlWTV9CVUdfT04ocHVkX2xlYWYoKnB1ZCkpOwo+ICsKPiArCS8qCj4gKwkg KiBGaW5pc2ggYW4gZW50aXJlIFBNRCBpbiB0d28gcGFzc2VzOiB0aGUgZmlyc3Qgb25seSByZWFj aGVzIHRvIFBURQo+ICsJICogdGFibGVzIHRvIGF2b2lkIHRha2luZyB0aGUgUE1EIGxvY2s7IHRo ZSBzZWNvbmQsIGlmIG5lY2Vzc2FyeSwgdGFrZXMKPiArCSAqIHRoZSBQTUQgbG9jayB0byBjbGVh ciB0aGUgYWNjZXNzZWQgYml0IGluIFBNRCBlbnRyaWVzLgo+ICsJICovCj4gKwlwbWQgPSBwbWRf b2Zmc2V0KHB1ZCwgc3RhcnQgJiBQVURfTUFTSyk7Cj4gK3Jlc3RhcnQ6Cj4gKwkvKiB3YWxrX3B0 ZV9yYW5nZSgpIG1heSBjYWxsIGdldF9uZXh0X3ZtYSgpICovCj4gKwl2bWEgPSB3YWxrLT52bWE7 Cj4gKwlmb3IgKGkgPSBwbWRfaW5kZXgoc3RhcnQpLCBhZGRyID0gc3RhcnQ7IGFkZHIgIT0gZW5k OyBpKyssIGFkZHIgPSBuZXh0KSB7Cj4gKwkJcG1kX3QgdmFsID0gcG1kX3JlYWRfYXRvbWljKHBt ZCArIGkpOwo+ICsKPiArCQkvKiBmb3IgcG1kX3JlYWRfYXRvbWljKCkgKi8KPiArCQliYXJyaWVy KCk7Cj4gKwo+ICsJCW5leHQgPSBwbWRfYWRkcl9lbmQoYWRkciwgZW5kKTsKPiArCj4gKwkJaWYg KCFwbWRfcHJlc2VudCh2YWwpKSB7Cj4gKwkJCXByaXYtPm1tX3N0YXRzW01NX1BURV9UT1RBTF0r KzsKPiArCQkJY29udGludWU7Cj4gKwkJfQo+ICsKPiArI2lmZGVmIENPTkZJR19UUkFOU1BBUkVO VF9IVUdFUEFHRQo+ICsJCWlmIChwbWRfdHJhbnNfaHVnZSh2YWwpKSB7Cj4gKwkJCXVuc2lnbmVk IGxvbmcgcGZuID0gcG1kX3Bmbih2YWwpOwo+ICsJCQlzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0 ID0gbHJ1dmVjX3BnZGF0KHByaXYtPmxydXZlYyk7Cj4gKwo+ICsJCQlwcml2LT5tbV9zdGF0c1tN TV9QVEVfVE9UQUxdKys7Cj4gKwo+ICsJCQlpZiAoaXNfaHVnZV96ZXJvX3BtZCh2YWwpKQo+ICsJ CQkJY29udGludWU7Cj4gKwo+ICsJCQlpZiAoIXBtZF95b3VuZyh2YWwpKSB7Cj4gKwkJCQlwcml2 LT5tbV9zdGF0c1tNTV9QVEVfT0xEXSsrOwo+ICsJCQkJY29udGludWU7Cj4gKwkJCX0KPiArCj4g KwkJCWlmIChwZm4gPCBwZ2RhdC0+bm9kZV9zdGFydF9wZm4gfHwgcGZuID49IHBnZGF0X2VuZF9w Zm4ocGdkYXQpKQo+ICsJCQkJY29udGludWU7Cj4gKwo+ICsJCQl3YWxrX3BtZF9yYW5nZV9sb2Nr ZWQocHVkLCBhZGRyLCB2bWEsIHdhbGssICZwb3MpOwo+ICsJCQljb250aW51ZTsKPiArCQl9Cj4g KyNlbmRpZgo+ICsJCXByaXYtPm1tX3N0YXRzW01NX1BNRF9UT1RBTF0rKzsKPiArCj4gKyNpZmRl ZiBDT05GSUdfQVJDSF9IQVNfTk9OTEVBRl9QTURfWU9VTkcKPiArCQlpZiAoIXBtZF95b3VuZyh2 YWwpKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJd2Fsa19wbWRfcmFuZ2VfbG9ja2VkKHB1ZCwg YWRkciwgdm1hLCB3YWxrLCAmcG9zKTsKPiArI2VuZGlmCj4gKwkJaWYgKCFwcml2LT5mdWxsX3Nj YW4gJiYgIXRlc3RfYmxvb21fZmlsdGVyKHByaXYtPmxydXZlYywgcHJpdi0+bWF4X3NlcSwgcG1k ICsgaSkpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlwcml2LT5tbV9zdGF0c1tNTV9QTURfRk9V TkRdKys7Cj4gKwo+ICsJCWlmICghd2Fsa19wdGVfcmFuZ2UoJnZhbCwgYWRkciwgbmV4dCwgd2Fs aykpCj4gKwkJCWNvbnRpbnVlOwo+ICsKPiArCQlwcml2LT5tbV9zdGF0c1tNTV9QTURfQURERURd Kys7Cj4gKwo+ICsJCS8qIGNhcnJ5IG92ZXIgdG8gdGhlIG5leHQgZ2VuZXJhdGlvbiAqLwo+ICsJ CXVwZGF0ZV9ibG9vbV9maWx0ZXIocHJpdi0+bHJ1dmVjLCBwcml2LT5tYXhfc2VxICsgMSwgcG1k ICsgaSk7Cj4gKwl9Cj4gKwo+ICsJd2Fsa19wbWRfcmFuZ2VfbG9ja2VkKHB1ZCwgLTEsIHZtYSwg d2FsaywgJnBvcyk7Cj4gKwo+ICsJaWYgKGkgPCBQVFJTX1BFUl9QTUQgJiYgZ2V0X25leHRfdm1h KHdhbGssIFBVRF9NQVNLLCBQTURfU0laRSwgJnN0YXJ0LCAmZW5kKSkKPiArCQlnb3RvIHJlc3Rh cnQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgd2Fsa19wdWRfcmFuZ2UocDRkX3QgKnA0ZCwgdW5z aWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCj4gKwkJCSAgc3RydWN0IG1tX3dh bGsgKndhbGspCj4gK3sKPiArCWludCBpOwo+ICsJcHVkX3QgKnB1ZDsKPiArCXVuc2lnbmVkIGxv bmcgYWRkcjsKPiArCXVuc2lnbmVkIGxvbmcgbmV4dDsKPiArCXN0cnVjdCBscnVfZ2VuX21tX3dh bGsgKnByaXYgPSB3YWxrLT5wcml2YXRlOwo+ICsKPiArCVZNX0JVR19PTihwNGRfbGVhZigqcDRk KSk7Cj4gKwo+ICsJcHVkID0gcHVkX29mZnNldChwNGQsIHN0YXJ0ICYgUDREX01BU0spOwo+ICty ZXN0YXJ0Ogo+ICsJZm9yIChpID0gcHVkX2luZGV4KHN0YXJ0KSwgYWRkciA9IHN0YXJ0OyBhZGRy ICE9IGVuZDsgaSsrLCBhZGRyID0gbmV4dCkgewo+ICsJCXB1ZF90IHZhbCA9IFJFQURfT05DRShw dWRbaV0pOwo+ICsKPiArCQluZXh0ID0gcHVkX2FkZHJfZW5kKGFkZHIsIGVuZCk7Cj4gKwo+ICsJ CWlmICghcHVkX3ByZXNlbnQodmFsKSB8fCBXQVJOX09OX09OQ0UocHVkX2xlYWYodmFsKSkpCj4g KwkJCWNvbnRpbnVlOwo+ICsKPiArCQl3YWxrX3BtZF9yYW5nZSgmdmFsLCBhZGRyLCBuZXh0LCB3 YWxrKTsKPiArCj4gKwkJaWYgKHByaXYtPmJhdGNoZWQgPj0gTUFYX0xSVV9CQVRDSCkgewo+ICsJ CQllbmQgPSAoYWRkciB8IH5QVURfTUFTSykgKyAxOwo+ICsJCQlnb3RvIGRvbmU7Cj4gKwkJfQo+ ICsJfQo+ICsKPiArCWlmIChpIDwgUFRSU19QRVJfUFVEICYmIGdldF9uZXh0X3ZtYSh3YWxrLCBQ NERfTUFTSywgUFVEX1NJWkUsICZzdGFydCwgJmVuZCkpCj4gKwkJZ290byByZXN0YXJ0Owo+ICsK PiArCWVuZCA9IHJvdW5kX3VwKGVuZCwgUDREX1NJWkUpOwo+ICtkb25lOgo+ICsJLyogcm91bmRl ZC11cCBib3VuZGFyaWVzIGNhbiB3cmFwIHRvIDAgKi8KPiArCXByaXYtPm5leHRfYWRkciA9IGVu ZCAmJiB3YWxrLT52bWEgPyBtYXgoZW5kLCB3YWxrLT52bWEtPnZtX3N0YXJ0KSA6IDA7Cj4gKwo+ ICsJcmV0dXJuIC1FQUdBSU47Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lkIHdhbGtfbW0oc3RydWN0 IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgbW1fc3RydWN0ICptbSwgc3RydWN0IGxydV9nZW5fbW1f d2FsayAqd2FsaykKPiArewo+ICsJc3RhdGljIGNvbnN0IHN0cnVjdCBtbV93YWxrX29wcyBtbV93 YWxrX29wcyA9IHsKPiArCQkudGVzdF93YWxrID0gc2hvdWxkX3NraXBfdm1hLAo+ICsJCS5wNGRf ZW50cnkgPSB3YWxrX3B1ZF9yYW5nZSwKPiArCX07Cj4gKwo+ICsJaW50IGVycjsKPiArCXN0cnVj dCBtZW1fY2dyb3VwICptZW1jZyA9IGxydXZlY19tZW1jZyhscnV2ZWMpOwo+ICsKPiArCXdhbGst Pm5leHRfYWRkciA9IEZJUlNUX1VTRVJfQUREUkVTUzsKPiArCj4gKwlkbyB7Cj4gKwkJZXJyID0g LUVCVVNZOwo+ICsKPiArCQkvKiBmb2xpb191cGRhdGVfZ2VuKCkgcmVxdWlyZXMgc3RhYmxlIGZv bGlvX21lbWNnKCkgKi8KPiArCQlpZiAoIW1lbV9jZ3JvdXBfdHJ5bG9ja19wYWdlcyhtZW1jZykp Cj4gKwkJCWJyZWFrOwo+ICsKPiArCQkvKiB0aGUgY2FsbGVyIG1pZ2h0IGJlIGhvbGRpbmcgdGhl IGxvY2sgZm9yIHdyaXRlICovCj4gKwkJaWYgKG1tYXBfcmVhZF90cnlsb2NrKG1tKSkgewo+ICsJ CQl1bnNpZ25lZCBsb25nIHN0YXJ0ID0gd2Fsay0+bmV4dF9hZGRyOwo+ICsJCQl1bnNpZ25lZCBs b25nIGVuZCA9IG1tLT5oaWdoZXN0X3ZtX2VuZDsKPiArCj4gKwkJCWVyciA9IHdhbGtfcGFnZV9y YW5nZShtbSwgc3RhcnQsIGVuZCwgJm1tX3dhbGtfb3BzLCB3YWxrKTsKPiArCj4gKwkJCW1tYXBf cmVhZF91bmxvY2sobW0pOwo+ICsKPiArCQkJaWYgKHdhbGstPmJhdGNoZWQpIHsKPiArCQkJCXNw aW5fbG9ja19pcnEoJmxydXZlYy0+bHJ1X2xvY2spOwo+ICsJCQkJcmVzZXRfYmF0Y2hfc2l6ZShs cnV2ZWMsIHdhbGspOwo+ICsJCQkJc3Bpbl91bmxvY2tfaXJxKCZscnV2ZWMtPmxydV9sb2NrKTsK PiArCQkJfQo+ICsJCX0KPiArCj4gKwkJbWVtX2Nncm91cF91bmxvY2tfcGFnZXMoKTsKPiArCj4g KwkJY29uZF9yZXNjaGVkKCk7Cj4gKwl9IHdoaWxlIChlcnIgPT0gLUVBR0FJTiAmJiB3YWxrLT5u ZXh0X2FkZHIgJiYgIW1tX2lzX29vbV92aWN0aW0obW0pKTsKPiArfQo+ICsKPiArc3RhdGljIHN0 cnVjdCBscnVfZ2VuX21tX3dhbGsgKmFsbG9jX21tX3dhbGsodm9pZCkKPiArewo+ICsJaWYgKGN1 cnJlbnQtPnJlY2xhaW1fc3RhdGUgJiYgY3VycmVudC0+cmVjbGFpbV9zdGF0ZS0+bW1fd2FsaykK PiArCQlyZXR1cm4gY3VycmVudC0+cmVjbGFpbV9zdGF0ZS0+bW1fd2FsazsKPiArCj4gKwlyZXR1 cm4ga3phbGxvYyhzaXplb2Yoc3RydWN0IGxydV9nZW5fbW1fd2FsayksCj4gKwkJICAgICAgIF9f R0ZQX0hJR0ggfCBfX0dGUF9OT01FTUFMTE9DIHwgX19HRlBfTk9XQVJOKTsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgZnJlZV9tbV93YWxrKHN0cnVjdCBscnVfZ2VuX21tX3dhbGsgKndhbGspCj4g K3sKPiArCWlmICghY3VycmVudC0+cmVjbGFpbV9zdGF0ZSB8fCAhY3VycmVudC0+cmVjbGFpbV9z dGF0ZS0+bW1fd2FsaykKPiArCQlrZnJlZSh3YWxrKTsKPiArfQo+ICsKPiAgIHN0YXRpYyB2b2lk IGluY19taW5fc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYykKPiAgIHsKPiAgIAlpbnQgdHlwZTsK PiBAQCAtMzI3Miw3ICs0MTEyLDcgQEAgc3RhdGljIGJvb2wgdHJ5X3RvX2luY19taW5fc2VxKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgYm9vbCBjYW5fc3dhcCkKPiAgIAlyZXR1cm4gc3VjY2VzczsK PiAgIH0KPiAgIAo+IC1zdGF0aWMgdm9pZCBpbmNfbWF4X3NlcShzdHJ1Y3QgbHJ1dmVjICpscnV2 ZWMsIHVuc2lnbmVkIGxvbmcgbWF4X3NlcSkKPiArc3RhdGljIHZvaWQgaW5jX21heF9zZXEoc3Ry dWN0IGxydXZlYyAqbHJ1dmVjKQo+ICAgewo+ICAgCWludCBwcmV2LCBuZXh0Owo+ICAgCWludCB0 eXBlLCB6b25lOwo+IEBAIC0zMjgyLDkgKzQxMjIsNiBAQCBzdGF0aWMgdm9pZCBpbmNfbWF4X3Nl cShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHVuc2lnbmVkIGxvbmcgbWF4X3NlcSkKPiAgIAo+ICAg CVZNX0JVR19PTighc2VxX2lzX3ZhbGlkKGxydXZlYykpOwo+ICAgCj4gLQlpZiAobWF4X3NlcSAh PSBscnVnZW4tPm1heF9zZXEpCj4gLQkJZ290byB1bmxvY2s7Cj4gLQo+ICAgCWluY19taW5fc2Vx KGxydXZlYyk7Cj4gICAKPiAgIAkvKgo+IEBAIC0zMzE2LDEwICs0MTUzLDcyIEBAIHN0YXRpYyB2 b2lkIGluY19tYXhfc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhf c2VxKQo+ICAgCj4gICAJLyogbWFrZSBzdXJlIHByZWNlZGluZyBtb2RpZmljYXRpb25zIGFwcGVh ciAqLwo+ICAgCXNtcF9zdG9yZV9yZWxlYXNlKCZscnVnZW4tPm1heF9zZXEsIGxydWdlbi0+bWF4 X3NlcSArIDEpOwo+IC11bmxvY2s6Cj4gKwo+ICAgCXNwaW5fdW5sb2NrX2lycSgmbHJ1dmVjLT5s cnVfbG9jayk7Cj4gICB9Cj4gICAKPiArc3RhdGljIGJvb2wgdHJ5X3RvX2luY19tYXhfc2VxKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhfc2VxLAo+ICsJCQkgICAgICAg c3RydWN0IHNjYW5fY29udHJvbCAqc2MsIGJvb2wgY2FuX3N3YXAsIGJvb2wgZnVsbF9zY2FuKQo+ ICt7Cj4gKwlib29sIHN1Y2Nlc3M7Cj4gKwlzdHJ1Y3QgbHJ1X2dlbl9tbV93YWxrICp3YWxrOwo+ ICsJc3RydWN0IG1tX3N0cnVjdCAqbW0gPSBOVUxMOwo+ICsJc3RydWN0IGxydV9nZW5fc3RydWN0 ICpscnVnZW4gPSAmbHJ1dmVjLT5scnVnZW47Cj4gKwo+ICsJVk1fQlVHX09OKG1heF9zZXEgPiBS RUFEX09OQ0UobHJ1Z2VuLT5tYXhfc2VxKSk7Cj4gKwo+ICsJLyoKPiArCSAqIElmIHRoZSBoYXJk d2FyZSBkb2Vzbid0IGF1dG9tYXRpY2FsbHkgc2V0IHRoZSBhY2Nlc3NlZCBiaXQsIGZhbGxiYWNr Cj4gKwkgKiB0byBscnVfZ2VuX2xvb2tfYXJvdW5kKCksIHdoaWNoIG9ubHkgY2xlYXJzIHRoZSBh Y2Nlc3NlZCBiaXQgaW4gYQo+ICsJICogaGFuZGZ1bCBvZiBQVEVzLiBTcHJlYWRpbmcgdGhlIHdv cmsgb3V0IG92ZXIgYSBwZXJpb2Qgb2YgdGltZSB1c3VhbGx5Cj4gKwkgKiBpcyBsZXNzIGVmZmlj aWVudCwgYnV0IGl0IGF2b2lkcyBidXJzdHkgcGFnZSBmYXVsdHMuCj4gKwkgKi8KPiArCWlmICgh ZnVsbF9zY2FuICYmICFhcmNoX2hhc19od19wdGVfeW91bmcoKSkgewo+ICsJCXN1Y2Nlc3MgPSBp dGVyYXRlX21tX2xpc3Rfbm93YWxrKGxydXZlYywgbWF4X3NlcSk7Cj4gKwkJZ290byBkb25lOwo+ ICsJfQo+ICsKPiArCXdhbGsgPSBhbGxvY19tbV93YWxrKCk7Cj4gKwlpZiAoIXdhbGspIHsKPiAr CQlzdWNjZXNzID0gaXRlcmF0ZV9tbV9saXN0X25vd2FsayhscnV2ZWMsIG1heF9zZXEpOwo+ICsJ CWdvdG8gZG9uZTsKPiArCX0KPiArCj4gKwl3YWxrLT5scnV2ZWMgPSBscnV2ZWM7Cj4gKwl3YWxr LT5tYXhfc2VxID0gbWF4X3NlcTsKPiArCXdhbGstPmNhbl9zd2FwID0gY2FuX3N3YXA7Cj4gKwl3 YWxrLT5mdWxsX3NjYW4gPSBmdWxsX3NjYW47Cj4gKwo+ICsJZG8gewo+ICsJCXN1Y2Nlc3MgPSBp dGVyYXRlX21tX2xpc3QobHJ1dmVjLCB3YWxrLCAmbW0pOwo+ICsJCWlmIChtbSkKPiArCQkJd2Fs a19tbShscnV2ZWMsIG1tLCB3YWxrKTsKPiArCj4gKwkJY29uZF9yZXNjaGVkKCk7Cj4gKwl9IHdo aWxlIChtbSk7Cj4gKwo+ICsJZnJlZV9tbV93YWxrKHdhbGspOwo+ICtkb25lOgo+ICsJaWYgKCFz dWNjZXNzKSB7Cj4gKwkJaWYgKCFjdXJyZW50X2lzX2tzd2FwZCgpICYmICFzYy0+cHJpb3JpdHkp Cj4gKwkJCXdhaXRfZXZlbnRfa2lsbGFibGUobHJ1dmVjLT5tbV9zdGF0ZS53YWl0LAo+ICsJCQkJ CSAgICBtYXhfc2VxIDwgUkVBRF9PTkNFKGxydWdlbi0+bWF4X3NlcSkpOwo+ICsKPiArCQlyZXR1 cm4gbWF4X3NlcSA8IFJFQURfT05DRShscnVnZW4tPm1heF9zZXEpOwo+ICsJfQo+ICsKPiArCVZN X0JVR19PTihtYXhfc2VxICE9IFJFQURfT05DRShscnVnZW4tPm1heF9zZXEpKTsKPiArCj4gKwlp bmNfbWF4X3NlcShscnV2ZWMpOwo+ICsJLyogZWl0aGVyIHRoaXMgc2VlcyBhbnkgd2FpdGVycyBv ciB0aGV5IHdpbGwgc2VlIHVwZGF0ZWQgbWF4X3NlcSAqLwo+ICsJaWYgKHdxX2hhc19zbGVlcGVy KCZscnV2ZWMtPm1tX3N0YXRlLndhaXQpKQo+ICsJCXdha2VfdXBfYWxsKCZscnV2ZWMtPm1tX3N0 YXRlLndhaXQpOwo+ICsKPiArCXdha2V1cF9mbHVzaGVyX3RocmVhZHMoV0JfUkVBU09OX1ZNU0NB Tik7Cj4gKwo+ICsJcmV0dXJuIHRydWU7Cj4gK30KPiArCj4gICBzdGF0aWMgbG9uZyBnZXRfbnJf ZXZpY3RhYmxlKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhfc2VxLAo+ ICAgCQkJICAgICB1bnNpZ25lZCBsb25nICptaW5fc2VxLCBib29sIGNhbl9zd2FwLCBib29sICpu ZWVkX2FnaW5nKQo+ICAgewo+IEBAIC0zNDAxLDcgKzQzMDAsNyBAQCBzdGF0aWMgdm9pZCBhZ2Vf bHJ1dmVjKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IHNjYW5fY29udHJvbCAqc2MpCj4g ICAJCW5yX3RvX3NjYW4rKzsKPiAgIAo+ICAgCWlmIChucl90b19zY2FuICYmIG5lZWRfYWdpbmcg JiYgKCFtZW1fY2dyb3VwX2JlbG93X2xvdyhtZW1jZykgfHwgc2MtPm1lbWNnX2xvd19yZWNsYWlt KSkKPiAtCQlpbmNfbWF4X3NlcShscnV2ZWMsIG1heF9zZXEpOwo+ICsJCXRyeV90b19pbmNfbWF4 X3NlcShscnV2ZWMsIG1heF9zZXEsIHNjLCBzd2FwcGluZXNzLCBmYWxzZSk7Cj4gICB9Cj4gICAK PiAgIHN0YXRpYyB2b2lkIGxydV9nZW5fYWdlX25vZGUoc3RydWN0IHBnbGlzdF9kYXRhICpwZ2Rh dCwgc3RydWN0IHNjYW5fY29udHJvbCAqc2MpCj4gQEAgLTM0MTAsNiArNDMwOSw4IEBAIHN0YXRp YyB2b2lkIGxydV9nZW5fYWdlX25vZGUoc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCwgc3RydWN0 IHNjYW5fY29udHJvbCAqc2MpCj4gICAKPiAgIAlWTV9CVUdfT04oIWN1cnJlbnRfaXNfa3N3YXBk KCkpOwo+ICAgCj4gKwljdXJyZW50LT5yZWNsYWltX3N0YXRlLT5tbV93YWxrID0gJnBnZGF0LT5t bV93YWxrOwo+ICsKPiAgIAltZW1jZyA9IG1lbV9jZ3JvdXBfaXRlcihOVUxMLCBOVUxMLCBOVUxM KTsKPiAgIAlkbyB7Cj4gICAJCXN0cnVjdCBscnV2ZWMgKmxydXZlYyA9IG1lbV9jZ3JvdXBfbHJ1 dmVjKG1lbWNnLCBwZ2RhdCk7Cj4gQEAgLTM0MTgsMTEgKzQzMTksMTYgQEAgc3RhdGljIHZvaWQg bHJ1X2dlbl9hZ2Vfbm9kZShzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0LCBzdHJ1Y3Qgc2Nhbl9j b250cm9sICpzYykKPiAgIAo+ICAgCQljb25kX3Jlc2NoZWQoKTsKPiAgIAl9IHdoaWxlICgobWVt Y2cgPSBtZW1fY2dyb3VwX2l0ZXIoTlVMTCwgbWVtY2csIE5VTEwpKSk7Cj4gKwo+ICsJY3VycmVu dC0+cmVjbGFpbV9zdGF0ZS0+bW1fd2FsayA9IE5VTEw7Cj4gICB9Cj4gICAKPiAgIC8qCj4gICAg KiBUaGlzIGZ1bmN0aW9uIGV4cGxvaXRzIHNwYXRpYWwgbG9jYWxpdHkgd2hlbiBzaHJpbmtfcGFn ZV9saXN0KCkgd2Fsa3MgdGhlCj4gICAgKiBybWFwLiBJdCBzY2FucyB0aGUgYWRqYWNlbnQgUFRF cyBvZiBhIHlvdW5nIFBURSBhbmQgcHJvbW90ZXMgaG90IHBhZ2VzLgo+ICsgKiBJZiB0aGUgc2Nh biB3YXMgZG9uZSBjYWNoZWxpbmUgZWZmaWNpZW50bHksIGl0IGFkZHMgdGhlIFBNRCBlbnRyeSBw b2ludGluZwo+ICsgKiB0byB0aGUgUFRFIHRhYmxlIHRvIHRoZSBCbG9vbSBmaWx0ZXIuIFRoaXMg cHJvY2VzcyBpcyBhIGZlZWRiYWNrIGxvb3AgZnJvbQo+ICsgKiB0aGUgZXZpY3Rpb24gdG8gdGhl IGFnaW5nLgo+ICAgICovCj4gICB2b2lkIGxydV9nZW5fbG9va19hcm91bmQoc3RydWN0IHBhZ2Vf dm1hX21hcHBlZF93YWxrICpwdm13KQo+ICAgewo+IEBAIC0zNDMxLDYgKzQzMzcsOCBAQCB2b2lk IGxydV9nZW5fbG9va19hcm91bmQoc3RydWN0IHBhZ2Vfdm1hX21hcHBlZF93YWxrICpwdm13KQo+ ICAgCXVuc2lnbmVkIGxvbmcgc3RhcnQ7Cj4gICAJdW5zaWduZWQgbG9uZyBlbmQ7Cj4gICAJdW5z aWduZWQgbG9uZyBhZGRyOwo+ICsJc3RydWN0IGxydV9nZW5fbW1fd2FsayAqd2FsazsKPiArCWlu dCB5b3VuZyA9IDA7Cj4gICAJdW5zaWduZWQgbG9uZyBiaXRtYXBbQklUU19UT19MT05HUyhNSU5f TFJVX0JBVENIKV0gPSB7fTsKPiAgIAlzdHJ1Y3QgZm9saW8gKmZvbGlvID0gcGZuX2ZvbGlvKHB2 bXctPnBmbik7Cj4gICAJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0gZm9saW9fbWVtY2coZm9s aW8pOwo+IEBAIC0zNDkyLDYgKzQ0MDAsOCBAQCB2b2lkIGxydV9nZW5fbG9va19hcm91bmQoc3Ry dWN0IHBhZ2Vfdm1hX21hcHBlZF93YWxrICpwdm13KQo+ICAgCQlpZiAoIXB0ZXBfdGVzdF9hbmRf Y2xlYXJfeW91bmcocHZtdy0+dm1hLCBhZGRyLCBwdGUgKyBpKSkKPiAgIAkJCWNvbnRpbnVlOwo+ ICAgCj4gKwkJeW91bmcrKzsKPiArCj4gICAJCWlmIChwdGVfZGlydHkocHRlW2ldKSAmJiAhZm9s aW9fdGVzdF9kaXJ0eShmb2xpbykgJiYKPiAgIAkJICAgICEoZm9saW9fdGVzdF9hbm9uKGZvbGlv KSAmJiBmb2xpb190ZXN0X3N3YXBiYWNrZWQoZm9saW8pICYmCj4gICAJCSAgICAgICFmb2xpb190 ZXN0X3N3YXBjYWNoZShmb2xpbykpKQo+IEBAIC0zNTA3LDcgKzQ0MTcsMTMgQEAgdm9pZCBscnVf Z2VuX2xvb2tfYXJvdW5kKHN0cnVjdCBwYWdlX3ZtYV9tYXBwZWRfd2FsayAqcHZtdykKPiAgIAlh cmNoX2xlYXZlX2xhenlfbW11X21vZGUoKTsKPiAgIAlyY3VfcmVhZF91bmxvY2soKTsKPiAgIAo+ IC0JaWYgKGJpdG1hcF93ZWlnaHQoYml0bWFwLCBNSU5fTFJVX0JBVENIKSA8IFBBR0VWRUNfU0la RSkgewo+ICsJLyogZmVlZGJhY2sgZnJvbSBybWFwIHdhbGtlcnMgdG8gcGFnZSB0YWJsZSB3YWxr ZXJzICovCj4gKwlpZiAoc3VpdGFibGVfdG9fc2NhbihpLCB5b3VuZykpCj4gKwkJdXBkYXRlX2Js b29tX2ZpbHRlcihscnV2ZWMsIG1heF9zZXEsIHB2bXctPnBtZCk7Cj4gKwo+ICsJd2FsayA9IGN1 cnJlbnQtPnJlY2xhaW1fc3RhdGUgPyBjdXJyZW50LT5yZWNsYWltX3N0YXRlLT5tbV93YWxrIDog TlVMTDsKPiArCj4gKwlpZiAoIXdhbGsgJiYgYml0bWFwX3dlaWdodChiaXRtYXAsIE1JTl9MUlVf QkFUQ0gpIDwgUEFHRVZFQ19TSVpFKSB7Cj4gICAJCWZvcl9lYWNoX3NldF9iaXQoaSwgYml0bWFw LCBNSU5fTFJVX0JBVENIKSB7Cj4gICAJCQlmb2xpbyA9IHBmbl9mb2xpbyhwdGVfcGZuKHB0ZVtp XSkpOwo+ICAgCQkJZm9saW9fYWN0aXZhdGUoZm9saW8pOwo+IEBAIC0zNTE5LDggKzQ0MzUsMTAg QEAgdm9pZCBscnVfZ2VuX2xvb2tfYXJvdW5kKHN0cnVjdCBwYWdlX3ZtYV9tYXBwZWRfd2FsayAq cHZtdykKPiAgIAlpZiAoIW1lbV9jZ3JvdXBfdHJ5bG9ja19wYWdlcyhtZW1jZykpCj4gICAJCXJl dHVybjsKPiAgIAo+IC0Jc3Bpbl9sb2NrX2lycSgmbHJ1dmVjLT5scnVfbG9jayk7Cj4gLQluZXdf Z2VuID0gbHJ1X2dlbl9mcm9tX3NlcShscnV2ZWMtPmxydWdlbi5tYXhfc2VxKTsKPiArCWlmICgh d2Fsaykgewo+ICsJCXNwaW5fbG9ja19pcnEoJmxydXZlYy0+bHJ1X2xvY2spOwo+ICsJCW5ld19n ZW4gPSBscnVfZ2VuX2Zyb21fc2VxKGxydXZlYy0+bHJ1Z2VuLm1heF9zZXEpOwo+ICsJfQo+ICAg Cj4gICAJZm9yX2VhY2hfc2V0X2JpdChpLCBiaXRtYXAsIE1JTl9MUlVfQkFUQ0gpIHsKPiAgIAkJ Zm9saW8gPSBwZm5fZm9saW8ocHRlX3BmbihwdGVbaV0pKTsKPiBAQCAtMzUzMSwxMCArNDQ0OSwx NCBAQCB2b2lkIGxydV9nZW5fbG9va19hcm91bmQoc3RydWN0IHBhZ2Vfdm1hX21hcHBlZF93YWxr ICpwdm13KQo+ICAgCQlpZiAob2xkX2dlbiA8IDAgfHwgb2xkX2dlbiA9PSBuZXdfZ2VuKQo+ICAg CQkJY29udGludWU7Cj4gICAKPiAtCQlscnVfZ2VuX3VwZGF0ZV9zaXplKGxydXZlYywgZm9saW8s IG9sZF9nZW4sIG5ld19nZW4pOwo+ICsJCWlmICh3YWxrKQo+ICsJCQl1cGRhdGVfYmF0Y2hfc2l6 ZSh3YWxrLCBmb2xpbywgb2xkX2dlbiwgbmV3X2dlbik7Cj4gKwkJZWxzZQo+ICsJCQlscnVfZ2Vu X3VwZGF0ZV9zaXplKGxydXZlYywgZm9saW8sIG9sZF9nZW4sIG5ld19nZW4pOwo+ICAgCX0KPiAg IAo+IC0Jc3Bpbl91bmxvY2tfaXJxKCZscnV2ZWMtPmxydV9sb2NrKTsKPiArCWlmICghd2FsaykK PiArCQlzcGluX3VubG9ja19pcnEoJmxydXZlYy0+bHJ1X2xvY2spOwo+ICAgCj4gICAJbWVtX2Nn cm91cF91bmxvY2tfcGFnZXMoKTsKPiAgIH0KPiBAQCAtMzgwMSw2ICs0NzIzLDcgQEAgc3RhdGlj IGludCBldmljdF9mb2xpb3Moc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3Qgc2Nhbl9jb250 cm9sICpzYywgaW50IHN3YXAKPiAgIAlzdHJ1Y3QgZm9saW8gKmZvbGlvOwo+ICAgCWVudW0gdm1f ZXZlbnRfaXRlbSBpdGVtOwo+ICAgCXN0cnVjdCByZWNsYWltX3N0YXQgc3RhdDsKPiArCXN0cnVj dCBscnVfZ2VuX21tX3dhbGsgKndhbGs7Cj4gICAJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0g bHJ1dmVjX21lbWNnKGxydXZlYyk7Cj4gICAJc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCA9IGxy dXZlY19wZ2RhdChscnV2ZWMpOwo+ICAgCj4gQEAgLTM4NDAsNiArNDc2MywxMCBAQCBzdGF0aWMg aW50IGV2aWN0X2ZvbGlvcyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRy b2wgKnNjLCBpbnQgc3dhcAo+ICAgCj4gICAJbW92ZV9wYWdlc190b19scnUobHJ1dmVjLCAmbGlz dCk7Cj4gICAKPiArCXdhbGsgPSBjdXJyZW50LT5yZWNsYWltX3N0YXRlID8gY3VycmVudC0+cmVj bGFpbV9zdGF0ZS0+bW1fd2FsayA6IE5VTEw7Cj4gKwlpZiAod2FsayAmJiB3YWxrLT5iYXRjaGVk KQo+ICsJCXJlc2V0X2JhdGNoX3NpemUobHJ1dmVjLCB3YWxrKTsKPiArCj4gICAJaXRlbSA9IGN1 cnJlbnRfaXNfa3N3YXBkKCkgPyBQR1NURUFMX0tTV0FQRCA6IFBHU1RFQUxfRElSRUNUOwo+ICAg CWlmICghY2dyb3VwX3JlY2xhaW0oc2MpKQo+ICAgCQlfX2NvdW50X3ZtX2V2ZW50cyhpdGVtLCBy ZWNsYWltZWQpOwo+IEBAIC0zODk0LDIwICs0ODIxLDI1IEBAIHN0YXRpYyBsb25nIGdldF9ucl90 b19zY2FuKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IHNjYW5fY29udHJvbCAqc2MsIGJv b2wKPiAgIAkJcmV0dXJuIDA7Cj4gICAJfQo+ICAgCj4gLQlpbmNfbWF4X3NlcShscnV2ZWMsIG1h eF9zZXEpOwo+ICsJaWYgKHRyeV90b19pbmNfbWF4X3NlcShscnV2ZWMsIG1heF9zZXEsIHNjLCBj YW5fc3dhcCwgZmFsc2UpKQo+ICsJCXJldHVybiBucl90b19zY2FuOwo+ICAgCj4gLQlyZXR1cm4g bnJfdG9fc2NhbjsKPiArCXJldHVybiBtaW5fc2VxW0xSVV9HRU5fRklMRV0gKyBNSU5fTlJfR0VO UyA8PSBtYXhfc2VxID8gbnJfdG9fc2NhbiA6IDA7Cj4gICB9Cj4gICAKPiAgIHN0YXRpYyB2b2lk IGxydV9nZW5fc2hyaW5rX2xydXZlYyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2Fu X2NvbnRyb2wgKnNjKQo+ICAgewo+ICAgCXN0cnVjdCBibGtfcGx1ZyBwbHVnOwo+ICAgCWxvbmcg c2Nhbm5lZCA9IDA7Cj4gKwlzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0ID0gbHJ1dmVjX3BnZGF0 KGxydXZlYyk7Cj4gICAKPiAgIAlscnVfYWRkX2RyYWluKCk7Cj4gICAKPiAgIAlibGtfc3RhcnRf cGx1ZygmcGx1Zyk7Cj4gICAKPiArCWlmIChjdXJyZW50X2lzX2tzd2FwZCgpKQo+ICsJCWN1cnJl bnQtPnJlY2xhaW1fc3RhdGUtPm1tX3dhbGsgPSAmcGdkYXQtPm1tX3dhbGs7Cj4gKwo+ICAgCXdo aWxlICh0cnVlKSB7Cj4gICAJCWludCBkZWx0YTsKPiAgIAkJaW50IHN3YXBwaW5lc3M7Cj4gQEAg LTM5MzUsNiArNDg2Nyw5IEBAIHN0YXRpYyB2b2lkIGxydV9nZW5fc2hyaW5rX2xydXZlYyhzdHJ1 Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjCj4gICAJCWNvbmRfcmVz Y2hlZCgpOwo+ICAgCX0KPiAgIAo+ICsJaWYgKGN1cnJlbnRfaXNfa3N3YXBkKCkpCj4gKwkJY3Vy cmVudC0+cmVjbGFpbV9zdGF0ZS0+bW1fd2FsayA9IE5VTEw7Cj4gKwo+ICAgCWJsa19maW5pc2hf cGx1ZygmcGx1Zyk7Cj4gICB9Cj4gICAKPiBAQCAtMzk1MSwxNSArNDg4NiwyMSBAQCB2b2lkIGxy dV9nZW5faW5pdF9scnV2ZWMoc3RydWN0IGxydXZlYyAqbHJ1dmVjKQo+ICAgCj4gICAJZm9yX2Vh Y2hfZ2VuX3R5cGVfem9uZShnZW4sIHR5cGUsIHpvbmUpCj4gICAJCUlOSVRfTElTVF9IRUFEKCZs cnVnZW4tPmxpc3RzW2dlbl1bdHlwZV1bem9uZV0pOwo+ICsKPiArCWxydXZlYy0+bW1fc3RhdGUu c2VxID0gTUlOX05SX0dFTlM7Cj4gKwlpbml0X3dhaXRxdWV1ZV9oZWFkKCZscnV2ZWMtPm1tX3N0 YXRlLndhaXQpOwo+ICAgfQo+ICAgCj4gICAjaWZkZWYgQ09ORklHX01FTUNHCj4gICB2b2lkIGxy dV9nZW5faW5pdF9tZW1jZyhzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cpCj4gICB7Cj4gKwlJTklU X0xJU1RfSEVBRCgmbWVtY2ctPm1tX2xpc3QuZmlmbyk7Cj4gKwlzcGluX2xvY2tfaW5pdCgmbWVt Y2ctPm1tX2xpc3QubG9jayk7Cj4gICB9Cj4gICAKPiAgIHZvaWQgbHJ1X2dlbl9leGl0X21lbWNn KHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKPiAgIHsKPiArCWludCBpOwo+ICAgCWludCBuaWQ7 Cj4gICAKPiAgIAlmb3JfZWFjaF9ub2RlKG5pZCkgewo+IEBAIC0zOTY3LDYgKzQ5MDgsMTEgQEAg dm9pZCBscnVfZ2VuX2V4aXRfbWVtY2coc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQo+ICAgCj4g ICAJCVZNX0JVR19PTihtZW1jaHJfaW52KGxydXZlYy0+bHJ1Z2VuLm5yX3BhZ2VzLCAwLAo+ICAg CQkJCSAgICAgc2l6ZW9mKGxydXZlYy0+bHJ1Z2VuLm5yX3BhZ2VzKSkpOwo+ICsKPiArCQlmb3Ig KGkgPSAwOyBpIDwgTlJfQkxPT01fRklMVEVSUzsgaSsrKSB7Cj4gKwkJCWJpdG1hcF9mcmVlKGxy dXZlYy0+bW1fc3RhdGUuZmlsdGVyc1tpXSk7Cj4gKwkJCWxydXZlYy0+bW1fc3RhdGUuZmlsdGVy c1tpXSA9IE5VTEw7Cj4gKwkJfQo+ICAgCX0KPiAgIH0KPiAgICNlbmRpZgo+IEBAIC0zOTc1LDYg KzQ5MjEsNyBAQCBzdGF0aWMgaW50IF9faW5pdCBpbml0X2xydV9nZW4odm9pZCkKPiAgIHsKPiAg IAlCVUlMRF9CVUdfT04oTUlOX05SX0dFTlMgKyAxID49IE1BWF9OUl9HRU5TKTsKPiAgIAlCVUlM RF9CVUdfT04oQklUKExSVV9HRU5fV0lEVEgpIDw9IE1BWF9OUl9HRU5TKTsKPiArCUJVSUxEX0JV R19PTihzaXplb2YoTU1fU1RBVF9DT0RFUykgIT0gTlJfTU1fU1RBVFMgKyAxKTsKPiAgIAo+ICAg CXJldHVybiAwOwo+ICAgfTsKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxA bGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xp c3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK