1 /* SPDX-License-Identifier: GPL-2.0 */
2 #define _GNU_SOURCE
3 #include <linux/membarrier.h>
4 #include <syscall.h>
5 #include <stdio.h>
6 #include <errno.h>
7 #include <string.h>
8 #include <pthread.h>
9
10 #include "../kselftest.h"
11
12 static int registrations;
13
14 static int sys_membarrier(int cmd, int flags)
15 {
16 return syscall(__NR_membarrier, cmd, flags);
17 }
18
19 static int test_membarrier_get_registrations(int cmd)
20 {
21 int ret, flags = 0;
22 const char *test_name =
23 "sys membarrier MEMBARRIER_CMD_GET_REGISTRATIONS";
24
25 registrations |= cmd;
26
27 ret = sys_membarrier(MEMBARRIER_CMD_GET_REGISTRATIONS, 0);
28 if (ret < 0) {
29 ksft_exit_fail_msg(
30 "%s test: flags = %d, errno = %d\n",
31 test_name, flags, errno);
32 } else if (ret != registrations) {
33 ksft_exit_fail_msg(
34 "%s test: flags = %d, ret = %d, registrations = %d\n",
35 test_name, flags, ret, registrations);
36 }
37 ksft_test_result_pass(
38 "%s test: flags = %d, ret = %d, registrations = %d\n",
39 test_name, flags, ret, registrations);
40
41 return 0;
42 }
43
44 static int test_membarrier_cmd_fail(void)
45 {
46 int cmd = -1, flags = 0;
47 const char *test_name = "sys membarrier invalid command";
48
49 if (sys_membarrier(cmd, flags) != -1) {
50 ksft_exit_fail_msg(
51 "%s test: command = %d, flags = %d. Should fail, but passed\n",
52 test_name, cmd, flags);
53 }
54 if (errno != EINVAL) {
55 ksft_exit_fail_msg(
56 "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
57 test_name, flags, EINVAL, strerror(EINVAL),
58 errno, strerror(errno));
59 }
60
61 ksft_test_result_pass(
62 "%s test: command = %d, flags = %d, errno = %d. Failed as expected\n",
63 test_name, cmd, flags, errno);
64 return 0;
65 }
66
67 static int test_membarrier_flags_fail(void)
68 {
69 int cmd = MEMBARRIER_CMD_QUERY, flags = 1;
70 const char *test_name = "sys membarrier MEMBARRIER_CMD_QUERY invalid flags";
71
72 if (sys_membarrier(cmd, flags) != -1) {
73 ksft_exit_fail_msg(
74 "%s test: flags = %d. Should fail, but passed\n",
75 test_name, flags);
76 }
77 if (errno != EINVAL) {
78 ksft_exit_fail_msg(
79 "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
80 test_name, flags, EINVAL, strerror(EINVAL),
81 errno, strerror(errno));
82 }
83
84 ksft_test_result_pass(
85 "%s test: flags = %d, errno = %d. Failed as expected\n",
86 test_name, flags, errno);
87 return 0;
88 }
89
90 static int test_membarrier_global_success(void)
91 {
92 int cmd = MEMBARRIER_CMD_GLOBAL, flags = 0;
93 const char *test_name = "sys membarrier MEMBARRIER_CMD_GLOBAL";
94
95 if (sys_membarrier(cmd, flags) != 0) {
96 ksft_exit_fail_msg(
97 "%s test: flags = %d, errno = %d\n",
98 test_name, flags, errno);
99 }
100
101 ksft_test_result_pass(
102 "%s test: flags = %d\n", test_name, flags);
103 return 0;
104 }
105
106 static int test_membarrier_private_expedited_fail(void)
107 {
108 int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
109 const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED not registered failure";
110
111 if (sys_membarrier(cmd, flags) != -1) {
112 ksft_exit_fail_msg(
113 "%s test: flags = %d. Should fail, but passed\n",
114 test_name, flags);
115 }
116 if (errno != EPERM) {
117 ksft_exit_fail_msg(
118 "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
119 test_name, flags, EPERM, strerror(EPERM),
120 errno, strerror(errno));
121 }
122
123 ksft_test_result_pass(
124 "%s test: flags = %d, errno = %d\n",
125 test_name, flags, errno);
126 return 0;
127 }
128
129 static int test_membarrier_register_private_expedited_success(void)
130 {
131 int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED, flags = 0;
132 const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED";
133
134 if (sys_membarrier(cmd, flags) != 0) {
135 ksft_exit_fail_msg(
136 "%s test: flags = %d, errno = %d\n",
137 test_name, flags, errno);
138 }
139
140 ksft_test_result_pass(
141 "%s test: flags = %d\n",
142 test_name, flags);
143
144 test_membarrier_get_registrations(cmd);
145 return 0;
146 }
147
148 static int test_membarrier_private_expedited_success(void)
149 {
150 int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
151 const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED";
152
153 if (sys_membarrier(cmd, flags) != 0) {
154 ksft_exit_fail_msg(
155 "%s test: flags = %d, errno = %d\n",
156 test_name, flags, errno);
157 }
158
159 ksft_test_result_pass(
160 "%s test: flags = %d\n",
161 test_name, flags);
162 return 0;
163 }
164
165 static int test_membarrier_private_expedited_sync_core_fail(void)
166 {
167 int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0;
168 const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE not registered failure";
169
170 if (sys_membarrier(cmd, flags) != -1) {
171 ksft_exit_fail_msg(
172 "%s test: flags = %d. Should fail, but passed\n",
173 test_name, flags);
174 }
175 if (errno != EPERM) {
176 ksft_exit_fail_msg(
177 "%s test: flags = %d. Should return (%d: \"%s\"), but returned (%d: \"%s\").\n",
178 test_name, flags, EPERM, strerror(EPERM),
179 errno, strerror(errno));
180 }
181
182 ksft_test_result_pass(
183 "%s test: flags = %d, errno = %d\n",
184 test_name, flags, errno);
185 return 0;
186 }
187
188 static int test_membarrier_register_private_expedited_sync_core_success(void)
189 {
190 int cmd = MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE, flags = 0;
191 const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED_SYNC_CORE";
192
193 if (sys_membarrier(cmd, flags) != 0) {
194 ksft_exit_fail_msg(
195 "%s test: flags = %d, errno = %d\n",
196 test_name, flags, errno);
197 }
198
199 ksft_test_result_pass(
200 "%s test: flags = %d\n",
201 test_name, flags);
202
203 test_membarrier_get_registrations(cmd);
204 return 0;
205 }
206
207 static int test_membarrier_private_expedited_sync_core_success(void)
208 {
209 int cmd = MEMBARRIER_CMD_PRIVATE_EXPEDITED, flags = 0;
210 const char *test_name = "sys membarrier MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE";
211
212 if (sys_membarrier(cmd, flags) != 0) {
213 ksft_exit_fail_msg(
214 "%s test: flags = %d, errno = %d\n",
215 test_name, flags, errno);
216 }
217
218 ksft_test_result_pass(
219 "%s test: flags = %d\n",
220 test_name, flags);
221 return 0;
222 }
223
224 static int test_membarrier_register_global_expedited_success(void)
225 {
226 int cmd = MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED, flags = 0;
227 const char *test_name = "sys membarrier MEMBARRIER_CMD_REGISTER_GLOBAL_EXPEDITED";
228
229 if (sys_membarrier(cmd, flags) != 0) {
230 ksft_exit_fail_msg(
231 "%s test: flags = %d, errno = %d\n",
232 test_name, flags, errno);
233 }
234
235 ksft_test_result_pass(
236 "%s test: flags = %d\n",
237 test_name, flags);
238
239 test_membarrier_get_registrations(cmd);
240 return 0;
241 }
242
243 static int test_membarrier_global_expedited_success(void)
244 {
245 int cmd = MEMBARRIER_CMD_GLOBAL_EXPEDITED, flags = 0;
246 const char *test_name = "sys membarrier MEMBARRIER_CMD_GLOBAL_EXPEDITED";
247
248 if (sys_membarrier(cmd, flags) != 0) {
249 ksft_exit_fail_msg(
250 "%s test: flags = %d, errno = %d\n",
251 test_name, flags, errno);
252 }
253
254 ksft_test_result_pass(
255 "%s test: flags = %d\n",
256 test_name, flags);
257 return 0;
258 }
259
260 static int test_membarrier_fail(void)
261 {
262 int status;
263
264 status = test_membarrier_cmd_fail();
265 if (status)
266 return status;
267 status = test_membarrier_flags_fail();
268 if (status)
269 return status;
270 status = test_membarrier_private_expedited_fail();
271 if (status)
272 return status;
273 status = sys_membarrier(MEMBARRIER_CMD_QUERY, 0);
274 if (status < 0) {
275 ksft_test_result_fail("sys_membarrier() failed\n");
276 return status;
277 }
278 if (status & MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE) {
279 status = test_membarrier_private_expedited_sync_core_fail();
280 if (status)
281 return status;
282 }
283 return 0;
284 }
285
286 static int test_membarrier_success(void)
287 {
288 int status;
289
290 status = test_membarrier_global_success();
291 if (status)
292 return status;
293 status = test_membarrier_register_private_expedited_success();
294 if (status)
295 return status;
296 status = test_membarrier_private_expedited_success();
297 if (status)
298 return status;
299 status = sys_membarrier(MEMBARRIER_CMD_QUERY, 0);
300 if (status < 0) {
301 ksft_test_result_fail("sys_membarrier() failed\n");
302 return status;
303 }
304 if (status & MEMBARRIER_CMD_PRIVATE_EXPEDITED_SYNC_CORE) {
305 status = test_membarrier_register_private_expedited_sync_core_success();
306 if (status)
307 return status;
308 status = test_membarrier_private_expedited_sync_core_success();
309 if (status)
310 return status;
311 }
312 /*
313 * It is valid to send a global membarrier from a non-registered
314 * process.
315 */
316 status = test_membarrier_global_expedited_success();
317 if (status)
318 return status;
319 status = test_membarrier_register_global_expedited_success();
320 if (status)
321 return status;
322 status = test_membarrier_global_expedited_success();
323 if (status)
324 return status;
325 return 0;
326 }
327
328 static int test_membarrier_query(void)
329 {
330 int flags = 0, ret;
331
332 ret = sys_membarrier(MEMBARRIER_CMD_QUERY, flags);
333 if (ret < 0) {
334 if (errno == ENOSYS) {
335 /*
336 * It is valid to build a kernel with
337 * CONFIG_MEMBARRIER=n. However, this skips the tests.
338 */
339 ksft_exit_skip(
340 "sys membarrier (CONFIG_MEMBARRIER) is disabled.\n");
341 }
342 ksft_exit_fail_msg("sys_membarrier() failed\n");
343 }
344 if (!(ret & MEMBARRIER_CMD_GLOBAL))
345 ksft_exit_skip(
346 "sys_membarrier unsupported: CMD_GLOBAL not found.\n");
347
348 ksft_test_result_pass("sys_membarrier available\n");
349 return 0;
350 }
351
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.