// SPDX-License-Identifier: GPL-2.0
#define _GNU_SOURCE
#include <test_progs.h>
#include <fcntl.h>
#include <linux/magic.h>
#include <sys/vfs.h>
#include <sys/wait.h>
#include <unistd.h>
#include <sys/user.h>
#ifndef PAGE_SIZE /* on some archs it comes in sys/user.h */
#define PAGE_SIZE getpagesize()
#endif
#include "cgroup_helpers.h"
#include "arena_memcg.skel.h"
#define CG_PATH "/arena_memcg"
/* Reclaimable page cache the child builds up before it gets capped. */
#define RECLAIMABLE (128 * 1024 * 1024)
/* Headroom left under memory.max, far less than the arena we fault in. */
#define HEADROOM (8 * 1024 * 1024)
/* Arena to fault in; it only fits by reclaiming the page cache. */
#define ARENA_FAULT (64 * 1024 * 1024)
/* Child exit code for "this environment cannot host the test". */
#define CHILD_UNSUPPORTED 9
static void dump_memcg(void)
{
char buf[512];
if (!read_cgroup_file(CG_PATH, "memory.max", buf, sizeof(buf)))
fprintf(stderr, "memory.max: %s", buf);
if (!read_cgroup_file(CG_PATH, "memory.peak", buf, sizeof(buf)))
fprintf(stderr, "memory.peak: %s", buf);
if (!read_cgroup_file(CG_PATH, "memory.events", buf, sizeof(buf)))
fprintf(stderr, "memory.events:\n%s", buf);
}
/*
* Fill the page cache with @size bytes of clean, reclaimable pages by
* reading a sparse temp file, the way the cgroup selftests do. Returns the
* fd, which must stay open: closing it drops the cache. Returns -EOPNOTSUPP
* if the working directory cannot back such a file, -1 on error.
*/
static int alloc_pagecache(size_t size)
{
struct statfs stfs;
char buf[4096];
size_t off;
int fd;
fd = open(".", O_TMPFILE | O_RDWR | O_EXCL, 0600);
if (fd < 0)
return errno == EOPNOTSUPP ? -EOPNOTSUPP : -1;
/* tmpfs hands out shmem pages, which are not reclaimable without swap */
if (fstatfs(fd, &stfs) || stfs.f_type == TMPFS_MAGIC) {
close(fd);
return -EOPNOTSUPP;
}
if (ftruncate(fd, size))
goto err;
for (off = 0; off < size; off += sizeof(buf))
if (read(fd, buf, sizeof(buf)) < 0)
goto err;
return fd;
err:
close(fd);
return -1;
}
void serial_test_arena_memcg(void)
{
int cgroup_fd = -1, status, err;
const long ps = PAGE_SIZE;
char buf[64];
pid_t pid;
err = setup_cgroup_environment();
if (!ASSERT_OK(err, "setup_cgroup_environment"))
goto out;
cgroup_fd = create_and_get_cgroup(CG_PATH);
if (!ASSERT_OK_FD(cgroup_fd, "create_and_get_cgroup"))
goto out;
/* No memory controller -> nothing to test. */
if (read_cgroup_file(CG_PATH, "memory.current", buf, sizeof(buf))) {
fprintf(stderr, "%s:SKIP:no memory controller or other env error\n",
__func__);
test__skip();
goto out;
}
pid = fork();
if (!ASSERT_GE(pid, 0, "fork"))
goto out;
if (pid == 0) {
struct arena_memcg *cskel;
__u32 i, npages;
char *base;
size_t sz;
long cur;
int fd;
/*
* Everything runs in the child: the arena vma is VM_DONTCOPY so
* it does not survive fork(), and only the child should be under
* the limit. The work dir belongs to the parent, so use the
* _parent() helpers; errors come back as an exit code, ASSERT_*
* does not reach the parent from here.
*/
/* Step 1: join the memcg, so what follows is charged to it. */
snprintf(buf, sizeof(buf), "%d", getpid());
if (write_cgroup_file_parent(CG_PATH, "cgroup.procs", buf))
_exit(2);
/*
* Step 2: load the arena. A map is charged to whoever creates
* it, hence joining first.
*/
cskel = arena_memcg__open_and_load();
if (!cskel)
_exit(3);
base = bpf_map__initial_value(cskel->maps.arena, &sz);
if (!base)
_exit(4);
npages = ARENA_FAULT / ps;
if (npages > bpf_map__max_entries(cskel->maps.arena))
_exit(5);
/* Step 3: make RECLAIMABLE bytes of clean page cache. */
fd = alloc_pagecache(RECLAIMABLE);
if (fd == -EOPNOTSUPP)
_exit(CHILD_UNSUPPORTED);
if (fd < 0)
_exit(6);
/*
* Step 4: set memory.max to what we use now plus HEADROOM. The
* page cache is already inside the limit, so only HEADROOM is
* left.
*/
if (read_cgroup_file_parent(CG_PATH, "memory.current", buf, sizeof(buf)))
_exit(7);
cur = strtol(buf, NULL, 10);
snprintf(buf, sizeof(buf), "%ld", cur + HEADROOM);
if (write_cgroup_file_parent(CG_PATH, "memory.max", buf))
_exit(8);
/*
* Step 5: fault ARENA_FAULT of arena in, much more than
* HEADROOM. Once it hits memory.max every further page has to
* come from reclaiming the page cache. With the fix the
* fault-in reclaims and all of it succeeds; without it the
* allocation cannot reclaim and we die on a valid address.
*/
for (i = 0; i < npages; i++)
base[(size_t)i * ps] = 1;
_exit(0); /* fd deliberately kept open until here */
}
if (!ASSERT_EQ(waitpid(pid, &status, 0), pid, "waitpid"))
goto out;
/* The working directory cannot hold a reclaimable page cache. */
if (WIFEXITED(status) && WEXITSTATUS(status) == CHILD_UNSUPPORTED) {
fprintf(stderr, "%s:SKIP:no disk-backed O_TMPFILE in cwd\n", __func__);
test__skip();
goto out;
}
/* A non-zero exit means the child failed to set up; the code says where. */
if (WIFEXITED(status) && WEXITSTATUS(status)) {
ASSERT_OK(WEXITSTATUS(status), "child setup");
goto out;
}
/*
* With the fix the arena fault-in reclaims the page cache and every
* fault succeeds, so the child exits 0. Without it the allocation
* cannot reclaim, fails once the headroom is used up, and the child
* dies with SIGSEGV on a valid arena address.
*/
if (!ASSERT_TRUE(WIFEXITED(status) && !WEXITSTATUS(status),
"child faulted the arena in")) {
if (WIFSIGNALED(status))
fprintf(stderr, "child killed by signal %d\n", WTERMSIG(status));
dump_memcg();
}
out:
if (cgroup_fd >= 0)
close(cgroup_fd);
cleanup_cgroup_environment();
}