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 4C4C3C433EF for ; Wed, 9 Mar 2022 01:15:16 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230362AbiCIBQM (ORCPT ); Tue, 8 Mar 2022 20:16:12 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:44692 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230241AbiCIBOe (ORCPT ); Tue, 8 Mar 2022 20:14:34 -0500 Received: from mail-yw1-x1149.google.com (mail-yw1-x1149.google.com [IPv6:2607:f8b0:4864:20::1149]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6975C710E2 for ; Tue, 8 Mar 2022 16:59:59 -0800 (PST) Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-2d7eaa730d9so4841227b3.13 for ; Tue, 08 Mar 2022 16:59:59 -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=/iCNuexYGotGFt8POzGsBCce+mSDDcAsjMZkTqPyc38=; b=YRJglsMVDEyVZaVp011I0ixjYYUWlm3Jg9BIYGMWPz1C0d9GvEiUe2EALmUkx3ZXuf +c09J0A38DJyIsnaQDFUn1j9asWovFlKB1Y5AE88hLd6W245q9ph31J5MpqLBbSCFswZ hvuF08on3fwythCoePPVCg8FQdJFK6ElT+iXwCKrIRKtg5D/j7rHjM2/Mj40F4lLvpjy cqXqXNW3DC0xtUPZs9UEEAW1uWkXBIGlAu9RlbarIEvqBPVWvizv3BWm4nmUfKxokpZC Tg8N9avZVLEbJAC5Gnt0pewjSBU/hb/ZYhTaYz7kUXXPDEG+eECBbgetgPcy/QaSF0U+ R0/A== 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=/iCNuexYGotGFt8POzGsBCce+mSDDcAsjMZkTqPyc38=; b=HS+ZeXAkh/iV7YXc/E6buSEE0GcQyIDtt8VFYDV9mAwv/mYhsezkPLfEYbNX+ZKrd9 wG7bk0CeXrentaMg50MptwWh4Pn9w3Z94Y+cVlAfgtiu/s3igIhMiTw+e/ZIZjqT77JR gJyAvnm0q1PRZB9xqIliJn0CZ6hcybOqCVFlGR37ppfMxbvT5+xoqW6Tx5x3LvEL3c31 GYI7SFWAD3NiM81J7uK3BSwltxLxt+UYCY/T27F1m/WljNPruM8Va7gLJq7Qsz8kzTbd LEj2C2wMzsjXtUNIU4NCduF/pV2IF6DJPt3jadHNLKjfLwHfELr4nYPNkivMGwaYYJrX hRhg== X-Gm-Message-State: AOAM5315R9OlLnqGP9lHJ5gKvbuHLlsbzhqLukUhznBuMnMZ2s5N22mX C/lvedDzTkGcowZz27xqAMXXGL+wxcU= X-Google-Smtp-Source: ABdhPJw1Yd1Ej264ruZWhlybkE9ZtgXn1ttNUy7v7eonV3w7gUp67PvrNKscp4FV95hqBmLC0NMzeMF9S6c= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:128f:0:b0:2dc:3c54:c5d8 with SMTP id 137-20020a81128f000000b002dc3c54c5d8mr14744211yws.395.1646783318114; Tue, 08 Mar 2022 15:48:38 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:20 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-11-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 10/14] mm: multi-gen LRU: kill switch 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 Add /sys/kernel/mm/lru_gen/enabled as a kill switch. Components that can be disabled include: 0x0001: the multi-gen LRU core 0x0002: walking page table, when arch_has_hw_pte_young() returns true 0x0004: clearing the accessed bit in non-leaf PMD entries, when CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG=3Dy [yYnN]: apply to all the components above E.g., echo y >/sys/kernel/mm/lru_gen/enabled cat /sys/kernel/mm/lru_gen/enabled 0x0007 echo 5 >/sys/kernel/mm/lru_gen/enabled cat /sys/kernel/mm/lru_gen/enabled 0x0005 NB: the page table walks happen on the scale of seconds under heavy memory pressure, in which case the mmap_lock contention is a lesser concern, compared with the LRU lock contention and the I/O congestion. So far the only well-known case of the mmap_lock contention happens on Android, due to Scudo [1] which allocates several thousand VMAs for merely a few hundred MBs. The SPF and the Maple Tree also have provided their own assessments [2][3]. However, if walking page tables does worsen the mmap_lock contention, the kill switch can be used to disable it. In this case the multi-gen LRU will suffer a minor performance degradation, as shown previously. Clearing the accessed bit in non-leaf PMD entries can also be disabled, since this behavior was not tested on x86 varieties other than Intel and AMD. [1] https://source.android.com/devices/tech/debug/scudo [2] https://lore.kernel.org/lkml/20220128131006.67712-1-michel@lespinasse.o= rg/ [3] https://lore.kernel.org/lkml/20220202024137.2516438-1-Liam.Howlett@orac= le.com/ 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 --- include/linux/cgroup.h | 15 +- include/linux/mm_inline.h | 12 +- include/linux/mmzone.h | 9 ++ kernel/cgroup/cgroup-internal.h | 1 - mm/Kconfig | 6 + mm/vmscan.c | 237 +++++++++++++++++++++++++++++++- 6 files changed, 271 insertions(+), 9 deletions(-) diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h index 75c151413fda..b145025f3eac 100644 --- a/include/linux/cgroup.h +++ b/include/linux/cgroup.h @@ -432,6 +432,18 @@ static inline void cgroup_put(struct cgroup *cgrp) css_put(&cgrp->self); } =20 +extern struct mutex cgroup_mutex; + +static inline void cgroup_lock(void) +{ + mutex_lock(&cgroup_mutex); +} + +static inline void cgroup_unlock(void) +{ + mutex_unlock(&cgroup_mutex); +} + /** * task_css_set_check - obtain a task's css_set with extra access conditio= ns * @task: the task to obtain css_set for @@ -446,7 +458,6 @@ static inline void cgroup_put(struct cgroup *cgrp) * as locks used during the cgroup_subsys::attach() methods. */ #ifdef CONFIG_PROVE_RCU -extern struct mutex cgroup_mutex; extern spinlock_t css_set_lock; #define task_css_set_check(task, __c) \ rcu_dereference_check((task)->cgroups, \ @@ -707,6 +718,8 @@ struct cgroup; static inline u64 cgroup_id(const struct cgroup *cgrp) { return 1; } static inline void css_get(struct cgroup_subsys_state *css) {} static inline void css_put(struct cgroup_subsys_state *css) {} +static inline void cgroup_lock(void) {} +static inline void cgroup_unlock(void) {} static inline int cgroup_attach_task_all(struct task_struct *from, struct task_struct *t) { return 0; } static inline int cgroupstats_build(struct cgroupstats *stats, diff --git a/include/linux/mm_inline.h b/include/linux/mm_inline.h index 15a04a9b5560..1c8d617e73a9 100644 --- a/include/linux/mm_inline.h +++ b/include/linux/mm_inline.h @@ -106,7 +106,15 @@ static __always_inline enum lru_list folio_lru_list(st= ruct folio *folio) =20 static inline bool lru_gen_enabled(void) { - return true; +#ifdef CONFIG_LRU_GEN_ENABLED + DECLARE_STATIC_KEY_TRUE(lru_gen_caps[NR_LRU_GEN_CAPS]); + + return static_branch_likely(&lru_gen_caps[LRU_GEN_CORE]); +#else + DECLARE_STATIC_KEY_FALSE(lru_gen_caps[NR_LRU_GEN_CAPS]); + + return static_branch_unlikely(&lru_gen_caps[LRU_GEN_CORE]); +#endif } =20 static inline bool lru_gen_in_fault(void) @@ -196,7 +204,7 @@ static inline bool lru_gen_add_folio(struct lruvec *lru= vec, struct folio *folio, int zone =3D folio_zonenum(folio); struct lru_gen_struct *lrugen =3D &lruvec->lrugen; =20 - if (folio_test_unevictable(folio)) + if (folio_test_unevictable(folio) || !lrugen->enabled) return false; /* * There are three common cases for this page: diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h index 8706f75a12dd..51e90e1eec3f 100644 --- a/include/linux/mmzone.h +++ b/include/linux/mmzone.h @@ -316,6 +316,13 @@ enum { LRU_GEN_FILE, }; =20 +enum { + LRU_GEN_CORE, + LRU_GEN_MM_WALK, + LRU_GEN_NONLEAF_YOUNG, + NR_LRU_GEN_CAPS +}; + #define MIN_LRU_BATCH BITS_PER_LONG #define MAX_LRU_BATCH (MIN_LRU_BATCH * 128) =20 @@ -397,6 +404,8 @@ struct lru_gen_struct { /* can be modified without holding the LRU lock */ atomic_long_t evicted[NR_HIST_GENS][ANON_AND_FILE][MAX_NR_TIERS]; atomic_long_t refaulted[NR_HIST_GENS][ANON_AND_FILE][MAX_NR_TIERS]; + /* whether the multi-gen LRU is enabled */ + bool enabled; }; =20 enum { diff --git a/kernel/cgroup/cgroup-internal.h b/kernel/cgroup/cgroup-interna= l.h index 6e36e854b512..929ed3bf1a7c 100644 --- a/kernel/cgroup/cgroup-internal.h +++ b/kernel/cgroup/cgroup-internal.h @@ -165,7 +165,6 @@ struct cgroup_mgctx { #define DEFINE_CGROUP_MGCTX(name) \ struct cgroup_mgctx name =3D CGROUP_MGCTX_INIT(name) =20 -extern struct mutex cgroup_mutex; extern spinlock_t css_set_lock; extern struct cgroup_subsys *cgroup_subsys[]; extern struct list_head cgroup_roots; diff --git a/mm/Kconfig b/mm/Kconfig index d4aa3d881269..e9d5f1d09ac4 100644 --- a/mm/Kconfig +++ b/mm/Kconfig @@ -901,6 +901,12 @@ config LRU_GEN help A high performance LRU implementation for memory overcommit. =20 +config LRU_GEN_ENABLED + bool "Enable by default" + depends on LRU_GEN + help + This option enables the multi-gen LRU by default. + config NR_LRU_GENS int "Max number of generations" depends on LRU_GEN diff --git a/mm/vmscan.c b/mm/vmscan.c index 7375c9dae08f..55cc7d6b018b 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -3063,6 +3063,12 @@ static bool can_age_anon_pages(struct pglist_data *p= gdat, =20 #ifdef CONFIG_LRU_GEN =20 +#ifdef CONFIG_LRU_GEN_ENABLED +DEFINE_STATIC_KEY_ARRAY_TRUE(lru_gen_caps, NR_LRU_GEN_CAPS); +#else +DEFINE_STATIC_KEY_ARRAY_FALSE(lru_gen_caps, NR_LRU_GEN_CAPS); +#endif + /*************************************************************************= ***** * shorthand helpers *************************************************************************= *****/ @@ -3099,6 +3105,15 @@ static int folio_lru_tier(struct folio *folio) return lru_tier_from_refs(refs); } =20 +static bool get_cap(int cap) +{ +#ifdef CONFIG_LRU_GEN_ENABLED + return static_branch_likely(&lru_gen_caps[cap]); +#else + return static_branch_unlikely(&lru_gen_caps[cap]); +#endif +} + static struct lruvec *get_lruvec(struct mem_cgroup *memcg, int nid) { struct pglist_data *pgdat =3D NODE_DATA(nid); @@ -3892,7 +3907,8 @@ static void walk_pmd_range_locked(pud_t *pud, unsigne= d long next, struct vm_area goto next; =20 if (!pmd_trans_huge(pmd[i])) { - if (IS_ENABLED(CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG)) + if (IS_ENABLED(CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG) && + get_cap(LRU_GEN_NONLEAF_YOUNG)) pmdp_test_and_clear_young(vma, addr, pmd + i); goto next; } @@ -3999,10 +4015,12 @@ static void walk_pmd_range(pud_t *pud, unsigned lon= g start, unsigned long end, priv->mm_stats[MM_PMD_TOTAL]++; =20 #ifdef CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG - if (!pmd_young(val)) - continue; + if (get_cap(LRU_GEN_NONLEAF_YOUNG)) { + if (!pmd_young(val)) + continue; =20 - walk_pmd_range_locked(pud, addr, vma, walk, &pos); + walk_pmd_range_locked(pud, addr, vma, walk, &pos); + } #endif if (!priv->full_scan && !test_bloom_filter(priv->lruvec, priv->max_seq, = pmd + i)) continue; @@ -4233,7 +4251,7 @@ static bool try_to_inc_max_seq(struct lruvec *lruvec,= unsigned long max_seq, * handful of PTEs. Spreading the work out over a period of time usually * is less efficient, but it avoids bursty page faults. */ - if (!full_scan && !arch_has_hw_pte_young()) { + if (!full_scan && (!arch_has_hw_pte_young() || !get_cap(LRU_GEN_MM_WALK))= ) { success =3D iterate_mm_list_nowalk(lruvec, max_seq); goto done; } @@ -4946,6 +4964,211 @@ static void lru_gen_shrink_lruvec(struct lruvec *lr= uvec, struct scan_control *sc blk_finish_plug(&plug); } =20 +/*************************************************************************= ***** + * state change + *************************************************************************= *****/ + +static bool __maybe_unused state_is_valid(struct lruvec *lruvec) +{ + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + + if (lrugen->enabled) { + enum lru_list lru; + + for_each_evictable_lru(lru) { + if (!list_empty(&lruvec->lists[lru])) + return false; + } + } else { + int gen, type, zone; + + for_each_gen_type_zone(gen, type, zone) { + if (!list_empty(&lrugen->lists[gen][type][zone])) + return false; + + /* unlikely but not a bug when reset_batch_size() is pending */ + VM_WARN_ON(lrugen->nr_pages[gen][type][zone]); + } + } + + return true; +} + +static bool fill_evictable(struct lruvec *lruvec) +{ + enum lru_list lru; + int remaining =3D MAX_LRU_BATCH; + + for_each_evictable_lru(lru) { + int type =3D is_file_lru(lru); + bool active =3D is_active_lru(lru); + struct list_head *head =3D &lruvec->lists[lru]; + + while (!list_empty(head)) { + bool success; + struct folio *folio =3D lru_to_folio(head); + + VM_BUG_ON_FOLIO(folio_test_unevictable(folio), folio); + VM_BUG_ON_FOLIO(folio_test_active(folio) !=3D active, folio); + VM_BUG_ON_FOLIO(folio_is_file_lru(folio) !=3D type, folio); + VM_BUG_ON_FOLIO(folio_lru_gen(folio) < MAX_NR_GENS, folio); + + lruvec_del_folio(lruvec, folio); + success =3D lru_gen_add_folio(lruvec, folio, false); + VM_BUG_ON(!success); + + if (!--remaining) + return false; + } + } + + return true; +} + +static bool drain_evictable(struct lruvec *lruvec) +{ + int gen, type, zone; + int remaining =3D MAX_LRU_BATCH; + + for_each_gen_type_zone(gen, type, zone) { + struct list_head *head =3D &lruvec->lrugen.lists[gen][type][zone]; + + while (!list_empty(head)) { + bool success; + struct folio *folio =3D lru_to_folio(head); + + VM_BUG_ON_FOLIO(folio_test_unevictable(folio), folio); + VM_BUG_ON_FOLIO(folio_test_active(folio), folio); + VM_BUG_ON_FOLIO(folio_is_file_lru(folio) !=3D type, folio); + VM_BUG_ON_FOLIO(folio_zonenum(folio) !=3D zone, folio); + + success =3D lru_gen_del_folio(lruvec, folio, false); + VM_BUG_ON(!success); + lruvec_add_folio(lruvec, folio); + + if (!--remaining) + return false; + } + } + + return true; +} + +static void lru_gen_change_state(bool enable) +{ + static DEFINE_MUTEX(state_mutex); + + struct mem_cgroup *memcg; + + cgroup_lock(); + cpus_read_lock(); + get_online_mems(); + mutex_lock(&state_mutex); + + if (enable =3D=3D lru_gen_enabled()) + goto unlock; + + if (enable) + static_branch_enable_cpuslocked(&lru_gen_caps[LRU_GEN_CORE]); + else + static_branch_disable_cpuslocked(&lru_gen_caps[LRU_GEN_CORE]); + + memcg =3D mem_cgroup_iter(NULL, NULL, NULL); + do { + int nid; + + for_each_node(nid) { + struct lruvec *lruvec =3D get_lruvec(memcg, nid); + + if (!lruvec) + continue; + + spin_lock_irq(&lruvec->lru_lock); + + VM_BUG_ON(!seq_is_valid(lruvec)); + VM_BUG_ON(!state_is_valid(lruvec)); + + lruvec->lrugen.enabled =3D enable; + + while (!(enable ? fill_evictable(lruvec) : drain_evictable(lruvec))) { + spin_unlock_irq(&lruvec->lru_lock); + cond_resched(); + spin_lock_irq(&lruvec->lru_lock); + } + + spin_unlock_irq(&lruvec->lru_lock); + } + + cond_resched(); + } while ((memcg =3D mem_cgroup_iter(NULL, memcg, NULL))); +unlock: + mutex_unlock(&state_mutex); + put_online_mems(); + cpus_read_unlock(); + cgroup_unlock(); +} + +/*************************************************************************= ***** + * sysfs interface + *************************************************************************= *****/ + +static ssize_t show_enable(struct kobject *kobj, struct kobj_attribute *at= tr, char *buf) +{ + unsigned int caps =3D 0; + + if (get_cap(LRU_GEN_CORE)) + caps |=3D BIT(LRU_GEN_CORE); + + if (arch_has_hw_pte_young() && get_cap(LRU_GEN_MM_WALK)) + caps |=3D BIT(LRU_GEN_MM_WALK); + + if (IS_ENABLED(CONFIG_ARCH_HAS_NONLEAF_PMD_YOUNG) && get_cap(LRU_GEN_NONL= EAF_YOUNG)) + caps |=3D BIT(LRU_GEN_NONLEAF_YOUNG); + + return snprintf(buf, PAGE_SIZE, "0x%04x\n", caps); +} + +static ssize_t store_enable(struct kobject *kobj, struct kobj_attribute *a= ttr, + const char *buf, size_t len) +{ + int i; + unsigned int caps; + + if (tolower(*buf) =3D=3D 'n') + caps =3D 0; + else if (tolower(*buf) =3D=3D 'y') + caps =3D -1; + else if (kstrtouint(buf, 0, &caps)) + return -EINVAL; + + for (i =3D 0; i < NR_LRU_GEN_CAPS; i++) { + bool enable =3D caps & BIT(i); + + if (i =3D=3D LRU_GEN_CORE) + lru_gen_change_state(enable); + else if (enable) + static_branch_enable(&lru_gen_caps[i]); + else + static_branch_disable(&lru_gen_caps[i]); + } + + return len; +} + +static struct kobj_attribute lru_gen_enabled_attr =3D __ATTR( + enabled, 0644, show_enable, store_enable +); + +static struct attribute *lru_gen_attrs[] =3D { + &lru_gen_enabled_attr.attr, + NULL +}; + +static struct attribute_group lru_gen_attr_group =3D { + .name =3D "lru_gen", + .attrs =3D lru_gen_attrs, +}; + /*************************************************************************= ***** * initialization *************************************************************************= *****/ @@ -4956,6 +5179,7 @@ void lru_gen_init_lruvec(struct lruvec *lruvec) struct lru_gen_struct *lrugen =3D &lruvec->lrugen; =20 lrugen->max_seq =3D MIN_NR_GENS + 1; + lrugen->enabled =3D lru_gen_enabled(); =20 for_each_gen_type_zone(gen, type, zone) INIT_LIST_HEAD(&lrugen->lists[gen][type][zone]); @@ -4996,6 +5220,9 @@ static int __init init_lru_gen(void) BUILD_BUG_ON(BIT(LRU_GEN_WIDTH) <=3D MAX_NR_GENS); BUILD_BUG_ON(sizeof(MM_STAT_CODES) !=3D NR_MM_STATS + 1); =20 + if (sysfs_create_group(mm_kobj, &lru_gen_attr_group)) + pr_err("lru_gen: failed to create sysfs group\n"); + return 0; }; late_initcall(init_lru_gen); --=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 77F91C433F5 for ; Tue, 8 Mar 2022 23:56:56 +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=fmJCr6UO1AAtA0TmvC5J5HLWMv/t1x//7Tcbj2iRAkA=; b=k6v2qM8Pi3qzSqF03p81brM27q jm1MaiWRkg8aA0RDyis8nkhir8CBQdA5DlugD3Bl4KRmCAY2Hcr89QtRG/AbrueCDlyCPjeC4WBwt U9SCn/KBlYQ7OtrkflhLCi3wQZ8V7HXK6AK+7jMiAMCV/YIVyHC7w/t56270irzPJrAdJ1uWy+Cox z0ksndNlm3ZGKmQI2jJ6yDsoSljfimzKrLiF5wvlJIYxtYZaoTbxOMZ7hNgv9B62l9w9RoX1h8Scu wDJCsdx4WdRBOFKXXgFmvpPtVSqEg2GSHFewJ8WLO1uiBoRFRfZAIi6ZkCcqvwY/ynjSnh7cvw8Rf 012b3H2g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjff-006cx6-7c; Tue, 08 Mar 2022 23:55:15 +0000 Received: from mail-yw1-x114a.google.com ([2607:f8b0:4864:20::114a]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nRjZH-006aQA-SL for linux-arm-kernel@lists.infradead.org; Tue, 08 Mar 2022 23:48:54 +0000 Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-2d6994a6942so3522027b3.17 for ; Tue, 08 Mar 2022 15:48:38 -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=/iCNuexYGotGFt8POzGsBCce+mSDDcAsjMZkTqPyc38=; b=YRJglsMVDEyVZaVp011I0ixjYYUWlm3Jg9BIYGMWPz1C0d9GvEiUe2EALmUkx3ZXuf +c09J0A38DJyIsnaQDFUn1j9asWovFlKB1Y5AE88hLd6W245q9ph31J5MpqLBbSCFswZ hvuF08on3fwythCoePPVCg8FQdJFK6ElT+iXwCKrIRKtg5D/j7rHjM2/Mj40F4lLvpjy cqXqXNW3DC0xtUPZs9UEEAW1uWkXBIGlAu9RlbarIEvqBPVWvizv3BWm4nmUfKxokpZC Tg8N9avZVLEbJAC5Gnt0pewjSBU/hb/ZYhTaYz7kUXXPDEG+eECBbgetgPcy/QaSF0U+ R0/A== 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=/iCNuexYGotGFt8POzGsBCce+mSDDcAsjMZkTqPyc38=; b=nbTa4Rqyj8cgxVk7u5MSlRF5/91SEcwyOI3AiFXlZq74fj6jbwocukS2707Ra3MHXv 0kbn/nVMk0l4ot+MM+jXbXJeM39+l+ICTSCOTwgbxS0E6FnB6/ARkt5pbeE/2GkgxmA5 6V5Khg0NeAeYEJC/kD2FpCn9LAu5rdu/32nzG+P72q+G5ETavQc5iDoHrbbiJp7yjqoE W3vTJA3j3kTzi8CKBMyFAUYcbDuV4siiZQq0kk0iNtGAn0iklA5NoqUU//+zBT/PfVkW zmiOtXTGT9aB0LmKXnzsAUuIf7y7ANvJayO1IriuYgTknH+IOSMWNSK5oldRPPeY+tbY 2uVQ== X-Gm-Message-State: AOAM533LD7cHddMRgkWQV4uat7QC/BBQ22a22aA+BY7oHM+naB84n3pj iLrkxh+pB+bAScOtHPw1XFBsqXlmbbw= X-Google-Smtp-Source: ABdhPJw1Yd1Ej264ruZWhlybkE9ZtgXn1ttNUy7v7eonV3w7gUp67PvrNKscp4FV95hqBmLC0NMzeMF9S6c= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:57a6:54a6:aad1:c0a8]) (user=yuzhao job=sendgmr) by 2002:a81:128f:0:b0:2dc:3c54:c5d8 with SMTP id 137-20020a81128f000000b002dc3c54c5d8mr14744211yws.395.1646783318114; Tue, 08 Mar 2022 15:48:38 -0800 (PST) Date: Tue, 8 Mar 2022 16:47:20 -0700 In-Reply-To: <20220308234723.3834941-1-yuzhao@google.com> Message-Id: <20220308234723.3834941-11-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 10/14] mm: multi-gen LRU: kill switch 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_154839_989403_A216ADBB X-CRM114-Status: GOOD ( 27.72 ) 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 QWRkIC9zeXMva2VybmVsL21tL2xydV9nZW4vZW5hYmxlZCBhcyBhIGtpbGwgc3dpdGNoLiBDb21w b25lbnRzIHRoYXQKY2FuIGJlIGRpc2FibGVkIGluY2x1ZGU6CiAgMHgwMDAxOiB0aGUgbXVsdGkt Z2VuIExSVSBjb3JlCiAgMHgwMDAyOiB3YWxraW5nIHBhZ2UgdGFibGUsIHdoZW4gYXJjaF9oYXNf aHdfcHRlX3lvdW5nKCkgcmV0dXJucwogICAgICAgICAgdHJ1ZQogIDB4MDAwNDogY2xlYXJpbmcg dGhlIGFjY2Vzc2VkIGJpdCBpbiBub24tbGVhZiBQTUQgZW50cmllcywgd2hlbgogICAgICAgICAg Q09ORklHX0FSQ0hfSEFTX05PTkxFQUZfUE1EX1lPVU5HPXkKICBbeVluTl06IGFwcGx5IHRvIGFs bCB0aGUgY29tcG9uZW50cyBhYm92ZQpFLmcuLAogIGVjaG8geSA+L3N5cy9rZXJuZWwvbW0vbHJ1 X2dlbi9lbmFibGVkCiAgY2F0IC9zeXMva2VybmVsL21tL2xydV9nZW4vZW5hYmxlZAogIDB4MDAw NwogIGVjaG8gNSA+L3N5cy9rZXJuZWwvbW0vbHJ1X2dlbi9lbmFibGVkCiAgY2F0IC9zeXMva2Vy bmVsL21tL2xydV9nZW4vZW5hYmxlZAogIDB4MDAwNQoKTkI6IHRoZSBwYWdlIHRhYmxlIHdhbGtz IGhhcHBlbiBvbiB0aGUgc2NhbGUgb2Ygc2Vjb25kcyB1bmRlciBoZWF2eQptZW1vcnkgcHJlc3N1 cmUsIGluIHdoaWNoIGNhc2UgdGhlIG1tYXBfbG9jayBjb250ZW50aW9uIGlzIGEgbGVzc2VyCmNv bmNlcm4sIGNvbXBhcmVkIHdpdGggdGhlIExSVSBsb2NrIGNvbnRlbnRpb24gYW5kIHRoZSBJL08g Y29uZ2VzdGlvbi4KU28gZmFyIHRoZSBvbmx5IHdlbGwta25vd24gY2FzZSBvZiB0aGUgbW1hcF9s b2NrIGNvbnRlbnRpb24gaGFwcGVucyBvbgpBbmRyb2lkLCBkdWUgdG8gU2N1ZG8gWzFdIHdoaWNo IGFsbG9jYXRlcyBzZXZlcmFsIHRob3VzYW5kIFZNQXMgZm9yCm1lcmVseSBhIGZldyBodW5kcmVk IE1Ccy4gVGhlIFNQRiBhbmQgdGhlIE1hcGxlIFRyZWUgYWxzbyBoYXZlCnByb3ZpZGVkIHRoZWly IG93biBhc3Nlc3NtZW50cyBbMl1bM10uIEhvd2V2ZXIsIGlmIHdhbGtpbmcgcGFnZSB0YWJsZXMK ZG9lcyB3b3JzZW4gdGhlIG1tYXBfbG9jayBjb250ZW50aW9uLCB0aGUga2lsbCBzd2l0Y2ggY2Fu IGJlIHVzZWQgdG8KZGlzYWJsZSBpdC4gSW4gdGhpcyBjYXNlIHRoZSBtdWx0aS1nZW4gTFJVIHdp bGwgc3VmZmVyIGEgbWlub3IKcGVyZm9ybWFuY2UgZGVncmFkYXRpb24sIGFzIHNob3duIHByZXZp b3VzbHkuCgpDbGVhcmluZyB0aGUgYWNjZXNzZWQgYml0IGluIG5vbi1sZWFmIFBNRCBlbnRyaWVz IGNhbiBhbHNvIGJlCmRpc2FibGVkLCBzaW5jZSB0aGlzIGJlaGF2aW9yIHdhcyBub3QgdGVzdGVk IG9uIHg4NiB2YXJpZXRpZXMgb3RoZXIKdGhhbiBJbnRlbCBhbmQgQU1ELgoKWzFdIGh0dHBzOi8v c291cmNlLmFuZHJvaWQuY29tL2RldmljZXMvdGVjaC9kZWJ1Zy9zY3VkbwpbMl0gaHR0cHM6Ly9s b3JlLmtlcm5lbC5vcmcvbGttbC8yMDIyMDEyODEzMTAwNi42NzcxMi0xLW1pY2hlbEBsZXNwaW5h c3NlLm9yZy8KWzNdIGh0dHBzOi8vbG9yZS5rZXJuZWwub3JnL2xrbWwvMjAyMjAyMDIwMjQxMzcu MjUxNjQzOC0xLUxpYW0uSG93bGV0dEBvcmFjbGUuY29tLwoKU2lnbmVkLW9mZi1ieTogWXUgWmhh byA8eXV6aGFvQGdvb2dsZS5jb20+CkFja2VkLWJ5OiBCcmlhbiBHZWZmb24gPGJnZWZmb25AZ29v Z2xlLmNvbT4KQWNrZWQtYnk6IEphbiBBbGV4YW5kZXIgU3RlZmZlbnMgKGhlZnRpZykgPGhlZnRp Z0BhcmNobGludXgub3JnPgpBY2tlZC1ieTogT2xla3NhbmRyIE5hdGFsZW5rbyA8b2xla3NhbmRy QG5hdGFsZW5rby5uYW1lPgpBY2tlZC1ieTogU3RldmVuIEJhcnJldHQgPHN0ZXZlbkBsaXF1b3Jp eC5uZXQ+CkFja2VkLWJ5OiBTdWxlaW1hbiBTb3VobGFsIDxzdWxlaW1hbkBnb29nbGUuY29tPgpU ZXN0ZWQtYnk6IERhbmllbCBCeXJuZSA8ZGpieXJuZUBtdHUuZWR1PgpUZXN0ZWQtYnk6IERvbmFs ZCBDYXJyIDxkQGNoYW9zLXJlaW5zLmNvbT4KVGVzdGVkLWJ5OiBIb2xnZXIgSG9mZnN0w6R0dGUg PGhvbGdlckBhcHBsaWVkLWFzeW5jaHJvbnkuY29tPgpUZXN0ZWQtYnk6IEtvbnN0YW50aW4gS2hh cmxhbW92IDxIaS1BbmdlbEB5YW5kZXgucnU+ClRlc3RlZC1ieTogU2h1YW5nIFpoYWkgPHN6aGFp MkBjcy5yb2NoZXN0ZXIuZWR1PgpUZXN0ZWQtYnk6IFNvZmlhIFRyaW5oIDxzb2ZpYS50cmluaEBl ZGkud29ya3M+ClRlc3RlZC1ieTogVmFpYmhhdiBKYWluIDx2YWliaGF2QGxpbnV4LmlibS5jb20+ Ci0tLQogaW5jbHVkZS9saW51eC9jZ3JvdXAuaCAgICAgICAgICB8ICAxNSArLQogaW5jbHVkZS9s aW51eC9tbV9pbmxpbmUuaCAgICAgICB8ICAxMiArLQogaW5jbHVkZS9saW51eC9tbXpvbmUuaCAg ICAgICAgICB8ICAgOSArKwoga2VybmVsL2Nncm91cC9jZ3JvdXAtaW50ZXJuYWwuaCB8ICAgMSAt CiBtbS9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICsKIG1tL3Ztc2Nhbi5jICAg ICAgICAgICAgICAgICAgICAgfCAyMzcgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0K IDYgZmlsZXMgY2hhbmdlZCwgMjcxIGluc2VydGlvbnMoKyksIDkgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvaW5jbHVkZS9saW51eC9jZ3JvdXAuaCBiL2luY2x1ZGUvbGludXgvY2dyb3VwLmgK aW5kZXggNzVjMTUxNDEzZmRhLi5iMTQ1MDI1ZjNlYWMgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGlu dXgvY2dyb3VwLmgKKysrIGIvaW5jbHVkZS9saW51eC9jZ3JvdXAuaApAQCAtNDMyLDYgKzQzMiwx OCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgY2dyb3VwX3B1dChzdHJ1Y3QgY2dyb3VwICpjZ3JwKQog CWNzc19wdXQoJmNncnAtPnNlbGYpOwogfQogCitleHRlcm4gc3RydWN0IG11dGV4IGNncm91cF9t dXRleDsKKworc3RhdGljIGlubGluZSB2b2lkIGNncm91cF9sb2NrKHZvaWQpCit7CisJbXV0ZXhf bG9jaygmY2dyb3VwX211dGV4KTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGNncm91cF91bmxv Y2sodm9pZCkKK3sKKwltdXRleF91bmxvY2soJmNncm91cF9tdXRleCk7Cit9CisKIC8qKgogICog dGFza19jc3Nfc2V0X2NoZWNrIC0gb2J0YWluIGEgdGFzaydzIGNzc19zZXQgd2l0aCBleHRyYSBh Y2Nlc3MgY29uZGl0aW9ucwogICogQHRhc2s6IHRoZSB0YXNrIHRvIG9idGFpbiBjc3Nfc2V0IGZv cgpAQCAtNDQ2LDcgKzQ1OCw2IEBAIHN0YXRpYyBpbmxpbmUgdm9pZCBjZ3JvdXBfcHV0KHN0cnVj dCBjZ3JvdXAgKmNncnApCiAgKiBhcyBsb2NrcyB1c2VkIGR1cmluZyB0aGUgY2dyb3VwX3N1YnN5 czo6YXR0YWNoKCkgbWV0aG9kcy4KICAqLwogI2lmZGVmIENPTkZJR19QUk9WRV9SQ1UKLWV4dGVy biBzdHJ1Y3QgbXV0ZXggY2dyb3VwX211dGV4OwogZXh0ZXJuIHNwaW5sb2NrX3QgY3NzX3NldF9s b2NrOwogI2RlZmluZSB0YXNrX2Nzc19zZXRfY2hlY2sodGFzaywgX19jKQkJCQkJXAogCXJjdV9k ZXJlZmVyZW5jZV9jaGVjaygodGFzayktPmNncm91cHMsCQkJCVwKQEAgLTcwNyw2ICs3MTgsOCBA QCBzdHJ1Y3QgY2dyb3VwOwogc3RhdGljIGlubGluZSB1NjQgY2dyb3VwX2lkKGNvbnN0IHN0cnVj dCBjZ3JvdXAgKmNncnApIHsgcmV0dXJuIDE7IH0KIHN0YXRpYyBpbmxpbmUgdm9pZCBjc3NfZ2V0 KHN0cnVjdCBjZ3JvdXBfc3Vic3lzX3N0YXRlICpjc3MpIHt9CiBzdGF0aWMgaW5saW5lIHZvaWQg Y3NzX3B1dChzdHJ1Y3QgY2dyb3VwX3N1YnN5c19zdGF0ZSAqY3NzKSB7fQorc3RhdGljIGlubGlu ZSB2b2lkIGNncm91cF9sb2NrKHZvaWQpIHt9CitzdGF0aWMgaW5saW5lIHZvaWQgY2dyb3VwX3Vu bG9jayh2b2lkKSB7fQogc3RhdGljIGlubGluZSBpbnQgY2dyb3VwX2F0dGFjaF90YXNrX2FsbChz dHJ1Y3QgdGFza19zdHJ1Y3QgKmZyb20sCiAJCQkJCSBzdHJ1Y3QgdGFza19zdHJ1Y3QgKnQpIHsg cmV0dXJuIDA7IH0KIHN0YXRpYyBpbmxpbmUgaW50IGNncm91cHN0YXRzX2J1aWxkKHN0cnVjdCBj Z3JvdXBzdGF0cyAqc3RhdHMsCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L21tX2lubGluZS5o IGIvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaAppbmRleCAxNWEwNGE5YjU1NjAuLjFjOGQ2MTdl NzNhOSAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9tbV9pbmxpbmUuaAorKysgYi9pbmNsdWRl L2xpbnV4L21tX2lubGluZS5oCkBAIC0xMDYsNyArMTA2LDE1IEBAIHN0YXRpYyBfX2Fsd2F5c19p bmxpbmUgZW51bSBscnVfbGlzdCBmb2xpb19scnVfbGlzdChzdHJ1Y3QgZm9saW8gKmZvbGlvKQog CiBzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9lbmFibGVkKHZvaWQpCiB7Ci0JcmV0dXJuIHRy dWU7CisjaWZkZWYgQ09ORklHX0xSVV9HRU5fRU5BQkxFRAorCURFQ0xBUkVfU1RBVElDX0tFWV9U UlVFKGxydV9nZW5fY2Fwc1tOUl9MUlVfR0VOX0NBUFNdKTsKKworCXJldHVybiBzdGF0aWNfYnJh bmNoX2xpa2VseSgmbHJ1X2dlbl9jYXBzW0xSVV9HRU5fQ09SRV0pOworI2Vsc2UKKwlERUNMQVJF X1NUQVRJQ19LRVlfRkFMU0UobHJ1X2dlbl9jYXBzW05SX0xSVV9HRU5fQ0FQU10pOworCisJcmV0 dXJuIHN0YXRpY19icmFuY2hfdW5saWtlbHkoJmxydV9nZW5fY2Fwc1tMUlVfR0VOX0NPUkVdKTsK KyNlbmRpZgogfQogCiBzdGF0aWMgaW5saW5lIGJvb2wgbHJ1X2dlbl9pbl9mYXVsdCh2b2lkKQpA QCAtMTk2LDcgKzIwNCw3IEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBscnVfZ2VuX2FkZF9mb2xpbyhz dHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBmb2xpbyAqZm9saW8sCiAJaW50IHpvbmUgPSBm b2xpb196b25lbnVtKGZvbGlvKTsKIAlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZs cnV2ZWMtPmxydWdlbjsKIAotCWlmIChmb2xpb190ZXN0X3VuZXZpY3RhYmxlKGZvbGlvKSkKKwlp ZiAoZm9saW9fdGVzdF91bmV2aWN0YWJsZShmb2xpbykgfHwgIWxydWdlbi0+ZW5hYmxlZCkKIAkJ cmV0dXJuIGZhbHNlOwogCS8qCiAJICogVGhlcmUgYXJlIHRocmVlIGNvbW1vbiBjYXNlcyBmb3Ig dGhpcyBwYWdlOgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9tbXpvbmUuaCBiL2luY2x1ZGUv bGludXgvbW16b25lLmgKaW5kZXggODcwNmY3NWExMmRkLi41MWU5MGUxZWVjM2YgMTAwNjQ0Ci0t LSBhL2luY2x1ZGUvbGludXgvbW16b25lLmgKKysrIGIvaW5jbHVkZS9saW51eC9tbXpvbmUuaApA QCAtMzE2LDYgKzMxNiwxMyBAQCBlbnVtIHsKIAlMUlVfR0VOX0ZJTEUsCiB9OwogCitlbnVtIHsK KwlMUlVfR0VOX0NPUkUsCisJTFJVX0dFTl9NTV9XQUxLLAorCUxSVV9HRU5fTk9OTEVBRl9ZT1VO RywKKwlOUl9MUlVfR0VOX0NBUFMKK307CisKICNkZWZpbmUgTUlOX0xSVV9CQVRDSAkJQklUU19Q RVJfTE9ORwogI2RlZmluZSBNQVhfTFJVX0JBVENICQkoTUlOX0xSVV9CQVRDSCAqIDEyOCkKIApA QCAtMzk3LDYgKzQwNCw4IEBAIHN0cnVjdCBscnVfZ2VuX3N0cnVjdCB7CiAJLyogY2FuIGJlIG1v ZGlmaWVkIHdpdGhvdXQgaG9sZGluZyB0aGUgTFJVIGxvY2sgKi8KIAlhdG9taWNfbG9uZ190IGV2 aWN0ZWRbTlJfSElTVF9HRU5TXVtBTk9OX0FORF9GSUxFXVtNQVhfTlJfVElFUlNdOwogCWF0b21p Y19sb25nX3QgcmVmYXVsdGVkW05SX0hJU1RfR0VOU11bQU5PTl9BTkRfRklMRV1bTUFYX05SX1RJ RVJTXTsKKwkvKiB3aGV0aGVyIHRoZSBtdWx0aS1nZW4gTFJVIGlzIGVuYWJsZWQgKi8KKwlib29s IGVuYWJsZWQ7CiB9OwogCiBlbnVtIHsKZGlmZiAtLWdpdCBhL2tlcm5lbC9jZ3JvdXAvY2dyb3Vw LWludGVybmFsLmggYi9rZXJuZWwvY2dyb3VwL2Nncm91cC1pbnRlcm5hbC5oCmluZGV4IDZlMzZl ODU0YjUxMi4uOTI5ZWQzYmYxYTdjIDEwMDY0NAotLS0gYS9rZXJuZWwvY2dyb3VwL2Nncm91cC1p bnRlcm5hbC5oCisrKyBiL2tlcm5lbC9jZ3JvdXAvY2dyb3VwLWludGVybmFsLmgKQEAgLTE2NSw3 ICsxNjUsNiBAQCBzdHJ1Y3QgY2dyb3VwX21nY3R4IHsKICNkZWZpbmUgREVGSU5FX0NHUk9VUF9N R0NUWChuYW1lKQkJCQkJCVwKIAlzdHJ1Y3QgY2dyb3VwX21nY3R4IG5hbWUgPSBDR1JPVVBfTUdD VFhfSU5JVChuYW1lKQogCi1leHRlcm4gc3RydWN0IG11dGV4IGNncm91cF9tdXRleDsKIGV4dGVy biBzcGlubG9ja190IGNzc19zZXRfbG9jazsKIGV4dGVybiBzdHJ1Y3QgY2dyb3VwX3N1YnN5cyAq Y2dyb3VwX3N1YnN5c1tdOwogZXh0ZXJuIHN0cnVjdCBsaXN0X2hlYWQgY2dyb3VwX3Jvb3RzOwpk aWZmIC0tZ2l0IGEvbW0vS2NvbmZpZyBiL21tL0tjb25maWcKaW5kZXggZDRhYTNkODgxMjY5Li5l OWQ1ZjFkMDlhYzQgMTAwNjQ0Ci0tLSBhL21tL0tjb25maWcKKysrIGIvbW0vS2NvbmZpZwpAQCAt OTAxLDYgKzkwMSwxMiBAQCBjb25maWcgTFJVX0dFTgogCWhlbHAKIAkgIEEgaGlnaCBwZXJmb3Jt YW5jZSBMUlUgaW1wbGVtZW50YXRpb24gZm9yIG1lbW9yeSBvdmVyY29tbWl0LgogCitjb25maWcg TFJVX0dFTl9FTkFCTEVECisJYm9vbCAiRW5hYmxlIGJ5IGRlZmF1bHQiCisJZGVwZW5kcyBvbiBM UlVfR0VOCisJaGVscAorCSAgVGhpcyBvcHRpb24gZW5hYmxlcyB0aGUgbXVsdGktZ2VuIExSVSBi eSBkZWZhdWx0LgorCiBjb25maWcgTlJfTFJVX0dFTlMKIAlpbnQgIk1heCBudW1iZXIgb2YgZ2Vu ZXJhdGlvbnMiCiAJZGVwZW5kcyBvbiBMUlVfR0VOCmRpZmYgLS1naXQgYS9tbS92bXNjYW4uYyBi L21tL3Ztc2Nhbi5jCmluZGV4IDczNzVjOWRhZTA4Zi4uNTVjYzdkNmIwMThiIDEwMDY0NAotLS0g YS9tbS92bXNjYW4uYworKysgYi9tbS92bXNjYW4uYwpAQCAtMzA2Myw2ICszMDYzLDEyIEBAIHN0 YXRpYyBib29sIGNhbl9hZ2VfYW5vbl9wYWdlcyhzdHJ1Y3QgcGdsaXN0X2RhdGEgKnBnZGF0LAog CiAjaWZkZWYgQ09ORklHX0xSVV9HRU4KIAorI2lmZGVmIENPTkZJR19MUlVfR0VOX0VOQUJMRUQK K0RFRklORV9TVEFUSUNfS0VZX0FSUkFZX1RSVUUobHJ1X2dlbl9jYXBzLCBOUl9MUlVfR0VOX0NB UFMpOworI2Vsc2UKK0RFRklORV9TVEFUSUNfS0VZX0FSUkFZX0ZBTFNFKGxydV9nZW5fY2Fwcywg TlJfTFJVX0dFTl9DQVBTKTsKKyNlbmRpZgorCiAvKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAgKiAg ICAgICAgICAgICAgICAgICAgICAgICAgc2hvcnRoYW5kIGhlbHBlcnMKICAqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKiovCkBAIC0zMDk5LDYgKzMxMDUsMTUgQEAgc3RhdGljIGludCBmb2xpb19scnVfdGll cihzdHJ1Y3QgZm9saW8gKmZvbGlvKQogCXJldHVybiBscnVfdGllcl9mcm9tX3JlZnMocmVmcyk7 CiB9CiAKK3N0YXRpYyBib29sIGdldF9jYXAoaW50IGNhcCkKK3sKKyNpZmRlZiBDT05GSUdfTFJV X0dFTl9FTkFCTEVECisJcmV0dXJuIHN0YXRpY19icmFuY2hfbGlrZWx5KCZscnVfZ2VuX2NhcHNb Y2FwXSk7CisjZWxzZQorCXJldHVybiBzdGF0aWNfYnJhbmNoX3VubGlrZWx5KCZscnVfZ2VuX2Nh cHNbY2FwXSk7CisjZW5kaWYKK30KKwogc3RhdGljIHN0cnVjdCBscnV2ZWMgKmdldF9scnV2ZWMo c3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnLCBpbnQgbmlkKQogewogCXN0cnVjdCBwZ2xpc3RfZGF0 YSAqcGdkYXQgPSBOT0RFX0RBVEEobmlkKTsKQEAgLTM4OTIsNyArMzkwNyw4IEBAIHN0YXRpYyB2 b2lkIHdhbGtfcG1kX3JhbmdlX2xvY2tlZChwdWRfdCAqcHVkLCB1bnNpZ25lZCBsb25nIG5leHQs IHN0cnVjdCB2bV9hcmVhCiAJCQlnb3RvIG5leHQ7CiAKIAkJaWYgKCFwbWRfdHJhbnNfaHVnZShw bWRbaV0pKSB7Ci0JCQlpZiAoSVNfRU5BQkxFRChDT05GSUdfQVJDSF9IQVNfTk9OTEVBRl9QTURf WU9VTkcpKQorCQkJaWYgKElTX0VOQUJMRUQoQ09ORklHX0FSQ0hfSEFTX05PTkxFQUZfUE1EX1lP VU5HKSAmJgorCQkJICAgIGdldF9jYXAoTFJVX0dFTl9OT05MRUFGX1lPVU5HKSkKIAkJCQlwbWRw X3Rlc3RfYW5kX2NsZWFyX3lvdW5nKHZtYSwgYWRkciwgcG1kICsgaSk7CiAJCQlnb3RvIG5leHQ7 CiAJCX0KQEAgLTM5OTksMTAgKzQwMTUsMTIgQEAgc3RhdGljIHZvaWQgd2Fsa19wbWRfcmFuZ2Uo cHVkX3QgKnB1ZCwgdW5zaWduZWQgbG9uZyBzdGFydCwgdW5zaWduZWQgbG9uZyBlbmQsCiAJCXBy aXYtPm1tX3N0YXRzW01NX1BNRF9UT1RBTF0rKzsKIAogI2lmZGVmIENPTkZJR19BUkNIX0hBU19O T05MRUFGX1BNRF9ZT1VORwotCQlpZiAoIXBtZF95b3VuZyh2YWwpKQotCQkJY29udGludWU7CisJ CWlmIChnZXRfY2FwKExSVV9HRU5fTk9OTEVBRl9ZT1VORykpIHsKKwkJCWlmICghcG1kX3lvdW5n KHZhbCkpCisJCQkJY29udGludWU7CiAKLQkJd2Fsa19wbWRfcmFuZ2VfbG9ja2VkKHB1ZCwgYWRk ciwgdm1hLCB3YWxrLCAmcG9zKTsKKwkJCXdhbGtfcG1kX3JhbmdlX2xvY2tlZChwdWQsIGFkZHIs IHZtYSwgd2FsaywgJnBvcyk7CisJCX0KICNlbmRpZgogCQlpZiAoIXByaXYtPmZ1bGxfc2NhbiAm JiAhdGVzdF9ibG9vbV9maWx0ZXIocHJpdi0+bHJ1dmVjLCBwcml2LT5tYXhfc2VxLCBwbWQgKyBp KSkKIAkJCWNvbnRpbnVlOwpAQCAtNDIzMyw3ICs0MjUxLDcgQEAgc3RhdGljIGJvb2wgdHJ5X3Rv X2luY19tYXhfc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhfc2Vx LAogCSAqIGhhbmRmdWwgb2YgUFRFcy4gU3ByZWFkaW5nIHRoZSB3b3JrIG91dCBvdmVyIGEgcGVy aW9kIG9mIHRpbWUgdXN1YWxseQogCSAqIGlzIGxlc3MgZWZmaWNpZW50LCBidXQgaXQgYXZvaWRz IGJ1cnN0eSBwYWdlIGZhdWx0cy4KIAkgKi8KLQlpZiAoIWZ1bGxfc2NhbiAmJiAhYXJjaF9oYXNf aHdfcHRlX3lvdW5nKCkpIHsKKwlpZiAoIWZ1bGxfc2NhbiAmJiAoIWFyY2hfaGFzX2h3X3B0ZV95 b3VuZygpIHx8ICFnZXRfY2FwKExSVV9HRU5fTU1fV0FMSykpKSB7CiAJCXN1Y2Nlc3MgPSBpdGVy YXRlX21tX2xpc3Rfbm93YWxrKGxydXZlYywgbWF4X3NlcSk7CiAJCWdvdG8gZG9uZTsKIAl9CkBA IC00OTQ2LDYgKzQ5NjQsMjExIEBAIHN0YXRpYyB2b2lkIGxydV9nZW5fc2hyaW5rX2xydXZlYyhz dHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjCiAJYmxrX2Zpbmlz aF9wbHVnKCZwbHVnKTsKIH0KIAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogICAgICAgICAg ICAgICAgICAgICAgICAgIHN0YXRlIGNoYW5nZQorICoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKwor c3RhdGljIGJvb2wgX19tYXliZV91bnVzZWQgc3RhdGVfaXNfdmFsaWQoc3RydWN0IGxydXZlYyAq bHJ1dmVjKQoreworCXN0cnVjdCBscnVfZ2VuX3N0cnVjdCAqbHJ1Z2VuID0gJmxydXZlYy0+bHJ1 Z2VuOworCisJaWYgKGxydWdlbi0+ZW5hYmxlZCkgeworCQllbnVtIGxydV9saXN0IGxydTsKKwor CQlmb3JfZWFjaF9ldmljdGFibGVfbHJ1KGxydSkgeworCQkJaWYgKCFsaXN0X2VtcHR5KCZscnV2 ZWMtPmxpc3RzW2xydV0pKQorCQkJCXJldHVybiBmYWxzZTsKKwkJfQorCX0gZWxzZSB7CisJCWlu dCBnZW4sIHR5cGUsIHpvbmU7CisKKwkJZm9yX2VhY2hfZ2VuX3R5cGVfem9uZShnZW4sIHR5cGUs IHpvbmUpIHsKKwkJCWlmICghbGlzdF9lbXB0eSgmbHJ1Z2VuLT5saXN0c1tnZW5dW3R5cGVdW3pv bmVdKSkKKwkJCQlyZXR1cm4gZmFsc2U7CisKKwkJCS8qIHVubGlrZWx5IGJ1dCBub3QgYSBidWcg d2hlbiByZXNldF9iYXRjaF9zaXplKCkgaXMgcGVuZGluZyAqLworCQkJVk1fV0FSTl9PTihscnVn ZW4tPm5yX3BhZ2VzW2dlbl1bdHlwZV1bem9uZV0pOworCQl9CisJfQorCisJcmV0dXJuIHRydWU7 Cit9CisKK3N0YXRpYyBib29sIGZpbGxfZXZpY3RhYmxlKHN0cnVjdCBscnV2ZWMgKmxydXZlYykK K3sKKwllbnVtIGxydV9saXN0IGxydTsKKwlpbnQgcmVtYWluaW5nID0gTUFYX0xSVV9CQVRDSDsK KworCWZvcl9lYWNoX2V2aWN0YWJsZV9scnUobHJ1KSB7CisJCWludCB0eXBlID0gaXNfZmlsZV9s cnUobHJ1KTsKKwkJYm9vbCBhY3RpdmUgPSBpc19hY3RpdmVfbHJ1KGxydSk7CisJCXN0cnVjdCBs aXN0X2hlYWQgKmhlYWQgPSAmbHJ1dmVjLT5saXN0c1tscnVdOworCisJCXdoaWxlICghbGlzdF9l bXB0eShoZWFkKSkgeworCQkJYm9vbCBzdWNjZXNzOworCQkJc3RydWN0IGZvbGlvICpmb2xpbyA9 IGxydV90b19mb2xpbyhoZWFkKTsKKworCQkJVk1fQlVHX09OX0ZPTElPKGZvbGlvX3Rlc3RfdW5l dmljdGFibGUoZm9saW8pLCBmb2xpbyk7CisJCQlWTV9CVUdfT05fRk9MSU8oZm9saW9fdGVzdF9h Y3RpdmUoZm9saW8pICE9IGFjdGl2ZSwgZm9saW8pOworCQkJVk1fQlVHX09OX0ZPTElPKGZvbGlv X2lzX2ZpbGVfbHJ1KGZvbGlvKSAhPSB0eXBlLCBmb2xpbyk7CisJCQlWTV9CVUdfT05fRk9MSU8o Zm9saW9fbHJ1X2dlbihmb2xpbykgPCBNQVhfTlJfR0VOUywgZm9saW8pOworCisJCQlscnV2ZWNf ZGVsX2ZvbGlvKGxydXZlYywgZm9saW8pOworCQkJc3VjY2VzcyA9IGxydV9nZW5fYWRkX2ZvbGlv KGxydXZlYywgZm9saW8sIGZhbHNlKTsKKwkJCVZNX0JVR19PTighc3VjY2Vzcyk7CisKKwkJCWlm ICghLS1yZW1haW5pbmcpCisJCQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorCisJcmV0dXJuIHRy dWU7Cit9CisKK3N0YXRpYyBib29sIGRyYWluX2V2aWN0YWJsZShzdHJ1Y3QgbHJ1dmVjICpscnV2 ZWMpCit7CisJaW50IGdlbiwgdHlwZSwgem9uZTsKKwlpbnQgcmVtYWluaW5nID0gTUFYX0xSVV9C QVRDSDsKKworCWZvcl9lYWNoX2dlbl90eXBlX3pvbmUoZ2VuLCB0eXBlLCB6b25lKSB7CisJCXN0 cnVjdCBsaXN0X2hlYWQgKmhlYWQgPSAmbHJ1dmVjLT5scnVnZW4ubGlzdHNbZ2VuXVt0eXBlXVt6 b25lXTsKKworCQl3aGlsZSAoIWxpc3RfZW1wdHkoaGVhZCkpIHsKKwkJCWJvb2wgc3VjY2VzczsK KwkJCXN0cnVjdCBmb2xpbyAqZm9saW8gPSBscnVfdG9fZm9saW8oaGVhZCk7CisKKwkJCVZNX0JV R19PTl9GT0xJTyhmb2xpb190ZXN0X3VuZXZpY3RhYmxlKGZvbGlvKSwgZm9saW8pOworCQkJVk1f QlVHX09OX0ZPTElPKGZvbGlvX3Rlc3RfYWN0aXZlKGZvbGlvKSwgZm9saW8pOworCQkJVk1fQlVH X09OX0ZPTElPKGZvbGlvX2lzX2ZpbGVfbHJ1KGZvbGlvKSAhPSB0eXBlLCBmb2xpbyk7CisJCQlW TV9CVUdfT05fRk9MSU8oZm9saW9fem9uZW51bShmb2xpbykgIT0gem9uZSwgZm9saW8pOworCisJ CQlzdWNjZXNzID0gbHJ1X2dlbl9kZWxfZm9saW8obHJ1dmVjLCBmb2xpbywgZmFsc2UpOworCQkJ Vk1fQlVHX09OKCFzdWNjZXNzKTsKKwkJCWxydXZlY19hZGRfZm9saW8obHJ1dmVjLCBmb2xpbyk7 CisKKwkJCWlmICghLS1yZW1haW5pbmcpCisJCQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorCisJ cmV0dXJuIHRydWU7Cit9CisKK3N0YXRpYyB2b2lkIGxydV9nZW5fY2hhbmdlX3N0YXRlKGJvb2wg ZW5hYmxlKQoreworCXN0YXRpYyBERUZJTkVfTVVURVgoc3RhdGVfbXV0ZXgpOworCisJc3RydWN0 IG1lbV9jZ3JvdXAgKm1lbWNnOworCisJY2dyb3VwX2xvY2soKTsKKwljcHVzX3JlYWRfbG9jaygp OworCWdldF9vbmxpbmVfbWVtcygpOworCW11dGV4X2xvY2soJnN0YXRlX211dGV4KTsKKworCWlm IChlbmFibGUgPT0gbHJ1X2dlbl9lbmFibGVkKCkpCisJCWdvdG8gdW5sb2NrOworCisJaWYgKGVu YWJsZSkKKwkJc3RhdGljX2JyYW5jaF9lbmFibGVfY3B1c2xvY2tlZCgmbHJ1X2dlbl9jYXBzW0xS VV9HRU5fQ09SRV0pOworCWVsc2UKKwkJc3RhdGljX2JyYW5jaF9kaXNhYmxlX2NwdXNsb2NrZWQo JmxydV9nZW5fY2Fwc1tMUlVfR0VOX0NPUkVdKTsKKworCW1lbWNnID0gbWVtX2Nncm91cF9pdGVy KE5VTEwsIE5VTEwsIE5VTEwpOworCWRvIHsKKwkJaW50IG5pZDsKKworCQlmb3JfZWFjaF9ub2Rl KG5pZCkgeworCQkJc3RydWN0IGxydXZlYyAqbHJ1dmVjID0gZ2V0X2xydXZlYyhtZW1jZywgbmlk KTsKKworCQkJaWYgKCFscnV2ZWMpCisJCQkJY29udGludWU7CisKKwkJCXNwaW5fbG9ja19pcnEo JmxydXZlYy0+bHJ1X2xvY2spOworCisJCQlWTV9CVUdfT04oIXNlcV9pc192YWxpZChscnV2ZWMp KTsKKwkJCVZNX0JVR19PTighc3RhdGVfaXNfdmFsaWQobHJ1dmVjKSk7CisKKwkJCWxydXZlYy0+ bHJ1Z2VuLmVuYWJsZWQgPSBlbmFibGU7CisKKwkJCXdoaWxlICghKGVuYWJsZSA/IGZpbGxfZXZp Y3RhYmxlKGxydXZlYykgOiBkcmFpbl9ldmljdGFibGUobHJ1dmVjKSkpIHsKKwkJCQlzcGluX3Vu bG9ja19pcnEoJmxydXZlYy0+bHJ1X2xvY2spOworCQkJCWNvbmRfcmVzY2hlZCgpOworCQkJCXNw aW5fbG9ja19pcnEoJmxydXZlYy0+bHJ1X2xvY2spOworCQkJfQorCisJCQlzcGluX3VubG9ja19p cnEoJmxydXZlYy0+bHJ1X2xvY2spOworCQl9CisKKwkJY29uZF9yZXNjaGVkKCk7CisJfSB3aGls ZSAoKG1lbWNnID0gbWVtX2Nncm91cF9pdGVyKE5VTEwsIG1lbWNnLCBOVUxMKSkpOwordW5sb2Nr OgorCW11dGV4X3VubG9jaygmc3RhdGVfbXV0ZXgpOworCXB1dF9vbmxpbmVfbWVtcygpOworCWNw dXNfcmVhZF91bmxvY2soKTsKKwljZ3JvdXBfdW5sb2NrKCk7Cit9CisKKy8qKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioKKyAqICAgICAgICAgICAgICAgICAgICAgICAgICBzeXNmcyBpbnRlcmZhY2UKKyAq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKiovCisKK3N0YXRpYyBzc2l6ZV90IHNob3dfZW5hYmxlKHN0cnVj dCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgKmF0dHIsIGNoYXIgKmJ1ZikK K3sKKwl1bnNpZ25lZCBpbnQgY2FwcyA9IDA7CisKKwlpZiAoZ2V0X2NhcChMUlVfR0VOX0NPUkUp KQorCQljYXBzIHw9IEJJVChMUlVfR0VOX0NPUkUpOworCisJaWYgKGFyY2hfaGFzX2h3X3B0ZV95 b3VuZygpICYmIGdldF9jYXAoTFJVX0dFTl9NTV9XQUxLKSkKKwkJY2FwcyB8PSBCSVQoTFJVX0dF Tl9NTV9XQUxLKTsKKworCWlmIChJU19FTkFCTEVEKENPTkZJR19BUkNIX0hBU19OT05MRUFGX1BN RF9ZT1VORykgJiYgZ2V0X2NhcChMUlVfR0VOX05PTkxFQUZfWU9VTkcpKQorCQljYXBzIHw9IEJJ VChMUlVfR0VOX05PTkxFQUZfWU9VTkcpOworCisJcmV0dXJuIHNucHJpbnRmKGJ1ZiwgUEFHRV9T SVpFLCAiMHglMDR4XG4iLCBjYXBzKTsKK30KKworc3RhdGljIHNzaXplX3Qgc3RvcmVfZW5hYmxl KHN0cnVjdCBrb2JqZWN0ICprb2JqLCBzdHJ1Y3Qga29ial9hdHRyaWJ1dGUgKmF0dHIsCisJCQkg ICAgY29uc3QgY2hhciAqYnVmLCBzaXplX3QgbGVuKQoreworCWludCBpOworCXVuc2lnbmVkIGlu dCBjYXBzOworCisJaWYgKHRvbG93ZXIoKmJ1ZikgPT0gJ24nKQorCQljYXBzID0gMDsKKwllbHNl IGlmICh0b2xvd2VyKCpidWYpID09ICd5JykKKwkJY2FwcyA9IC0xOworCWVsc2UgaWYgKGtzdHJ0 b3VpbnQoYnVmLCAwLCAmY2FwcykpCisJCXJldHVybiAtRUlOVkFMOworCisJZm9yIChpID0gMDsg aSA8IE5SX0xSVV9HRU5fQ0FQUzsgaSsrKSB7CisJCWJvb2wgZW5hYmxlID0gY2FwcyAmIEJJVChp KTsKKworCQlpZiAoaSA9PSBMUlVfR0VOX0NPUkUpCisJCQlscnVfZ2VuX2NoYW5nZV9zdGF0ZShl bmFibGUpOworCQllbHNlIGlmIChlbmFibGUpCisJCQlzdGF0aWNfYnJhbmNoX2VuYWJsZSgmbHJ1 X2dlbl9jYXBzW2ldKTsKKwkJZWxzZQorCQkJc3RhdGljX2JyYW5jaF9kaXNhYmxlKCZscnVfZ2Vu X2NhcHNbaV0pOworCX0KKworCXJldHVybiBsZW47Cit9CisKK3N0YXRpYyBzdHJ1Y3Qga29ial9h dHRyaWJ1dGUgbHJ1X2dlbl9lbmFibGVkX2F0dHIgPSBfX0FUVFIoCisJZW5hYmxlZCwgMDY0NCwg c2hvd19lbmFibGUsIHN0b3JlX2VuYWJsZQorKTsKKworc3RhdGljIHN0cnVjdCBhdHRyaWJ1dGUg KmxydV9nZW5fYXR0cnNbXSA9IHsKKwkmbHJ1X2dlbl9lbmFibGVkX2F0dHIuYXR0ciwKKwlOVUxM Cit9OworCitzdGF0aWMgc3RydWN0IGF0dHJpYnV0ZV9ncm91cCBscnVfZ2VuX2F0dHJfZ3JvdXAg PSB7CisJLm5hbWUgPSAibHJ1X2dlbiIsCisJLmF0dHJzID0gbHJ1X2dlbl9hdHRycywKK307CisK IC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICAgICAgICAgICAgICAgICBpbml0 aWFsaXphdGlvbgogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KQEAgLTQ5NTYsNiArNTE3OSw3IEBA IHZvaWQgbHJ1X2dlbl9pbml0X2xydXZlYyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMpCiAJc3RydWN0 IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAmbHJ1dmVjLT5scnVnZW47CiAKIAlscnVnZW4tPm1h eF9zZXEgPSBNSU5fTlJfR0VOUyArIDE7CisJbHJ1Z2VuLT5lbmFibGVkID0gbHJ1X2dlbl9lbmFi bGVkKCk7CiAKIAlmb3JfZWFjaF9nZW5fdHlwZV96b25lKGdlbiwgdHlwZSwgem9uZSkKIAkJSU5J VF9MSVNUX0hFQUQoJmxydWdlbi0+bGlzdHNbZ2VuXVt0eXBlXVt6b25lXSk7CkBAIC00OTk2LDYg KzUyMjAsOSBAQCBzdGF0aWMgaW50IF9faW5pdCBpbml0X2xydV9nZW4odm9pZCkKIAlCVUlMRF9C VUdfT04oQklUKExSVV9HRU5fV0lEVEgpIDw9IE1BWF9OUl9HRU5TKTsKIAlCVUlMRF9CVUdfT04o c2l6ZW9mKE1NX1NUQVRfQ09ERVMpICE9IE5SX01NX1NUQVRTICsgMSk7CiAKKwlpZiAoc3lzZnNf Y3JlYXRlX2dyb3VwKG1tX2tvYmosICZscnVfZ2VuX2F0dHJfZ3JvdXApKQorCQlwcl9lcnIoImxy dV9nZW46IGZhaWxlZCB0byBjcmVhdGUgc3lzZnMgZ3JvdXBcbiIpOworCiAJcmV0dXJuIDA7CiB9 OwogbGF0ZV9pbml0Y2FsbChpbml0X2xydV9nZW4pOwotLSAKMi4zNS4xLjYxNi5nMGJkY2JiNDQ2 NC1nb29nCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K bGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZy YWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGlu dXgtYXJtLWtlcm5lbAo=