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 17F0CC4332F for ; Thu, 7 Apr 2022 03:17:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S240039AbiDGDS5 (ORCPT ); Wed, 6 Apr 2022 23:18:57 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44254 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239934AbiDGDS0 (ORCPT ); Wed, 6 Apr 2022 23:18:26 -0400 Received: from mail-io1-xd4a.google.com (mail-io1-xd4a.google.com [IPv6:2607:f8b0:4864:20::d4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 09C2A92D25 for ; Wed, 6 Apr 2022 20:16:05 -0700 (PDT) Received: by mail-io1-xd4a.google.com with SMTP id g16-20020a05660203d000b005f7b3b0642eso2843451iov.16 for ; Wed, 06 Apr 2022 20:16:05 -0700 (PDT) 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=YqVNhyISztZ1ZK/2DcLD4jMBoPqetUzlmDZSmAvpxb8=; b=KUp+wQaYibi57iFMFE/eEwpILESpluPg+F+rzsePc1T786tD8U71zBc+UFR4VG0tQI k97U/X/iwxUfuZp6ZW4bzPH6hv1KDGKlVlDHDbv8sdssLmu0zB+yAVIFxtamHjIf0xLG QLlBIYpdSlbWdjLJLcEbPzBD/A6J0LbxL3t/3IOsempoljxAvBam3m/A3Z+RyIfKXTeN ThTQ+151w2P3bq8/IRl/w1NS66NWLkS1j5UY08QgyRvPxQ/K8zM8CW6axhV0pM+JQ+zA Gi41Hri/XCqSq9JzqKIp6ESiceXu6v5U/hOnqmnz+HUjurJtBG3FzIB9XK7xY8O52j1a TJQQ== 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=YqVNhyISztZ1ZK/2DcLD4jMBoPqetUzlmDZSmAvpxb8=; b=XEvgNPFJw3wD0Fn+tm569386r4F/aO3fTqi3d32QfvBAa35NU+DykoEvgJyOMcCQf1 WlnLOTr9iI9BmFujz30ReQLWnh1CINanT9ik6LvhlDi/pAoBEtW9G5kafSJ7npCIzNnb NfxyTKcfssrIs8lTIl5ilbeZ9W8KLs6hfEZ8TyKUFz5KPoBEwsJEHYkCb6cZyS7UnNcU vSxMSY3+S7V8HIb4vPzsHJJrNtQrAIUnTnYqotgJmBFV35Z/l0aEhxeazak7IpKgDu1A 0hwdEnMgVg8jiBrTlEmwQM/UG6qxjLVFPHgieF67ES9soBZTNKkL9G7uplZVmrLBonMq 9XIg== X-Gm-Message-State: AOAM531ng30w56TTsU0igW0ObaYb06q7o9RdDOFe3n61h3d50Hxczb2F dNwQRJ4KEwmK5varoVeJfI1VlIRfNQI= X-Google-Smtp-Source: ABdhPJz3y56QFPyEh3j7Q9wOUJVbETO4p5mf579lHkbFR/+WkicQ3Y4ESJ5d1WZM62kOC2QCHXMHNT7H6kM= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:9ea2:c755:ae22:6862]) (user=yuzhao job=sendgmr) by 2002:a05:6638:14d5:b0:323:dca6:fe8a with SMTP id l21-20020a05663814d500b00323dca6fe8amr6080100jak.309.1649301364377; Wed, 06 Apr 2022 20:16:04 -0700 (PDT) Date: Wed, 6 Apr 2022 21:15:17 -0600 In-Reply-To: <20220407031525.2368067-1-yuzhao@google.com> Message-Id: <20220407031525.2368067-6-yuzhao@google.com> Mime-Version: 1.0 References: <20220407031525.2368067-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.1094.g7c7d902a7c-goog Subject: [PATCH v10 05/14] mm: multi-gen LRU: groundwork From: Yu Zhao To: 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, 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 [3][4]. The next patch will address the "outlying refaults". Three macros, i.e., LRU_REFS_WIDTH, LRU_REFS_PGOFF and LRU_REFS_MASK, used later are added in this patch to make the entire patchset less diffy. A page is added to the youngest generation on faulting. The aging needs to check the accessed bit at least twice before handing this page over to the eviction. The first check takes care of the accessed bit set on the initial fault; the second check makes sure this page has not been used since then. This protocol, AKA second chance, requires a minimum of two generations, hence MIN_NR_GENS. [1] https://dl.acm.org/doi/10.1145/3297858.3304053 [2] https://dl.acm.org/doi/10.1145/3503222.3507731 [3] https://lwn.net/Articles/495543/ [4] https://lwn.net/Articles/815342/ Signed-off-by: Yu Zhao Acked-by: Brian Geffon Acked-by: Jan Alexander Steffens (heftig) Acked-by: Oleksandr Natalenko Acked-by: Steven Barrett Acked-by: Suleiman Souhlal Tested-by: Daniel Byrne Tested-by: Donald Carr Tested-by: Holger Hoffst=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 | 94 ++++++++++++++++ include/linux/page-flags-layout.h | 11 +- include/linux/page-flags.h | 4 +- include/linux/sched.h | 4 + kernel/bounds.c | 7 ++ mm/Kconfig | 8 ++ mm/huge_memory.c | 3 +- mm/memcontrol.c | 2 + mm/memory.c | 25 +++++ mm/mm_init.c | 6 +- mm/mmzone.c | 2 + mm/swap.c | 9 +- mm/vmscan.c | 75 +++++++++++++ 16 files changed, 418 insertions(+), 13 deletions(-) diff --git a/fs/fuse/dev.c b/fs/fuse/dev.c index 0e537e580dc1..5d36015071d2 100644 --- a/fs/fuse/dev.c +++ b/fs/fuse/dev.c @@ -777,7 +777,8 @@ static int fuse_check_page(struct page *page) 1 << PG_active | 1 << PG_workingset | 1 << PG_reclaim | - 1 << PG_waiters))) { + 1 << PG_waiters | + LRU_GEN_MASK | LRU_REFS_MASK))) { dump_page(page, "fuse: trying to steal weird page"); return 1; } diff --git a/include/linux/mm.h b/include/linux/mm.h index e34edb775334..980f568204a3 100644 --- a/include/linux/mm.h +++ b/include/linux/mm.h @@ -1060,6 +1060,8 @@ vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf)= ; #define ZONES_PGOFF (NODES_PGOFF - ZONES_WIDTH) #define LAST_CPUPID_PGOFF (ZONES_PGOFF - LAST_CPUPID_WIDTH) #define KASAN_TAG_PGOFF (LAST_CPUPID_PGOFF - KASAN_TAG_WIDTH) +#define LRU_GEN_PGOFF (KASAN_TAG_PGOFF - LRU_GEN_WIDTH) +#define LRU_REFS_PGOFF (LRU_GEN_PGOFF - LRU_REFS_WIDTH) =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 7c9c2157e9a8..9abd72a95462 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)); if (lru !=3D LRU_UNEVICTABLE) @@ -121,6 +291,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)); /* This is not expected to be used on LRU_UNEVICTABLE */ @@ -138,6 +311,9 @@ void lruvec_del_folio(struct lruvec *lruvec, struct fol= io *folio) { enum lru_list lru =3D folio_lru_list(folio); =20 + if (lru_gen_del_folio(lruvec, folio, false)) + return; + if (lru !=3D LRU_UNEVICTABLE) list_del(&folio->lru); update_lru_size(lruvec, lru, folio_zonenum(folio), diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 962b14d403e8..bde05427e2bb 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -317,6 +317,96 @@ enum lruvec_flags { */ }; =20 +#endif /* !__GENERATING_BOUNDS_H */ + +/* + * Evictable pages are divided into multiple generations. The youngest and= the + * oldest generation numbers, max_seq and min_seq, are monotonically 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(). + * + * MAX_NR_GENS is set to 4 so that the multi-gen LRU can support twice of = the + * categories of the active/inactive LRU when keeping track of accesses th= rough + * page tables. It requires order_base_2(MAX_NR_GENS+1) bits in folio->fla= gs. + */ +#define MIN_NR_GENS 2U +#define MAX_NR_GENS 4U + +#ifndef __GENERATING_BOUNDS_H + +struct lruvec; + +#define LRU_GEN_MASK ((BIT(LRU_GEN_WIDTH) - 1) << LRU_GEN_PGOFF) +#define LRU_REFS_MASK ((BIT(LRU_REFS_WIDTH) - 1) << LRU_REFS_PGOFF) + +#ifdef CONFIG_LRU_GEN + +enum { + LRU_GEN_ANON, + LRU_GEN_FILE, +}; + +/* + * The youngest generation number is stored in max_seq for both anon and 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 */ @@ -334,6 +424,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..c1946cdb845f 100644 --- a/include/linux/page-flags-layout.h +++ b/include/linux/page-flags-layout.h @@ -55,7 +55,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 +90,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 +101,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 9d8eeaa67d05..5cbde013ce66 100644 --- a/include/linux/page-flags.h +++ b/include/linux/page-flags.h @@ -1017,7 +1017,7 @@ PAGEFLAG(Isolated, isolated, PF_ANY); 1UL << PG_private | 1UL << PG_private_2 | \ 1UL << PG_writeback | 1UL << PG_reserved | \ 1UL << PG_slab | 1UL << PG_active | \ - 1UL << PG_unevictable | __PG_MLOCKED) + 1UL << PG_unevictable | __PG_MLOCKED | LRU_GEN_MASK) =20 /* * Flags checked when a page is prepped for return by the page allocator. @@ -1028,7 +1028,7 @@ PAGEFLAG(Isolated, isolated, PF_ANY); * alloc-free cycle to prevent from reusing the page. */ #define PAGE_FLAGS_CHECK_AT_PREP \ - (PAGEFLAGS_MASK & ~__PG_HWPOISON) + ((PAGEFLAGS_MASK & ~__PG_HWPOISON) | LRU_GEN_MASK | LRU_REFS_MASK) =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 d5e3c00b74e1..4cd6345f62f9 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..e08fb89f87f4 100644 --- a/kernel/bounds.c +++ b/kernel/bounds.c @@ -22,6 +22,13 @@ int main(void) DEFINE(NR_CPUS_BITS, ilog2(CONFIG_NR_CPUS)); #endif DEFINE(SPINLOCK_SIZE, sizeof(spinlock_t)); +#ifdef CONFIG_LRU_GEN + DEFINE(LRU_GEN_WIDTH, order_base_2(MAX_NR_GENS + 1)); + DEFINE(LRU_REFS_WIDTH, 0); +#else + DEFINE(LRU_GEN_WIDTH, 0); + DEFINE(LRU_REFS_WIDTH, 0); +#endif /* End of constants */ =20 return 0; diff --git a/mm/Kconfig b/mm/Kconfig index 034d87953600..4595fc654181 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -909,6 +909,14 @@ config ANON_VMA_NAME area from being merged with adjacent virtual memory areas due to the difference in their name. =20 +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 to overcommit memory. + source "mm/damon/Kconfig" =20 endmenu diff --git a/mm/huge_memory.c b/mm/huge_memory.c index 2fe38212e07c..c5dbb7eef61d 100644 --- a/mm/huge_memory.c +++ b/mm/huge_memory.c @@ -2321,7 +2321,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 725f76723220..f5de8be80c13 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -5062,6 +5062,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); } @@ -5120,6 +5121,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 44a1ec7a2cac..6df27b84c5aa 100644 --- a/mm/memory.c +++ b/mm/memory.c @@ -4812,6 +4812,27 @@ static inline void mm_account_fault(struct pt_regs *= regs, perf_sw_event(PERF_COUNT_SW_PAGE_FAULTS_MIN, 1, regs, address); } =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 * @@ -4843,11 +4864,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 0ae7571e35ab..68e1511be12d 100644 --- a/mm/mmzone.c +++ b/mm/mmzone.c @@ -88,6 +88,8 @@ void lruvec_init(struct lruvec *lruvec) * Poison its list head, so that any operations on it would crash. */ list_del(&lruvec->lists[LRU_UNEVICTABLE]); + + lru_gen_init_lruvec(lruvec); } =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 7e320ec08c6a..a6870ba0bd83 100644 --- a/mm/swap.c +++ b/mm/swap.c @@ -460,6 +460,11 @@ void folio_add_lru(struct folio *folio) VM_BUG_ON_FOLIO(folio_test_active(folio) && folio_test_unevictable(folio)= , folio); VM_BUG_ON_FOLIO(folio_test_lru(folio), folio); =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); @@ -551,7 +556,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); @@ -666,7 +671,7 @@ void deactivate_file_folio(struct folio *folio) */ void deactivate_page(struct page *page) { - if (PageLRU(page) && PageActive(page) && !PageUnevictable(page)) { + if (PageLRU(page) && !PageUnevictable(page) && (PageActive(page) || lru_g= en_enabled())) { struct pagevec *pvec; =20 local_lock(&lru_pvecs.lock); diff --git a/mm/vmscan.c b/mm/vmscan.c index 2232cb55af41..37dd5d1c3d07 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2968,6 +2968,81 @@ 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 __maybe_unused *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 + VM_BUG_ON(!mem_cgroup_disabled()); + + return pgdat ? &pgdat->__lruvec : NULL; +} + +/*************************************************************************= ***** + * initialization + *************************************************************************= *****/ + +void lru_gen_init_lruvec(struct lruvec *lruvec) +{ + int gen, type, zone; + struct lru_gen_struct *lrugen =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.1094.g7c7d902a7c-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 0E3ABC43219 for ; Thu, 7 Apr 2022 03:28:53 +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=ykGkaJoQZYAfp1SPXMyzNiVK1e3HC7QZjNsOhmaAJwM=; b=sBxzZEEJKubhpMKd/ZgfjetzOA CQJ8wNZG8hYTXmHepXN6eRySidhWQjcgCMIzVqy4Jr4xPoMHxi497BzxdzShlN1Dsik3fdPHvbIqb cQkijE8XfNY/+H8+WUMQvXaQCsE+lXmFbflmNPdVo2zmG00dMARGsvY6FouLgnIukksE6epTgBbX5 GUFJv+2UQ9ypOBca/3UoazqWG34qoi7qqHhk4ebP4F5DKoNJ2hbJUFB6NZrGk6LgqOP6AwoZLqU0n jUMgk14ypiD5XU6mYgnEtU23pc2zJBGPmkjjZvLzndsLqv894875acFrtzvy1hHOw0uh8fuTPe429 CGvBpQCA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1ncInP-0095dT-65; Thu, 07 Apr 2022 03:26:55 +0000 Received: from mail-io1-xd49.google.com ([2607:f8b0:4864:20::d49]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1ncIcv-0091Z0-VE for linux-arm-kernel@lists.infradead.org; Thu, 07 Apr 2022 03:16:15 +0000 Received: by mail-io1-xd49.google.com with SMTP id u10-20020a5ec00a000000b00648e5804d5bso2853707iol.12 for ; Wed, 06 Apr 2022 20:16:04 -0700 (PDT) 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=YqVNhyISztZ1ZK/2DcLD4jMBoPqetUzlmDZSmAvpxb8=; b=KUp+wQaYibi57iFMFE/eEwpILESpluPg+F+rzsePc1T786tD8U71zBc+UFR4VG0tQI k97U/X/iwxUfuZp6ZW4bzPH6hv1KDGKlVlDHDbv8sdssLmu0zB+yAVIFxtamHjIf0xLG QLlBIYpdSlbWdjLJLcEbPzBD/A6J0LbxL3t/3IOsempoljxAvBam3m/A3Z+RyIfKXTeN ThTQ+151w2P3bq8/IRl/w1NS66NWLkS1j5UY08QgyRvPxQ/K8zM8CW6axhV0pM+JQ+zA Gi41Hri/XCqSq9JzqKIp6ESiceXu6v5U/hOnqmnz+HUjurJtBG3FzIB9XK7xY8O52j1a TJQQ== 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=YqVNhyISztZ1ZK/2DcLD4jMBoPqetUzlmDZSmAvpxb8=; b=zSVF+Jy85gb7n9gSZfPyDsdJXXwOvvsZfmdqs31eWb0ZZ4NOsRf/va/0I6cuhAi1em HZKNhlewuoLeM5CWlv0bB4OHMkkVrrMAVJ17ZanFZA1TOvkCBi3uqsIs3zOjL92+pKHG /g/M3CY2FjHHLvUkCEmEgVymG+2knf5ZxOHHi2lUROt68E21ujbnC2b9J6vvukl9TOgk kkLDRFqH90bS4gW5QYHsrJk2mB/5M55Zpf4DhziTawYkjjMjblHGoyU4h0AquNxi1WNG jf9kfplpRMSkJfkBV646gdMLoWZtqh/Yp1joOVS0b+5unq0/kGpUrzif7X/BEe2QsYIH kWAg== X-Gm-Message-State: AOAM532pB10SQIQxTG4VlPVRG0AsPNpmF1Ypo6gbKGH0YJVJoHAEySuc yVScAco1PBuPREDM8rdN731iO9HQ+Ag= X-Google-Smtp-Source: ABdhPJz3y56QFPyEh3j7Q9wOUJVbETO4p5mf579lHkbFR/+WkicQ3Y4ESJ5d1WZM62kOC2QCHXMHNT7H6kM= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:9ea2:c755:ae22:6862]) (user=yuzhao job=sendgmr) by 2002:a05:6638:14d5:b0:323:dca6:fe8a with SMTP id l21-20020a05663814d500b00323dca6fe8amr6080100jak.309.1649301364377; Wed, 06 Apr 2022 20:16:04 -0700 (PDT) Date: Wed, 6 Apr 2022 21:15:17 -0600 In-Reply-To: <20220407031525.2368067-1-yuzhao@google.com> Message-Id: <20220407031525.2368067-6-yuzhao@google.com> Mime-Version: 1.0 References: <20220407031525.2368067-1-yuzhao@google.com> X-Mailer: git-send-email 2.35.1.1094.g7c7d902a7c-goog Subject: [PATCH v10 05/14] mm: multi-gen LRU: groundwork From: Yu Zhao To: 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, 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-20220406_201606_118022_C5DA6947 X-CRM114-Status: GOOD ( 30.81 ) 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 c3Mgb3V0bHlpbmcgcmVmYXVsdHMgaGF2ZSBiZWVuIG9ic2VydmVkIFszXVs0XS4KClRoZSBuZXh0 IHBhdGNoIHdpbGwgYWRkcmVzcyB0aGUgIm91dGx5aW5nIHJlZmF1bHRzIi4gVGhyZWUgbWFjcm9z LAppLmUuLCBMUlVfUkVGU19XSURUSCwgTFJVX1JFRlNfUEdPRkYgYW5kIExSVV9SRUZTX01BU0ss IHVzZWQgbGF0ZXIgYXJlCmFkZGVkIGluIHRoaXMgcGF0Y2ggdG8gbWFrZSB0aGUgZW50aXJlIHBh dGNoc2V0IGxlc3MgZGlmZnkuCgpBIHBhZ2UgaXMgYWRkZWQgdG8gdGhlIHlvdW5nZXN0IGdlbmVy YXRpb24gb24gZmF1bHRpbmcuIFRoZSBhZ2luZwpuZWVkcyB0byBjaGVjayB0aGUgYWNjZXNzZWQg Yml0IGF0IGxlYXN0IHR3aWNlIGJlZm9yZSBoYW5kaW5nIHRoaXMKcGFnZSBvdmVyIHRvIHRoZSBl dmljdGlvbi4gVGhlIGZpcnN0IGNoZWNrIHRha2VzIGNhcmUgb2YgdGhlIGFjY2Vzc2VkCmJpdCBz ZXQgb24gdGhlIGluaXRpYWwgZmF1bHQ7IHRoZSBzZWNvbmQgY2hlY2sgbWFrZXMgc3VyZSB0aGlz IHBhZ2UKaGFzIG5vdCBiZWVuIHVzZWQgc2luY2UgdGhlbi4gVGhpcyBwcm90b2NvbCwgQUtBIHNl Y29uZCBjaGFuY2UsCnJlcXVpcmVzIGEgbWluaW11bSBvZiB0d28gZ2VuZXJhdGlvbnMsIGhlbmNl IE1JTl9OUl9HRU5TLgoKWzFdIGh0dHBzOi8vZGwuYWNtLm9yZy9kb2kvMTAuMTE0NS8zMjk3ODU4 LjMzMDQwNTMKWzJdIGh0dHBzOi8vZGwuYWNtLm9yZy9kb2kvMTAuMTE0NS8zNTAzMjIyLjM1MDc3 MzEKWzNdIGh0dHBzOi8vbHduLm5ldC9BcnRpY2xlcy80OTU1NDMvCls0XSBodHRwczovL2x3bi5u ZXQvQXJ0aWNsZXMvODE1MzQyLwoKU2lnbmVkLW9mZi1ieTogWXUgWmhhbyA8eXV6aGFvQGdvb2ds ZS5jb20+CkFja2VkLWJ5OiBCcmlhbiBHZWZmb24gPGJnZWZmb25AZ29vZ2xlLmNvbT4KQWNrZWQt Ynk6IEphbiBBbGV4YW5kZXIgU3RlZmZlbnMgKGhlZnRpZykgPGhlZnRpZ0BhcmNobGludXgub3Jn PgpBY2tlZC1ieTogT2xla3NhbmRyIE5hdGFsZW5rbyA8b2xla3NhbmRyQG5hdGFsZW5rby5uYW1l PgpBY2tlZC1ieTogU3RldmVuIEJhcnJldHQgPHN0ZXZlbkBsaXF1b3JpeC5uZXQ+CkFja2VkLWJ5 OiBTdWxlaW1hbiBTb3VobGFsIDxzdWxlaW1hbkBnb29nbGUuY29tPgpUZXN0ZWQtYnk6IERhbmll bCBCeXJuZSA8ZGpieXJuZUBtdHUuZWR1PgpUZXN0ZWQtYnk6IERvbmFsZCBDYXJyIDxkQGNoYW9z LXJlaW5zLmNvbT4KVGVzdGVkLWJ5OiBIb2xnZXIgSG9mZnN0w6R0dGUgPGhvbGdlckBhcHBsaWVk LWFzeW5jaHJvbnkuY29tPgpUZXN0ZWQtYnk6IEtvbnN0YW50aW4gS2hhcmxhbW92IDxIaS1Bbmdl bEB5YW5kZXgucnU+ClRlc3RlZC1ieTogU2h1YW5nIFpoYWkgPHN6aGFpMkBjcy5yb2NoZXN0ZXIu ZWR1PgpUZXN0ZWQtYnk6IFNvZmlhIFRyaW5oIDxzb2ZpYS50cmluaEBlZGkud29ya3M+ClRlc3Rl ZC1ieTogVmFpYmhhdiBKYWluIDx2YWliaGF2QGxpbnV4LmlibS5jb20+Ci0tLQogZnMvZnVzZS9k ZXYuYyAgICAgICAgICAgICAgICAgICAgIHwgICAzICstCiBpbmNsdWRlL2xpbnV4L21tLmggICAg ICAgICAgICAgICAgfCAgIDIgKwogaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaCAgICAgICAgIHwg MTc2ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9tbXpvbmUu aCAgICAgICAgICAgIHwgIDk0ICsrKysrKysrKysrKysrKysKIGluY2x1ZGUvbGludXgvcGFnZS1m bGFncy1sYXlvdXQuaCB8ICAxMSArLQogaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLmggICAgICAg IHwgICA0ICstCiBpbmNsdWRlL2xpbnV4L3NjaGVkLmggICAgICAgICAgICAgfCAgIDQgKwoga2Vy bmVsL2JvdW5kcy5jICAgICAgICAgICAgICAgICAgIHwgICA3ICsrCiBtbS9LY29uZmlnICAgICAg ICAgICAgICAgICAgICAgICAgfCAgIDggKysKIG1tL2h1Z2VfbWVtb3J5LmMgICAgICAgICAgICAg ICAgICB8ICAgMyArLQogbW0vbWVtY29udHJvbC5jICAgICAgICAgICAgICAgICAgIHwgICAyICsK IG1tL21lbW9yeS5jICAgICAgICAgICAgICAgICAgICAgICB8ICAyNSArKysrKwogbW0vbW1faW5p dC5jICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICstCiBtbS9tbXpvbmUuYyAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDIgKwogbW0vc3dhcC5jICAgICAgICAgICAgICAgICAgICAgICAgIHwg ICA5ICstCiBtbS92bXNjYW4uYyAgICAgICAgICAgICAgICAgICAgICAgfCAgNzUgKysrKysrKysr KysrKwogMTYgZmlsZXMgY2hhbmdlZCwgNDE4IGluc2VydGlvbnMoKyksIDEzIGRlbGV0aW9ucygt KQoKZGlmZiAtLWdpdCBhL2ZzL2Z1c2UvZGV2LmMgYi9mcy9mdXNlL2Rldi5jCmluZGV4IDBlNTM3 ZTU4MGRjMS4uNWQzNjAxNTA3MWQyIDEwMDY0NAotLS0gYS9mcy9mdXNlL2Rldi5jCisrKyBiL2Zz L2Z1c2UvZGV2LmMKQEAgLTc3Nyw3ICs3NzcsOCBAQCBzdGF0aWMgaW50IGZ1c2VfY2hlY2tfcGFn ZShzdHJ1Y3QgcGFnZSAqcGFnZSkKIAkgICAgICAgMSA8PCBQR19hY3RpdmUgfAogCSAgICAgICAx IDw8IFBHX3dvcmtpbmdzZXQgfAogCSAgICAgICAxIDw8IFBHX3JlY2xhaW0gfAotCSAgICAgICAx IDw8IFBHX3dhaXRlcnMpKSkgeworCSAgICAgICAxIDw8IFBHX3dhaXRlcnMgfAorCSAgICAgICBM UlVfR0VOX01BU0sgfCBMUlVfUkVGU19NQVNLKSkpIHsKIAkJZHVtcF9wYWdlKHBhZ2UsICJmdXNl OiB0cnlpbmcgdG8gc3RlYWwgd2VpcmQgcGFnZSIpOwogCQlyZXR1cm4gMTsKIAl9CmRpZmYgLS1n aXQgYS9pbmNsdWRlL2xpbnV4L21tLmggYi9pbmNsdWRlL2xpbnV4L21tLmgKaW5kZXggZTM0ZWRi Nzc1MzM0Li45ODBmNTY4MjA0YTMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvbW0uaAorKysg Yi9pbmNsdWRlL2xpbnV4L21tLmgKQEAgLTEwNjAsNiArMTA2MCw4IEBAIHZtX2ZhdWx0X3QgZmlu aXNoX21rd3JpdGVfZmF1bHQoc3RydWN0IHZtX2ZhdWx0ICp2bWYpOwogI2RlZmluZSBaT05FU19Q R09GRgkJKE5PREVTX1BHT0ZGIC0gWk9ORVNfV0lEVEgpCiAjZGVmaW5lIExBU1RfQ1BVUElEX1BH T0ZGCShaT05FU19QR09GRiAtIExBU1RfQ1BVUElEX1dJRFRIKQogI2RlZmluZSBLQVNBTl9UQUdf UEdPRkYJCShMQVNUX0NQVVBJRF9QR09GRiAtIEtBU0FOX1RBR19XSURUSCkKKyNkZWZpbmUgTFJV X0dFTl9QR09GRgkJKEtBU0FOX1RBR19QR09GRiAtIExSVV9HRU5fV0lEVEgpCisjZGVmaW5lIExS VV9SRUZTX1BHT0ZGCQkoTFJVX0dFTl9QR09GRiAtIExSVV9SRUZTX1dJRFRIKQogCiAvKgogICog RGVmaW5lIHRoZSBiaXQgc2hpZnRzIHRvIGFjY2VzcyBlYWNoIHNlY3Rpb24uICBGb3Igbm9uLWV4 aXN0ZW50CmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tX2lubGluZS5oIGIvaW5jbHVkZS9s aW51eC9tbV9pbmxpbmUuaAppbmRleCA3YzljMjE1N2U5YTguLjlhYmQ3MmE5NTQ2MiAxMDA2NDQK LS0tIGEvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21tX2lu bGluZS5oCkBAIC0zOCw2ICszOCw5IEBAIHN0YXRpYyBfX2Fsd2F5c19pbmxpbmUgdm9pZCBfX3Vw ZGF0ZV9scnVfc2l6ZShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsCiB7CiAJc3RydWN0IHBnbGlzdF9k YXRhICpwZ2RhdCA9IGxydXZlY19wZ2RhdChscnV2ZWMpOwogCisJbG9ja2RlcF9hc3NlcnRfaGVs ZCgmbHJ1dmVjLT5scnVfbG9jayk7CisJV0FSTl9PTl9PTkNFKG5yX3BhZ2VzICE9IChpbnQpbnJf cGFnZXMpOworCiAJX19tb2RfbHJ1dmVjX3N0YXRlKGxydXZlYywgTlJfTFJVX0JBU0UgKyBscnUs IG5yX3BhZ2VzKTsKIAlfX21vZF96b25lX3BhZ2Vfc3RhdGUoJnBnZGF0LT5ub2RlX3pvbmVzW3pp ZF0sCiAJCQkJTlJfWk9ORV9MUlVfQkFTRSArIGxydSwgbnJfcGFnZXMpOwpAQCAtOTksMTEgKzEw MiwxNzggQEAgc3RhdGljIF9fYWx3YXlzX2lubGluZSBlbnVtIGxydV9saXN0IGZvbGlvX2xydV9s aXN0KHN0cnVjdCBmb2xpbyAqZm9saW8pCiAJcmV0dXJuIGxydTsKIH0KIAorI2lmZGVmIENPTkZJ R19MUlVfR0VOCisKK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2VuYWJsZWQodm9pZCkKK3sK KwlyZXR1cm4gdHJ1ZTsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5faW5fZmF1bHQo dm9pZCkKK3sKKwlyZXR1cm4gY3VycmVudC0+aW5fbHJ1X2ZhdWx0OworfQorCitzdGF0aWMgaW5s aW5lIGludCBscnVfZ2VuX2Zyb21fc2VxKHVuc2lnbmVkIGxvbmcgc2VxKQoreworCXJldHVybiBz ZXEgJSBNQVhfTlJfR0VOUzsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5faXNfYWN0 aXZlKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgaW50IGdlbikKK3sKKwl1bnNpZ25lZCBsb25nIG1h eF9zZXEgPSBscnV2ZWMtPmxydWdlbi5tYXhfc2VxOworCisJVk1fQlVHX09OKGdlbiA+PSBNQVhf TlJfR0VOUyk7CisKKwkvKiBzZWUgdGhlIGNvbW1lbnQgb24gTUlOX05SX0dFTlMgKi8KKwlyZXR1 cm4gZ2VuID09IGxydV9nZW5fZnJvbV9zZXEobWF4X3NlcSkgfHwgZ2VuID09IGxydV9nZW5fZnJv bV9zZXEobWF4X3NlcSAtIDEpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgbHJ1X2dlbl91cGRh dGVfc2l6ZShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sCisJCQkJ ICAgICAgIGludCBvbGRfZ2VuLCBpbnQgbmV3X2dlbikKK3sKKwlpbnQgdHlwZSA9IGZvbGlvX2lz X2ZpbGVfbHJ1KGZvbGlvKTsKKwlpbnQgem9uZSA9IGZvbGlvX3pvbmVudW0oZm9saW8pOworCWlu dCBkZWx0YSA9IGZvbGlvX25yX3BhZ2VzKGZvbGlvKTsKKwllbnVtIGxydV9saXN0IGxydSA9IHR5 cGUgKiBMUlVfSU5BQ1RJVkVfRklMRTsKKwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9 ICZscnV2ZWMtPmxydWdlbjsKKworCVZNX0JVR19PTihvbGRfZ2VuICE9IC0xICYmIG9sZF9nZW4g Pj0gTUFYX05SX0dFTlMpOworCVZNX0JVR19PTihuZXdfZ2VuICE9IC0xICYmIG5ld19nZW4gPj0g TUFYX05SX0dFTlMpOworCVZNX0JVR19PTihvbGRfZ2VuID09IC0xICYmIG5ld19nZW4gPT0gLTEp OworCisJaWYgKG9sZF9nZW4gPj0gMCkKKwkJV1JJVEVfT05DRShscnVnZW4tPm5yX3BhZ2VzW29s ZF9nZW5dW3R5cGVdW3pvbmVdLAorCQkJICAgbHJ1Z2VuLT5ucl9wYWdlc1tvbGRfZ2VuXVt0eXBl XVt6b25lXSAtIGRlbHRhKTsKKwlpZiAobmV3X2dlbiA+PSAwKQorCQlXUklURV9PTkNFKGxydWdl bi0+bnJfcGFnZXNbbmV3X2dlbl1bdHlwZV1bem9uZV0sCisJCQkgICBscnVnZW4tPm5yX3BhZ2Vz W25ld19nZW5dW3R5cGVdW3pvbmVdICsgZGVsdGEpOworCisJLyogYWRkaXRpb24gKi8KKwlpZiAo b2xkX2dlbiA8IDApIHsKKwkJaWYgKGxydV9nZW5faXNfYWN0aXZlKGxydXZlYywgbmV3X2dlbikp CisJCQlscnUgKz0gTFJVX0FDVElWRTsKKwkJX191cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUs IHpvbmUsIGRlbHRhKTsKKwkJcmV0dXJuOworCX0KKworCS8qIGRlbGV0aW9uICovCisJaWYgKG5l d19nZW4gPCAwKSB7CisJCWlmIChscnVfZ2VuX2lzX2FjdGl2ZShscnV2ZWMsIG9sZF9nZW4pKQor CQkJbHJ1ICs9IExSVV9BQ1RJVkU7CisJCV9fdXBkYXRlX2xydV9zaXplKGxydXZlYywgbHJ1LCB6 b25lLCAtZGVsdGEpOworCQlyZXR1cm47CisJfQorfQorCitzdGF0aWMgaW5saW5lIGJvb2wgbHJ1 X2dlbl9hZGRfZm9saW8oc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlv LCBib29sIHJlY2xhaW1pbmcpCit7CisJaW50IGdlbjsKKwl1bnNpZ25lZCBsb25nIG9sZF9mbGFn cywgbmV3X2ZsYWdzOworCWludCB0eXBlID0gZm9saW9faXNfZmlsZV9scnUoZm9saW8pOworCWlu dCB6b25lID0gZm9saW9fem9uZW51bShmb2xpbyk7CisJc3RydWN0IGxydV9nZW5fc3RydWN0ICps cnVnZW4gPSAmbHJ1dmVjLT5scnVnZW47CisKKwlpZiAoZm9saW9fdGVzdF91bmV2aWN0YWJsZShm b2xpbykpCisJCXJldHVybiBmYWxzZTsKKwkvKgorCSAqIFRoZXJlIGFyZSB0aHJlZSBjb21tb24g Y2FzZXMgZm9yIHRoaXMgcGFnZToKKwkgKiAxLiBJZiBpdCdzIGhvdCwgZS5nLiwgZnJlc2hseSBm YXVsdGVkIGluIG9yIHByZXZpb3VzbHkgaG90IGFuZAorCSAqICAgIG1pZ3JhdGVkLCBhZGQgaXQg dG8gdGhlIHlvdW5nZXN0IGdlbmVyYXRpb24uCisJICogMi4gSWYgaXQncyBjb2xkIGJ1dCBjYW4n dCBiZSBldmljdGVkIGltbWVkaWF0ZWx5LCBpLmUuLCBhbiBhbm9uIHBhZ2UKKwkgKiAgICBub3Qg aW4gc3dhcGNhY2hlIG9yIGEgZGlydHkgcGFnZSBwZW5kaW5nIHdyaXRlYmFjaywgYWRkIGl0IHRv IHRoZQorCSAqICAgIHNlY29uZCBvbGRlc3QgZ2VuZXJhdGlvbi4KKwkgKiAzLiBFdmVyeXRoaW5n IGVsc2UgKGNsZWFuLCBjb2xkKSBpcyBhZGRlZCB0byB0aGUgb2xkZXN0IGdlbmVyYXRpb24uCisJ ICovCisJaWYgKGZvbGlvX3Rlc3RfYWN0aXZlKGZvbGlvKSkKKwkJZ2VuID0gbHJ1X2dlbl9mcm9t X3NlcShscnVnZW4tPm1heF9zZXEpOworCWVsc2UgaWYgKCh0eXBlID09IExSVV9HRU5fQU5PTiAm JiAhZm9saW9fdGVzdF9zd2FwY2FjaGUoZm9saW8pKSB8fAorCQkgKGZvbGlvX3Rlc3RfcmVjbGFp bShmb2xpbykgJiYKKwkJICAoZm9saW9fdGVzdF9kaXJ0eShmb2xpbykgfHwgZm9saW9fdGVzdF93 cml0ZWJhY2soZm9saW8pKSkpCisJCWdlbiA9IGxydV9nZW5fZnJvbV9zZXEobHJ1Z2VuLT5taW5f c2VxW3R5cGVdICsgMSk7CisJZWxzZQorCQlnZW4gPSBscnVfZ2VuX2Zyb21fc2VxKGxydWdlbi0+ bWluX3NlcVt0eXBlXSk7CisKKwlkbyB7CisJCW5ld19mbGFncyA9IG9sZF9mbGFncyA9IFJFQURf T05DRShmb2xpby0+ZmxhZ3MpOworCQlWTV9CVUdfT05fRk9MSU8obmV3X2ZsYWdzICYgTFJVX0dF Tl9NQVNLLCBmb2xpbyk7CisKKwkJLyogc2VlIHRoZSBjb21tZW50IG9uIE1JTl9OUl9HRU5TICov CisJCW5ld19mbGFncyAmPSB+KExSVV9HRU5fTUFTSyB8IEJJVChQR19hY3RpdmUpKTsKKwkJbmV3 X2ZsYWdzIHw9IChnZW4gKyAxVUwpIDw8IExSVV9HRU5fUEdPRkY7CisJfSB3aGlsZSAoY21weGNo ZygmZm9saW8tPmZsYWdzLCBvbGRfZmxhZ3MsIG5ld19mbGFncykgIT0gb2xkX2ZsYWdzKTsKKwor CWxydV9nZW5fdXBkYXRlX3NpemUobHJ1dmVjLCBmb2xpbywgLTEsIGdlbik7CisJLyogZm9yIGZv bGlvX3JvdGF0ZV9yZWNsYWltYWJsZSgpICovCisJaWYgKHJlY2xhaW1pbmcpCisJCWxpc3RfYWRk X3RhaWwoJmZvbGlvLT5scnUsICZscnVnZW4tPmxpc3RzW2dlbl1bdHlwZV1bem9uZV0pOworCWVs c2UKKwkJbGlzdF9hZGQoJmZvbGlvLT5scnUsICZscnVnZW4tPmxpc3RzW2dlbl1bdHlwZV1bem9u ZV0pOworCisJcmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2Rl bF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sIGJvb2wg cmVjbGFpbWluZykKK3sKKwlpbnQgZ2VuOworCXVuc2lnbmVkIGxvbmcgb2xkX2ZsYWdzLCBuZXdf ZmxhZ3M7CisKKwlkbyB7CisJCW5ld19mbGFncyA9IG9sZF9mbGFncyA9IFJFQURfT05DRShmb2xp by0+ZmxhZ3MpOworCQlpZiAoIShuZXdfZmxhZ3MgJiBMUlVfR0VOX01BU0spKQorCQkJcmV0dXJu IGZhbHNlOworCisJCVZNX0JVR19PTl9GT0xJTyhmb2xpb190ZXN0X2FjdGl2ZShmb2xpbyksIGZv bGlvKTsKKwkJVk1fQlVHX09OX0ZPTElPKGZvbGlvX3Rlc3RfdW5ldmljdGFibGUoZm9saW8pLCBm b2xpbyk7CisKKwkJZ2VuID0gKChuZXdfZmxhZ3MgJiBMUlVfR0VOX01BU0spID4+IExSVV9HRU5f UEdPRkYpIC0gMTsKKworCQluZXdfZmxhZ3MgJj0gfkxSVV9HRU5fTUFTSzsKKwkJLyogZm9yIHNo cmlua19wYWdlX2xpc3QoKSAqLworCQlpZiAocmVjbGFpbWluZykKKwkJCW5ld19mbGFncyAmPSB+ KEJJVChQR19yZWZlcmVuY2VkKSB8IEJJVChQR19yZWNsYWltKSk7CisJCWVsc2UgaWYgKGxydV9n ZW5faXNfYWN0aXZlKGxydXZlYywgZ2VuKSkKKwkJCW5ld19mbGFncyB8PSBCSVQoUEdfYWN0aXZl KTsKKwl9IHdoaWxlIChjbXB4Y2hnKCZmb2xpby0+ZmxhZ3MsIG9sZF9mbGFncywgbmV3X2ZsYWdz KSAhPSBvbGRfZmxhZ3MpOworCisJbHJ1X2dlbl91cGRhdGVfc2l6ZShscnV2ZWMsIGZvbGlvLCBn ZW4sIC0xKTsKKwlsaXN0X2RlbCgmZm9saW8tPmxydSk7CisKKwlyZXR1cm4gdHJ1ZTsKK30KKwor I2Vsc2UKKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5fZW5hYmxlZCh2b2lkKQoreworCXJl dHVybiBmYWxzZTsKK30KKworc3RhdGljIGlubGluZSBib29sIGxydV9nZW5faW5fZmF1bHQodm9p ZCkKK3sKKwlyZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2Fk ZF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sIGJvb2wg cmVjbGFpbWluZykKK3sKKwlyZXR1cm4gZmFsc2U7Cit9CisKK3N0YXRpYyBpbmxpbmUgYm9vbCBs cnVfZ2VuX2RlbF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9s aW8sIGJvb2wgcmVjbGFpbWluZykKK3sKKwlyZXR1cm4gZmFsc2U7Cit9CisKKyNlbmRpZiAvKiBD T05GSUdfTFJVX0dFTiAqLworCiBzdGF0aWMgX19hbHdheXNfaW5saW5lCiB2b2lkIGxydXZlY19h ZGRfZm9saW8oc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3QgZm9saW8gKmZvbGlvKQogewog CWVudW0gbHJ1X2xpc3QgbHJ1ID0gZm9saW9fbHJ1X2xpc3QoZm9saW8pOwogCisJaWYgKGxydV9n ZW5fYWRkX2ZvbGlvKGxydXZlYywgZm9saW8sIGZhbHNlKSkKKwkJcmV0dXJuOworCiAJdXBkYXRl X2xydV9zaXplKGxydXZlYywgbHJ1LCBmb2xpb196b25lbnVtKGZvbGlvKSwKIAkJCWZvbGlvX25y X3BhZ2VzKGZvbGlvKSk7CiAJaWYgKGxydSAhPSBMUlVfVU5FVklDVEFCTEUpCkBAIC0xMjEsNiAr MjkxLDkgQEAgdm9pZCBscnV2ZWNfYWRkX2ZvbGlvX3RhaWwoc3RydWN0IGxydXZlYyAqbHJ1dmVj LCBzdHJ1Y3QgZm9saW8gKmZvbGlvKQogewogCWVudW0gbHJ1X2xpc3QgbHJ1ID0gZm9saW9fbHJ1 X2xpc3QoZm9saW8pOwogCisJaWYgKGxydV9nZW5fYWRkX2ZvbGlvKGxydXZlYywgZm9saW8sIHRy dWUpKQorCQlyZXR1cm47CisKIAl1cGRhdGVfbHJ1X3NpemUobHJ1dmVjLCBscnUsIGZvbGlvX3pv bmVudW0oZm9saW8pLAogCQkJZm9saW9fbnJfcGFnZXMoZm9saW8pKTsKIAkvKiBUaGlzIGlzIG5v dCBleHBlY3RlZCB0byBiZSB1c2VkIG9uIExSVV9VTkVWSUNUQUJMRSAqLwpAQCAtMTM4LDYgKzMx MSw5IEBAIHZvaWQgbHJ1dmVjX2RlbF9mb2xpbyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVj dCBmb2xpbyAqZm9saW8pCiB7CiAJZW51bSBscnVfbGlzdCBscnUgPSBmb2xpb19scnVfbGlzdChm b2xpbyk7CiAKKwlpZiAobHJ1X2dlbl9kZWxfZm9saW8obHJ1dmVjLCBmb2xpbywgZmFsc2UpKQor CQlyZXR1cm47CisKIAlpZiAobHJ1ICE9IExSVV9VTkVWSUNUQUJMRSkKIAkJbGlzdF9kZWwoJmZv bGlvLT5scnUpOwogCXVwZGF0ZV9scnVfc2l6ZShscnV2ZWMsIGxydSwgZm9saW9fem9uZW51bShm b2xpbyksCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tem9uZS5oIGIvaW5jbHVkZS9saW51 eC9tbXpvbmUuaAppbmRleCA5NjJiMTRkNDAzZTguLmJkZTA1NDI3ZTJiYiAxMDA2NDQKLS0tIGEv aW5jbHVkZS9saW51eC9tbXpvbmUuaAorKysgYi9pbmNsdWRlL2xpbnV4L21tem9uZS5oCkBAIC0z MTcsNiArMzE3LDk2IEBAIGVudW0gbHJ1dmVjX2ZsYWdzIHsKIAkJCQkJICovCiB9OwogCisjZW5k aWYgLyogIV9fR0VORVJBVElOR19CT1VORFNfSCAqLworCisvKgorICogRXZpY3RhYmxlIHBhZ2Vz IGFyZSBkaXZpZGVkIGludG8gbXVsdGlwbGUgZ2VuZXJhdGlvbnMuIFRoZSB5b3VuZ2VzdCBhbmQg dGhlCisgKiBvbGRlc3QgZ2VuZXJhdGlvbiBudW1iZXJzLCBtYXhfc2VxIGFuZCBtaW5fc2VxLCBh cmUgbW9ub3RvbmljYWxseSBpbmNyZWFzaW5nLgorICogVGhleSBmb3JtIGEgc2xpZGluZyB3aW5k b3cgb2YgYSB2YXJpYWJsZSBzaXplIFtNSU5fTlJfR0VOUywgTUFYX05SX0dFTlNdLiBBbgorICog b2Zmc2V0IHdpdGhpbiBNQVhfTlJfR0VOUywgZ2VuLCBpbmRleGVzIHRoZSBMUlUgbGlzdCBvZiB0 aGUgY29ycmVzcG9uZGluZworICogZ2VuZXJhdGlvbi4gVGhlIGdlbiBjb3VudGVyIGluIGZvbGlv LT5mbGFncyBzdG9yZXMgZ2VuKzEgd2hpbGUgYSBwYWdlIGlzIG9uCisgKiBvbmUgb2YgbHJ1Z2Vu LT5saXN0c1tdLiBPdGhlcndpc2UgaXQgc3RvcmVzIDAuCisgKgorICogQSBwYWdlIGlzIGFkZGVk IHRvIHRoZSB5b3VuZ2VzdCBnZW5lcmF0aW9uIG9uIGZhdWx0aW5nLiBUaGUgYWdpbmcgbmVlZHMg dG8KKyAqIGNoZWNrIHRoZSBhY2Nlc3NlZCBiaXQgYXQgbGVhc3QgdHdpY2UgYmVmb3JlIGhhbmRp bmcgdGhpcyBwYWdlIG92ZXIgdG8gdGhlCisgKiBldmljdGlvbi4gVGhlIGZpcnN0IGNoZWNrIHRh a2VzIGNhcmUgb2YgdGhlIGFjY2Vzc2VkIGJpdCBzZXQgb24gdGhlIGluaXRpYWwKKyAqIGZhdWx0 OyB0aGUgc2Vjb25kIGNoZWNrIG1ha2VzIHN1cmUgdGhpcyBwYWdlIGhhc24ndCBiZWVuIHVzZWQg c2luY2UgdGhlbi4KKyAqIFRoaXMgcHJvY2VzcywgQUtBIHNlY29uZCBjaGFuY2UsIHJlcXVpcmVz IGEgbWluaW11bSBvZiB0d28gZ2VuZXJhdGlvbnMsCisgKiBoZW5jZSBNSU5fTlJfR0VOUy4gQW5k IHRvIG1haW50YWluIEFCSSBjb21wYXRpYmlsaXR5IHdpdGggdGhlIGFjdGl2ZS9pbmFjdGl2ZQor ICogTFJVLCB0aGVzZSB0d28gZ2VuZXJhdGlvbnMgYXJlIGNvbnNpZGVyZWQgYWN0aXZlOyB0aGUg cmVzdCBvZiBnZW5lcmF0aW9ucywgaWYKKyAqIHRoZXkgZXhpc3QsIGFyZSBjb25zaWRlcmVkIGlu YWN0aXZlLiBTZWUgbHJ1X2dlbl9pc19hY3RpdmUoKS4gUEdfYWN0aXZlIGlzCisgKiBhbHdheXMg Y2xlYXJlZCB3aGlsZSBhIHBhZ2UgaXMgb24gb25lIG9mIGxydWdlbi0+bGlzdHNbXSBzbyB0aGF0 IHRoZSBhZ2luZworICogbmVlZHMgbm90IHRvIHdvcnJ5IGFib3V0IGl0LiBBbmQgaXQncyBzZXQg YWdhaW4gd2hlbiBhIHBhZ2UgY29uc2lkZXJlZCBhY3RpdmUKKyAqIGlzIGlzb2xhdGVkIGZvciBu b24tcmVjbGFpbWluZyBwdXJwb3NlcywgZS5nLiwgbWlncmF0aW9uLiBTZWUKKyAqIGxydV9nZW5f YWRkX2ZvbGlvKCkgYW5kIGxydV9nZW5fZGVsX2ZvbGlvKCkuCisgKgorICogTUFYX05SX0dFTlMg aXMgc2V0IHRvIDQgc28gdGhhdCB0aGUgbXVsdGktZ2VuIExSVSBjYW4gc3VwcG9ydCB0d2ljZSBv ZiB0aGUKKyAqIGNhdGVnb3JpZXMgb2YgdGhlIGFjdGl2ZS9pbmFjdGl2ZSBMUlUgd2hlbiBrZWVw aW5nIHRyYWNrIG9mIGFjY2Vzc2VzIHRocm91Z2gKKyAqIHBhZ2UgdGFibGVzLiBJdCByZXF1aXJl cyBvcmRlcl9iYXNlXzIoTUFYX05SX0dFTlMrMSkgYml0cyBpbiBmb2xpby0+ZmxhZ3MuCisgKi8K KyNkZWZpbmUgTUlOX05SX0dFTlMJCTJVCisjZGVmaW5lIE1BWF9OUl9HRU5TCQk0VQorCisjaWZu ZGVmIF9fR0VORVJBVElOR19CT1VORFNfSAorCitzdHJ1Y3QgbHJ1dmVjOworCisjZGVmaW5lIExS VV9HRU5fTUFTSwkJKChCSVQoTFJVX0dFTl9XSURUSCkgLSAxKSA8PCBMUlVfR0VOX1BHT0ZGKQor I2RlZmluZSBMUlVfUkVGU19NQVNLCQkoKEJJVChMUlVfUkVGU19XSURUSCkgLSAxKSA8PCBMUlVf UkVGU19QR09GRikKKworI2lmZGVmIENPTkZJR19MUlVfR0VOCisKK2VudW0geworCUxSVV9HRU5f QU5PTiwKKwlMUlVfR0VOX0ZJTEUsCit9OworCisvKgorICogVGhlIHlvdW5nZXN0IGdlbmVyYXRp b24gbnVtYmVyIGlzIHN0b3JlZCBpbiBtYXhfc2VxIGZvciBib3RoIGFub24gYW5kIGZpbGUKKyAq IHR5cGVzIGFzIHRoZXkgYXJlIGFnZWQgb24gYW4gZXF1YWwgZm9vdGluZy4gVGhlIG9sZGVzdCBn ZW5lcmF0aW9uIG51bWJlcnMgYXJlCisgKiBzdG9yZWQgaW4gbWluX3NlcVtdIHNlcGFyYXRlbHkg Zm9yIGFub24gYW5kIGZpbGUgdHlwZXMgYXMgY2xlYW4gZmlsZSBwYWdlcworICogY2FuIGJlIGV2 aWN0ZWQgcmVnYXJkbGVzcyBvZiBzd2FwIGNvbnN0cmFpbnRzLgorICoKKyAqIE5vcm1hbGx5IGFu b24gYW5kIGZpbGUgbWluX3NlcSBhcmUgaW4gc3luYy4gQnV0IGlmIHN3YXBwaW5nIGlzIGNvbnN0 cmFpbmVkLAorICogZS5nLiwgb3V0IG9mIHN3YXAgc3BhY2UsIGZpbGUgbWluX3NlcSBpcyBhbGxv d2VkIHRvIGFkdmFuY2UgYW5kIGxlYXZlIGFub24KKyAqIG1pbl9zZXEgYmVoaW5kLgorICovCitz dHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgeworCS8qIHRoZSBhZ2luZyBpbmNyZW1lbnRzIHRoZSB5b3Vu Z2VzdCBnZW5lcmF0aW9uIG51bWJlciAqLworCXVuc2lnbmVkIGxvbmcgbWF4X3NlcTsKKwkvKiB0 aGUgZXZpY3Rpb24gaW5jcmVtZW50cyB0aGUgb2xkZXN0IGdlbmVyYXRpb24gbnVtYmVycyAqLwor CXVuc2lnbmVkIGxvbmcgbWluX3NlcVtBTk9OX0FORF9GSUxFXTsKKwkvKiB0aGUgbXVsdGktZ2Vu IExSVSBsaXN0cyAqLworCXN0cnVjdCBsaXN0X2hlYWQgbGlzdHNbTUFYX05SX0dFTlNdW0FOT05f QU5EX0ZJTEVdW01BWF9OUl9aT05FU107CisJLyogdGhlIHNpemVzIG9mIHRoZSBhYm92ZSBsaXN0 cyAqLworCXVuc2lnbmVkIGxvbmcgbnJfcGFnZXNbTUFYX05SX0dFTlNdW0FOT05fQU5EX0ZJTEVd W01BWF9OUl9aT05FU107Cit9OworCit2b2lkIGxydV9nZW5faW5pdF9scnV2ZWMoc3RydWN0IGxy dXZlYyAqbHJ1dmVjKTsKKworI2lmZGVmIENPTkZJR19NRU1DRwordm9pZCBscnVfZ2VuX2luaXRf bWVtY2coc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKTsKK3ZvaWQgbHJ1X2dlbl9leGl0X21lbWNn KHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZyk7CisjZW5kaWYKKworI2Vsc2UgLyogIUNPTkZJR19M UlVfR0VOICovCisKK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2luaXRfbHJ1dmVjKHN0cnVj dCBscnV2ZWMgKmxydXZlYykKK3sKK30KKworI2lmZGVmIENPTkZJR19NRU1DRworc3RhdGljIGlu bGluZSB2b2lkIGxydV9nZW5faW5pdF9tZW1jZyhzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cpCit7 Cit9CisKK3N0YXRpYyBpbmxpbmUgdm9pZCBscnVfZ2VuX2V4aXRfbWVtY2coc3RydWN0IG1lbV9j Z3JvdXAgKm1lbWNnKQoreworfQorI2VuZGlmCisKKyNlbmRpZiAvKiBDT05GSUdfTFJVX0dFTiAq LworCiBzdHJ1Y3QgbHJ1dmVjIHsKIAlzdHJ1Y3QgbGlzdF9oZWFkCQlsaXN0c1tOUl9MUlVfTElT VFNdOwogCS8qIHBlciBscnV2ZWMgbHJ1X2xvY2sgZm9yIG1lbWNnICovCkBAIC0zMzQsNiArNDI0 LDEwIEBAIHN0cnVjdCBscnV2ZWMgewogCXVuc2lnbmVkIGxvbmcJCQlyZWZhdWx0c1tBTk9OX0FO RF9GSUxFXTsKIAkvKiBWYXJpb3VzIGxydXZlYyBzdGF0ZSBmbGFncyAoZW51bSBscnV2ZWNfZmxh Z3MpICovCiAJdW5zaWduZWQgbG9uZwkJCWZsYWdzOworI2lmZGVmIENPTkZJR19MUlVfR0VOCisJ LyogZXZpY3RhYmxlIHBhZ2VzIGRpdmlkZWQgaW50byBnZW5lcmF0aW9ucyAqLworCXN0cnVjdCBs cnVfZ2VuX3N0cnVjdAkJbHJ1Z2VuOworI2VuZGlmCiAjaWZkZWYgQ09ORklHX01FTUNHCiAJc3Ry dWN0IHBnbGlzdF9kYXRhICpwZ2RhdDsKICNlbmRpZgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51 eC9wYWdlLWZsYWdzLWxheW91dC5oIGIvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxheW91dC5o CmluZGV4IGVmMWUzZTczNmUxNC4uYzE5NDZjZGI4NDVmIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xp bnV4L3BhZ2UtZmxhZ3MtbGF5b3V0LmgKKysrIGIvaW5jbHVkZS9saW51eC9wYWdlLWZsYWdzLWxh eW91dC5oCkBAIC01NSw3ICs1NSw4IEBACiAjZGVmaW5lIFNFQ1RJT05TX1dJRFRICQkwCiAjZW5k aWYKIAotI2lmIFpPTkVTX1dJRFRIICsgU0VDVElPTlNfV0lEVEggKyBOT0RFU19TSElGVCA8PSBC SVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdTCisjaWYgWk9ORVNfV0lEVEggKyBMUlVfR0VOX1dJ RFRIICsgTFJVX1JFRlNfV0lEVEggKyBTRUNUSU9OU19XSURUSCArIE5PREVTX1NISUZUIFwKKwk8 PSBCSVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdTCiAjZGVmaW5lIE5PREVTX1dJRFRICQlOT0RF U19TSElGVAogI2VsaWYgZGVmaW5lZChDT05GSUdfU1BBUlNFTUVNX1ZNRU1NQVApCiAjZXJyb3Ig IlZtZW1tYXA6IE5vIHNwYWNlIGZvciBub2RlcyBmaWVsZCBpbiBwYWdlIGZsYWdzIgpAQCAtODks OCArOTAsOCBAQAogI2RlZmluZSBMQVNUX0NQVVBJRF9TSElGVCAwCiAjZW5kaWYKIAotI2lmIFpP TkVTX1dJRFRIICsgU0VDVElPTlNfV0lEVEggKyBOT0RFU19XSURUSCArIEtBU0FOX1RBR19XSURU SCArIExBU1RfQ1BVUElEX1NISUZUIFwKLQk8PSBCSVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdT CisjaWYgWk9ORVNfV0lEVEggKyBMUlVfR0VOX1dJRFRIICsgTFJVX1JFRlNfV0lEVEggKyBTRUNU SU9OU19XSURUSCArIE5PREVTX1dJRFRIICsgXAorCUtBU0FOX1RBR19XSURUSCArIExBU1RfQ1BV UElEX1NISUZUIDw9IEJJVFNfUEVSX0xPTkcgLSBOUl9QQUdFRkxBR1MKICNkZWZpbmUgTEFTVF9D UFVQSURfV0lEVEggTEFTVF9DUFVQSURfU0hJRlQKICNlbHNlCiAjZGVmaW5lIExBU1RfQ1BVUElE X1dJRFRIIDAKQEAgLTEwMCw4ICsxMDEsOCBAQAogI2RlZmluZSBMQVNUX0NQVVBJRF9OT1RfSU5f UEFHRV9GTEFHUwogI2VuZGlmCiAKLSNpZiBaT05FU19XSURUSCArIFNFQ1RJT05TX1dJRFRIICsg Tk9ERVNfV0lEVEggKyBLQVNBTl9UQUdfV0lEVEggKyBMQVNUX0NQVVBJRF9XSURUSCBcCi0JPiBC SVRTX1BFUl9MT05HIC0gTlJfUEFHRUZMQUdTCisjaWYgWk9ORVNfV0lEVEggKyBMUlVfR0VOX1dJ RFRIICsgTFJVX1JFRlNfV0lEVEggKyBTRUNUSU9OU19XSURUSCArIE5PREVTX1dJRFRIICsgXAor CUtBU0FOX1RBR19XSURUSCArIExBU1RfQ1BVUElEX1dJRFRIID4gQklUU19QRVJfTE9ORyAtIE5S X1BBR0VGTEFHUwogI2Vycm9yICJOb3QgZW5vdWdoIGJpdHMgaW4gcGFnZSBmbGFncyIKICNlbmRp ZgogCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaCBiL2luY2x1ZGUvbGlu dXgvcGFnZS1mbGFncy5oCmluZGV4IDlkOGVlYWE2N2QwNS4uNWNiZGUwMTNjZTY2IDEwMDY0NAot LS0gYS9pbmNsdWRlL2xpbnV4L3BhZ2UtZmxhZ3MuaAorKysgYi9pbmNsdWRlL2xpbnV4L3BhZ2Ut ZmxhZ3MuaApAQCAtMTAxNyw3ICsxMDE3LDcgQEAgUEFHRUZMQUcoSXNvbGF0ZWQsIGlzb2xhdGVk LCBQRl9BTlkpOwogCSAxVUwgPDwgUEdfcHJpdmF0ZQl8IDFVTCA8PCBQR19wcml2YXRlXzIJfAlc CiAJIDFVTCA8PCBQR193cml0ZWJhY2sJfCAxVUwgPDwgUEdfcmVzZXJ2ZWQJfAlcCiAJIDFVTCA8 PCBQR19zbGFiCQl8IDFVTCA8PCBQR19hY3RpdmUgCXwJXAotCSAxVUwgPDwgUEdfdW5ldmljdGFi bGUJfCBfX1BHX01MT0NLRUQpCisJIDFVTCA8PCBQR191bmV2aWN0YWJsZQl8IF9fUEdfTUxPQ0tF RCB8IExSVV9HRU5fTUFTSykKIAogLyoKICAqIEZsYWdzIGNoZWNrZWQgd2hlbiBhIHBhZ2UgaXMg cHJlcHBlZCBmb3IgcmV0dXJuIGJ5IHRoZSBwYWdlIGFsbG9jYXRvci4KQEAgLTEwMjgsNyArMTAy OCw3IEBAIFBBR0VGTEFHKElzb2xhdGVkLCBpc29sYXRlZCwgUEZfQU5ZKTsKICAqIGFsbG9jLWZy ZWUgY3ljbGUgdG8gcHJldmVudCBmcm9tIHJldXNpbmcgdGhlIHBhZ2UuCiAgKi8KICNkZWZpbmUg UEFHRV9GTEFHU19DSEVDS19BVF9QUkVQCVwKLQkoUEFHRUZMQUdTX01BU0sgJiB+X19QR19IV1BP SVNPTikKKwkoKFBBR0VGTEFHU19NQVNLICYgfl9fUEdfSFdQT0lTT04pIHwgTFJVX0dFTl9NQVNL IHwgTFJVX1JFRlNfTUFTSykKIAogI2RlZmluZSBQQUdFX0ZMQUdTX1BSSVZBVEUJCQkJXAogCSgx VUwgPDwgUEdfcHJpdmF0ZSB8IDFVTCA8PCBQR19wcml2YXRlXzIpCmRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L3NjaGVkLmggYi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKaW5kZXggZDVlM2MwMGI3 NGUxLi40Y2Q2MzQ1ZjYyZjkgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvc2NoZWQuaAorKysg Yi9pbmNsdWRlL2xpbnV4L3NjaGVkLmgKQEAgLTkxNCw2ICs5MTQsMTAgQEAgc3RydWN0IHRhc2tf c3RydWN0IHsKICNpZmRlZiBDT05GSUdfTUVNQ0cKIAl1bnNpZ25lZAkJCWluX3VzZXJfZmF1bHQ6 MTsKICNlbmRpZgorI2lmZGVmIENPTkZJR19MUlVfR0VOCisJLyogd2hldGhlciB0aGUgTFJVIGFs Z29yaXRobSBtYXkgYXBwbHkgdG8gdGhpcyBhY2Nlc3MgKi8KKwl1bnNpZ25lZAkJCWluX2xydV9m YXVsdDoxOworI2VuZGlmCiAjaWZkZWYgQ09ORklHX0NPTVBBVF9CUksKIAl1bnNpZ25lZAkJCWJy a19yYW5kb21pemVkOjE7CiAjZW5kaWYKZGlmZiAtLWdpdCBhL2tlcm5lbC9ib3VuZHMuYyBiL2tl cm5lbC9ib3VuZHMuYwppbmRleCA5Nzk1ZDc1YjA5YjIuLmUwOGZiODlmODdmNCAxMDA2NDQKLS0t IGEva2VybmVsL2JvdW5kcy5jCisrKyBiL2tlcm5lbC9ib3VuZHMuYwpAQCAtMjIsNiArMjIsMTMg QEAgaW50IG1haW4odm9pZCkKIAlERUZJTkUoTlJfQ1BVU19CSVRTLCBpbG9nMihDT05GSUdfTlJf Q1BVUykpOwogI2VuZGlmCiAJREVGSU5FKFNQSU5MT0NLX1NJWkUsIHNpemVvZihzcGlubG9ja190 KSk7CisjaWZkZWYgQ09ORklHX0xSVV9HRU4KKwlERUZJTkUoTFJVX0dFTl9XSURUSCwgb3JkZXJf YmFzZV8yKE1BWF9OUl9HRU5TICsgMSkpOworCURFRklORShMUlVfUkVGU19XSURUSCwgMCk7Cisj ZWxzZQorCURFRklORShMUlVfR0VOX1dJRFRILCAwKTsKKwlERUZJTkUoTFJVX1JFRlNfV0lEVEgs IDApOworI2VuZGlmCiAJLyogRW5kIG9mIGNvbnN0YW50cyAqLwogCiAJcmV0dXJuIDA7CmRpZmYg LS1naXQgYS9tbS9LY29uZmlnIGIvbW0vS2NvbmZpZwppbmRleCAwMzRkODc5NTM2MDAuLjQ1OTVm YzY1NDE4MSAxMDA2NDQKLS0tIGEvbW0vS2NvbmZpZworKysgYi9tbS9LY29uZmlnCkBAIC05MDks NiArOTA5LDE0IEBAIGNvbmZpZyBBTk9OX1ZNQV9OQU1FCiAJICBhcmVhIGZyb20gYmVpbmcgbWVy Z2VkIHdpdGggYWRqYWNlbnQgdmlydHVhbCBtZW1vcnkgYXJlYXMgZHVlIHRvIHRoZQogCSAgZGlm ZmVyZW5jZSBpbiB0aGVpciBuYW1lLgogCitjb25maWcgTFJVX0dFTgorCWJvb2wgIk11bHRpLUdl biBMUlUiCisJZGVwZW5kcyBvbiBNTVUKKwkjIHRoZSBmb2xsb3dpbmcgb3B0aW9ucyBjYW4gdXNl IHVwIHRoZSBzcGFyZSBiaXRzIGluIHBhZ2UgZmxhZ3MKKwlkZXBlbmRzIG9uICFNQVhTTVAgJiYg KDY0QklUIHx8ICFTUEFSU0VNRU0gfHwgU1BBUlNFTUVNX1ZNRU1NQVApCisJaGVscAorCSAgQSBo aWdoIHBlcmZvcm1hbmNlIExSVSBpbXBsZW1lbnRhdGlvbiB0byBvdmVyY29tbWl0IG1lbW9yeS4K Kwogc291cmNlICJtbS9kYW1vbi9LY29uZmlnIgogCiBlbmRtZW51CmRpZmYgLS1naXQgYS9tbS9o dWdlX21lbW9yeS5jIGIvbW0vaHVnZV9tZW1vcnkuYwppbmRleCAyZmUzODIxMmUwN2MuLmM1ZGJi N2VlZjYxZCAxMDA2NDQKLS0tIGEvbW0vaHVnZV9tZW1vcnkuYworKysgYi9tbS9odWdlX21lbW9y eS5jCkBAIC0yMzIxLDcgKzIzMjEsOCBAQCBzdGF0aWMgdm9pZCBfX3NwbGl0X2h1Z2VfcGFnZV90 YWlsKHN0cnVjdCBwYWdlICpoZWFkLCBpbnQgdGFpbCwKICNpZmRlZiBDT05GSUdfNjRCSVQKIAkJ CSAoMUwgPDwgUEdfYXJjaF8yKSB8CiAjZW5kaWYKLQkJCSAoMUwgPDwgUEdfZGlydHkpKSk7CisJ CQkgKDFMIDw8IFBHX2RpcnR5KSB8CisJCQkgTFJVX0dFTl9NQVNLIHwgTFJVX1JFRlNfTUFTSykp OwogCiAJLyogLT5tYXBwaW5nIGluIGZpcnN0IHRhaWwgcGFnZSBpcyBjb21wb3VuZF9tYXBjb3Vu dCAqLwogCVZNX0JVR19PTl9QQUdFKHRhaWwgPiAyICYmIHBhZ2VfdGFpbC0+bWFwcGluZyAhPSBU QUlMX01BUFBJTkcsCmRpZmYgLS1naXQgYS9tbS9tZW1jb250cm9sLmMgYi9tbS9tZW1jb250cm9s LmMKaW5kZXggNzI1Zjc2NzIzMjIwLi5mNWRlOGJlODBjMTMgMTAwNjQ0Ci0tLSBhL21tL21lbWNv bnRyb2wuYworKysgYi9tbS9tZW1jb250cm9sLmMKQEAgLTUwNjIsNiArNTA2Miw3IEBAIHN0YXRp YyB2b2lkIF9fbWVtX2Nncm91cF9mcmVlKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKIAogc3Rh dGljIHZvaWQgbWVtX2Nncm91cF9mcmVlKHN0cnVjdCBtZW1fY2dyb3VwICptZW1jZykKIHsKKwls cnVfZ2VuX2V4aXRfbWVtY2cobWVtY2cpOwogCW1lbWNnX3diX2RvbWFpbl9leGl0KG1lbWNnKTsK IAlfX21lbV9jZ3JvdXBfZnJlZShtZW1jZyk7CiB9CkBAIC01MTIwLDYgKzUxMjEsNyBAQCBzdGF0 aWMgc3RydWN0IG1lbV9jZ3JvdXAgKm1lbV9jZ3JvdXBfYWxsb2Modm9pZCkKIAltZW1jZy0+ZGVm ZXJyZWRfc3BsaXRfcXVldWUuc3BsaXRfcXVldWVfbGVuID0gMDsKICNlbmRpZgogCWlkcl9yZXBs YWNlKCZtZW1fY2dyb3VwX2lkciwgbWVtY2csIG1lbWNnLT5pZC5pZCk7CisJbHJ1X2dlbl9pbml0 X21lbWNnKG1lbWNnKTsKIAlyZXR1cm4gbWVtY2c7CiBmYWlsOgogCW1lbV9jZ3JvdXBfaWRfcmVt b3ZlKG1lbWNnKTsKZGlmZiAtLWdpdCBhL21tL21lbW9yeS5jIGIvbW0vbWVtb3J5LmMKaW5kZXgg NDRhMWVjN2EyY2FjLi42ZGYyN2I4NGM1YWEgMTAwNjQ0Ci0tLSBhL21tL21lbW9yeS5jCisrKyBi L21tL21lbW9yeS5jCkBAIC00ODEyLDYgKzQ4MTIsMjcgQEAgc3RhdGljIGlubGluZSB2b2lkIG1t X2FjY291bnRfZmF1bHQoc3RydWN0IHB0X3JlZ3MgKnJlZ3MsCiAJCXBlcmZfc3dfZXZlbnQoUEVS Rl9DT1VOVF9TV19QQUdFX0ZBVUxUU19NSU4sIDEsIHJlZ3MsIGFkZHJlc3MpOwogfQogCisjaWZk ZWYgQ09ORklHX0xSVV9HRU4KK3N0YXRpYyB2b2lkIGxydV9nZW5fZW50ZXJfZmF1bHQoc3RydWN0 IHZtX2FyZWFfc3RydWN0ICp2bWEpCit7CisJLyogdGhlIExSVSBhbGdvcml0aG0gZG9lc24ndCBh cHBseSB0byBzZXF1ZW50aWFsIG9yIHJhbmRvbSByZWFkcyAqLworCWN1cnJlbnQtPmluX2xydV9m YXVsdCA9ICEodm1hLT52bV9mbGFncyAmIChWTV9TRVFfUkVBRCB8IFZNX1JBTkRfUkVBRCkpOwor fQorCitzdGF0aWMgdm9pZCBscnVfZ2VuX2V4aXRfZmF1bHQodm9pZCkKK3sKKwljdXJyZW50LT5p bl9scnVfZmF1bHQgPSBmYWxzZTsKK30KKyNlbHNlCitzdGF0aWMgdm9pZCBscnVfZ2VuX2VudGVy X2ZhdWx0KHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hKQoreworfQorCitzdGF0aWMgdm9pZCBs cnVfZ2VuX2V4aXRfZmF1bHQodm9pZCkKK3sKK30KKyNlbmRpZiAvKiBDT05GSUdfTFJVX0dFTiAq LworCiAvKgogICogQnkgdGhlIHRpbWUgd2UgZ2V0IGhlcmUsIHdlIGFscmVhZHkgaG9sZCB0aGUg bW0gc2VtYXBob3JlCiAgKgpAQCAtNDg0MywxMSArNDg2NCwxNSBAQCB2bV9mYXVsdF90IGhhbmRs ZV9tbV9mYXVsdChzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwgdW5zaWduZWQgbG9uZyBhZGRy ZXNzLAogCWlmIChmbGFncyAmIEZBVUxUX0ZMQUdfVVNFUikKIAkJbWVtX2Nncm91cF9lbnRlcl91 c2VyX2ZhdWx0KCk7CiAKKwlscnVfZ2VuX2VudGVyX2ZhdWx0KHZtYSk7CisKIAlpZiAodW5saWtl bHkoaXNfdm1faHVnZXRsYl9wYWdlKHZtYSkpKQogCQlyZXQgPSBodWdldGxiX2ZhdWx0KHZtYS0+ dm1fbW0sIHZtYSwgYWRkcmVzcywgZmxhZ3MpOwogCWVsc2UKIAkJcmV0ID0gX19oYW5kbGVfbW1f ZmF1bHQodm1hLCBhZGRyZXNzLCBmbGFncyk7CiAKKwlscnVfZ2VuX2V4aXRfZmF1bHQoKTsKKwog CWlmIChmbGFncyAmIEZBVUxUX0ZMQUdfVVNFUikgewogCQltZW1fY2dyb3VwX2V4aXRfdXNlcl9m YXVsdCgpOwogCQkvKgpkaWZmIC0tZ2l0IGEvbW0vbW1faW5pdC5jIGIvbW0vbW1faW5pdC5jCmlu ZGV4IDlkZGFmMGUxYjBhYi4uMGQ3YjJiZDI0NTRhIDEwMDY0NAotLS0gYS9tbS9tbV9pbml0LmMK KysrIGIvbW0vbW1faW5pdC5jCkBAIC02NSwxNCArNjUsMTYgQEAgdm9pZCBfX2luaXQgbW1pbml0 X3ZlcmlmeV9wYWdlZmxhZ3NfbGF5b3V0KHZvaWQpCiAKIAlzaGlmdCA9IDggKiBzaXplb2YodW5z aWduZWQgbG9uZyk7CiAJd2lkdGggPSBzaGlmdCAtIFNFQ1RJT05TX1dJRFRIIC0gTk9ERVNfV0lE VEggLSBaT05FU19XSURUSAotCQktIExBU1RfQ1BVUElEX1NISUZUIC0gS0FTQU5fVEFHX1dJRFRI OworCQktIExBU1RfQ1BVUElEX1NISUZUIC0gS0FTQU5fVEFHX1dJRFRIIC0gTFJVX0dFTl9XSURU SCAtIExSVV9SRUZTX1dJRFRIOwogCW1taW5pdF9kcHJpbnRrKE1NSU5JVF9UUkFDRSwgInBhZ2Vm bGFnc19sYXlvdXRfd2lkdGhzIiwKLQkJIlNlY3Rpb24gJWQgTm9kZSAlZCBab25lICVkIExhc3Rj cHVwaWQgJWQgS2FzYW50YWcgJWQgRmxhZ3MgJWRcbiIsCisJCSJTZWN0aW9uICVkIE5vZGUgJWQg Wm9uZSAlZCBMYXN0Y3B1cGlkICVkIEthc2FudGFnICVkIEdlbiAlZCBUaWVyICVkIEZsYWdzICVk XG4iLAogCQlTRUNUSU9OU19XSURUSCwKIAkJTk9ERVNfV0lEVEgsCiAJCVpPTkVTX1dJRFRILAog CQlMQVNUX0NQVVBJRF9XSURUSCwKIAkJS0FTQU5fVEFHX1dJRFRILAorCQlMUlVfR0VOX1dJRFRI LAorCQlMUlVfUkVGU19XSURUSCwKIAkJTlJfUEFHRUZMQUdTKTsKIAltbWluaXRfZHByaW50ayhN TUlOSVRfVFJBQ0UsICJwYWdlZmxhZ3NfbGF5b3V0X3NoaWZ0cyIsCiAJCSJTZWN0aW9uICVkIE5v ZGUgJWQgWm9uZSAlZCBMYXN0Y3B1cGlkICVkIEthc2FudGFnICVkXG4iLApkaWZmIC0tZ2l0IGEv bW0vbW16b25lLmMgYi9tbS9tbXpvbmUuYwppbmRleCAwYWU3NTcxZTM1YWIuLjY4ZTE1MTFiZTEy ZCAxMDA2NDQKLS0tIGEvbW0vbW16b25lLmMKKysrIGIvbW0vbW16b25lLmMKQEAgLTg4LDYgKzg4 LDggQEAgdm9pZCBscnV2ZWNfaW5pdChzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMpCiAJICogUG9pc29u IGl0cyBsaXN0IGhlYWQsIHNvIHRoYXQgYW55IG9wZXJhdGlvbnMgb24gaXQgd291bGQgY3Jhc2gu CiAJICovCiAJbGlzdF9kZWwoJmxydXZlYy0+bGlzdHNbTFJVX1VORVZJQ1RBQkxFXSk7CisKKwls cnVfZ2VuX2luaXRfbHJ1dmVjKGxydXZlYyk7CiB9CiAKICNpZiBkZWZpbmVkKENPTkZJR19OVU1B X0JBTEFOQ0lORykgJiYgIWRlZmluZWQoTEFTVF9DUFVQSURfTk9UX0lOX1BBR0VfRkxBR1MpCmRp ZmYgLS1naXQgYS9tbS9zd2FwLmMgYi9tbS9zd2FwLmMKaW5kZXggN2UzMjBlYzA4YzZhLi5hNjg3 MGJhMGJkODMgMTAwNjQ0Ci0tLSBhL21tL3N3YXAuYworKysgYi9tbS9zd2FwLmMKQEAgLTQ2MCw2 ICs0NjAsMTEgQEAgdm9pZCBmb2xpb19hZGRfbHJ1KHN0cnVjdCBmb2xpbyAqZm9saW8pCiAJVk1f QlVHX09OX0ZPTElPKGZvbGlvX3Rlc3RfYWN0aXZlKGZvbGlvKSAmJiBmb2xpb190ZXN0X3VuZXZp Y3RhYmxlKGZvbGlvKSwgZm9saW8pOwogCVZNX0JVR19PTl9GT0xJTyhmb2xpb190ZXN0X2xydShm b2xpbyksIGZvbGlvKTsKIAorCS8qIHNlZSB0aGUgY29tbWVudCBpbiBscnVfZ2VuX2FkZF9mb2xp bygpICovCisJaWYgKGxydV9nZW5fZW5hYmxlZCgpICYmICFmb2xpb190ZXN0X3VuZXZpY3RhYmxl KGZvbGlvKSAmJgorCSAgICBscnVfZ2VuX2luX2ZhdWx0KCkgJiYgIShjdXJyZW50LT5mbGFncyAm IFBGX01FTUFMTE9DKSkKKwkJZm9saW9fc2V0X2FjdGl2ZShmb2xpbyk7CisKIAlmb2xpb19nZXQo Zm9saW8pOwogCWxvY2FsX2xvY2soJmxydV9wdmVjcy5sb2NrKTsKIAlwdmVjID0gdGhpc19jcHVf cHRyKCZscnVfcHZlY3MubHJ1X2FkZCk7CkBAIC01NTEsNyArNTU2LDcgQEAgc3RhdGljIHZvaWQg bHJ1X2RlYWN0aXZhdGVfZmlsZV9mbihzdHJ1Y3QgcGFnZSAqcGFnZSwgc3RydWN0IGxydXZlYyAq bHJ1dmVjKQogCiBzdGF0aWMgdm9pZCBscnVfZGVhY3RpdmF0ZV9mbihzdHJ1Y3QgcGFnZSAqcGFn ZSwgc3RydWN0IGxydXZlYyAqbHJ1dmVjKQogewotCWlmIChQYWdlQWN0aXZlKHBhZ2UpICYmICFQ YWdlVW5ldmljdGFibGUocGFnZSkpIHsKKwlpZiAoIVBhZ2VVbmV2aWN0YWJsZShwYWdlKSAmJiAo UGFnZUFjdGl2ZShwYWdlKSB8fCBscnVfZ2VuX2VuYWJsZWQoKSkpIHsKIAkJaW50IG5yX3BhZ2Vz ID0gdGhwX25yX3BhZ2VzKHBhZ2UpOwogCiAJCWRlbF9wYWdlX2Zyb21fbHJ1X2xpc3QocGFnZSwg bHJ1dmVjKTsKQEAgLTY2Niw3ICs2NzEsNyBAQCB2b2lkIGRlYWN0aXZhdGVfZmlsZV9mb2xpbyhz dHJ1Y3QgZm9saW8gKmZvbGlvKQogICovCiB2b2lkIGRlYWN0aXZhdGVfcGFnZShzdHJ1Y3QgcGFn ZSAqcGFnZSkKIHsKLQlpZiAoUGFnZUxSVShwYWdlKSAmJiBQYWdlQWN0aXZlKHBhZ2UpICYmICFQ YWdlVW5ldmljdGFibGUocGFnZSkpIHsKKwlpZiAoUGFnZUxSVShwYWdlKSAmJiAhUGFnZVVuZXZp Y3RhYmxlKHBhZ2UpICYmIChQYWdlQWN0aXZlKHBhZ2UpIHx8IGxydV9nZW5fZW5hYmxlZCgpKSkg ewogCQlzdHJ1Y3QgcGFnZXZlYyAqcHZlYzsKIAogCQlsb2NhbF9sb2NrKCZscnVfcHZlY3MubG9j ayk7CmRpZmYgLS1naXQgYS9tbS92bXNjYW4uYyBiL21tL3Ztc2Nhbi5jCmluZGV4IDIyMzJjYjU1 YWY0MS4uMzdkZDVkMWMzZDA3IDEwMDY0NAotLS0gYS9tbS92bXNjYW4uYworKysgYi9tbS92bXNj YW4uYwpAQCAtMjk2OCw2ICsyOTY4LDgxIEBAIHN0YXRpYyBib29sIGNhbl9hZ2VfYW5vbl9wYWdl cyhzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0LAogCXJldHVybiBjYW5fZGVtb3RlKHBnZGF0LT5u b2RlX2lkLCBzYyk7CiB9CiAKKyNpZmRlZiBDT05GSUdfTFJVX0dFTgorCisvKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgc2hvcnRoYW5kIGhlbHBlcnMK KyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKiovCisKKyNkZWZpbmUgZm9yX2VhY2hfZ2VuX3R5cGVfem9u ZShnZW4sIHR5cGUsIHpvbmUpCQkJCVwKKwlmb3IgKChnZW4pID0gMDsgKGdlbikgPCBNQVhfTlJf R0VOUzsgKGdlbikrKykJCQlcCisJCWZvciAoKHR5cGUpID0gMDsgKHR5cGUpIDwgQU5PTl9BTkRf RklMRTsgKHR5cGUpKyspCVwKKwkJCWZvciAoKHpvbmUpID0gMDsgKHpvbmUpIDwgTUFYX05SX1pP TkVTOyAoem9uZSkrKykKKworc3RhdGljIHN0cnVjdCBscnV2ZWMgX19tYXliZV91bnVzZWQgKmdl dF9scnV2ZWMoc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnLCBpbnQgbmlkKQoreworCXN0cnVjdCBw Z2xpc3RfZGF0YSAqcGdkYXQgPSBOT0RFX0RBVEEobmlkKTsKKworI2lmZGVmIENPTkZJR19NRU1D RworCWlmIChtZW1jZykgeworCQlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMgPSAmbWVtY2ctPm5vZGVp bmZvW25pZF0tPmxydXZlYzsKKworCQkvKiBmb3IgaG90YWRkX25ld19wZ2RhdCgpICovCisJCWlm ICghbHJ1dmVjLT5wZ2RhdCkKKwkJCWxydXZlYy0+cGdkYXQgPSBwZ2RhdDsKKworCQlyZXR1cm4g bHJ1dmVjOworCX0KKyNlbmRpZgorCVZNX0JVR19PTighbWVtX2Nncm91cF9kaXNhYmxlZCgpKTsK KworCXJldHVybiBwZ2RhdCA/ICZwZ2RhdC0+X19scnV2ZWMgOiBOVUxMOworfQorCisvKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgaW5pdGlhbGl6YXRp b24KKyAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKiovCisKK3ZvaWQgbHJ1X2dlbl9pbml0X2xydXZlYyhz dHJ1Y3QgbHJ1dmVjICpscnV2ZWMpCit7CisJaW50IGdlbiwgdHlwZSwgem9uZTsKKwlzdHJ1Y3Qg bHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZscnV2ZWMtPmxydWdlbjsKKworCWxydWdlbi0+bWF4 X3NlcSA9IE1JTl9OUl9HRU5TICsgMTsKKworCWZvcl9lYWNoX2dlbl90eXBlX3pvbmUoZ2VuLCB0 eXBlLCB6b25lKQorCQlJTklUX0xJU1RfSEVBRCgmbHJ1Z2VuLT5saXN0c1tnZW5dW3R5cGVdW3pv bmVdKTsKK30KKworI2lmZGVmIENPTkZJR19NRU1DRwordm9pZCBscnVfZ2VuX2luaXRfbWVtY2co c3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnKQoreworfQorCit2b2lkIGxydV9nZW5fZXhpdF9tZW1j ZyhzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cpCit7CisJaW50IG5pZDsKKworCWZvcl9lYWNoX25v ZGUobmlkKSB7CisJCXN0cnVjdCBscnV2ZWMgKmxydXZlYyA9IGdldF9scnV2ZWMobWVtY2csIG5p ZCk7CisKKwkJVk1fQlVHX09OKG1lbWNocl9pbnYobHJ1dmVjLT5scnVnZW4ubnJfcGFnZXMsIDAs CisJCQkJICAgICBzaXplb2YobHJ1dmVjLT5scnVnZW4ubnJfcGFnZXMpKSk7CisJfQorfQorI2Vu ZGlmCisKK3N0YXRpYyBpbnQgX19pbml0IGluaXRfbHJ1X2dlbih2b2lkKQoreworCUJVSUxEX0JV R19PTihNSU5fTlJfR0VOUyArIDEgPj0gTUFYX05SX0dFTlMpOworCUJVSUxEX0JVR19PTihCSVQo TFJVX0dFTl9XSURUSCkgPD0gTUFYX05SX0dFTlMpOworCisJcmV0dXJuIDA7Cit9OworbGF0ZV9p bml0Y2FsbChpbml0X2xydV9nZW4pOworCisjZW5kaWYgLyogQ09ORklHX0xSVV9HRU4gKi8KKwog c3RhdGljIHZvaWQgc2hyaW5rX2xydXZlYyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBz Y2FuX2NvbnRyb2wgKnNjKQogewogCXVuc2lnbmVkIGxvbmcgbnJbTlJfTFJVX0xJU1RTXTsKLS0g CjIuMzUuMS4xMDk0Lmc3YzdkOTAyYTdjLWdvb2cKCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51 eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==