1// SPDX-License-Identifier: GPL-2.0
2/*
3 * The main purpose of the tests here is to exercise the migration entry code
4 * paths in the kernel.
5 */
6
7#include "../kselftest_harness.h"
8#include <strings.h>
9#include <pthread.h>
10#include <numa.h>
11#include <numaif.h>
12#include <sys/mman.h>
13#include <sys/prctl.h>
14#include <sys/types.h>
15#include <signal.h>
16#include <time.h>
17
18#define TWOMEG (2<<20)
19#define RUNTIME (20)
20
21#define ALIGN(x, a) (((x) + (a - 1)) & (~((a) - 1)))
22
23FIXTURE(migration)
24{
25	pthread_t *threads;
26	pid_t *pids;
27	int nthreads;
28	int n1;
29	int n2;
30};
31
32FIXTURE_SETUP(migration)
33{
34	int n;
35
36	ASSERT_EQ(numa_available(), 0);
37	self->nthreads = numa_num_task_cpus() - 1;
38	self->n1 = -1;
39	self->n2 = -1;
40
41	for (n = 0; n < numa_max_possible_node(); n++)
42		if (numa_bitmask_isbitset(numa_all_nodes_ptr, n)) {
43			if (self->n1 == -1) {
44				self->n1 = n;
45			} else {
46				self->n2 = n;
47				break;
48			}
49		}
50
51	self->threads = malloc(self->nthreads * sizeof(*self->threads));
52	ASSERT_NE(self->threads, NULL);
53	self->pids = malloc(self->nthreads * sizeof(*self->pids));
54	ASSERT_NE(self->pids, NULL);
55};
56
57FIXTURE_TEARDOWN(migration)
58{
59	free(self->threads);
60	free(self->pids);
61}
62
63int migrate(uint64_t *ptr, int n1, int n2)
64{
65	int ret, tmp;
66	int status = 0;
67	struct timespec ts1, ts2;
68
69	if (clock_gettime(CLOCK_MONOTONIC, &ts1))
70		return -1;
71
72	while (1) {
73		if (clock_gettime(CLOCK_MONOTONIC, &ts2))
74			return -1;
75
76		if (ts2.tv_sec - ts1.tv_sec >= RUNTIME)
77			return 0;
78
79		ret = move_pages(0, 1, (void **) &ptr, &n2, &status,
80				MPOL_MF_MOVE_ALL);
81		if (ret) {
82			if (ret > 0)
83				printf("Didn't migrate %d pages\n", ret);
84			else
85				perror("Couldn't migrate pages");
86			return -2;
87		}
88
89		tmp = n2;
90		n2 = n1;
91		n1 = tmp;
92	}
93
94	return 0;
95}
96
97void *access_mem(void *ptr)
98{
99	volatile uint64_t y = 0;
100	volatile uint64_t *x = ptr;
101
102	while (1) {
103		pthread_testcancel();
104		y += *x;
105
106		/* Prevent the compiler from optimizing out the writes to y: */
107		asm volatile("" : "+r" (y));
108	}
109
110	return NULL;
111}
112
113/*
114 * Basic migration entry testing. One thread will move pages back and forth
115 * between nodes whilst other threads try and access them triggering the
116 * migration entry wait paths in the kernel.
117 */
118TEST_F_TIMEOUT(migration, private_anon, 2*RUNTIME)
119{
120	uint64_t *ptr;
121	int i;
122
123	if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
124		SKIP(return, "Not enough threads or NUMA nodes available");
125
126	ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
127		MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
128	ASSERT_NE(ptr, MAP_FAILED);
129
130	memset(ptr, 0xde, TWOMEG);
131	for (i = 0; i < self->nthreads - 1; i++)
132		if (pthread_create(&self->threads[i], NULL, access_mem, ptr))
133			perror("Couldn't create thread");
134
135	ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
136	for (i = 0; i < self->nthreads - 1; i++)
137		ASSERT_EQ(pthread_cancel(self->threads[i]), 0);
138}
139
140/*
141 * Same as the previous test but with shared memory.
142 */
143TEST_F_TIMEOUT(migration, shared_anon, 2*RUNTIME)
144{
145	pid_t pid;
146	uint64_t *ptr;
147	int i;
148
149	if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
150		SKIP(return, "Not enough threads or NUMA nodes available");
151
152	ptr = mmap(NULL, TWOMEG, PROT_READ | PROT_WRITE,
153		MAP_SHARED | MAP_ANONYMOUS, -1, 0);
154	ASSERT_NE(ptr, MAP_FAILED);
155
156	memset(ptr, 0xde, TWOMEG);
157	for (i = 0; i < self->nthreads - 1; i++) {
158		pid = fork();
159		if (!pid) {
160			prctl(PR_SET_PDEATHSIG, SIGHUP);
161			/* Parent may have died before prctl so check now. */
162			if (getppid() == 1)
163				kill(getpid(), SIGHUP);
164			access_mem(ptr);
165		} else {
166			self->pids[i] = pid;
167		}
168	}
169
170	ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
171	for (i = 0; i < self->nthreads - 1; i++)
172		ASSERT_EQ(kill(self->pids[i], SIGTERM), 0);
173}
174
175/*
176 * Tests the pmd migration entry paths.
177 */
178TEST_F_TIMEOUT(migration, private_anon_thp, 2*RUNTIME)
179{
180	uint64_t *ptr;
181	int i;
182
183	if (self->nthreads < 2 || self->n1 < 0 || self->n2 < 0)
184		SKIP(return, "Not enough threads or NUMA nodes available");
185
186	ptr = mmap(NULL, 2*TWOMEG, PROT_READ | PROT_WRITE,
187		MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
188	ASSERT_NE(ptr, MAP_FAILED);
189
190	ptr = (uint64_t *) ALIGN((uintptr_t) ptr, TWOMEG);
191	ASSERT_EQ(madvise(ptr, TWOMEG, MADV_HUGEPAGE), 0);
192	memset(ptr, 0xde, TWOMEG);
193	for (i = 0; i < self->nthreads - 1; i++)
194		if (pthread_create(&self->threads[i], NULL, access_mem, ptr))
195			perror("Couldn't create thread");
196
197	ASSERT_EQ(migrate(ptr, self->n1, self->n2), 0);
198	for (i = 0; i < self->nthreads - 1; i++)
199		ASSERT_EQ(pthread_cancel(self->threads[i]), 0);
200}
201
202TEST_HARNESS_MAIN
203