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();
|
|
}
|