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