From patchwork Tue Apr 19 20:32:00 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kent Overstreet X-Patchwork-Id: 12819410 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 678FBC433EF for ; Tue, 19 Apr 2022 20:32:16 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 6BA786B0074; Tue, 19 Apr 2022 16:32:15 -0400 (EDT) Received: by kanga.kvack.org (Postfix, from userid 40) id 50C306B0075; Tue, 19 Apr 2022 16:32:15 -0400 (EDT) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 35AAB6B0078; Tue, 19 Apr 2022 16:32:15 -0400 (EDT) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (relay.hostedemail.com [64.99.140.25]) by kanga.kvack.org (Postfix) with ESMTP id 24D916B0074 for ; Tue, 19 Apr 2022 16:32:15 -0400 (EDT) Received: from smtpin24.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay11.hostedemail.com (Postfix) with ESMTP id F042D80A20 for ; Tue, 19 Apr 2022 20:32:14 +0000 (UTC) X-FDA: 79374775788.24.31C1A4C Received: from mail-qk1-f174.google.com (mail-qk1-f174.google.com [209.85.222.174]) by imf29.hostedemail.com (Postfix) with ESMTP id E3E49120007 for ; Tue, 19 Apr 2022 20:32:13 +0000 (UTC) Received: by mail-qk1-f174.google.com with SMTP id c1so14429222qkf.13 for ; Tue, 19 Apr 2022 13:32:14 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=eAsTyebn2Y4pYis3+WZXuPp8TzH7j4PwV2amK3FTGx8=; b=khs60x2X71XXGoTkHhioI4BexG0UIkVMgtqev1LPBrp8sYHGVkGviBnDYmmKy13J8b PVmHKs/9xDnbDTA9nadcNVdUvzNsTviuf+zuwOlUk6wWiOiEJ8bOX93ySGVuCXz8tK7M bUfMl6IWLi9YjypNmw8tbT+hFrztpzIUEv6/UrUHRiImiAZfjZeWQEhuir7oGYCcRRA3 ulNhOLWsnuJRF/pnuEI+lAvPH3rP0KS+yJprgTaMr4hEmDwypLjxSqRYn05REIxfQP9t JDkQqJmFjbKmRUGijPkYDG3iQxNA5YpFgnXmRr1EYp6lBBE7A7TC9SZpssDgd0yRyPls YJJw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=eAsTyebn2Y4pYis3+WZXuPp8TzH7j4PwV2amK3FTGx8=; b=S7gwGX2oRGIYxweH84TEWynu9VBzwh5/u1dGcKRbdRI0vqQ7NFJ9qj6teUn3rNwiZp p4mQJHx1RUjhygxxWIEIFNX9rUQXJvopYsvxknEgnipDEKdkeLnAags7tUxWlO8vkHFV N2t8L6VAyUXgQjtSixdv8ET3DlxWWaxw5HYPiWXqOt+7rT4ShiClI/SzAWfYRjuo6Rd/ j/529miZOQov4++ckB1enL7VCshFJT1IwQYX+MmS+7CoNDUnZ3dxYbCKBJQTCoDcEa6U i8B5DuZxLp/Tgu8mtGHndxhdCHqJIrO+wC0LQqyMlUculoe5+ahEEQXy9vLaIsowFMEG OF/g== X-Gm-Message-State: AOAM531m6JhVU9dIGvOlaLnsPeQVu6rZ6Y5HWnptRcqPm3uIwHM+oQN9 T/ysXh4bNHAMS/+0FnJ1jw== X-Google-Smtp-Source: ABdhPJzy77PDFL4mID+Y5nmbtwckqXAJD3A1O7H2Cv2QKmNENJFo8FIIY08mjslvWbtO3ZWiJNrtXw== X-Received: by 2002:a05:620a:31a3:b0:69e:c355:18db with SMTP id bi35-20020a05620a31a300b0069ec35518dbmr2812119qkb.752.1650400333705; Tue, 19 Apr 2022 13:32:13 -0700 (PDT) Received: from moria.home.lan (c-73-219-103-14.hsd1.vt.comcast.net. [73.219.103.14]) by smtp.gmail.com with ESMTPSA id e9-20020ac84e49000000b002f1fcda1ac7sm611180qtw.82.2022.04.19.13.32.12 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 19 Apr 2022 13:32:12 -0700 (PDT) From: Kent Overstreet To: linux-kernel@vger.kernel.org, linux-mm@kvack.org, linux-fsdevel@vger.kernel.org Cc: Kent Overstreet , roman.gushchin@linux.dev, hannes@cmpxchg.org Subject: [PATCH 2/4] mm: Add a .to_text() method for shrinkers Date: Tue, 19 Apr 2022 16:32:00 -0400 Message-Id: <20220419203202.2670193-3-kent.overstreet@gmail.com> X-Mailer: git-send-email 2.35.2 In-Reply-To: <20220419203202.2670193-1-kent.overstreet@gmail.com> References: <20220419203202.2670193-1-kent.overstreet@gmail.com> MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam11 X-Rspamd-Queue-Id: E3E49120007 X-Stat-Signature: e4n4ze6qfs3txq8phf3kx58ki7j6eba9 Authentication-Results: imf29.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b=khs60x2X; spf=pass (imf29.hostedemail.com: domain of kent.overstreet@gmail.com designates 209.85.222.174 as permitted sender) smtp.mailfrom=kent.overstreet@gmail.com; dmarc=pass (policy=none) header.from=gmail.com X-HE-Tag: 1650400333-212456 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 adds a new callback method to shrinkers which they can use to describe anything relevant to memory reclaim about their internal state, for example object dirtyness. This uses the new printbufs to output to heap allocated strings, so that the .to_text() methods can be used both for messages logged to the console, and also sysfs/debugfs. This patch also adds shrinkers_to_text(), which reports on the top 10 shrinkers - by object count - in sorted order, to be used in OOM reporting. Signed-off-by: Kent Overstreet --- include/linux/shrinker.h | 5 +++ mm/vmscan.c | 75 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 80 insertions(+) diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h index 76fbf92b04..b5f411768b 100644 --- a/include/linux/shrinker.h +++ b/include/linux/shrinker.h @@ -2,6 +2,8 @@ #ifndef _LINUX_SHRINKER_H #define _LINUX_SHRINKER_H +struct printbuf; + /* * This struct is used to pass information from page reclaim to the shrinkers. * We consolidate the values for easier extension later. @@ -58,10 +60,12 @@ struct shrink_control { * @flags determine the shrinker abilities, like numa awareness */ struct shrinker { + char name[32]; unsigned long (*count_objects)(struct shrinker *, struct shrink_control *sc); unsigned long (*scan_objects)(struct shrinker *, struct shrink_control *sc); + void (*to_text)(struct printbuf *, struct shrinker *); long batch; /* reclaim batch size, 0 = default */ int seeks; /* seeks to recreate an obj */ @@ -94,4 +98,5 @@ 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); +void shrinkers_to_text(struct printbuf *); #endif diff --git a/mm/vmscan.c b/mm/vmscan.c index 59b14e0d69..09c483dfd3 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -50,6 +50,7 @@ #include #include #include +#include #include #include @@ -702,6 +703,80 @@ void synchronize_shrinkers(void) } EXPORT_SYMBOL(synchronize_shrinkers); +/** + * shrinkers_to_text - Report on shrinkers with highest usage + * + * This reports on the top 10 shrinkers, by object counts, in sorted order: + * intended to be used for OOM reporting. + */ +void shrinkers_to_text(struct printbuf *out) +{ + struct shrinker *shrinker; + struct shrinker_by_mem { + struct shrinker *shrinker; + unsigned long mem; + } shrinkers_by_mem[10]; + int i, nr = 0; + + if (!down_read_trylock(&shrinker_rwsem)) { + pr_buf(out, "(couldn't take shrinker lock)"); + return; + } + + list_for_each_entry(shrinker, &shrinker_list, list) { + struct shrink_control sc = { .gfp_mask = GFP_KERNEL, }; + unsigned long mem = shrinker->count_objects(shrinker, &sc); + + if (!mem || mem == SHRINK_STOP || mem == SHRINK_EMPTY) + continue; + + for (i = 0; i < nr; i++) + if (mem < shrinkers_by_mem[i].mem) + break; + + if (nr < ARRAY_SIZE(shrinkers_by_mem)) { + memmove(&shrinkers_by_mem[i + 1], + &shrinkers_by_mem[i], + sizeof(shrinkers_by_mem[0]) * (nr - i)); + nr++; + } else if (i) { + i--; + memmove(&shrinkers_by_mem[0], + &shrinkers_by_mem[1], + sizeof(shrinkers_by_mem[0]) * i); + } else { + continue; + } + + shrinkers_by_mem[i] = (struct shrinker_by_mem) { + .shrinker = shrinker, + .mem = mem, + }; + } + + for (i = nr - 1; i >= 0; --i) { + struct shrink_control sc = { .gfp_mask = GFP_KERNEL, }; + shrinker = shrinkers_by_mem[i].shrinker; + + if (shrinker->name[0]) + pr_buf(out, "%s", shrinker->name); + else + pr_buf(out, "%ps:", shrinker->scan_objects); + + pr_buf(out, " objects: %lu", shrinker->count_objects(shrinker, &sc)); + pr_newline(out); + + if (shrinker->to_text) { + pr_indent_push(out, 2); + shrinker->to_text(out, shrinker); + pr_indent_pop(out, 2); + pr_newline(out); + } + } + + up_read(&shrinker_rwsem); +} + #define SHRINK_BATCH 128 static unsigned long do_shrink_slab(struct shrink_control *shrinkctl,