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 kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id AED9BC433EF for ; Fri, 22 Apr 2022 20:27:03 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 1C6EB6B0074; Fri, 22 Apr 2022 16:27:03 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 0B4646B0075; Fri, 22 Apr 2022 16:27:03 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id E6DD36B0078; Fri, 22 Apr 2022 16:27:02 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (relay.a.hostedemail.com [64.99.140.24]) by kanga.kvack.org (Postfix) with ESMTP id DAC396B0074 for ; Fri, 22 Apr 2022 16:27:02 -0400 (EDT) Received: from smtpin24.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay10.hostedemail.com (Postfix) with ESMTP id ACEF4DF6 for ; Fri, 22 Apr 2022 20:27:02 +0000 (UTC) X-FDA: 79385649084.24.6D6D462 Received: from out2.migadu.com (out2.migadu.com [188.165.223.204]) by imf08.hostedemail.com (Postfix) with ESMTP id C3DA416002B for ; Fri, 22 Apr 2022 20:26:58 +0000 (UTC) X-Report-Abuse: Please report any abuse attempt to abuse@migadu.com and include these headers. DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linux.dev; s=key1; t=1650659220; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=urcY4KpR6Y/rKfU1Exf0ylTVTWbC0tQ2e4XTZHXE3Ec=; b=Rkp7y8m+AwOnzfVRecboeJevDVmitFoVkP/aOEar3B+GCCQWfBGuLjtKKW/3F33jeIIi+Y xKLlrm53i8aUwoAbATIEyFk7+0Zi01RLZZC5rWiIUZbSjMfQlTKFh2FHEhpPCxpeOkYhtI 7z8uAUQpo6SCvqDyeiHuefgVhe5ctPM= From: Roman Gushchin To: Andrew Morton , linux-mm@kvack.org Cc: Dave Chinner , linux-kernel@vger.kernel.org, Yang Shi , Kent Overstreet , Hillf Danton , Roman Gushchin Subject: [PATCH v2 1/7] mm: introduce debugfs interface for kernel memory shrinkers Date: Fri, 22 Apr 2022 13:26:38 -0700 Message-Id: <20220422202644.799732-2-roman.gushchin@linux.dev> In-Reply-To: <20220422202644.799732-1-roman.gushchin@linux.dev> References: <20220422202644.799732-1-roman.gushchin@linux.dev> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Migadu-Flow: FLOW_OUT X-Migadu-Auth-User: linux.dev X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: C3DA416002B X-Stat-Signature: 4hx8zcmhcanyyzp4bsuyr4ai8dyz3qm9 Authentication-Results: imf08.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=Rkp7y8m+; dmarc=pass (policy=none) header.from=linux.dev; spf=pass (imf08.hostedemail.com: domain of roman.gushchin@linux.dev designates 188.165.223.204 as permitted sender) smtp.mailfrom=roman.gushchin@linux.dev X-Rspam-User: X-HE-Tag: 1650659218-368339 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: This commit introduces the /sys/kernel/debug/shrinker debugfs interface which provides an ability to observe the state and interact with individual kernel memory shrinkers. Because the feature is oriented on kernel developers and adds some memory overhead (which shouldn't be large unless there is a huge amount of registered shrinkers), it's guarded by a config option (disabled by default). This commit introduces "count" and "scan" interfaces for each shrinker registered in the system. Basic usage: 1) Get the number of objects $ cat count 2) Try to reclaim 500 objects $ echo "500" > scan Following commits in the series will add memcg- and numa-specific features. This commit gives debugfs entries simple numeric names, which are not very convenient. The following commit in the series will provide shrinkers with more meaningful names. Signed-off-by: Roman Gushchin --- include/linux/shrinker.h | 19 +++- lib/Kconfig.debug | 9 ++ mm/Makefile | 1 + mm/shrinker_debug.c | 214 +++++++++++++++++++++++++++++++++++++++ mm/vmscan.c | 6 +- 5 files changed, 246 insertions(+), 3 deletions(-) create mode 100644 mm/shrinker_debug.c diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h index 76fbf92b04d9..17985a890887 100644 --- a/include/linux/shrinker.h +++ b/include/linux/shrinker.h @@ -72,6 +72,10 @@ struct shrinker { #ifdef CONFIG_MEMCG /* ID in shrinker_idr */ int id; +#endif +#ifdef CONFIG_SHRINKER_DEBUG + int debugfs_id; + struct dentry *debugfs_entry; #endif /* objs pending delete, per node */ atomic_long_t *nr_deferred; @@ -94,4 +98,17 @@ extern int register_shrinker(struct shrinker *shrinker); extern void unregister_shrinker(struct shrinker *shrinker); extern void free_prealloced_shrinker(struct shrinker *shrinker); extern void synchronize_shrinkers(void); -#endif + +#ifdef CONFIG_SHRINKER_DEBUG +int shrinker_debugfs_add(struct shrinker *shrinker); +void shrinker_debugfs_remove(struct shrinker *shrinker); +#else /* CONFIG_SHRINKER_DEBUG */ +static inline int shrinker_debugfs_add(struct shrinker *shrinker) +{ + return 0; +} +static inline void shrinker_debugfs_remove(struct shrinker *shrinker) +{ +} +#endif /* CONFIG_SHRINKER_DEBUG */ +#endif /* _LINUX_SHRINKER_H */ diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 6bf9cceb7d20..51910b291b81 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -733,6 +733,15 @@ config SLUB_STATS out which slabs are relevant to a particular load. Try running: slabinfo -DA +config SHRINKER_DEBUG + default n + bool "Enable shrinker debugging support" + depends on DEBUG_FS + help + Say Y to enable the shrinker debugfs interface which provides + visibility into the kernel memory shrinkers subsystem. + Disable it to avoid an extra memory footprint. + config HAVE_DEBUG_KMEMLEAK bool diff --git a/mm/Makefile b/mm/Makefile index 6f9ffa968a1a..9a564f836403 100644 --- a/mm/Makefile +++ b/mm/Makefile @@ -133,3 +133,4 @@ obj-$(CONFIG_PAGE_REPORTING) += page_reporting.o obj-$(CONFIG_IO_MAPPING) += io-mapping.o obj-$(CONFIG_HAVE_BOOTMEM_INFO_NODE) += bootmem_info.o obj-$(CONFIG_GENERIC_IOREMAP) += ioremap.o +obj-$(CONFIG_SHRINKER_DEBUG) += shrinker_debug.o diff --git a/mm/shrinker_debug.c b/mm/shrinker_debug.c new file mode 100644 index 000000000000..4df7382a0737 --- /dev/null +++ b/mm/shrinker_debug.c @@ -0,0 +1,214 @@ +// SPDX-License-Identifier: GPL-2.0 +#include +#include +#include +#include + +/* defined in vmscan.c */ +extern struct rw_semaphore shrinker_rwsem; +extern struct list_head shrinker_list; + +static DEFINE_IDA(shrinker_debugfs_ida); +static struct dentry *shrinker_debugfs_root; + +static int shrinker_debugfs_count_show(struct seq_file *m, void *v) +{ + struct shrinker *shrinker = (struct shrinker *)m->private; + unsigned long nr, total = 0; + int ret, nid; + + ret = down_read_killable(&shrinker_rwsem); + if (ret) + return ret; + + for_each_node(nid) { + struct shrink_control sc = { + .gfp_mask = GFP_KERNEL, + .nid = nid, + }; + + nr = shrinker->count_objects(shrinker, &sc); + if (nr == SHRINK_EMPTY) + nr = 0; + total += nr; + + if (!(shrinker->flags & SHRINKER_NUMA_AWARE)) + break; + + cond_resched(); + } + up_read(&shrinker_rwsem); + + seq_printf(m, "%lu\n", total); + + return ret; +} +DEFINE_SHOW_ATTRIBUTE(shrinker_debugfs_count); + +static ssize_t shrinker_debugfs_scan_write(struct file *file, + const char __user *buf, + size_t size, loff_t *pos) +{ + struct shrinker *shrinker = (struct shrinker *)file->private_data; + unsigned long nr, total = 0, nr_to_scan; + unsigned long *count_per_node = NULL; + int nid; + char kbuf[24]; + int read_len = size < (sizeof(kbuf) - 1) ? size : (sizeof(kbuf) - 1); + ssize_t ret; + + if (copy_from_user(kbuf, buf, read_len)) + return -EFAULT; + kbuf[read_len] = '\0'; + + if (kstrtoul(kbuf, 10, &nr_to_scan)) + return -EINVAL; + + ret = down_read_killable(&shrinker_rwsem); + if (ret) + return ret; + + if (shrinker->flags & SHRINKER_NUMA_AWARE) { + /* + * If the shrinker is numa aware, distribute nr_to_scan + * proportionally. + */ + count_per_node = kcalloc(nr_node_ids, sizeof(unsigned long), + GFP_KERNEL); + if (!count_per_node) { + ret = -ENOMEM; + goto out; + } + + for_each_node(nid) { + struct shrink_control sc = { + .gfp_mask = GFP_KERNEL, + .nid = nid, + }; + + nr = shrinker->count_objects(shrinker, &sc); + if (nr == SHRINK_EMPTY) + nr = 0; + count_per_node[nid] = nr; + total += nr; + + cond_resched(); + } + } + + for_each_node(nid) { + struct shrink_control sc = { + .gfp_mask = GFP_KERNEL, + .nid = nid, + }; + + if (shrinker->flags & SHRINKER_NUMA_AWARE) { + sc.nr_to_scan = nr_to_scan * count_per_node[nid] / + (total ? total : 1); + sc.nr_scanned = sc.nr_to_scan; + } else { + sc.nr_to_scan = nr_to_scan; + sc.nr_scanned = sc.nr_to_scan; + } + + nr = shrinker->scan_objects(shrinker, &sc); + if (nr == SHRINK_STOP) + break; + + if (!(shrinker->flags & SHRINKER_NUMA_AWARE)) + break; + + cond_resched(); + + } + ret = size; +out: + up_read(&shrinker_rwsem); + kfree(count_per_node); + return ret; +} + +static int shrinker_debugfs_scan_open(struct inode *inode, struct file *file) +{ + file->private_data = inode->i_private; + return nonseekable_open(inode, file); +} + +static const struct file_operations shrinker_debugfs_scan_fops = { + .owner = THIS_MODULE, + .open = shrinker_debugfs_scan_open, + .write = shrinker_debugfs_scan_write, +}; + +int shrinker_debugfs_add(struct shrinker *shrinker) +{ + struct dentry *entry; + char buf[256]; + int id; + + lockdep_assert_held(&shrinker_rwsem); + + /* debugfs isn't initialized yet, add debugfs entries later. */ + if (!shrinker_debugfs_root) + return 0; + + id = ida_alloc(&shrinker_debugfs_ida, GFP_KERNEL); + if (id < 0) + return id; + shrinker->debugfs_id = id; + + snprintf(buf, sizeof(buf), "%d", id); + + /* create debugfs entry */ + entry = debugfs_create_dir(buf, shrinker_debugfs_root); + if (IS_ERR(entry)) { + ida_free(&shrinker_debugfs_ida, id); + return PTR_ERR(entry); + } + shrinker->debugfs_entry = entry; + + /* create generic interfaces */ + debugfs_create_file("count", 0220, entry, shrinker, + &shrinker_debugfs_count_fops); + debugfs_create_file("scan", 0440, entry, shrinker, + &shrinker_debugfs_scan_fops); + + return 0; +} + +void shrinker_debugfs_remove(struct shrinker *shrinker) +{ + lockdep_assert_held(&shrinker_rwsem); + + if (!shrinker->debugfs_entry) + return; + + debugfs_remove_recursive(shrinker->debugfs_entry); + ida_free(&shrinker_debugfs_ida, shrinker->debugfs_id); +} + +static int __init shrinker_debugfs_init(void) +{ + struct shrinker *shrinker; + int ret; + + if (!debugfs_initialized()) + return -ENODEV; + + shrinker_debugfs_root = debugfs_create_dir("shrinker", NULL); + if (!shrinker_debugfs_root) + return -ENOMEM; + + /* Create debugfs entries for shrinkers registered at boot */ + ret = down_write_killable(&shrinker_rwsem); + if (ret) + return ret; + + list_for_each_entry(shrinker, &shrinker_list, list) + if (!shrinker->debugfs_entry) + ret = shrinker_debugfs_add(shrinker); + up_write(&shrinker_rwsem); + + return ret; +} +late_initcall(shrinker_debugfs_init); diff --git a/mm/vmscan.c b/mm/vmscan.c index 99a572f01cb4..121a54a1602b 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -190,8 +190,8 @@ static void set_task_reclaim_state(struct task_struct *task, task->reclaim_state = rs; } -static LIST_HEAD(shrinker_list); -static DECLARE_RWSEM(shrinker_rwsem); +LIST_HEAD(shrinker_list); +DECLARE_RWSEM(shrinker_rwsem); #ifdef CONFIG_MEMCG static int shrinker_nr_max; @@ -655,6 +655,7 @@ void register_shrinker_prepared(struct shrinker *shrinker) down_write(&shrinker_rwsem); list_add_tail(&shrinker->list, &shrinker_list); shrinker->flags |= SHRINKER_REGISTERED; + WARN_ON_ONCE(shrinker_debugfs_add(shrinker)); up_write(&shrinker_rwsem); } @@ -682,6 +683,7 @@ void unregister_shrinker(struct shrinker *shrinker) shrinker->flags &= ~SHRINKER_REGISTERED; if (shrinker->flags & SHRINKER_MEMCG_AWARE) unregister_memcg_shrinker(shrinker); + shrinker_debugfs_remove(shrinker); up_write(&shrinker_rwsem); kfree(shrinker->nr_deferred); -- 2.35.1