static void test_hugemmap(void)
{
long page_sz = 0;
fildes = SAFE_OPEN(TEMPFILE, O_RDWR | O_CREAT, 0666);
beforetest = SAFE_READ_MEMINFO("HugePages_Free:");
page_sz = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
addr = mmap(NULL, page_sz, PROT_READ | PROT_WRITE,
MAP_SHARED, fildes, 0);
if (addr == MAP_FAILED) {
tst_res(TFAIL | TERRNO, "mmap() Failed on %s",
TEMPFILE);
} else {
tst_res(TPASS, "call succeeded");
/* force to allocate page and change HugePages_Free */
*(int *)addr = 0;
/* Make sure the number of free huge pages AFTER testing decreased */
aftertest = SAFE_READ_MEMINFO("HugePages_Free:");
hugepagesmapped = beforetest - aftertest;
if (hugepagesmapped < 1)
tst_res(TWARN, "Number of HUGEPAGES_FREE stayed the"
" same. Okay if multiple copies running due"
" to test collision.");
munmap(addr, page_sz);
}
close(fildes);
}
static void check_swapping(void)
{
int status, i;
long swap_free_now, swapped;
/* wait child stop */
SAFE_WAITPID(pid, &status, WUNTRACED);
if (!WIFSTOPPED(status))
tst_brk(TBROK, "child was not stopped.");
/* Still occupying memory, loop for a while */
i = 0;
while (i < 10) {
swap_free_now = SAFE_READ_MEMINFO("SwapFree:");
sleep(1);
if (abs(swap_free_now - SAFE_READ_MEMINFO("SwapFree:")) < 512)
break;
i++;
}
swap_free_now = SAFE_READ_MEMINFO("SwapFree:");
swapped = swap_free_init - swap_free_now;
if (swapped > mem_over_max) {
kill(pid, SIGCONT);
tst_brk(TFAIL, "heavy swapping detected: "
"%ld MB swapped.", swapped / 1024);
}
tst_res(TPASS, "no heavy swapping detected, %ld MB swapped.",
swapped / 1024);
kill(pid, SIGCONT);
/* wait child exit */
SAFE_WAITPID(pid, &status, 0);
}
static void update_mem(void)
{
long mem_free, swap_free;
mem_free = SAFE_READ_MEMINFO("MemFree:");
swap_free = SAFE_READ_MEMINFO("SwapFree:");
free_total = mem_free + swap_free;
}
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 test_hugemmap(void)
{
int huge_pagesize = 0;
/* Creat a temporary file used for huge mapping */
fildes = SAFE_OPEN(TEMPFILE, O_RDWR | O_CREAT, 0666);
freepages = SAFE_READ_MEMINFO("HugePages_Free:");
beforetest = freepages;
huge_pagesize = SAFE_READ_MEMINFO("Hugepagesize:");
tst_res(TINFO, "Size of huge pages is %d KB", huge_pagesize);
#ifdef TST_ABI32
tst_res(TINFO, "Total amount of free huge pages is %d",
freepages);
tst_res(TINFO, "Max number allowed for 1 mmap file in"
" 32-bits is 128");
if (freepages > 128)
freepages = 128;
#endif
mapsize = (long long)freepages * huge_pagesize * 1024;
addr = mmap(NULL, mapsize, PROT_READ | PROT_WRITE,
MAP_SHARED, fildes, 0);
if (addr == MAP_FAILED) {
tst_res(TFAIL | TERRNO, "mmap() Failed on %s",
TEMPFILE);
} else {
tst_res(TPASS,
"Succeeded mapping file using %ld pages",
freepages);
/* force to allocate page and change HugePages_Free */
*(int *)addr = 0;
/* Make sure the number of free huge pages AFTER testing decreased */
aftertest = SAFE_READ_MEMINFO("HugePages_Free:");
hugepagesmapped = beforetest - aftertest;
if (hugepagesmapped < 1)
tst_res(TWARN, "Number of HUGEPAGES_FREE stayed the"
" same. Okay if multiple copies running due"
" to test collision.");
}
munmap(addr, mapsize);
close(fildes);
}
static void init_meminfo(void)
{
swap_free_init = SAFE_READ_MEMINFO("SwapFree:");
if (FILE_LINES_SCANF("/proc/meminfo", "MemAvailable: %ld",
&mem_available_init)) {
mem_available_init = SAFE_READ_MEMINFO("MemFree:")
+ SAFE_READ_MEMINFO("Cached:");
}
mem_over = mem_available_init * COE_SLIGHT_OVER;
mem_over_max = mem_available_init * COE_DELTA;
/* at least 10MB available physical memory needed */
if (mem_available_init < 10240)
tst_brk(TCONF, "Not enough available mem to test.");
if (swap_free_init < mem_over_max)
tst_brk(TCONF, "Not enough swap space to test.");
}
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);
}
static void update_mem_commit(void)
{
long committed;
commit_limit = SAFE_READ_MEMINFO("CommitLimit:");
committed = SAFE_READ_MEMINFO("Committed_AS:");
commit_left = commit_limit - committed;
if (commit_left < 0) {
tst_res(TINFO, "CommitLimit is %ld, Committed_AS is %ld",
commit_limit, committed);
if (overcommit_ratio > old_overcommit_ratio) {
tst_brk(TBROK, "Unexpected error: "
"CommitLimit < Committed_AS");
}
tst_brk(TCONF, "Specified overcommit_ratio %ld <= default %ld, "
"so it's possible for CommitLimit < Committed_AS and skip test",
overcommit_ratio, old_overcommit_ratio);
}
}
static void update_mem(void)
{
long mem_free, swap_free;
long committed;
mem_free = SAFE_READ_MEMINFO("MemFree:");
swap_free = SAFE_READ_MEMINFO("SwapFree:");
free_total = mem_free + swap_free;
commit_limit = SAFE_READ_MEMINFO("CommitLimit:");
if (get_sys_tune("overcommit_memory") == 2) {
committed = SAFE_READ_MEMINFO("Committed_AS:");
commit_left = commit_limit - committed;
if (commit_left < 0) {
tst_res(TINFO, "CommitLimit is %ld, Committed_AS"
" is %ld", commit_limit, committed);
tst_brk(TBROK, "Unexpected error: "
"CommitLimit < Committed_AS");
}
}
}
void setup(void)
{
long hpage_size;
save_nr_hugepages();
if (nr_opt)
hugepages = SAFE_STRTOL(nr_opt, 0, LONG_MAX);
set_sys_tune("nr_hugepages", hugepages, 1);
hpage_size = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
shm_size = hpage_size * hugepages / 2;
update_shm_size(&shm_size);
shmkey = getipckey();
shmkey2 = shmkey + 1;
shm_id_1 = shmget(shmkey, shm_size,
SHM_HUGETLB | IPC_CREAT | IPC_EXCL | SHM_RW);
if (shm_id_1 == -1)
tst_brk(TBROK | TERRNO, "shmget #setup");
}
static void setup(void)
{
long hpage_size;
save_nr_hugepages();
if (nr_opt)
hugepages = SAFE_STRTOL(nr_opt, 0, LONG_MAX);
SAFE_FILE_SCANF(PATH_SHMMNI, "%ld", &orig_shmmni);
set_sys_tune("nr_hugepages", hugepages, 1);
SAFE_FILE_PRINTF(PATH_SHMMNI, "%ld", hugepages / 2);
hpage_size = SAFE_READ_MEMINFO("Hugepagesize:") * 1024;
shm_size = hpage_size;
/*
* 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_brk(TBROK, "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_brk(TBROK | TERRNO, "shmget #setup");
}
static void test_overcommit(void)
{
void *addr = NULL, *shmaddr = NULL;
if (opt_shmid) {
shmid = SAFE_SHMGET(key, (length / 2 * hugepagesize),
SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W);
} else {
fd = SAFE_OPEN(TEST_FILE, O_CREAT | O_RDWR, 0755);
addr = SAFE_MMAP(ADDR, (length / 2 * hugepagesize),
PROTECTION, FLAGS, fd, 0);
}
if (opt_sysfs) {
tst_res(TINFO, "check sysfs before allocation.");
if (checksys(path_sys_sz_huge, "HugePages_Total", length / 2))
return;
if (checksys(path_sys_sz_free, "HugePages_Free", length / 2))
return;
if (checksys(path_sys_sz_surp, "HugePages_Surp",
length / 2 - size))
return;
if (checksys(path_sys_sz_resv, "HugePages_Rsvd", length / 2))
return;
} else {
tst_res(TINFO, "check /proc/meminfo before allocation.");
if (checkproc(SAFE_READ_MEMINFO("HugePages_Total:"),
"HugePages_Total", length / 2))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Free:"),
"HugePages_Free", length / 2))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Surp:"),
"HugePages_Surp", length / 2 - size))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Rsvd:"),
"HugePages_Rsvd", length / 2))
return;
}
if (opt_shmid) {
tst_res(TINFO, "shmid: 0x%x", shmid);
shmaddr = SAFE_SHMAT(shmid, ADDR, SHMAT_FLAGS);
check_wr_bytes(shmaddr);
} else {
check_wr_bytes(addr);
}
if (opt_sysfs) {
tst_res(TINFO, "check sysfs.");
if (checksys(path_sys_sz_huge, "HugePages_Total", length / 2))
return;
if (checksys(path_sys_sz_free, "HugePages_Free", 0))
return;
if (checksys(path_sys_sz_surp, "HugePages_Surp",
length / 2 - size))
return;
if (checksys(path_sys_sz_resv, "HugePages_Rsvd", 0))
return;
} else {
tst_res(TINFO, "check /proc/meminfo.");
if (checkproc(SAFE_READ_MEMINFO("HugePages_Total:"),
"HugePages_Total", length / 2))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Free:"),
"HugePages_Free", 0))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Surp:"),
"HugePages_Surp", length / 2 - size))
return;
if (checkproc(SAFE_READ_MEMINFO("HugePages_Rsvd:"),
"HugePages_Rsvd", 0))
return;
}
if (opt_shmid) {
SAFE_SHMDT(shmaddr);
SAFE_SHMCTL(shmid, IPC_RMID, NULL);
} else {
SAFE_MUNMAP(addr, (length / 2 * hugepagesize));
SAFE_CLOSE(fd);
SAFE_UNLINK(TEST_FILE);
}
tst_res(TPASS, "hugepages overcommit test pass");
}
