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 E05BAC433F5 for ; Wed, 18 May 2022 01:48:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234027AbiERBsZ (ORCPT ); Tue, 17 May 2022 21:48:25 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58026 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S233949AbiERBrV (ORCPT ); Tue, 17 May 2022 21:47:21 -0400 Received: from mail-yw1-x114a.google.com (mail-yw1-x114a.google.com [IPv6:2607:f8b0:4864:20::114a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7649D54F89 for ; Tue, 17 May 2022 18:47:12 -0700 (PDT) Received: by mail-yw1-x114a.google.com with SMTP id 00721157ae682-2f4dfd09d7fso8828667b3.0 for ; Tue, 17 May 2022 18:47:12 -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=W1lmCBMSvh8WM0XdwNyp+PodjxHLyHRsBa8QQZ0AbFw=; b=WvVuu9D+7nu5qVB8kWHqWcYHQbsJXYb8i6L7M+/DrCSC3GN8OWxaa1DizXgf3xnJHk fINbVn4vyZ+HHizxwYyklCrtZpgPwGn/iXVnNmj3tdRYejslmJNHRnltXf0eTNUkPhVp 53hGUOxOYFsZoTAKx6Jns5j5nJuzgmQlW4j/Fo5aiV5yxTE2g1rqp7ewPQH5u7cIk2LA iPYvljtc464NjJPnlOpsNyj0iBzRPWSV33Cuy0ChBxojzIYeXCiYSDrT7zCZwkTIITvG rlxySrkZ7IiIyK0h8z8aIC7pRAwXwsbZdVx59yNzngzWnm2cAP0ZmlzB7HdF4LFhEP30 gvSQ== 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=W1lmCBMSvh8WM0XdwNyp+PodjxHLyHRsBa8QQZ0AbFw=; b=WJBMoNT3HsrOr0dYIGJzLfgZvhZ+M4bg3ayj5iTtHeDYS/6RtCmB9bETqbEMWWzvYW +yMT5TLyhVwcAFtY9CSOQalzL7b5Js5bHRP/G9iHSFPascoG4ByWH70b7uwct18mviAs ULA7CxQfv+lkcdV7gMvirSQ0gfVoJOTKwkIIk0oo4xQ5RcP7dY1ovM4xaebqYtb+hxSc lRHFthWL3GKUw6MHPZNEg/BiyNobqRQgWR6xzVjX5BGYVzbswJgTZ1ypSubJk+qIU65u F2W6EKRjg+7tfHu5BmU82dAg67Quuy3dWH57dZb0V17CJSCpszwFCFgZtan8T/B0pc1B bGIA== X-Gm-Message-State: AOAM530p0N6xXr9BgMQisddrxULmX0dinQ1iO/N38s0WhMjQUIrLUOX4 FBMO0F7Q7Yz9aD8cqJA4J225PvVZ/fY= X-Google-Smtp-Source: ABdhPJylNicMwjJM0mSLGeu5WFwH+Uvqs4PoDUUOGjHkU7Hmd7go+9S3O62WXfmdYFAyReYmXT0hT8SNDRY= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:f7bc:90c9:d86e:4ea8]) (user=yuzhao job=sendgmr) by 2002:a81:5212:0:b0:2fe:e667:ee6e with SMTP id g18-20020a815212000000b002fee667ee6emr16390918ywb.155.1652838431235; Tue, 17 May 2022 18:47:11 -0700 (PDT) Date: Tue, 17 May 2022 19:46:31 -0600 In-Reply-To: <20220518014632.922072-1-yuzhao@google.com> Message-Id: <20220518014632.922072-13-yuzhao@google.com> Mime-Version: 1.0 References: <20220518014632.922072-1-yuzhao@google.com> X-Mailer: git-send-email 2.36.0.550.gb090851708-goog Subject: [PATCH v11 12/14] mm: multi-gen LRU: debugfs interface From: Yu Zhao To: Andrew Morton , linux-mm@kvack.org Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Peter Zijlstra , Tejun Heo , Vlastimil Babka , Will Deacon , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, page-reclaim@google.com, 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/debug/lru_gen for working set estimation and proactive reclaim. These techniques are commonly used to optimize job scheduling (bin packing) in data centers [1][2]. Compared with the page table-based approach and the PFN-based approach, this lruvec-based approach has the following advantages: 1. It offers better choices because it is aware of memcgs, NUMA nodes, shared mappings and unmapped page cache. 2. It is more scalable because it is O(nr_hot_pages), whereas the PFN-based approach is O(nr_total_pages). Add /sys/kernel/debug/lru_gen_full for debugging. [1] https://dl.acm.org/doi/10.1145/3297858.3304053 [2] https://dl.acm.org/doi/10.1145/3503222.3507731 Signed-off-by: Yu Zhao Acked-by: Brian Geffon Acked-by: Jan Alexander Steffens (heftig) Acked-by: Oleksandr Natalenko Acked-by: Steven Barrett Acked-by: Suleiman Souhlal Tested-by: Daniel Byrne Tested-by: Donald Carr Tested-by: Holger Hoffst=C3=A4tte Tested-by: Konstantin Kharlamov Tested-by: Shuang Zhai Tested-by: Sofia Trinh Tested-by: Vaibhav Jain --- include/linux/nodemask.h | 1 + mm/vmscan.c | 403 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 394 insertions(+), 10 deletions(-) diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h index 567c3ddba2c4..90840c459abc 100644 --- a/include/linux/nodemask.h +++ b/include/linux/nodemask.h @@ -486,6 +486,7 @@ static inline int num_node_state(enum node_states state= ) #define first_online_node 0 #define first_memory_node 0 #define next_online_node(nid) (MAX_NUMNODES) +#define next_memory_node(nid) (MAX_NUMNODES) #define nr_node_ids 1U #define nr_online_nodes 1U =20 diff --git a/mm/vmscan.c b/mm/vmscan.c index 823c55e17e64..aef71c45c424 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -53,6 +53,7 @@ #include #include #include +#include =20 #include #include @@ -4063,12 +4064,39 @@ static void free_mm_walk(struct lru_gen_mm_walk *wa= lk) kfree(walk); } =20 -static void inc_min_seq(struct lruvec *lruvec, int type) +static bool inc_min_seq(struct lruvec *lruvec, int type, bool can_swap) { + int zone; + int remaining =3D MAX_LRU_BATCH; struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + int new_gen, old_gen =3D lru_gen_from_seq(lrugen->min_seq[type]); =20 + if (type =3D=3D LRU_GEN_ANON && !can_swap) + goto done; + + for (zone =3D 0; zone < MAX_NR_ZONES; zone++) { + struct list_head *head =3D &lrugen->lists[old_gen][type][zone]; + + while (!list_empty(head)) { + struct folio *folio =3D lru_to_folio(head); + + VM_WARN_ON_ONCE_FOLIO(folio_test_unevictable(folio), folio); + VM_WARN_ON_ONCE_FOLIO(folio_test_active(folio), folio); + VM_WARN_ON_ONCE_FOLIO(folio_is_file_lru(folio) !=3D type, folio); + VM_WARN_ON_ONCE_FOLIO(folio_zonenum(folio) !=3D zone, folio); + + new_gen =3D folio_inc_gen(lruvec, folio, false); + list_move_tail(&folio->lru, &lrugen->lists[new_gen][type][zone]); + + if (!--remaining) + return false; + } + } +done: reset_ctrl_pos(lruvec, type, true); WRITE_ONCE(lrugen->min_seq[type], lrugen->min_seq[type] + 1); + + return true; } =20 static bool try_to_inc_min_seq(struct lruvec *lruvec, bool can_swap) @@ -4114,7 +4142,7 @@ static bool try_to_inc_min_seq(struct lruvec *lruvec,= bool can_swap) return success; } =20 -static void inc_max_seq(struct lruvec *lruvec, bool can_swap) +static void inc_max_seq(struct lruvec *lruvec, bool can_swap, bool force_s= can) { int prev, next; int type, zone; @@ -4128,9 +4156,13 @@ static void inc_max_seq(struct lruvec *lruvec, bool = can_swap) if (get_nr_gens(lruvec, type) !=3D MAX_NR_GENS) continue; =20 - VM_WARN_ON_ONCE(type =3D=3D LRU_GEN_FILE || can_swap); + VM_WARN_ON_ONCE(!force_scan && (type =3D=3D LRU_GEN_FILE || can_swap)); =20 - inc_min_seq(lruvec, type); + while (!inc_min_seq(lruvec, type, can_swap)) { + spin_unlock_irq(&lruvec->lru_lock); + cond_resched(); + spin_lock_irq(&lruvec->lru_lock); + } } =20 /* @@ -4167,7 +4199,7 @@ static void inc_max_seq(struct lruvec *lruvec, bool c= an_swap) } =20 static bool try_to_inc_max_seq(struct lruvec *lruvec, unsigned long max_se= q, - struct scan_control *sc, bool can_swap) + struct scan_control *sc, bool can_swap, bool force_scan) { bool success; struct lru_gen_mm_walk *walk; @@ -4182,7 +4214,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 (!(arch_has_hw_pte_young() && get_cap(LRU_GEN_MM_WALK))) { + if (!force_scan && !(arch_has_hw_pte_young() && get_cap(LRU_GEN_MM_WALK))= ) { success =3D iterate_mm_list_nowalk(lruvec, max_seq); goto done; } @@ -4196,7 +4228,7 @@ static bool try_to_inc_max_seq(struct lruvec *lruvec,= unsigned long max_seq, walk->lruvec =3D lruvec; walk->max_seq =3D max_seq; walk->can_swap =3D can_swap; - walk->force_scan =3D false; + walk->force_scan =3D force_scan; =20 do { success =3D iterate_mm_list(lruvec, walk, &mm); @@ -4218,7 +4250,7 @@ static bool try_to_inc_max_seq(struct lruvec *lruvec,= unsigned long max_seq, =20 VM_WARN_ON_ONCE(max_seq !=3D READ_ONCE(lrugen->max_seq)); =20 - inc_max_seq(lruvec, can_swap); + inc_max_seq(lruvec, can_swap, force_scan); /* either this sees any waiters or they will see updated max_seq */ if (wq_has_sleeper(&lruvec->mm_state.wait)) wake_up_all(&lruvec->mm_state.wait); @@ -4317,7 +4349,7 @@ static bool age_lruvec(struct lruvec *lruvec, struct = scan_control *sc, nr_to_scan++; =20 if (nr_to_scan && need_aging) - try_to_inc_max_seq(lruvec, max_seq, sc, swappiness); + try_to_inc_max_seq(lruvec, max_seq, sc, swappiness, false); =20 return true; } @@ -4887,7 +4919,7 @@ static long get_nr_to_scan(struct lruvec *lruvec, str= uct scan_control *sc, bool return 0; } =20 - if (try_to_inc_max_seq(lruvec, max_seq, sc, can_swap)) + if (try_to_inc_max_seq(lruvec, max_seq, sc, can_swap, false)) return nr_to_scan; =20 return min_seq[!can_swap] + MIN_NR_GENS <=3D max_seq ? nr_to_scan : 0; @@ -5175,6 +5207,354 @@ static struct attribute_group lru_gen_attr_group = =3D { .attrs =3D lru_gen_attrs, }; =20 +/*************************************************************************= ***** + * debugfs interface + *************************************************************************= *****/ + +static void *lru_gen_seq_start(struct seq_file *m, loff_t *pos) +{ + struct mem_cgroup *memcg; + loff_t nr_to_skip =3D *pos; + + m->private =3D kvmalloc(PATH_MAX, GFP_KERNEL); + if (!m->private) + return ERR_PTR(-ENOMEM); + + memcg =3D mem_cgroup_iter(NULL, NULL, NULL); + do { + int nid; + + for_each_node_state(nid, N_MEMORY) { + if (!nr_to_skip--) + return get_lruvec(memcg, nid); + } + } while ((memcg =3D mem_cgroup_iter(NULL, memcg, NULL))); + + return NULL; +} + +static void lru_gen_seq_stop(struct seq_file *m, void *v) +{ + if (!IS_ERR_OR_NULL(v)) + mem_cgroup_iter_break(NULL, lruvec_memcg(v)); + + kvfree(m->private); + m->private =3D NULL; +} + +static void *lru_gen_seq_next(struct seq_file *m, void *v, loff_t *pos) +{ + int nid =3D lruvec_pgdat(v)->node_id; + struct mem_cgroup *memcg =3D lruvec_memcg(v); + + ++*pos; + + nid =3D next_memory_node(nid); + if (nid =3D=3D MAX_NUMNODES) { + memcg =3D mem_cgroup_iter(NULL, memcg, NULL); + if (!memcg) + return NULL; + + nid =3D first_memory_node; + } + + return get_lruvec(memcg, nid); +} + +static void lru_gen_seq_show_full(struct seq_file *m, struct lruvec *lruve= c, + unsigned long max_seq, unsigned long *min_seq, + unsigned long seq) +{ + int i; + int type, tier; + int hist =3D lru_hist_from_seq(seq); + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + + for (tier =3D 0; tier < MAX_NR_TIERS; tier++) { + seq_printf(m, " %10d", tier); + for (type =3D 0; type < ANON_AND_FILE; type++) { + unsigned long n[3] =3D {}; + + if (seq =3D=3D max_seq) { + n[0] =3D READ_ONCE(lrugen->avg_refaulted[type][tier]); + n[1] =3D READ_ONCE(lrugen->avg_total[type][tier]); + + seq_printf(m, " %10luR %10luT %10lu ", n[0], n[1], n[2]); + } else if (seq =3D=3D min_seq[type] || NR_HIST_GENS > 1) { + n[0] =3D atomic_long_read(&lrugen->refaulted[hist][type][tier]); + n[1] =3D atomic_long_read(&lrugen->evicted[hist][type][tier]); + if (tier) + n[2] =3D READ_ONCE(lrugen->protected[hist][type][tier - 1]); + + seq_printf(m, " %10lur %10lue %10lup", n[0], n[1], n[2]); + } else + seq_puts(m, " 0 0 0 "); + } + seq_putc(m, '\n'); + } + + seq_puts(m, " "); + for (i =3D 0; i < NR_MM_STATS; i++) { + if (seq =3D=3D max_seq && NR_HIST_GENS =3D=3D 1) + seq_printf(m, " %10lu%c", READ_ONCE(lruvec->mm_state.stats[hist][i]), + toupper(MM_STAT_CODES[i])); + else if (seq !=3D max_seq && NR_HIST_GENS > 1) + seq_printf(m, " %10lu%c", READ_ONCE(lruvec->mm_state.stats[hist][i]), + MM_STAT_CODES[i]); + else + seq_puts(m, " 0 "); + } + seq_putc(m, '\n'); +} + +static int lru_gen_seq_show(struct seq_file *m, void *v) +{ + unsigned long seq; + bool full =3D !debugfs_real_fops(m->file)->write; + struct lruvec *lruvec =3D v; + struct lru_gen_struct *lrugen =3D &lruvec->lrugen; + int nid =3D lruvec_pgdat(lruvec)->node_id; + struct mem_cgroup *memcg =3D lruvec_memcg(lruvec); + DEFINE_MAX_SEQ(lruvec); + DEFINE_MIN_SEQ(lruvec); + + if (nid =3D=3D first_memory_node) { + const char *path =3D memcg ? m->private : ""; + +#ifdef CONFIG_MEMCG + if (memcg) + cgroup_path(memcg->css.cgroup, m->private, PATH_MAX); +#endif + seq_printf(m, "memcg %5hu %s\n", mem_cgroup_id(memcg), path); + } + + seq_printf(m, " node %5d\n", nid); + + if (!full) + seq =3D min_seq[LRU_GEN_ANON]; + else if (max_seq >=3D MAX_NR_GENS) + seq =3D max_seq - MAX_NR_GENS + 1; + else + seq =3D 0; + + for (; seq <=3D max_seq; seq++) { + int type, zone; + int gen =3D lru_gen_from_seq(seq); + unsigned long birth =3D READ_ONCE(lruvec->lrugen.timestamps[gen]); + + seq_printf(m, " %10lu %10u", seq, jiffies_to_msecs(jiffies - birth)); + + for (type =3D 0; type < ANON_AND_FILE; type++) { + long size =3D 0; + char mark =3D full && seq < min_seq[type] ? 'x' : ' '; + + for (zone =3D 0; zone < MAX_NR_ZONES; zone++) + size +=3D READ_ONCE(lrugen->nr_pages[gen][type][zone]); + + seq_printf(m, " %10lu%c", max(size, 0L), mark); + } + + seq_putc(m, '\n'); + + if (full) + lru_gen_seq_show_full(m, lruvec, max_seq, min_seq, seq); + } + + return 0; +} + +static const struct seq_operations lru_gen_seq_ops =3D { + .start =3D lru_gen_seq_start, + .stop =3D lru_gen_seq_stop, + .next =3D lru_gen_seq_next, + .show =3D lru_gen_seq_show, +}; + +static int run_aging(struct lruvec *lruvec, unsigned long seq, struct scan= _control *sc, + bool can_swap, bool force_scan) +{ + DEFINE_MAX_SEQ(lruvec); + DEFINE_MIN_SEQ(lruvec); + + if (seq < max_seq) + return 0; + + if (seq > max_seq || (!force_scan && min_seq[!can_swap] + MAX_NR_GENS - 1= <=3D max_seq)) + return -EINVAL; + + try_to_inc_max_seq(lruvec, max_seq, sc, can_swap, force_scan); + + return 0; +} + +static int run_eviction(struct lruvec *lruvec, unsigned long seq, struct s= can_control *sc, + int swappiness, unsigned long nr_to_reclaim) +{ + struct blk_plug plug; + int err =3D -EINTR; + DEFINE_MAX_SEQ(lruvec); + + if (seq + MIN_NR_GENS > max_seq) + return -EINVAL; + + sc->nr_reclaimed =3D 0; + + blk_start_plug(&plug); + + while (!signal_pending(current)) { + DEFINE_MIN_SEQ(lruvec); + + if (seq < min_seq[!swappiness] || sc->nr_reclaimed >=3D nr_to_reclaim || + !evict_folios(lruvec, sc, swappiness, NULL)) { + err =3D 0; + break; + } + + cond_resched(); + } + + blk_finish_plug(&plug); + + return err; +} + +static int run_cmd(char cmd, int memcg_id, int nid, unsigned long seq, + struct scan_control *sc, int swappiness, unsigned long opt) +{ + struct lruvec *lruvec; + int err =3D -EINVAL; + struct mem_cgroup *memcg =3D NULL; + + if (!mem_cgroup_disabled()) { + rcu_read_lock(); + memcg =3D mem_cgroup_from_id(memcg_id); +#ifdef CONFIG_MEMCG + if (memcg && !css_tryget(&memcg->css)) + memcg =3D NULL; +#endif + rcu_read_unlock(); + + if (!memcg) + goto done; + } + if (memcg_id !=3D mem_cgroup_id(memcg)) + goto done; + + if (nid < 0 || nid >=3D MAX_NUMNODES || !node_state(nid, N_MEMORY)) + goto done; + + lruvec =3D get_lruvec(memcg, nid); + + if (swappiness < 0) + swappiness =3D get_swappiness(lruvec, sc); + else if (swappiness > 200) + goto done; + + switch (cmd) { + case '+': + err =3D run_aging(lruvec, seq, sc, swappiness, opt); + break; + case '-': + err =3D run_eviction(lruvec, seq, sc, swappiness, opt); + break; + } +done: + mem_cgroup_put(memcg); + + return err; +} + +static ssize_t lru_gen_seq_write(struct file *file, const char __user *src= , + size_t len, loff_t *pos) +{ + void *buf; + char *cur, *next; + unsigned int flags; + int err =3D 0; + struct scan_control sc =3D { + .may_writepage =3D true, + .may_unmap =3D true, + .may_swap =3D true, + .reclaim_idx =3D MAX_NR_ZONES - 1, + .gfp_mask =3D GFP_KERNEL, + }; + + buf =3D kvmalloc(len + 1, GFP_KERNEL); + if (!buf) + return -ENOMEM; + + if (copy_from_user(buf, src, len)) { + kvfree(buf); + return -EFAULT; + } + + next =3D buf; + next[len] =3D '\0'; + + sc.reclaim_state.mm_walk =3D alloc_mm_walk(); + if (!sc.reclaim_state.mm_walk) { + kvfree(buf); + return -ENOMEM; + } + + set_task_reclaim_state(current, &sc.reclaim_state); + flags =3D memalloc_noreclaim_save(); + + while ((cur =3D strsep(&next, ",;\n"))) { + int n; + int end; + char cmd; + unsigned int memcg_id; + unsigned int nid; + unsigned long seq; + unsigned int swappiness =3D -1; + unsigned long opt =3D -1; + + cur =3D skip_spaces(cur); + if (!*cur) + continue; + + n =3D sscanf(cur, "%c %u %u %lu %n %u %n %lu %n", &cmd, &memcg_id, &nid, + &seq, &end, &swappiness, &end, &opt, &end); + if (n < 4 || cur[end]) { + err =3D -EINVAL; + break; + } + + err =3D run_cmd(cmd, memcg_id, nid, seq, &sc, swappiness, opt); + if (err) + break; + } + + memalloc_noreclaim_restore(flags); + set_task_reclaim_state(current, NULL); + + free_mm_walk(sc.reclaim_state.mm_walk); + kvfree(buf); + + return err ? : len; +} + +static int lru_gen_seq_open(struct inode *inode, struct file *file) +{ + return seq_open(file, &lru_gen_seq_ops); +} + +static const struct file_operations lru_gen_rw_fops =3D { + .open =3D lru_gen_seq_open, + .read =3D seq_read, + .write =3D lru_gen_seq_write, + .llseek =3D seq_lseek, + .release =3D seq_release, +}; + +static const struct file_operations lru_gen_ro_fops =3D { + .open =3D lru_gen_seq_open, + .read =3D seq_read, + .llseek =3D seq_lseek, + .release =3D seq_release, +}; + /*************************************************************************= ***** * initialization *************************************************************************= *****/ @@ -5233,6 +5613,9 @@ static int __init init_lru_gen(void) if (sysfs_create_group(mm_kobj, &lru_gen_attr_group)) pr_err("lru_gen: failed to create sysfs group\n"); =20 + debugfs_create_file("lru_gen", 0644, NULL, NULL, &lru_gen_rw_fops); + debugfs_create_file("lru_gen_full", 0444, NULL, NULL, &lru_gen_ro_fops); + return 0; }; late_initcall(init_lru_gen); --=20 2.36.0.550.gb090851708-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 EFA99C433EF for ; Wed, 18 May 2022 03:02:13 +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=GTgouRR1W0hNGfdMdV5kAL/b5xPQLs/TGcTbmMp8sA0=; b=QkNVT5XbxoCi8u6OVOv2AJ0oMG 3NgB9axpsZ9o78YWQwR7cfyoYAzH1CtAlqGz9D7f9dCoT2cuMy9Jb1c5gqu2VkLUM5WNb/AhIYlBM x9O6By0flAQWypahdurSVhxXPxNpPLmMDAIUqAUz0sVbvtA5MuqVJW0DafAtxe16oSuOd4Ntwf4lg BpDSkJl9gLjb7FK4A52NtjQ1pvztaGuVhw8F0623tYTv+y8j+kzkGEYrfFWbHh3PRccdkRU+Zh4Vz 0vL0UtlSx5CUCNiCguzAQ2b0SQSJl5QIUjYm2cE3LjdBh4HMla1Gi4YPIXf5qWNyPQ3ghsN7eSaT1 80mwviWA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1nr9wC-00GmAy-Ds; Wed, 18 May 2022 03:01:24 +0000 Received: from mail-yw1-x1149.google.com ([2607:f8b0:4864:20::1149]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1nr8mO-00GdEb-Pb for linux-arm-kernel@lists.infradead.org; Wed, 18 May 2022 01:47:17 +0000 Received: by mail-yw1-x1149.google.com with SMTP id 00721157ae682-2fecfc7a95aso7794847b3.22 for ; Tue, 17 May 2022 18:47:11 -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=W1lmCBMSvh8WM0XdwNyp+PodjxHLyHRsBa8QQZ0AbFw=; b=WvVuu9D+7nu5qVB8kWHqWcYHQbsJXYb8i6L7M+/DrCSC3GN8OWxaa1DizXgf3xnJHk fINbVn4vyZ+HHizxwYyklCrtZpgPwGn/iXVnNmj3tdRYejslmJNHRnltXf0eTNUkPhVp 53hGUOxOYFsZoTAKx6Jns5j5nJuzgmQlW4j/Fo5aiV5yxTE2g1rqp7ewPQH5u7cIk2LA iPYvljtc464NjJPnlOpsNyj0iBzRPWSV33Cuy0ChBxojzIYeXCiYSDrT7zCZwkTIITvG rlxySrkZ7IiIyK0h8z8aIC7pRAwXwsbZdVx59yNzngzWnm2cAP0ZmlzB7HdF4LFhEP30 gvSQ== 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=W1lmCBMSvh8WM0XdwNyp+PodjxHLyHRsBa8QQZ0AbFw=; b=wX8jljzzJc9M//yzi+nbLxhEesVToDrwuGRVuXmaPtc8wH1M2EhCkTelNqhNxbwM49 mibH46WTDvLjg+9/Pu6aeZHdrvmNg5ZyWLxJezl56iIqx8pUG2teJFUCQXIVgpQ/sqp6 KpbIqif2h0v+VW+70NQvuhcb/X3ihVLwNQmKK1KaN4hASOQOqJaEW6N5Sw0UZXdAGt8q D27DNeg0vBqV/jwkgqCnUu3JlIm7ii5RMW0bqClXjUS3EU1iirhKeXvB4A4oSRwfPvE4 WOj4dHUQ5Iuv/syCGMxcVPXuOwNR5W5JBaEA0dGG6/7RiHrdhKZ+guKMtB+EDWw+F6CK 6pQQ== X-Gm-Message-State: AOAM531i/me8EflghCB1yBwaJAc3K7ZufDbdDi9TOOE3Z9W1+htQ9sK3 my5mtNotRLQOErG1nVr25NdlTjR98AA= X-Google-Smtp-Source: ABdhPJylNicMwjJM0mSLGeu5WFwH+Uvqs4PoDUUOGjHkU7Hmd7go+9S3O62WXfmdYFAyReYmXT0hT8SNDRY= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:f7bc:90c9:d86e:4ea8]) (user=yuzhao job=sendgmr) by 2002:a81:5212:0:b0:2fe:e667:ee6e with SMTP id g18-20020a815212000000b002fee667ee6emr16390918ywb.155.1652838431235; Tue, 17 May 2022 18:47:11 -0700 (PDT) Date: Tue, 17 May 2022 19:46:31 -0600 In-Reply-To: <20220518014632.922072-1-yuzhao@google.com> Message-Id: <20220518014632.922072-13-yuzhao@google.com> Mime-Version: 1.0 References: <20220518014632.922072-1-yuzhao@google.com> X-Mailer: git-send-email 2.36.0.550.gb090851708-goog Subject: [PATCH v11 12/14] mm: multi-gen LRU: debugfs interface From: Yu Zhao To: Andrew Morton , linux-mm@kvack.org Cc: Andi Kleen , Aneesh Kumar , Catalin Marinas , Dave Hansen , Hillf Danton , Jens Axboe , Johannes Weiner , Jonathan Corbet , Linus Torvalds , Matthew Wilcox , Mel Gorman , Michael Larabel , Michal Hocko , Mike Rapoport , Peter Zijlstra , Tejun Heo , Vlastimil Babka , Will Deacon , linux-arm-kernel@lists.infradead.org, linux-doc@vger.kernel.org, linux-kernel@vger.kernel.org, x86@kernel.org, page-reclaim@google.com, 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-20220517_184712_896643_CB38B63C X-CRM114-Status: GOOD ( 22.73 ) 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 QWRkIC9zeXMva2VybmVsL2RlYnVnL2xydV9nZW4gZm9yIHdvcmtpbmcgc2V0IGVzdGltYXRpb24g YW5kIHByb2FjdGl2ZQpyZWNsYWltLiBUaGVzZSB0ZWNobmlxdWVzIGFyZSBjb21tb25seSB1c2Vk IHRvIG9wdGltaXplIGpvYiBzY2hlZHVsaW5nCihiaW4gcGFja2luZykgaW4gZGF0YSBjZW50ZXJz IFsxXVsyXS4KCkNvbXBhcmVkIHdpdGggdGhlIHBhZ2UgdGFibGUtYmFzZWQgYXBwcm9hY2ggYW5k IHRoZSBQRk4tYmFzZWQKYXBwcm9hY2gsIHRoaXMgbHJ1dmVjLWJhc2VkIGFwcHJvYWNoIGhhcyB0 aGUgZm9sbG93aW5nIGFkdmFudGFnZXM6CjEuIEl0IG9mZmVycyBiZXR0ZXIgY2hvaWNlcyBiZWNh dXNlIGl0IGlzIGF3YXJlIG9mIG1lbWNncywgTlVNQSBub2RlcywKICAgc2hhcmVkIG1hcHBpbmdz IGFuZCB1bm1hcHBlZCBwYWdlIGNhY2hlLgoyLiBJdCBpcyBtb3JlIHNjYWxhYmxlIGJlY2F1c2Ug aXQgaXMgTyhucl9ob3RfcGFnZXMpLCB3aGVyZWFzIHRoZQogICBQRk4tYmFzZWQgYXBwcm9hY2gg aXMgTyhucl90b3RhbF9wYWdlcykuCgpBZGQgL3N5cy9rZXJuZWwvZGVidWcvbHJ1X2dlbl9mdWxs IGZvciBkZWJ1Z2dpbmcuCgpbMV0gaHR0cHM6Ly9kbC5hY20ub3JnL2RvaS8xMC4xMTQ1LzMyOTc4 NTguMzMwNDA1MwpbMl0gaHR0cHM6Ly9kbC5hY20ub3JnL2RvaS8xMC4xMTQ1LzM1MDMyMjIuMzUw NzczMQoKU2lnbmVkLW9mZi1ieTogWXUgWmhhbyA8eXV6aGFvQGdvb2dsZS5jb20+CkFja2VkLWJ5 OiBCcmlhbiBHZWZmb24gPGJnZWZmb25AZ29vZ2xlLmNvbT4KQWNrZWQtYnk6IEphbiBBbGV4YW5k ZXIgU3RlZmZlbnMgKGhlZnRpZykgPGhlZnRpZ0BhcmNobGludXgub3JnPgpBY2tlZC1ieTogT2xl a3NhbmRyIE5hdGFsZW5rbyA8b2xla3NhbmRyQG5hdGFsZW5rby5uYW1lPgpBY2tlZC1ieTogU3Rl dmVuIEJhcnJldHQgPHN0ZXZlbkBsaXF1b3JpeC5uZXQ+CkFja2VkLWJ5OiBTdWxlaW1hbiBTb3Vo bGFsIDxzdWxlaW1hbkBnb29nbGUuY29tPgpUZXN0ZWQtYnk6IERhbmllbCBCeXJuZSA8ZGpieXJu ZUBtdHUuZWR1PgpUZXN0ZWQtYnk6IERvbmFsZCBDYXJyIDxkQGNoYW9zLXJlaW5zLmNvbT4KVGVz dGVkLWJ5OiBIb2xnZXIgSG9mZnN0w6R0dGUgPGhvbGdlckBhcHBsaWVkLWFzeW5jaHJvbnkuY29t PgpUZXN0ZWQtYnk6IEtvbnN0YW50aW4gS2hhcmxhbW92IDxIaS1BbmdlbEB5YW5kZXgucnU+ClRl c3RlZC1ieTogU2h1YW5nIFpoYWkgPHN6aGFpMkBjcy5yb2NoZXN0ZXIuZWR1PgpUZXN0ZWQtYnk6 IFNvZmlhIFRyaW5oIDxzb2ZpYS50cmluaEBlZGkud29ya3M+ClRlc3RlZC1ieTogVmFpYmhhdiBK YWluIDx2YWliaGF2QGxpbnV4LmlibS5jb20+Ci0tLQogaW5jbHVkZS9saW51eC9ub2RlbWFzay5o IHwgICAxICsKIG1tL3Ztc2Nhbi5jICAgICAgICAgICAgICB8IDQwMyArKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgMzk0IGluc2VydGlvbnMo KyksIDEwIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbm9kZW1hc2su aCBiL2luY2x1ZGUvbGludXgvbm9kZW1hc2suaAppbmRleCA1NjdjM2RkYmEyYzQuLjkwODQwYzQ1 OWFiYyAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ub2RlbWFzay5oCisrKyBiL2luY2x1ZGUv bGludXgvbm9kZW1hc2suaApAQCAtNDg2LDYgKzQ4Niw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IG51 bV9ub2RlX3N0YXRlKGVudW0gbm9kZV9zdGF0ZXMgc3RhdGUpCiAjZGVmaW5lIGZpcnN0X29ubGlu ZV9ub2RlCTAKICNkZWZpbmUgZmlyc3RfbWVtb3J5X25vZGUJMAogI2RlZmluZSBuZXh0X29ubGlu ZV9ub2RlKG5pZCkJKE1BWF9OVU1OT0RFUykKKyNkZWZpbmUgbmV4dF9tZW1vcnlfbm9kZShuaWQp CShNQVhfTlVNTk9ERVMpCiAjZGVmaW5lIG5yX25vZGVfaWRzCQkxVQogI2RlZmluZSBucl9vbmxp bmVfbm9kZXMJCTFVCiAKZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5k ZXggODIzYzU1ZTE3ZTY0Li5hZWY3MWM0NWM0MjQgMTAwNjQ0Ci0tLSBhL21tL3Ztc2Nhbi5jCisr KyBiL21tL3Ztc2Nhbi5jCkBAIC01Myw2ICs1Myw3IEBACiAjaW5jbHVkZSA8bGludXgvcGFnZXdh bGsuaD4KICNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBl Lmg+CisjaW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgogCiAjaW5jbHVkZSA8YXNtL3RsYmZsdXNo Lmg+CiAjaW5jbHVkZSA8YXNtL2RpdjY0Lmg+CkBAIC00MDYzLDEyICs0MDY0LDM5IEBAIHN0YXRp YyB2b2lkIGZyZWVfbW1fd2FsayhzdHJ1Y3QgbHJ1X2dlbl9tbV93YWxrICp3YWxrKQogCQlrZnJl ZSh3YWxrKTsKIH0KIAotc3RhdGljIHZvaWQgaW5jX21pbl9zZXEoc3RydWN0IGxydXZlYyAqbHJ1 dmVjLCBpbnQgdHlwZSkKK3N0YXRpYyBib29sIGluY19taW5fc2VxKHN0cnVjdCBscnV2ZWMgKmxy dXZlYywgaW50IHR5cGUsIGJvb2wgY2FuX3N3YXApCiB7CisJaW50IHpvbmU7CisJaW50IHJlbWFp bmluZyA9IE1BWF9MUlVfQkFUQ0g7CiAJc3RydWN0IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAm bHJ1dmVjLT5scnVnZW47CisJaW50IG5ld19nZW4sIG9sZF9nZW4gPSBscnVfZ2VuX2Zyb21fc2Vx KGxydWdlbi0+bWluX3NlcVt0eXBlXSk7CiAKKwlpZiAodHlwZSA9PSBMUlVfR0VOX0FOT04gJiYg IWNhbl9zd2FwKQorCQlnb3RvIGRvbmU7CisKKwlmb3IgKHpvbmUgPSAwOyB6b25lIDwgTUFYX05S X1pPTkVTOyB6b25lKyspIHsKKwkJc3RydWN0IGxpc3RfaGVhZCAqaGVhZCA9ICZscnVnZW4tPmxp c3RzW29sZF9nZW5dW3R5cGVdW3pvbmVdOworCisJCXdoaWxlICghbGlzdF9lbXB0eShoZWFkKSkg eworCQkJc3RydWN0IGZvbGlvICpmb2xpbyA9IGxydV90b19mb2xpbyhoZWFkKTsKKworCQkJVk1f V0FSTl9PTl9PTkNFX0ZPTElPKGZvbGlvX3Rlc3RfdW5ldmljdGFibGUoZm9saW8pLCBmb2xpbyk7 CisJCQlWTV9XQVJOX09OX09OQ0VfRk9MSU8oZm9saW9fdGVzdF9hY3RpdmUoZm9saW8pLCBmb2xp byk7CisJCQlWTV9XQVJOX09OX09OQ0VfRk9MSU8oZm9saW9faXNfZmlsZV9scnUoZm9saW8pICE9 IHR5cGUsIGZvbGlvKTsKKwkJCVZNX1dBUk5fT05fT05DRV9GT0xJTyhmb2xpb196b25lbnVtKGZv bGlvKSAhPSB6b25lLCBmb2xpbyk7CisKKwkJCW5ld19nZW4gPSBmb2xpb19pbmNfZ2VuKGxydXZl YywgZm9saW8sIGZhbHNlKTsKKwkJCWxpc3RfbW92ZV90YWlsKCZmb2xpby0+bHJ1LCAmbHJ1Z2Vu LT5saXN0c1tuZXdfZ2VuXVt0eXBlXVt6b25lXSk7CisKKwkJCWlmICghLS1yZW1haW5pbmcpCisJ CQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorZG9uZToKIAlyZXNldF9jdHJsX3BvcyhscnV2ZWMs IHR5cGUsIHRydWUpOwogCVdSSVRFX09OQ0UobHJ1Z2VuLT5taW5fc2VxW3R5cGVdLCBscnVnZW4t Pm1pbl9zZXFbdHlwZV0gKyAxKTsKKworCXJldHVybiB0cnVlOwogfQogCiBzdGF0aWMgYm9vbCB0 cnlfdG9faW5jX21pbl9zZXEoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBib29sIGNhbl9zd2FwKQpA QCAtNDExNCw3ICs0MTQyLDcgQEAgc3RhdGljIGJvb2wgdHJ5X3RvX2luY19taW5fc2VxKHN0cnVj dCBscnV2ZWMgKmxydXZlYywgYm9vbCBjYW5fc3dhcCkKIAlyZXR1cm4gc3VjY2VzczsKIH0KIAot c3RhdGljIHZvaWQgaW5jX21heF9zZXEoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBib29sIGNhbl9z d2FwKQorc3RhdGljIHZvaWQgaW5jX21heF9zZXEoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBib29s IGNhbl9zd2FwLCBib29sIGZvcmNlX3NjYW4pCiB7CiAJaW50IHByZXYsIG5leHQ7CiAJaW50IHR5 cGUsIHpvbmU7CkBAIC00MTI4LDkgKzQxNTYsMTMgQEAgc3RhdGljIHZvaWQgaW5jX21heF9zZXEo c3RydWN0IGxydXZlYyAqbHJ1dmVjLCBib29sIGNhbl9zd2FwKQogCQlpZiAoZ2V0X25yX2dlbnMo bHJ1dmVjLCB0eXBlKSAhPSBNQVhfTlJfR0VOUykKIAkJCWNvbnRpbnVlOwogCi0JCVZNX1dBUk5f T05fT05DRSh0eXBlID09IExSVV9HRU5fRklMRSB8fCBjYW5fc3dhcCk7CisJCVZNX1dBUk5fT05f T05DRSghZm9yY2Vfc2NhbiAmJiAodHlwZSA9PSBMUlVfR0VOX0ZJTEUgfHwgY2FuX3N3YXApKTsK IAotCQlpbmNfbWluX3NlcShscnV2ZWMsIHR5cGUpOworCQl3aGlsZSAoIWluY19taW5fc2VxKGxy dXZlYywgdHlwZSwgY2FuX3N3YXApKSB7CisJCQlzcGluX3VubG9ja19pcnEoJmxydXZlYy0+bHJ1 X2xvY2spOworCQkJY29uZF9yZXNjaGVkKCk7CisJCQlzcGluX2xvY2tfaXJxKCZscnV2ZWMtPmxy dV9sb2NrKTsKKwkJfQogCX0KIAogCS8qCkBAIC00MTY3LDcgKzQxOTksNyBAQCBzdGF0aWMgdm9p ZCBpbmNfbWF4X3NlcShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIGJvb2wgY2FuX3N3YXApCiB9CiAK IHN0YXRpYyBib29sIHRyeV90b19pbmNfbWF4X3NlcShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHVu c2lnbmVkIGxvbmcgbWF4X3NlcSwKLQkJCSAgICAgICBzdHJ1Y3Qgc2Nhbl9jb250cm9sICpzYywg Ym9vbCBjYW5fc3dhcCkKKwkJCSAgICAgICBzdHJ1Y3Qgc2Nhbl9jb250cm9sICpzYywgYm9vbCBj YW5fc3dhcCwgYm9vbCBmb3JjZV9zY2FuKQogewogCWJvb2wgc3VjY2VzczsKIAlzdHJ1Y3QgbHJ1 X2dlbl9tbV93YWxrICp3YWxrOwpAQCAtNDE4Miw3ICs0MjE0LDcgQEAgc3RhdGljIGJvb2wgdHJ5 X3RvX2luY19tYXhfc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhf c2VxLAogCSAqIGhhbmRmdWwgb2YgUFRFcy4gU3ByZWFkaW5nIHRoZSB3b3JrIG91dCBvdmVyIGEg cGVyaW9kIG9mIHRpbWUgdXN1YWxseQogCSAqIGlzIGxlc3MgZWZmaWNpZW50LCBidXQgaXQgYXZv aWRzIGJ1cnN0eSBwYWdlIGZhdWx0cy4KIAkgKi8KLQlpZiAoIShhcmNoX2hhc19od19wdGVfeW91 bmcoKSAmJiBnZXRfY2FwKExSVV9HRU5fTU1fV0FMSykpKSB7CisJaWYgKCFmb3JjZV9zY2FuICYm ICEoYXJjaF9oYXNfaHdfcHRlX3lvdW5nKCkgJiYgZ2V0X2NhcChMUlVfR0VOX01NX1dBTEspKSkg ewogCQlzdWNjZXNzID0gaXRlcmF0ZV9tbV9saXN0X25vd2FsayhscnV2ZWMsIG1heF9zZXEpOwog CQlnb3RvIGRvbmU7CiAJfQpAQCAtNDE5Niw3ICs0MjI4LDcgQEAgc3RhdGljIGJvb2wgdHJ5X3Rv X2luY19tYXhfc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhfc2Vx LAogCXdhbGstPmxydXZlYyA9IGxydXZlYzsKIAl3YWxrLT5tYXhfc2VxID0gbWF4X3NlcTsKIAl3 YWxrLT5jYW5fc3dhcCA9IGNhbl9zd2FwOwotCXdhbGstPmZvcmNlX3NjYW4gPSBmYWxzZTsKKwl3 YWxrLT5mb3JjZV9zY2FuID0gZm9yY2Vfc2NhbjsKIAogCWRvIHsKIAkJc3VjY2VzcyA9IGl0ZXJh dGVfbW1fbGlzdChscnV2ZWMsIHdhbGssICZtbSk7CkBAIC00MjE4LDcgKzQyNTAsNyBAQCBzdGF0 aWMgYm9vbCB0cnlfdG9faW5jX21heF9zZXEoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCB1bnNpZ25l ZCBsb25nIG1heF9zZXEsCiAKIAlWTV9XQVJOX09OX09OQ0UobWF4X3NlcSAhPSBSRUFEX09OQ0Uo bHJ1Z2VuLT5tYXhfc2VxKSk7CiAKLQlpbmNfbWF4X3NlcShscnV2ZWMsIGNhbl9zd2FwKTsKKwlp bmNfbWF4X3NlcShscnV2ZWMsIGNhbl9zd2FwLCBmb3JjZV9zY2FuKTsKIAkvKiBlaXRoZXIgdGhp cyBzZWVzIGFueSB3YWl0ZXJzIG9yIHRoZXkgd2lsbCBzZWUgdXBkYXRlZCBtYXhfc2VxICovCiAJ aWYgKHdxX2hhc19zbGVlcGVyKCZscnV2ZWMtPm1tX3N0YXRlLndhaXQpKQogCQl3YWtlX3VwX2Fs bCgmbHJ1dmVjLT5tbV9zdGF0ZS53YWl0KTsKQEAgLTQzMTcsNyArNDM0OSw3IEBAIHN0YXRpYyBi b29sIGFnZV9scnV2ZWMoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCBzdHJ1Y3Qgc2Nhbl9jb250cm9s ICpzYywKIAkJbnJfdG9fc2NhbisrOwogCiAJaWYgKG5yX3RvX3NjYW4gJiYgbmVlZF9hZ2luZykK LQkJdHJ5X3RvX2luY19tYXhfc2VxKGxydXZlYywgbWF4X3NlcSwgc2MsIHN3YXBwaW5lc3MpOwor CQl0cnlfdG9faW5jX21heF9zZXEobHJ1dmVjLCBtYXhfc2VxLCBzYywgc3dhcHBpbmVzcywgZmFs c2UpOwogCiAJcmV0dXJuIHRydWU7CiB9CkBAIC00ODg3LDcgKzQ5MTksNyBAQCBzdGF0aWMgbG9u ZyBnZXRfbnJfdG9fc2NhbihzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRy b2wgKnNjLCBib29sCiAJCXJldHVybiAwOwogCX0KIAotCWlmICh0cnlfdG9faW5jX21heF9zZXEo bHJ1dmVjLCBtYXhfc2VxLCBzYywgY2FuX3N3YXApKQorCWlmICh0cnlfdG9faW5jX21heF9zZXEo bHJ1dmVjLCBtYXhfc2VxLCBzYywgY2FuX3N3YXAsIGZhbHNlKSkKIAkJcmV0dXJuIG5yX3RvX3Nj YW47CiAKIAlyZXR1cm4gbWluX3NlcVshY2FuX3N3YXBdICsgTUlOX05SX0dFTlMgPD0gbWF4X3Nl cSA/IG5yX3RvX3NjYW4gOiAwOwpAQCAtNTE3NSw2ICs1MjA3LDM1NCBAQCBzdGF0aWMgc3RydWN0 IGF0dHJpYnV0ZV9ncm91cCBscnVfZ2VuX2F0dHJfZ3JvdXAgPSB7CiAJLmF0dHJzID0gbHJ1X2dl bl9hdHRycywKIH07CiAKKy8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKyAqICAgICAgICAgICAgICAg ICAgICAgICAgICBkZWJ1Z2ZzIGludGVyZmFjZQorICoqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KKwor c3RhdGljIHZvaWQgKmxydV9nZW5fc2VxX3N0YXJ0KHN0cnVjdCBzZXFfZmlsZSAqbSwgbG9mZl90 ICpwb3MpCit7CisJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnOworCWxvZmZfdCBucl90b19za2lw ID0gKnBvczsKKworCW0tPnByaXZhdGUgPSBrdm1hbGxvYyhQQVRIX01BWCwgR0ZQX0tFUk5FTCk7 CisJaWYgKCFtLT5wcml2YXRlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCW1lbWNn ID0gbWVtX2Nncm91cF9pdGVyKE5VTEwsIE5VTEwsIE5VTEwpOworCWRvIHsKKwkJaW50IG5pZDsK KworCQlmb3JfZWFjaF9ub2RlX3N0YXRlKG5pZCwgTl9NRU1PUlkpIHsKKwkJCWlmICghbnJfdG9f c2tpcC0tKQorCQkJCXJldHVybiBnZXRfbHJ1dmVjKG1lbWNnLCBuaWQpOworCQl9CisJfSB3aGls ZSAoKG1lbWNnID0gbWVtX2Nncm91cF9pdGVyKE5VTEwsIG1lbWNnLCBOVUxMKSkpOworCisJcmV0 dXJuIE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIGxydV9nZW5fc2VxX3N0b3Aoc3RydWN0IHNlcV9m aWxlICptLCB2b2lkICp2KQoreworCWlmICghSVNfRVJSX09SX05VTEwodikpCisJCW1lbV9jZ3Jv dXBfaXRlcl9icmVhayhOVUxMLCBscnV2ZWNfbWVtY2codikpOworCisJa3ZmcmVlKG0tPnByaXZh dGUpOworCW0tPnByaXZhdGUgPSBOVUxMOworfQorCitzdGF0aWMgdm9pZCAqbHJ1X2dlbl9zZXFf bmV4dChzdHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKnYsIGxvZmZfdCAqcG9zKQoreworCWludCBu aWQgPSBscnV2ZWNfcGdkYXQodiktPm5vZGVfaWQ7CisJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNn ID0gbHJ1dmVjX21lbWNnKHYpOworCisJKysqcG9zOworCisJbmlkID0gbmV4dF9tZW1vcnlfbm9k ZShuaWQpOworCWlmIChuaWQgPT0gTUFYX05VTU5PREVTKSB7CisJCW1lbWNnID0gbWVtX2Nncm91 cF9pdGVyKE5VTEwsIG1lbWNnLCBOVUxMKTsKKwkJaWYgKCFtZW1jZykKKwkJCXJldHVybiBOVUxM OworCisJCW5pZCA9IGZpcnN0X21lbW9yeV9ub2RlOworCX0KKworCXJldHVybiBnZXRfbHJ1dmVj KG1lbWNnLCBuaWQpOworfQorCitzdGF0aWMgdm9pZCBscnVfZ2VuX3NlcV9zaG93X2Z1bGwoc3Ry dWN0IHNlcV9maWxlICptLCBzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsCisJCQkJICB1bnNpZ25lZCBs b25nIG1heF9zZXEsIHVuc2lnbmVkIGxvbmcgKm1pbl9zZXEsCisJCQkJICB1bnNpZ25lZCBsb25n IHNlcSkKK3sKKwlpbnQgaTsKKwlpbnQgdHlwZSwgdGllcjsKKwlpbnQgaGlzdCA9IGxydV9oaXN0 X2Zyb21fc2VxKHNlcSk7CisJc3RydWN0IGxydV9nZW5fc3RydWN0ICpscnVnZW4gPSAmbHJ1dmVj LT5scnVnZW47CisKKwlmb3IgKHRpZXIgPSAwOyB0aWVyIDwgTUFYX05SX1RJRVJTOyB0aWVyKysp IHsKKwkJc2VxX3ByaW50ZihtLCAiICAgICAgICAgICAgJTEwZCIsIHRpZXIpOworCQlmb3IgKHR5 cGUgPSAwOyB0eXBlIDwgQU5PTl9BTkRfRklMRTsgdHlwZSsrKSB7CisJCQl1bnNpZ25lZCBsb25n IG5bM10gPSB7fTsKKworCQkJaWYgKHNlcSA9PSBtYXhfc2VxKSB7CisJCQkJblswXSA9IFJFQURf T05DRShscnVnZW4tPmF2Z19yZWZhdWx0ZWRbdHlwZV1bdGllcl0pOworCQkJCW5bMV0gPSBSRUFE X09OQ0UobHJ1Z2VuLT5hdmdfdG90YWxbdHlwZV1bdGllcl0pOworCisJCQkJc2VxX3ByaW50Ziht LCAiICUxMGx1UiAlMTBsdVQgJTEwbHUgIiwgblswXSwgblsxXSwgblsyXSk7CisJCQl9IGVsc2Ug aWYgKHNlcSA9PSBtaW5fc2VxW3R5cGVdIHx8IE5SX0hJU1RfR0VOUyA+IDEpIHsKKwkJCQluWzBd ID0gYXRvbWljX2xvbmdfcmVhZCgmbHJ1Z2VuLT5yZWZhdWx0ZWRbaGlzdF1bdHlwZV1bdGllcl0p OworCQkJCW5bMV0gPSBhdG9taWNfbG9uZ19yZWFkKCZscnVnZW4tPmV2aWN0ZWRbaGlzdF1bdHlw ZV1bdGllcl0pOworCQkJCWlmICh0aWVyKQorCQkJCQluWzJdID0gUkVBRF9PTkNFKGxydWdlbi0+ cHJvdGVjdGVkW2hpc3RdW3R5cGVdW3RpZXIgLSAxXSk7CisKKwkJCQlzZXFfcHJpbnRmKG0sICIg JTEwbHVyICUxMGx1ZSAlMTBsdXAiLCBuWzBdLCBuWzFdLCBuWzJdKTsKKwkJCX0gZWxzZQorCQkJ CXNlcV9wdXRzKG0sICIgICAgICAgICAgMCAgICAgICAgICAgMCAgICAgICAgICAgMCAiKTsKKwkJ fQorCQlzZXFfcHV0YyhtLCAnXG4nKTsKKwl9CisKKwlzZXFfcHV0cyhtLCAiICAgICAgICAgICAg ICAgICAgICAgICIpOworCWZvciAoaSA9IDA7IGkgPCBOUl9NTV9TVEFUUzsgaSsrKSB7CisJCWlm IChzZXEgPT0gbWF4X3NlcSAmJiBOUl9ISVNUX0dFTlMgPT0gMSkKKwkJCXNlcV9wcmludGYobSwg IiAlMTBsdSVjIiwgUkVBRF9PTkNFKGxydXZlYy0+bW1fc3RhdGUuc3RhdHNbaGlzdF1baV0pLAor CQkJCSAgIHRvdXBwZXIoTU1fU1RBVF9DT0RFU1tpXSkpOworCQllbHNlIGlmIChzZXEgIT0gbWF4 X3NlcSAmJiBOUl9ISVNUX0dFTlMgPiAxKQorCQkJc2VxX3ByaW50ZihtLCAiICUxMGx1JWMiLCBS RUFEX09OQ0UobHJ1dmVjLT5tbV9zdGF0ZS5zdGF0c1toaXN0XVtpXSksCisJCQkJICAgTU1fU1RB VF9DT0RFU1tpXSk7CisJCWVsc2UKKwkJCXNlcV9wdXRzKG0sICIgICAgICAgICAgMCAiKTsKKwl9 CisJc2VxX3B1dGMobSwgJ1xuJyk7Cit9CisKK3N0YXRpYyBpbnQgbHJ1X2dlbl9zZXFfc2hvdyhz dHJ1Y3Qgc2VxX2ZpbGUgKm0sIHZvaWQgKnYpCit7CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9v bCBmdWxsID0gIWRlYnVnZnNfcmVhbF9mb3BzKG0tPmZpbGUpLT53cml0ZTsKKwlzdHJ1Y3QgbHJ1 dmVjICpscnV2ZWMgPSB2OworCXN0cnVjdCBscnVfZ2VuX3N0cnVjdCAqbHJ1Z2VuID0gJmxydXZl Yy0+bHJ1Z2VuOworCWludCBuaWQgPSBscnV2ZWNfcGdkYXQobHJ1dmVjKS0+bm9kZV9pZDsKKwlz dHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cgPSBscnV2ZWNfbWVtY2cobHJ1dmVjKTsKKwlERUZJTkVf TUFYX1NFUShscnV2ZWMpOworCURFRklORV9NSU5fU0VRKGxydXZlYyk7CisKKwlpZiAobmlkID09 IGZpcnN0X21lbW9yeV9ub2RlKSB7CisJCWNvbnN0IGNoYXIgKnBhdGggPSBtZW1jZyA/IG0tPnBy aXZhdGUgOiAiIjsKKworI2lmZGVmIENPTkZJR19NRU1DRworCQlpZiAobWVtY2cpCisJCQljZ3Jv dXBfcGF0aChtZW1jZy0+Y3NzLmNncm91cCwgbS0+cHJpdmF0ZSwgUEFUSF9NQVgpOworI2VuZGlm CisJCXNlcV9wcmludGYobSwgIm1lbWNnICU1aHUgJXNcbiIsIG1lbV9jZ3JvdXBfaWQobWVtY2cp LCBwYXRoKTsKKwl9CisKKwlzZXFfcHJpbnRmKG0sICIgbm9kZSAlNWRcbiIsIG5pZCk7CisKKwlp ZiAoIWZ1bGwpCisJCXNlcSA9IG1pbl9zZXFbTFJVX0dFTl9BTk9OXTsKKwllbHNlIGlmIChtYXhf c2VxID49IE1BWF9OUl9HRU5TKQorCQlzZXEgPSBtYXhfc2VxIC0gTUFYX05SX0dFTlMgKyAxOwor CWVsc2UKKwkJc2VxID0gMDsKKworCWZvciAoOyBzZXEgPD0gbWF4X3NlcTsgc2VxKyspIHsKKwkJ aW50IHR5cGUsIHpvbmU7CisJCWludCBnZW4gPSBscnVfZ2VuX2Zyb21fc2VxKHNlcSk7CisJCXVu c2lnbmVkIGxvbmcgYmlydGggPSBSRUFEX09OQ0UobHJ1dmVjLT5scnVnZW4udGltZXN0YW1wc1tn ZW5dKTsKKworCQlzZXFfcHJpbnRmKG0sICIgJTEwbHUgJTEwdSIsIHNlcSwgamlmZmllc190b19t c2VjcyhqaWZmaWVzIC0gYmlydGgpKTsKKworCQlmb3IgKHR5cGUgPSAwOyB0eXBlIDwgQU5PTl9B TkRfRklMRTsgdHlwZSsrKSB7CisJCQlsb25nIHNpemUgPSAwOworCQkJY2hhciBtYXJrID0gZnVs bCAmJiBzZXEgPCBtaW5fc2VxW3R5cGVdID8gJ3gnIDogJyAnOworCisJCQlmb3IgKHpvbmUgPSAw OyB6b25lIDwgTUFYX05SX1pPTkVTOyB6b25lKyspCisJCQkJc2l6ZSArPSBSRUFEX09OQ0UobHJ1 Z2VuLT5ucl9wYWdlc1tnZW5dW3R5cGVdW3pvbmVdKTsKKworCQkJc2VxX3ByaW50ZihtLCAiICUx MGx1JWMiLCBtYXgoc2l6ZSwgMEwpLCBtYXJrKTsKKwkJfQorCisJCXNlcV9wdXRjKG0sICdcbicp OworCisJCWlmIChmdWxsKQorCQkJbHJ1X2dlbl9zZXFfc2hvd19mdWxsKG0sIGxydXZlYywgbWF4 X3NlcSwgbWluX3NlcSwgc2VxKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0 IHN0cnVjdCBzZXFfb3BlcmF0aW9ucyBscnVfZ2VuX3NlcV9vcHMgPSB7CisJLnN0YXJ0ID0gbHJ1 X2dlbl9zZXFfc3RhcnQsCisJLnN0b3AgPSBscnVfZ2VuX3NlcV9zdG9wLAorCS5uZXh0ID0gbHJ1 X2dlbl9zZXFfbmV4dCwKKwkuc2hvdyA9IGxydV9nZW5fc2VxX3Nob3csCit9OworCitzdGF0aWMg aW50IHJ1bl9hZ2luZyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHVuc2lnbmVkIGxvbmcgc2VxLCBz dHJ1Y3Qgc2Nhbl9jb250cm9sICpzYywKKwkJICAgICBib29sIGNhbl9zd2FwLCBib29sIGZvcmNl X3NjYW4pCit7CisJREVGSU5FX01BWF9TRVEobHJ1dmVjKTsKKwlERUZJTkVfTUlOX1NFUShscnV2 ZWMpOworCisJaWYgKHNlcSA8IG1heF9zZXEpCisJCXJldHVybiAwOworCisJaWYgKHNlcSA+IG1h eF9zZXEgfHwgKCFmb3JjZV9zY2FuICYmIG1pbl9zZXFbIWNhbl9zd2FwXSArIE1BWF9OUl9HRU5T IC0gMSA8PSBtYXhfc2VxKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwl0cnlfdG9faW5jX21heF9z ZXEobHJ1dmVjLCBtYXhfc2VxLCBzYywgY2FuX3N3YXAsIGZvcmNlX3NjYW4pOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgcnVuX2V2aWN0aW9uKHN0cnVjdCBscnV2ZWMgKmxydXZlYywg dW5zaWduZWQgbG9uZyBzZXEsIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjLAorCQkJaW50IHN3YXBw aW5lc3MsIHVuc2lnbmVkIGxvbmcgbnJfdG9fcmVjbGFpbSkKK3sKKwlzdHJ1Y3QgYmxrX3BsdWcg cGx1ZzsKKwlpbnQgZXJyID0gLUVJTlRSOworCURFRklORV9NQVhfU0VRKGxydXZlYyk7CisKKwlp ZiAoc2VxICsgTUlOX05SX0dFTlMgPiBtYXhfc2VxKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXNj LT5ucl9yZWNsYWltZWQgPSAwOworCisJYmxrX3N0YXJ0X3BsdWcoJnBsdWcpOworCisJd2hpbGUg KCFzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgeworCQlERUZJTkVfTUlOX1NFUShscnV2ZWMpOwor CisJCWlmIChzZXEgPCBtaW5fc2VxWyFzd2FwcGluZXNzXSB8fCBzYy0+bnJfcmVjbGFpbWVkID49 IG5yX3RvX3JlY2xhaW0gfHwKKwkJICAgICFldmljdF9mb2xpb3MobHJ1dmVjLCBzYywgc3dhcHBp bmVzcywgTlVMTCkpIHsKKwkJCWVyciA9IDA7CisJCQlicmVhazsKKwkJfQorCisJCWNvbmRfcmVz Y2hlZCgpOworCX0KKworCWJsa19maW5pc2hfcGx1ZygmcGx1Zyk7CisKKwlyZXR1cm4gZXJyOwor fQorCitzdGF0aWMgaW50IHJ1bl9jbWQoY2hhciBjbWQsIGludCBtZW1jZ19pZCwgaW50IG5pZCwg dW5zaWduZWQgbG9uZyBzZXEsCisJCSAgIHN0cnVjdCBzY2FuX2NvbnRyb2wgKnNjLCBpbnQgc3dh cHBpbmVzcywgdW5zaWduZWQgbG9uZyBvcHQpCit7CisJc3RydWN0IGxydXZlYyAqbHJ1dmVjOwor CWludCBlcnIgPSAtRUlOVkFMOworCXN0cnVjdCBtZW1fY2dyb3VwICptZW1jZyA9IE5VTEw7CisK KwlpZiAoIW1lbV9jZ3JvdXBfZGlzYWJsZWQoKSkgeworCQlyY3VfcmVhZF9sb2NrKCk7CisJCW1l bWNnID0gbWVtX2Nncm91cF9mcm9tX2lkKG1lbWNnX2lkKTsKKyNpZmRlZiBDT05GSUdfTUVNQ0cK KwkJaWYgKG1lbWNnICYmICFjc3NfdHJ5Z2V0KCZtZW1jZy0+Y3NzKSkKKwkJCW1lbWNnID0gTlVM TDsKKyNlbmRpZgorCQlyY3VfcmVhZF91bmxvY2soKTsKKworCQlpZiAoIW1lbWNnKQorCQkJZ290 byBkb25lOworCX0KKwlpZiAobWVtY2dfaWQgIT0gbWVtX2Nncm91cF9pZChtZW1jZykpCisJCWdv dG8gZG9uZTsKKworCWlmIChuaWQgPCAwIHx8IG5pZCA+PSBNQVhfTlVNTk9ERVMgfHwgIW5vZGVf c3RhdGUobmlkLCBOX01FTU9SWSkpCisJCWdvdG8gZG9uZTsKKworCWxydXZlYyA9IGdldF9scnV2 ZWMobWVtY2csIG5pZCk7CisKKwlpZiAoc3dhcHBpbmVzcyA8IDApCisJCXN3YXBwaW5lc3MgPSBn ZXRfc3dhcHBpbmVzcyhscnV2ZWMsIHNjKTsKKwllbHNlIGlmIChzd2FwcGluZXNzID4gMjAwKQor CQlnb3RvIGRvbmU7CisKKwlzd2l0Y2ggKGNtZCkgeworCWNhc2UgJysnOgorCQllcnIgPSBydW5f YWdpbmcobHJ1dmVjLCBzZXEsIHNjLCBzd2FwcGluZXNzLCBvcHQpOworCQlicmVhazsKKwljYXNl ICctJzoKKwkJZXJyID0gcnVuX2V2aWN0aW9uKGxydXZlYywgc2VxLCBzYywgc3dhcHBpbmVzcywg b3B0KTsKKwkJYnJlYWs7CisJfQorZG9uZToKKwltZW1fY2dyb3VwX3B1dChtZW1jZyk7CisKKwly ZXR1cm4gZXJyOworfQorCitzdGF0aWMgc3NpemVfdCBscnVfZ2VuX3NlcV93cml0ZShzdHJ1Y3Qg ZmlsZSAqZmlsZSwgY29uc3QgY2hhciBfX3VzZXIgKnNyYywKKwkJCQkgc2l6ZV90IGxlbiwgbG9m Zl90ICpwb3MpCit7CisJdm9pZCAqYnVmOworCWNoYXIgKmN1ciwgKm5leHQ7CisJdW5zaWduZWQg aW50IGZsYWdzOworCWludCBlcnIgPSAwOworCXN0cnVjdCBzY2FuX2NvbnRyb2wgc2MgPSB7CisJ CS5tYXlfd3JpdGVwYWdlID0gdHJ1ZSwKKwkJLm1heV91bm1hcCA9IHRydWUsCisJCS5tYXlfc3dh cCA9IHRydWUsCisJCS5yZWNsYWltX2lkeCA9IE1BWF9OUl9aT05FUyAtIDEsCisJCS5nZnBfbWFz ayA9IEdGUF9LRVJORUwsCisJfTsKKworCWJ1ZiA9IGt2bWFsbG9jKGxlbiArIDEsIEdGUF9LRVJO RUwpOworCWlmICghYnVmKQorCQlyZXR1cm4gLUVOT01FTTsKKworCWlmIChjb3B5X2Zyb21fdXNl cihidWYsIHNyYywgbGVuKSkgeworCQlrdmZyZWUoYnVmKTsKKwkJcmV0dXJuIC1FRkFVTFQ7CisJ fQorCisJbmV4dCA9IGJ1ZjsKKwluZXh0W2xlbl0gPSAnXDAnOworCisJc2MucmVjbGFpbV9zdGF0 ZS5tbV93YWxrID0gYWxsb2NfbW1fd2FsaygpOworCWlmICghc2MucmVjbGFpbV9zdGF0ZS5tbV93 YWxrKSB7CisJCWt2ZnJlZShidWYpOworCQlyZXR1cm4gLUVOT01FTTsKKwl9CisKKwlzZXRfdGFz a19yZWNsYWltX3N0YXRlKGN1cnJlbnQsICZzYy5yZWNsYWltX3N0YXRlKTsKKwlmbGFncyA9IG1l bWFsbG9jX25vcmVjbGFpbV9zYXZlKCk7CisKKwl3aGlsZSAoKGN1ciA9IHN0cnNlcCgmbmV4dCwg Iiw7XG4iKSkpIHsKKwkJaW50IG47CisJCWludCBlbmQ7CisJCWNoYXIgY21kOworCQl1bnNpZ25l ZCBpbnQgbWVtY2dfaWQ7CisJCXVuc2lnbmVkIGludCBuaWQ7CisJCXVuc2lnbmVkIGxvbmcgc2Vx OworCQl1bnNpZ25lZCBpbnQgc3dhcHBpbmVzcyA9IC0xOworCQl1bnNpZ25lZCBsb25nIG9wdCA9 IC0xOworCisJCWN1ciA9IHNraXBfc3BhY2VzKGN1cik7CisJCWlmICghKmN1cikKKwkJCWNvbnRp bnVlOworCisJCW4gPSBzc2NhbmYoY3VyLCAiJWMgJXUgJXUgJWx1ICVuICV1ICVuICVsdSAlbiIs ICZjbWQsICZtZW1jZ19pZCwgJm5pZCwKKwkJCSAgICZzZXEsICZlbmQsICZzd2FwcGluZXNzLCAm ZW5kLCAmb3B0LCAmZW5kKTsKKwkJaWYgKG4gPCA0IHx8IGN1cltlbmRdKSB7CisJCQllcnIgPSAt RUlOVkFMOworCQkJYnJlYWs7CisJCX0KKworCQllcnIgPSBydW5fY21kKGNtZCwgbWVtY2dfaWQs IG5pZCwgc2VxLCAmc2MsIHN3YXBwaW5lc3MsIG9wdCk7CisJCWlmIChlcnIpCisJCQlicmVhazsK Kwl9CisKKwltZW1hbGxvY19ub3JlY2xhaW1fcmVzdG9yZShmbGFncyk7CisJc2V0X3Rhc2tfcmVj bGFpbV9zdGF0ZShjdXJyZW50LCBOVUxMKTsKKworCWZyZWVfbW1fd2FsayhzYy5yZWNsYWltX3N0 YXRlLm1tX3dhbGspOworCWt2ZnJlZShidWYpOworCisJcmV0dXJuIGVyciA/IDogbGVuOworfQor CitzdGF0aWMgaW50IGxydV9nZW5fc2VxX29wZW4oc3RydWN0IGlub2RlICppbm9kZSwgc3RydWN0 IGZpbGUgKmZpbGUpCit7CisJcmV0dXJuIHNlcV9vcGVuKGZpbGUsICZscnVfZ2VuX3NlcV9vcHMp OworfQorCitzdGF0aWMgY29uc3Qgc3RydWN0IGZpbGVfb3BlcmF0aW9ucyBscnVfZ2VuX3J3X2Zv cHMgPSB7CisJLm9wZW4gPSBscnVfZ2VuX3NlcV9vcGVuLAorCS5yZWFkID0gc2VxX3JlYWQsCisJ LndyaXRlID0gbHJ1X2dlbl9zZXFfd3JpdGUsCisJLmxsc2VlayA9IHNlcV9sc2VlaywKKwkucmVs ZWFzZSA9IHNlcV9yZWxlYXNlLAorfTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJh dGlvbnMgbHJ1X2dlbl9yb19mb3BzID0geworCS5vcGVuID0gbHJ1X2dlbl9zZXFfb3BlbiwKKwku cmVhZCA9IHNlcV9yZWFkLAorCS5sbHNlZWsgPSBzZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzZXFf cmVsZWFzZSwKK307CisKIC8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAqICAgICAgICAgICAgICAg ICAgICAgICAgICBpbml0aWFsaXphdGlvbgogICoqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KQEAgLTUy MzMsNiArNTYxMyw5IEBAIHN0YXRpYyBpbnQgX19pbml0IGluaXRfbHJ1X2dlbih2b2lkKQogCWlm IChzeXNmc19jcmVhdGVfZ3JvdXAobW1fa29iaiwgJmxydV9nZW5fYXR0cl9ncm91cCkpCiAJCXBy X2VycigibHJ1X2dlbjogZmFpbGVkIHRvIGNyZWF0ZSBzeXNmcyBncm91cFxuIik7CiAKKwlkZWJ1 Z2ZzX2NyZWF0ZV9maWxlKCJscnVfZ2VuIiwgMDY0NCwgTlVMTCwgTlVMTCwgJmxydV9nZW5fcndf Zm9wcyk7CisJZGVidWdmc19jcmVhdGVfZmlsZSgibHJ1X2dlbl9mdWxsIiwgMDQ0NCwgTlVMTCwg TlVMTCwgJmxydV9nZW5fcm9fZm9wcyk7CisKIAlyZXR1cm4gMDsKIH07CiBsYXRlX2luaXRjYWxs KGluaXRfbHJ1X2dlbik7Ci0tIAoyLjM2LjAuNTUwLmdiMDkwODUxNzA4LWdvb2cKCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVs IG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg==