void setup(void)
{
long mem_total, swap_total;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
if (access(PATH_SYSVM "overcommit_memory", F_OK) == -1 ||
access(PATH_SYSVM "overcommit_ratio", F_OK) == -1)
tst_brkm(TCONF, NULL, "The system "
"can't support to test %s", TCID);
old_overcommit_memory = get_sys_tune("overcommit_memory");
old_overcommit_ratio = get_sys_tune("overcommit_ratio");
set_sys_tune("overcommit_ratio", overcommit_ratio, 1);
mem_total = read_meminfo("MemTotal:");
tst_resm(TINFO, "MemTotal is %ld kB", mem_total);
swap_total = read_meminfo("SwapTotal:");
tst_resm(TINFO, "SwapTotal is %ld kB", swap_total);
sum_total = mem_total + swap_total;
commit_limit = read_meminfo("CommitLimit:");
tst_resm(TINFO, "CommitLimit is %ld kB", commit_limit);
}
void setup(void)
{
tst_require_root(NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
if (access(PATH_SYSVM "max_map_count", F_OK) != 0)
tst_brkm(TBROK | TERRNO, NULL,
"Can't support to test max_map_count");
old_max_map_count = get_sys_tune("max_map_count");
old_overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 2, 1);
}
void setup(void)
{
long hpage_size;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey();
/* create a shared memory segment without read or write permissions */
shm_id_1 = shmget(shmkey, shm_size, SHM_HUGETLB | IPC_CREAT | IPC_EXCL);
if (shm_id_1 == -1)
tst_brkm(TBROK | TERRNO, cleanup, "shmget #1");
/* create a shared memory segment with read and write permissions */
shm_id_2 = shmget(shmkey + 1, shm_size,
SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW);
if (shm_id_2 == -1)
tst_brkm(TBROK | TERRNO, cleanup, "shmget #2");
TEST_PAUSE;
}
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;
}
void setup(void)
{
int memnode, ret;
tst_require_root(NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW);
/*
* Some nodes do not contain memory, so use
* get_allowed_nodes(NH_MEMS) to get a memory
* node. This operation also applies to Non-NUMA
* systems.
*/
ret = get_allowed_nodes(NH_MEMS, 1, &memnode);
if (ret < 0)
tst_brkm(TBROK, NULL, "Failed to get a memory node "
"using get_allowed_nodes()");
write_cpusets(memnode);
}
void setup(void)
{
long hpage_size;
tst_require_root();
check_hugepage();
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey(cleanup);
shm_id_1 = shmget(shmkey, shm_size,
SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW);
if (shm_id_1 == -1)
tst_brkm(TBROK | TERRNO, cleanup, "shmget");
/* get the userid for a non root user */
ltp_uid = getuserid(cleanup, ltp_user);
TEST_PAUSE;
}
void setup(void)
{
int ret, memnode;
tst_require_root();
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
if (!is_numa(NULL, NH_MEMS, 1))
tst_brkm(TCONF, NULL, "requires NUMA with at least 1 node");
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
mount_mem("memcg", "cgroup", "memory", MEMCG_PATH, MEMCG_PATH_NEW);
mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW);
write_memcg();
/*
* Some nodes do not contain memory, so use
* get_allowed_nodes(NH_MEMS) to get a memory
* node. This operation also applies to Non-NUMA
* systems.
*/
ret = get_allowed_nodes(NH_MEMS, 1, &memnode);
if (ret < 0)
tst_brkm(TBROK, cleanup, "Failed to get a memory node "
"using get_allowed_nodes()");
write_cpusets(memnode);
}
void setup(void)
{
long hpage_size;
tst_require_root(NULL);
tst_sig(NOFORK, sighandler, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey();
/* create a shared memory resource with read and write permissions */
shm_id_1 = shmget(shmkey, shm_size,
SHM_HUGETLB | SHM_RW | IPC_CREAT | IPC_EXCL);
if (shm_id_1 == -1)
tst_brkm(TBROK | TERRNO, cleanup, "shmget");
/* attach the shared memory segment */
shared = shmat(shm_id_1, 0, 0);
if (shared == (void *)-1)
tst_brkm(TBROK | TERRNO, cleanup, "shmat #1");
/* give a value to the shared memory integer */
*shared = 4;
TEST_PAUSE;
}
static void setup(void)
{
int memnode, ret;
if (!is_numa(NULL, NH_MEMS, 1))
tst_brk(TCONF, "requires NUMA with at least 1 node");
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW);
cpuset_mounted = 1;
/*
* Some nodes do not contain memory, so use
* get_allowed_nodes(NH_MEMS) to get a memory
* node. This operation also applies to Non-NUMA
* systems.
*/
ret = get_allowed_nodes(NH_MEMS, 1, &memnode);
if (ret < 0)
tst_brk(TBROK, "Failed to get a memory node "
"using get_allowed_nodes()");
write_cpusets(memnode);
}
void setup(void)
{
tst_require_root();
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
overcommit = get_sys_tune("overcommit_memory");
}
void setup(void)
{
tst_require_root(NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
mount_mem("cpuset", "cpuset", NULL, CPATH, CPATH_NEW);
}
void setup(void)
{
TEST_PAUSE;
tst_require_root();
if (mount("none", Hopt, "hugetlbfs", 0, NULL) < 0)
tst_brkm(TBROK | TERRNO, NULL, "mount failed on %s", Hopt);
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
snprintf(TEMPFILE, sizeof(TEMPFILE), "%s/mmapfile%d", Hopt, getpid());
}
void setup(void)
{
tst_require_root(NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
mount_mem("memcg", "cgroup", "memory", MEMCG_PATH, MEMCG_PATH_NEW);
}
void setup(void)
{
tst_require_root();
tst_sig(FORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
if (!is_numa(NULL))
tst_brkm(TCONF, NULL, "The case need a NUMA system.");
overcommit = get_sys_tune("overcommit_memory");
set_sys_tune("overcommit_memory", 1, 1);
}
static void setup(void)
{
long mem_total, swap_total;
struct rlimit lim;
if (access(PATH_SYSVM "overcommit_memory", F_OK) == -1 ||
access(PATH_SYSVM "overcommit_ratio", F_OK) == -1)
tst_brk(TCONF, "The system "
"can't support to test %s", TCID);
if (R_opt)
overcommit_ratio = SAFE_STRTOL(R_opt, 0, LONG_MAX);
else
overcommit_ratio = DEFAULT_OVER_RATIO;
old_overcommit_memory = get_sys_tune("overcommit_memory");
old_overcommit_ratio = get_sys_tune("overcommit_ratio");
mem_total = SAFE_READ_MEMINFO("MemTotal:");
tst_res(TINFO, "MemTotal is %ld kB", mem_total);
swap_total = SAFE_READ_MEMINFO("SwapTotal:");
tst_res(TINFO, "SwapTotal is %ld kB", swap_total);
sum_total = mem_total + swap_total;
commit_limit = SAFE_READ_MEMINFO("CommitLimit:");
tst_res(TINFO, "CommitLimit is %ld kB", commit_limit);
SAFE_GETRLIMIT(RLIMIT_AS, &lim);
if (lim.rlim_cur != RLIM_INFINITY) {
lim.rlim_cur = RLIM_INFINITY;
lim.rlim_max = RLIM_INFINITY;
tst_res(TINFO, "Increasing RLIM_AS to INFINITY");
SAFE_SETRLIMIT(RLIMIT_AS, &lim);
}
set_sys_tune("overcommit_ratio", overcommit_ratio, 1);
}
void set_sys_tune(char *sys_file, long tune, int check)
{
long val;
char path[BUFSIZ];
tst_resm(TINFO, "set %s to %ld", sys_file, tune);
snprintf(path, BUFSIZ, PATH_SYSVM "%s", sys_file);
SAFE_FILE_PRINTF(NULL, path, "%ld", tune);
if (check) {
val = get_sys_tune(sys_file);
if (val != tune)
tst_brkm(TBROK, cleanup, "%s = %ld, but expect %ld",
sys_file, val, tune);
}
}
void setup(void)
{
long hpage_size;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey();
TEST_PAUSE;
}
void set_sys_tune(char *sys_file, long tune, int check)
{
long val;
char buf[BUFSIZ], path[BUFSIZ];
tst_resm(TINFO, "set %s to %ld", sys_file, tune);
snprintf(path, BUFSIZ, "%s%s", PATH_SYSVM, sys_file);
snprintf(buf, BUFSIZ, "%ld", tune);
write_file(path, buf);
if (check) {
val = get_sys_tune(sys_file);
if (val != tune)
tst_brkm(TBROK, cleanup, "%s = %ld, but expect %ld",
sys_file, val, tune);
}
}
void setup(void)
{
long hpage_size;
tst_require_root();
check_hugepage();
tst_sig(FORK, sighandler, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey(cleanup);
TEST_PAUSE;
}
void setup(void)
{
long hpage_size;
char buf[BUFSIZ];
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size;
read_file(PATH_SHMMNI, buf);
orig_shmmni = SAFE_STRTOL(cleanup, buf, 0, LONG_MAX);
snprintf(buf, BUFSIZ, "%ld", hugepages / 2);
write_file(PATH_SHMMNI, buf);
/*
* Use a while loop to create the maximum number of memory segments.
* If the loop exceeds MAXIDS, then break the test and cleanup.
*/
num_shms = 0;
shm_id_1 = shmget(IPC_PRIVATE, shm_size,
SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW);
while (shm_id_1 != -1) {
shm_id_arr[num_shms++] = shm_id_1;
if (num_shms == MAXIDS)
tst_brkm(TBROK, cleanup, "The maximum number of "
"shared memory ID's has been reached. "
"Please increase the MAXIDS value in "
"the test.");
shm_id_1 = shmget(IPC_PRIVATE, shm_size,
SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW);
}
if (errno != ENOSPC)
tst_brkm(TBROK | TERRNO, cleanup, "shmget #setup");
TEST_PAUSE;
}
void setup(void)
{
long hpage_size;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
orig_hugepages = get_sys_tune("nr_hugepages");
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = read_meminfo("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey();
shm_id_1 = shmget(shmkey++, shm_size,
SHM_HUGETLB | SHM_RW | IPC_CREAT | IPC_EXCL);
if (shm_id_1 == -1)
tst_brkm(TBROK | TERRNO, cleanup, "shmget");
TEST_PAUSE;
}
static void update_mem(void)
{
long mem_free, swap_free;
long committed;
mem_free = read_meminfo("MemFree:");
swap_free = read_meminfo("SwapFree:");
free_total = mem_free + swap_free;
commit_limit = read_meminfo("CommitLimit:");
if (get_sys_tune("overcommit_memory") == 2) {
committed = read_meminfo("Committed_AS:");
commit_left = commit_limit - committed;
if (commit_left < 0) {
tst_resm(TINFO, "CommmitLimit is %ld, Committed_AS"
" is %ld", commit_limit, committed);
tst_brkm(TBROK, cleanup, "Unexpected error: "
"CommitLimit < Committed_AS");
}
}
}
