From: Wilson Felipe Pereira <wfelipe@google.com>
To: tj@kernel.org, hannes@cmpxchg.org, mkoutny@suse.com, shuah@kernel.org
Cc: mhocko@kernel.org, roman.gushchin@linux.dev,
shakeel.butt@linux.dev, muchun.song@linux.dev,
osalvador@suse.de, david@kernel.org, yosry@kernel.org,
nphamcs@gmail.com, chengming.zhou@linux.dev,
cgroups@vger.kernel.org, linux-kselftest@vger.kernel.org,
linux-mm@kvack.org, linux-kernel@vger.kernel.org,
Wilson Felipe Pereira <wfelipe@google.com>
Subject: [PATCH v2] selftests/cgroup: convert cg_read_*long*() helpers to s64
Date: Fri, 6 Nov 2026 18:55:06 +0000 [thread overview]
Message-ID: <20261106185520.290139-1-wfelipe@google.com> (raw)
Cgroup byte and time counters in control files (such as memory.current,
memory.peak, memory.stat, and cpu.stat) are exported by the kernel as
64-bit values, while cg_read_long(), cg_read_long_fd(), and
cg_read_key_long() parse them with atol() and return a signed long. On
32-bit platforms, atol() clamps values above 2 GiB to LONG_MAX.
Although current tests do not allocate enough memory to hit LONG_MAX,
converting these helpers to 64-bit keeps the selftest types consistent
with the kernel counters and avoids 32-bit truncation:
- Define s64 as int64_t in cgroup_util.h (matching
tools/include/linux/types.h) and use PRId64 from <inttypes.h>.
- Convert cg_read_long(), cg_read_long_fd(), cg_read_key_long(), and
cg_read_key_long_poll() to cg_read_s64(), cg_read_s64_fd(),
cg_read_key_s64(), and cg_read_key_s64_poll() using atoll().
- Update cg_write_numeric(), values_close(), and values_close_report()
to take s64 and use llabs().
- Update callers across the cgroup selftests to use s64 and PRId64.
Suggested-by: Michal Koutný <mkoutny@suse.com>
Signed-off-by: Wilson Felipe Pereira <wfelipe@google.com>
---
v1 -> v2:
- Rebase on linus/master (v7.4-rc1+) and convert the new
cg_read_key_long() call in test_pids_events_notify() (Tejun Heo).
- Define s64 as int64_t in cgroup_util.h (matching
tools/include/linux/types.h) and use PRId64 from <inttypes.h> to fix
the KVM selftests build failure (Tejun Heo).
- Convert cg_read_long(), cg_read_long_fd(), and cg_write_numeric() to
s64 alongside the remaining callers in test_freezer.c, test_cpu.c,
test_hugetlb_memcg.c, test_kmem.c, test_memcontrol.c, and test_zswap.c
(Tejun Heo).
- Update commit description to note atol() saturates at LONG_MAX and
clean up stray whitespace/alignment changes (Tejun Heo).
v1: https://lore.kernel.org/all/20261022042921.711624-1-wfelipe@google.com/
.../selftests/cgroup/lib/cgroup_util.c | 26 +--
.../cgroup/lib/include/cgroup_util.h | 32 +--
tools/testing/selftests/cgroup/test_cpu.c | 48 ++---
tools/testing/selftests/cgroup/test_freezer.c | 88 +++++----
.../selftests/cgroup/test_hugetlb_memcg.c | 26 +--
tools/testing/selftests/cgroup/test_kmem.c | 62 +++---
.../selftests/cgroup/test_memcontrol.c | 183 +++++++++---------
tools/testing/selftests/cgroup/test_pids.c | 6 +-
tools/testing/selftests/cgroup/test_zswap.c | 77 ++++----
9 files changed, 284 insertions(+), 264 deletions(-)
diff --git a/tools/testing/selftests/cgroup/lib/cgroup_util.c b/tools/testing/selftests/cgroup/lib/cgroup_util.c
index 823b0312b2b2..279dfc5acfe1 100644
--- a/tools/testing/selftests/cgroup/lib/cgroup_util.c
+++ b/tools/testing/selftests/cgroup/lib/cgroup_util.c
@@ -175,27 +175,27 @@ int cg_read_strstr(const char *cgroup, const char *control, const char *needle)
return strstr(buf, needle) ? 0 : -1;
}
-long cg_read_long(const char *cgroup, const char *control)
+s64 cg_read_s64(const char *cgroup, const char *control)
{
char buf[128];
if (cg_read(cgroup, control, buf, sizeof(buf)))
return -1;
- return atol(buf);
+ return atoll(buf);
}
-long cg_read_long_fd(int fd)
+s64 cg_read_s64_fd(int fd)
{
char buf[128];
if (pread(fd, buf, sizeof(buf), 0) <= 0)
return -1;
- return atol(buf);
+ return atoll(buf);
}
-long cg_read_key_long(const char *cgroup, const char *control, const char *key)
+s64 cg_read_key_s64(const char *cgroup, const char *control, const char *key)
{
char buf[BUF_SIZE];
char *ptr;
@@ -207,18 +207,18 @@ long cg_read_key_long(const char *cgroup, const char *control, const char *key)
if (!ptr)
return -1;
- return atol(ptr + strlen(key));
+ return atoll(ptr + strlen(key));
}
-long cg_read_key_long_poll(const char *cgroup, const char *control,
- const char *key, long expected, int retries,
- useconds_t wait_interval_us)
+s64 cg_read_key_s64_poll(const char *cgroup, const char *control,
+ const char *key, s64 expected, int retries,
+ useconds_t wait_interval_us)
{
- long val = -1;
+ s64 val = -1;
int i;
for (i = 0; i < retries; i++) {
- val = cg_read_key_long(cgroup, control, key);
+ val = cg_read_key_s64(cgroup, control, key);
if (val < 0)
return val;
@@ -270,12 +270,12 @@ int cg_open(const char *cgroup, const char *control, int flags)
return open(path, flags);
}
-int cg_write_numeric(const char *cgroup, const char *control, long value)
+int cg_write_numeric(const char *cgroup, const char *control, s64 value)
{
char buf[64];
int ret;
- ret = sprintf(buf, "%lu", value);
+ ret = sprintf(buf, "%" PRId64, value);
if (ret < 0)
return ret;
diff --git a/tools/testing/selftests/cgroup/lib/include/cgroup_util.h b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
index 5307f3bf32a0..bc0dd25f24ee 100644
--- a/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
+++ b/tools/testing/selftests/cgroup/lib/include/cgroup_util.h
@@ -1,7 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0 */
+#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
+typedef int64_t s64;
+
#ifndef BUF_SIZE
#define BUF_SIZE 4096
#endif
@@ -27,26 +30,27 @@
/*
* Checks if two given values differ by less than err% of their sum.
*/
-static inline int values_close(long a, long b, int err)
+static inline int values_close(s64 a, s64 b, int err)
{
- return labs(a - b) <= (a + b) / 100 * err;
+ return llabs(a - b) <= (a + b) / 100 * err;
}
/*
* Checks if two given values differ by less than err% of their sum and assert
* with detailed debug info if not.
*/
-static inline int values_close_report(long a, long b, int err)
+static inline int values_close_report(s64 a, s64 b, int err)
{
- long diff = labs(a - b);
- long limit = (a + b) / 100 * err;
+ s64 diff = llabs(a - b);
+ s64 limit = (a + b) / 100 * err;
double actual_err = (a + b) ? (100.0 * diff / (a + b)) : 0.0;
int close = diff <= limit;
if (!close)
fprintf(stderr,
- "[FAIL] actual=%ld expected=%ld | diff=%ld | limit=%ld | "
- "tolerance=%d%% | actual_error=%.2f%%\n",
+ "[FAIL] actual=%" PRId64 " expected=%" PRId64
+ " | diff=%" PRId64 " | limit=%" PRId64
+ " | tolerance=%d%% | actual_error=%.2f%%\n",
a, b, diff, limit, err, actual_err);
return close;
@@ -70,16 +74,16 @@ extern int cg_read_strcmp_wait(const char *cgroup, const char *control,
const char *expected);
extern int cg_read_strstr(const char *cgroup, const char *control,
const char *needle);
-extern long cg_read_long(const char *cgroup, const char *control);
-extern long cg_read_long_fd(int fd);
-long cg_read_key_long(const char *cgroup, const char *control, const char *key);
-long cg_read_key_long_poll(const char *cgroup, const char *control,
- const char *key, long expected, int retries,
- useconds_t wait_interval_us);
+s64 cg_read_s64(const char *cgroup, const char *control);
+s64 cg_read_s64_fd(int fd);
+s64 cg_read_key_s64(const char *cgroup, const char *control, const char *key);
+s64 cg_read_key_s64_poll(const char *cgroup, const char *control,
+ const char *key, s64 expected, int retries,
+ useconds_t wait_interval_us);
extern long cg_read_lc(const char *cgroup, const char *control);
extern int cg_write(const char *cgroup, const char *control, char *buf);
extern int cg_open(const char *cgroup, const char *control, int flags);
-int cg_write_numeric(const char *cgroup, const char *control, long value);
+int cg_write_numeric(const char *cgroup, const char *control, s64 value);
extern int cg_run(const char *cgroup,
int (*fn)(const char *cgroup, void *arg),
void *arg);
diff --git a/tools/testing/selftests/cgroup/test_cpu.c b/tools/testing/selftests/cgroup/test_cpu.c
index 3456e3e988c6..1db8ff3f0e5c 100644
--- a/tools/testing/selftests/cgroup/test_cpu.c
+++ b/tools/testing/selftests/cgroup/test_cpu.c
@@ -24,7 +24,7 @@ enum hog_clock_type {
struct cpu_hogger {
char *cgroup;
pid_t pid;
- long usage;
+ s64 usage;
};
struct cpu_hog_func_param {
@@ -185,7 +185,7 @@ static int hog_cpus_timed(const char *cgroup, void *arg)
static int test_cpucg_stats(const char *root)
{
int ret = KSFT_FAIL;
- long usage_usec, user_usec, system_usec;
+ s64 usage_usec, user_usec, system_usec;
long usage_seconds = 2;
long expected_usage_usec = usage_seconds * USEC_PER_SEC;
char *cpucg;
@@ -197,9 +197,9 @@ static int test_cpucg_stats(const char *root)
if (cg_create(cpucg))
goto cleanup;
- usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
- user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
- system_usec = cg_read_key_long(cpucg, "cpu.stat", "system_usec");
+ usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
+ user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+ system_usec = cg_read_key_s64(cpucg, "cpu.stat", "system_usec");
if (usage_usec != 0 || user_usec != 0 || system_usec != 0)
goto cleanup;
@@ -214,8 +214,8 @@ static int test_cpucg_stats(const char *root)
if (cg_run(cpucg, hog_cpus_timed, (void *)¶m))
goto cleanup;
- usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
- user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
+ usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
+ user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
if (user_usec <= 0)
goto cleanup;
@@ -239,7 +239,7 @@ static int test_cpucg_nice(const char *root)
{
int ret = KSFT_FAIL;
int status;
- long user_usec, nice_usec;
+ s64 user_usec, nice_usec;
long usage_seconds = 2;
long expected_nice_usec = usage_seconds * USEC_PER_SEC;
char *cpucg;
@@ -252,8 +252,8 @@ static int test_cpucg_nice(const char *root)
if (cg_create(cpucg))
goto cleanup;
- user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
- nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");
+ user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+ nice_usec = cg_read_key_s64(cpucg, "cpu.stat", "nice_usec");
if (nice_usec == -1)
ret = KSFT_SKIP;
if (user_usec != 0 || nice_usec != 0)
@@ -289,8 +289,8 @@ static int test_cpucg_nice(const char *root)
if (!WIFEXITED(status))
goto cleanup;
- user_usec = cg_read_key_long(cpucg, "cpu.stat", "user_usec");
- nice_usec = cg_read_key_long(cpucg, "cpu.stat", "nice_usec");
+ user_usec = cg_read_key_s64(cpucg, "cpu.stat", "user_usec");
+ nice_usec = cg_read_key_s64(cpucg, "cpu.stat", "nice_usec");
if (user_usec <= 0)
goto cleanup;
if (!values_close_report(nice_usec, expected_nice_usec, 1))
@@ -357,8 +357,8 @@ run_cpucg_weight_test(
}
for (i = 0; i < ARRAY_SIZE(children); i++)
- children[i].usage = cg_read_key_long(children[i].cgroup,
- "cpu.stat", "usage_usec");
+ children[i].usage = cg_read_key_s64(children[i].cgroup,
+ "cpu.stat", "usage_usec");
if (validate(children, ARRAY_SIZE(children)))
goto cleanup;
@@ -400,7 +400,7 @@ overprovision_validate(const struct cpu_hogger *children, int num_children)
int ret = KSFT_FAIL, i;
for (i = 0; i < num_children - 1; i++) {
- long delta;
+ s64 delta;
if (children[i + 1].usage <= children[i].usage)
goto cleanup;
@@ -486,7 +486,7 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
int ret = KSFT_FAIL, i;
char *parent = NULL, *child = NULL;
struct cpu_hogger leaf[3] = {};
- long nested_leaf_usage, child_usage;
+ s64 nested_leaf_usage, child_usage;
int nprocs = get_nprocs();
if (!overprovisioned) {
@@ -567,8 +567,8 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
}
for (i = 0; i < ARRAY_SIZE(leaf); i++) {
- leaf[i].usage = cg_read_key_long(leaf[i].cgroup,
- "cpu.stat", "usage_usec");
+ leaf[i].usage = cg_read_key_s64(leaf[i].cgroup, "cpu.stat",
+ "usage_usec");
if (leaf[i].usage <= 0)
goto cleanup;
}
@@ -581,7 +581,7 @@ run_cpucg_nested_weight_test(const char *root, bool overprovisioned)
goto cleanup;
- child_usage = cg_read_key_long(child, "cpu.stat", "usage_usec");
+ child_usage = cg_read_key_s64(child, "cpu.stat", "usage_usec");
if (child_usage <= 0)
goto cleanup;
if (!values_close_report(child_usage, nested_leaf_usage, 1))
@@ -679,7 +679,8 @@ static int test_cpucg_max(const char *root)
long duration_seconds = 1;
long duration_usec;
- long usage_usec, n_periods, remainder_usec, expected_usage_usec;
+ long n_periods, remainder_usec, expected_usage_usec;
+ s64 usage_usec;
char *cpucg;
char quota_buf[32];
@@ -708,7 +709,7 @@ static int test_cpucg_max(const char *root)
if (cg_run(cpucg, hog_cpus_timed, (void *)¶m))
goto cleanup;
- usage_usec = cg_read_key_long(cpucg, "cpu.stat", "usage_usec");
+ usage_usec = cg_read_key_s64(cpucg, "cpu.stat", "usage_usec");
if (usage_usec <= 0)
goto cleanup;
@@ -746,7 +747,8 @@ static int test_cpucg_max_nested(const char *root)
long duration_seconds = 1;
long duration_usec;
- long usage_usec, n_periods, remainder_usec, expected_usage_usec;
+ long n_periods, remainder_usec, expected_usage_usec;
+ s64 usage_usec;
char *parent, *child;
char quota_buf[32];
@@ -782,7 +784,7 @@ static int test_cpucg_max_nested(const char *root)
if (cg_run(child, hog_cpus_timed, (void *)¶m))
goto cleanup;
- usage_usec = cg_read_key_long(child, "cpu.stat", "usage_usec");
+ usage_usec = cg_read_key_s64(child, "cpu.stat", "usage_usec");
if (usage_usec <= 0)
goto cleanup;
diff --git a/tools/testing/selftests/cgroup/test_freezer.c b/tools/testing/selftests/cgroup/test_freezer.c
index f28bb02e9783..266b1a0f889f 100644
--- a/tools/testing/selftests/cgroup/test_freezer.c
+++ b/tools/testing/selftests/cgroup/test_freezer.c
@@ -807,10 +807,9 @@ static int test_cgfreezer_vfork(const char *root)
/*
* Get the current frozen_usec for the cgroup.
*/
-static long cg_check_freezetime(const char *cgroup)
+static s64 cg_check_freezetime(const char *cgroup)
{
- return cg_read_key_long(cgroup, "cgroup.stat.local",
- "frozen_usec ");
+ return cg_read_key_s64(cgroup, "cgroup.stat.local", "frozen_usec ");
}
/*
@@ -820,7 +819,7 @@ static int test_cgfreezer_time_empty(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
- long prev, curr;
+ s64 prev, curr;
cgroup = cg_name(root, "cg_time_test_empty");
if (!cgroup)
@@ -839,7 +838,7 @@ static int test_cgfreezer_time_empty(const char *root)
goto cleanup;
}
if (curr > 0) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -853,7 +852,7 @@ static int test_cgfreezer_time_empty(const char *root)
usleep(1000);
curr = cg_check_freezetime(cgroup);
if (curr < 1000) {
- debug("Expect time (%ld) to be at least 1000 us\n",
+ debug("Expect time (%" PRId64 ") to be at least 1000 us\n",
curr);
goto cleanup;
}
@@ -867,7 +866,7 @@ static int test_cgfreezer_time_empty(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -879,8 +878,8 @@ static int test_cgfreezer_time_empty(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
- debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
- curr, prev);
+ debug("Expect time (%" PRId64 ") to be unchanged from previous check (%"
+ PRId64 ")\n", curr, prev);
goto cleanup;
}
@@ -902,7 +901,7 @@ static int test_cgfreezer_time_simple(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
- long prev, curr;
+ s64 prev, curr;
cgroup = cg_name(root, "cg_time_test_simple");
if (!cgroup)
@@ -920,7 +919,7 @@ static int test_cgfreezer_time_simple(const char *root)
goto cleanup;
}
if (curr > 0) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -932,7 +931,7 @@ static int test_cgfreezer_time_simple(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr > prev) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -947,7 +946,7 @@ static int test_cgfreezer_time_simple(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr < 1000) {
- debug("Expect time (%ld) to be at least 1000 us\n",
+ debug("Expect time (%" PRId64 ") to be at least 1000 us\n",
curr);
goto cleanup;
}
@@ -961,7 +960,7 @@ static int test_cgfreezer_time_simple(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -974,8 +973,8 @@ static int test_cgfreezer_time_simple(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
- debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
- curr, prev);
+ debug("Expect time (%" PRId64 ") to be unchanged from previous check (%"
+ PRId64 ")\n", curr, prev);
goto cleanup;
}
@@ -996,7 +995,7 @@ static int test_cgfreezer_time_populate(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
- long prev, curr;
+ s64 prev, curr;
int i;
cgroup = cg_name(root, "cg_time_test_populate");
@@ -1012,7 +1011,7 @@ static int test_cgfreezer_time_populate(const char *root)
goto cleanup;
}
if (curr > 0) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -1025,7 +1024,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -1038,7 +1037,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
- debug("Expect time (%ld) to be 0\n", curr);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr);
goto cleanup;
}
@@ -1051,7 +1050,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -1061,7 +1060,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -1075,7 +1074,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -1089,7 +1088,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -1103,8 +1102,8 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
- debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
- curr, prev);
+ debug("Expect time (%" PRId64 ") to be unchanged from previous check (%"
+ PRId64 ")\n", curr, prev);
goto cleanup;
}
@@ -1119,7 +1118,7 @@ static int test_cgfreezer_time_populate(const char *root)
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr, prev);
goto cleanup;
}
@@ -1140,7 +1139,7 @@ static int test_cgfreezer_time_populate(const char *root)
*/
static int test_cgfreezer_time_migrate(const char *root)
{
- long prev_A, curr_A, curr_B;
+ s64 prev_A, curr_A, curr_B;
char *cgroup[2] = {0};
int ret = KSFT_FAIL;
int pid;
@@ -1173,12 +1172,12 @@ static int test_cgfreezer_time_migrate(const char *root)
curr_A = cg_check_freezetime(cgroup[0]);
if (curr_A) {
- debug("Expect time (%ld) to be 0\n", curr_A);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr_A);
goto cleanup;
}
curr_B = cg_check_freezetime(cgroup[1]);
if (curr_B) {
- debug("Expect time (%ld) to be 0\n", curr_B);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr_B);
goto cleanup;
}
@@ -1190,7 +1189,7 @@ static int test_cgfreezer_time_migrate(const char *root)
prev_A = curr_A;
curr_A = cg_check_freezetime(cgroup[0]);
if (curr_A <= prev_A) {
- debug("Expect time (%ld) to be > 0\n", curr_A);
+ debug("Expect time (%" PRId64 ") to be > 0\n", curr_A);
goto cleanup;
}
@@ -1203,14 +1202,14 @@ static int test_cgfreezer_time_migrate(const char *root)
usleep(1000);
curr_B = cg_check_freezetime(cgroup[1]);
if (curr_B) {
- debug("Expect time (%ld) to be 0\n", curr_B);
+ debug("Expect time (%" PRId64 ") to be 0\n", curr_B);
goto cleanup;
}
prev_A = curr_A;
curr_A = cg_check_freezetime(cgroup[0]);
if (curr_A <= prev_A) {
- debug("Expect time (%ld) to be more than previous check (%ld)\n",
+ debug("Expect time (%" PRId64 ") to be more than previous check (%" PRId64 ")\n",
curr_A, prev_A);
goto cleanup;
}
@@ -1238,7 +1237,7 @@ static int test_cgfreezer_time_parent(const char *root)
{
char *parent, *child = NULL;
int ret = KSFT_FAIL;
- long ptime, ctime;
+ s64 ptime, ctime;
parent = cg_name(root, "cg_test_parent_A");
if (!parent)
@@ -1277,7 +1276,8 @@ static int test_cgfreezer_time_parent(const char *root)
ptime = cg_check_freezetime(parent);
ctime = cg_check_freezetime(child);
if (ptime <= ctime) {
- debug("Expect ptime (%ld) > ctime (%ld)\n", ptime, ctime);
+ debug("Expect ptime (%" PRId64 ") > ctime (%" PRId64 ")\n",
+ ptime, ctime);
goto cleanup;
}
@@ -1296,7 +1296,8 @@ static int test_cgfreezer_time_parent(const char *root)
ptime = cg_check_freezetime(parent);
if (ctime <= ptime) {
- debug("Expect ctime (%ld) > ptime (%ld)\n", ctime, ptime);
+ debug("Expect ctime (%" PRId64 ") > ptime (%" PRId64 ")\n",
+ ctime, ptime);
goto cleanup;
}
@@ -1321,7 +1322,7 @@ static int test_cgfreezer_time_child(const char *root)
{
char *parent, *child = NULL;
int ret = KSFT_FAIL;
- long ptime, ctime;
+ s64 ptime, ctime;
parent = cg_name(root, "cg_test_child_A");
if (!parent)
@@ -1348,12 +1349,13 @@ static int test_cgfreezer_time_child(const char *root)
ctime = cg_check_freezetime(child);
ptime = cg_check_freezetime(parent);
if (ptime != 0) {
- debug("Expect ptime (%ld) to be 0\n", ptime);
+ debug("Expect ptime (%" PRId64 ") to be 0\n", ptime);
goto cleanup;
}
if (ctime <= ptime) {
- debug("Expect ctime (%ld) > ptime (%ld)\n", ctime, ptime);
+ debug("Expect ctime (%" PRId64 ") > ptime (%" PRId64 ")\n",
+ ctime, ptime);
goto cleanup;
}
@@ -1386,7 +1388,7 @@ static int test_cgfreezer_time_nested(const char *root)
{
char *cgroup[3] = {0};
int ret = KSFT_FAIL;
- long time[3] = {0};
+ s64 time[3] = {0};
int i;
cgroup[0] = cg_name(root, "cg_test_time_A");
@@ -1440,12 +1442,14 @@ static int test_cgfreezer_time_nested(const char *root)
time[0] = cg_check_freezetime(cgroup[0]);
if (time[2] <= time[1]) {
- debug("Expect C's time (%ld) > B's time (%ld)", time[2], time[1]);
+ debug("Expect C's time (%" PRId64 ") > B's time (%" PRId64 ")",
+ time[2], time[1]);
goto cleanup;
}
if (time[1] <= time[0]) {
- debug("Expect B's time (%ld) > A's time (%ld)", time[1], time[0]);
+ debug("Expect B's time (%" PRId64 ") > A's time (%" PRId64 ")",
+ time[1], time[0]);
goto cleanup;
}
diff --git a/tools/testing/selftests/cgroup/test_hugetlb_memcg.c b/tools/testing/selftests/cgroup/test_hugetlb_memcg.c
index 8c5aced813b6..803248c496e4 100644
--- a/tools/testing/selftests/cgroup/test_hugetlb_memcg.c
+++ b/tools/testing/selftests/cgroup/test_hugetlb_memcg.c
@@ -96,16 +96,17 @@ static int hugetlb_test_program(const char *cgroup, void *arg)
{
char *test_group = (char *)arg;
void *addr;
- long old_current, expected_current, current;
+ s64 old_current, expected_current, current;
int ret = EXIT_FAILURE;
- old_current = cg_read_long(test_group, "memory.current");
+ old_current = cg_read_s64(test_group, "memory.current");
set_nr_hugepages(20);
- current = cg_read_long(test_group, "memory.current");
+ current = cg_read_s64(test_group, "memory.current");
if (current - old_current >= MB(2)) {
ksft_print_msg(
"setting nr_hugepages should not increase hugepage usage.\n");
- ksft_print_msg("before: %ld, after: %ld\n", old_current, current);
+ ksft_print_msg("before: %" PRId64 ", after: %" PRId64 "\n",
+ old_current, current);
return EXIT_FAILURE;
}
@@ -114,10 +115,11 @@ static int hugetlb_test_program(const char *cgroup, void *arg)
ksft_print_msg("fail to mmap.\n");
return EXIT_FAILURE;
}
- current = cg_read_long(test_group, "memory.current");
+ current = cg_read_s64(test_group, "memory.current");
if (current - old_current >= MB(2)) {
ksft_print_msg("mmap should not increase hugepage usage.\n");
- ksft_print_msg("before: %ld, after: %ld\n", old_current, current);
+ ksft_print_msg("before: %" PRId64 ", after: %" PRId64 "\n",
+ old_current, current);
goto out_failed_munmap;
}
old_current = current;
@@ -125,35 +127,35 @@ static int hugetlb_test_program(const char *cgroup, void *arg)
/* read the first page */
check_first(addr);
expected_current = old_current + MB(2);
- current = cg_read_long(test_group, "memory.current");
+ current = cg_read_s64(test_group, "memory.current");
if (!values_close(expected_current, current, 5)) {
ksft_print_msg("memory usage should increase by around 2MB.\n");
ksft_print_msg(
- "expected memory: %ld, actual memory: %ld\n",
+ "expected memory: %" PRId64 ", actual memory: %" PRId64 "\n",
expected_current, current);
goto out_failed_munmap;
}
/* write to the whole range */
write_data(addr);
- current = cg_read_long(test_group, "memory.current");
+ current = cg_read_s64(test_group, "memory.current");
expected_current = old_current + MB(8);
if (!values_close(expected_current, current, 5)) {
ksft_print_msg("memory usage should increase by around 8MB.\n");
ksft_print_msg(
- "expected memory: %ld, actual memory: %ld\n",
+ "expected memory: %" PRId64 ", actual memory: %" PRId64 "\n",
expected_current, current);
goto out_failed_munmap;
}
/* unmap the whole range */
munmap(addr, LENGTH);
- current = cg_read_long(test_group, "memory.current");
+ current = cg_read_s64(test_group, "memory.current");
expected_current = old_current;
if (!values_close(expected_current, current, 5)) {
ksft_print_msg("memory usage should go back down.\n");
ksft_print_msg(
- "expected memory: %ld, actual memory: %ld\n",
+ "expected memory: %" PRId64 ", actual memory: %" PRId64 "\n",
expected_current, current);
return ret;
}
diff --git a/tools/testing/selftests/cgroup/test_kmem.c b/tools/testing/selftests/cgroup/test_kmem.c
index 30af47ad6979..43a8eb094f48 100644
--- a/tools/testing/selftests/cgroup/test_kmem.c
+++ b/tools/testing/selftests/cgroup/test_kmem.c
@@ -54,7 +54,7 @@ static int test_kmem_basic(const char *root)
{
int ret = KSFT_FAIL;
char *cg = NULL;
- long slab0, slab1, current;
+ s64 slab0, slab1, current;
cg = cg_name(root, "kmem_basic_test");
if (!cg)
@@ -66,7 +66,7 @@ static int test_kmem_basic(const char *root)
if (cg_run(cg, alloc_dcache, (void *)100000))
goto cleanup;
- slab0 = cg_read_key_long(cg, "memory.stat", "slab ");
+ slab0 = cg_read_key_s64(cg, "memory.stat", "slab ");
if (slab0 < (1 << 20))
goto cleanup;
@@ -75,11 +75,11 @@ static int test_kmem_basic(const char *root)
/* wait for RCU freeing */
sleep(1);
- slab1 = cg_read_key_long(cg, "memory.stat", "slab ");
+ slab1 = cg_read_key_s64(cg, "memory.stat", "slab ");
if (slab1 < 0)
goto cleanup;
- current = cg_read_long(cg, "memory.current");
+ current = cg_read_s64(cg, "memory.current");
if (current < 0)
goto cleanup;
@@ -167,7 +167,7 @@ static int cg_run_in_subcgroups(const char *parent,
*/
static int test_kmem_memcg_deletion(const char *root)
{
- long current, anon, file, kernel, sock, sum;
+ s64 current, anon, file, kernel, sock, sum;
int ret = KSFT_FAIL;
char *parent;
@@ -184,24 +184,24 @@ static int test_kmem_memcg_deletion(const char *root)
if (cg_run_in_subcgroups(parent, alloc_kmem_smp, NULL, 100))
goto cleanup;
- current = cg_read_long(parent, "memory.current");
- anon = cg_read_key_long(parent, "memory.stat", "anon ");
- file = cg_read_key_long(parent, "memory.stat", "file ");
- kernel = cg_read_key_long(parent, "memory.stat", "kernel ");
- sock = cg_read_key_long(parent, "memory.stat", "sock ");
+ current = cg_read_s64(parent, "memory.current");
+ anon = cg_read_key_s64(parent, "memory.stat", "anon ");
+ file = cg_read_key_s64(parent, "memory.stat", "file ");
+ kernel = cg_read_key_s64(parent, "memory.stat", "kernel ");
+ sock = cg_read_key_s64(parent, "memory.stat", "sock ");
if (current < 0 || anon < 0 || file < 0 || kernel < 0 || sock < 0)
goto cleanup;
sum = anon + file + kernel + sock;
- if (labs(sum - current) < MAX_VMSTAT_ERROR) {
+ if (llabs(sum - current) < MAX_VMSTAT_ERROR) {
ret = KSFT_PASS;
} else {
- printf("memory.current = %ld\n", current);
- printf("anon + file + kernel + sock = %ld\n", sum);
- printf("anon = %ld\n", anon);
- printf("file = %ld\n", file);
- printf("kernel = %ld\n", kernel);
- printf("sock = %ld\n", sock);
+ printf("memory.current = %" PRId64 "\n", current);
+ printf("anon + file + kernel + sock = %" PRId64 "\n", sum);
+ printf("anon = %" PRId64 "\n", anon);
+ printf("file = %" PRId64 "\n", file);
+ printf("kernel = %" PRId64 "\n", kernel);
+ printf("sock = %" PRId64 "\n", sock);
}
cleanup:
@@ -248,7 +248,7 @@ static int spawn_1000_threads(const char *cgroup, void *arg)
int nr_threads = 1000;
pthread_t *tinfo;
unsigned long i;
- long stack;
+ s64 stack;
int ret = -1;
tinfo = calloc(nr_threads, sizeof(pthread_t));
@@ -263,7 +263,7 @@ static int spawn_1000_threads(const char *cgroup, void *arg)
}
}
- stack = cg_read_key_long(cgroup, "memory.stat", "kernel_stack ");
+ stack = cg_read_key_s64(cgroup, "memory.stat", "kernel_stack ");
if (stack >= 4096 * 1000)
ret = 0;
@@ -307,7 +307,7 @@ static int test_kmem_dead_cgroups(const char *root)
{
int ret = KSFT_FAIL;
char *parent;
- long dead = -1;
+ s64 dead = -1;
parent = cg_name(root, "kmem_dead_cgroups_test");
if (!parent)
@@ -328,9 +328,10 @@ static int test_kmem_dead_cgroups(const char *root)
* from a specific kernel constant, and can be adjusted if reclaim
* behavior changes in the future.
*/
- dead = cg_read_key_long_poll(parent, "cgroup.stat",
- "nr_dying_descendants ", 0, KMEM_DEAD_WAIT_RETRIES,
- DEFAULT_WAIT_INTERVAL_US);
+ dead = cg_read_key_s64_poll(parent, "cgroup.stat",
+ "nr_dying_descendants ", 0,
+ KMEM_DEAD_WAIT_RETRIES,
+ DEFAULT_WAIT_INTERVAL_US);
if (dead)
goto cleanup;
@@ -353,7 +354,7 @@ static int test_percpu_basic(const char *root)
{
int ret = KSFT_FAIL;
char *parent, *child;
- long current, percpu, slab;
+ s64 current, percpu, slab;
int i;
parent = cg_name(root, "percpu_basic_test");
@@ -381,16 +382,17 @@ static int test_percpu_basic(const char *root)
free(child);
}
- current = cg_read_long(parent, "memory.current");
- percpu = cg_read_key_long(parent, "memory.stat", "percpu ");
- slab = cg_read_key_long(parent, "memory.stat", "slab ");
+ current = cg_read_s64(parent, "memory.current");
+ percpu = cg_read_key_s64(parent, "memory.stat", "percpu ");
+ slab = cg_read_key_s64(parent, "memory.stat", "slab ");
if (current > 0 && percpu > 0 && slab >= 0 &&
- labs(current - (percpu + slab)) < MAX_VMSTAT_ERROR)
+ llabs(current - (percpu + slab)) < MAX_VMSTAT_ERROR)
ret = KSFT_PASS;
else
- printf("memory.current %ld\npercpu %ld\nslab %ld\ndelta %ld\n",
- current, percpu, slab, current - (percpu + slab));
+ printf("memory.current %" PRId64 "\npercpu %" PRId64 "\nslab %"
+ PRId64 "\ndelta %" PRId64 "\n",
+ current, percpu, slab, current - (percpu + slab));
cleanup_children:
for (i = 0; i < 1000; i++) {
diff --git a/tools/testing/selftests/cgroup/test_memcontrol.c b/tools/testing/selftests/cgroup/test_memcontrol.c
index bb673012dcf0..9ff43e7c87b4 100644
--- a/tools/testing/selftests/cgroup/test_memcontrol.c
+++ b/tools/testing/selftests/cgroup/test_memcontrol.c
@@ -195,21 +195,21 @@ static int alloc_anon_50M_check(const char *cgroup, void *arg)
{
size_t size = MB(50);
char *buf;
- long anon, current;
+ s64 anon, current;
int ret = -1;
buf = alloc_and_populate_anon(size);
if (!buf)
return -1;
- current = cg_read_long(cgroup, "memory.current");
+ current = cg_read_s64(cgroup, "memory.current");
if (current < size)
goto cleanup;
if (!values_close(size, current, 3))
goto cleanup;
- anon = cg_read_key_long(cgroup, "memory.stat", "anon ");
+ anon = cg_read_key_s64(cgroup, "memory.stat", "anon ");
if (anon < 0)
goto cleanup;
@@ -226,7 +226,7 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
{
size_t size = MB(50);
int ret = -1;
- long current, file;
+ s64 current, file;
int fd;
fd = get_temp_fd();
@@ -236,11 +236,11 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
if (alloc_pagecache(fd, size))
goto cleanup;
- current = cg_read_long(cgroup, "memory.current");
+ current = cg_read_s64(cgroup, "memory.current");
if (current < size)
goto cleanup;
- file = cg_read_key_long(cgroup, "memory.stat", "file ");
+ file = cg_read_key_s64(cgroup, "memory.stat", "file ");
if (file < 0)
goto cleanup;
@@ -262,7 +262,8 @@ static int alloc_pagecache_50M_check(const char *cgroup, void *arg)
static int test_memcg_current_peak(const char *root)
{
int ret = KSFT_FAIL;
- long current, peak, peak_reset;
+ s64 current, peak;
+ long peak_reset;
char *memcg;
bool fd2_closed = false, fd3_closed = false, fd4_closed = false;
int peak_fd = -1, peak_fd2 = -1, peak_fd3 = -1, peak_fd4 = -1;
@@ -275,18 +276,18 @@ static int test_memcg_current_peak(const char *root)
if (cg_create(memcg))
goto cleanup;
- current = cg_read_long(memcg, "memory.current");
+ current = cg_read_s64(memcg, "memory.current");
if (current != 0)
goto cleanup;
- peak = cg_read_long(memcg, "memory.peak");
+ peak = cg_read_s64(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");
+ peak = cg_read_s64(memcg, "memory.peak");
if (peak < MB(50))
goto cleanup;
@@ -342,7 +343,7 @@ static int test_memcg_current_peak(const char *root)
goto cleanup;
/* Make sure a completely independent read isn't affected by our FD-local reset above*/
- peak = cg_read_long(memcg, "memory.peak");
+ peak = cg_read_s64(memcg, "memory.peak");
if (peak < MB(50))
goto cleanup;
@@ -359,23 +360,23 @@ static int test_memcg_current_peak(const char *root)
if (peak_reset != sizeof(reset_string))
goto cleanup;
- peak = cg_read_long_fd(peak_fd);
+ peak = cg_read_s64_fd(peak_fd);
if (peak > MB(30) || peak < 0)
goto cleanup;
if (cg_run(memcg, alloc_pagecache_50M_check, NULL))
goto cleanup;
- peak = cg_read_long(memcg, "memory.peak");
+ peak = cg_read_s64(memcg, "memory.peak");
if (peak < MB(50))
goto cleanup;
/* Make sure everything is back to normal */
- peak = cg_read_long_fd(peak_fd);
+ peak = cg_read_s64_fd(peak_fd);
if (peak < MB(50))
goto cleanup;
- peak = cg_read_long_fd(peak_fd4);
+ peak = cg_read_s64_fd(peak_fd4);
if (peak < MB(50))
goto cleanup;
@@ -451,7 +452,7 @@ static int cg_test_proc_killed(const char *cgroup)
return -1;
}
-static bool reclaim_until(const char *memcg, long goal);
+static bool reclaim_until(const char *memcg, s64 goal);
/*
* First, this test creates the following hierarchy:
@@ -495,8 +496,8 @@ static int test_memcg_protection(const char *root, bool min)
char *parent[3] = {NULL};
char *children[4] = {NULL};
const char *attribute = min ? "memory.min" : "memory.low";
- long c[4];
- long current;
+ s64 c[4];
+ s64 current;
int i, attempts;
int fd;
@@ -519,7 +520,7 @@ static int test_memcg_protection(const char *root, bool min)
if (cg_create(parent[0]))
goto cleanup;
- if (cg_read_long(parent[0], attribute)) {
+ if (cg_read_s64(parent[0], attribute)) {
/* No memory.min on older kernels is fine */
if (min)
ret = KSFT_SKIP;
@@ -571,7 +572,7 @@ static int test_memcg_protection(const char *root, bool min)
goto cleanup;
attempts = 0;
- while (!values_close(cg_read_long(parent[1], "memory.current"),
+ while (!values_close(cg_read_s64(parent[1], "memory.current"),
MB(150), 3)) {
if (attempts++ > 5)
break;
@@ -581,11 +582,11 @@ static int test_memcg_protection(const char *root, bool min)
if (cg_run(parent[2], alloc_anon, (void *)MB(148)))
goto cleanup;
- if (!values_close(cg_read_long(parent[1], "memory.current"), MB(50), 3))
+ if (!values_close(cg_read_s64(parent[1], "memory.current"), MB(50), 3))
goto cleanup;
for (i = 0; i < ARRAY_SIZE(children); i++)
- c[i] = cg_read_long(children[i], "memory.current");
+ c[i] = cg_read_s64(children[i], "memory.current");
if (!values_close(c[0], MB(29), 15))
goto cleanup;
@@ -606,7 +607,7 @@ static int test_memcg_protection(const char *root, bool min)
}
current = min ? MB(50) : MB(30);
- if (!values_close(cg_read_long(parent[1], "memory.current"), current, 3))
+ if (!values_close(cg_read_s64(parent[1], "memory.current"), current, 3))
goto cleanup;
if (!reclaim_until(children[0], MB(10)))
@@ -626,10 +627,10 @@ static int test_memcg_protection(const char *root, bool min)
for (i = 0; i < ARRAY_SIZE(children); i++) {
int ignore_low_events_index = has_recursiveprot ? 2 : -1;
int no_low_events_index = 1;
- long low, oom;
+ s64 low, oom;
- oom = cg_read_key_long(children[i], "memory.events", "oom ");
- low = cg_read_key_long(children[i], "memory.events", "low ");
+ oom = cg_read_key_s64(children[i], "memory.events", "oom ");
+ low = cg_read_key_s64(children[i], "memory.events", "low ");
if (oom)
goto cleanup;
@@ -678,11 +679,11 @@ static int alloc_pagecache_max_30M(const char *cgroup, void *arg)
{
size_t size = MB(50);
int ret = -1;
- long current, high, max;
+ s64 current, high, max;
int fd;
- high = cg_read_long(cgroup, "memory.high");
- max = cg_read_long(cgroup, "memory.max");
+ high = cg_read_s64(cgroup, "memory.high");
+ max = cg_read_s64(cgroup, "memory.max");
if (high != MB(30) && max != MB(30))
return -1;
@@ -693,7 +694,7 @@ static int alloc_pagecache_max_30M(const char *cgroup, void *arg)
if (alloc_pagecache(fd, size))
goto cleanup;
- current = cg_read_long(cgroup, "memory.current");
+ current = cg_read_s64(cgroup, "memory.current");
if (!values_close(current, MB(30), 5))
goto cleanup;
@@ -714,7 +715,7 @@ static int test_memcg_high(const char *root)
{
int ret = KSFT_FAIL;
char *memcg;
- long high;
+ s64 high;
memcg = cg_name(root, "memcg_test");
if (!memcg)
@@ -741,7 +742,7 @@ static int test_memcg_high(const char *root)
if (cg_run(memcg, alloc_pagecache_max_30M, NULL))
goto cleanup;
- high = cg_read_key_long(memcg, "memory.events", "high ");
+ high = cg_read_key_s64(memcg, "memory.events", "high ");
if (high <= 0)
goto cleanup;
@@ -777,8 +778,8 @@ static int test_memcg_high_sync(const char *root)
{
int ret = KSFT_FAIL, pid, fd = -1;
char *memcg;
- long pre_high, pre_max;
- long post_high, post_max;
+ s64 pre_high, pre_max;
+ s64 post_high, post_max;
memcg = cg_name(root, "memcg_test");
if (!memcg)
@@ -787,8 +788,8 @@ static int test_memcg_high_sync(const char *root)
if (cg_create(memcg))
goto cleanup;
- pre_high = cg_read_key_long(memcg, "memory.events", "high ");
- pre_max = cg_read_key_long(memcg, "memory.events", "max ");
+ pre_high = cg_read_key_s64(memcg, "memory.events", "high ");
+ pre_max = cg_read_key_s64(memcg, "memory.events", "max ");
if (pre_high < 0 || pre_max < 0)
goto cleanup;
@@ -811,8 +812,8 @@ static int test_memcg_high_sync(const char *root)
cg_wait_for(fd);
- post_high = cg_read_key_long(memcg, "memory.events", "high ");
- post_max = cg_read_key_long(memcg, "memory.events", "max ");
+ post_high = cg_read_key_s64(memcg, "memory.events", "high ");
+ post_max = cg_read_key_s64(memcg, "memory.events", "max ");
if (post_high < 0 || post_max < 0)
goto cleanup;
@@ -839,7 +840,7 @@ static int test_memcg_max(const char *root)
{
int ret = KSFT_FAIL;
char *memcg;
- long current, max;
+ s64 current, max;
memcg = cg_name(root, "memcg_test");
if (!memcg)
@@ -864,11 +865,11 @@ static int test_memcg_max(const char *root)
if (cg_run(memcg, alloc_pagecache_max_30M, NULL))
goto cleanup;
- current = cg_read_long(memcg, "memory.current");
+ current = cg_read_s64(memcg, "memory.current");
if (current > MB(30) || !current)
goto cleanup;
- max = cg_read_key_long(memcg, "memory.events", "max ");
+ max = cg_read_key_s64(memcg, "memory.events", "max ");
if (max <= 0)
goto cleanup;
@@ -896,15 +897,15 @@ static int test_memcg_max(const char *root)
* false if memory.reclaim's error codes do not make sense, even if
* the usage goal was satisfied.
*/
-static bool reclaim_until(const char *memcg, long goal)
+static bool reclaim_until(const char *memcg, s64 goal)
{
char buf[64];
int retries, err;
- long current, to_reclaim;
+ s64 current, to_reclaim;
bool reclaimed = false;
for (retries = 5; retries > 0; retries--) {
- current = cg_read_long(memcg, "memory.current");
+ current = cg_read_s64(memcg, "memory.current");
if (current < goal || values_close(current, goal, 3))
break;
@@ -913,7 +914,7 @@ static bool reclaim_until(const char *memcg, long goal)
return false;
to_reclaim = current - goal;
- snprintf(buf, sizeof(buf), "%ld", to_reclaim);
+ snprintf(buf, sizeof(buf), "%" PRId64, to_reclaim);
err = cg_write(memcg, "memory.reclaim", buf);
if (!err)
reclaimed = true;
@@ -933,7 +934,7 @@ static int test_memcg_reclaim(const char *root)
int fd = -1;
int retries;
char *memcg;
- long current, expected_usage;
+ s64 current, expected_usage;
memcg = cg_name(root, "memcg_test");
if (!memcg)
@@ -942,7 +943,7 @@ static int test_memcg_reclaim(const char *root)
if (cg_create(memcg))
goto cleanup;
- current = cg_read_long(memcg, "memory.current");
+ current = cg_read_s64(memcg, "memory.current");
if (current != 0)
goto cleanup;
@@ -967,14 +968,14 @@ static int test_memcg_reclaim(const char *root)
* retries).
*/
retries = 5;
- while (!values_close(cg_read_long(memcg, "memory.current"),
- expected_usage, 10)) {
+ while (!values_close(cg_read_s64(memcg, "memory.current"),
+ expected_usage, 10)) {
if (retries--) {
sleep(1);
continue;
} else {
fprintf(stderr,
- "failed to allocate %ld for memcg reclaim test\n",
+ "failed to allocate %" PRId64 " for memcg reclaim test\n",
expected_usage);
goto cleanup;
}
@@ -1001,18 +1002,18 @@ static int alloc_anon_50M_check_swap(const char *cgroup, void *arg)
long mem_max = (long)arg;
size_t size = MB(50);
char *buf;
- long mem_current, swap_current;
+ s64 mem_current, swap_current;
int ret = -1;
buf = alloc_and_populate_anon(size);
if (!buf)
return -1;
- mem_current = cg_read_long(cgroup, "memory.current");
+ mem_current = cg_read_s64(cgroup, "memory.current");
if (!mem_current || !values_close(mem_current, mem_max, 3))
goto cleanup;
- swap_current = cg_read_long(cgroup, "memory.swap.current");
+ swap_current = cg_read_s64(cgroup, "memory.swap.current");
if (!swap_current ||
!values_close(mem_current + swap_current, size, 3))
goto cleanup;
@@ -1032,7 +1033,7 @@ static int test_memcg_swap_max_peak(const char *root)
{
int ret = KSFT_FAIL;
char *memcg;
- long max, peak;
+ s64 max, peak;
struct stat ss;
int swap_peak_fd = -1, mem_peak_fd = -1;
@@ -1049,7 +1050,7 @@ static int test_memcg_swap_max_peak(const char *root)
if (cg_create(memcg))
goto cleanup;
- if (cg_read_long(memcg, "memory.swap.current")) {
+ if (cg_read_s64(memcg, "memory.swap.current")) {
ret = KSFT_SKIP;
goto cleanup;
}
@@ -1081,10 +1082,10 @@ static int test_memcg_swap_max_peak(const char *root)
if (mem_peak_fd == -1)
goto cleanup;
- if (cg_read_long(memcg, "memory.swap.peak"))
+ if (cg_read_s64(memcg, "memory.swap.peak"))
goto cleanup;
- if (cg_read_long_fd(swap_peak_fd))
+ if (cg_read_s64_fd(swap_peak_fd))
goto cleanup;
/* switch the swap and mem fds into local-peak tracking mode*/
@@ -1093,20 +1094,20 @@ static int test_memcg_swap_max_peak(const char *root)
if (peak_reset != sizeof(reset_string))
goto cleanup;
- if (cg_read_long_fd(swap_peak_fd))
+ if (cg_read_s64_fd(swap_peak_fd))
goto cleanup;
- if (cg_read_long(memcg, "memory.peak"))
+ if (cg_read_s64(memcg, "memory.peak"))
goto cleanup;
- if (cg_read_long_fd(mem_peak_fd))
+ if (cg_read_s64_fd(mem_peak_fd))
goto cleanup;
peak_reset = write(mem_peak_fd, reset_string, sizeof(reset_string));
if (peak_reset != sizeof(reset_string))
goto cleanup;
- if (cg_read_long_fd(mem_peak_fd))
+ if (cg_read_s64_fd(mem_peak_fd))
goto cleanup;
if (cg_read_strcmp(memcg, "memory.max", "max\n"))
@@ -1125,25 +1126,25 @@ static int test_memcg_swap_max_peak(const char *root)
if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
goto cleanup;
- if (cg_read_key_long(memcg, "memory.events", "oom ") != 1)
+ if (cg_read_key_s64(memcg, "memory.events", "oom ") != 1)
goto cleanup;
- if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1)
+ if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 1)
goto cleanup;
- peak = cg_read_long(memcg, "memory.peak");
+ peak = cg_read_s64(memcg, "memory.peak");
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long(memcg, "memory.swap.peak");
+ peak = cg_read_s64(memcg, "memory.swap.peak");
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long_fd(mem_peak_fd);
+ peak = cg_read_s64_fd(mem_peak_fd);
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long_fd(swap_peak_fd);
+ peak = cg_read_s64_fd(swap_peak_fd);
if (peak < MB(29))
goto cleanup;
@@ -1168,7 +1169,7 @@ static int test_memcg_swap_max_peak(const char *root)
if (peak_reset != sizeof(reset_string))
goto cleanup;
- peak = cg_read_long_fd(swap_peak_fd);
+ peak = cg_read_s64_fd(swap_peak_fd);
if (peak > MB(10))
goto cleanup;
@@ -1176,36 +1177,36 @@ static int test_memcg_swap_max_peak(const char *root)
* The cgroup is now empty, but there may be a page or two associated
* with the open FD accounted to it.
*/
- peak = cg_read_long_fd(mem_peak_fd);
+ peak = cg_read_s64_fd(mem_peak_fd);
if (peak > MB(1))
goto cleanup;
- if (cg_read_long(memcg, "memory.peak") < MB(29))
+ if (cg_read_s64(memcg, "memory.peak") < MB(29))
goto cleanup;
- if (cg_read_long(memcg, "memory.swap.peak") < MB(29))
+ if (cg_read_s64(memcg, "memory.swap.peak") < MB(29))
goto cleanup;
if (cg_run(memcg, alloc_anon_50M_check_swap, (void *)MB(30)))
goto cleanup;
- max = cg_read_key_long(memcg, "memory.events", "max ");
+ max = cg_read_key_s64(memcg, "memory.events", "max ");
if (max <= 0)
goto cleanup;
- peak = cg_read_long(memcg, "memory.peak");
+ peak = cg_read_s64(memcg, "memory.peak");
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long(memcg, "memory.swap.peak");
+ peak = cg_read_s64(memcg, "memory.swap.peak");
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long_fd(mem_peak_fd);
+ peak = cg_read_s64_fd(mem_peak_fd);
if (peak < MB(29))
goto cleanup;
- peak = cg_read_long_fd(swap_peak_fd);
+ peak = cg_read_s64_fd(swap_peak_fd);
if (peak < MB(19))
goto cleanup;
@@ -1251,10 +1252,10 @@ static int test_memcg_oom_events(const char *root)
if (cg_read_strcmp(memcg, "cgroup.procs", ""))
goto cleanup;
- if (cg_read_key_long(memcg, "memory.events", "oom ") != 1)
+ if (cg_read_key_s64(memcg, "memory.events", "oom ") != 1)
goto cleanup;
- if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 1)
+ if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 1)
goto cleanup;
ret = KSFT_PASS;
@@ -1339,9 +1340,9 @@ static int tcp_client(const char *cgroup, unsigned short port)
long budget = 4 * MEMCG_FLUSH_BYTES;
int rcvbuf = 64 * 1024;
int sk, ret;
- long allocated;
+ s64 allocated;
- allocated = cg_read_long(cgroup, "memory.current");
+ allocated = cg_read_s64(cgroup, "memory.current");
snprintf(servport, sizeof(servport), "%hd", port);
ret = getaddrinfo(server, servport, NULL, &ai);
if (ret)
@@ -1363,7 +1364,7 @@ static int tcp_client(const char *cgroup, unsigned short port)
ret = KSFT_FAIL;
while (budget > 0) {
uint8_t buf[0x100000];
- long current, sock;
+ s64 current, sock;
ssize_t len;
len = read(sk, buf, sizeof(buf));
@@ -1371,8 +1372,8 @@ static int tcp_client(const char *cgroup, unsigned short port)
goto close_sk;
budget -= len;
- current = cg_read_long(cgroup, "memory.current");
- sock = cg_read_key_long(cgroup, "memory.stat", "sock ");
+ current = cg_read_s64(cgroup, "memory.current");
+ sock = cg_read_key_s64(cgroup, "memory.stat", "sock ");
if (current < 0 || sock < 0)
goto close_sk;
@@ -1422,7 +1423,7 @@ static int test_memcg_sock(const char *root)
int bind_retries = 5, ret = KSFT_FAIL, pid, err;
unsigned short port;
char *memcg;
- long sock_post = -1;
+ s64 sock_post = -1;
int flush_rounds = 3;
if (memcg_sockets_disabled())
@@ -1478,7 +1479,7 @@ static int test_memcg_sock(const char *root)
if (WEXITSTATUS(err))
goto cleanup;
- if (cg_read_long(memcg, "memory.current") < 0)
+ if (cg_read_s64(memcg, "memory.current") < 0)
goto cleanup;
/* the uncharge is done, but a flush still walking the CPUs can hide it from a read */
@@ -1486,7 +1487,7 @@ static int test_memcg_sock(const char *root)
if (cg_run(memcg, alloc_anon, (void *)MEMCG_FLUSH_BYTES))
goto cleanup;
- sock_post = cg_read_key_long(memcg, "memory.stat", "sock ");
+ sock_post = cg_read_key_s64(memcg, "memory.stat", "sock ");
if (!sock_post)
break;
}
@@ -1512,7 +1513,7 @@ static int test_memcg_oom_group_leaf_events(const char *root)
{
int ret = KSFT_FAIL;
char *parent, *child;
- long parent_oom_events;
+ s64 parent_oom_events;
parent = cg_name(root, "memcg_test_0");
child = cg_name(root, "memcg_test_0/memcg_test_1");
@@ -1547,11 +1548,11 @@ static int test_memcg_oom_group_leaf_events(const char *root)
if (cg_test_proc_killed(child))
goto cleanup;
- if (cg_read_key_long(child, "memory.events", "oom_kill ") <= 0)
+ if (cg_read_key_s64(child, "memory.events", "oom_kill ") <= 0)
goto cleanup;
- parent_oom_events = cg_read_key_long(
- parent, "memory.events", "oom_kill ");
+ parent_oom_events =
+ cg_read_key_s64(parent, "memory.events", "oom_kill ");
/*
* If memory_localevents is not enabled (the default), the parent should
* count OOM events in its children groups. Otherwise, it should not
@@ -1667,7 +1668,7 @@ static int test_memcg_oom_group_score_events(const char *root)
if (!cg_run(memcg, alloc_anon, (void *)MB(100)))
goto cleanup;
- if (cg_read_key_long(memcg, "memory.events", "oom_kill ") != 3)
+ if (cg_read_key_s64(memcg, "memory.events", "oom_kill ") != 3)
goto cleanup;
if (kill(safe_pid, SIGKILL))
diff --git a/tools/testing/selftests/cgroup/test_pids.c b/tools/testing/selftests/cgroup/test_pids.c
index e775c5510cf2..9c1cda47c73d 100644
--- a/tools/testing/selftests/cgroup/test_pids.c
+++ b/tools/testing/selftests/cgroup/test_pids.c
@@ -114,9 +114,9 @@ static int test_pids_events(const char *root)
if (kill(pid, SIGINT))
goto cleanup;
- if (cg_read_key_long(cg_child, "pids.events", "max ") != 0)
+ if (cg_read_key_s64(cg_child, "pids.events", "max ") != 0)
goto cleanup;
- if (cg_read_key_long(cg_parent, "pids.events", "max ") != 1)
+ if (cg_read_key_s64(cg_parent, "pids.events", "max ") != 1)
goto cleanup;
@@ -179,7 +179,7 @@ static int test_pids_events_notify(const char *root)
if (cg_run_nowait(cg_pids, run_success, NULL) != -1 || errno != EAGAIN)
goto cleanup;
- if (cg_read_key_long(cg_pids, "pids.events", "max ") != 1)
+ if (cg_read_key_s64(cg_pids, "pids.events", "max ") != 1)
goto cleanup;
pfd.fd = inotify_fd;
diff --git a/tools/testing/selftests/cgroup/test_zswap.c b/tools/testing/selftests/cgroup/test_zswap.c
index d50acc1b83ac..a851f6fe5875 100644
--- a/tools/testing/selftests/cgroup/test_zswap.c
+++ b/tools/testing/selftests/cgroup/test_zswap.c
@@ -60,14 +60,14 @@ static int get_zswap_stored_pages(size_t *value)
return read_int(PATH_ZSWAP_STORED_PAGES, value);
}
-static long get_cg_wb_count(const char *cg)
+static s64 get_cg_wb_count(const char *cg)
{
- return cg_read_key_long(cg, "memory.stat", "zswpwb");
+ return cg_read_key_s64(cg, "memory.stat", "zswpwb");
}
-static long get_zswpout(const char *cgroup)
+static s64 get_zswpout(const char *cgroup)
{
- return cg_read_key_long(cgroup, "memory.stat", "zswpout ");
+ return cg_read_key_s64(cgroup, "memory.stat", "zswpout ");
}
static int allocate_and_read_bytes(const char *cgroup, void *arg)
@@ -126,9 +126,10 @@ static char *setup_test_group_1M(const char *root, const char *name)
* Writeback is asynchronous; poll until at least one writeback has
* been recorded for @cg, or until @timeout_ms has elapsed.
*/
-static long wait_for_writeback(const char *cg, int timeout_ms)
+static s64 wait_for_writeback(const char *cg, int timeout_ms)
{
- long elapsed, count;
+ long elapsed;
+ s64 count;
for (elapsed = 0; elapsed < timeout_ms; elapsed += 100) {
count = get_cg_wb_count(cg);
@@ -148,7 +149,7 @@ static long wait_for_writeback(const char *cg, int timeout_ms)
*/
static int test_zswap_usage(const char *root)
{
- long zswpout_before, zswpout_after;
+ s64 zswpout_before, zswpout_after;
int ret = KSFT_FAIL;
char *test_group;
@@ -192,7 +193,7 @@ static int test_swapin_nozswap(const char *root)
{
int ret = KSFT_FAIL;
char *test_group, mem_max_buf[32];
- long swap_peak, zswpout, min_swap;
+ s64 swap_peak, zswpout, min_swap;
size_t allocation_size = page_size * 512;
min_swap = allocation_size / 4;
@@ -213,15 +214,15 @@ static int test_swapin_nozswap(const char *root)
goto out;
/* Verify that pages are swapped out, but no zswap happened */
- swap_peak = cg_read_long(test_group, "memory.swap.peak");
+ swap_peak = cg_read_s64(test_group, "memory.swap.peak");
if (swap_peak < 0) {
ksft_print_msg("failed to get cgroup's swap_peak\n");
goto out;
}
if (swap_peak < min_swap) {
- ksft_print_msg("at least %ldKB of memory should be swapped out\n",
- min_swap / 1024);
+ ksft_print_msg("at least %" PRId64 "KB of memory should be swapped out\n",
+ min_swap / 1024);
goto out;
}
@@ -249,7 +250,7 @@ static int test_zswapin(const char *root)
{
int ret = KSFT_FAIL;
char *test_group;
- long zswpin;
+ s64 zswpin;
test_group = cg_name(root, "zswapin_test");
if (!test_group)
@@ -265,7 +266,7 @@ static int test_zswapin(const char *root)
if (cg_run(test_group, allocate_and_read_bytes, (void *)MB(32)))
goto out;
- zswpin = cg_read_key_long(test_group, "memory.stat", "zswpin ");
+ zswpin = cg_read_key_s64(test_group, "memory.stat", "zswpin ");
if (zswpin < 0) {
ksft_print_msg("failed to get zswpin\n");
goto out;
@@ -300,7 +301,7 @@ static int attempt_writeback(const char *cgroup, void *arg)
{
size_t memsize = page_size * 1024;
char buf[page_size];
- long zswap_usage;
+ s64 zswap_usage;
bool wb_enabled = *(bool *) arg;
int ret = -1;
char *mem;
@@ -326,7 +327,7 @@ static int attempt_writeback(const char *cgroup, void *arg)
goto out;
}
- zswap_usage = cg_read_long(cgroup, "memory.zswap.current");
+ zswap_usage = cg_read_s64(cgroup, "memory.zswap.current");
/* zswpin */
for (int i = 0; i < memsize; i += page_size) {
@@ -365,11 +366,12 @@ static int attempt_writeback(const char *cgroup, void *arg)
static int test_zswap_writeback_one(const char *cgroup, bool wb)
{
- long zswpwb_before, zswpwb_after;
+ s64 zswpwb_before, zswpwb_after;
zswpwb_before = get_cg_wb_count(cgroup);
if (zswpwb_before != 0) {
- ksft_print_msg("zswpwb_before = %ld instead of 0\n", zswpwb_before);
+ ksft_print_msg("zswpwb_before = %" PRId64 " instead of 0\n",
+ zswpwb_before);
return -1;
}
@@ -385,8 +387,8 @@ static int test_zswap_writeback_one(const char *cgroup, bool wb)
return -1;
if (wb != !!zswpwb_after) {
- ksft_print_msg("zswpwb_after is %ld while wb is %s\n",
- zswpwb_after, wb ? "enabled" : "disabled");
+ ksft_print_msg("zswpwb_after is %" PRId64 " while wb is %s\n",
+ zswpwb_after, wb ? "enabled" : "disabled");
return -1;
}
@@ -475,7 +477,7 @@ static int test_no_invasive_cgroup_shrink(const char *root)
{
int ret = KSFT_FAIL;
unsigned int off;
- long zswpwb_before, zswpwb_after, zswpwb_target;
+ s64 zswpwb_before, zswpwb_after, zswpwb_target;
size_t allocation_size = page_size * 1024;
unsigned int nr_pages = allocation_size / page_size;
char zswap_max_buf[32], mem_max_buf[32];
@@ -508,7 +510,7 @@ static int test_no_invasive_cgroup_shrink(const char *root)
memset(&zw_allocation[off], 0, page_size);
memset(&zw_allocation[off], 'a', page_size/4);
}
- if (cg_read_key_long(zw_group, "memory.stat", "zswapped") < 1)
+ if (cg_read_key_s64(zw_group, "memory.stat", "zswapped") < 1)
goto out;
/* If the shrinker is enabled, try to let the writebacks finish first */
@@ -663,12 +665,11 @@ static int test_no_kmem_bypass(const char *root)
break;
/* If memory was pushed to zswap, verify it belongs to memcg */
if (stored_pages > stored_pages_threshold) {
- long zswapped = cg_read_key_long(
- test_group, "memory.stat", "zswapped ");
- long long delta =
- (long long)stored_pages * page_size - zswapped;
- long long max_delta =
- (long long)stored_pages * page_size / 4;
+ s64 zswapped = cg_read_key_s64(test_group,
+ "memory.stat",
+ "zswapped ");
+ s64 delta = (s64)stored_pages * page_size - zswapped;
+ s64 max_delta = (s64)stored_pages * page_size / 4;
ret = (delta < max_delta) ? KSFT_PASS : KSFT_FAIL;
break;
@@ -739,9 +740,9 @@ static int allocate_random_and_wait(const char *cgroup, void *arg)
return 0;
}
-static long get_zswap_incomp(const char *cgroup)
+static s64 get_zswap_incomp(const char *cgroup)
{
- return cg_read_key_long(cgroup, "memory.stat", "zswap_incomp ");
+ return cg_read_key_s64(cgroup, "memory.stat", "zswap_incomp ");
}
/*
@@ -757,7 +758,7 @@ static int test_zswap_incompressible(const char *root)
int ret = KSFT_FAIL;
struct incomp_child_args *values;
char *test_group;
- long zswap_incomp;
+ s64 zswap_incomp;
pid_t child_pid;
int child_status;
char buf;
@@ -793,12 +794,16 @@ static int test_zswap_incompressible(const char *root)
zswap_incomp = get_zswap_incomp(test_group);
if (zswap_incomp <= 0) {
- long zswpout = get_zswpout(test_group);
- long zswapped = cg_read_key_long(test_group, "memory.stat", "zswapped ");
- long zswap_b = cg_read_key_long(test_group, "memory.stat", "zswap ");
-
- ksft_print_msg("zswap_incomp not increased: %ld\n", zswap_incomp);
- ksft_print_msg("debug: zswpout=%ld zswapped=%ld zswap_b=%ld\n",
+ s64 zswpout = get_zswpout(test_group);
+ s64 zswapped =
+ cg_read_key_s64(test_group, "memory.stat", "zswapped ");
+ s64 zswap_b =
+ cg_read_key_s64(test_group, "memory.stat", "zswap ");
+
+ ksft_print_msg("zswap_incomp not increased: %" PRId64 "\n",
+ zswap_incomp);
+ ksft_print_msg("debug: zswpout=%" PRId64 " zswapped=%" PRId64
+ " zswap_b=%" PRId64 "\n",
zswpout, zswapped, zswap_b);
ksft_print_msg("debug: madvise ret=%d errno=%d\n",
values->madvise_ret, values->madvise_errno);
--
2.56.0.506.g506a7eabc5-goog
next reply other threads:[~2026-11-06 18:55 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-06 18:55 Wilson Felipe Pereira [this message]
2026-11-09 16:04 ` [PATCH v2] selftests/cgroup: convert cg_read_*long*() helpers to s64 Tejun Heo
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261106185520.290139-1-wfelipe@google.com \
--to=wfelipe@google.com \
--cc=cgroups@vger.kernel.org \
--cc=chengming.zhou@linux.dev \
--cc=david@kernel.org \
--cc=hannes@cmpxchg.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-kselftest@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=mhocko@kernel.org \
--cc=mkoutny@suse.com \
--cc=muchun.song@linux.dev \
--cc=nphamcs@gmail.com \
--cc=osalvador@suse.de \
--cc=roman.gushchin@linux.dev \
--cc=shakeel.butt@linux.dev \
--cc=shuah@kernel.org \
--cc=tj@kernel.org \
--cc=yosry@kernel.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.