static int migrate_to_node(pid_t pid, int node) { unsigned long nodemask_size, max_node; unsigned long *old_nodes, *new_nodes; int i; tst_resm(TINFO, "pid(%d) migrate pid %d to node -> %d", getpid(), pid, node); max_node = LTP_ALIGN(get_max_node(), sizeof(unsigned long)*8); nodemask_size = max_node / 8; old_nodes = SAFE_MALLOC(NULL, nodemask_size); new_nodes = SAFE_MALLOC(NULL, nodemask_size); memset(old_nodes, 0, nodemask_size); memset(new_nodes, 0, nodemask_size); for (i = 0; i < num_nodes; i++) set_bit(old_nodes, nodes[i], 1); set_bit(new_nodes, node, 1); TEST(ltp_syscall(__NR_migrate_pages, pid, max_node, old_nodes, new_nodes)); if (TEST_RETURN != 0) { if (TEST_RETURN < 0) tst_resm(TFAIL | TERRNO, "migrate_pages failed " "ret: %ld, ", TEST_RETURN); else tst_resm(TWARN, "migrate_pages could not migrate all " "pages, not migrated: %ld", TEST_RETURN); print_mem_stats(pid, node); } free(old_nodes); free(new_nodes); return TEST_RETURN; }
static void setup(void) { int i, fd; fd = SAFE_OPEN(TEST_FILE, O_RDWR | O_CREAT, 0664); pagesize = getpagesize(); /* Writing 16 pages of random data into this file */ for (i = 0; i < (pagesize / 2); i++) SAFE_WRITE(1, fd, STR, sizeof(STR) - 1); SAFE_FSTAT(fd, &st); file1 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0); file2 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0); file3 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0); shared_anon = SAFE_MMAP(0, MAP_SIZE, PROT_READ, MAP_SHARED | MAP_ANONYMOUS, -1, 0); nonalign = file1 + 100; ptr_addr = SAFE_MALLOC(st.st_size); tmp_addr = (void*)LTP_ALIGN((long)ptr_addr, pagesize); /* unmap as last step to avoid subsequent mmap(s) pick same address */ SAFE_MUNMAP(file2 + st.st_size - pagesize, pagesize); SAFE_CLOSE(fd); tcases_filter(); }
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; }
static void setup(void) { int i, fd; fd = SAFE_OPEN(TEST_FILE, O_RDWR | O_CREAT, 0664); pagesize = getpagesize(); /* Writing 16 pages of random data into this file */ for (i = 0; i < (pagesize / 2); i++) SAFE_WRITE(1, fd, STR, sizeof(STR) - 1); SAFE_FSTAT(fd, &st); file1 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0); file2 = SAFE_MMAP(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0); SAFE_MUNMAP(file2 + st.st_size - pagesize, pagesize); nonalign = file1 + 100; ptr_addr = SAFE_MALLOC(st.st_size); tmp_addr = (void*)LTP_ALIGN((long)ptr_addr, pagesize); SAFE_CLOSE(fd); tcases_filter(); }
/* * get_allowed_nodes_arr - get number and array of available nodes * @num_nodes: pointer where number of available nodes will be stored * @nodes: array of available node ids, this is MPOL_F_MEMS_ALLOWED * node bitmask compacted (without holes), so that each field * contains node number. If NULL only num_nodes is * returned, otherwise it cotains new allocated array, * which caller is responsible to free. * RETURNS: * 0 on success * -1 on allocation failure * -2 on get_mempolicy failure */ int get_allowed_nodes_arr(int flag, int *num_nodes, int **nodes) { int ret = 0; #if HAVE_NUMA_H int i; nodemask_t *nodemask = NULL; #endif *num_nodes = 0; if (nodes) *nodes = NULL; #if HAVE_NUMA_H unsigned long max_node = LTP_ALIGN(get_max_node(), sizeof(unsigned long)*8); unsigned long nodemask_size = max_node / 8; nodemask = malloc(nodemask_size); if (nodes) *nodes = malloc(sizeof(int) * max_node); do { if (nodemask == NULL || (nodes && (*nodes == NULL))) { ret = -1; break; } /* allow all nodes at start, then filter based on flags */ get_nodemask_allnodes(nodemask, max_node); if ((flag & NH_MEMS) == NH_MEMS) { ret = filter_nodemask_mem(nodemask, max_node); if (ret < 0) break; } if ((flag & NH_CPUS) == NH_CPUS) filter_nodemask_cpu(nodemask, max_node); for (i = 0; i < max_node; i++) { if (nodemask_isset(nodemask, i)) { if (nodes) (*nodes)[*num_nodes] = i; (*num_nodes)++; } } } while (0); free(nodemask); #endif return ret; }