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 931F2C433F5 for ; Wed, 9 Mar 2022 01:13:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230247AbiCIBOM (ORCPT ); Tue, 8 Mar 2022 20:14:12 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46414 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231220AbiCIBNH (ORCPT ); Tue, 8 Mar 2022 20:13:07 -0500 Received: from mail-oi1-x24a.google.com (mail-oi1-x24a.google.com [IPv6:2607:f8b0:4864:20::24a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 31C8F156C7A for ; Tue, 8 Mar 2022 16:56:06 -0800 (PST) Received: by mail-oi1-x24a.google.com with SMTP id o124-20020aca5a82000000b002d7585f6de6so764493oib.3 for ; Tue, 08 Mar 2022 16:56:06 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=a0E0Q1QtpSnVdD4gLkS++iOw9pjvjPcNm2rqSTZPUHw=; b=GOQqDJYetpDtNgZnPIQOOz6Pci+7pDa9WceQGQcl9fKp8Xv53nb1+T2u7uN1WIL1HS JlaRzHIhlNXRfmdorY8AXAP6y6q/oDBYhzHxSQI30fIGhHZp2YFWpimJkZ7R3AvDwvNg pK4Zyt9/G6GtoAM2FyjrktDOa3DlfC06uB84I5OkORjszASLIsEdkeEkURAJoPtjUT4R 2MgZn3+cKQzKmx4UbE2X2LBM7bvvRXzsJIW6g+NVt2DL1e379aAri+tBA0r9TOM+B/u+ K8m8z7djW2fgPP4eid+ROiEBVMk/0fnKzWZJmqKYPMe7LvjISGThTg7ZerVlZbv+RH9Z KVmQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=a0E0Q1QtpSnVdD4gLkS++iOw9pjvjPcNm2rqSTZPUHw=; b=ivzZpiHPmof6fymNycSZTl8sZFYS+/E9T9PW5+s609/FEmRfFk4HKZbHl9yLM4uz0w RELOvzbOdf5TwkpnQ5PQwcarfiju+3YuXBbDpwtC0//g8zAp5+nR7orvtkOYC6locjqD g3aGXEwNGyzZTUu4OBuMqmjN+IRnrREQTv+pMLQsMT3bzJHy5p9+P7nj6MASCRL1LurL xxd5ctVjQZKiEqlqMNDIQHs4Avm3XcAOIMNz22vh0pChwJkgGU8lL/QdKKoJlIvGL/Fb ibjD3suH8Kl+MfTrizMVIrRUycAa/THnt7O5bSrsxVVghayU2Yt8YaCANK/OaYVql5C7 wC9A== X-Gm-Message-State: AOAM530Y/xJjrUZS1j8ymBKtLIsNcGiC++sTwWocC6BpUWx+EMUn0OUu t0A+PULXNgiSbT9h/FpnXh0AuZDiFoU= X-Google-Smtp-Source: ABdhPJxMIhDGRYQPwlDCSOK7QOfRr1+fo536L3ts/S5F3D5TQbGxJIyZdVGKBP7VmTU3JK6Q6pyNO8RRPzM= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a25:557:0:b0:628:9c9f:e9a3 with SMTP id 84-20020a250557000000b006289c9fe9a3mr14182059ybf.176.1646783311065; Tue, 08 Mar 2022 15:48:31 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:15 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-6-yuzhao@google.com> Mime-Version: 1.0 References: <20220308234723.3834941-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v8 05/14] mm: multi-gen LRU: groundwork From: Yu Zhao To: Andrew Morton Cc: Andi Kleen , Aneesh Kumar , 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, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Evictable pages are divided into multiple generations for each lruvec. The youngest generation number is stored in lrugen->max_seq for both anon and file types as they are aged on an equal footing. The oldest generation numbers are stored in lrugen->min_seq[] separately for anon and file types as clean file pages can be evicted regardless of swap constraints. These three variables are monotonically increasing. Generation numbers are truncated into order_base_2(MAX_NR_GENS+1) bits in order to fit into the gen counter in folio->flags. Each truncated generation number is an index to lrugen->lists[]. The sliding window technique is used to track at least MIN_NR_GENS and at most MAX_NR_GENS generations. The gen counter stores a value within [1, MAX_NR_GENS] while a page is on one of lrugen->lists[]. Otherwise it stores 0. There are two conceptually independent procedures: "the aging", which produces young generations, and "the eviction", which consumes old generations. They form a closed-loop system, i.e., "the page reclaim". Both procedures can be invoked from userspace for the purposes of working set estimation and proactive reclaim. These features are required to optimize job scheduling (bin packing) in data centers. The variable size of the sliding window is designed for such use cases [1][2]. To avoid confusion, the terms "hot" and "cold" will be applied to the multi-gen LRU, as a new convention; the terms "active" and "inactive" will be applied to the active/inactive LRU, as usual. The protection of hot pages and the selection of cold pages are based on page access channels and patterns. There are two access channels: one through page tables and the other through file descriptors. The protection of the former channel is by design stronger because: 1. The uncertainty in determining the access patterns of the former channel is higher due to the approximation of the accessed bit. 2. The cost of evicting the former channel is higher due to the TLB flushes required and the likelihood of encountering the dirty bit. 3. The penalty of underprotecting the former channel is higher because applications usually do not prepare themselves for major page faults like they do for blocked I/O. E.g., GUI applications commonly use dedicated I/O threads to avoid blocking the rendering threads. There are also two access patterns: one with temporal locality and the other without. For the reasons listed above, the former channel is assumed to follow the former pattern unless VM_SEQ_READ or VM_RAND_READ is present; the latter channel is assumed to follow the latter pattern unless outlying refaults have been observed. The next patch will address the "outlying refaults". A few macros, i.e., LRU_REFS_*, used later are added in this patch to make the patchset less diffy. A page is added to the youngest generation on faulting. The aging needs to check the accessed bit at least twice before handing this page over to the eviction. The first check takes care of the accessed bit set on the initial fault; the second check makes sure this page has not been used since then. This protocol, AKA second chance, requires a minimum of two generations, hence MIN_NR_GENS. [1] https://dl.acm.org/doi/10.1145/3297858.3304053 [2] https://dl.acm.org/doi/10.1145/3503222.3507731 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=C3=A4tte Tested-by: Konstantin Kharlamov Tested-by: Shuang Zhai Tested-by: Sofia Trinh Tested-by: Vaibhav Jain --- fs/fuse/dev.c | 3 +- include/linux/mm.h | 2 + include/linux/mm_inline.h | 176 ++++++++++++++++++++++++++++++ include/linux/mmzone.h | 86 +++++++++++++++ include/linux/page-flags-layout.h | 19 +++- include/linux/page-flags.h | 4 +- include/linux/sched.h | 4 + kernel/bounds.c | 3 + mm/Kconfig | 22 ++++ mm/huge_memory.c | 3 +- mm/memcontrol.c | 2 + mm/memory.c | 25 +++++ mm/mm_init.c | 6 +- mm/mmzone.c | 2 + mm/swap.c | 9 +- mm/vmscan.c | 73 +++++++++++++ 16 files changed, 426 insertions(+), 13 deletions(-) diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c index 592730fd6e42..e7c0aa6d61ce 100644 --- a/fs/fuse/dev.c +++ b/fs/fuse/dev.c @@ -785,7 +785,8 @@ static int fuse_check_page(struct page *page) 1 << PG_active | 1 << PG_workingset | 1 << PG_reclaim | - 1 << PG_waiters))) { + 1 << PG_waiters | + LRU_GEN_MASK | LRU_REFS_MASK))) { dump_page(page, "fuse: trying to steal weird page"); return 1; } diff --git a/include/linux/mm.h b/include/linux/mm.h index 5744a3fc4716..c1162659d824 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1032,6 +1032,8 @@ vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf)= ; #define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH) #define LAST_CPUPID_PGOFF (ZONES_PGOFF - LAST_CPUPID_WIDTH) #define KASAN_TAG_PGOFF (LAST_CPUPID_PGOFF - KASAN_TAG_WIDTH) +#define LRU_GEN_PGOFF (KASAN_TAG_PGOFF - LRU_GEN_WIDTH) +#define LRU_REFS_PGOFF (LRU_GEN_PGOFF - LRU_REFS_WIDTH) =20 /* * Define the bit shifts to access each section. For non-existent diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h index 2c24f5ac3e2a..e3594171b421 100644 --- a/include/linux/mm_inline.h +++ b/include/linux/mm_inline.h @@ -38,6 +38,9 @@ static __always_inline void __update_lru_size(struct lruv= ec *lruvec, { struct pglist_data *pgdat =3D lruvec_pgdat(lruvec); =20 + lockdep_assert_held(&lruvec->lru_lock); + WARN_ON_ONCE(nr_pages !=3D (int)nr_pages); + __mod_lruvec_state(lruvec, NR_LRU_BASE + lru, nr_pages); __mod_zone_page_state(&pgdat->node_zones[zid], NR_ZONE_LRU_BASE + lru, nr_pages); @@ -99,11 +102,178 @@ static __always_inline enum lru_list folio_lru_list(s= truct folio *folio) return lru; } =20 +#ifdef CONFIG_LRU_GEN + +static inline bool lru_gen_enabled(void) +{ + return true; +} + +static inline bool lru_gen_in_fault(void) +{ + return current->in_lru_fault; +} + +static inline int lru_gen_from_seq(unsigned long seq) +{ + return seq % MAX_NR_GENS; +} + +static inline bool lru_gen_is_active(struct lruvec *lruvec, int gen) +{ + unsigned long max_seq =3D lruvec->lrugen.max_seq; + + VM_BUG_ON(gen >=3D MAX_NR_GENS); + + /* see the comment on MIN_NR_GENS */ + return gen =3D=3D lru_gen_from_seq(max_seq) || gen =3D=3D lru_gen_from_se= q(max_seq - 1); +} + +static inline void lru_gen_update_size(struct lruvec *lruvec, struct folio= *folio, + int old_gen, int new_gen) +{ + int type =3D folio_is_file_lru(folio); + int zone =3D folio_zonenum(folio); + int delta =3D folio_nr_pages(folio); + enum lru_list lru =3D type * LRU_INACTIVE_FILE; + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + + VM_BUG_ON(old_gen !=3D -1 && old_gen >=3D MAX_NR_GENS); + VM_BUG_ON(new_gen !=3D -1 && new_gen >=3D MAX_NR_GENS); + VM_BUG_ON(old_gen =3D=3D -1 && new_gen =3D=3D -1); + + if (old_gen >=3D 0) + WRITE_ONCE(lrugen->nr_pages[old_gen][type][zone], + lrugen->nr_pages[old_gen][type][zone] - delta); + if (new_gen >=3D 0) + WRITE_ONCE(lrugen->nr_pages[new_gen][type][zone], + lrugen->nr_pages[new_gen][type][zone] + delta); + + /* addition */ + if (old_gen < 0) { + if (lru_gen_is_active(lruvec, new_gen)) + lru +=3D LRU_ACTIVE; + __update_lru_size(lruvec, lru, zone, delta); + return; + } + + /* deletion */ + if (new_gen < 0) { + if (lru_gen_is_active(lruvec, old_gen)) + lru +=3D LRU_ACTIVE; + __update_lru_size(lruvec, lru, zone, -delta); + return; + } +} + +static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *= folio, bool reclaiming) +{ + int gen; + unsigned long old_flags, new_flags; + int type =3D folio_is_file_lru(folio); + int zone =3D folio_zonenum(folio); + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + + if (folio_test_unevictable(folio)) + return false; + /* + * There are three common cases for this page: + * 1. If it's hot, e.g., freshly faulted in or previously hot and + * migrated, add it to the youngest generation. + * 2. If it's cold but can't be evicted immediately, i.e., an anon page + * not in swapcache or a dirty page pending writeback, add it to the + * second oldest generation. + * 3. Everything else (clean, cold) is added to the oldest generation. + */ + if (folio_test_active(folio)) + gen =3D lru_gen_from_seq(lrugen->max_seq); + else if ((type =3D=3D LRU_GEN_ANON && !folio_test_swapcache(folio)) || + (folio_test_reclaim(folio) && + (folio_test_dirty(folio) || folio_test_writeback(folio)))) + gen =3D lru_gen_from_seq(lrugen->min_seq[type] + 1); + else + gen =3D lru_gen_from_seq(lrugen->min_seq[type]); + + do { + new_flags =3D old_flags =3D READ_ONCE(folio->flags); + VM_BUG_ON_FOLIO(new_flags & LRU_GEN_MASK, folio); + + /* see the comment on MIN_NR_GENS */ + new_flags &=3D ~(LRU_GEN_MASK | BIT(PG_active)); + new_flags |=3D (gen + 1UL) << LRU_GEN_PGOFF; + } while (cmpxchg(&folio->flags, old_flags, new_flags) !=3D old_flags); + + lru_gen_update_size(lruvec, folio, -1, gen); + /* for folio_rotate_reclaimable() */ + if (reclaiming) + list_add_tail(&folio->lru, &lrugen->lists[gen][type][zone]); + else + list_add(&folio->lru, &lrugen->lists[gen][type][zone]); + + return true; +} + +static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *= folio, bool reclaiming) +{ + int gen; + unsigned long old_flags, new_flags; + + do { + new_flags =3D old_flags =3D READ_ONCE(folio->flags); + if (!(new_flags & LRU_GEN_MASK)) + return false; + + VM_BUG_ON_FOLIO(folio_test_active(folio), folio); + VM_BUG_ON_FOLIO(folio_test_unevictable(folio), folio); + + gen =3D ((new_flags & LRU_GEN_MASK) >> LRU_GEN_PGOFF) - 1; + + new_flags &=3D ~LRU_GEN_MASK; + /* for shrink_page_list() */ + if (reclaiming) + new_flags &=3D ~(BIT(PG_referenced) | BIT(PG_reclaim)); + else if (lru_gen_is_active(lruvec, gen)) + new_flags |=3D BIT(PG_active); + } while (cmpxchg(&folio->flags, old_flags, new_flags) !=3D old_flags); + + lru_gen_update_size(lruvec, folio, gen, -1); + list_del(&folio->lru); + + return true; +} + +#else + +static inline bool lru_gen_enabled(void) +{ + return false; +} + +static inline bool lru_gen_in_fault(void) +{ + return false; +} + +static inline bool lru_gen_add_folio(struct lruvec *lruvec, struct folio *= folio, bool reclaiming) +{ + return false; +} + +static inline bool lru_gen_del_folio(struct lruvec *lruvec, struct folio *= folio, bool reclaiming) +{ + return false; +} + +#endif /* CONFIG_LRU_GEN */ + static __always_inline void lruvec_add_folio(struct lruvec *lruvec, struct folio *folio) { enum lru_list lru =3D folio_lru_list(folio); =20 + if (lru_gen_add_folio(lruvec, folio, false)) + return; + update_lru_size(lruvec, lru, folio_zonenum(folio), folio_nr_pages(folio)); list_add(&folio->lru, &lruvec->lists[lru]); @@ -120,6 +290,9 @@ void lruvec_add_folio_tail(struct lruvec *lruvec, struc= t folio *folio) { enum lru_list lru =3D folio_lru_list(folio); =20 + if (lru_gen_add_folio(lruvec, folio, true)) + return; + update_lru_size(lruvec, lru, folio_zonenum(folio), folio_nr_pages(folio)); list_add_tail(&folio->lru, &lruvec->lists[lru]); @@ -134,6 +307,9 @@ static __always_inline void add_page_to_lru_list_tail(s= truct page *page, static __always_inline void lruvec_del_folio(struct lruvec *lruvec, struct folio *folio) { + if (lru_gen_del_folio(lruvec, folio, false)) + return; + list_del(&folio->lru); update_lru_size(lruvec, folio_lru_list(folio), folio_zonenum(folio), -folio_nr_pages(folio)); diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index aed44e9b5d89..a8eb619f742c 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -303,6 +303,88 @@ enum lruvec_flags { */ }; =20 +struct lruvec; + +#define LRU_GEN_MASK ((BIT(LRU_GEN_WIDTH) - 1) << LRU_GEN_PGOFF) +#define LRU_REFS_MASK ((BIT(LRU_REFS_WIDTH) - 1) << LRU_REFS_PGOFF) + +#ifdef CONFIG_LRU_GEN + +enum { + LRU_GEN_ANON, + LRU_GEN_FILE, +}; + +/* + * Evictable pages are divided into multiple generations. The youngest and= the + * oldest generation numbers, max_seq and min_seq, are monotonically incre= asing. + * They form a sliding window of a variable size [MIN_NR_GENS, MAX_NR_GENS= ]. An + * offset within MAX_NR_GENS, gen, indexes the LRU list of the correspondi= ng + * generation. The gen counter in folio->flags stores gen+1 while a page i= s on + * one of lrugen->lists[]. Otherwise it stores 0. + * + * A page is added to the youngest generation on faulting. The aging needs= to + * check the accessed bit at least twice before handing this page over to = the + * eviction. The first check takes care of the accessed bit set on the ini= tial + * fault; the second check makes sure this page hasn't been used since the= n. + * This process, AKA second chance, requires a minimum of two generations, + * hence MIN_NR_GENS. And to maintain ABI compatibility with the active/in= active + * LRU, these two generations are considered active; the rest of generatio= ns, if + * they exist, are considered inactive. See lru_gen_is_active(). PG_active= is + * always cleared while a page is on one of lrugen->lists[] so that the ag= ing + * needs not to worry about it. And it's set again when a page considered = active + * is isolated for non-reclaiming purposes, e.g., migration. See + * lru_gen_add_folio() and lru_gen_del_folio(). + */ +#define MIN_NR_GENS 2U +#define MAX_NR_GENS ((unsigned int)CONFIG_NR_LRU_GENS) + +/* + * The youngest generation number is stored in max_seq for both anon and f= ile + * types as they are aged on an equal footing. The oldest generation numbe= rs are + * stored in min_seq[] separately for anon and file types as clean file pa= ges + * can be evicted regardless of swap constraints. + * + * Normally anon and file min_seq are in sync. But if swapping is constrai= ned, + * e.g., out of swap space, file min_seq is allowed to advance and leave a= non + * min_seq behind. + */ +struct lru_gen_struct { + /* the aging increments the youngest generation number */ + unsigned long max_seq; + /* the eviction increments the oldest generation numbers */ + unsigned long min_seq[ANON_AND_FILE]; + /* the multi-gen LRU lists */ + struct list_head lists[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_ZONES]; + /* the sizes of the above lists */ + unsigned long nr_pages[MAX_NR_GENS][ANON_AND_FILE][MAX_NR_ZONES]; +}; + +void lru_gen_init_lruvec(struct lruvec *lruvec); + +#ifdef CONFIG_MEMCG +void lru_gen_init_memcg(struct mem_cgroup *memcg); +void lru_gen_exit_memcg(struct mem_cgroup *memcg); +#endif + +#else /* !CONFIG_LRU_GEN */ + +static inline void lru_gen_init_lruvec(struct lruvec *lruvec) +{ +} + +#ifdef CONFIG_MEMCG +static inline void lru_gen_init_memcg(struct mem_cgroup *memcg) +{ +} + +static inline void lru_gen_exit_memcg(struct mem_cgroup *memcg) +{ +} +#endif + +#endif /* CONFIG_LRU_GEN */ + struct lruvec { struct list_head lists[NR_LRU_LISTS]; /* per lruvec lru_lock for memcg */ @@ -320,6 +402,10 @@ struct lruvec { unsigned long refaults[ANON_AND_FILE]; /* Various lruvec state flags (enum lruvec_flags) */ unsigned long flags; +#ifdef CONFIG_LRU_GEN + /* evictable pages divided into generations */ + struct lru_gen_struct lrugen; +#endif #ifdef CONFIG_MEMCG struct pglist_data *pgdat; #endif diff --git a/include/linux/page-flags-layout.h b/include/linux/page-flags-l= ayout.h index ef1e3e736e14..db47ebd672e8 100644 --- a/include/linux/page-flags-layout.h +++ b/include/linux/page-flags-layout.h @@ -26,6 +26,14 @@ =20 #define ZONES_WIDTH ZONES_SHIFT =20 +#ifdef CONFIG_LRU_GEN +/* LRU_GEN_WIDTH is generated from order_base_2(CONFIG_NR_LRU_GENS + 1). *= / +#define LRU_REFS_WIDTH 0 +#else +#define LRU_GEN_WIDTH 0 +#define LRU_REFS_WIDTH 0 +#endif /* CONFIG_LRU_GEN */ + #ifdef CONFIG_SPARSEMEM #include #define SECTIONS_SHIFT (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS) @@ -55,7 +63,8 @@ #define SECTIONS_WIDTH 0 #endif =20 -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_SHIFT <=3D BITS_PER_LONG - NR_PAG= EFLAGS +#if ZONES_WIDTH + LRU_GEN_WIDTH + LRU_REFS_WIDTH + SECTIONS_WIDTH + NODES_= SHIFT \ + <=3D BITS_PER_LONG - NR_PAGEFLAGS #define NODES_WIDTH NODES_SHIFT #elif defined(CONFIG_SPARSEMEM_VMEMMAP) #error "Vmemmap: No space for nodes field in page flags" @@ -89,8 +98,8 @@ #define LAST_CPUPID_SHIFT 0 #endif =20 -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + KASAN_TAG_WIDTH + LAST_CP= UPID_SHIFT \ - <=3D BITS_PER_LONG - NR_PAGEFLAGS +#if ZONES_WIDTH + LRU_GEN_WIDTH + LRU_REFS_WIDTH + SECTIONS_WIDTH + NODES_= WIDTH + \ + KASAN_TAG_WIDTH + LAST_CPUPID_SHIFT <=3D BITS_PER_LONG - NR_PAGEFLAGS #define LAST_CPUPID_WIDTH LAST_CPUPID_SHIFT #else #define LAST_CPUPID_WIDTH 0 @@ -100,8 +109,8 @@ #define LAST_CPUPID_NOT_IN_PAGE_FLAGS #endif =20 -#if ZONES_WIDTH + SECTIONS_WIDTH + NODES_WIDTH + KASAN_TAG_WIDTH + LAST_CP= UPID_WIDTH \ - > BITS_PER_LONG - NR_PAGEFLAGS +#if ZONES_WIDTH + LRU_GEN_WIDTH + LRU_REFS_WIDTH + SECTIONS_WIDTH + NODES_= WIDTH + \ + KASAN_TAG_WIDTH + LAST_CPUPID_WIDTH > BITS_PER_LONG - NR_PAGEFLAGS #error "Not enough bits in page flags" #endif =20 diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h index 1c3b6e5c8bfd..a95518ca98eb 100644 --- a/include/linux/page-flags.h +++ b/include/linux/page-flags.h @@ -935,7 +935,7 @@ __PAGEFLAG(Isolated, isolated, PF_ANY); 1UL << PG_private | 1UL << PG_private_2 | \ 1UL << PG_writeback | 1UL << PG_reserved | \ 1UL << PG_slab | 1UL << PG_active | \ - 1UL << PG_unevictable | __PG_MLOCKED) + 1UL << PG_unevictable | __PG_MLOCKED | LRU_GEN_MASK) =20 /* * Flags checked when a page is prepped for return by the page allocator. @@ -946,7 +946,7 @@ __PAGEFLAG(Isolated, isolated, PF_ANY); * alloc-free cycle to prevent from reusing the page. */ #define PAGE_FLAGS_CHECK_AT_PREP \ - (PAGEFLAGS_MASK & ~__PG_HWPOISON) + ((PAGEFLAGS_MASK & ~__PG_HWPOISON) | LRU_GEN_MASK | LRU_REFS_MASK) =20 #define PAGE_FLAGS_PRIVATE \ (1UL << PG_private | 1UL << PG_private_2) diff --git a/include/linux/sched.h b/include/linux/sched.h index 75ba8aa60248..e7fe784b11aa 100644 --- a/include/linux/sched.h +++ b/include/linux/sched.h @@ -914,6 +914,10 @@ struct task_struct { #ifdef CONFIG_MEMCG unsigned in_user_fault:1; #endif +#ifdef CONFIG_LRU_GEN + /* whether the LRU algorithm may apply to this access */ + unsigned in_lru_fault:1; +#endif #ifdef CONFIG_COMPAT_BRK unsigned brk_randomized:1; #endif diff --git a/kernel/bounds.c b/kernel/bounds.c index 9795d75b09b2..aba13aa7336c 100644 --- a/kernel/bounds.c +++ b/kernel/bounds.c @@ -22,6 +22,9 @@ int main(void) DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS)); #endif DEFINE(SPINLOCK_SIZE, sizeof(spinlock_t)); +#ifdef CONFIG_LRU_GEN + DEFINE(LRU_GEN_WIDTH, order_base_2(CONFIG_NR_LRU_GENS + 1)); +#endif /* End of constants */ =20 return 0; diff --git a/mm/Kconfig b/mm/Kconfig index 3326ee3903f3..4ef67f157374 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -892,6 +892,28 @@ config ANON_VMA_NAME area from being merged with adjacent virtual memory areas due to the difference in their name. =20 +# the multi-gen LRU { +config LRU_GEN + bool "Multi-Gen LRU" + depends on MMU + # the following options can use up the spare bits in page flags + depends on !MAXSMP && (64BIT || !SPARSEMEM || SPARSEMEM_VMEMMAP) + help + A high performance LRU implementation for memory overcommit. + +config NR_LRU_GENS + int "Max number of generations" + depends on LRU_GEN + range 4 31 + default 4 + help + Do not increase this value unless you plan to use working set + estimation and proactive reclaim. These features are usually for job + scheduling optimizations in data centers. + + This option uses order_base_2(N+1) bits in page flags. +# } + source "mm/damon/Kconfig" =20 endmenu diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 406a3c28c026..3df389fd307f 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -2364,7 +2364,8 @@ static void __split_huge_page_tail(struct page *head,= int tail, #ifdef CONFIG_64BIT (1L << PG_arch_2) | #endif - (1L << PG_dirty))); + (1L << PG_dirty) | + LRU_GEN_MASK | LRU_REFS_MASK)); =20 /* ->mapping in first tail page is compound_mapcount */ VM_BUG_ON_PAGE(tail > 2 && page_tail->mapping !=3D TAIL_MAPPING, diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 36e9f38c919d..3fcbfeda259b 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -5121,6 +5121,7 @@ static void __mem_cgroup_free(struct mem_cgroup *memc= g) =20 static void mem_cgroup_free(struct mem_cgroup *memcg) { + lru_gen_exit_memcg(memcg); memcg_wb_domain_exit(memcg); __mem_cgroup_free(memcg); } @@ -5180,6 +5181,7 @@ static struct mem_cgroup *mem_cgroup_alloc(void) memcg->deferred_split_queue.split_queue_len =3D 0; #endif idr_replace(&mem_cgroup_idr, memcg, memcg->id.id); + lru_gen_init_memcg(memcg); return memcg; fail: mem_cgroup_id_remove(memcg); diff --git a/mm/memory.c b/mm/memory.c index a7379196a47e..d27e5f1a2533 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -4754,6 +4754,27 @@ static inline void mm_account_fault(struct pt_regs *= regs, perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address); } =20 +#ifdef CONFIG_LRU_GEN +static void lru_gen_enter_fault(struct vm_area_struct *vma) +{ + /* the LRU algorithm doesn't apply to sequential or random reads */ + current->in_lru_fault =3D !(vma->vm_flags & (VM_SEQ_READ | VM_RAND_READ))= ; +} + +static void lru_gen_exit_fault(void) +{ + current->in_lru_fault =3D false; +} +#else +static void lru_gen_enter_fault(struct vm_area_struct *vma) +{ +} + +static void lru_gen_exit_fault(void) +{ +} +#endif /* CONFIG_LRU_GEN */ + /* * By the time we get here, we already hold the mm semaphore * @@ -4785,11 +4806,15 @@ vm_fault_t handle_mm_fault(struct vm_area_struct *v= ma, unsigned long address, if (flags & FAULT_FLAG_USER) mem_cgroup_enter_user_fault(); =20 + lru_gen_enter_fault(vma); + if (unlikely(is_vm_hugetlb_page(vma))) ret =3D hugetlb_fault(vma->vm_mm, vma, address, flags); else ret =3D __handle_mm_fault(vma, address, flags); =20 + lru_gen_exit_fault(); + if (flags & FAULT_FLAG_USER) { mem_cgroup_exit_user_fault(); /* diff --git a/mm/mm_init.c b/mm/mm_init.c index 9ddaf0e1b0ab..0d7b2bd2454a 100644 --- a/mm/mm_init.c +++ b/mm/mm_init.c @@ -65,14 +65,16 @@ void __init mminit_verify_pageflags_layout(void) =20 shift =3D 8 * sizeof(unsigned long); width =3D shift - SECTIONS_WIDTH - NODES_WIDTH - ZONES_WIDTH - - LAST_CPUPID_SHIFT - KASAN_TAG_WIDTH; + - LAST_CPUPID_SHIFT - KASAN_TAG_WIDTH - LRU_GEN_WIDTH - LRU_REFS_WIDTH; mminit_dprintk(MMINIT_TRACE, "pageflags_layout_widths", - "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d Flags %d\n", + "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d Gen %d Tier %d Fla= gs %d\n", SECTIONS_WIDTH, NODES_WIDTH, ZONES_WIDTH, LAST_CPUPID_WIDTH, KASAN_TAG_WIDTH, + LRU_GEN_WIDTH, + LRU_REFS_WIDTH, NR_PAGEFLAGS); mminit_dprintk(MMINIT_TRACE, "pageflags_layout_shifts", "Section %d Node %d Zone %d Lastcpupid %d Kasantag %d\n", diff --git a/mm/mmzone.c b/mm/mmzone.c index eb89d6e018e2..2ec0d7793424 100644 --- a/mm/mmzone.c +++ b/mm/mmzone.c @@ -81,6 +81,8 @@ void lruvec_init(struct lruvec *lruvec) =20 for_each_lru(lru) INIT_LIST_HEAD(&lruvec->lists[lru]); + + lru_gen_init_lruvec(lruvec); } =20 #if defined(CONFIG_NUMA_BALANCING) && !defined(LAST_CPUPID_NOT_IN_PAGE_FLA= GS) diff --git a/mm/swap.c b/mm/swap.c index bcf3ac288b56..e5f2ab3dab4a 100644 --- a/mm/swap.c +++ b/mm/swap.c @@ -462,6 +462,11 @@ void folio_add_lru(struct folio *folio) VM_BUG_ON_FOLIO(folio_test_active(folio) && folio_test_unevictable(folio)= , folio); VM_BUG_ON_FOLIO(folio_test_lru(folio), folio); =20 + /* see the comment in lru_gen_add_folio() */ + if (lru_gen_enabled() && !folio_test_unevictable(folio) && + lru_gen_in_fault() && !(current->flags & PF_MEMALLOC)) + folio_set_active(folio); + folio_get(folio); local_lock(&lru_pvecs.lock); pvec =3D this_cpu_ptr(&lru_pvecs.lru_add); @@ -563,7 +568,7 @@ static void lru_deactivate_file_fn(struct page *page, s= truct lruvec *lruvec) =20 static void lru_deactivate_fn(struct page *page, struct lruvec *lruvec) { - if (PageActive(page) && !PageUnevictable(page)) { + if (!PageUnevictable(page) && (PageActive(page) || lru_gen_enabled())) { int nr_pages =3D thp_nr_pages(page); =20 del_page_from_lru_list(page, lruvec); @@ -677,7 +682,7 @@ void deactivate_file_page(struct page *page) */ void deactivate_page(struct page *page) { - if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) { + if (PageLRU(page) && !PageUnevictable(page) && (PageActive(page) || lru_g= en_enabled())) { struct pagevec *pvec; =20 local_lock(&lru_pvecs.lock); diff --git a/mm/vmscan.c b/mm/vmscan.c index 8e744cdf802f..65eb668abf2d 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -3042,6 +3042,79 @@ static bool can_age_anon_pages(struct pglist_data *p= gdat, return can_demote(pgdat->node_id, sc); } =20 +#ifdef CONFIG_LRU_GEN + +/*************************************************************************= ***** + * shorthand helpers + *************************************************************************= *****/ + +#define for_each_gen_type_zone(gen, type, zone) \ + for ((gen) =3D 0; (gen) < MAX_NR_GENS; (gen)++) \ + for ((type) =3D 0; (type) < ANON_AND_FILE; (type)++) \ + for ((zone) =3D 0; (zone) < MAX_NR_ZONES; (zone)++) + +static struct lruvec *get_lruvec(struct mem_cgroup *memcg, int nid) +{ + struct pglist_data *pgdat =3D NODE_DATA(nid); + +#ifdef CONFIG_MEMCG + if (memcg) { + struct lruvec *lruvec =3D &memcg->nodeinfo[nid]->lruvec; + + /* for hotadd_new_pgdat() */ + if (!lruvec->pgdat) + lruvec->pgdat =3D pgdat; + + return lruvec; + } +#endif + return pgdat ? &pgdat->__lruvec : NULL; +} + +/*************************************************************************= ***** + * initialization + *************************************************************************= *****/ + +void lru_gen_init_lruvec(struct lruvec *lruvec) +{ + int gen, type, zone; + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + + lrugen->max_seq =3D MIN_NR_GENS + 1; + + for_each_gen_type_zone(gen, type, zone) + INIT_LIST_HEAD(&lrugen->lists[gen][type][zone]); +} + +#ifdef CONFIG_MEMCG +void lru_gen_init_memcg(struct mem_cgroup *memcg) +{ +} + +void lru_gen_exit_memcg(struct mem_cgroup *memcg) +{ + int nid; + + for_each_node(nid) { + struct lruvec *lruvec =3D get_lruvec(memcg, nid); + + VM_BUG_ON(memchr_inv(lruvec->lrugen.nr_pages, 0, + sizeof(lruvec->lrugen.nr_pages))); + } +} +#endif + +static int __init init_lru_gen(void) +{ + BUILD_BUG_ON(MIN_NR_GENS + 1 >=3D MAX_NR_GENS); + BUILD_BUG_ON(BIT(LRU_GEN_WIDTH) <=3D MAX_NR_GENS); + + return 0; +}; +late_initcall(init_lru_gen); + +#endif /* CONFIG_LRU_GEN */ + static void shrink_lruvec(struct lruvec *lruvec, struct scan_control *sc) { unsigned long nr[NR_LRU_LISTS]; --=20 2.35.1.616.g0bdcbb4464-goog 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 B3AE1C433F5 for ; Tue, 8 Mar 2022 23:51:27 +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-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:From:Subject:References: Mime-Version:Message-Id:In-Reply-To:Date:Reply-To:Content-ID: Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc :Resent-Message-ID:List-Owner; bh=ATRkpNLlB2FKRmlYSXxiFTTCo3GZ08BO5MIZwGleEaE=; b=SHLhaQa4Ax5MA/J9QuI06/43+q VMFtdWT4Mglg/CiZZNqt+uTi8v+qH8cmiERsJEuHOlWwJRflgMJek9LVaSBKOFpGYYZbXlvSFcTs5 1FGx353DMZSMqEEOUZ/gNCnFFElgb31TCyIvXb/BxIazXbY4AnuQumUvpjKmf7f7VZfDWeCIORr8a MYrBrg/uVHL8MmYlv2WqinB2r3j1LQjkLHjTPYnxzxJWiBJsefEcBOMKe3V/G2YJl7OO6VH5YdO74 0SKv9+mK1gJWrDI/9eGWoDFZ3h+BMpsfFPLIVEfdpM5lhuiWOgCCZEYdNdxiE3lJIpwHUE0Zyt2pE aE3I0KYQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjaL-006amS-Hg; Tue, 08 Mar 2022 23:49:45 +0000 Received: from mail-yb1-xb4a.google.com ([2607:f8b0:4864:20::b4a]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjZA-006aKx-JN for linux-arm-kernel@lists.infradead.org; Tue, 08 Mar 2022 23:48:39 +0000 Received: by mail-yb1-xb4a.google.com with SMTP id l16-20020a25bf90000000b00628c3a412cdso413674ybk.10 for ; Tue, 08 Mar 2022 15:48:31 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=date:in-reply-to:message-id:mime-version:references:subject:from:to :cc:content-transfer-encoding; bh=a0E0Q1QtpSnVdD4gLkS++iOw9pjvjPcNm2rqSTZPUHw=; b=GOQqDJYetpDtNgZnPIQOOz6Pci+7pDa9WceQGQcl9fKp8Xv53nb1+T2u7uN1WIL1HS JlaRzHIhlNXRfmdorY8AXAP6y6q/oDBYhzHxSQI30fIGhHZp2YFWpimJkZ7R3AvDwvNg pK4Zyt9/G6GtoAM2FyjrktDOa3DlfC06uB84I5OkORjszASLIsEdkeEkURAJoPtjUT4R 2MgZn3+cKQzKmx4UbE2X2LBM7bvvRXzsJIW6g+NVt2DL1e379aAri+tBA0r9TOM+B/u+ K8m8z7djW2fgPP4eid+ROiEBVMk/0fnKzWZJmqKYPMe7LvjISGThTg7ZerVlZbv+RH9Z KVmQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:in-reply-to:message-id:mime-version :references:subject:from:to:cc:content-transfer-encoding; bh=a0E0Q1QtpSnVdD4gLkS++iOw9pjvjPcNm2rqSTZPUHw=; b=zCfFbbHcKpNZEMsJgf/9iSrJX5tf/4RBypo6UGKA8zM4o/l4bQR+oIQ/Bpa1HBDUvD beRZP5arfk4CqPjGOn5fpuLs6H+owfmWmwDkV738Oyt3yIVWfPIc2wNIqRgDdrhbJ/B/ s+jxJ9kETX7mqb5MZ3iIDIFZMCvpDmq62kVXn+agc1kyPcGvc8my5FK+IilK1qqPQf5Y 0O2m/BBSUnM67rLZvl8w3tv2GOL2EUGiU9/jma9W3SDAoZ2+HyrTw0nziQLgggSPHCNz mD/xc5xLFoZosVMeTxwwgYEG40H89ix0JtlPi0k9IwZvYUNHYC3TPfpRwflUiwaVTz2M rnJA== X-Gm-Message-State: AOAM532i8K0lPMMbBpfhaBnEpS3W+8Nnbg4zVs0u7A72kB+FBgPoByiT xmRIP76vGAgurFrjAxHRY/Rm7pYH8/g= X-Google-Smtp-Source: ABdhPJxMIhDGRYQPwlDCSOK7QOfRr1+fo536L3ts/S5F3D5TQbGxJIyZdVGKBP7VmTU3JK6Q6pyNO8RRPzM= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a25:557:0:b0:628:9c9f:e9a3 with SMTP id 84-20020a250557000000b006289c9fe9a3mr14182059ybf.176.1646783311065; Tue, 08 Mar 2022 15:48:31 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:15 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-6-yuzhao@google.com> Mime-Version: 1.0 References: <20220308234723.3834941-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.616.g0bdcbb4464-goog Subject: [PATCH v8 05/14] mm: multi-gen LRU: groundwork From: Yu Zhao To: Andrew Morton Cc: Andi Kleen , Aneesh Kumar , 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, linux-mm@kvack.org, page-reclaim@google.com, x86@kernel.org, Yu Zhao , Brian Geffon , Jan Alexander Steffens , Oleksandr Natalenko , Steven Barrett , Suleiman Souhlal , Daniel Byrne , Donald Carr , "=?UTF-8?q?Holger=20Hoffst=C3=A4tte?=" , Konstantin Kharlamov , Shuang Zhai , Sofia Trinh , Vaibhav Jain X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220308_154832_769686_3E9A6C06 X-CRM114-Status: GOOD ( 31.40 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RXZpY3RhYmxlIHBhZ2VzIGFyZSBkaXZpZGVkIGludG8gbXVsdGlwbGUgZ2VuZXJhdGlvbnMgZm9y IGVhY2ggbHJ1dmVjLgpUaGUgeW91bmdlc3QgZ2VuZXJhdGlvbiBudW1iZXIgaXMgc3RvcmVkIGlu IGxydWdlbi0+bWF4X3NlcSBmb3IgYm90aAphbm9uIGFuZCBmaWxlIHR5cGVzIGFzIHRoZXkgYXJl IGFnZWQgb24gYW4gZXF1YWwgZm9vdGluZy4gVGhlIG9sZGVzdApnZW5lcmF0aW9uIG51bWJlcnMg YXJlIHN0b3JlZCBpbiBscnVnZW4tPm1pbl9zZXFbXSBzZXBhcmF0ZWx5IGZvciBhbm9uCmFuZCBm aWxlIHR5cGVzIGFzIGNsZWFuIGZpbGUgcGFnZXMgY2FuIGJlIGV2aWN0ZWQgcmVnYXJkbGVzcyBv ZiBzd2FwCmNvbnN0cmFpbnRzLiBUaGVzZSB0aHJlZSB2YXJpYWJsZXMgYXJlIG1vbm90b25pY2Fs bHkgaW5jcmVhc2luZy4KCkdlbmVyYXRpb24gbnVtYmVycyBhcmUgdHJ1bmNhdGVkIGludG8gb3Jk ZXJfYmFzZV8yKE1BWF9OUl9HRU5TKzEpIGJpdHMKaW4gb3JkZXIgdG8gZml0IGludG8gdGhlIGdl biBjb3VudGVyIGluIGZvbGlvLT5mbGFncy4gRWFjaCB0cnVuY2F0ZWQKZ2VuZXJhdGlvbiBudW1i ZXIgaXMgYW4gaW5kZXggdG8gbHJ1Z2VuLT5saXN0c1tdLiBUaGUgc2xpZGluZyB3aW5kb3cKdGVj aG5pcXVlIGlzIHVzZWQgdG8gdHJhY2sgYXQgbGVhc3QgTUlOX05SX0dFTlMgYW5kIGF0IG1vc3QK TUFYX05SX0dFTlMgZ2VuZXJhdGlvbnMuIFRoZSBnZW4gY291bnRlciBzdG9yZXMgYSB2YWx1ZSB3 aXRoaW4gWzEsCk1BWF9OUl9HRU5TXSB3aGlsZSBhIHBhZ2UgaXMgb24gb25lIG9mIGxydWdlbi0+ bGlzdHNbXS4gT3RoZXJ3aXNlIGl0CnN0b3JlcyAwLgoKVGhlcmUgYXJlIHR3byBjb25jZXB0dWFs bHkgaW5kZXBlbmRlbnQgcHJvY2VkdXJlczogInRoZSBhZ2luZyIsIHdoaWNoCnByb2R1Y2VzIHlv dW5nIGdlbmVyYXRpb25zLCBhbmQgInRoZSBldmljdGlvbiIsIHdoaWNoIGNvbnN1bWVzIG9sZApn ZW5lcmF0aW9ucy4gVGhleSBmb3JtIGEgY2xvc2VkLWxvb3Agc3lzdGVtLCBpLmUuLCAidGhlIHBh Z2UgcmVjbGFpbSIuCkJvdGggcHJvY2VkdXJlcyBjYW4gYmUgaW52b2tlZCBmcm9tIHVzZXJzcGFj ZSBmb3IgdGhlIHB1cnBvc2VzIG9mCndvcmtpbmcgc2V0IGVzdGltYXRpb24gYW5kIHByb2FjdGl2 ZSByZWNsYWltLiBUaGVzZSBmZWF0dXJlcyBhcmUKcmVxdWlyZWQgdG8gb3B0aW1pemUgam9iIHNj aGVkdWxpbmcgKGJpbiBwYWNraW5nKSBpbiBkYXRhIGNlbnRlcnMuIFRoZQp2YXJpYWJsZSBzaXpl IG9mIHRoZSBzbGlkaW5nIHdpbmRvdyBpcyBkZXNpZ25lZCBmb3Igc3VjaCB1c2UgY2FzZXMKWzFd WzJdLgoKVG8gYXZvaWQgY29uZnVzaW9uLCB0aGUgdGVybXMgImhvdCIgYW5kICJjb2xkIiB3aWxs IGJlIGFwcGxpZWQgdG8gdGhlCm11bHRpLWdlbiBMUlUsIGFzIGEgbmV3IGNvbnZlbnRpb247IHRo ZSB0ZXJtcyAiYWN0aXZlIiBhbmQgImluYWN0aXZlIgp3aWxsIGJlIGFwcGxpZWQgdG8gdGhlIGFj dGl2ZS9pbmFjdGl2ZSBMUlUsIGFzIHVzdWFsLgoKVGhlIHByb3RlY3Rpb24gb2YgaG90IHBhZ2Vz IGFuZCB0aGUgc2VsZWN0aW9uIG9mIGNvbGQgcGFnZXMgYXJlIGJhc2VkCm9uIHBhZ2UgYWNjZXNz IGNoYW5uZWxzIGFuZCBwYXR0ZXJucy4gVGhlcmUgYXJlIHR3byBhY2Nlc3MgY2hhbm5lbHM6Cm9u ZSB0aHJvdWdoIHBhZ2UgdGFibGVzIGFuZCB0aGUgb3RoZXIgdGhyb3VnaCBmaWxlIGRlc2NyaXB0 b3JzLiBUaGUKcHJvdGVjdGlvbiBvZiB0aGUgZm9ybWVyIGNoYW5uZWwgaXMgYnkgZGVzaWduIHN0 cm9uZ2VyIGJlY2F1c2U6CjEuIFRoZSB1bmNlcnRhaW50eSBpbiBkZXRlcm1pbmluZyB0aGUgYWNj ZXNzIHBhdHRlcm5zIG9mIHRoZSBmb3JtZXIKICAgY2hhbm5lbCBpcyBoaWdoZXIgZHVlIHRvIHRo ZSBhcHByb3hpbWF0aW9uIG9mIHRoZSBhY2Nlc3NlZCBiaXQuCjIuIFRoZSBjb3N0IG9mIGV2aWN0 aW5nIHRoZSBmb3JtZXIgY2hhbm5lbCBpcyBoaWdoZXIgZHVlIHRvIHRoZSBUTEIKICAgZmx1c2hl cyByZXF1aXJlZCBhbmQgdGhlIGxpa2VsaWhvb2Qgb2YgZW5jb3VudGVyaW5nIHRoZSBkaXJ0eSBi aXQuCjMuIFRoZSBwZW5hbHR5IG9mIHVuZGVycHJvdGVjdGluZyB0aGUgZm9ybWVyIGNoYW5uZWwg aXMgaGlnaGVyIGJlY2F1c2UKICAgYXBwbGljYXRpb25zIHVzdWFsbHkgZG8gbm90IHByZXBhcmUg dGhlbXNlbHZlcyBmb3IgbWFqb3IgcGFnZQogICBmYXVsdHMgbGlrZSB0aGV5IGRvIGZvciBibG9j a2VkIEkvTy4gRS5nLiwgR1VJIGFwcGxpY2F0aW9ucwogICBjb21tb25seSB1c2UgZGVkaWNhdGVk IEkvTyB0aHJlYWRzIHRvIGF2b2lkIGJsb2NraW5nIHRoZSByZW5kZXJpbmcKICAgdGhyZWFkcy4K VGhlcmUgYXJlIGFsc28gdHdvIGFjY2VzcyBwYXR0ZXJuczogb25lIHdpdGggdGVtcG9yYWwgbG9j YWxpdHkgYW5kIHRoZQpvdGhlciB3aXRob3V0LiBGb3IgdGhlIHJlYXNvbnMgbGlzdGVkIGFib3Zl LCB0aGUgZm9ybWVyIGNoYW5uZWwgaXMKYXNzdW1lZCB0byBmb2xsb3cgdGhlIGZvcm1lciBwYXR0 ZXJuIHVubGVzcyBWTV9TRVFfUkVBRCBvcgpWTV9SQU5EX1JFQUQgaXMgcHJlc2VudDsgdGhlIGxh dHRlciBjaGFubmVsIGlzIGFzc3VtZWQgdG8gZm9sbG93IHRoZQpsYXR0ZXIgcGF0dGVybiB1bmxl c3Mgb3V0bHlpbmcgcmVmYXVsdHMgaGF2ZSBiZWVuIG9ic2VydmVkLgoKVGhlIG5leHQgcGF0Y2gg d2lsbCBhZGRyZXNzIHRoZSAib3V0bHlpbmcgcmVmYXVsdHMiLiBBIGZldyBtYWNyb3MsCmkuZS4s IExSVV9SRUZTXyosIHVzZWQgbGF0ZXIgYXJlIGFkZGVkIGluIHRoaXMgcGF0Y2ggdG8gbWFrZSB0 aGUKcGF0Y2hzZXQgbGVzcyBkaWZmeS4KCkEgcGFnZSBpcyBhZGRlZCB0byB0aGUgeW91bmdlc3Qg Z2VuZXJhdGlvbiBvbiBmYXVsdGluZy4gVGhlIGFnaW5nCm5lZWRzIHRvIGNoZWNrIHRoZSBhY2Nl c3NlZCBiaXQgYXQgbGVhc3QgdHdpY2UgYmVmb3JlIGhhbmRpbmcgdGhpcwpwYWdlIG92ZXIgdG8g dGhlIGV2aWN0aW9uLiBUaGUgZmlyc3QgY2hlY2sgdGFrZXMgY2FyZSBvZiB0aGUgYWNjZXNzZWQK Yml0IHNldCBvbiB0aGUgaW5pdGlhbCBmYXVsdDsgdGhlIHNlY29uZCBjaGVjayBtYWtlcyBzdXJl IHRoaXMgcGFnZQpoYXMgbm90IGJlZW4gdXNlZCBzaW5jZSB0aGVuLiBUaGlzIHByb3RvY29sLCBB S0Egc2Vjb25kIGNoYW5jZSwKcmVxdWlyZXMgYSBtaW5pbXVtIG9mIHR3byBnZW5lcmF0aW9ucywg aGVuY2UgTUlOX05SX0dFTlMuCgpbMV0gaHR0cHM6Ly9kbC5hY20ub3JnL2RvaS8xMC4xMTQ1LzMy OTc4NTguMzMwNDA1MwpbMl0gaHR0cHM6Ly9kbC5hY20ub3JnL2RvaS8xMC4xMTQ1LzM1MDMyMjIu MzUwNzczMQoKU2lnbmVkLW9mZi1ieTogWXUgWmhhbyA8eXV6aGFvQGdvb2dsZS5jb20+CkFja2Vk LWJ5OiBCcmlhbiBHZWZmb24gPGJnZWZmb25AZ29vZ2xlLmNvbT4KQWNrZWQtYnk6IEphbiBBbGV4 YW5kZXIgU3RlZmZlbnMgKGhlZnRpZykgPGhlZnRpZ0BhcmNobGludXgub3JnPgpBY2tlZC1ieTog T2xla3NhbmRyIE5hdGFsZW5rbyA8b2xla3NhbmRyQG5hdGFsZW5rby5uYW1lPgpBY2tlZC1ieTog U3RldmVuIEJhcnJldHQgPHN0ZXZlbkBsaXF1b3JpeC5uZXQ+CkFja2VkLWJ5OiBTdWxlaW1hbiBT b3VobGFsIDxzdWxlaW1hbkBnb29nbGUuY29tPgpUZXN0ZWQtYnk6IERhbmllbCBCeXJuZSA8ZGpi eXJuZUBtdHUuZWR1PgpUZXN0ZWQtYnk6IERvbmFsZCBDYXJyIDxkQGNoYW9zLXJlaW5zLmNvbT4K VGVzdGVkLWJ5OiBIb2xnZXIgSG9mZnN0w6R0dGUgPGhvbGdlckBhcHBsaWVkLWFzeW5jaHJvbnku Y29tPgpUZXN0ZWQtYnk6IEtvbnN0YW50aW4gS2hhcmxhbW92IDxIaS1BbmdlbEB5YW5kZXgucnU+ ClRlc3RlZC1ieTogU2h1YW5nIFpoYWkgPHN6aGFpMkBjcy5yb2NoZXN0ZXIuZWR1PgpUZXN0ZWQt Ynk6IFNvZmlhIFRyaW5oIDxzb2ZpYS50cmluaEBlZGkud29ya3M+ClRlc3RlZC1ieTogVmFpYmhh diBKYWluIDx2YWliaGF2QGxpbnV4LmlibS5jb20+Ci0tLQogZnMvZnVzZS9kZXYuYyAgICAgICAg ICAgICAgICAgICAgIHwgICAzICstCiBpbmNsdWRlL2xpbnV4L21tLmggICAgICAgICAgICAgICAg fCAgIDIgKwogaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaCAgICAgICAgIHwgMTc2ICsrKysrKysr KysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9tbXpvbmUuaCAgICAgICAgICAg IHwgIDg2ICsrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxheW91dC5o IHwgIDE5ICsrKy0KIGluY2x1ZGUvbGludXgvcGFnZS1mbGFncy5oICAgICAgICB8ICAgNCArLQog aW5jbHVkZS9saW51eC9zY2hlZC5oICAgICAgICAgICAgIHwgICA0ICsKIGtlcm5lbC9ib3VuZHMu YyAgICAgICAgICAgICAgICAgICB8ICAgMyArCiBtbS9LY29uZmlnICAgICAgICAgICAgICAgICAg ICAgICAgfCAgMjIgKysrKwogbW0vaHVnZV9tZW1vcnkuYyAgICAgICAgICAgICAgICAgIHwgICAz ICstCiBtbS9tZW1jb250cm9sLmMgICAgICAgICAgICAgICAgICAgfCAgIDIgKwogbW0vbWVtb3J5 LmMgICAgICAgICAgICAgICAgICAgICAgIHwgIDI1ICsrKysrCiBtbS9tbV9pbml0LmMgICAgICAg ICAgICAgICAgICAgICAgfCAgIDYgKy0KIG1tL21tem9uZS5jICAgICAgICAgICAgICAgICAgICAg ICB8ICAgMiArCiBtbS9zd2FwLmMgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDkgKy0KIG1t L3Ztc2Nhbi5jICAgICAgICAgICAgICAgICAgICAgICB8ICA3MyArKysrKysrKysrKysrCiAxNiBm aWxlcyBjaGFuZ2VkLCA0MjYgaW5zZXJ0aW9ucygrKSwgMTMgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvZnMvZnVzZS9kZXYuYyBiL2ZzL2Z1c2UvZGV2LmMKaW5kZXggNTkyNzMwZmQ2ZTQyLi5l N2MwYWE2ZDYxY2UgMTAwNjQ0Ci0tLSBhL2ZzL2Z1c2UvZGV2LmMKKysrIGIvZnMvZnVzZS9kZXYu YwpAQCAtNzg1LDcgKzc4NSw4IEBAIHN0YXRpYyBpbnQgZnVzZV9jaGVja19wYWdlKHN0cnVjdCBw YWdlICpwYWdlKQogCSAgICAgICAxIDw8IFBHX2FjdGl2ZSB8CiAJICAgICAgIDEgPDwgUEdfd29y a2luZ3NldCB8CiAJICAgICAgIDEgPDwgUEdfcmVjbGFpbSB8Ci0JICAgICAgIDEgPDwgUEdfd2Fp dGVycykpKSB7CisJICAgICAgIDEgPDwgUEdfd2FpdGVycyB8CisJICAgICAgIExSVV9HRU5fTUFT SyB8IExSVV9SRUZTX01BU0spKSkgewogCQlkdW1wX3BhZ2UocGFnZSwgImZ1c2U6IHRyeWluZyB0 byBzdGVhbCB3ZWlyZCBwYWdlIik7CiAJCXJldHVybiAxOwogCX0KZGlmZiAtLWdpdCBhL2luY2x1 ZGUvbGludXgvbW0uaCBiL2luY2x1ZGUvbGludXgvbW0uaAppbmRleCA1NzQ0YTNmYzQ3MTYuLmMx MTYyNjU5ZDgyNCAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbS5oCisrKyBiL2luY2x1ZGUv bGludXgvbW0uaApAQCAtMTAzMiw2ICsxMDMyLDggQEAgdm1fZmF1bHRfdCBmaW5pc2hfbWt3cml0 ZV9mYXVsdChzdHJ1Y3Qgdm1fZmF1bHQgKnZtZik7CiAjZGVmaW5lIFpPTkVTX1BHT0ZGCQkoTk9E RVNfUEdPRkYgLSBaT05FU19XSURUSCkKICNkZWZpbmUgTEFTVF9DUFVQSURfUEdPRkYJKFpPTkVT X1BHT0ZGIC0gTEFTVF9DUFVQSURfV0lEVEgpCiAjZGVmaW5lIEtBU0FOX1RBR19QR09GRgkJKExB U1RfQ1BVUElEX1BHT0ZGIC0gS0FTQU5fVEFHX1dJRFRIKQorI2RlZmluZSBMUlVfR0VOX1BHT0ZG CQkoS0FTQU5fVEFHX1BHT0ZGIC0gTFJVX0dFTl9XSURUSCkKKyNkZWZpbmUgTFJVX1JFRlNfUEdP RkYJCShMUlVfR0VOX1BHT0ZGIC0gTFJVX1JFRlNfV0lEVEgpCiAKIC8qCiAgKiBEZWZpbmUgdGhl IGJpdCBzaGlmdHMgdG8gYWNjZXNzIGVhY2ggc2VjdGlvbi4gIEZvciBub24tZXhpc3RlbnQKZGlm ZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW1faW5saW5lLmggYi9pbmNsdWRlL2xpbnV4L21tX2lu bGluZS5oCmluZGV4IDJjMjRmNWFjM2UyYS4uZTM1OTQxNzFiNDIxIDEwMDY0NAotLS0gYS9pbmNs dWRlL2xpbnV4L21tX2lubGluZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbW1faW5saW5lLmgKQEAg LTM4LDYgKzM4LDkgQEAgc3RhdGljIF9fYWx3YXlzX2lubGluZSB2b2lkIF9fdXBkYXRlX2xydV9z aXplKHN0cnVjdCBscnV2ZWMgKmxydXZlYywKIHsKIAlzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0 ID0gbHJ1dmVjX3BnZGF0KGxydXZlYyk7CiAKKwlsb2NrZGVwX2Fzc2VydF9oZWxkKCZscnV2ZWMt PmxydV9sb2NrKTsKKwlXQVJOX09OX09OQ0UobnJfcGFnZXMgIT0gKGludClucl9wYWdlcyk7CisK IAlfX21vZF9scnV2ZWNfc3RhdGUobHJ1dmVjLCBOUl9MUlVfQkFTRSArIGxydSwgbnJfcGFnZXMp OwogCV9fbW9kX3pvbmVfcGFnZV9zdGF0ZSgmcGdkYXQtPm5vZGVfem9uZXNbemlkXSwKIAkJCQlO Ul9aT05FX0xSVV9CQVNFICsgbHJ1LCBucl9wYWdlcyk7CkBAIC05OSwxMSArMTAyLDE3OCBAQCBz dGF0aWMgX19hbHdheXNfaW5saW5lIGVudW0gbHJ1X2xpc3QgZm9saW9fbHJ1X2xpc3Qoc3RydWN0 IGZvbGlvICpmb2xpbykKIAlyZXR1cm4gbHJ1OwogfQogCisjaWZkZWYgQ09ORklHX0xSVV9HRU4K Kworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fZW5hYmxlZCh2b2lkKQoreworCXJldHVybiB0 cnVlOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9pbl9mYXVsdCh2b2lkKQorewor CXJldHVybiBjdXJyZW50LT5pbl9scnVfZmF1bHQ7Cit9CisKK3N0YXRpYyBpbmxpbmUgaW50IGxy dV9nZW5fZnJvbV9zZXEodW5zaWduZWQgbG9uZyBzZXEpCit7CisJcmV0dXJuIHNlcSAlIE1BWF9O Ul9HRU5TOworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9pc19hY3RpdmUoc3RydWN0 IGxydXZlYyAqbHJ1dmVjLCBpbnQgZ2VuKQoreworCXVuc2lnbmVkIGxvbmcgbWF4X3NlcSA9IGxy dXZlYy0+bHJ1Z2VuLm1heF9zZXE7CisKKwlWTV9CVUdfT04oZ2VuID49IE1BWF9OUl9HRU5TKTsK KworCS8qIHNlZSB0aGUgY29tbWVudCBvbiBNSU5fTlJfR0VOUyAqLworCXJldHVybiBnZW4gPT0g bHJ1X2dlbl9mcm9tX3NlcShtYXhfc2VxKSB8fCBnZW4gPT0gbHJ1X2dlbl9mcm9tX3NlcShtYXhf c2VxIC0gMSk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX3VwZGF0ZV9zaXplKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IGZvbGlvICpmb2xpbywKKwkJCQkgICAgICAgaW50 IG9sZF9nZW4sIGludCBuZXdfZ2VuKQoreworCWludCB0eXBlID0gZm9saW9faXNfZmlsZV9scnUo Zm9saW8pOworCWludCB6b25lID0gZm9saW9fem9uZW51bShmb2xpbyk7CisJaW50IGRlbHRhID0g Zm9saW9fbnJfcGFnZXMoZm9saW8pOworCWVudW0gbHJ1X2xpc3QgbHJ1ID0gdHlwZSAqIExSVV9J TkFDVElWRV9GSUxFOworCXN0cnVjdCBscnVfZ2VuX3N0cnVjdCAqbHJ1Z2VuID0gJmxydXZlYy0+ bHJ1Z2VuOworCisJVk1fQlVHX09OKG9sZF9nZW4gIT0gLTEgJiYgb2xkX2dlbiA+PSBNQVhfTlJf R0VOUyk7CisJVk1fQlVHX09OKG5ld19nZW4gIT0gLTEgJiYgbmV3X2dlbiA+PSBNQVhfTlJfR0VO Uyk7CisJVk1fQlVHX09OKG9sZF9nZW4gPT0gLTEgJiYgbmV3X2dlbiA9PSAtMSk7CisKKwlpZiAo b2xkX2dlbiA+PSAwKQorCQlXUklURV9PTkNFKGxydWdlbi0+bnJfcGFnZXNbb2xkX2dlbl1bdHlw ZV1bem9uZV0sCisJCQkgICBscnVnZW4tPm5yX3BhZ2VzW29sZF9nZW5dW3R5cGVdW3pvbmVdIC0g ZGVsdGEpOworCWlmIChuZXdfZ2VuID49IDApCisJCVdSSVRFX09OQ0UobHJ1Z2VuLT5ucl9wYWdl c1tuZXdfZ2VuXVt0eXBlXVt6b25lXSwKKwkJCSAgIGxydWdlbi0+bnJfcGFnZXNbbmV3X2dlbl1b dHlwZV1bem9uZV0gKyBkZWx0YSk7CisKKwkvKiBhZGRpdGlvbiAqLworCWlmIChvbGRfZ2VuIDwg MCkgeworCQlpZiAobHJ1X2dlbl9pc19hY3RpdmUobHJ1dmVjLCBuZXdfZ2VuKSkKKwkJCWxydSAr PSBMUlVfQUNUSVZFOworCQlfX3VwZGF0ZV9scnVfc2l6ZShscnV2ZWMsIGxydSwgem9uZSwgZGVs dGEpOworCQlyZXR1cm47CisJfQorCisJLyogZGVsZXRpb24gKi8KKwlpZiAobmV3X2dlbiA8IDAp IHsKKwkJaWYgKGxydV9nZW5faXNfYWN0aXZlKGxydXZlYywgb2xkX2dlbikpCisJCQlscnUgKz0g TFJVX0FDVElWRTsKKwkJX191cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIHpvbmUsIC1kZWx0 YSk7CisJCXJldHVybjsKKwl9Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2FkZF9m b2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sIGJvb2wgcmVj bGFpbWluZykKK3sKKwlpbnQgZ2VuOworCXVuc2lnbmVkIGxvbmcgb2xkX2ZsYWdzLCBuZXdfZmxh Z3M7CisJaW50IHR5cGUgPSBmb2xpb19pc19maWxlX2xydShmb2xpbyk7CisJaW50IHpvbmUgPSBm b2xpb196b25lbnVtKGZvbGlvKTsKKwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZs cnV2ZWMtPmxydWdlbjsKKworCWlmIChmb2xpb190ZXN0X3VuZXZpY3RhYmxlKGZvbGlvKSkKKwkJ cmV0dXJuIGZhbHNlOworCS8qCisJICogVGhlcmUgYXJlIHRocmVlIGNvbW1vbiBjYXNlcyBmb3Ig dGhpcyBwYWdlOgorCSAqIDEuIElmIGl0J3MgaG90LCBlLmcuLCBmcmVzaGx5IGZhdWx0ZWQgaW4g b3IgcHJldmlvdXNseSBob3QgYW5kCisJICogICAgbWlncmF0ZWQsIGFkZCBpdCB0byB0aGUgeW91 bmdlc3QgZ2VuZXJhdGlvbi4KKwkgKiAyLiBJZiBpdCdzIGNvbGQgYnV0IGNhbid0IGJlIGV2aWN0 ZWQgaW1tZWRpYXRlbHksIGkuZS4sIGFuIGFub24gcGFnZQorCSAqICAgIG5vdCBpbiBzd2FwY2Fj aGUgb3IgYSBkaXJ0eSBwYWdlIHBlbmRpbmcgd3JpdGViYWNrLCBhZGQgaXQgdG8gdGhlCisJICog ICAgc2Vjb25kIG9sZGVzdCBnZW5lcmF0aW9uLgorCSAqIDMuIEV2ZXJ5dGhpbmcgZWxzZSAoY2xl YW4sIGNvbGQpIGlzIGFkZGVkIHRvIHRoZSBvbGRlc3QgZ2VuZXJhdGlvbi4KKwkgKi8KKwlpZiAo Zm9saW9fdGVzdF9hY3RpdmUoZm9saW8pKQorCQlnZW4gPSBscnVfZ2VuX2Zyb21fc2VxKGxydWdl bi0+bWF4X3NlcSk7CisJZWxzZSBpZiAoKHR5cGUgPT0gTFJVX0dFTl9BTk9OICYmICFmb2xpb190 ZXN0X3N3YXBjYWNoZShmb2xpbykpIHx8CisJCSAoZm9saW9fdGVzdF9yZWNsYWltKGZvbGlvKSAm JgorCQkgIChmb2xpb190ZXN0X2RpcnR5KGZvbGlvKSB8fCBmb2xpb190ZXN0X3dyaXRlYmFjayhm b2xpbykpKSkKKwkJZ2VuID0gbHJ1X2dlbl9mcm9tX3NlcShscnVnZW4tPm1pbl9zZXFbdHlwZV0g KyAxKTsKKwllbHNlCisJCWdlbiA9IGxydV9nZW5fZnJvbV9zZXEobHJ1Z2VuLT5taW5fc2VxW3R5 cGVdKTsKKworCWRvIHsKKwkJbmV3X2ZsYWdzID0gb2xkX2ZsYWdzID0gUkVBRF9PTkNFKGZvbGlv LT5mbGFncyk7CisJCVZNX0JVR19PTl9GT0xJTyhuZXdfZmxhZ3MgJiBMUlVfR0VOX01BU0ssIGZv bGlvKTsKKworCQkvKiBzZWUgdGhlIGNvbW1lbnQgb24gTUlOX05SX0dFTlMgKi8KKwkJbmV3X2Zs YWdzICY9IH4oTFJVX0dFTl9NQVNLIHwgQklUKFBHX2FjdGl2ZSkpOworCQluZXdfZmxhZ3MgfD0g KGdlbiArIDFVTCkgPDwgTFJVX0dFTl9QR09GRjsKKwl9IHdoaWxlIChjbXB4Y2hnKCZmb2xpby0+ ZmxhZ3MsIG9sZF9mbGFncywgbmV3X2ZsYWdzKSAhPSBvbGRfZmxhZ3MpOworCisJbHJ1X2dlbl91 cGRhdGVfc2l6ZShscnV2ZWMsIGZvbGlvLCAtMSwgZ2VuKTsKKwkvKiBmb3IgZm9saW9fcm90YXRl X3JlY2xhaW1hYmxlKCkgKi8KKwlpZiAocmVjbGFpbWluZykKKwkJbGlzdF9hZGRfdGFpbCgmZm9s aW8tPmxydSwgJmxydWdlbi0+bGlzdHNbZ2VuXVt0eXBlXVt6b25lXSk7CisJZWxzZQorCQlsaXN0 X2FkZCgmZm9saW8tPmxydSwgJmxydWdlbi0+bGlzdHNbZ2VuXVt0eXBlXVt6b25lXSk7CisKKwly ZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fZGVsX2ZvbGlvKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IGZvbGlvICpmb2xpbywgYm9vbCByZWNsYWltaW5n KQoreworCWludCBnZW47CisJdW5zaWduZWQgbG9uZyBvbGRfZmxhZ3MsIG5ld19mbGFnczsKKwor CWRvIHsKKwkJbmV3X2ZsYWdzID0gb2xkX2ZsYWdzID0gUkVBRF9PTkNFKGZvbGlvLT5mbGFncyk7 CisJCWlmICghKG5ld19mbGFncyAmIExSVV9HRU5fTUFTSykpCisJCQlyZXR1cm4gZmFsc2U7CisK KwkJVk1fQlVHX09OX0ZPTElPKGZvbGlvX3Rlc3RfYWN0aXZlKGZvbGlvKSwgZm9saW8pOworCQlW TV9CVUdfT05fRk9MSU8oZm9saW9fdGVzdF91bmV2aWN0YWJsZShmb2xpbyksIGZvbGlvKTsKKwor CQlnZW4gPSAoKG5ld19mbGFncyAmIExSVV9HRU5fTUFTSykgPj4gTFJVX0dFTl9QR09GRikgLSAx OworCisJCW5ld19mbGFncyAmPSB+TFJVX0dFTl9NQVNLOworCQkvKiBmb3Igc2hyaW5rX3BhZ2Vf bGlzdCgpICovCisJCWlmIChyZWNsYWltaW5nKQorCQkJbmV3X2ZsYWdzICY9IH4oQklUKFBHX3Jl ZmVyZW5jZWQpIHwgQklUKFBHX3JlY2xhaW0pKTsKKwkJZWxzZSBpZiAobHJ1X2dlbl9pc19hY3Rp dmUobHJ1dmVjLCBnZW4pKQorCQkJbmV3X2ZsYWdzIHw9IEJJVChQR19hY3RpdmUpOworCX0gd2hp bGUgKGNtcHhjaGcoJmZvbGlvLT5mbGFncywgb2xkX2ZsYWdzLCBuZXdfZmxhZ3MpICE9IG9sZF9m bGFncyk7CisKKwlscnVfZ2VuX3VwZGF0ZV9zaXplKGxydXZlYywgZm9saW8sIGdlbiwgLTEpOwor CWxpc3RfZGVsKCZmb2xpby0+bHJ1KTsKKworCXJldHVybiB0cnVlOworfQorCisjZWxzZQorCitz dGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9lbmFibGVkKHZvaWQpCit7CisJcmV0dXJuIGZhbHNl OworfQorCitzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9pbl9mYXVsdCh2b2lkKQoreworCXJl dHVybiBmYWxzZTsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fYWRkX2ZvbGlvKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IGZvbGlvICpmb2xpbywgYm9vbCByZWNsYWltaW5n KQoreworCXJldHVybiBmYWxzZTsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fZGVs X2ZvbGlvKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgc3RydWN0IGZvbGlvICpmb2xpbywgYm9vbCBy ZWNsYWltaW5nKQoreworCXJldHVybiBmYWxzZTsKK30KKworI2VuZGlmIC8qIENPTkZJR19MUlVf R0VOICovCisKIHN0YXRpYyBfX2Fsd2F5c19pbmxpbmUKIHZvaWQgbHJ1dmVjX2FkZF9mb2xpbyhz dHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8pCiB7CiAJZW51bSBscnVf bGlzdCBscnUgPSBmb2xpb19scnVfbGlzdChmb2xpbyk7CiAKKwlpZiAobHJ1X2dlbl9hZGRfZm9s aW8obHJ1dmVjLCBmb2xpbywgZmFsc2UpKQorCQlyZXR1cm47CisKIAl1cGRhdGVfbHJ1X3NpemUo bHJ1dmVjLCBscnUsIGZvbGlvX3pvbmVudW0oZm9saW8pLAogCQkJZm9saW9fbnJfcGFnZXMoZm9s aW8pKTsKIAlsaXN0X2FkZCgmZm9saW8tPmxydSwgJmxydXZlYy0+bGlzdHNbbHJ1XSk7CkBAIC0x MjAsNiArMjkwLDkgQEAgdm9pZCBscnV2ZWNfYWRkX2ZvbGlvX3RhaWwoc3RydWN0IGxydXZlYyAq bHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlvKQogewogCWVudW0gbHJ1X2xpc3QgbHJ1ID0gZm9s aW9fbHJ1X2xpc3QoZm9saW8pOwogCisJaWYgKGxydV9nZW5fYWRkX2ZvbGlvKGxydXZlYywgZm9s aW8sIHRydWUpKQorCQlyZXR1cm47CisKIAl1cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIGZv bGlvX3pvbmVudW0oZm9saW8pLAogCQkJZm9saW9fbnJfcGFnZXMoZm9saW8pKTsKIAlsaXN0X2Fk ZF90YWlsKCZmb2xpby0+bHJ1LCAmbHJ1dmVjLT5saXN0c1tscnVdKTsKQEAgLTEzNCw2ICszMDcs OSBAQCBzdGF0aWMgX19hbHdheXNfaW5saW5lIHZvaWQgYWRkX3BhZ2VfdG9fbHJ1X2xpc3RfdGFp bChzdHJ1Y3QgcGFnZSAqcGFnZSwKIHN0YXRpYyBfX2Fsd2F5c19pbmxpbmUKIHZvaWQgbHJ1dmVj X2RlbF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8pCiB7 CisJaWYgKGxydV9nZW5fZGVsX2ZvbGlvKGxydXZlYywgZm9saW8sIGZhbHNlKSkKKwkJcmV0dXJu OworCiAJbGlzdF9kZWwoJmZvbGlvLT5scnUpOwogCXVwZGF0ZV9scnVfc2l6ZShscnV2ZWMsIGZv bGlvX2xydV9saXN0KGZvbGlvKSwgZm9saW9fem9uZW51bShmb2xpbyksCiAJCQktZm9saW9fbnJf cGFnZXMoZm9saW8pKTsKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbW16b25lLmggYi9pbmNs dWRlL2xpbnV4L21tem9uZS5oCmluZGV4IGFlZDQ0ZTliNWQ4OS4uYThlYjYxOWY3NDJjIDEwMDY0 NAotLS0gYS9pbmNsdWRlL2xpbnV4L21tem9uZS5oCisrKyBiL2luY2x1ZGUvbGludXgvbW16b25l LmgKQEAgLTMwMyw2ICszMDMsODggQEAgZW51bSBscnV2ZWNfZmxhZ3MgewogCQkJCQkgKi8KIH07 CiAKK3N0cnVjdCBscnV2ZWM7CisKKyNkZWZpbmUgTFJVX0dFTl9NQVNLCQkoKEJJVChMUlVfR0VO X1dJRFRIKSAtIDEpIDw8IExSVV9HRU5fUEdPRkYpCisjZGVmaW5lIExSVV9SRUZTX01BU0sJCSgo QklUKExSVV9SRUZTX1dJRFRIKSAtIDEpIDw8IExSVV9SRUZTX1BHT0ZGKQorCisjaWZkZWYgQ09O RklHX0xSVV9HRU4KKworZW51bSB7CisJTFJVX0dFTl9BTk9OLAorCUxSVV9HRU5fRklMRSwKK307 CisKKy8qCisgKiBFdmljdGFibGUgcGFnZXMgYXJlIGRpdmlkZWQgaW50byBtdWx0aXBsZSBnZW5l cmF0aW9ucy4gVGhlIHlvdW5nZXN0IGFuZCB0aGUKKyAqIG9sZGVzdCBnZW5lcmF0aW9uIG51bWJl cnMsIG1heF9zZXEgYW5kIG1pbl9zZXEsIGFyZSBtb25vdG9uaWNhbGx5IGluY3JlYXNpbmcuCisg KiBUaGV5IGZvcm0gYSBzbGlkaW5nIHdpbmRvdyBvZiBhIHZhcmlhYmxlIHNpemUgW01JTl9OUl9H RU5TLCBNQVhfTlJfR0VOU10uIEFuCisgKiBvZmZzZXQgd2l0aGluIE1BWF9OUl9HRU5TLCBnZW4s IGluZGV4ZXMgdGhlIExSVSBsaXN0IG9mIHRoZSBjb3JyZXNwb25kaW5nCisgKiBnZW5lcmF0aW9u LiBUaGUgZ2VuIGNvdW50ZXIgaW4gZm9saW8tPmZsYWdzIHN0b3JlcyBnZW4rMSB3aGlsZSBhIHBh Z2UgaXMgb24KKyAqIG9uZSBvZiBscnVnZW4tPmxpc3RzW10uIE90aGVyd2lzZSBpdCBzdG9yZXMg MC4KKyAqCisgKiBBIHBhZ2UgaXMgYWRkZWQgdG8gdGhlIHlvdW5nZXN0IGdlbmVyYXRpb24gb24g ZmF1bHRpbmcuIFRoZSBhZ2luZyBuZWVkcyB0bworICogY2hlY2sgdGhlIGFjY2Vzc2VkIGJpdCBh dCBsZWFzdCB0d2ljZSBiZWZvcmUgaGFuZGluZyB0aGlzIHBhZ2Ugb3ZlciB0byB0aGUKKyAqIGV2 aWN0aW9uLiBUaGUgZmlyc3QgY2hlY2sgdGFrZXMgY2FyZSBvZiB0aGUgYWNjZXNzZWQgYml0IHNl dCBvbiB0aGUgaW5pdGlhbAorICogZmF1bHQ7IHRoZSBzZWNvbmQgY2hlY2sgbWFrZXMgc3VyZSB0 aGlzIHBhZ2UgaGFzbid0IGJlZW4gdXNlZCBzaW5jZSB0aGVuLgorICogVGhpcyBwcm9jZXNzLCBB S0Egc2Vjb25kIGNoYW5jZSwgcmVxdWlyZXMgYSBtaW5pbXVtIG9mIHR3byBnZW5lcmF0aW9ucywK KyAqIGhlbmNlIE1JTl9OUl9HRU5TLiBBbmQgdG8gbWFpbnRhaW4gQUJJIGNvbXBhdGliaWxpdHkg d2l0aCB0aGUgYWN0aXZlL2luYWN0aXZlCisgKiBMUlUsIHRoZXNlIHR3byBnZW5lcmF0aW9ucyBh cmUgY29uc2lkZXJlZCBhY3RpdmU7IHRoZSByZXN0IG9mIGdlbmVyYXRpb25zLCBpZgorICogdGhl eSBleGlzdCwgYXJlIGNvbnNpZGVyZWQgaW5hY3RpdmUuIFNlZSBscnVfZ2VuX2lzX2FjdGl2ZSgp LiBQR19hY3RpdmUgaXMKKyAqIGFsd2F5cyBjbGVhcmVkIHdoaWxlIGEgcGFnZSBpcyBvbiBvbmUg b2YgbHJ1Z2VuLT5saXN0c1tdIHNvIHRoYXQgdGhlIGFnaW5nCisgKiBuZWVkcyBub3QgdG8gd29y cnkgYWJvdXQgaXQuIEFuZCBpdCdzIHNldCBhZ2FpbiB3aGVuIGEgcGFnZSBjb25zaWRlcmVkIGFj dGl2ZQorICogaXMgaXNvbGF0ZWQgZm9yIG5vbi1yZWNsYWltaW5nIHB1cnBvc2VzLCBlLmcuLCBt aWdyYXRpb24uIFNlZQorICogbHJ1X2dlbl9hZGRfZm9saW8oKSBhbmQgbHJ1X2dlbl9kZWxfZm9s aW8oKS4KKyAqLworI2RlZmluZSBNSU5fTlJfR0VOUwkJMlUKKyNkZWZpbmUgTUFYX05SX0dFTlMJ CSgodW5zaWduZWQgaW50KUNPTkZJR19OUl9MUlVfR0VOUykKKworLyoKKyAqIFRoZSB5b3VuZ2Vz dCBnZW5lcmF0aW9uIG51bWJlciBpcyBzdG9yZWQgaW4gbWF4X3NlcSBmb3IgYm90aCBhbm9uIGFu ZCBmaWxlCisgKiB0eXBlcyBhcyB0aGV5IGFyZSBhZ2VkIG9uIGFuIGVxdWFsIGZvb3RpbmcuIFRo ZSBvbGRlc3QgZ2VuZXJhdGlvbiBudW1iZXJzIGFyZQorICogc3RvcmVkIGluIG1pbl9zZXFbXSBz ZXBhcmF0ZWx5IGZvciBhbm9uIGFuZCBmaWxlIHR5cGVzIGFzIGNsZWFuIGZpbGUgcGFnZXMKKyAq IGNhbiBiZSBldmljdGVkIHJlZ2FyZGxlc3Mgb2Ygc3dhcCBjb25zdHJhaW50cy4KKyAqCisgKiBO b3JtYWxseSBhbm9uIGFuZCBmaWxlIG1pbl9zZXEgYXJlIGluIHN5bmMuIEJ1dCBpZiBzd2FwcGlu ZyBpcyBjb25zdHJhaW5lZCwKKyAqIGUuZy4sIG91dCBvZiBzd2FwIHNwYWNlLCBmaWxlIG1pbl9z ZXEgaXMgYWxsb3dlZCB0byBhZHZhbmNlIGFuZCBsZWF2ZSBhbm9uCisgKiBtaW5fc2VxIGJlaGlu ZC4KKyAqLworc3RydWN0IGxydV9nZW5fc3RydWN0IHsKKwkvKiB0aGUgYWdpbmcgaW5jcmVtZW50 cyB0aGUgeW91bmdlc3QgZ2VuZXJhdGlvbiBudW1iZXIgKi8KKwl1bnNpZ25lZCBsb25nIG1heF9z ZXE7CisJLyogdGhlIGV2aWN0aW9uIGluY3JlbWVudHMgdGhlIG9sZGVzdCBnZW5lcmF0aW9uIG51 bWJlcnMgKi8KKwl1bnNpZ25lZCBsb25nIG1pbl9zZXFbQU5PTl9BTkRfRklMRV07CisJLyogdGhl IG11bHRpLWdlbiBMUlUgbGlzdHMgKi8KKwlzdHJ1Y3QgbGlzdF9oZWFkIGxpc3RzW01BWF9OUl9H RU5TXVtBTk9OX0FORF9GSUxFXVtNQVhfTlJfWk9ORVNdOworCS8qIHRoZSBzaXplcyBvZiB0aGUg YWJvdmUgbGlzdHMgKi8KKwl1bnNpZ25lZCBsb25nIG5yX3BhZ2VzW01BWF9OUl9HRU5TXVtBTk9O X0FORF9GSUxFXVtNQVhfTlJfWk9ORVNdOworfTsKKwordm9pZCBscnVfZ2VuX2luaXRfbHJ1dmVj KHN0cnVjdCBscnV2ZWMgKmxydXZlYyk7CisKKyNpZmRlZiBDT05GSUdfTUVNQ0cKK3ZvaWQgbHJ1 X2dlbl9pbml0X21lbWNnKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZyk7Cit2b2lkIGxydV9nZW5f ZXhpdF9tZW1jZyhzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cpOworI2VuZGlmCisKKyNlbHNlIC8q ICFDT05GSUdfTFJVX0dFTiAqLworCitzdGF0aWMgaW5saW5lIHZvaWQgbHJ1X2dlbl9pbml0X2xy dXZlYyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMpCit7Cit9CisKKyNpZmRlZiBDT05GSUdfTUVNQ0cK K3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbWVtY2coc3RydWN0IG1lbV9jZ3JvdXAg Km1lbWNnKQoreworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbHJ1X2dlbl9leGl0X21lbWNnKHN0 cnVjdCBtZW1fY2dyb3VwICptZW1jZykKK3sKK30KKyNlbmRpZgorCisjZW5kaWYgLyogQ09ORklH X0xSVV9HRU4gKi8KKwogc3RydWN0IGxydXZlYyB7CiAJc3RydWN0IGxpc3RfaGVhZAkJbGlzdHNb TlJfTFJVX0xJU1RTXTsKIAkvKiBwZXIgbHJ1dmVjIGxydV9sb2NrIGZvciBtZW1jZyAqLwpAQCAt MzIwLDYgKzQwMiwxMCBAQCBzdHJ1Y3QgbHJ1dmVjIHsKIAl1bnNpZ25lZCBsb25nCQkJcmVmYXVs dHNbQU5PTl9BTkRfRklMRV07CiAJLyogVmFyaW91cyBscnV2ZWMgc3RhdGUgZmxhZ3MgKGVudW0g bHJ1dmVjX2ZsYWdzKSAqLwogCXVuc2lnbmVkIGxvbmcJCQlmbGFnczsKKyNpZmRlZiBDT05GSUdf TFJVX0dFTgorCS8qIGV2aWN0YWJsZSBwYWdlcyBkaXZpZGVkIGludG8gZ2VuZXJhdGlvbnMgKi8K KwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QJCWxydWdlbjsKKyNlbmRpZgogI2lmZGVmIENPTkZJR19N RU1DRwogCXN0cnVjdCBwZ2xpc3RfZGF0YSAqcGdkYXQ7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgvcGFnZS1mbGFncy1sYXlvdXQuaCBiL2luY2x1ZGUvbGludXgvcGFnZS1mbGFn cy1sYXlvdXQuaAppbmRleCBlZjFlM2U3MzZlMTQuLmRiNDdlYmQ2NzJlOCAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxheW91dC5oCisrKyBiL2luY2x1ZGUvbGludXgvcGFn ZS1mbGFncy1sYXlvdXQuaApAQCAtMjYsNiArMjYsMTQgQEAKIAogI2RlZmluZSBaT05FU19XSURU SAkJWk9ORVNfU0hJRlQKIAorI2lmZGVmIENPTkZJR19MUlVfR0VOCisvKiBMUlVfR0VOX1dJRFRI IGlzIGdlbmVyYXRlZCBmcm9tIG9yZGVyX2Jhc2VfMihDT05GSUdfTlJfTFJVX0dFTlMgKyAxKS4g Ki8KKyNkZWZpbmUgTFJVX1JFRlNfV0lEVEgJCTAKKyNlbHNlCisjZGVmaW5lIExSVV9HRU5fV0lE VEgJCTAKKyNkZWZpbmUgTFJVX1JFRlNfV0lEVEgJCTAKKyNlbmRpZiAvKiBDT05GSUdfTFJVX0dF TiAqLworCiAjaWZkZWYgQ09ORklHX1NQQVJTRU1FTQogI2luY2x1ZGUgPGFzbS9zcGFyc2VtZW0u aD4KICNkZWZpbmUgU0VDVElPTlNfU0hJRlQJKE1BWF9QSFlTTUVNX0JJVFMgLSBTRUNUSU9OX1NJ WkVfQklUUykKQEAgLTU1LDcgKzYzLDggQEAKICNkZWZpbmUgU0VDVElPTlNfV0lEVEgJCTAKICNl bmRpZgogCi0jaWYgWk9ORVNfV0lEVEggKyBTRUNUSU9OU19XSURUSCArIE5PREVTX1NISUZUIDw9 IEJJVFNfUEVSX0xPTkcgLSBOUl9QQUdFRkxBR1MKKyNpZiBaT05FU19XSURUSCArIExSVV9HRU5f V0lEVEggKyBMUlVfUkVGU19XSURUSCArIFNFQ1RJT05TX1dJRFRIICsgTk9ERVNfU0hJRlQgXAor CTw9IEJJVFNfUEVSX0xPTkcgLSBOUl9QQUdFRkxBR1MKICNkZWZpbmUgTk9ERVNfV0lEVEgJCU5P REVTX1NISUZUCiAjZWxpZiBkZWZpbmVkKENPTkZJR19TUEFSU0VNRU1fVk1FTU1BUCkKICNlcnJv ciAiVm1lbW1hcDogTm8gc3BhY2UgZm9yIG5vZGVzIGZpZWxkIGluIHBhZ2UgZmxhZ3MiCkBAIC04 OSw4ICs5OCw4IEBACiAjZGVmaW5lIExBU1RfQ1BVUElEX1NISUZUIDAKICNlbmRpZgogCi0jaWYg Wk9ORVNfV0lEVEggKyBTRUNUSU9OU19XSURUSCArIE5PREVTX1dJRFRIICsgS0FTQU5fVEFHX1dJ RFRIICsgTEFTVF9DUFVQSURfU0hJRlQgXAotCTw9IEJJVFNfUEVSX0xPTkcgLSBOUl9QQUdFRkxB R1MKKyNpZiBaT05FU19XSURUSCArIExSVV9HRU5fV0lEVEggKyBMUlVfUkVGU19XSURUSCArIFNF Q1RJT05TX1dJRFRIICsgTk9ERVNfV0lEVEggKyBcCisJS0FTQU5fVEFHX1dJRFRIICsgTEFTVF9D UFVQSURfU0hJRlQgPD0gQklUU19QRVJfTE9ORyAtIE5SX1BBR0VGTEFHUwogI2RlZmluZSBMQVNU X0NQVVBJRF9XSURUSCBMQVNUX0NQVVBJRF9TSElGVAogI2Vsc2UKICNkZWZpbmUgTEFTVF9DUFVQ SURfV0lEVEggMApAQCAtMTAwLDggKzEwOSw4IEBACiAjZGVmaW5lIExBU1RfQ1BVUElEX05PVF9J Tl9QQUdFX0ZMQUdTCiAjZW5kaWYKIAotI2lmIFpPTkVTX1dJRFRIICsgU0VDVElPTlNfV0lEVEgg KyBOT0RFU19XSURUSCArIEtBU0FOX1RBR19XSURUSCArIExBU1RfQ1BVUElEX1dJRFRIIFwKLQk+ IEJJVFNfUEVSX0xPTkcgLSBOUl9QQUdFRkxBR1MKKyNpZiBaT05FU19XSURUSCArIExSVV9HRU5f V0lEVEggKyBMUlVfUkVGU19XSURUSCArIFNFQ1RJT05TX1dJRFRIICsgTk9ERVNfV0lEVEggKyBc CisJS0FTQU5fVEFHX1dJRFRIICsgTEFTVF9DUFVQSURfV0lEVEggPiBCSVRTX1BFUl9MT05HIC0g TlJfUEFHRUZMQUdTCiAjZXJyb3IgIk5vdCBlbm91Z2ggYml0cyBpbiBwYWdlIGZsYWdzIgogI2Vu ZGlmCiAKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcGFnZS1mbGFncy5oIGIvaW5jbHVkZS9s aW51eC9wYWdlLWZsYWdzLmgKaW5kZXggMWMzYjZlNWM4YmZkLi5hOTU1MThjYTk4ZWIgMTAwNjQ0 Ci0tLSBhL2luY2x1ZGUvbGludXgvcGFnZS1mbGFncy5oCisrKyBiL2luY2x1ZGUvbGludXgvcGFn ZS1mbGFncy5oCkBAIC05MzUsNyArOTM1LDcgQEAgX19QQUdFRkxBRyhJc29sYXRlZCwgaXNvbGF0 ZWQsIFBGX0FOWSk7CiAJIDFVTCA8PCBQR19wcml2YXRlCXwgMVVMIDw8IFBHX3ByaXZhdGVfMgl8 CVwKIAkgMVVMIDw8IFBHX3dyaXRlYmFjawl8IDFVTCA8PCBQR19yZXNlcnZlZAl8CVwKIAkgMVVM IDw8IFBHX3NsYWIJCXwgMVVMIDw8IFBHX2FjdGl2ZSAJfAlcCi0JIDFVTCA8PCBQR191bmV2aWN0 YWJsZQl8IF9fUEdfTUxPQ0tFRCkKKwkgMVVMIDw8IFBHX3VuZXZpY3RhYmxlCXwgX19QR19NTE9D S0VEIHwgTFJVX0dFTl9NQVNLKQogCiAvKgogICogRmxhZ3MgY2hlY2tlZCB3aGVuIGEgcGFnZSBp cyBwcmVwcGVkIGZvciByZXR1cm4gYnkgdGhlIHBhZ2UgYWxsb2NhdG9yLgpAQCAtOTQ2LDcgKzk0 Niw3IEBAIF9fUEFHRUZMQUcoSXNvbGF0ZWQsIGlzb2xhdGVkLCBQRl9BTlkpOwogICogYWxsb2Mt ZnJlZSBjeWNsZSB0byBwcmV2ZW50IGZyb20gcmV1c2luZyB0aGUgcGFnZS4KICAqLwogI2RlZmlu ZSBQQUdFX0ZMQUdTX0NIRUNLX0FUX1BSRVAJXAotCShQQUdFRkxBR1NfTUFTSyAmIH5fX1BHX0hX UE9JU09OKQorCSgoUEFHRUZMQUdTX01BU0sgJiB+X19QR19IV1BPSVNPTikgfCBMUlVfR0VOX01B U0sgfCBMUlVfUkVGU19NQVNLKQogCiAjZGVmaW5lIFBBR0VfRkxBR1NfUFJJVkFURQkJCQlcCiAJ KDFVTCA8PCBQR19wcml2YXRlIHwgMVVMIDw8IFBHX3ByaXZhdGVfMikKZGlmZiAtLWdpdCBhL2lu Y2x1ZGUvbGludXgvc2NoZWQuaCBiL2luY2x1ZGUvbGludXgvc2NoZWQuaAppbmRleCA3NWJhOGFh NjAyNDguLmU3ZmU3ODRiMTFhYSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9zY2hlZC5oCisr KyBiL2luY2x1ZGUvbGludXgvc2NoZWQuaApAQCAtOTE0LDYgKzkxNCwxMCBAQCBzdHJ1Y3QgdGFz a19zdHJ1Y3QgewogI2lmZGVmIENPTkZJR19NRU1DRwogCXVuc2lnbmVkCQkJaW5fdXNlcl9mYXVs dDoxOwogI2VuZGlmCisjaWZkZWYgQ09ORklHX0xSVV9HRU4KKwkvKiB3aGV0aGVyIHRoZSBMUlUg YWxnb3JpdGhtIG1heSBhcHBseSB0byB0aGlzIGFjY2VzcyAqLworCXVuc2lnbmVkCQkJaW5fbHJ1 X2ZhdWx0OjE7CisjZW5kaWYKICNpZmRlZiBDT05GSUdfQ09NUEFUX0JSSwogCXVuc2lnbmVkCQkJ YnJrX3JhbmRvbWl6ZWQ6MTsKICNlbmRpZgpkaWZmIC0tZ2l0IGEva2VybmVsL2JvdW5kcy5jIGIv a2VybmVsL2JvdW5kcy5jCmluZGV4IDk3OTVkNzViMDliMi4uYWJhMTNhYTczMzZjIDEwMDY0NAot LS0gYS9rZXJuZWwvYm91bmRzLmMKKysrIGIva2VybmVsL2JvdW5kcy5jCkBAIC0yMiw2ICsyMiw5 IEBAIGludCBtYWluKHZvaWQpCiAJREVGSU5FKE5SX0NQVVNfQklUUywgaWxvZzIoQ09ORklHX05S X0NQVVMpKTsKICNlbmRpZgogCURFRklORShTUElOTE9DS19TSVpFLCBzaXplb2Yoc3BpbmxvY2tf dCkpOworI2lmZGVmIENPTkZJR19MUlVfR0VOCisJREVGSU5FKExSVV9HRU5fV0lEVEgsIG9yZGVy X2Jhc2VfMihDT05GSUdfTlJfTFJVX0dFTlMgKyAxKSk7CisjZW5kaWYKIAkvKiBFbmQgb2YgY29u c3RhbnRzICovCiAKIAlyZXR1cm4gMDsKZGlmZiAtLWdpdCBhL21tL0tjb25maWcgYi9tbS9LY29u ZmlnCmluZGV4IDMzMjZlZTM5MDNmMy4uNGVmNjdmMTU3Mzc0IDEwMDY0NAotLS0gYS9tbS9LY29u ZmlnCisrKyBiL21tL0tjb25maWcKQEAgLTg5Miw2ICs4OTIsMjggQEAgY29uZmlnIEFOT05fVk1B X05BTUUKIAkgIGFyZWEgZnJvbSBiZWluZyBtZXJnZWQgd2l0aCBhZGphY2VudCB2aXJ0dWFsIG1l bW9yeSBhcmVhcyBkdWUgdG8gdGhlCiAJICBkaWZmZXJlbmNlIGluIHRoZWlyIG5hbWUuCiAKKyMg dGhlIG11bHRpLWdlbiBMUlUgeworY29uZmlnIExSVV9HRU4KKwlib29sICJNdWx0aS1HZW4gTFJV IgorCWRlcGVuZHMgb24gTU1VCisJIyB0aGUgZm9sbG93aW5nIG9wdGlvbnMgY2FuIHVzZSB1cCB0 aGUgc3BhcmUgYml0cyBpbiBwYWdlIGZsYWdzCisJZGVwZW5kcyBvbiAhTUFYU01QICYmICg2NEJJ VCB8fCAhU1BBUlNFTUVNIHx8IFNQQVJTRU1FTV9WTUVNTUFQKQorCWhlbHAKKwkgIEEgaGlnaCBw ZXJmb3JtYW5jZSBMUlUgaW1wbGVtZW50YXRpb24gZm9yIG1lbW9yeSBvdmVyY29tbWl0LgorCitj b25maWcgTlJfTFJVX0dFTlMKKwlpbnQgIk1heCBudW1iZXIgb2YgZ2VuZXJhdGlvbnMiCisJZGVw ZW5kcyBvbiBMUlVfR0VOCisJcmFuZ2UgNCAzMQorCWRlZmF1bHQgNAorCWhlbHAKKwkgIERvIG5v dCBpbmNyZWFzZSB0aGlzIHZhbHVlIHVubGVzcyB5b3UgcGxhbiB0byB1c2Ugd29ya2luZyBzZXQK KwkgIGVzdGltYXRpb24gYW5kIHByb2FjdGl2ZSByZWNsYWltLiBUaGVzZSBmZWF0dXJlcyBhcmUg dXN1YWxseSBmb3Igam9iCisJICBzY2hlZHVsaW5nIG9wdGltaXphdGlvbnMgaW4gZGF0YSBjZW50 ZXJzLgorCisJICBUaGlzIG9wdGlvbiB1c2VzIG9yZGVyX2Jhc2VfMihOKzEpIGJpdHMgaW4gcGFn ZSBmbGFncy4KKyMgfQorCiBzb3VyY2UgIm1tL2RhbW9uL0tjb25maWciCiAKIGVuZG1lbnUKZGlm ZiAtLWdpdCBhL21tL2h1Z2VfbWVtb3J5LmMgYi9tbS9odWdlX21lbW9yeS5jCmluZGV4IDQwNmEz YzI4YzAyNi4uM2RmMzg5ZmQzMDdmIDEwMDY0NAotLS0gYS9tbS9odWdlX21lbW9yeS5jCisrKyBi L21tL2h1Z2VfbWVtb3J5LmMKQEAgLTIzNjQsNyArMjM2NCw4IEBAIHN0YXRpYyB2b2lkIF9fc3Bs aXRfaHVnZV9wYWdlX3RhaWwoc3RydWN0IHBhZ2UgKmhlYWQsIGludCB0YWlsLAogI2lmZGVmIENP TkZJR182NEJJVAogCQkJICgxTCA8PCBQR19hcmNoXzIpIHwKICNlbmRpZgotCQkJICgxTCA8PCBQ R19kaXJ0eSkpKTsKKwkJCSAoMUwgPDwgUEdfZGlydHkpIHwKKwkJCSBMUlVfR0VOX01BU0sgfCBM UlVfUkVGU19NQVNLKSk7CiAKIAkvKiAtPm1hcHBpbmcgaW4gZmlyc3QgdGFpbCBwYWdlIGlzIGNv bXBvdW5kX21hcGNvdW50ICovCiAJVk1fQlVHX09OX1BBR0UodGFpbCA+IDIgJiYgcGFnZV90YWls LT5tYXBwaW5nICE9IFRBSUxfTUFQUElORywKZGlmZiAtLWdpdCBhL21tL21lbWNvbnRyb2wuYyBi L21tL21lbWNvbnRyb2wuYwppbmRleCAzNmU5ZjM4YzkxOWQuLjNmY2JmZWRhMjU5YiAxMDA2NDQK LS0tIGEvbW0vbWVtY29udHJvbC5jCisrKyBiL21tL21lbWNvbnRyb2wuYwpAQCAtNTEyMSw2ICs1 MTIxLDcgQEAgc3RhdGljIHZvaWQgX19tZW1fY2dyb3VwX2ZyZWUoc3RydWN0IG1lbV9jZ3JvdXAg Km1lbWNnKQogCiBzdGF0aWMgdm9pZCBtZW1fY2dyb3VwX2ZyZWUoc3RydWN0IG1lbV9jZ3JvdXAg Km1lbWNnKQogeworCWxydV9nZW5fZXhpdF9tZW1jZyhtZW1jZyk7CiAJbWVtY2dfd2JfZG9tYWlu X2V4aXQobWVtY2cpOwogCV9fbWVtX2Nncm91cF9mcmVlKG1lbWNnKTsKIH0KQEAgLTUxODAsNiAr NTE4MSw3IEBAIHN0YXRpYyBzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtX2Nncm91cF9hbGxvYyh2b2lk KQogCW1lbWNnLT5kZWZlcnJlZF9zcGxpdF9xdWV1ZS5zcGxpdF9xdWV1ZV9sZW4gPSAwOwogI2Vu ZGlmCiAJaWRyX3JlcGxhY2UoJm1lbV9jZ3JvdXBfaWRyLCBtZW1jZywgbWVtY2ctPmlkLmlkKTsK KwlscnVfZ2VuX2luaXRfbWVtY2cobWVtY2cpOwogCXJldHVybiBtZW1jZzsKIGZhaWw6CiAJbWVt X2Nncm91cF9pZF9yZW1vdmUobWVtY2cpOwpkaWZmIC0tZ2l0IGEvbW0vbWVtb3J5LmMgYi9tbS9t ZW1vcnkuYwppbmRleCBhNzM3OTE5NmE0N2UuLmQyN2U1ZjFhMjUzMyAxMDA2NDQKLS0tIGEvbW0v bWVtb3J5LmMKKysrIGIvbW0vbWVtb3J5LmMKQEAgLTQ3NTQsNiArNDc1NCwyNyBAQCBzdGF0aWMg aW5saW5lIHZvaWQgbW1fYWNjb3VudF9mYXVsdChzdHJ1Y3QgcHRfcmVncyAqcmVncywKIAkJcGVy Zl9zd19ldmVudChQRVJGX0NPVU5UX1NXX1BBR0VfRkFVTFRTX01JTiwgMSwgcmVncywgYWRkcmVz cyk7CiB9CiAKKyNpZmRlZiBDT05GSUdfTFJVX0dFTgorc3RhdGljIHZvaWQgbHJ1X2dlbl9lbnRl cl9mYXVsdChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwkvKiB0aGUgTFJVIGFsZ29y aXRobSBkb2Vzbid0IGFwcGx5IHRvIHNlcXVlbnRpYWwgb3IgcmFuZG9tIHJlYWRzICovCisJY3Vy cmVudC0+aW5fbHJ1X2ZhdWx0ID0gISh2bWEtPnZtX2ZsYWdzICYgKFZNX1NFUV9SRUFEIHwgVk1f UkFORF9SRUFEKSk7Cit9CisKK3N0YXRpYyB2b2lkIGxydV9nZW5fZXhpdF9mYXVsdCh2b2lkKQor eworCWN1cnJlbnQtPmluX2xydV9mYXVsdCA9IGZhbHNlOworfQorI2Vsc2UKK3N0YXRpYyB2b2lk IGxydV9nZW5fZW50ZXJfZmF1bHQoc3RydWN0IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7Cit9CisK K3N0YXRpYyB2b2lkIGxydV9nZW5fZXhpdF9mYXVsdCh2b2lkKQoreworfQorI2VuZGlmIC8qIENP TkZJR19MUlVfR0VOICovCisKIC8qCiAgKiBCeSB0aGUgdGltZSB3ZSBnZXQgaGVyZSwgd2UgYWxy ZWFkeSBob2xkIHRoZSBtbSBzZW1hcGhvcmUKICAqCkBAIC00Nzg1LDExICs0ODA2LDE1IEBAIHZt X2ZhdWx0X3QgaGFuZGxlX21tX2ZhdWx0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLCB1bnNp Z25lZCBsb25nIGFkZHJlc3MsCiAJaWYgKGZsYWdzICYgRkFVTFRfRkxBR19VU0VSKQogCQltZW1f Y2dyb3VwX2VudGVyX3VzZXJfZmF1bHQoKTsKIAorCWxydV9nZW5fZW50ZXJfZmF1bHQodm1hKTsK KwogCWlmICh1bmxpa2VseShpc192bV9odWdldGxiX3BhZ2Uodm1hKSkpCiAJCXJldCA9IGh1Z2V0 bGJfZmF1bHQodm1hLT52bV9tbSwgdm1hLCBhZGRyZXNzLCBmbGFncyk7CiAJZWxzZQogCQlyZXQg PSBfX2hhbmRsZV9tbV9mYXVsdCh2bWEsIGFkZHJlc3MsIGZsYWdzKTsKIAorCWxydV9nZW5fZXhp dF9mYXVsdCgpOworCiAJaWYgKGZsYWdzICYgRkFVTFRfRkxBR19VU0VSKSB7CiAJCW1lbV9jZ3Jv dXBfZXhpdF91c2VyX2ZhdWx0KCk7CiAJCS8qCmRpZmYgLS1naXQgYS9tbS9tbV9pbml0LmMgYi9t bS9tbV9pbml0LmMKaW5kZXggOWRkYWYwZTFiMGFiLi4wZDdiMmJkMjQ1NGEgMTAwNjQ0Ci0tLSBh L21tL21tX2luaXQuYworKysgYi9tbS9tbV9pbml0LmMKQEAgLTY1LDE0ICs2NSwxNiBAQCB2b2lk IF9faW5pdCBtbWluaXRfdmVyaWZ5X3BhZ2VmbGFnc19sYXlvdXQodm9pZCkKIAogCXNoaWZ0ID0g OCAqIHNpemVvZih1bnNpZ25lZCBsb25nKTsKIAl3aWR0aCA9IHNoaWZ0IC0gU0VDVElPTlNfV0lE VEggLSBOT0RFU19XSURUSCAtIFpPTkVTX1dJRFRICi0JCS0gTEFTVF9DUFVQSURfU0hJRlQgLSBL QVNBTl9UQUdfV0lEVEg7CisJCS0gTEFTVF9DUFVQSURfU0hJRlQgLSBLQVNBTl9UQUdfV0lEVEgg LSBMUlVfR0VOX1dJRFRIIC0gTFJVX1JFRlNfV0lEVEg7CiAJbW1pbml0X2RwcmludGsoTU1JTklU X1RSQUNFLCAicGFnZWZsYWdzX2xheW91dF93aWR0aHMiLAotCQkiU2VjdGlvbiAlZCBOb2RlICVk IFpvbmUgJWQgTGFzdGNwdXBpZCAlZCBLYXNhbnRhZyAlZCBGbGFncyAlZFxuIiwKKwkJIlNlY3Rp b24gJWQgTm9kZSAlZCBab25lICVkIExhc3RjcHVwaWQgJWQgS2FzYW50YWcgJWQgR2VuICVkIFRp ZXIgJWQgRmxhZ3MgJWRcbiIsCiAJCVNFQ1RJT05TX1dJRFRILAogCQlOT0RFU19XSURUSCwKIAkJ Wk9ORVNfV0lEVEgsCiAJCUxBU1RfQ1BVUElEX1dJRFRILAogCQlLQVNBTl9UQUdfV0lEVEgsCisJ CUxSVV9HRU5fV0lEVEgsCisJCUxSVV9SRUZTX1dJRFRILAogCQlOUl9QQUdFRkxBR1MpOwogCW1t aW5pdF9kcHJpbnRrKE1NSU5JVF9UUkFDRSwgInBhZ2VmbGFnc19sYXlvdXRfc2hpZnRzIiwKIAkJ IlNlY3Rpb24gJWQgTm9kZSAlZCBab25lICVkIExhc3RjcHVwaWQgJWQgS2FzYW50YWcgJWRcbiIs CmRpZmYgLS1naXQgYS9tbS9tbXpvbmUuYyBiL21tL21tem9uZS5jCmluZGV4IGViODlkNmUwMThl Mi4uMmVjMGQ3NzkzNDI0IDEwMDY0NAotLS0gYS9tbS9tbXpvbmUuYworKysgYi9tbS9tbXpvbmUu YwpAQCAtODEsNiArODEsOCBAQCB2b2lkIGxydXZlY19pbml0KHN0cnVjdCBscnV2ZWMgKmxydXZl YykKIAogCWZvcl9lYWNoX2xydShscnUpCiAJCUlOSVRfTElTVF9IRUFEKCZscnV2ZWMtPmxpc3Rz W2xydV0pOworCisJbHJ1X2dlbl9pbml0X2xydXZlYyhscnV2ZWMpOwogfQogCiAjaWYgZGVmaW5l ZChDT05GSUdfTlVNQV9CQUxBTkNJTkcpICYmICFkZWZpbmVkKExBU1RfQ1BVUElEX05PVF9JTl9Q QUdFX0ZMQUdTKQpkaWZmIC0tZ2l0IGEvbW0vc3dhcC5jIGIvbW0vc3dhcC5jCmluZGV4IGJjZjNh YzI4OGI1Ni4uZTVmMmFiM2RhYjRhIDEwMDY0NAotLS0gYS9tbS9zd2FwLmMKKysrIGIvbW0vc3dh cC5jCkBAIC00NjIsNiArNDYyLDExIEBAIHZvaWQgZm9saW9fYWRkX2xydShzdHJ1Y3QgZm9saW8g KmZvbGlvKQogCVZNX0JVR19PTl9GT0xJTyhmb2xpb190ZXN0X2FjdGl2ZShmb2xpbykgJiYgZm9s aW9fdGVzdF91bmV2aWN0YWJsZShmb2xpbyksIGZvbGlvKTsKIAlWTV9CVUdfT05fRk9MSU8oZm9s aW9fdGVzdF9scnUoZm9saW8pLCBmb2xpbyk7CiAKKwkvKiBzZWUgdGhlIGNvbW1lbnQgaW4gbHJ1 X2dlbl9hZGRfZm9saW8oKSAqLworCWlmIChscnVfZ2VuX2VuYWJsZWQoKSAmJiAhZm9saW9fdGVz dF91bmV2aWN0YWJsZShmb2xpbykgJiYKKwkgICAgbHJ1X2dlbl9pbl9mYXVsdCgpICYmICEoY3Vy cmVudC0+ZmxhZ3MgJiBQRl9NRU1BTExPQykpCisJCWZvbGlvX3NldF9hY3RpdmUoZm9saW8pOwor CiAJZm9saW9fZ2V0KGZvbGlvKTsKIAlsb2NhbF9sb2NrKCZscnVfcHZlY3MubG9jayk7CiAJcHZl YyA9IHRoaXNfY3B1X3B0cigmbHJ1X3B2ZWNzLmxydV9hZGQpOwpAQCAtNTYzLDcgKzU2OCw3IEBA IHN0YXRpYyB2b2lkIGxydV9kZWFjdGl2YXRlX2ZpbGVfZm4oc3RydWN0IHBhZ2UgKnBhZ2UsIHN0 cnVjdCBscnV2ZWMgKmxydXZlYykKIAogc3RhdGljIHZvaWQgbHJ1X2RlYWN0aXZhdGVfZm4oc3Ry dWN0IHBhZ2UgKnBhZ2UsIHN0cnVjdCBscnV2ZWMgKmxydXZlYykKIHsKLQlpZiAoUGFnZUFjdGl2 ZShwYWdlKSAmJiAhUGFnZVVuZXZpY3RhYmxlKHBhZ2UpKSB7CisJaWYgKCFQYWdlVW5ldmljdGFi bGUocGFnZSkgJiYgKFBhZ2VBY3RpdmUocGFnZSkgfHwgbHJ1X2dlbl9lbmFibGVkKCkpKSB7CiAJ CWludCBucl9wYWdlcyA9IHRocF9ucl9wYWdlcyhwYWdlKTsKIAogCQlkZWxfcGFnZV9mcm9tX2xy dV9saXN0KHBhZ2UsIGxydXZlYyk7CkBAIC02NzcsNyArNjgyLDcgQEAgdm9pZCBkZWFjdGl2YXRl X2ZpbGVfcGFnZShzdHJ1Y3QgcGFnZSAqcGFnZSkKICAqLwogdm9pZCBkZWFjdGl2YXRlX3BhZ2Uo c3RydWN0IHBhZ2UgKnBhZ2UpCiB7Ci0JaWYgKFBhZ2VMUlUocGFnZSkgJiYgUGFnZUFjdGl2ZShw YWdlKSAmJiAhUGFnZVVuZXZpY3RhYmxlKHBhZ2UpKSB7CisJaWYgKFBhZ2VMUlUocGFnZSkgJiYg IVBhZ2VVbmV2aWN0YWJsZShwYWdlKSAmJiAoUGFnZUFjdGl2ZShwYWdlKSB8fCBscnVfZ2VuX2Vu YWJsZWQoKSkpIHsKIAkJc3RydWN0IHBhZ2V2ZWMgKnB2ZWM7CiAKIAkJbG9jYWxfbG9jaygmbHJ1 X3B2ZWNzLmxvY2spOwpkaWZmIC0tZ2l0IGEvbW0vdm1zY2FuLmMgYi9tbS92bXNjYW4uYwppbmRl eCA4ZTc0NGNkZjgwMmYuLjY1ZWI2NjhhYmYyZCAxMDA2NDQKLS0tIGEvbW0vdm1zY2FuLmMKKysr IGIvbW0vdm1zY2FuLmMKQEAgLTMwNDIsNiArMzA0Miw3OSBAQCBzdGF0aWMgYm9vbCBjYW5fYWdl X2Fub25fcGFnZXMoc3RydWN0IHBnbGlzdF9kYXRhICpwZ2RhdCwKIAlyZXR1cm4gY2FuX2RlbW90 ZShwZ2RhdC0+bm9kZV9pZCwgc2MpOwogfQogCisjaWZkZWYgQ09ORklHX0xSVV9HRU4KKworLyoq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKgorICogICAgICAgICAgICAgICAgICAgICAgICAgIHNob3J0aGFu ZCBoZWxwZXJzCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCisjZGVmaW5lIGZvcl9lYWNoX2dl bl90eXBlX3pvbmUoZ2VuLCB0eXBlLCB6b25lKQkJCQlcCisJZm9yICgoZ2VuKSA9IDA7IChnZW4p IDwgTUFYX05SX0dFTlM7IChnZW4pKyspCQkJXAorCQlmb3IgKCh0eXBlKSA9IDA7ICh0eXBlKSA8 IEFOT05fQU5EX0ZJTEU7ICh0eXBlKSsrKQlcCisJCQlmb3IgKCh6b25lKSA9IDA7ICh6b25lKSA8 IE1BWF9OUl9aT05FUzsgKHpvbmUpKyspCisKK3N0YXRpYyBzdHJ1Y3QgbHJ1dmVjICpnZXRfbHJ1 dmVjKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZywgaW50IG5pZCkKK3sKKwlzdHJ1Y3QgcGdsaXN0 X2RhdGEgKnBnZGF0ID0gTk9ERV9EQVRBKG5pZCk7CisKKyNpZmRlZiBDT05GSUdfTUVNQ0cKKwlp ZiAobWVtY2cpIHsKKwkJc3RydWN0IGxydXZlYyAqbHJ1dmVjID0gJm1lbWNnLT5ub2RlaW5mb1tu aWRdLT5scnV2ZWM7CisKKwkJLyogZm9yIGhvdGFkZF9uZXdfcGdkYXQoKSAqLworCQlpZiAoIWxy dXZlYy0+cGdkYXQpCisJCQlscnV2ZWMtPnBnZGF0ID0gcGdkYXQ7CisKKwkJcmV0dXJuIGxydXZl YzsKKwl9CisjZW5kaWYKKwlyZXR1cm4gcGdkYXQgPyAmcGdkYXQtPl9fbHJ1dmVjIDogTlVMTDsK K30KKworLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogICAgICAgICAgICAgICAgICAgICAgICAg IGluaXRpYWxpemF0aW9uCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCit2b2lkIGxydV9nZW5f aW5pdF9scnV2ZWMoc3RydWN0IGxydXZlYyAqbHJ1dmVjKQoreworCWludCBnZW4sIHR5cGUsIHpv bmU7CisJc3RydWN0IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAmbHJ1dmVjLT5scnVnZW47CisK KwlscnVnZW4tPm1heF9zZXEgPSBNSU5fTlJfR0VOUyArIDE7CisKKwlmb3JfZWFjaF9nZW5fdHlw ZV96b25lKGdlbiwgdHlwZSwgem9uZSkKKwkJSU5JVF9MSVNUX0hFQUQoJmxydWdlbi0+bGlzdHNb Z2VuXVt0eXBlXVt6b25lXSk7Cit9CisKKyNpZmRlZiBDT05GSUdfTUVNQ0cKK3ZvaWQgbHJ1X2dl bl9pbml0X21lbWNnKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKK3sKK30KKwordm9pZCBscnVf Z2VuX2V4aXRfbWVtY2coc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQoreworCWludCBuaWQ7CisK Kwlmb3JfZWFjaF9ub2RlKG5pZCkgeworCQlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMgPSBnZXRfbHJ1 dmVjKG1lbWNnLCBuaWQpOworCisJCVZNX0JVR19PTihtZW1jaHJfaW52KGxydXZlYy0+bHJ1Z2Vu Lm5yX3BhZ2VzLCAwLAorCQkJCSAgICAgc2l6ZW9mKGxydXZlYy0+bHJ1Z2VuLm5yX3BhZ2VzKSkp OworCX0KK30KKyNlbmRpZgorCitzdGF0aWMgaW50IF9faW5pdCBpbml0X2xydV9nZW4odm9pZCkK K3sKKwlCVUlMRF9CVUdfT04oTUlOX05SX0dFTlMgKyAxID49IE1BWF9OUl9HRU5TKTsKKwlCVUlM RF9CVUdfT04oQklUKExSVV9HRU5fV0lEVEgpIDw9IE1BWF9OUl9HRU5TKTsKKworCXJldHVybiAw OworfTsKK2xhdGVfaW5pdGNhbGwoaW5pdF9scnVfZ2VuKTsKKworI2VuZGlmIC8qIENPTkZJR19M UlVfR0VOICovCisKIHN0YXRpYyB2b2lkIHNocmlua19scnV2ZWMoc3RydWN0IGxydXZlYyAqbHJ1 dmVjLCBzdHJ1Y3Qgc2Nhbl9jb250cm9sICpzYykKIHsKIAl1bnNpZ25lZCBsb25nIG5yW05SX0xS VV9MSVNUU107Ci0tIAoyLjM1LjEuNjE2LmcwYmRjYmI0NDY0LWdvb2cKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxp bmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3Rz LmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==