averello/linux-stable-mirror
1
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git synced 2026-08-14 06:22:34 +02:00
Code Issues Packages Projects Releases Wiki Activity
Files
2956268efc457cb05d29c1bf94de1e8e684d7bbc
linux-stable-mirror/tools/testing/selftests/cgroup/test_freezer.c
T
Li Wang 6e9f5c2eec selftests/cgroup: rename PAGE_SIZE to BUF_SIZE in cgroup_util 
The cgroup utility code defines a local PAGE_SIZE macro hardcoded to 4096,
which is used primarily as a generic buffer size for reading cgroup and
proc files.  This naming is misleading because the value has nothing to do
with the actual page size of the system.  On architectures with larger
pages (e.g., 64K on arm64 or ppc64), the name suggests a relationship that
does not exist.  Additionally, the name can shadow or conflict with
PAGE_SIZE definitions from system headers, leading to confusion or subtle
bugs.

To resolve this, rename the macro to BUF_SIZE to accurately reflect its
purpose as a general I/O buffer size.

Furthermore, test_memcontrol currently relies on this hardcoded 4K value
to stride through memory and trigger page faults.  Update this logic to
use the actual system page size dynamically.  This micro-optimizes the
memory faulting process by ensuring it iterates correctly and efficiently
based on the underlying architecture's true page size.  (This part from
Waiman)

Link: https://lore.kernel.org/20260424040059.12940-5-li.wang@linux.dev
Signed-off-by: Li Wang <li.wang@linux.dev>
Signed-off-by: Waiman Long <longman@redhat.com>
Acked-by: Nhat Pham <nphamcs@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Michal Koutný <mkoutny@suse.com>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Tejun Heo <tj@kernel.org>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Shakeel Butt <shakeel.butt@linux.dev>
Cc: Yosry Ahmed <yosryahmed@google.com>
Cc: Chengming Zhou <chengming.zhou@linux.dev>
Cc: Jiayuan Chen <jiayuan.chen@linux.dev>
Cc: Yosry Ahmed <yosry@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
2026-05-28 21:04:46 -07:00

1513 lines
29 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-2.0 */
#include <stdbool.h>
#include <linux/limits.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
#include "kselftest.h"
#include "cgroup_util.h"
#define DEBUG
#ifdef DEBUG
#define debug(args...) fprintf(stderr, args)
#else
#define debug(args...)
#endif
/*
* Check if the cgroup is frozen by looking at the cgroup.events::frozen value.
*/
static int cg_check_frozen(const char *cgroup, bool frozen)
{
if (frozen) {
if (cg_read_strstr(cgroup, "cgroup.events", "frozen 1") != 0) {
debug("Cgroup %s isn't frozen\n", cgroup);
return -1;
}
} else {
/*
* Check the cgroup.events::frozen value.
*/
if (cg_read_strstr(cgroup, "cgroup.events", "frozen 0") != 0) {
debug("Cgroup %s is frozen\n", cgroup);
return -1;
}
}
return 0;
}
/*
* Freeze the given cgroup.
*/
static int cg_freeze_nowait(const char *cgroup, bool freeze)
{
return cg_write(cgroup, "cgroup.freeze", freeze ? "1" : "0");
}
/*
* Attach a task to the given cgroup and wait for a cgroup frozen event.
* All transient events (e.g. populated) are ignored.
*/
static int cg_enter_and_wait_for_frozen(const char *cgroup, int pid,
bool frozen)
{
int fd, ret = -1;
int attempts;
fd = cg_prepare_for_wait(cgroup);
if (fd < 0)
return fd;
ret = cg_enter(cgroup, pid);
if (ret)
goto out;
for (attempts = 0; attempts < 10; attempts++) {
ret = cg_wait_for(fd);
if (ret)
break;
ret = cg_check_frozen(cgroup, frozen);
if (ret)
continue;
}
out:
close(fd);
return ret;
}
/*
* Freeze the given cgroup and wait for the inotify signal.
* If there are no events in 10 seconds, treat this as an error.
* Then check that the cgroup is in the desired state.
*/
static int cg_freeze_wait(const char *cgroup, bool freeze)
{
int fd, ret = -1;
fd = cg_prepare_for_wait(cgroup);
if (fd < 0)
return fd;
ret = cg_freeze_nowait(cgroup, freeze);
if (ret) {
debug("Error: cg_freeze_nowait() failed\n");
goto out;
}
ret = cg_wait_for(fd);
if (ret)
goto out;
ret = cg_check_frozen(cgroup, freeze);
out:
close(fd);
return ret;
}
/*
* A simple process running in a sleep loop until being
* re-parented.
*/
static int child_fn(const char *cgroup, void *arg)
{
int ppid = getppid();
while (getppid() == ppid)
usleep(1000);
return getppid() == ppid;
}
/*
* A simple test for the cgroup freezer: populated the cgroup with 100
* running processes and freeze it. Then unfreeze it. Then it kills all
* processes and destroys the cgroup.
*/
static int test_cgfreezer_simple(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
int i;
cgroup = cg_name(root, "cg_test_simple");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
for (i = 0; i < 100; i++)
cg_run_nowait(cgroup, child_fn, NULL);
if (cg_wait_for_proc_count(cgroup, 100))
goto cleanup;
if (cg_check_frozen(cgroup, false))
goto cleanup;
if (cg_freeze_wait(cgroup, true))
goto cleanup;
if (cg_freeze_wait(cgroup, false))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* The test creates the following hierarchy:
* A
* / / \ \
* B E I K
* /\ |
* C D F
* |
* G
* |
* H
*
* with a process in C, H and 3 processes in K.
* Then it tries to freeze and unfreeze the whole tree.
*/
static int test_cgfreezer_tree(const char *root)
{
char *cgroup[10] = {0};
int ret = KSFT_FAIL;
int i;
cgroup[0] = cg_name(root, "cg_test_tree_A");
if (!cgroup[0])
goto cleanup;
cgroup[1] = cg_name(cgroup[0], "B");
if (!cgroup[1])
goto cleanup;
cgroup[2] = cg_name(cgroup[1], "C");
if (!cgroup[2])
goto cleanup;
cgroup[3] = cg_name(cgroup[1], "D");
if (!cgroup[3])
goto cleanup;
cgroup[4] = cg_name(cgroup[0], "E");
if (!cgroup[4])
goto cleanup;
cgroup[5] = cg_name(cgroup[4], "F");
if (!cgroup[5])
goto cleanup;
cgroup[6] = cg_name(cgroup[5], "G");
if (!cgroup[6])
goto cleanup;
cgroup[7] = cg_name(cgroup[6], "H");
if (!cgroup[7])
goto cleanup;
cgroup[8] = cg_name(cgroup[0], "I");
if (!cgroup[8])
goto cleanup;
cgroup[9] = cg_name(cgroup[0], "K");
if (!cgroup[9])
goto cleanup;
for (i = 0; i < 10; i++)
if (cg_create(cgroup[i]))
goto cleanup;
cg_run_nowait(cgroup[2], child_fn, NULL);
cg_run_nowait(cgroup[7], child_fn, NULL);
cg_run_nowait(cgroup[9], child_fn, NULL);
cg_run_nowait(cgroup[9], child_fn, NULL);
cg_run_nowait(cgroup[9], child_fn, NULL);
/*
* Wait until all child processes will enter
* corresponding cgroups.
*/
if (cg_wait_for_proc_count(cgroup[2], 1) ||
cg_wait_for_proc_count(cgroup[7], 1) ||
cg_wait_for_proc_count(cgroup[9], 3))
goto cleanup;
/*
* Freeze B.
*/
if (cg_freeze_wait(cgroup[1], true))
goto cleanup;
/*
* Freeze F.
*/
if (cg_freeze_wait(cgroup[5], true))
goto cleanup;
/*
* Freeze G.
*/
if (cg_freeze_wait(cgroup[6], true))
goto cleanup;
/*
* Check that A and E are not frozen.
*/
if (cg_check_frozen(cgroup[0], false))
goto cleanup;
if (cg_check_frozen(cgroup[4], false))
goto cleanup;
/*
* Freeze A. Check that A, B and E are frozen.
*/
if (cg_freeze_wait(cgroup[0], true))
goto cleanup;
if (cg_check_frozen(cgroup[1], true))
goto cleanup;
if (cg_check_frozen(cgroup[4], true))
goto cleanup;
/*
* Unfreeze B, F and G
*/
if (cg_freeze_nowait(cgroup[1], false))
goto cleanup;
if (cg_freeze_nowait(cgroup[5], false))
goto cleanup;
if (cg_freeze_nowait(cgroup[6], false))
goto cleanup;
/*
* Check that C and H are still frozen.
*/
if (cg_check_frozen(cgroup[2], true))
goto cleanup;
if (cg_check_frozen(cgroup[7], true))
goto cleanup;
/*
* Unfreeze A. Check that A, C and K are not frozen.
*/
if (cg_freeze_wait(cgroup[0], false))
goto cleanup;
if (cg_check_frozen(cgroup[2], false))
goto cleanup;
if (cg_check_frozen(cgroup[9], false))
goto cleanup;
ret = KSFT_PASS;
cleanup:
for (i = 9; i >= 0 && cgroup[i]; i--) {
cg_destroy(cgroup[i]);
free(cgroup[i]);
}
return ret;
}
/*
* A fork bomb emulator.
*/
static int forkbomb_fn(const char *cgroup, void *arg)
{
int ppid;
fork();
fork();
ppid = getppid();
while (getppid() == ppid)
usleep(1000);
return getppid() == ppid;
}
/*
* The test runs a fork bomb in a cgroup and tries to freeze it.
* Then it kills all processes and checks that cgroup isn't populated
* anymore.
*/
static int test_cgfreezer_forkbomb(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
cgroup = cg_name(root, "cg_forkbomb_test");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
cg_run_nowait(cgroup, forkbomb_fn, NULL);
usleep(100000);
if (cg_freeze_wait(cgroup, true))
goto cleanup;
if (cg_killall(cgroup))
goto cleanup;
if (cg_wait_for_proc_count(cgroup, 0))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* The test creates a cgroups and freezes it. Then it creates a child cgroup
* and populates it with a task. After that it checks that the child cgroup
* is frozen and the parent cgroup remains frozen too.
*/
static int test_cgfreezer_mkdir(const char *root)
{
int ret = KSFT_FAIL;
char *parent, *child = NULL;
int pid;
parent = cg_name(root, "cg_test_mkdir_A");
if (!parent)
goto cleanup;
child = cg_name(parent, "cg_test_mkdir_B");
if (!child)
goto cleanup;
if (cg_create(parent))
goto cleanup;
if (cg_freeze_wait(parent, true))
goto cleanup;
if (cg_create(child))
goto cleanup;
pid = cg_run_nowait(child, child_fn, NULL);
if (pid < 0)
goto cleanup;
if (cg_wait_for_proc_count(child, 1))
goto cleanup;
if (cg_check_frozen(child, true))
goto cleanup;
if (cg_check_frozen(parent, true))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (child)
cg_destroy(child);
free(child);
if (parent)
cg_destroy(parent);
free(parent);
return ret;
}
/*
* The test creates two nested cgroups, freezes the parent
* and removes the child. Then it checks that the parent cgroup
* remains frozen and it's possible to create a new child
* without unfreezing. The new child is frozen too.
*/
static int test_cgfreezer_rmdir(const char *root)
{
int ret = KSFT_FAIL;
char *parent, *child = NULL;
parent = cg_name(root, "cg_test_rmdir_A");
if (!parent)
goto cleanup;
child = cg_name(parent, "cg_test_rmdir_B");
if (!child)
goto cleanup;
if (cg_create(parent))
goto cleanup;
if (cg_create(child))
goto cleanup;
if (cg_freeze_wait(parent, true))
goto cleanup;
if (cg_destroy(child))
goto cleanup;
if (cg_check_frozen(parent, true))
goto cleanup;
if (cg_create(child))
goto cleanup;
if (cg_check_frozen(child, true))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (child)
cg_destroy(child);
free(child);
if (parent)
cg_destroy(parent);
free(parent);
return ret;
}
/*
* The test creates two cgroups: A and B, runs a process in A
* and performs several migrations:
* 1) A (running) -> B (frozen)
* 2) B (frozen) -> A (running)
* 3) A (frozen) -> B (frozen)
*
* On each step it checks the actual state of both cgroups.
*/
static int test_cgfreezer_migrate(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup[2] = {0};
int pid;
cgroup[0] = cg_name(root, "cg_test_migrate_A");
if (!cgroup[0])
goto cleanup;
cgroup[1] = cg_name(root, "cg_test_migrate_B");
if (!cgroup[1])
goto cleanup;
if (cg_create(cgroup[0]))
goto cleanup;
if (cg_create(cgroup[1]))
goto cleanup;
pid = cg_run_nowait(cgroup[0], child_fn, NULL);
if (pid < 0)
goto cleanup;
if (cg_wait_for_proc_count(cgroup[0], 1))
goto cleanup;
/*
* Migrate from A (running) to B (frozen)
*/
if (cg_freeze_wait(cgroup[1], true))
goto cleanup;
if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
goto cleanup;
if (cg_check_frozen(cgroup[0], false))
goto cleanup;
/*
* Migrate from B (frozen) to A (running)
*/
if (cg_enter_and_wait_for_frozen(cgroup[0], pid, false))
goto cleanup;
if (cg_check_frozen(cgroup[1], true))
goto cleanup;
/*
* Migrate from A (frozen) to B (frozen)
*/
if (cg_freeze_wait(cgroup[0], true))
goto cleanup;
if (cg_enter_and_wait_for_frozen(cgroup[1], pid, true))
goto cleanup;
if (cg_check_frozen(cgroup[0], true))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup[0])
cg_destroy(cgroup[0]);
free(cgroup[0]);
if (cgroup[1])
cg_destroy(cgroup[1]);
free(cgroup[1]);
return ret;
}
/*
* The test checks that ptrace works with a tracing process in a frozen cgroup.
*/
static int test_cgfreezer_ptrace(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
siginfo_t siginfo;
int pid;
cgroup = cg_name(root, "cg_test_ptrace");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
pid = cg_run_nowait(cgroup, child_fn, NULL);
if (pid < 0)
goto cleanup;
if (cg_wait_for_proc_count(cgroup, 1))
goto cleanup;
if (cg_freeze_wait(cgroup, true))
goto cleanup;
if (ptrace(PTRACE_SEIZE, pid, NULL, NULL))
goto cleanup;
if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL))
goto cleanup;
waitpid(pid, NULL, 0);
/*
* Cgroup has to remain frozen, however the test task
* is in traced state.
*/
if (cg_check_frozen(cgroup, true))
goto cleanup;
if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo))
goto cleanup;
if (ptrace(PTRACE_DETACH, pid, NULL, NULL))
goto cleanup;
if (cg_check_frozen(cgroup, true))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* Check if the process is stopped.
*/
static int proc_check_stopped(int pid)
{
char buf[BUF_SIZE];
int len;
len = proc_read_text(pid, 0, "stat", buf, sizeof(buf));
if (len == -1) {
debug("Can't get %d stat\n", pid);
return -1;
}
if (strstr(buf, "(test_freezer) T ") == NULL) {
debug("Process %d in the unexpected state: %s\n", pid, buf);
return -1;
}
return 0;
}
/*
* Test that it's possible to freeze a cgroup with a stopped process.
*/
static int test_cgfreezer_stopped(const char *root)
{
int pid, ret = KSFT_FAIL;
char *cgroup = NULL;
cgroup = cg_name(root, "cg_test_stopped");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
pid = cg_run_nowait(cgroup, child_fn, NULL);
if (cg_wait_for_proc_count(cgroup, 1))
goto cleanup;
if (kill(pid, SIGSTOP))
goto cleanup;
if (cg_check_frozen(cgroup, false))
goto cleanup;
if (cg_freeze_wait(cgroup, true))
goto cleanup;
if (cg_freeze_wait(cgroup, false))
goto cleanup;
if (proc_check_stopped(pid))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* Test that it's possible to freeze a cgroup with a ptraced process.
*/
static int test_cgfreezer_ptraced(const char *root)
{
int pid, ret = KSFT_FAIL;
char *cgroup = NULL;
siginfo_t siginfo;
cgroup = cg_name(root, "cg_test_ptraced");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
pid = cg_run_nowait(cgroup, child_fn, NULL);
if (cg_wait_for_proc_count(cgroup, 1))
goto cleanup;
if (ptrace(PTRACE_SEIZE, pid, NULL, NULL))
goto cleanup;
if (ptrace(PTRACE_INTERRUPT, pid, NULL, NULL))
goto cleanup;
waitpid(pid, NULL, 0);
if (cg_check_frozen(cgroup, false))
goto cleanup;
if (cg_freeze_wait(cgroup, true))
goto cleanup;
/*
* cg_check_frozen(cgroup, true) will fail here,
* because the task is in the TRACEd state.
*/
if (cg_freeze_wait(cgroup, false))
goto cleanup;
if (ptrace(PTRACE_GETSIGINFO, pid, NULL, &siginfo))
goto cleanup;
if (ptrace(PTRACE_DETACH, pid, NULL, NULL))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
static int vfork_fn(const char *cgroup, void *arg)
{
int pid = vfork();
if (pid == 0)
while (true)
sleep(1);
return pid;
}
/*
* Test that it's possible to freeze a cgroup with a process,
* which called vfork() and is waiting for a child.
*/
static int test_cgfreezer_vfork(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
cgroup = cg_name(root, "cg_test_vfork");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
cg_run_nowait(cgroup, vfork_fn, NULL);
if (cg_wait_for_proc_count(cgroup, 2))
goto cleanup;
if (cg_freeze_wait(cgroup, true))
goto cleanup;
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* Get the current frozen_usec for the cgroup.
*/
static long cg_check_freezetime(const char *cgroup)
{
return cg_read_key_long(cgroup, "cgroup.stat.local",
"frozen_usec ");
}
/*
* Test that the freeze time will behave as expected for an empty cgroup.
*/
static int test_cgfreezer_time_empty(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
long prev, curr;
cgroup = cg_name(root, "cg_time_test_empty");
if (!cgroup)
goto cleanup;
/*
* 1) Create an empty cgroup and check that its freeze time
* is 0.
*/
if (cg_create(cgroup))
goto cleanup;
curr = cg_check_freezetime(cgroup);
if (curr < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (curr > 0) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
if (cg_freeze_nowait(cgroup, true))
goto cleanup;
/*
* 2) Sleep for 1000 us. Check that the freeze time is at
* least 1000 us.
*/
usleep(1000);
curr = cg_check_freezetime(cgroup);
if (curr < 1000) {
debug("Expect time (%ld) to be at least 1000 us\n",
curr);
goto cleanup;
}
/*
* 3) Unfreeze the cgroup. Check that the freeze time is
* larger than at 2).
*/
if (cg_freeze_nowait(cgroup, false))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 4) Check the freeze time again to ensure that it has not
* changed.
*/
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
curr, prev);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* A simple test for cgroup freezer time accounting. This test follows
* the same flow as test_cgfreezer_time_empty, but with a single process
* in the cgroup.
*/
static int test_cgfreezer_time_simple(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
long prev, curr;
cgroup = cg_name(root, "cg_time_test_simple");
if (!cgroup)
goto cleanup;
/*
* 1) Create a cgroup and check that its freeze time is 0.
*/
if (cg_create(cgroup))
goto cleanup;
curr = cg_check_freezetime(cgroup);
if (curr < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (curr > 0) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
/*
* 2) Populate the cgroup with one child and check that the
* freeze time is still 0.
*/
cg_run_nowait(cgroup, child_fn, NULL);
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr > prev) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
if (cg_freeze_nowait(cgroup, true))
goto cleanup;
/*
* 3) Sleep for 1000 us. Check that the freeze time is at
* least 1000 us.
*/
usleep(1000);
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr < 1000) {
debug("Expect time (%ld) to be at least 1000 us\n",
curr);
goto cleanup;
}
/*
* 4) Unfreeze the cgroup. Check that the freeze time is
* larger than at 3).
*/
if (cg_freeze_nowait(cgroup, false))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 5) Sleep for 1000 us. Check that the freeze time is the
* same as at 4).
*/
usleep(1000);
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
curr, prev);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* Test that freezer time accounting works as expected, even while we're
* populating a cgroup with processes.
*/
static int test_cgfreezer_time_populate(const char *root)
{
int ret = KSFT_FAIL;
char *cgroup = NULL;
long prev, curr;
int i;
cgroup = cg_name(root, "cg_time_test_populate");
if (!cgroup)
goto cleanup;
if (cg_create(cgroup))
goto cleanup;
curr = cg_check_freezetime(cgroup);
if (curr < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (curr > 0) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
/*
* 1) Populate the cgroup with 100 processes. Check that
* the freeze time is 0.
*/
for (i = 0; i < 100; i++)
cg_run_nowait(cgroup, child_fn, NULL);
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
/*
* 2) Wait for the group to become fully populated. Check
* that the freeze time is 0.
*/
if (cg_wait_for_proc_count(cgroup, 100))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
debug("Expect time (%ld) to be 0\n", curr);
goto cleanup;
}
/*
* 3) Freeze the cgroup and then populate it with 100 more
* processes. Check that the freeze time continues to grow.
*/
if (cg_freeze_nowait(cgroup, true))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
for (i = 0; i < 100; i++)
cg_run_nowait(cgroup, child_fn, NULL);
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 4) Wait for the group to become fully populated. Check
* that the freeze time is larger than at 3).
*/
if (cg_wait_for_proc_count(cgroup, 200))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 5) Unfreeze the cgroup. Check that the freeze time is
* larger than at 4).
*/
if (cg_freeze_nowait(cgroup, false))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 6) Kill the processes. Check that the freeze time is the
* same as it was at 5).
*/
if (cg_killall(cgroup))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr != prev) {
debug("Expect time (%ld) to be unchanged from previous check (%ld)\n",
curr, prev);
goto cleanup;
}
/*
* 7) Freeze and unfreeze the cgroup. Check that the freeze
* time is larger than it was at 6).
*/
if (cg_freeze_nowait(cgroup, true))
goto cleanup;
if (cg_freeze_nowait(cgroup, false))
goto cleanup;
prev = curr;
curr = cg_check_freezetime(cgroup);
if (curr <= prev) {
debug("Expect time (%ld) to be more than previous check (%ld)\n",
curr, prev);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (cgroup)
cg_destroy(cgroup);
free(cgroup);
return ret;
}
/*
* Test that frozen time for a cgroup continues to work as expected,
* even as processes are migrated. Frozen cgroup A's freeze time should
* continue to increase and running cgroup B's should stay 0.
*/
static int test_cgfreezer_time_migrate(const char *root)
{
long prev_A, curr_A, curr_B;
char *cgroup[2] = {0};
int ret = KSFT_FAIL;
int pid;
cgroup[0] = cg_name(root, "cg_time_test_migrate_A");
if (!cgroup[0])
goto cleanup;
cgroup[1] = cg_name(root, "cg_time_test_migrate_B");
if (!cgroup[1])
goto cleanup;
if (cg_create(cgroup[0]))
goto cleanup;
if (cg_check_freezetime(cgroup[0]) < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (cg_create(cgroup[1]))
goto cleanup;
pid = cg_run_nowait(cgroup[0], child_fn, NULL);
if (pid < 0)
goto cleanup;
if (cg_wait_for_proc_count(cgroup[0], 1))
goto cleanup;
curr_A = cg_check_freezetime(cgroup[0]);
if (curr_A) {
debug("Expect time (%ld) 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);
goto cleanup;
}
/*
* Freeze cgroup A.
*/
if (cg_freeze_wait(cgroup[0], true))
goto cleanup;
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);
goto cleanup;
}
/*
* Migrate from A (frozen) to B (running).
*/
if (cg_enter(cgroup[1], pid))
goto cleanup;
usleep(1000);
curr_B = cg_check_freezetime(cgroup[1]);
if (curr_B) {
debug("Expect time (%ld) 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",
curr_A, prev_A);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (cgroup[0])
cg_destroy(cgroup[0]);
free(cgroup[0]);
if (cgroup[1])
cg_destroy(cgroup[1]);
free(cgroup[1]);
return ret;
}
/*
* The test creates a cgroup and freezes it. Then it creates a child cgroup.
* After that it checks that the child cgroup has a non-zero freeze time
* that is less than the parent's. Next, it freezes the child, unfreezes
* the parent, and sleeps. Finally, it checks that the child's freeze
* time has grown larger than the parent's.
*/
static int test_cgfreezer_time_parent(const char *root)
{
char *parent, *child = NULL;
int ret = KSFT_FAIL;
long ptime, ctime;
parent = cg_name(root, "cg_test_parent_A");
if (!parent)
goto cleanup;
child = cg_name(parent, "cg_test_parent_B");
if (!child)
goto cleanup;
if (cg_create(parent))
goto cleanup;
if (cg_check_freezetime(parent) < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (cg_freeze_wait(parent, true))
goto cleanup;
usleep(1000);
if (cg_create(child))
goto cleanup;
if (cg_check_frozen(child, true))
goto cleanup;
/*
* Since the parent was frozen the entire time the child cgroup
* was being created, we expect the parent's freeze time to be
* larger than the child's.
*
* Ideally, we would be able to check both times simultaneously,
* but here we get the child's after we get the parent's.
*/
ptime = cg_check_freezetime(parent);
ctime = cg_check_freezetime(child);
if (ptime <= ctime) {
debug("Expect ptime (%ld) > ctime (%ld)\n", ptime, ctime);
goto cleanup;
}
if (cg_freeze_nowait(child, true))
goto cleanup;
if (cg_freeze_wait(parent, false))
goto cleanup;
if (cg_check_frozen(child, true))
goto cleanup;
usleep(100000);
ctime = cg_check_freezetime(child);
ptime = cg_check_freezetime(parent);
if (ctime <= ptime) {
debug("Expect ctime (%ld) > ptime (%ld)\n", ctime, ptime);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (child)
cg_destroy(child);
free(child);
if (parent)
cg_destroy(parent);
free(parent);
return ret;
}
/*
* The test creates a parent cgroup and a child cgroup. Then, it freezes
* the child and checks that the child's freeze time is greater than the
* parent's, which should be zero.
*/
static int test_cgfreezer_time_child(const char *root)
{
char *parent, *child = NULL;
int ret = KSFT_FAIL;
long ptime, ctime;
parent = cg_name(root, "cg_test_child_A");
if (!parent)
goto cleanup;
child = cg_name(parent, "cg_test_child_B");
if (!child)
goto cleanup;
if (cg_create(parent))
goto cleanup;
if (cg_check_freezetime(parent) < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (cg_create(child))
goto cleanup;
if (cg_freeze_wait(child, true))
goto cleanup;
ctime = cg_check_freezetime(child);
ptime = cg_check_freezetime(parent);
if (ptime != 0) {
debug("Expect ptime (%ld) to be 0\n", ptime);
goto cleanup;
}
if (ctime <= ptime) {
debug("Expect ctime (%ld) <= ptime (%ld)\n", ctime, ptime);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
if (child)
cg_destroy(child);
free(child);
if (parent)
cg_destroy(parent);
free(parent);
return ret;
}
/*
* The test creates the following hierarchy:
* A
* |
* B
* |
* C
*
* Then it freezes the cgroups in the order C, B, A.
* Then it unfreezes the cgroups in the order A, B, C.
* Then it checks that C's freeze time is larger than B's and
* that B's is larger than A's.
*/
static int test_cgfreezer_time_nested(const char *root)
{
char *cgroup[3] = {0};
int ret = KSFT_FAIL;
long time[3] = {0};
int i;
cgroup[0] = cg_name(root, "cg_test_time_A");
if (!cgroup[0])
goto cleanup;
cgroup[1] = cg_name(cgroup[0], "B");
if (!cgroup[1])
goto cleanup;
cgroup[2] = cg_name(cgroup[1], "C");
if (!cgroup[2])
goto cleanup;
if (cg_create(cgroup[0]))
goto cleanup;
if (cg_check_freezetime(cgroup[0]) < 0) {
ret = KSFT_SKIP;
goto cleanup;
}
if (cg_create(cgroup[1]))
goto cleanup;
if (cg_create(cgroup[2]))
goto cleanup;
if (cg_freeze_nowait(cgroup[2], true))
goto cleanup;
if (cg_freeze_nowait(cgroup[1], true))
goto cleanup;
if (cg_freeze_nowait(cgroup[0], true))
goto cleanup;
usleep(1000);
if (cg_freeze_nowait(cgroup[0], false))
goto cleanup;
if (cg_freeze_nowait(cgroup[1], false))
goto cleanup;
if (cg_freeze_nowait(cgroup[2], false))
goto cleanup;
time[2] = cg_check_freezetime(cgroup[2]);
time[1] = cg_check_freezetime(cgroup[1]);
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]);
goto cleanup;
}
if (time[1] <= time[0]) {
debug("Expect B's time (%ld) > A's time (%ld)", time[1], time[0]);
goto cleanup;
}
ret = KSFT_PASS;
cleanup:
for (i = 2; i >= 0 && cgroup[i]; i--) {
cg_destroy(cgroup[i]);
free(cgroup[i]);
}
return ret;
}
#define T(x) { x, #x }
struct cgfreezer_test {
int (*fn)(const char *root);
const char *name;
} tests[] = {
T(test_cgfreezer_simple),
T(test_cgfreezer_tree),
T(test_cgfreezer_forkbomb),
T(test_cgfreezer_mkdir),
T(test_cgfreezer_rmdir),
T(test_cgfreezer_migrate),
T(test_cgfreezer_ptrace),
T(test_cgfreezer_stopped),
T(test_cgfreezer_ptraced),
T(test_cgfreezer_vfork),
T(test_cgfreezer_time_empty),
T(test_cgfreezer_time_simple),
T(test_cgfreezer_time_populate),
T(test_cgfreezer_time_migrate),
T(test_cgfreezer_time_parent),
T(test_cgfreezer_time_child),
T(test_cgfreezer_time_nested),
};
#undef T
int main(int argc, char *argv[])
{
char root[PATH_MAX];
int i;
ksft_print_header();
ksft_set_plan(ARRAY_SIZE(tests));
if (cg_find_unified_root(root, sizeof(root), NULL))
ksft_exit_skip("cgroup v2 isn't mounted\n");
for (i = 0; i < ARRAY_SIZE(tests); i++) {
switch (tests[i].fn(root)) {
case KSFT_PASS:
ksft_test_result_pass("%s\n", tests[i].name);
break;
case KSFT_SKIP:
ksft_test_result_skip("%s\n", tests[i].name);
break;
default:
ksft_test_result_fail("%s\n", tests[i].name);
break;
}
}
ksft_finished();
}
Reference in New Issue View Git Blame Copy Permalink