void testoom(int mempolicy, int lite, int retcode, int allow_sigkill)
{
int ksm_run_orig;
set_global_mempolicy(mempolicy);
tst_res(TINFO, "start normal OOM testing.");
oom(NORMAL, lite, retcode, allow_sigkill);
tst_res(TINFO, "start OOM testing for mlocked pages.");
oom(MLOCK, lite, retcode, allow_sigkill);
/*
* Skip oom(KSM) if lite == 1, since limit_in_bytes may vary from
* run to run, which isn't reliable for oom03 cgroup test.
*/
if (access(PATH_KSM, F_OK) == -1 || lite == 1) {
tst_res(TINFO, "KSM is not configed or lite == 1, "
"skip OOM test for KSM pags");
} else {
tst_res(TINFO, "start OOM testing for KSM pages.");
SAFE_FILE_SCANF(PATH_KSM "run", "%d", &ksm_run_orig);
SAFE_FILE_PRINTF(PATH_KSM "run", "1");
oom(KSM, lite, retcode, allow_sigkill);
SAFE_FILE_PRINTF(PATH_KSM "run", "%d", ksm_run_orig);
}
}
static void cleanup(void)
{
if (opt_shmid && shmid != -1)
SAFE_SHMCTL(shmid, IPC_RMID, NULL);
if (!opt_shmid && fd != -1) {
SAFE_CLOSE(fd);
SAFE_UNLINK(TEST_FILE);
}
if (mounted)
tst_umount(MOUNT_DIR);
if (restore_nr_hgpgs) {
tst_res(TINFO, "restore nr_hugepages to %ld.", nr_hugepages);
SAFE_FILE_PRINTF(path, "%ld", nr_hugepages);
}
if (restore_shmmax)
SAFE_FILE_PRINTF(PATH_SHMMAX, "%llu", shmmax);
if (restore_overcomm_hgpgs) {
tst_res(TINFO, "restore nr_overcommit_hugepages to %ld.",
nr_overcommit_hugepages);
SAFE_FILE_PRINTF(pathover, "%ld", nr_overcommit_hugepages);
}
}
static void setup(void)
{
int fd;
tst_require_root(NULL);
fd = open(boost, O_RDWR);
if (fd == -1) {
tst_brkm(TCONF, NULL,
"acpi-cpufreq not loaded or overclock not supported");
}
close(fd);
tst_sig(FORK, DEF_HANDLER, cleanup);
SAFE_FILE_SCANF(NULL, boost, "%d", &boost_value);
SAFE_FILE_SCANF(NULL, up_limit, "%d", &threshold);
/* change cpu0 scaling governor */
SAFE_FILE_SCANF(NULL, governor, "%s", governor_name);
SAFE_FILE_PRINTF(cleanup, governor, "%s", "userspace");
/* use only cpu0 */
cpu_set_t set;
CPU_ZERO(&set);
CPU_SET(0, &set);
if (sched_setaffinity(0, sizeof(cpu_set_t), &set) < 0)
tst_brkm(TBROK | TERRNO, cleanup, "failed to set CPU0");
SAFE_FILE_PRINTF(cleanup, up_limit, "11");
}
void setup(void)
{
tst_require_root(NULL);
if (access(PATH_THP, F_OK) == -1)
tst_brkm(TCONF, NULL, "THP is not enabled");
SAFE_FILE_SCANF(NULL, PATH_KHPD "scan_sleep_millisecs",
"%d", &pre_thp_scan_sleep_millisecs);
/* set 0 to khugepaged/scan_sleep_millisecs to run khugepaged 100% */
SAFE_FILE_PRINTF(NULL, PATH_KHPD "scan_sleep_millisecs", "0");
SAFE_FILE_SCANF(NULL, PATH_KHPD "alloc_sleep_millisecs",
"%d", &pre_thp_alloc_sleep_millisecs);
/*
* set 0 to khugepaged/alloc_sleep_millisecs to make sure khugepaged
* don't stop if there's a hugepage allcation failure.
*/
SAFE_FILE_PRINTF(NULL, PATH_KHPD "alloc_sleep_millisecs", "0");
SAFE_FILE_SCANF(NULL, PATH_THP "enabled", "%[^\n]", pre_thp_enabled);
/* open khugepaged as 'always' mode */
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "always");
tst_sig(FORK, DEF_HANDLER, NULL);
TEST_PAUSE;
}
static void do_test(void)
{
int i;
if (!SAFE_FORK()) {
SAFE_FILE_PRINTF(PATH_AUTOGROUP, "%d", 1);
SAFE_SETSID();
if (SAFE_FORK())
pause();
SAFE_KILL(getppid(), SIGKILL);
usleep(1000);
// The child has gone, the grandchild runs with kref == 1
SAFE_FILE_PRINTF(PATH_AUTOGROUP, "%d", 0);
SAFE_SETSID();
// runs with the freed ag/tg
for (i = 0; i < LOOPS; i++)
usleep(10);
TST_CHECKPOINT_WAKE(0);
exit(0);
}
SAFE_WAIT(NULL); // destroy the child's ag/tg
TST_CHECKPOINT_WAIT(0);
tst_res(TPASS, "Bug not reproduced");
}
void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
char *abs_path = tst_get_tmpdir();
SAFE_ASPRINTF(cleanup, &testfile3, "%s/fstatattestfile3.txt", abs_path);
free(abs_path);
SAFE_MKDIR(cleanup, pathname, 0700);
fds[0] = SAFE_OPEN(cleanup, pathname, O_DIRECTORY);
fds[1] = fds[4] = fds[0];
SAFE_FILE_PRINTF(cleanup, testfile, testfile);
SAFE_FILE_PRINTF(cleanup, testfile2, testfile2);
fds[2] = SAFE_OPEN(cleanup, testfile3, O_CREAT | O_RDWR, 0600);
fds[3] = 100;
fds[5] = AT_FDCWD;
filenames[0] = filenames[2] = filenames[3] = filenames[4] =
filenames[5] = testfile;
filenames[1] = testfile3;
TEST_PAUSE;
}
int main(int argc, char *argv[])
{
char *msg;
int lc;
int swap_acc_on = 1;
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
#if __WORDSIZE == 32
tst_brkm(TCONF, NULL, "test is not designed for 32-bit system.");
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
tst_resm(TINFO, "OOM on CPUSET & MEMCG...");
testoom(0, 0);
/*
* Under NUMA system, the migration of cpuset's memory
* is in charge of cpuset.memory_migrate, we can write
* 1 to cpuset.memory_migrate to enable the migration.
*/
if (is_numa(cleanup)) {
write_cpuset_files(CPATH_NEW, "memory_migrate", "1");
tst_resm(TINFO, "OOM on CPUSET & MEMCG with "
"cpuset.memory_migrate=1");
testoom(0, 0);
}
if (access(MEMCG_SW_LIMIT, F_OK) == -1) {
if (errno == ENOENT) {
tst_resm(TCONF,
"memcg swap accounting is disabled");
swap_acc_on = 0;
} else
tst_brkm(TBROK|TERRNO, cleanup, "access");
}
if (swap_acc_on) {
tst_resm(TINFO, "OOM on CPUSET & MEMCG with "
"special memswap limitation:");
SAFE_FILE_PRINTF(cleanup, MEMCG_SW_LIMIT, "%ld", TESTMEM);
testoom(0, 0);
tst_resm(TINFO, "OOM on CPUSET & MEMCG with "
"disabled memswap limitation:");
SAFE_FILE_PRINTF(cleanup, MEMCG_SW_LIMIT, "-1");
testoom(0, 0);
}
}
cleanup();
tst_exit();
}
static void setup(void)
{
check_hugepage();
hugepagesize = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
init_sys_sz_paths();
if (opt_sysfs) {
path = path_sys_sz_huge;
pathover = path_sys_sz_over;
} else {
path = PATH_PROC_HUGE;
pathover = PATH_PROC_OVER;
}
if (opt_alloc) {
size = atoi(opt_alloc);
length = (size + size * 0.5) * 2;
}
if (opt_shmid) {
SAFE_FILE_SCANF(PATH_SHMMAX, "%llu", &shmmax);
if (shmmax < (unsigned long long)(length / 2 * hugepagesize)) {
restore_shmmax = 1;
SAFE_FILE_PRINTF(PATH_SHMMAX, "%ld",
(length / 2 * hugepagesize));
}
}
SAFE_FILE_SCANF(path, "%ld", &nr_hugepages);
tst_res(TINFO, "original nr_hugepages is %ld", nr_hugepages);
/* Reset. */
SAFE_FILE_PRINTF(path, "%ld", size);
restore_nr_hgpgs = 1;
if (access(pathover, F_OK)) {
tst_brk(TCONF, "file %s does not exist in the system",
pathover);
}
SAFE_FILE_SCANF(pathover, "%ld", &nr_overcommit_hugepages);
tst_res(TINFO, "original nr_overcommit_hugepages is %ld",
nr_overcommit_hugepages);
/* Reset. */
SAFE_FILE_PRINTF(pathover, "%ld", size);
restore_overcomm_hgpgs = 1;
SAFE_MKDIR(MOUNT_DIR, 0700);
SAFE_MOUNT(NULL, MOUNT_DIR, "hugetlbfs", 0, NULL);
mounted = 1;
if (opt_shmid) {
/* Use /proc/meminfo to generate an IPC key. */
key = ftok(PATH_MEMINFO, strlen(PATH_MEMINFO));
if (key == -1)
tst_brk(TBROK | TERRNO, "ftok");
}
}
static void cleanup(void)
{
SAFE_FILE_PRINTF(NULL, boost, "%d", boost_value);
if (governor[0] != '\0')
SAFE_FILE_PRINTF(NULL, governor, "%s", governor_name);
if (threshold)
SAFE_FILE_PRINTF(NULL, up_limit, "%d", threshold);
TEST_CLEANUP;
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fd2 = SAFE_OPEN(cleanup, ".", O_DIRECTORY);
SAFE_FILE_PRINTF(cleanup, "test_file", "A");
fd3 = SAFE_OPEN(cleanup, "test_file", O_RDWR);
#if !defined(UCLINUX)
outside_buf = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
#endif
addr4 = SAFE_MEMALIGN(cleanup, getpagesize(), (4096 * 10));
addr5 = addr4 + 1;
fs_type = tst_fs_type(cleanup, ".");
if (fs_type != TST_TMPFS_MAGIC)
fd4 = SAFE_OPEN(cleanup, "test_file", O_RDWR | O_DIRECT);
}
void setup(void)
{
long mem_total, hpage_size;
tst_require_root();
mem_total = read_meminfo("MemTotal:");
SAFE_FILE_SCANF(NULL, PATH_SHMMAX, "%ld", &orig_shmmax);
SAFE_FILE_PRINTF(NULL, PATH_SHMMAX, "%ld", (long)SIZE);
SAFE_FILE_SCANF(NULL, PATH_SHMMAX, "%ld", &new_shmmax);
if (mem_total < 2L*1024*1024)
tst_brkm(TCONF, NULL, "Needed > 2GB RAM, have: %ld", mem_total);
if (new_shmmax < SIZE)
tst_brkm(TCONF, NULL, "shmmax too low, have: %ld", new_shmmax);
orig_hugepages = get_sys_tune("nr_hugepages");
hpage_size = read_meminfo("Hugepagesize:") * 1024;
hugepages = (orig_hugepages * hpage_size + SIZE) / hpage_size;
set_sys_tune("nr_hugepages", hugepages, 1);
TEST_PAUSE;
}
static void client_run(void)
{
void *res = NULL;
long clnt_time = 0;
int i;
for (i = 0; i < clients_num; ++i) {
pthread_join(thread_ids[i], &res);
if (res) {
tst_brkm(TBROK, cleanup, "client[%d] failed: %s",
i, strerror((intptr_t)res));
}
}
clock_gettime(CLOCK_MONOTONIC_RAW, &tv_client_end);
clnt_time = (tv_client_end.tv_sec - tv_client_start.tv_sec) * 1000 +
(tv_client_end.tv_nsec - tv_client_start.tv_nsec) / 1000000;
tst_resm(TINFO, "total time '%ld' ms", clnt_time);
/* ask server to terminate */
client_msg[0] = start_fin_byte;
int cfd = client_connect_send(client_msg, client_msg_size);
if (cfd != -1) {
shutdown(cfd, SHUT_WR);
SAFE_CLOSE(NULL, cfd);
}
/* the script tcp_fastopen_run.sh will remove it */
SAFE_FILE_PRINTF(cleanup, rpath, "%ld", clnt_time);
}
void setup(void)
{
if ((tst_kvercmp(2, 6, 17)) < 0) {
tst_brkm(TCONF, cleanup, "This test can only run on kernels "
"that are 2.6.17 or higher");
}
TEST_PAUSE;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_FILE_PRINTF(cleanup, TEST_FILE, STR);
rdfd = SAFE_OPEN(cleanup, TEST_FILE, O_RDONLY);
wrfd = SAFE_OPEN(cleanup, TEST_FILE2,
O_WRONLY | O_CREAT, 0644);
appendfd = SAFE_OPEN(cleanup, TEST_FILE3,
O_RDWR | O_CREAT | O_APPEND, 0644);
SAFE_PIPE(cleanup, pipes);
SAFE_WRITE(cleanup, 1, pipes[1], STR, sizeof(STR) - 1);
}
void setup(void)
{
tst_require_root(NULL);
if (tst_kvercmp(2, 6, 32) < 0)
tst_brkm(TCONF, NULL, "2.6.32 or greater kernel required");
if (access(PATH_KSM, F_OK) == -1)
tst_brkm(TCONF, NULL, "KSM configuration is not enabled");
/*
* kernel commit 90bd6fd introduced a new KSM sysfs knob
* /sys/kernel/mm/ksm/merge_across_nodes, setting it to '0'
* will prevent KSM pages being merged across numa nodes,
* which will cause the case fail, so we need to make sure
* it is enabled before testing.
*/
if (access(PATH_KSM "merge_across_nodes", F_OK) == 0) {
SAFE_FILE_SCANF(NULL, PATH_KSM "merge_across_nodes",
"%d", &merge_across_nodes);
SAFE_FILE_PRINTF(NULL, PATH_KSM "merge_across_nodes", "1");
}
tst_sig(FORK, DEF_HANDLER, NULL);
TEST_PAUSE;
}
int main(int argc, char *argv[])
{
const char *msg;
int lc;
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
#if __WORDSIZE == 32
tst_brkm(TCONF, NULL, "test is not designed for 32-bit system.");
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
SAFE_FILE_PRINTF(cleanup, MEMCG_PATH_NEW "/tasks",
"%d", getpid());
SAFE_FILE_PRINTF(cleanup, MEMCG_LIMIT, "%ld", TESTMEM);
testoom(0, 0, ENOMEM, 1);
if (access(MEMCG_SW_LIMIT, F_OK) == -1) {
if (errno == ENOENT)
tst_resm(TCONF,
"memcg swap accounting is disabled");
else
tst_brkm(TBROK | TERRNO, cleanup, "access");
} else {
SAFE_FILE_PRINTF(cleanup, MEMCG_SW_LIMIT,
"%ld", TESTMEM);
testoom(0, 1, ENOMEM, 1);
}
/* OOM for MEMCG with mempolicy */
if (is_numa(cleanup)) {
tst_resm(TINFO, "OOM on MEMCG & mempolicy...");
testoom(MPOL_BIND, 0, ENOMEM, 1);
testoom(MPOL_INTERLEAVE, 0, ENOMEM, 1);
testoom(MPOL_PREFERRED, 0, ENOMEM, 1);
}
}
cleanup();
tst_exit();
}
static void cleanup(void)
{
if (ovl_mounted)
SAFE_UMOUNT(OVL_MNT);
if (orig_bdi_limit)
SAFE_FILE_PRINTF(sys_bdi_ra_path, "%d", orig_bdi_limit);
}
void cleanup(void)
{
SAFE_FILE_PRINTF(NULL, PATH_KHPD "scan_sleep_millisecs",
"%d", pre_thp_scan_sleep_millisecs);
SAFE_FILE_PRINTF(NULL, PATH_KHPD "alloc_sleep_millisecs",
"%d", pre_thp_alloc_sleep_millisecs);
if (strcmp(pre_thp_enabled, "[always] madvise never") == 0)
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "always");
else if (strcmp(pre_thp_enabled, "always [madvise] never") == 0)
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "madvise");
else
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "never");
TEST_CLEANUP;
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
SAFE_FILE_PRINTF(cleanup, FNAME, "File content\n");
}
static void setup(void)
{
SAFE_MKDIR(MOUNT_NAME, 0755);
SAFE_MOUNT(MOUNT_NAME, MOUNT_NAME, "none", MS_BIND, NULL);
mount_created = 1;
SAFE_CHDIR(MOUNT_NAME);
SAFE_MKDIR(DIR_NAME, 0755);
sprintf(fname, "tfile_%d", getpid());
SAFE_FILE_PRINTF(fname, "1");
}
static void test_run(void)
{
int cur_freq, max_freq;
SAFE_FILE_SCANF(cleanup, maxspeed, "%d", &max_freq);
set_speed(max_freq);
/* Enable boost */
if (boost_value == 0)
SAFE_FILE_PRINTF(cleanup, boost, "1");
cur_freq = load_cpu(30);
tst_resm((cur_freq >= max_freq) ? TPASS : TFAIL,
"compare current speed %d and max speed %d",
cur_freq, max_freq);
/* Disable boost */
SAFE_FILE_PRINTF(cleanup, boost, "0");
cur_freq = load_cpu(30);
tst_resm((cur_freq < max_freq) ? TPASS : TFAIL,
"compare current speed %d and max speed %d",
cur_freq, max_freq);
}
void setup(void)
{
TEST_PAUSE;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
SAFE_FILE_PRINTF(cleanup, TEST_FILE, "test file");
SAFE_SYMLINK(cleanup, TEST_FILE, SFILE);
}
static void do_cleanup(void)
{
free(client_msg);
free(server_msg);
tcp.cleanup();
if (tfo_cfg_changed) {
SAFE_FILE_SCANF(NULL, tfo_cfg, "%d", &tfo_cfg_value);
tfo_cfg_value &= ~tfo_bit_num;
tfo_cfg_value |= !tfo_support << (tfo_bit_num - 1);
tst_resm(TINFO, "unset '%s' back to '%d'",
tfo_cfg, tfo_cfg_value);
SAFE_FILE_PRINTF(NULL, tfo_cfg, "%d", tfo_cfg_value);
}
if (tw_reuse_changed) {
SAFE_FILE_PRINTF(NULL, tcp_tw_reuse, "0");
tst_resm(TINFO, "unset '%s' back to '0'", tcp_tw_reuse);
}
}
void cleanup(void)
{
SAFE_FILE_PRINTF(NULL, PATH_KHPD "scan_sleep_millisecs",
"%d", pre_thp_scan_sleep_millisecs);
SAFE_FILE_PRINTF(NULL, PATH_KHPD "alloc_sleep_millisecs",
"%d", pre_thp_alloc_sleep_millisecs);
/*
* The value of transparent_hugepage/enabled is speical,
* we need to recover the previous value one by one for
* the three mode: always, madvise, never.
*/
if (strcmp(pre_thp_enabled, "[always] madvise never") == 0)
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "always");
else if (strcmp(pre_thp_enabled, "always [madvise] never") == 0)
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "madvise");
else
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "never");
TEST_CLEANUP;
}
static void set_speed(int freq)
{
int set_freq;
SAFE_FILE_SCANF(cleanup, setspeed, "%d", &set_freq);
if (set_freq != freq) {
tst_resm(TINFO, "change speed from %d to %d...",
set_freq, freq);
SAFE_FILE_PRINTF(cleanup, setspeed, "%d", freq);
} else {
tst_resm(TINFO, "set speed is %d", set_freq);
}
}
static void test_run(void)
{
int boost_time, boost_off_time, max_freq_khz;
SAFE_FILE_SCANF(cleanup, maxspeed, "%d", &max_freq_khz);
tst_resm(TINFO, "maximum speed is %d KHz", max_freq_khz);
/* Enable boost */
if (boost_value == cdrv[id].off)
SAFE_FILE_PRINTF(cleanup, cdrv[id].file, "%s", cdrv[id].on_str);
tst_resm(TINFO, "load CPU0 with boost enabled");
boost_time = load_cpu(max_freq_khz);
/* Disable boost */
SAFE_FILE_PRINTF(cleanup, cdrv[id].file, "%s", cdrv[id].off_str);
tst_resm(TINFO, "load CPU0 with boost disabled");
boost_off_time = load_cpu(max_freq_khz);
boost_off_time *= .98;
tst_resm((boost_time < boost_off_time) ? TPASS : TFAIL,
"compare time spent with and without boost (-2%%)");
}
void testoom(int mempolicy, int lite, int retcode, int allow_sigkill)
{
int ksm_run_orig;
set_global_mempolicy(mempolicy);
tst_resm(TINFO, "start normal OOM testing.");
oom(NORMAL, lite, retcode, allow_sigkill);
tst_resm(TINFO, "start OOM testing for mlocked pages.");
oom(MLOCK, lite, retcode, allow_sigkill);
if (access(PATH_KSM, F_OK) == -1) {
tst_resm(TINFO, "KSM configuration is not enabled, "
"skip OOM test for KSM pags");
} else {
tst_resm(TINFO, "start OOM testing for KSM pages.");
SAFE_FILE_SCANF(cleanup, PATH_KSM "run", "%d", &ksm_run_orig);
SAFE_FILE_PRINTF(cleanup, PATH_KSM "run", "1");
oom(KSM, lite, retcode, allow_sigkill);
SAFE_FILE_PRINTF(cleanup,PATH_KSM "run", "%d", ksm_run_orig);
}
}
void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
char *abs_path = tst_get_tmpdir();
int p = getpid();
/* Initialize test dir and file names */
sprintf(pathname, "faccessattestdir%d", p);
sprintf(testfile, "faccessattestfile%d.txt", p);
sprintf(testfile2, "%s/faccessattestfile%d.txt", abs_path, p);
sprintf(testfile3, "faccessattestdir%d/faccessattestfile%d.txt", p, p);
free(abs_path);
SAFE_MKDIR(cleanup, pathname, 0700);
fds[0] = SAFE_OPEN(cleanup, pathname, O_DIRECTORY);
fds[1] = fds[4] = fds[0];
SAFE_FILE_PRINTF(cleanup, testfile, testfile);
SAFE_FILE_PRINTF(cleanup, testfile2, testfile2);
fds[2] = SAFE_OPEN(cleanup, testfile3, O_CREAT | O_RDWR, 0600);
fds[3] = 100;
fds[5] = AT_FDCWD;
filenames[0] = filenames[2] = filenames[3] = filenames[4] = testfile;
filenames[1] = testfile2;
filenames[5] = testfile3;
TEST_PAUSE;
}
void setup(void)
{
tst_require_root(NULL);
if (access(PATH_THP, F_OK) == -1)
tst_brkm(TCONF, NULL, "THP is not enabled");
if (!is_numa(NULL))
tst_brkm(TCONF, NULL, "The case need a NUMA system.");
SAFE_FILE_SCANF(NULL, PATH_KHPD "scan_sleep_millisecs",
"%d", &pre_thp_scan_sleep_millisecs);
SAFE_FILE_PRINTF(NULL, PATH_KHPD "scan_sleep_millisecs", "0");
SAFE_FILE_SCANF(NULL, PATH_KHPD "alloc_sleep_millisecs",
"%d", &pre_thp_alloc_sleep_millisecs);
SAFE_FILE_PRINTF(NULL, PATH_KHPD "alloc_sleep_millisecs", "0");
SAFE_FILE_SCANF(NULL, PATH_THP "enabled", "%[^\n]", pre_thp_enabled);
SAFE_FILE_PRINTF(NULL, PATH_THP "enabled", "always");
tst_sig(FORK, DEF_HANDLER, NULL);
TEST_PAUSE;
}
static void run_pci_testcases(int bus, int slot)
{
int i, res;
for (i = 0; i < TST_TOTAL; ++i) {
/* skip pci disable test-case, it is manual */
if (i == PCI_DISABLE)
continue;
SAFE_FILE_PRINTF(cleanup, dev_tcase, "%d", i);
SAFE_FILE_SCANF(cleanup, dev_result, "%d", &res);
tst_resm(res, "PCI bus %02x slot %02x : Test-case '%d'",
bus, slot, i);
}
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
UID16_CHECK((uid = geteuid()), "chown", cleanup)
GID16_CHECK((gid = getegid()), "chown", cleanup)
sprintf(fname, "t_%d", getpid());
SAFE_FILE_PRINTF(cleanup, fname, "davef");
}