mirror of
https://github.com/torvalds/linux.git
synced 2026-04-18 14:53:58 -04:00
509d3f4584
Pull non-MM updates from Andrew Morton:
- "panic: sys_info: Refactor and fix a potential issue" (Andy Shevchenko)
fixes a build issue and does some cleanup in ib/sys_info.c
- "Implement mul_u64_u64_div_u64_roundup()" (David Laight)
enhances the 64-bit math code on behalf of a PWM driver and beefs up
the test module for these library functions
- "scripts/gdb/symbols: make BPF debug info available to GDB" (Ilya Leoshkevich)
makes BPF symbol names, sizes, and line numbers available to the GDB
debugger
- "Enable hung_task and lockup cases to dump system info on demand" (Feng Tang)
adds a sysctl which can be used to cause additional info dumping when
the hung-task and lockup detectors fire
- "lib/base64: add generic encoder/decoder, migrate users" (Kuan-Wei Chiu)
adds a general base64 encoder/decoder to lib/ and migrates several
users away from their private implementations
- "rbree: inline rb_first() and rb_last()" (Eric Dumazet)
makes TCP a little faster
- "liveupdate: Rework KHO for in-kernel users" (Pasha Tatashin)
reworks the KEXEC Handover interfaces in preparation for Live Update
Orchestrator (LUO), and possibly for other future clients
- "kho: simplify state machine and enable dynamic updates" (Pasha Tatashin)
increases the flexibility of KEXEC Handover. Also preparation for LUO
- "Live Update Orchestrator" (Pasha Tatashin)
is a major new feature targeted at cloud environments. Quoting the
cover letter:
This series introduces the Live Update Orchestrator, a kernel
subsystem designed to facilitate live kernel updates using a
kexec-based reboot. This capability is critical for cloud
environments, allowing hypervisors to be updated with minimal
downtime for running virtual machines. LUO achieves this by
preserving the state of selected resources, such as memory,
devices and their dependencies, across the kernel transition.
As a key feature, this series includes support for preserving
memfd file descriptors, which allows critical in-memory data, such
as guest RAM or any other large memory region, to be maintained in
RAM across the kexec reboot.
Mike Rappaport merits a mention here, for his extensive review and
testing work.
- "kexec: reorganize kexec and kdump sysfs" (Sourabh Jain)
moves the kexec and kdump sysfs entries from /sys/kernel/ to
/sys/kernel/kexec/ and adds back-compatibility symlinks which can
hopefully be removed one day
- "kho: fixes for vmalloc restoration" (Mike Rapoport)
fixes a BUG which was being hit during KHO restoration of vmalloc()
regions
* tag 'mm-nonmm-stable-2025-12-06-11-14' of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm: (139 commits)
calibrate: update header inclusion
Reinstate "resource: avoid unnecessary lookups in find_next_iomem_res()"
vmcoreinfo: track and log recoverable hardware errors
kho: fix restoring of contiguous ranges of order-0 pages
kho: kho_restore_vmalloc: fix initialization of pages array
MAINTAINERS: TPM DEVICE DRIVER: update the W-tag
init: replace simple_strtoul with kstrtoul to improve lpj_setup
KHO: fix boot failure due to kmemleak access to non-PRESENT pages
Documentation/ABI: new kexec and kdump sysfs interface
Documentation/ABI: mark old kexec sysfs deprecated
kexec: move sysfs entries to /sys/kernel/kexec
test_kho: always print restore status
kho: free chunks using free_page() instead of kfree()
selftests/liveupdate: add kexec test for multiple and empty sessions
selftests/liveupdate: add simple kexec-based selftest for LUO
selftests/liveupdate: add userspace API selftests
docs: add documentation for memfd preservation via LUO
mm: memfd_luo: allow preserving memfd
liveupdate: luo_file: add private argument to store runtime state
mm: shmem: export some functions to internal.h
...
1513 lines
29 KiB
C
1513 lines
29 KiB
C
/* 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[PAGE_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();
|
|
}
|