From patchwork Sat Apr 16 00:27:54 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Roman Gushchin X-Patchwork-Id: 12815535 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 33540C433EF for ; Sat, 16 Apr 2022 00:28:25 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 88C8B6B0075; Fri, 15 Apr 2022 20:28:24 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 814E46B0078; Fri, 15 Apr 2022 20:28:24 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 618846B007B; Fri, 15 Apr 2022 20:28:24 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (relay.hostedemail.com [64.99.140.26]) by kanga.kvack.org (Postfix) with ESMTP id 4FBB66B0075 for ; Fri, 15 Apr 2022 20:28:24 -0400 (EDT) Received: from smtpin04.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay11.hostedemail.com (Postfix) with ESMTP id 2614980991 for ; Sat, 16 Apr 2022 00:28:24 +0000 (UTC) X-FDA: 79360855728.04.95A0F39 Received: from out2.migadu.com (out2.migadu.com [188.165.223.204]) by imf12.hostedemail.com (Postfix) with ESMTP id 7C68340005 for ; Sat, 16 Apr 2022 00:28:23 +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=1650068902; 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=4ERdF+19mvF3N82X1eSrvKaKf/NF7Kk10EurOOsSAC0=; b=QhVoFm1c0QEKUjYdxLXR9/OUgE6EDMKySAdoHLQG6gT4ZLBlQv6bsOQRK1dwmquyxGA5Lv pgh3k5rlgv7fJ2iN46oEowzO0DCSZP1gJjlfW2tuS5O5vncaPDRQNsjvXvjePkuYsRnqkP cUpVH91hOvlfJvy7YPvrKUVsNsGAlGU= From: Roman Gushchin To: linux-mm@kvack.org Cc: Andrew Morton , Dave Chinner , linux-kernel@vger.kernel.org, Johannes Weiner , Michal Hocko , Shakeel Butt , Yang Shi , Roman Gushchin Subject: [PATCH rfc 3/5] mm: introduce memcg interfaces for shrinker sysfs Date: Fri, 15 Apr 2022 17:27:54 -0700 Message-Id: <20220416002756.4087977-4-roman.gushchin@linux.dev> In-Reply-To: <20220416002756.4087977-1-roman.gushchin@linux.dev> References: <20220416002756.4087977-1-roman.gushchin@linux.dev> MIME-Version: 1.0 X-Migadu-Flow: FLOW_OUT X-Migadu-Auth-User: linux.dev X-Rspamd-Server: rspam05 X-Rspamd-Queue-Id: 7C68340005 X-Rspam-User: Authentication-Results: imf12.hostedemail.com; dkim=pass header.d=linux.dev header.s=key1 header.b=QhVoFm1c; spf=pass (imf12.hostedemail.com: domain of roman.gushchin@linux.dev designates 188.165.223.204 as permitted sender) smtp.mailfrom=roman.gushchin@linux.dev; dmarc=pass (policy=none) header.from=linux.dev X-Stat-Signature: arikibdq9bbtusuein1u7cow3bo4oi5q X-HE-Tag: 1650068903-891999 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 "count_memcg" and "scan_memcg" interfaces for memcg-aware shrinkers. Count_memcg using the following format: ... Memory cgroups with 0 associated objects are skipped. If the output doesn't fit into a page (sysfs limitation), a separate line with "..." is added at the end. It's possible to write a minimum number to the "count_memcg" interface to filter the output. Signed-off-by: Roman Gushchin --- mm/shrinker_debug.c | 216 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 216 insertions(+) diff --git a/mm/shrinker_debug.c b/mm/shrinker_debug.c index 817d578f993c..24f78f5feb22 100644 --- a/mm/shrinker_debug.c +++ b/mm/shrinker_debug.c @@ -3,6 +3,7 @@ #include #include #include +#include /* defined in vmscan.c */ extern struct rw_semaphore shrinker_rwsem; @@ -207,8 +208,223 @@ static const struct attribute_group shrinker_default_group = { .attrs = shrinker_default_attrs, }; +#ifdef CONFIG_MEMCG +static ssize_t count_memcg_show(struct shrinker_kobj *skobj, + struct shrinker_attribute *attr, char *buf) +{ + unsigned long nr, total; + struct shrinker *shrinker; + struct mem_cgroup *memcg; + ssize_t ret = 0; + int nid; + + down_read(&shrinker_rwsem); + rcu_read_lock(); + + shrinker = skobj->shrinker; + if (!shrinker) { + ret = -EBUSY; + goto out; + } + + memcg = mem_cgroup_iter(NULL, NULL, NULL); + do { + if (!mem_cgroup_online(memcg)) + continue; + + /* + * Display a PAGE_SIZE of data, reserve last 50 characters + * for "...". + */ + if (ret > PAGE_SIZE - 50) { + ret += sprintf(buf + ret, "...\n"); + mem_cgroup_iter_break(NULL, memcg); + break; + } + + total = 0; + for_each_node(nid) { + struct shrink_control sc = { + .gfp_mask = GFP_KERNEL, + .nid = nid, + .memcg = memcg, + }; + + nr = shrinker->count_objects(shrinker, &sc); + if (nr == SHRINK_EMPTY) + nr = 0; + total += nr; + + if (!(shrinker->flags & SHRINKER_NUMA_AWARE)) + break; + + cond_resched(); + } + + if (!total || total < attr->private) + continue; + + ret += sprintf(buf + ret, "%lu %lu\n", mem_cgroup_ino(memcg), + total); + + cond_resched(); + } while ((memcg = mem_cgroup_iter(NULL, memcg, NULL)) != NULL); +out: + rcu_read_unlock(); + up_read(&shrinker_rwsem); + return ret; +} + +static ssize_t count_memcg_store(struct shrinker_kobj *skobj, + struct shrinker_attribute *attr, + const char *buf, size_t size) +{ + unsigned long min_count; + + if (kstrtoul(buf, 10, &min_count)) + return -EINVAL; + + attr->private = min_count; + + return size; +} + +static struct shrinker_attribute count_memcg_attribute = __ATTR_RW(count_memcg); + +static ssize_t scan_memcg_show(struct shrinker_kobj *skobj, + struct shrinker_attribute *attr, char *buf) +{ + /* + * Display the number of objects freed on the last scan. + */ + return sprintf(buf, "%lu\n", attr->private); +} + +static ssize_t scan_memcg_store(struct shrinker_kobj *skobj, + struct shrinker_attribute *attr, + const char *buf, size_t size) +{ + unsigned long nr, nr_to_scan = 0, freed = 0, total = 0, ino; + unsigned long *count_per_node = NULL; + struct mem_cgroup *memcg; + struct shrinker *shrinker; + ssize_t ret = size; + int nid; + + if (sscanf(buf, "%lu %lu", &ino, &nr_to_scan) < 2) + return -EINVAL; + + memcg = mem_cgroup_get_from_ino(ino); + if (!memcg || IS_ERR(memcg)) + return -ENOENT; + + if (!mem_cgroup_online(memcg)) { + mem_cgroup_put(memcg); + return -ENOENT; + } + + down_read(&shrinker_rwsem); + + shrinker = skobj->shrinker; + if (!shrinker) { + ret = -EBUSY; + goto out; + } + + if (shrinker->flags & SHRINKER_NUMA_AWARE) { + count_per_node = kzalloc(sizeof(unsigned long) * nr_node_ids, + GFP_KERNEL); + if (!count_per_node) { + ret = -ENOMEM; + goto out; + } + + for_each_node(nid) { + struct shrink_control sc = { + .gfp_mask = GFP_KERNEL, + .nid = nid, + .memcg = memcg, + }; + + 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, + .memcg = memcg, + }; + + 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 || nr == SHRINK_EMPTY) + nr = 0; + + freed += nr; + + if (!(shrinker->flags & SHRINKER_NUMA_AWARE)) + break; + + cond_resched(); + } + attr->private = freed; +out: + up_read(&shrinker_rwsem); + mem_cgroup_put(memcg); + kfree(count_per_node); + return ret; +} + +static struct shrinker_attribute scan_memcg_attribute = __ATTR_RW(scan_memcg); + +static struct attribute *shrinker_memcg_attrs[] = { + &count_memcg_attribute.attr, + &scan_memcg_attribute.attr, + NULL, +}; + +static umode_t memcg_attrs_visible(struct kobject *kobj, struct attribute *attr, + int i) +{ + struct shrinker_kobj *skobj = to_shrinker_kobj(kobj); + struct shrinker *shrinker; + int ret = 0; + + lockdep_assert_held(&shrinker_rwsem); + + shrinker = skobj->shrinker; + if (shrinker && (shrinker->flags & SHRINKER_MEMCG_AWARE)) + ret = 0644; + + return ret; +} + +static const struct attribute_group shrinker_memcg_group = { + .attrs = shrinker_memcg_attrs, + .is_visible = memcg_attrs_visible, +}; +#endif /* CONFIG_MEMCG */ static const struct attribute_group *shrinker_sysfs_groups[] = { &shrinker_default_group, +#ifdef CONFIG_MEMCG + &shrinker_memcg_group, +#endif NULL, };