/* Warning: *DO NOT* use this function in child */
unsigned int get_a_numa_node(void (*cleanup_fn) (void))
{
unsigned int nd1, nd2;
int ret;
ret = get_allowed_nodes(0, 2, &nd1, &nd2);
switch (ret) {
case 0:
break;
case -3:
tst_brkm(TCONF, cleanup_fn, "requires a NUMA system.");
default:
tst_brkm(TBROK | TERRNO, cleanup_fn, "1st get_allowed_nodes");
}
ret = get_allowed_nodes(NH_MEMS | NH_CPUS, 1, &nd1);
switch (ret) {
case 0:
tst_resm(TINFO, "get node%lu.", nd1);
return nd1;
case -3:
tst_brkm(TCONF, cleanup_fn, "requires a NUMA system that has "
"at least one node with both memory and CPU "
"available.");
default:
break;
}
tst_brkm(TBROK | TERRNO, cleanup_fn, "2nd get_allowed_nodes");
}
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)
{
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);
}
int main(int argc, char **argv)
{
char *msg;
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc;
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 1, &from_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
/* reset tst_count in case we are looping */
tst_count = 0;
ret = alloc_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
to_node = numa_max_node() + 1;
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = to_node;
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE);
TEST_ERRNO = errno;
if (ret == -1 && errno == ENODEV)
tst_resm(TPASS, "move_pages failed with "
"ENODEV as expected");
else
tst_resm(TFAIL, "move pages did not fail "
"with ENODEV");
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
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);
}
static void setup(void)
{
int node, ret;
tst_require_root();
TEST(ltp_syscall(__NR_migrate_pages, 0, 0, NULL, NULL));
if (numa_available() == -1)
tst_brkm(TCONF, NULL, "NUMA not available");
ret = get_allowed_nodes(NH_MEMS, 1, &node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, NULL, "get_allowed_nodes_arr: %d",
ret);
sane_max_node = LTP_ALIGN(get_max_node(), sizeof(unsigned long)*8);
sane_nodemask_size = sane_max_node / 8;
sane_old_nodes = SAFE_MALLOC(NULL, sane_nodemask_size);
sane_new_nodes = SAFE_MALLOC(NULL, sane_nodemask_size);
memset(sane_old_nodes, 0, sane_nodemask_size);
memset(sane_new_nodes, 0, sane_nodemask_size);
set_bit(sane_old_nodes, node, 1);
set_bit(sane_new_nodes, node, 1);
TEST_PAUSE;
}
int main(int argc, char **argv)
{
tst_parse_opts(argc, argv, NULL, NULL);
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc;
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
/* reset tst_count in case we are looping */
tst_count = 0;
ret = alloc_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = to_node;
ret =
numa_move_pages(0, TEST_PAGES, pages, nodes, status,
MPOL_MF_MOVE);
if (ret != 0) {
tst_resm(TFAIL|TERRNO, "move_pages failed");
free_pages(pages, TEST_PAGES);
continue;
}
for (i = 0; i < TEST_PAGES; i++)
*((char *)pages[i]) = 0xAA;
verify_pages_on_node(pages, status, TEST_PAGES, to_node);
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
char *msg;
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL)
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc;
unsigned int from_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 1, &from_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
/* reset Tst_count in case we are looping */
Tst_count = 0;
ret = alloc_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = from_node;
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE);
TEST_ERRNO = errno;
/*
* commit e78bbfa8262424417a29349a8064a535053912b9
* Author: Brice Goglin <*****@*****.**>
* Date: Sat Oct 18 20:27:15 2008 -0700
* mm: stop returning -ENOENT from sys_move_pages() if nothing got migrated
*/
if ((tst_kvercmp(2, 6, 28)) >= 0) {
if (ret == 0)
tst_resm(TPASS, "move_pages succeeded");
else
tst_resm(TFAIL | TERRNO, "move_pages");
} else {
if (ret == -1 && errno == ENOENT)
tst_resm(TPASS, "move_pages failed with "
"ENOENT as expected");
else
tst_resm(TFAIL | TERRNO, "move_pages");
}
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
const char *msg;
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc;
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[N_TEST_PAGES] = { 0 };
int nodes[N_TEST_PAGES];
int status[N_TEST_PAGES];
pid_t cpid;
sem_t *sem;
/* reset tst_count in case we are looping */
tst_count = 0;
ret = alloc_shared_pages_on_node(pages + SHARED_PAGE,
N_SHARED_PAGES, from_node);
if (ret == -1)
continue;
ret = alloc_pages_on_node(pages + UNSHARED_PAGE,
N_UNSHARED_PAGES, from_node);
if (ret == -1)
goto err_free_shared;
for (i = 0; i < N_TEST_PAGES; i++) {
nodes[i] = to_node;
}
sem = alloc_sem(MAX_SEMS);
if (sem == NULL) {
goto err_free_unshared;
}
/*
* Fork a child process so that the shared pages are
* now really shared between two processes.
*/
cpid = fork();
if (cpid == -1) {
tst_resm(TBROK, "forking child failed");
goto err_free_sem;
} else if (cpid == 0) {
child(pages, sem);
}
/* Wait for child to setup and signal. */
if (sem_wait(&sem[SEM_CHILD_SETUP]) == -1)
tst_resm(TWARN | TERRNO, "error wait semaphore");
ret = numa_move_pages(0, N_TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE);
if (ret == -1) {
tst_resm(TFAIL | TERRNO,
"move_pages unexpectedly failed");
goto err_kill_child;
}
if (status[SHARED_PAGE] == -EACCES)
tst_resm(TPASS, "status[%d] set to expected -EACCES",
SHARED_PAGE);
else
tst_resm(TFAIL, "status[%d] is %d",
SHARED_PAGE, status[SHARED_PAGE]);
err_kill_child:
/* Test done. Ask child to terminate. */
if (sem_post(&sem[SEM_PARENT_TEST]) == -1)
tst_resm(TWARN | TERRNO, "error post semaphore");
/* Read the status, no zombies! */
wait(NULL);
err_free_sem:
free_sem(sem, MAX_SEMS);
err_free_unshared:
free_pages(pages + UNSHARED_PAGE, N_UNSHARED_PAGES);
err_free_shared:
free_shared_pages(pages + SHARED_PAGE, N_SHARED_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
char *msg; /* message returned from parse_opts */
/* parse standard options */
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
tst_exit();
}
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc; /* loop counter */
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK|TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
pid_t cpid;
sem_t *sem;
/* reset Tst_count in case we are looping */
Tst_count = 0;
ret = alloc_shared_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
for (i = 0; i < TEST_PAGES; i++) {
nodes[i] = to_node;
}
sem = alloc_sem(MAX_SEMS);
if (sem == NULL) {
goto err_free_pages;
}
/*
* Fork a child process so that the shared pages are
* now really shared between two processes.
*/
cpid = fork();
if (cpid == -1) {
tst_resm(TBROK, "forking child failed: %s",
strerror(errno));
goto err_free_sem;
} else if (cpid == 0) {
child(pages, sem);
}
/* Wait for child to setup and signal. */
if (sem_wait(&sem[SEM_CHILD_SETUP]) == -1)
tst_resm(TWARN, "error wait semaphore: %s",
strerror(errno));
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE_ALL);
TEST_ERRNO = errno;
if (ret == -1 && errno == EPERM)
tst_resm(TPASS, "move_pages failed with "
"EPERM as expected");
else
tst_resm(TFAIL, "move_pages did not fail "
"with EPERM");
/* Test done. Ask child to terminate. */
if (sem_post(&sem[SEM_PARENT_TEST]) == -1)
tst_resm(TWARN, "error post semaphore: %s",
strerror(errno));
/* Read the status, no zombies! */
wait(NULL);
err_free_sem:
free_sem(sem, MAX_SEMS);
err_free_pages:
free_shared_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
tst_parse_opts(argc, argv, NULL, NULL);
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc;
unsigned int from_node;
unsigned int to_node;
int ret, exp_status;
if ((tst_kvercmp(4, 3, 0)) >= 0)
exp_status = -EFAULT;
else
exp_status = -ENOENT;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
unsigned long onepage = get_page_size();
/* reset tst_count in case we are looping */
tst_count = 0;
ret = alloc_pages_on_node(pages, TOUCHED_PAGES, from_node);
if (ret == -1)
continue;
/* Allocate page and do not touch it. */
pages[UNTOUCHED_PAGE] = numa_alloc_onnode(onepage, from_node);
if (pages[UNTOUCHED_PAGE] == NULL) {
tst_resm(TBROK, "failed allocating page on node %d",
from_node);
goto err_free_pages;
}
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = to_node;
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE);
if (ret == -1) {
tst_resm(TFAIL | TERRNO,
"move_pages unexpectedly failed");
goto err_free_pages;
}
if (status[UNTOUCHED_PAGE] == exp_status) {
tst_resm(TPASS, "status[%d] has expected value",
UNTOUCHED_PAGE);
} else {
tst_resm(TFAIL, "status[%d] is %s, expected %s",
UNTOUCHED_PAGE,
tst_strerrno(-status[UNTOUCHED_PAGE]),
tst_strerrno(-exp_status));
}
err_free_pages:
/* This is capable of freeing both the touched and
* untouched pages.
*/
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
char *msg; /* message returned from parse_opts */
/* parse standard options */
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc; /* loop counter */
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK|TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
/* reset Tst_count in case we are looping */
Tst_count = 0;
ret = alloc_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = to_node;
ret =
numa_move_pages(0, TEST_PAGES, pages, nodes, status,
MPOL_MF_MOVE);
TEST_ERRNO = errno;
if (ret != 0) {
tst_resm(TFAIL, "retrieving NUMA nodes failed");
free_pages(pages, TEST_PAGES);
continue;
}
for (i = 0; i < TEST_PAGES; i++)
*((char *)pages[i]) = 0xAA;
verify_pages_on_node(pages, status, TEST_PAGES, to_node);
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
tst_parse_opts(argc, argv, NULL, NULL);
setup();
#ifdef HAVE_NUMA_V2
unsigned int i;
int lc;
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK | TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
pid_t cpid;
sem_t *sem;
/* reset tst_count in case we are looping */
tst_count = 0;
ret = alloc_shared_pages_on_node(pages, TEST_PAGES, from_node);
if (ret == -1)
continue;
for (i = 0; i < TEST_PAGES; i++) {
nodes[i] = to_node;
}
sem = alloc_sem(MAX_SEMS);
if (sem == NULL) {
goto err_free_pages;
}
/*
* Fork a child process so that the shared pages are
* now really shared between two processes.
*/
cpid = fork();
if (cpid == -1) {
tst_resm(TBROK | TERRNO, "forking child failed");
goto err_free_sem;
} else if (cpid == 0) {
child(pages, sem);
}
/* Wait for child to setup and signal. */
if (sem_wait(&sem[SEM_CHILD_SETUP]) == -1)
tst_resm(TWARN | TERRNO, "error wait semaphore");
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE_ALL);
if (ret < 0) {
tst_resm(TFAIL|TERRNO, "move_pages failed");
goto err_kill_child;
} else if (ret > 0) {
tst_resm(TINFO, "move_pages() returned %d\n", ret);
}
verify_pages_on_node(pages, status, TEST_PAGES, to_node);
err_kill_child:
/* Test done. Ask child to terminate. */
if (sem_post(&sem[SEM_PARENT_TEST]) == -1)
tst_resm(TWARN | TERRNO, "error post semaphore");
/* Read the status, no zombies! */
wait(NULL);
err_free_sem:
free_sem(sem, MAX_SEMS);
err_free_pages:
free_shared_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, NUMA_ERROR_MSG);
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
char *msg; /* message returned from parse_opts */
/* parse standard options */
msg = parse_opts(argc, argv, NULL, NULL);
if (msg != NULL) {
tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
}
setup();
#if HAVE_NUMA_MOVE_PAGES
unsigned int i;
int lc; /* loop counter */
unsigned int from_node;
unsigned int to_node;
int ret;
ret = get_allowed_nodes(NH_MEMS, 2, &from_node, &to_node);
if (ret < 0)
tst_brkm(TBROK|TERRNO, cleanup, "get_allowed_nodes: %d", ret);
/* check for looping state if -i option is given */
for (lc = 0; TEST_LOOPING(lc); lc++) {
void *pages[TEST_PAGES] = { 0 };
int nodes[TEST_PAGES];
int status[TEST_PAGES];
unsigned long onepage = get_page_size();
/* reset Tst_count in case we are looping */
Tst_count = 0;
ret = alloc_pages_on_node(pages, TOUCHED_PAGES, from_node);
if (ret == -1)
continue;
/* Allocate page and do not touch it. */
pages[UNTOUCHED_PAGE] = numa_alloc_onnode(onepage, from_node);
if (pages[UNTOUCHED_PAGE] == NULL) {
tst_resm(TBROK, "failed allocating page on node %d",
from_node);
goto err_free_pages;
}
for (i = 0; i < TEST_PAGES; i++)
nodes[i] = to_node;
ret = numa_move_pages(0, TEST_PAGES, pages, nodes,
status, MPOL_MF_MOVE);
TEST_ERRNO = errno;
if (ret == -1) {
tst_resm(TFAIL | TERRNO, "move_pages unexpectedly failed");
goto err_free_pages;
}
if (status[UNTOUCHED_PAGE] == -ENOENT)
tst_resm(TPASS, "status[%d] set to expected -ENOENT",
UNTOUCHED_PAGE);
else
tst_resm(TFAIL, "status[%d] is %d", UNTOUCHED_PAGE,
status[UNTOUCHED_PAGE]);
err_free_pages:
/* This is capable of freeing both the touched and
* untouched pages.
*/
free_pages(pages, TEST_PAGES);
}
#else
tst_resm(TCONF, "move_pages support not found.");
#endif
cleanup();
tst_exit();
}
int main(int argc, char **argv)
{
FILE *fp;
void *addr, *start, *end, *lastend;
int node, err, lc;
char buf[BUFSIZ];
struct bitmask *nmask = numa_allocate_nodemask();
pagesize = getpagesize();
tst_parse_opts(argc, argv, options, usage);
if (opt_node) {
node = SAFE_STRTOL(NULL, opt_nodestr, 1, LONG_MAX);
} else {
err = get_allowed_nodes(NH_MEMS | NH_MEMS, 1, &node);
if (err == -3)
tst_brkm(TCONF, NULL, "requires at least one node.");
else if (err < 0)
tst_brkm(TBROK | TERRNO, NULL, "get_allowed_nodes");
}
numa_bitmask_setbit(nmask, node);
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
addr = mmap(NULL, pagesize * 3, PROT_WRITE,
MAP_ANON | MAP_PRIVATE, 0, 0);
if (addr == MAP_FAILED)
tst_brkm(TBROK | TERRNO, NULL, "mmap");
tst_resm(TINFO, "pid = %d addr = %p", getpid(), addr);
/* make page populate */
memset(addr, 0, pagesize * 3);
/* first mbind */
err = mbind(addr + pagesize, pagesize, MPOL_BIND, nmask->maskp,
nmask->size, MPOL_MF_MOVE_ALL);
if (err != 0) {
if (errno != ENOSYS)
tst_brkm(TBROK | TERRNO, NULL, "mbind1");
else
tst_brkm(TCONF, NULL,
"mbind syscall not implemented on this system.");
}
/* second mbind */
err = mbind(addr, pagesize * 3, MPOL_DEFAULT, NULL, 0, 0);
if (err != 0)
tst_brkm(TBROK | TERRNO, NULL, "mbind2");
/* /proc/self/maps in the form of
"00400000-00406000 r-xp 00000000". */
fp = fopen("/proc/self/maps", "r");
if (fp == NULL)
tst_brkm(TBROK | TERRNO, NULL, "fopen");
while (fgets(buf, BUFSIZ, fp) != NULL) {
if (sscanf(buf, "%p-%p ", &start, &end) != 2)
continue;
if (start == addr) {
tst_resm(TINFO, "start = %p, end = %p",
start, end);
if (end == addr + pagesize * 3) {
tst_resm(TPASS, "only 1 VMA.");
break;
}
lastend = end;
while (fgets(buf, BUFSIZ, fp) != NULL) {
/* No more VMAs, break */
if (sscanf(buf, "%p-%p ", &start,
&end) != 2)
break;
tst_resm(TINFO, "start = %p, end = %p",
start, end);
/* more VMAs found */
if (start == lastend)
lastend = end;
if (end == addr + pagesize * 3) {
tst_resm(TFAIL,
">1 unmerged VMAs.");
break;
}
}
if (end != addr + pagesize * 3)
tst_resm(TFAIL, "no matched VMAs.");
break;
}
}
fclose(fp);
if (munmap(addr, pagesize * 3) == -1)
tst_brkm(TWARN | TERRNO, NULL, "munmap");
}
tst_exit();
}