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 1E769C25B0D for ; Mon, 15 Aug 2022 07:15:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S241680AbiHOHPn (ORCPT ); Mon, 15 Aug 2022 03:15:43 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:46796 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S241488AbiHOHPG (ORCPT ); Mon, 15 Aug 2022 03:15:06 -0400 Received: from mail-yb1-xb4a.google.com (mail-yb1-xb4a.google.com [IPv6:2607:f8b0:4864:20::b4a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4BBB71D0E8 for ; Mon, 15 Aug 2022 00:14:32 -0700 (PDT) Received: by mail-yb1-xb4a.google.com with SMTP id 137-20020a250b8f000000b0067a5a14d730so5419325ybl.12 for ; Mon, 15 Aug 2022 00:14:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:from:to:cc; bh=lOThpciqwDr+maZvkuw/8oEObhVxBBpJFcET3LtOyf0=; b=eEGG2IalZh3dKx23yxkkI3pf4gxP77pG6ifTJvYD56ChawSX+T1p9ljO9YiYZU41Nq t5Lx/faj5TdQuxQaF9PhBFPk+pWcLj4wAOblk1yuQv7HEOt05sUDLNFeHqWESFAXFbcc eLaB/Ayom3HntiyRbQEgv/gxrUs9LCDrFF94tOxHrvmvj6mlX3yXhfyDgzUhkFMy5O+G IB+WWM63letFmNRvkjmV2GzAKhGOU0H+TSaHmn8E0CRwrXU6qyeYH2hymXprgk+qKbaZ m/Iak7lk4zYsDZDv/Wr8kIVvoSfwvl3TPTPQ3iTM17tYtcU/bZPWICGcO7Z765L3GlJv nd4g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:x-gm-message-state:from:to :cc; bh=lOThpciqwDr+maZvkuw/8oEObhVxBBpJFcET3LtOyf0=; b=zrGRrhuofstoXc24AUpNAyUiTQotOdikyhqTfJFjMSuvnK3vVFwwzGa/cf0WQ52vs/ NTuwxCJ4k7mzxpQkrQgfdQ9In04W7cJCoQSL5WP4FrI499VFlTQ1uwLzPyapSSX2ewzJ ZGCmk+Oq3mXzjxoKTcRtYjkaTHq7+AjgDDu5eQw+qsmfn14hncH1ueana3W5ZI89LqXG 5TT7AFoRDu26L8m50FYypMGX/iz1MOAOt5bBE+xTaJB/X8171zBGOq3q1N3QuosTeMNO 9dGwEDg/xW7VI44nFwgpwGEcAWyLUagqaH7Ak3lZn4+AApQ6P+ZIpCQyMbwhizyRb5fi INiQ== X-Gm-Message-State: ACgBeo32vTF6FbYVVbN/XzhLHZ30weF9qBckFZHMRSUKnoqbaEQJRsSn Vj8ka1NclHg1bIyoJHwjZtHWFdowrho= X-Google-Smtp-Source: AA6agR5ncNG8veoSEEXX1Gf7Bfsqr9zsFBHLkr3H6YSOuL4oTs3hAUMfMQtHQsfsfADHlhXDhVjdEf7v81s= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:d91:5887:ac93:ddf0]) (user=yuzhao job=sendgmr) by 2002:a25:1c4:0:b0:67b:fc58:7a79 with SMTP id 187-20020a2501c4000000b0067bfc587a79mr11126744ybb.403.1660547671274; Mon, 15 Aug 2022 00:14:31 -0700 (PDT) Date: Mon, 15 Aug 2022 01:13:31 -0600 In-Reply-To: <20220815071332.627393-1-yuzhao@google.com> Message-Id: <20220815071332.627393-13-yuzhao@google.com> Mime-Version: 1.0 References: <20220815071332.627393-1-yuzhao@google.com> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog Subject: [PATCH v14 12/14] mm: multi-gen LRU: debugfs interface From: Yu Zhao To: Andrew Morton 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, linux-mm@kvack.org, x86@kernel.org, page-reclaim@google.com, Yu Zhao , Qi Zheng , 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 Reviewed-by: Qi Zheng 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 | 411 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 402 insertions(+), 10 deletions(-) diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h index 4b71a96190a8..3a0eec9f2faa 100644 --- a/include/linux/nodemask.h +++ b/include/linux/nodemask.h @@ -493,6 +493,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 08727f3b7171..509989fb39ef 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -52,6 +52,7 @@ #include #include #include +#include =20 #include #include @@ -4202,12 +4203,40 @@ static void clear_mm_walk(void) 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; + + /* prevent cold/hot inversion if force_scan is true */ + 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) @@ -4253,7 +4282,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; @@ -4267,9 +4296,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 /* @@ -4306,7 +4339,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; @@ -4327,7 +4360,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; } @@ -4341,7 +4374,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); @@ -4361,7 +4394,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); @@ -4460,7 +4493,7 @@ static bool age_lruvec(struct lruvec *lruvec, struct = scan_control *sc, unsigned } =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; } @@ -5041,7 +5074,7 @@ static unsigned long get_nr_to_scan(struct lruvec *lr= uvec, struct scan_control * if (current_is_kswapd()) 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; done: return min_seq[!can_swap] + MIN_NR_GENS <=3D max_seq ? nr_to_scan : 0; @@ -5330,6 +5363,361 @@ 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++) { + const char *s =3D " "; + unsigned long n[3] =3D {}; + + if (seq =3D=3D max_seq) { + s =3D "RT "; + n[0] =3D READ_ONCE(lrugen->avg_refaulted[type][tier]); + n[1] =3D READ_ONCE(lrugen->avg_total[type][tier]); + } else if (seq =3D=3D min_seq[type] || NR_HIST_GENS > 1) { + s =3D "rep"; + 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]); + } + + for (i =3D 0; i < 3; i++) + seq_printf(m, " %10lu%c", n[i], s[i]); + } + seq_putc(m, '\n'); + } + + seq_puts(m, " "); + for (i =3D 0; i < NR_MM_STATS; i++) { + const char *s =3D " "; + unsigned long n =3D 0; + + if (seq =3D=3D max_seq && NR_HIST_GENS =3D=3D 1) { + s =3D "LOYNFA"; + n =3D READ_ONCE(lruvec->mm_state.stats[hist][i]); + } else if (seq !=3D max_seq && NR_HIST_GENS > 1) { + s =3D "loynfa"; + n =3D READ_ONCE(lruvec->mm_state.stats[hist][i]); + } + + seq_printf(m, " %10lu%c", n, s[i]); + } + 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++) { + unsigned long size =3D 0; + char mark =3D full && seq < min_seq[type] ? 'x' : ' '; + + for (zone =3D 0; zone < MAX_NR_ZONES; zone++) + size +=3D max(READ_ONCE(lrugen->nr_pages[gen][type][zone]), 0L); + + seq_printf(m, " %10lu%c", size, 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) + return -EINVAL; + + if (!force_scan && min_seq[!can_swap] + MAX_NR_GENS - 1 <=3D max_seq) + return -ERANGE; + + 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) +{ + DEFINE_MAX_SEQ(lruvec); + + if (seq + MIN_NR_GENS > max_seq) + return -EINVAL; + + sc->nr_reclaimed =3D 0; + + while (!signal_pending(current)) { + DEFINE_MIN_SEQ(lruvec); + + if (seq < min_seq[!swappiness]) + return 0; + + if (sc->nr_reclaimed >=3D nr_to_reclaim) + return 0; + + if (!evict_folios(lruvec, sc, swappiness, NULL)) + return 0; + + cond_resched(); + } + + return -EINTR; +} + +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 (nid < 0 || nid >=3D MAX_NUMNODES || !node_state(nid, N_MEMORY)) + return -EINVAL; + + 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) + return -EINVAL; + } + + if (memcg_id !=3D mem_cgroup_id(memcg)) + 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; + struct blk_plug plug; + int err =3D -EINVAL; + 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; + } + + set_task_reclaim_state(current, &sc.reclaim_state); + flags =3D memalloc_noreclaim_save(); + blk_start_plug(&plug); + if (!set_mm_walk(NULL)) { + err =3D -ENOMEM; + goto done; + } + + next =3D buf; + next[len] =3D '\0'; + + 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; + } +done: + clear_mm_walk(); + blk_finish_plug(&plug); + memalloc_noreclaim_restore(flags); + set_task_reclaim_state(current, NULL); + + 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 *************************************************************************= *****/ @@ -5387,6 +5775,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.37.1.595.g718a3a8f04-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 BD07DC25B0E for ; Mon, 15 Aug 2022 07:50:38 +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=sR0oqPiDgCwa0AuiRo1Oi5VG9vTVlezyUxOMINMtpnU=; b=xnW5WHpJaBcOsez+zHA5NpkcH+ HHGZbSz4H/7urB/UXSEK8lYV7LhQN5DZM0o2REYndXwHdYgABgmoh1t7+L8b/cCw4Hlknm2W6Eo9W ucEchol3ew5jtWb+3dDOKCueQWdZzv6/zlCeYh/uUdNGqnWKjqXh9d/qhpnBXmvNlbaqM6Ffl0Mvu jtn3kRRAchXPsZCkbOJlPn/12Pde9t2aPRN3ykmm4PQSkxcCtqFp9XmjAuXco+P/AfnSW/xwJtNnK RvHDmSc/32QqYeHT2t1aXJqVMvPqxbkJ+xu/AkuFw+9UkTvpCJ1kBEZtallQOUbg1TSHhOFawwq2n /QLhao6w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oNUqN-00ClPN-8u; Mon, 15 Aug 2022 07:49:05 +0000 Received: from desiato.infradead.org ([90.155.92.199]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oNUpC-00CkVD-Oi for linux-arm-kernel@bombadil.infradead.org; Mon, 15 Aug 2022 07:47:51 +0000 DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=infradead.org; s=desiato.20200630; h=Content-Transfer-Encoding:Content-Type :Cc:To:From:Subject:References:Mime-Version:Message-Id:In-Reply-To:Date: Sender:Reply-To:Content-ID:Content-Description; bh=lOThpciqwDr+maZvkuw/8oEObhVxBBpJFcET3LtOyf0=; b=IWZaDSYuE5xWDEvuuLeWVepdZT pITkYrOtIuWlK3+SVx1KC0Oqe5PxF52W+XWIWN2SZ8GL96Ke3UkD+VrlyhsFgfoh0dmmu5bCtCPtC 7MdL9aSIf8i/TkFB2lLsJVr/UGaHrtCJvkesspn2A7b5DfiXzFvZLkZr+g3m2a2r6QGNWZ6mIdh01 SmdB0xDaT2ZVw70Z2n8q7Jo8C9+LuwMQunjHikrDa0smyg8FELJTkbyOZuvfAXWL/2JW75QBJCMAG F/2pEn/xsZLNJ5VArSVY4O8n90k1q8o1sKU4X9CAy7ttlDmWBaH4fPy+mSgwAoIL+abH6PYuiPiSY DW5dkykw==; Received: from mail-yb1-xb4a.google.com ([2607:f8b0:4864:20::b4a]) by desiato.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oNUIz-002bhQ-FP for linux-arm-kernel@lists.infradead.org; Mon, 15 Aug 2022 07:14:40 +0000 Received: by mail-yb1-xb4a.google.com with SMTP id i194-20020a253bcb000000b00676d86fc5d7so5363234yba.9 for ; Mon, 15 Aug 2022 00:14:32 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:from:to:cc; bh=lOThpciqwDr+maZvkuw/8oEObhVxBBpJFcET3LtOyf0=; b=eEGG2IalZh3dKx23yxkkI3pf4gxP77pG6ifTJvYD56ChawSX+T1p9ljO9YiYZU41Nq t5Lx/faj5TdQuxQaF9PhBFPk+pWcLj4wAOblk1yuQv7HEOt05sUDLNFeHqWESFAXFbcc eLaB/Ayom3HntiyRbQEgv/gxrUs9LCDrFF94tOxHrvmvj6mlX3yXhfyDgzUhkFMy5O+G IB+WWM63letFmNRvkjmV2GzAKhGOU0H+TSaHmn8E0CRwrXU6qyeYH2hymXprgk+qKbaZ m/Iak7lk4zYsDZDv/Wr8kIVvoSfwvl3TPTPQ3iTM17tYtcU/bZPWICGcO7Z765L3GlJv nd4g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=content-transfer-encoding:cc:to:from:subject:references :mime-version:message-id:in-reply-to:date:x-gm-message-state:from:to :cc; bh=lOThpciqwDr+maZvkuw/8oEObhVxBBpJFcET3LtOyf0=; b=RcOFnUGQ7NeIcs7m0HoPrrgNhDUy81YA1xNk4N4f1ORLbyzTM5+fKG5F/7k/dEsxoz boOxmI9/8azCvXWV8J0a2sZFXwftzn7+WlLHNFqeJCK4n4eTFdubXQwwTXfVnPa+Wuz2 jK/eHFZHQcy4ZYE67TaG1p0C0yF54eNJbDV/mFxF1nDyKpTEKswl2cv3+6u+67iIl41c VB3Aha8ObmexsH33+vs96wRL3374j11MvFPoV62SFh9XRoUeOprQKxdlM///lftgrWGS eFSMzCiFUMS9LaIiH5pwiYgZOI/grHDEunOYJGvajhUiKMkYOfX9AJr3NigeSVqQYvWi m3vg== X-Gm-Message-State: ACgBeo09qnJb2mr9OmdrmUWptcoroSgy2cm2aVQzXbxFXNtKSXyTHsnw EJHQIeJSh5tF4avTLxkphFLzP/JaZ30= X-Google-Smtp-Source: AA6agR5ncNG8veoSEEXX1Gf7Bfsqr9zsFBHLkr3H6YSOuL4oTs3hAUMfMQtHQsfsfADHlhXDhVjdEf7v81s= X-Received: from yuzhao.bld.corp.google.com ([2620:15c:183:200:d91:5887:ac93:ddf0]) (user=yuzhao job=sendgmr) by 2002:a25:1c4:0:b0:67b:fc58:7a79 with SMTP id 187-20020a2501c4000000b0067bfc587a79mr11126744ybb.403.1660547671274; Mon, 15 Aug 2022 00:14:31 -0700 (PDT) Date: Mon, 15 Aug 2022 01:13:31 -0600 In-Reply-To: <20220815071332.627393-1-yuzhao@google.com> Message-Id: <20220815071332.627393-13-yuzhao@google.com> Mime-Version: 1.0 References: <20220815071332.627393-1-yuzhao@google.com> X-Mailer: git-send-email 2.37.1.595.g718a3a8f04-goog Subject: [PATCH v14 12/14] mm: multi-gen LRU: debugfs interface From: Yu Zhao To: Andrew Morton 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, linux-mm@kvack.org, x86@kernel.org, page-reclaim@google.com, Yu Zhao , Qi Zheng , 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-20220815_081434_118082_636AA720 X-CRM114-Status: GOOD ( 23.62 ) 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+ClJldmlld2Vk LWJ5OiBRaSBaaGVuZyA8emhlbmdxaS5hcmNoQGJ5dGVkYW5jZS5jb20+CkFja2VkLWJ5OiBCcmlh biBHZWZmb24gPGJnZWZmb25AZ29vZ2xlLmNvbT4KQWNrZWQtYnk6IEphbiBBbGV4YW5kZXIgU3Rl ZmZlbnMgKGhlZnRpZykgPGhlZnRpZ0BhcmNobGludXgub3JnPgpBY2tlZC1ieTogT2xla3NhbmRy IE5hdGFsZW5rbyA8b2xla3NhbmRyQG5hdGFsZW5rby5uYW1lPgpBY2tlZC1ieTogU3RldmVuIEJh cnJldHQgPHN0ZXZlbkBsaXF1b3JpeC5uZXQ+CkFja2VkLWJ5OiBTdWxlaW1hbiBTb3VobGFsIDxz dWxlaW1hbkBnb29nbGUuY29tPgpUZXN0ZWQtYnk6IERhbmllbCBCeXJuZSA8ZGpieXJuZUBtdHUu ZWR1PgpUZXN0ZWQtYnk6IERvbmFsZCBDYXJyIDxkQGNoYW9zLXJlaW5zLmNvbT4KVGVzdGVkLWJ5 OiBIb2xnZXIgSG9mZnN0w6R0dGUgPGhvbGdlckBhcHBsaWVkLWFzeW5jaHJvbnkuY29tPgpUZXN0 ZWQtYnk6IEtvbnN0YW50aW4gS2hhcmxhbW92IDxIaS1BbmdlbEB5YW5kZXgucnU+ClRlc3RlZC1i eTogU2h1YW5nIFpoYWkgPHN6aGFpMkBjcy5yb2NoZXN0ZXIuZWR1PgpUZXN0ZWQtYnk6IFNvZmlh IFRyaW5oIDxzb2ZpYS50cmluaEBlZGkud29ya3M+ClRlc3RlZC1ieTogVmFpYmhhdiBKYWluIDx2 YWliaGF2QGxpbnV4LmlibS5jb20+Ci0tLQogaW5jbHVkZS9saW51eC9ub2RlbWFzay5oIHwgICAx ICsKIG1tL3Ztc2Nhbi5jICAgICAgICAgICAgICB8IDQxMSArKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKy0KIDIgZmlsZXMgY2hhbmdlZCwgNDAyIGluc2VydGlvbnMoKyksIDEw IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvbm9kZW1hc2suaCBiL2lu Y2x1ZGUvbGludXgvbm9kZW1hc2suaAppbmRleCA0YjcxYTk2MTkwYTguLjNhMGVlYzlmMmZhYSAx MDA2NDQKLS0tIGEvaW5jbHVkZS9saW51eC9ub2RlbWFzay5oCisrKyBiL2luY2x1ZGUvbGludXgv bm9kZW1hc2suaApAQCAtNDkzLDYgKzQ5Myw3IEBAIHN0YXRpYyBpbmxpbmUgaW50IG51bV9ub2Rl X3N0YXRlKGVudW0gbm9kZV9zdGF0ZXMgc3RhdGUpCiAjZGVmaW5lIGZpcnN0X29ubGluZV9ub2Rl CTAKICNkZWZpbmUgZmlyc3RfbWVtb3J5X25vZGUJMAogI2RlZmluZSBuZXh0X29ubGluZV9ub2Rl KG5pZCkJKE1BWF9OVU1OT0RFUykKKyNkZWZpbmUgbmV4dF9tZW1vcnlfbm9kZShuaWQpCShNQVhf TlVNTk9ERVMpCiAjZGVmaW5lIG5yX25vZGVfaWRzCQkxVQogI2RlZmluZSBucl9vbmxpbmVfbm9k ZXMJCTFVCiAKZGlmZiAtLWdpdCBhL21tL3Ztc2Nhbi5jIGIvbW0vdm1zY2FuLmMKaW5kZXggMDg3 MjdmM2I3MTcxLi41MDk5ODlmYjM5ZWYgMTAwNjQ0Ci0tLSBhL21tL3Ztc2Nhbi5jCisrKyBiL21t L3Ztc2Nhbi5jCkBAIC01Miw2ICs1Miw3IEBACiAjaW5jbHVkZSA8bGludXgvcGFnZXdhbGsuaD4K ICNpbmNsdWRlIDxsaW51eC9zaG1lbV9mcy5oPgogI2luY2x1ZGUgPGxpbnV4L2N0eXBlLmg+Cisj aW5jbHVkZSA8bGludXgvZGVidWdmcy5oPgogCiAjaW5jbHVkZSA8YXNtL3RsYmZsdXNoLmg+CiAj aW5jbHVkZSA8YXNtL2RpdjY0Lmg+CkBAIC00MjAyLDEyICs0MjAzLDQwIEBAIHN0YXRpYyB2b2lk IGNsZWFyX21tX3dhbGsodm9pZCkKIAkJa2ZyZWUod2Fsayk7CiB9CiAKLXN0YXRpYyB2b2lkIGlu Y19taW5fc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgaW50IHR5cGUpCitzdGF0aWMgYm9vbCBp bmNfbWluX3NlcShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIGludCB0eXBlLCBib29sIGNhbl9zd2Fw KQogeworCWludCB6b25lOworCWludCByZW1haW5pbmcgPSBNQVhfTFJVX0JBVENIOwogCXN0cnVj dCBscnVfZ2VuX3N0cnVjdCAqbHJ1Z2VuID0gJmxydXZlYy0+bHJ1Z2VuOworCWludCBuZXdfZ2Vu LCBvbGRfZ2VuID0gbHJ1X2dlbl9mcm9tX3NlcShscnVnZW4tPm1pbl9zZXFbdHlwZV0pOwogCisJ aWYgKHR5cGUgPT0gTFJVX0dFTl9BTk9OICYmICFjYW5fc3dhcCkKKwkJZ290byBkb25lOworCisJ LyogcHJldmVudCBjb2xkL2hvdCBpbnZlcnNpb24gaWYgZm9yY2Vfc2NhbiBpcyB0cnVlICovCisJ Zm9yICh6b25lID0gMDsgem9uZSA8IE1BWF9OUl9aT05FUzsgem9uZSsrKSB7CisJCXN0cnVjdCBs aXN0X2hlYWQgKmhlYWQgPSAmbHJ1Z2VuLT5saXN0c1tvbGRfZ2VuXVt0eXBlXVt6b25lXTsKKwor CQl3aGlsZSAoIWxpc3RfZW1wdHkoaGVhZCkpIHsKKwkJCXN0cnVjdCBmb2xpbyAqZm9saW8gPSBs cnVfdG9fZm9saW8oaGVhZCk7CisKKwkJCVZNX1dBUk5fT05fT05DRV9GT0xJTyhmb2xpb190ZXN0 X3VuZXZpY3RhYmxlKGZvbGlvKSwgZm9saW8pOworCQkJVk1fV0FSTl9PTl9PTkNFX0ZPTElPKGZv bGlvX3Rlc3RfYWN0aXZlKGZvbGlvKSwgZm9saW8pOworCQkJVk1fV0FSTl9PTl9PTkNFX0ZPTElP KGZvbGlvX2lzX2ZpbGVfbHJ1KGZvbGlvKSAhPSB0eXBlLCBmb2xpbyk7CisJCQlWTV9XQVJOX09O X09OQ0VfRk9MSU8oZm9saW9fem9uZW51bShmb2xpbykgIT0gem9uZSwgZm9saW8pOworCisJCQlu ZXdfZ2VuID0gZm9saW9faW5jX2dlbihscnV2ZWMsIGZvbGlvLCBmYWxzZSk7CisJCQlsaXN0X21v dmVfdGFpbCgmZm9saW8tPmxydSwgJmxydWdlbi0+bGlzdHNbbmV3X2dlbl1bdHlwZV1bem9uZV0p OworCisJCQlpZiAoIS0tcmVtYWluaW5nKQorCQkJCXJldHVybiBmYWxzZTsKKwkJfQorCX0KK2Rv bmU6CiAJcmVzZXRfY3RybF9wb3MobHJ1dmVjLCB0eXBlLCB0cnVlKTsKIAlXUklURV9PTkNFKGxy dWdlbi0+bWluX3NlcVt0eXBlXSwgbHJ1Z2VuLT5taW5fc2VxW3R5cGVdICsgMSk7CisKKwlyZXR1 cm4gdHJ1ZTsKIH0KIAogc3RhdGljIGJvb2wgdHJ5X3RvX2luY19taW5fc2VxKHN0cnVjdCBscnV2 ZWMgKmxydXZlYywgYm9vbCBjYW5fc3dhcCkKQEAgLTQyNTMsNyArNDI4Miw3IEBAIHN0YXRpYyBi b29sIHRyeV90b19pbmNfbWluX3NlcShzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIGJvb2wgY2FuX3N3 YXApCiAJcmV0dXJuIHN1Y2Nlc3M7CiB9CiAKLXN0YXRpYyB2b2lkIGluY19tYXhfc2VxKHN0cnVj dCBscnV2ZWMgKmxydXZlYywgYm9vbCBjYW5fc3dhcCkKK3N0YXRpYyB2b2lkIGluY19tYXhfc2Vx KHN0cnVjdCBscnV2ZWMgKmxydXZlYywgYm9vbCBjYW5fc3dhcCwgYm9vbCBmb3JjZV9zY2FuKQog ewogCWludCBwcmV2LCBuZXh0OwogCWludCB0eXBlLCB6b25lOwpAQCAtNDI2Nyw5ICs0Mjk2LDEz IEBAIHN0YXRpYyB2b2lkIGluY19tYXhfc2VxKHN0cnVjdCBscnV2ZWMgKmxydXZlYywgYm9vbCBj YW5fc3dhcCkKIAkJaWYgKGdldF9ucl9nZW5zKGxydXZlYywgdHlwZSkgIT0gTUFYX05SX0dFTlMp CiAJCQljb250aW51ZTsKIAotCQlWTV9XQVJOX09OX09OQ0UodHlwZSA9PSBMUlVfR0VOX0ZJTEUg fHwgY2FuX3N3YXApOworCQlWTV9XQVJOX09OX09OQ0UoIWZvcmNlX3NjYW4gJiYgKHR5cGUgPT0g TFJVX0dFTl9GSUxFIHx8IGNhbl9zd2FwKSk7CiAKLQkJaW5jX21pbl9zZXEobHJ1dmVjLCB0eXBl KTsKKwkJd2hpbGUgKCFpbmNfbWluX3NlcShscnV2ZWMsIHR5cGUsIGNhbl9zd2FwKSkgeworCQkJ c3Bpbl91bmxvY2tfaXJxKCZscnV2ZWMtPmxydV9sb2NrKTsKKwkJCWNvbmRfcmVzY2hlZCgpOwor CQkJc3Bpbl9sb2NrX2lycSgmbHJ1dmVjLT5scnVfbG9jayk7CisJCX0KIAl9CiAKIAkvKgpAQCAt NDMwNiw3ICs0MzM5LDcgQEAgc3RhdGljIHZvaWQgaW5jX21heF9zZXEoc3RydWN0IGxydXZlYyAq bHJ1dmVjLCBib29sIGNhbl9zd2FwKQogfQogCiBzdGF0aWMgYm9vbCB0cnlfdG9faW5jX21heF9z ZXEoc3RydWN0IGxydXZlYyAqbHJ1dmVjLCB1bnNpZ25lZCBsb25nIG1heF9zZXEsCi0JCQkgICAg ICAgc3RydWN0IHNjYW5fY29udHJvbCAqc2MsIGJvb2wgY2FuX3N3YXApCisJCQkgICAgICAgc3Ry dWN0IHNjYW5fY29udHJvbCAqc2MsIGJvb2wgY2FuX3N3YXAsIGJvb2wgZm9yY2Vfc2NhbikKIHsK IAlib29sIHN1Y2Nlc3M7CiAJc3RydWN0IGxydV9nZW5fbW1fd2FsayAqd2FsazsKQEAgLTQzMjcs NyArNDM2MCw3IEBAIHN0YXRpYyBib29sIHRyeV90b19pbmNfbWF4X3NlcShzdHJ1Y3QgbHJ1dmVj ICpscnV2ZWMsIHVuc2lnbmVkIGxvbmcgbWF4X3NlcSwKIAkgKiBoYW5kZnVsIG9mIFBURXMuIFNw cmVhZGluZyB0aGUgd29yayBvdXQgb3ZlciBhIHBlcmlvZCBvZiB0aW1lIHVzdWFsbHkKIAkgKiBp cyBsZXNzIGVmZmljaWVudCwgYnV0IGl0IGF2b2lkcyBidXJzdHkgcGFnZSBmYXVsdHMuCiAJICov Ci0JaWYgKCEoYXJjaF9oYXNfaHdfcHRlX3lvdW5nKCkgJiYgZ2V0X2NhcChMUlVfR0VOX01NX1dB TEspKSkgeworCWlmICghZm9yY2Vfc2NhbiAmJiAhKGFyY2hfaGFzX2h3X3B0ZV95b3VuZygpICYm IGdldF9jYXAoTFJVX0dFTl9NTV9XQUxLKSkpIHsKIAkJc3VjY2VzcyA9IGl0ZXJhdGVfbW1fbGlz dF9ub3dhbGsobHJ1dmVjLCBtYXhfc2VxKTsKIAkJZ290byBkb25lOwogCX0KQEAgLTQzNDEsNyAr NDM3NCw3IEBAIHN0YXRpYyBib29sIHRyeV90b19pbmNfbWF4X3NlcShzdHJ1Y3QgbHJ1dmVjICps cnV2ZWMsIHVuc2lnbmVkIGxvbmcgbWF4X3NlcSwKIAl3YWxrLT5scnV2ZWMgPSBscnV2ZWM7CiAJ d2Fsay0+bWF4X3NlcSA9IG1heF9zZXE7CiAJd2Fsay0+Y2FuX3N3YXAgPSBjYW5fc3dhcDsKLQl3 YWxrLT5mb3JjZV9zY2FuID0gZmFsc2U7CisJd2Fsay0+Zm9yY2Vfc2NhbiA9IGZvcmNlX3NjYW47 CiAKIAlkbyB7CiAJCXN1Y2Nlc3MgPSBpdGVyYXRlX21tX2xpc3QobHJ1dmVjLCB3YWxrLCAmbW0p OwpAQCAtNDM2MSw3ICs0Mzk0LDcgQEAgc3RhdGljIGJvb2wgdHJ5X3RvX2luY19tYXhfc2VxKHN0 cnVjdCBscnV2ZWMgKmxydXZlYywgdW5zaWduZWQgbG9uZyBtYXhfc2VxLAogCiAJVk1fV0FSTl9P Tl9PTkNFKG1heF9zZXEgIT0gUkVBRF9PTkNFKGxydWdlbi0+bWF4X3NlcSkpOwogCi0JaW5jX21h eF9zZXEobHJ1dmVjLCBjYW5fc3dhcCk7CisJaW5jX21heF9zZXEobHJ1dmVjLCBjYW5fc3dhcCwg Zm9yY2Vfc2Nhbik7CiAJLyogZWl0aGVyIHRoaXMgc2VlcyBhbnkgd2FpdGVycyBvciB0aGV5IHdp bGwgc2VlIHVwZGF0ZWQgbWF4X3NlcSAqLwogCWlmICh3cV9oYXNfc2xlZXBlcigmbHJ1dmVjLT5t bV9zdGF0ZS53YWl0KSkKIAkJd2FrZV91cF9hbGwoJmxydXZlYy0+bW1fc3RhdGUud2FpdCk7CkBA IC00NDYwLDcgKzQ0OTMsNyBAQCBzdGF0aWMgYm9vbCBhZ2VfbHJ1dmVjKHN0cnVjdCBscnV2ZWMg KmxydXZlYywgc3RydWN0IHNjYW5fY29udHJvbCAqc2MsIHVuc2lnbmVkCiAJfQogCiAJaWYgKG5y X3RvX3NjYW4gJiYgbmVlZF9hZ2luZykKLQkJdHJ5X3RvX2luY19tYXhfc2VxKGxydXZlYywgbWF4 X3NlcSwgc2MsIHN3YXBwaW5lc3MpOworCQl0cnlfdG9faW5jX21heF9zZXEobHJ1dmVjLCBtYXhf c2VxLCBzYywgc3dhcHBpbmVzcywgZmFsc2UpOwogCiAJcmV0dXJuIHRydWU7CiB9CkBAIC01MDQx LDcgKzUwNzQsNyBAQCBzdGF0aWMgdW5zaWduZWQgbG9uZyBnZXRfbnJfdG9fc2NhbihzdHJ1Y3Qg bHJ1dmVjICpscnV2ZWMsIHN0cnVjdCBzY2FuX2NvbnRyb2wgKgogCWlmIChjdXJyZW50X2lzX2tz d2FwZCgpKQogCQlyZXR1cm4gMDsKIAotCWlmICh0cnlfdG9faW5jX21heF9zZXEobHJ1dmVjLCBt YXhfc2VxLCBzYywgY2FuX3N3YXApKQorCWlmICh0cnlfdG9faW5jX21heF9zZXEobHJ1dmVjLCBt YXhfc2VxLCBzYywgY2FuX3N3YXAsIGZhbHNlKSkKIAkJcmV0dXJuIG5yX3RvX3NjYW47CiBkb25l OgogCXJldHVybiBtaW5fc2VxWyFjYW5fc3dhcF0gKyBNSU5fTlJfR0VOUyA8PSBtYXhfc2VxID8g bnJfdG9fc2NhbiA6IDA7CkBAIC01MzMwLDYgKzUzNjMsMzYxIEBAIHN0YXRpYyBzdHJ1Y3QgYXR0 cmlidXRlX2dyb3VwIGxydV9nZW5fYXR0cl9ncm91cCA9IHsKIAkuYXR0cnMgPSBscnVfZ2VuX2F0 dHJzLAogfTsKIAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogICAgICAgICAgICAgICAgICAg ICAgICAgIGRlYnVnZnMgaW50ZXJmYWNlCisgKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLworCitzdGF0 aWMgdm9pZCAqbHJ1X2dlbl9zZXFfc3RhcnQoc3RydWN0IHNlcV9maWxlICptLCBsb2ZmX3QgKnBv cykKK3sKKwlzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2c7CisJbG9mZl90IG5yX3RvX3NraXAgPSAq cG9zOworCisJbS0+cHJpdmF0ZSA9IGt2bWFsbG9jKFBBVEhfTUFYLCBHRlBfS0VSTkVMKTsKKwlp ZiAoIW0tPnByaXZhdGUpCisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJbWVtY2cgPSBt ZW1fY2dyb3VwX2l0ZXIoTlVMTCwgTlVMTCwgTlVMTCk7CisJZG8geworCQlpbnQgbmlkOworCisJ CWZvcl9lYWNoX25vZGVfc3RhdGUobmlkLCBOX01FTU9SWSkgeworCQkJaWYgKCFucl90b19za2lw LS0pCisJCQkJcmV0dXJuIGdldF9scnV2ZWMobWVtY2csIG5pZCk7CisJCX0KKwl9IHdoaWxlICgo bWVtY2cgPSBtZW1fY2dyb3VwX2l0ZXIoTlVMTCwgbWVtY2csIE5VTEwpKSk7CisKKwlyZXR1cm4g TlVMTDsKK30KKworc3RhdGljIHZvaWQgbHJ1X2dlbl9zZXFfc3RvcChzdHJ1Y3Qgc2VxX2ZpbGUg Km0sIHZvaWQgKnYpCit7CisJaWYgKCFJU19FUlJfT1JfTlVMTCh2KSkKKwkJbWVtX2Nncm91cF9p dGVyX2JyZWFrKE5VTEwsIGxydXZlY19tZW1jZyh2KSk7CisKKwlrdmZyZWUobS0+cHJpdmF0ZSk7 CisJbS0+cHJpdmF0ZSA9IE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkICpscnVfZ2VuX3NlcV9uZXh0 KHN0cnVjdCBzZXFfZmlsZSAqbSwgdm9pZCAqdiwgbG9mZl90ICpwb3MpCit7CisJaW50IG5pZCA9 IGxydXZlY19wZ2RhdCh2KS0+bm9kZV9pZDsKKwlzdHJ1Y3QgbWVtX2Nncm91cCAqbWVtY2cgPSBs cnV2ZWNfbWVtY2codik7CisKKwkrKypwb3M7CisKKwluaWQgPSBuZXh0X21lbW9yeV9ub2RlKG5p ZCk7CisJaWYgKG5pZCA9PSBNQVhfTlVNTk9ERVMpIHsKKwkJbWVtY2cgPSBtZW1fY2dyb3VwX2l0 ZXIoTlVMTCwgbWVtY2csIE5VTEwpOworCQlpZiAoIW1lbWNnKQorCQkJcmV0dXJuIE5VTEw7CisK KwkJbmlkID0gZmlyc3RfbWVtb3J5X25vZGU7CisJfQorCisJcmV0dXJuIGdldF9scnV2ZWMobWVt Y2csIG5pZCk7Cit9CisKK3N0YXRpYyB2b2lkIGxydV9nZW5fc2VxX3Nob3dfZnVsbChzdHJ1Y3Qg c2VxX2ZpbGUgKm0sIHN0cnVjdCBscnV2ZWMgKmxydXZlYywKKwkJCQkgIHVuc2lnbmVkIGxvbmcg bWF4X3NlcSwgdW5zaWduZWQgbG9uZyAqbWluX3NlcSwKKwkJCQkgIHVuc2lnbmVkIGxvbmcgc2Vx KQoreworCWludCBpOworCWludCB0eXBlLCB0aWVyOworCWludCBoaXN0ID0gbHJ1X2hpc3RfZnJv bV9zZXEoc2VxKTsKKwlzdHJ1Y3QgbHJ1X2dlbl9zdHJ1Y3QgKmxydWdlbiA9ICZscnV2ZWMtPmxy dWdlbjsKKworCWZvciAodGllciA9IDA7IHRpZXIgPCBNQVhfTlJfVElFUlM7IHRpZXIrKykgewor CQlzZXFfcHJpbnRmKG0sICIgICAgICAgICAgICAlMTBkIiwgdGllcik7CisJCWZvciAodHlwZSA9 IDA7IHR5cGUgPCBBTk9OX0FORF9GSUxFOyB0eXBlKyspIHsKKwkJCWNvbnN0IGNoYXIgKnMgPSAi ICAgIjsKKwkJCXVuc2lnbmVkIGxvbmcgblszXSA9IHt9OworCisJCQlpZiAoc2VxID09IG1heF9z ZXEpIHsKKwkJCQlzID0gIlJUICI7CisJCQkJblswXSA9IFJFQURfT05DRShscnVnZW4tPmF2Z19y ZWZhdWx0ZWRbdHlwZV1bdGllcl0pOworCQkJCW5bMV0gPSBSRUFEX09OQ0UobHJ1Z2VuLT5hdmdf dG90YWxbdHlwZV1bdGllcl0pOworCQkJfSBlbHNlIGlmIChzZXEgPT0gbWluX3NlcVt0eXBlXSB8 fCBOUl9ISVNUX0dFTlMgPiAxKSB7CisJCQkJcyA9ICJyZXAiOworCQkJCW5bMF0gPSBhdG9taWNf bG9uZ19yZWFkKCZscnVnZW4tPnJlZmF1bHRlZFtoaXN0XVt0eXBlXVt0aWVyXSk7CisJCQkJblsx XSA9IGF0b21pY19sb25nX3JlYWQoJmxydWdlbi0+ZXZpY3RlZFtoaXN0XVt0eXBlXVt0aWVyXSk7 CisJCQkJaWYgKHRpZXIpCisJCQkJCW5bMl0gPSBSRUFEX09OQ0UobHJ1Z2VuLT5wcm90ZWN0ZWRb aGlzdF1bdHlwZV1bdGllciAtIDFdKTsKKwkJCX0KKworCQkJZm9yIChpID0gMDsgaSA8IDM7IGkr KykKKwkJCQlzZXFfcHJpbnRmKG0sICIgJTEwbHUlYyIsIG5baV0sIHNbaV0pOworCQl9CisJCXNl cV9wdXRjKG0sICdcbicpOworCX0KKworCXNlcV9wdXRzKG0sICIgICAgICAgICAgICAgICAgICAg ICAgIik7CisJZm9yIChpID0gMDsgaSA8IE5SX01NX1NUQVRTOyBpKyspIHsKKwkJY29uc3QgY2hh ciAqcyA9ICIgICAgICAiOworCQl1bnNpZ25lZCBsb25nIG4gPSAwOworCisJCWlmIChzZXEgPT0g bWF4X3NlcSAmJiBOUl9ISVNUX0dFTlMgPT0gMSkgeworCQkJcyA9ICJMT1lORkEiOworCQkJbiA9 IFJFQURfT05DRShscnV2ZWMtPm1tX3N0YXRlLnN0YXRzW2hpc3RdW2ldKTsKKwkJfSBlbHNlIGlm IChzZXEgIT0gbWF4X3NlcSAmJiBOUl9ISVNUX0dFTlMgPiAxKSB7CisJCQlzID0gImxveW5mYSI7 CisJCQluID0gUkVBRF9PTkNFKGxydXZlYy0+bW1fc3RhdGUuc3RhdHNbaGlzdF1baV0pOworCQl9 CisKKwkJc2VxX3ByaW50ZihtLCAiICUxMGx1JWMiLCBuLCBzW2ldKTsKKwl9CisJc2VxX3B1dGMo bSwgJ1xuJyk7Cit9CisKK3N0YXRpYyBpbnQgbHJ1X2dlbl9zZXFfc2hvdyhzdHJ1Y3Qgc2VxX2Zp bGUgKm0sIHZvaWQgKnYpCit7CisJdW5zaWduZWQgbG9uZyBzZXE7CisJYm9vbCBmdWxsID0gIWRl YnVnZnNfcmVhbF9mb3BzKG0tPmZpbGUpLT53cml0ZTsKKwlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMg PSB2OworCXN0cnVjdCBscnVfZ2VuX3N0cnVjdCAqbHJ1Z2VuID0gJmxydXZlYy0+bHJ1Z2VuOwor CWludCBuaWQgPSBscnV2ZWNfcGdkYXQobHJ1dmVjKS0+bm9kZV9pZDsKKwlzdHJ1Y3QgbWVtX2Nn cm91cCAqbWVtY2cgPSBscnV2ZWNfbWVtY2cobHJ1dmVjKTsKKwlERUZJTkVfTUFYX1NFUShscnV2 ZWMpOworCURFRklORV9NSU5fU0VRKGxydXZlYyk7CisKKwlpZiAobmlkID09IGZpcnN0X21lbW9y eV9ub2RlKSB7CisJCWNvbnN0IGNoYXIgKnBhdGggPSBtZW1jZyA/IG0tPnByaXZhdGUgOiAiIjsK KworI2lmZGVmIENPTkZJR19NRU1DRworCQlpZiAobWVtY2cpCisJCQljZ3JvdXBfcGF0aChtZW1j Zy0+Y3NzLmNncm91cCwgbS0+cHJpdmF0ZSwgUEFUSF9NQVgpOworI2VuZGlmCisJCXNlcV9wcmlu dGYobSwgIm1lbWNnICU1aHUgJXNcbiIsIG1lbV9jZ3JvdXBfaWQobWVtY2cpLCBwYXRoKTsKKwl9 CisKKwlzZXFfcHJpbnRmKG0sICIgbm9kZSAlNWRcbiIsIG5pZCk7CisKKwlpZiAoIWZ1bGwpCisJ CXNlcSA9IG1pbl9zZXFbTFJVX0dFTl9BTk9OXTsKKwllbHNlIGlmIChtYXhfc2VxID49IE1BWF9O Ul9HRU5TKQorCQlzZXEgPSBtYXhfc2VxIC0gTUFYX05SX0dFTlMgKyAxOworCWVsc2UKKwkJc2Vx ID0gMDsKKworCWZvciAoOyBzZXEgPD0gbWF4X3NlcTsgc2VxKyspIHsKKwkJaW50IHR5cGUsIHpv bmU7CisJCWludCBnZW4gPSBscnVfZ2VuX2Zyb21fc2VxKHNlcSk7CisJCXVuc2lnbmVkIGxvbmcg YmlydGggPSBSRUFEX09OQ0UobHJ1dmVjLT5scnVnZW4udGltZXN0YW1wc1tnZW5dKTsKKworCQlz ZXFfcHJpbnRmKG0sICIgJTEwbHUgJTEwdSIsIHNlcSwgamlmZmllc190b19tc2VjcyhqaWZmaWVz IC0gYmlydGgpKTsKKworCQlmb3IgKHR5cGUgPSAwOyB0eXBlIDwgQU5PTl9BTkRfRklMRTsgdHlw ZSsrKSB7CisJCQl1bnNpZ25lZCBsb25nIHNpemUgPSAwOworCQkJY2hhciBtYXJrID0gZnVsbCAm JiBzZXEgPCBtaW5fc2VxW3R5cGVdID8gJ3gnIDogJyAnOworCisJCQlmb3IgKHpvbmUgPSAwOyB6 b25lIDwgTUFYX05SX1pPTkVTOyB6b25lKyspCisJCQkJc2l6ZSArPSBtYXgoUkVBRF9PTkNFKGxy dWdlbi0+bnJfcGFnZXNbZ2VuXVt0eXBlXVt6b25lXSksIDBMKTsKKworCQkJc2VxX3ByaW50Ziht LCAiICUxMGx1JWMiLCBzaXplLCBtYXJrKTsKKwkJfQorCisJCXNlcV9wdXRjKG0sICdcbicpOwor CisJCWlmIChmdWxsKQorCQkJbHJ1X2dlbl9zZXFfc2hvd19mdWxsKG0sIGxydXZlYywgbWF4X3Nl cSwgbWluX3NlcSwgc2VxKTsKKwl9CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGNvbnN0IHN0 cnVjdCBzZXFfb3BlcmF0aW9ucyBscnVfZ2VuX3NlcV9vcHMgPSB7CisJLnN0YXJ0ID0gbHJ1X2dl bl9zZXFfc3RhcnQsCisJLnN0b3AgPSBscnVfZ2VuX3NlcV9zdG9wLAorCS5uZXh0ID0gbHJ1X2dl bl9zZXFfbmV4dCwKKwkuc2hvdyA9IGxydV9nZW5fc2VxX3Nob3csCit9OworCitzdGF0aWMgaW50 IHJ1bl9hZ2luZyhzdHJ1Y3QgbHJ1dmVjICpscnV2ZWMsIHVuc2lnbmVkIGxvbmcgc2VxLCBzdHJ1 Y3Qgc2Nhbl9jb250cm9sICpzYywKKwkJICAgICBib29sIGNhbl9zd2FwLCBib29sIGZvcmNlX3Nj YW4pCit7CisJREVGSU5FX01BWF9TRVEobHJ1dmVjKTsKKwlERUZJTkVfTUlOX1NFUShscnV2ZWMp OworCisJaWYgKHNlcSA8IG1heF9zZXEpCisJCXJldHVybiAwOworCisJaWYgKHNlcSA+IG1heF9z ZXEpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFmb3JjZV9zY2FuICYmIG1pbl9zZXFbIWNh bl9zd2FwXSArIE1BWF9OUl9HRU5TIC0gMSA8PSBtYXhfc2VxKQorCQlyZXR1cm4gLUVSQU5HRTsK KworCXRyeV90b19pbmNfbWF4X3NlcShscnV2ZWMsIG1heF9zZXEsIHNjLCBjYW5fc3dhcCwgZm9y Y2Vfc2Nhbik7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIGludCBydW5fZXZpY3Rpb24oc3Ry dWN0IGxydXZlYyAqbHJ1dmVjLCB1bnNpZ25lZCBsb25nIHNlcSwgc3RydWN0IHNjYW5fY29udHJv bCAqc2MsCisJCQlpbnQgc3dhcHBpbmVzcywgdW5zaWduZWQgbG9uZyBucl90b19yZWNsYWltKQor eworCURFRklORV9NQVhfU0VRKGxydXZlYyk7CisKKwlpZiAoc2VxICsgTUlOX05SX0dFTlMgPiBt YXhfc2VxKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXNjLT5ucl9yZWNsYWltZWQgPSAwOworCisJ d2hpbGUgKCFzaWduYWxfcGVuZGluZyhjdXJyZW50KSkgeworCQlERUZJTkVfTUlOX1NFUShscnV2 ZWMpOworCisJCWlmIChzZXEgPCBtaW5fc2VxWyFzd2FwcGluZXNzXSkKKwkJCXJldHVybiAwOwor CisJCWlmIChzYy0+bnJfcmVjbGFpbWVkID49IG5yX3RvX3JlY2xhaW0pCisJCQlyZXR1cm4gMDsK KworCQlpZiAoIWV2aWN0X2ZvbGlvcyhscnV2ZWMsIHNjLCBzd2FwcGluZXNzLCBOVUxMKSkKKwkJ CXJldHVybiAwOworCisJCWNvbmRfcmVzY2hlZCgpOworCX0KKworCXJldHVybiAtRUlOVFI7Cit9 CisKK3N0YXRpYyBpbnQgcnVuX2NtZChjaGFyIGNtZCwgaW50IG1lbWNnX2lkLCBpbnQgbmlkLCB1 bnNpZ25lZCBsb25nIHNlcSwKKwkJICAgc3RydWN0IHNjYW5fY29udHJvbCAqc2MsIGludCBzd2Fw cGluZXNzLCB1bnNpZ25lZCBsb25nIG9wdCkKK3sKKwlzdHJ1Y3QgbHJ1dmVjICpscnV2ZWM7CisJ aW50IGVyciA9IC1FSU5WQUw7CisJc3RydWN0IG1lbV9jZ3JvdXAgKm1lbWNnID0gTlVMTDsKKwor CWlmIChuaWQgPCAwIHx8IG5pZCA+PSBNQVhfTlVNTk9ERVMgfHwgIW5vZGVfc3RhdGUobmlkLCBO X01FTU9SWSkpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKCFtZW1fY2dyb3VwX2Rpc2FibGVk KCkpIHsKKwkJcmN1X3JlYWRfbG9jaygpOworCQltZW1jZyA9IG1lbV9jZ3JvdXBfZnJvbV9pZCht ZW1jZ19pZCk7CisjaWZkZWYgQ09ORklHX01FTUNHCisJCWlmIChtZW1jZyAmJiAhY3NzX3RyeWdl dCgmbWVtY2ctPmNzcykpCisJCQltZW1jZyA9IE5VTEw7CisjZW5kaWYKKwkJcmN1X3JlYWRfdW5s b2NrKCk7CisKKwkJaWYgKCFtZW1jZykKKwkJCXJldHVybiAtRUlOVkFMOworCX0KKworCWlmICht ZW1jZ19pZCAhPSBtZW1fY2dyb3VwX2lkKG1lbWNnKSkKKwkJZ290byBkb25lOworCisJbHJ1dmVj ID0gZ2V0X2xydXZlYyhtZW1jZywgbmlkKTsKKworCWlmIChzd2FwcGluZXNzIDwgMCkKKwkJc3dh cHBpbmVzcyA9IGdldF9zd2FwcGluZXNzKGxydXZlYywgc2MpOworCWVsc2UgaWYgKHN3YXBwaW5l c3MgPiAyMDApCisJCWdvdG8gZG9uZTsKKworCXN3aXRjaCAoY21kKSB7CisJY2FzZSAnKyc6CisJ CWVyciA9IHJ1bl9hZ2luZyhscnV2ZWMsIHNlcSwgc2MsIHN3YXBwaW5lc3MsIG9wdCk7CisJCWJy ZWFrOworCWNhc2UgJy0nOgorCQllcnIgPSBydW5fZXZpY3Rpb24obHJ1dmVjLCBzZXEsIHNjLCBz d2FwcGluZXNzLCBvcHQpOworCQlicmVhazsKKwl9Citkb25lOgorCW1lbV9jZ3JvdXBfcHV0KG1l bWNnKTsKKworCXJldHVybiBlcnI7Cit9CisKK3N0YXRpYyBzc2l6ZV90IGxydV9nZW5fc2VxX3dy aXRlKHN0cnVjdCBmaWxlICpmaWxlLCBjb25zdCBjaGFyIF9fdXNlciAqc3JjLAorCQkJCSBzaXpl X3QgbGVuLCBsb2ZmX3QgKnBvcykKK3sKKwl2b2lkICpidWY7CisJY2hhciAqY3VyLCAqbmV4dDsK Kwl1bnNpZ25lZCBpbnQgZmxhZ3M7CisJc3RydWN0IGJsa19wbHVnIHBsdWc7CisJaW50IGVyciA9 IC1FSU5WQUw7CisJc3RydWN0IHNjYW5fY29udHJvbCBzYyA9IHsKKwkJLm1heV93cml0ZXBhZ2Ug PSB0cnVlLAorCQkubWF5X3VubWFwID0gdHJ1ZSwKKwkJLm1heV9zd2FwID0gdHJ1ZSwKKwkJLnJl Y2xhaW1faWR4ID0gTUFYX05SX1pPTkVTIC0gMSwKKwkJLmdmcF9tYXNrID0gR0ZQX0tFUk5FTCwK Kwl9OworCisJYnVmID0ga3ZtYWxsb2MobGVuICsgMSwgR0ZQX0tFUk5FTCk7CisJaWYgKCFidWYp CisJCXJldHVybiAtRU5PTUVNOworCisJaWYgKGNvcHlfZnJvbV91c2VyKGJ1Ziwgc3JjLCBsZW4p KSB7CisJCWt2ZnJlZShidWYpOworCQlyZXR1cm4gLUVGQVVMVDsKKwl9CisKKwlzZXRfdGFza19y ZWNsYWltX3N0YXRlKGN1cnJlbnQsICZzYy5yZWNsYWltX3N0YXRlKTsKKwlmbGFncyA9IG1lbWFs bG9jX25vcmVjbGFpbV9zYXZlKCk7CisJYmxrX3N0YXJ0X3BsdWcoJnBsdWcpOworCWlmICghc2V0 X21tX3dhbGsoTlVMTCkpIHsKKwkJZXJyID0gLUVOT01FTTsKKwkJZ290byBkb25lOworCX0KKwor CW5leHQgPSBidWY7CisJbmV4dFtsZW5dID0gJ1wwJzsKKworCXdoaWxlICgoY3VyID0gc3Ryc2Vw KCZuZXh0LCAiLDtcbiIpKSkgeworCQlpbnQgbjsKKwkJaW50IGVuZDsKKwkJY2hhciBjbWQ7CisJ CXVuc2lnbmVkIGludCBtZW1jZ19pZDsKKwkJdW5zaWduZWQgaW50IG5pZDsKKwkJdW5zaWduZWQg bG9uZyBzZXE7CisJCXVuc2lnbmVkIGludCBzd2FwcGluZXNzID0gLTE7CisJCXVuc2lnbmVkIGxv bmcgb3B0ID0gLTE7CisKKwkJY3VyID0gc2tpcF9zcGFjZXMoY3VyKTsKKwkJaWYgKCEqY3VyKQor CQkJY29udGludWU7CisKKwkJbiA9IHNzY2FuZihjdXIsICIlYyAldSAldSAlbHUgJW4gJXUgJW4g JWx1ICVuIiwgJmNtZCwgJm1lbWNnX2lkLCAmbmlkLAorCQkJICAgJnNlcSwgJmVuZCwgJnN3YXBw aW5lc3MsICZlbmQsICZvcHQsICZlbmQpOworCQlpZiAobiA8IDQgfHwgY3VyW2VuZF0pIHsKKwkJ CWVyciA9IC1FSU5WQUw7CisJCQlicmVhazsKKwkJfQorCisJCWVyciA9IHJ1bl9jbWQoY21kLCBt ZW1jZ19pZCwgbmlkLCBzZXEsICZzYywgc3dhcHBpbmVzcywgb3B0KTsKKwkJaWYgKGVycikKKwkJ CWJyZWFrOworCX0KK2RvbmU6CisJY2xlYXJfbW1fd2FsaygpOworCWJsa19maW5pc2hfcGx1Zygm cGx1Zyk7CisJbWVtYWxsb2Nfbm9yZWNsYWltX3Jlc3RvcmUoZmxhZ3MpOworCXNldF90YXNrX3Jl Y2xhaW1fc3RhdGUoY3VycmVudCwgTlVMTCk7CisKKwlrdmZyZWUoYnVmKTsKKworCXJldHVybiBl cnIgPyA6IGxlbjsKK30KKworc3RhdGljIGludCBscnVfZ2VuX3NlcV9vcGVuKHN0cnVjdCBpbm9k ZSAqaW5vZGUsIHN0cnVjdCBmaWxlICpmaWxlKQoreworCXJldHVybiBzZXFfb3BlbihmaWxlLCAm bHJ1X2dlbl9zZXFfb3BzKTsKK30KKworc3RhdGljIGNvbnN0IHN0cnVjdCBmaWxlX29wZXJhdGlv bnMgbHJ1X2dlbl9yd19mb3BzID0geworCS5vcGVuID0gbHJ1X2dlbl9zZXFfb3BlbiwKKwkucmVh ZCA9IHNlcV9yZWFkLAorCS53cml0ZSA9IGxydV9nZW5fc2VxX3dyaXRlLAorCS5sbHNlZWsgPSBz ZXFfbHNlZWssCisJLnJlbGVhc2UgPSBzZXFfcmVsZWFzZSwKK307CisKK3N0YXRpYyBjb25zdCBz dHJ1Y3QgZmlsZV9vcGVyYXRpb25zIGxydV9nZW5fcm9fZm9wcyA9IHsKKwkub3BlbiA9IGxydV9n ZW5fc2VxX29wZW4sCisJLnJlYWQgPSBzZXFfcmVhZCwKKwkubGxzZWVrID0gc2VxX2xzZWVrLAor CS5yZWxlYXNlID0gc2VxX3JlbGVhc2UsCit9OworCiAvKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAg KiAgICAgICAgICAgICAgICAgICAgICAgICAgaW5pdGlhbGl6YXRpb24KICAqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKiovCkBAIC01Mzg3LDYgKzU3NzUsOSBAQCBzdGF0aWMgaW50IF9faW5pdCBpbml0X2xy dV9nZW4odm9pZCkKIAlpZiAoc3lzZnNfY3JlYXRlX2dyb3VwKG1tX2tvYmosICZscnVfZ2VuX2F0 dHJfZ3JvdXApKQogCQlwcl9lcnIoImxydV9nZW46IGZhaWxlZCB0byBjcmVhdGUgc3lzZnMgZ3Jv dXBcbiIpOwogCisJZGVidWdmc19jcmVhdGVfZmlsZSgibHJ1X2dlbiIsIDA2NDQsIE5VTEwsIE5V TEwsICZscnVfZ2VuX3J3X2ZvcHMpOworCWRlYnVnZnNfY3JlYXRlX2ZpbGUoImxydV9nZW5fZnVs bCIsIDA0NDQsIE5VTEwsIE5VTEwsICZscnVfZ2VuX3JvX2ZvcHMpOworCiAJcmV0dXJuIDA7CiB9 OwogbGF0ZV9pbml0Y2FsbChpbml0X2xydV9nZW4pOwotLSAKMi4zNy4xLjU5NS5nNzE4YTNhOGYw NC1nb29nCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18K bGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZy YWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGlu dXgtYXJtLWtlcm5lbAo=