From patchwork Mon Dec 4 19:41:56 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Finkel X-Patchwork-Id: 13479031 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 1E544C4167B for ; Mon, 4 Dec 2023 19:42:05 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id AB5176B02E7; Mon, 4 Dec 2023 14:42:04 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id A657D6B02F1; Mon, 4 Dec 2023 14:42:04 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 92D9A6B02FA; Mon, 4 Dec 2023 14:42:04 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0011.hostedemail.com [216.40.44.11]) by kanga.kvack.org (Postfix) with ESMTP id 852C96B02E7 for ; Mon, 4 Dec 2023 14:42:04 -0500 (EST) Received: from smtpin08.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay02.hostedemail.com (Postfix) with ESMTP id 603AD12032C for ; Mon, 4 Dec 2023 19:42:04 +0000 (UTC) X-FDA: 81530156568.08.E5D8B02 Received: from m47-110.mailgun.net (m47-110.mailgun.net [69.72.47.110]) by imf04.hostedemail.com (Postfix) with ESMTP id 8533E4001C for ; Mon, 4 Dec 2023 19:42:02 +0000 (UTC) Authentication-Results: imf04.hostedemail.com; dkim=pass header.d=relay.vimeo.com header.s=mailo header.b=EnkzsLar; dmarc=pass (policy=reject) header.from=vimeo.com; spf=pass (imf04.hostedemail.com: domain of "bounce+ea57f2.9d2a1c-linux-mm=kvack.org@relay.vimeo.com" designates 69.72.47.110 as permitted sender) smtp.mailfrom="bounce+ea57f2.9d2a1c-linux-mm=kvack.org@relay.vimeo.com" ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1701718922; a=rsa-sha256; cv=none; b=UuJeBcrByfcsH3NNCD8szmGnol0inJOrGAsxjIPjvCgyMx/Vuor0otzDEvteaXaAnzQ7Sm cCE0+OeqJrwUWA6tSj+zLIbnh++t9jls/0RJQghm3WSMH5edMZ5uYiLwWF29oSLUF1Mu2y Vd4J7cTuvnAjTJMPMHiMmCHK04ftadM= ARC-Authentication-Results: i=1; imf04.hostedemail.com; dkim=pass header.d=relay.vimeo.com header.s=mailo header.b=EnkzsLar; dmarc=pass (policy=reject) header.from=vimeo.com; spf=pass (imf04.hostedemail.com: domain of "bounce+ea57f2.9d2a1c-linux-mm=kvack.org@relay.vimeo.com" designates 69.72.47.110 as permitted sender) smtp.mailfrom="bounce+ea57f2.9d2a1c-linux-mm=kvack.org@relay.vimeo.com" ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1701718922; h=from:from:sender:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-transfer-encoding:content-transfer-encoding: in-reply-to:references:dkim-signature; bh=HmhFXlBPh7ZkC6JgQKrUP2LiSRCDQOnp19qvKKGJsfA=; b=5wZcVlhPQz9xrpew6GPnZSlM/Pf3q+MznTQKV8P9V62mI73dt90KQxFUYEfLE61o+fTf1L SQeUxMkMgoX1zxcZXz70HMihCQfv+O/C4brlK8klwKJs3VUHfT6f0Z+xTJDpD2n4yHJ9zy Gg8/NYMxdrUfSFXJwKRda/fFB/gt5Co= DKIM-Signature: a=rsa-sha256; v=1; c=relaxed/relaxed; d=relay.vimeo.com; q=dns/txt; s=mailo; t=1701718920; x=1701726120; h=Content-Transfer-Encoding: MIME-Version: Message-Id: Date: Subject: Subject: Cc: To: To: From: From: Sender: Sender; bh=HmhFXlBPh7ZkC6JgQKrUP2LiSRCDQOnp19qvKKGJsfA=; b=EnkzsLarzf+CtE1pj4CwgBjbnv/rbn+IdLS+xelgSHF1lZQNbj6yXDZuOGeSOAFrKiBYpARYLZgK+8inJmWVyHgmS3JE3/sWawuTq/xCsnN3FG7nPtazdI82cbmzKcxI+nW6vSVwrqGsknXx5jrFsOf8UWemVCN6fUDQ5bKiKCM= X-Mailgun-Sending-Ip: 69.72.47.110 X-Mailgun-Sid: WyI5NTRmYiIsImxpbnV4LW1tQGt2YWNrLm9yZyIsIjlkMmExYyJd Received: from smtp.vimeo.com (215.71.185.35.bc.googleusercontent.com [35.185.71.215]) by fd7bfb80eee6 with SMTP id 656e2b88156c2f103906ede9 (version=TLS1.2, cipher=TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256); Mon, 04 Dec 2023 19:42:00 GMT Received: from nutau (gke-sre-us-east1-main-c45160e0-u25i.c.vimeo-core.internal [10.56.27.31]) by smtp.vimeo.com (Postfix) with ESMTP id 55BD44DD; Mon, 4 Dec 2023 19:42:00 +0000 (UTC) Received: by nutau (Postfix, from userid 1001) id 2E15AB422EE; Mon, 4 Dec 2023 14:42:00 -0500 (EST) From: David Finkel To: Muchun Song Cc: core-services@vimeo.com, Jonathan Corbet , Michal Hocko , Roman Gushchin , Shakeel Butt , Shuah Khan , cgroups@vger.kernel.org, linux-doc@vger.kernel.org, linux-mm@kvack.org, linux-kselftest@vger.kernel.org, David Finkel Subject: [PATCH] mm, memcg: cg2 memory{.swap,}.peak write handlers Date: Mon, 4 Dec 2023 14:41:56 -0500 Message-Id: <20231204194156.2411672-1-davidf@vimeo.com> X-Mailer: git-send-email 2.39.2 MIME-Version: 1.0 X-Rspam-User: X-Rspamd-Server: rspam06 X-Rspamd-Queue-Id: 8533E4001C X-Stat-Signature: 3fxnawfqjq37boxjje9498gqya98hqwe X-HE-Tag: 1701718922-966664 X-HE-Meta: U2FsdGVkX18OBy3ZFnY2NyYVKvzEF7Xem0OB+ObHB3y+PAyYmEufmsDnnCSfPHIZoig7PeWuYJDMxpOO+hF5IAbfnI6dalHbE64FjQY479gpve6Hvwx4PCwDJeqr2OrtIZXYHwnmUpPGPSpARsueBKRKZ5Uf6Mv8QJxVbZFQJzRf50UIzLZmUTMRziwFNKqPPmrIt7UfHwJkcbnqNHfNQfKfMqheYYmJm37+D6pKbJJotTgDTiyuYblqWNWsg8kPO3MAYnxWAdQnB62XCbVbxC3869Xzm2QKQfP51wCyDUC7P+Hqn/J73Wh2qPMX4hoE2C9QMzGcQ5XMXXoIbqmW+jlGGbjn464Bo9Pz3DeCSVm2Gklhsq90CFQDsQJN1KA0GcjOqQFty5XVGPwEYPUjZ+CYDcLPhVy598pC5eGdUAgwr2RUObxpLKy9aS1DIrBaSjMTcktm5WpwBBM9v0szCZvWVIMK+Ue/t9VPBnVrELh4FpAFm5JlaCfNZSqAj5+Fge9KMCQWzuq/y2yKAsvMSsM72Z3BAu0iuJ13RY971uuzMeV2Sso1l61gKb0u++jk5jLd+tYV5RM1uKdnYuPYWCwWxg5t6q/f6+Ls8g9NKluTvcIRlbG76oin9+02qM6EI2uOUdLncwwQou9zm0YdPxISzttWwL/tiGEP7NiJ8IZgVaq07pSA1b8il0shT6T9ORZULfJo3nWjLfWkuE8yoR1FKvWNci7eRMEiLDbF2PkcsPd8oWyvks8uma71DP1Yr13sW3vz/TLZf8R0XSeK7ufsgk9yMkG2ioI//z3Eft01wJl/5zrvwEVEUcbKPZAozno62G5pEmaICwRgbTPJSvpDwm3MwoAGbsycAf0f/A+5MK/yTemgseIOAd0KdiMlRh+2yA11P0Na0i2PyZvWCTv4owPc2+xOEMS/DNO5Img1ipglil/mSqIQuCbs6E8c0oVrPSQVOScmpYvVUhl 7cjhbLfE LSvgtuVR+oJyKsQqh7U1ufo3CKJuNazbeDtK6KGDujZG2RumPBGJRejVuE0TwLmXP9YwL37EjJptkQcR9llVzFcrO2IDgaSby2YqxXsMQ4F8AMYo06lP8B3jhw1kB8/HMv2OltugvvK1A6VQQJqbu1dcy8P5QuXi4UcRLGI0ckP5J96e+nybvL2AQyuKkk5rtm6uVwzdy47r43pnE1B1IPDJX9vx+8N4KLpKheyAgBEEIfHVJedhAAxdYOzrHJCp3KMPeSP4ZdYnehng3w/ZkTwXF6OO3I3axavlOlioTkutUxZuVNOjmXJ+4KnmYLn12zBNcy3iz9PVKnuBL7spzNlmIjEU8g0YA2s3WVsnjkWdfYj9BI3Wsen4SqYk5T2wnbyFxrbp1tFmxFMw1+hcJE0fA9Uky3fkJ6whzHKL23SupDpiiuBV55fg6u9/GVXIXd40LVA+Q5l6VWifXpL6/D+6bEIOFofQwgyUD X-Bogosity: Ham, tests=bogofilter, spamicity=0.000001, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: List-Subscribe: List-Unsubscribe: Other mechanisms for querying the peak memory usage of either a process or v1 memory cgroup allow for resetting the high watermark. Restore parity with those mechanisms. For example: - Any write to memory.max_usage_in_bytes in a cgroup v1 mount resets the high watermark. - writing "5" to the clear_refs pseudo-file in a processes's proc directory resets the peak RSS. This change copies the cgroup v1 behavior so any write to the memory.peak and memory.swap.peak pseudo-files reset the high watermark to the current usage. This behavior is particularly useful for work scheduling systems that need to track memory usage of worker processes/cgroups per-work-item. Since memory can't be squeezed like CPU can (the OOM-killer has opinions), these systems need to track the peak memory usage to compute system/container fullness when binpacking workitems. Signed-off-by: David Finkel Acked-by: Shakeel Butt Acked-by: Michal Hocko --- Documentation/admin-guide/cgroup-v2.rst | 20 +++--- mm/memcontrol.c | 23 ++++++ .../selftests/cgroup/test_memcontrol.c | 72 ++++++++++++++++--- 3 files changed, 99 insertions(+), 16 deletions(-) diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admin-guide/cgroup-v2.rst index 3f85254f3cef..95af0628dc44 100644 --- a/Documentation/admin-guide/cgroup-v2.rst +++ b/Documentation/admin-guide/cgroup-v2.rst @@ -1305,11 +1305,13 @@ PAGE_SIZE multiple when read back. reclaim induced by memory.reclaim. memory.peak - A read-only single value file which exists on non-root - cgroups. + A read-write single value file which exists on non-root cgroups. + + The max memory usage recorded for the cgroup and its descendants since + either the creation of the cgroup or the most recent reset. - The max memory usage recorded for the cgroup and its - descendants since the creation of the cgroup. + Any non-empty write to this file resets it to the current memory usage. + All content written is completely ignored. memory.oom.group A read-write single value file which exists on non-root @@ -1626,11 +1628,13 @@ PAGE_SIZE multiple when read back. Healthy workloads are not expected to reach this limit. memory.swap.peak - A read-only single value file which exists on non-root - cgroups. + A read-write single value file which exists on non-root cgroups. + + The max swap usage recorded for the cgroup and its descendants since + the creation of the cgroup or the most recent reset. - The max swap usage recorded for the cgroup and its - descendants since the creation of the cgroup. + Any non-empty write to this file resets it to the current swap usage. + All content written is completely ignored. memory.swap.max A read-write single value file which exists on non-root diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 1c1061df9cd1..b04af158922d 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -25,6 +25,7 @@ * Copyright (C) 2020 Alibaba, Inc, Alex Shi */ +#include #include #include #include @@ -6635,6 +6636,16 @@ static u64 memory_peak_read(struct cgroup_subsys_state *css, return (u64)memcg->memory.watermark * PAGE_SIZE; } +static ssize_t memory_peak_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off) +{ + struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of)); + + page_counter_reset_watermark(&memcg->memory); + + return nbytes; +} + static int memory_min_show(struct seq_file *m, void *v) { return seq_puts_memcg_tunable(m, @@ -6947,6 +6958,7 @@ static struct cftype memory_files[] = { .name = "peak", .flags = CFTYPE_NOT_ON_ROOT, .read_u64 = memory_peak_read, + .write = memory_peak_write, }, { .name = "min", @@ -7917,6 +7929,16 @@ static u64 swap_peak_read(struct cgroup_subsys_state *css, return (u64)memcg->swap.watermark * PAGE_SIZE; } +static ssize_t swap_peak_write(struct kernfs_open_file *of, + char *buf, size_t nbytes, loff_t off) +{ + struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of)); + + page_counter_reset_watermark(&memcg->swap); + + return nbytes; +} + static int swap_high_show(struct seq_file *m, void *v) { return seq_puts_memcg_tunable(m, @@ -7999,6 +8021,7 @@ static struct cftype swap_files[] = { .name = "swap.peak", .flags = CFTYPE_NOT_ON_ROOT, .read_u64 = swap_peak_read, + .write = swap_peak_write, }, { .name = "swap.events", diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c index c7c9572003a8..0326c317f1f2 100644 --- a/tools/testing/selftests/cgroup/test_memcontrol.c +++ b/tools/testing/selftests/cgroup/test_memcontrol.c @@ -161,12 +161,12 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg) /* * This test create a memory cgroup, allocates * some anonymous memory and some pagecache - * and check memory.current and some memory.stat values. + * and checks memory.current, memory.peak, and some memory.stat values. */ -static int test_memcg_current(const char *root) +static int test_memcg_current_peak(const char *root) { int ret = KSFT_FAIL; - long current; + long current, peak, peak_reset; char *memcg; memcg = cg_name(root, "memcg_test"); @@ -180,12 +180,32 @@ static int test_memcg_current(const char *root) if (current != 0) goto cleanup; + peak = cg_read_long(memcg, "memory.peak"); + if (peak != 0) + goto cleanup; + if (cg_run(memcg, alloc_anon_50M_check, NULL)) goto cleanup; + peak = cg_read_long(memcg, "memory.peak"); + if (peak < MB(50)) + goto cleanup; + + peak_reset = cg_write(memcg, "memory.peak", "\n"); + if (peak_reset != 0) + goto cleanup; + + peak = cg_read_long(memcg, "memory.peak"); + if (peak > MB(30)) + goto cleanup; + if (cg_run(memcg, alloc_pagecache_50M_check, NULL)) goto cleanup; + peak = cg_read_long(memcg, "memory.peak"); + if (peak < MB(50)) + goto cleanup; + ret = KSFT_PASS; cleanup: @@ -815,13 +835,14 @@ static int alloc_anon_50M_check_swap(const char *cgroup, void *arg) /* * This test checks that memory.swap.max limits the amount of - * anonymous memory which can be swapped out. + * anonymous memory which can be swapped out. Additionally, it verifies that + * memory.swap.peak reflects the high watermark and can be reset. */ -static int test_memcg_swap_max(const char *root) +static int test_memcg_swap_max_peak(const char *root) { int ret = KSFT_FAIL; char *memcg; - long max; + long max, peak; if (!is_swap_enabled()) return KSFT_SKIP; @@ -838,6 +859,12 @@ static int test_memcg_swap_max(const char *root) goto cleanup; } + if (cg_read_long(memcg, "memory.swap.peak")) + goto cleanup; + + if (cg_read_long(memcg, "memory.peak")) + goto cleanup; + if (cg_read_strcmp(memcg, "memory.max", "max\n")) goto cleanup; @@ -860,6 +887,27 @@ static int test_memcg_swap_max(const char *root) if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1) goto cleanup; + peak = cg_read_long(memcg, "memory.peak"); + if (peak < MB(29)) + goto cleanup; + + peak = cg_read_long(memcg, "memory.swap.peak"); + if (peak < MB(29)) + goto cleanup; + + if (cg_write(memcg, "memory.swap.peak", "\n")) + goto cleanup; + + if (cg_read_long(memcg, "memory.swap.peak") > MB(10)) + goto cleanup; + + + if (cg_write(memcg, "memory.peak", "\n")) + goto cleanup; + + if (cg_read_long(memcg, "memory.peak")) + goto cleanup; + if (cg_run(memcg, alloc_anon_50M_check_swap, (void *)MB(30))) goto cleanup; @@ -867,6 +915,14 @@ static int test_memcg_swap_max(const char *root) if (max <= 0) goto cleanup; + peak = cg_read_long(memcg, "memory.peak"); + if (peak < MB(29)) + goto cleanup; + + peak = cg_read_long(memcg, "memory.swap.peak"); + if (peak < MB(19)) + goto cleanup; + ret = KSFT_PASS; cleanup: @@ -1293,7 +1349,7 @@ struct memcg_test { const char *name; } tests[] = { T(test_memcg_subtree_control), - T(test_memcg_current), + T(test_memcg_current_peak), T(test_memcg_min), T(test_memcg_low), T(test_memcg_high), @@ -1301,7 +1357,7 @@ struct memcg_test { T(test_memcg_max), T(test_memcg_reclaim), T(test_memcg_oom_events), - T(test_memcg_swap_max), + T(test_memcg_swap_max_peak), T(test_memcg_sock), T(test_memcg_oom_group_leaf_events), T(test_memcg_oom_group_parent_events),