1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2024 Meta Platforms, Inc. and affiliates. */
3 #include <test_progs.h>
4 #include "arena_atomics.skel.h"
5
test_add(struct arena_atomics * skel)6 static void test_add(struct arena_atomics *skel)
7 {
8 LIBBPF_OPTS(bpf_test_run_opts, topts);
9 int err, prog_fd;
10
11 /* No need to attach it, just run it directly */
12 prog_fd = bpf_program__fd(skel->progs.add);
13 err = bpf_prog_test_run_opts(prog_fd, &topts);
14 if (!ASSERT_OK(err, "test_run_opts err"))
15 return;
16 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
17 return;
18
19 ASSERT_EQ(skel->arena->add64_value, 3, "add64_value");
20 ASSERT_EQ(skel->arena->add64_result, 1, "add64_result");
21
22 ASSERT_EQ(skel->arena->add32_value, 3, "add32_value");
23 ASSERT_EQ(skel->arena->add32_result, 1, "add32_result");
24
25 ASSERT_EQ(skel->arena->add_stack_value_copy, 3, "add_stack_value");
26 ASSERT_EQ(skel->arena->add_stack_result, 1, "add_stack_result");
27
28 ASSERT_EQ(skel->arena->add_noreturn_value, 3, "add_noreturn_value");
29 }
30
test_sub(struct arena_atomics * skel)31 static void test_sub(struct arena_atomics *skel)
32 {
33 LIBBPF_OPTS(bpf_test_run_opts, topts);
34 int err, prog_fd;
35
36 /* No need to attach it, just run it directly */
37 prog_fd = bpf_program__fd(skel->progs.sub);
38 err = bpf_prog_test_run_opts(prog_fd, &topts);
39 if (!ASSERT_OK(err, "test_run_opts err"))
40 return;
41 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
42 return;
43
44 ASSERT_EQ(skel->arena->sub64_value, -1, "sub64_value");
45 ASSERT_EQ(skel->arena->sub64_result, 1, "sub64_result");
46
47 ASSERT_EQ(skel->arena->sub32_value, -1, "sub32_value");
48 ASSERT_EQ(skel->arena->sub32_result, 1, "sub32_result");
49
50 ASSERT_EQ(skel->arena->sub_stack_value_copy, -1, "sub_stack_value");
51 ASSERT_EQ(skel->arena->sub_stack_result, 1, "sub_stack_result");
52
53 ASSERT_EQ(skel->arena->sub_noreturn_value, -1, "sub_noreturn_value");
54 }
55
test_and(struct arena_atomics * skel)56 static void test_and(struct arena_atomics *skel)
57 {
58 LIBBPF_OPTS(bpf_test_run_opts, topts);
59 int err, prog_fd;
60
61 /* No need to attach it, just run it directly */
62 prog_fd = bpf_program__fd(skel->progs.and);
63 err = bpf_prog_test_run_opts(prog_fd, &topts);
64 if (!ASSERT_OK(err, "test_run_opts err"))
65 return;
66 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
67 return;
68
69 ASSERT_EQ(skel->arena->and64_value, 0x010ull << 32, "and64_value");
70 ASSERT_EQ(skel->arena->and32_value, 0x010, "and32_value");
71 }
72
test_or(struct arena_atomics * skel)73 static void test_or(struct arena_atomics *skel)
74 {
75 LIBBPF_OPTS(bpf_test_run_opts, topts);
76 int err, prog_fd;
77
78 /* No need to attach it, just run it directly */
79 prog_fd = bpf_program__fd(skel->progs.or);
80 err = bpf_prog_test_run_opts(prog_fd, &topts);
81 if (!ASSERT_OK(err, "test_run_opts err"))
82 return;
83 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
84 return;
85
86 ASSERT_EQ(skel->arena->or64_value, 0x111ull << 32, "or64_value");
87 ASSERT_EQ(skel->arena->or32_value, 0x111, "or32_value");
88 }
89
test_xor(struct arena_atomics * skel)90 static void test_xor(struct arena_atomics *skel)
91 {
92 LIBBPF_OPTS(bpf_test_run_opts, topts);
93 int err, prog_fd;
94
95 /* No need to attach it, just run it directly */
96 prog_fd = bpf_program__fd(skel->progs.xor);
97 err = bpf_prog_test_run_opts(prog_fd, &topts);
98 if (!ASSERT_OK(err, "test_run_opts err"))
99 return;
100 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
101 return;
102
103 ASSERT_EQ(skel->arena->xor64_value, 0x101ull << 32, "xor64_value");
104 ASSERT_EQ(skel->arena->xor32_value, 0x101, "xor32_value");
105 }
106
test_cmpxchg(struct arena_atomics * skel)107 static void test_cmpxchg(struct arena_atomics *skel)
108 {
109 LIBBPF_OPTS(bpf_test_run_opts, topts);
110 int err, prog_fd;
111
112 /* No need to attach it, just run it directly */
113 prog_fd = bpf_program__fd(skel->progs.cmpxchg);
114 err = bpf_prog_test_run_opts(prog_fd, &topts);
115 if (!ASSERT_OK(err, "test_run_opts err"))
116 return;
117 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
118 return;
119
120 ASSERT_EQ(skel->arena->cmpxchg64_value, 2, "cmpxchg64_value");
121 ASSERT_EQ(skel->arena->cmpxchg64_result_fail, 1, "cmpxchg_result_fail");
122 ASSERT_EQ(skel->arena->cmpxchg64_result_succeed, 1, "cmpxchg_result_succeed");
123
124 ASSERT_EQ(skel->arena->cmpxchg32_value, 2, "lcmpxchg32_value");
125 ASSERT_EQ(skel->arena->cmpxchg32_result_fail, 1, "cmpxchg_result_fail");
126 ASSERT_EQ(skel->arena->cmpxchg32_result_succeed, 1, "cmpxchg_result_succeed");
127 }
128
test_xchg(struct arena_atomics * skel)129 static void test_xchg(struct arena_atomics *skel)
130 {
131 LIBBPF_OPTS(bpf_test_run_opts, topts);
132 int err, prog_fd;
133
134 /* No need to attach it, just run it directly */
135 prog_fd = bpf_program__fd(skel->progs.xchg);
136 err = bpf_prog_test_run_opts(prog_fd, &topts);
137 if (!ASSERT_OK(err, "test_run_opts err"))
138 return;
139 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
140 return;
141
142 ASSERT_EQ(skel->arena->xchg64_value, 2, "xchg64_value");
143 ASSERT_EQ(skel->arena->xchg64_result, 1, "xchg64_result");
144
145 ASSERT_EQ(skel->arena->xchg32_value, 2, "xchg32_value");
146 ASSERT_EQ(skel->arena->xchg32_result, 1, "xchg32_result");
147 }
148
test_uaf(struct arena_atomics * skel)149 static void test_uaf(struct arena_atomics *skel)
150 {
151 LIBBPF_OPTS(bpf_test_run_opts, topts);
152 int err, prog_fd;
153
154 /* No need to attach it, just run it directly */
155 prog_fd = bpf_program__fd(skel->progs.uaf);
156 err = bpf_prog_test_run_opts(prog_fd, &topts);
157 if (!ASSERT_OK(err, "test_run_opts err"))
158 return;
159 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
160 return;
161
162 ASSERT_EQ(skel->arena->uaf_recovery_fails, 0, "uaf_recovery_fails");
163 }
164
test_load_acquire(struct arena_atomics * skel)165 static void test_load_acquire(struct arena_atomics *skel)
166 {
167 LIBBPF_OPTS(bpf_test_run_opts, topts);
168 int err, prog_fd;
169
170 if (skel->data->skip_lacq_srel_tests) {
171 printf("%s:SKIP: ENABLE_ATOMICS_TESTS not defined, Clang doesn't support addr_space_cast, and/or JIT doesn't support load-acquire\n",
172 __func__);
173 test__skip();
174 return;
175 }
176
177 /* No need to attach it, just run it directly */
178 prog_fd = bpf_program__fd(skel->progs.load_acquire);
179 err = bpf_prog_test_run_opts(prog_fd, &topts);
180 if (!ASSERT_OK(err, "test_run_opts err"))
181 return;
182 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
183 return;
184
185 ASSERT_EQ(skel->arena->load_acquire8_result, 0x12,
186 "load_acquire8_result");
187 ASSERT_EQ(skel->arena->load_acquire16_result, 0x1234,
188 "load_acquire16_result");
189 ASSERT_EQ(skel->arena->load_acquire32_result, 0x12345678,
190 "load_acquire32_result");
191 ASSERT_EQ(skel->arena->load_acquire64_result, 0x1234567890abcdef,
192 "load_acquire64_result");
193 }
194
test_store_release(struct arena_atomics * skel)195 static void test_store_release(struct arena_atomics *skel)
196 {
197 LIBBPF_OPTS(bpf_test_run_opts, topts);
198 int err, prog_fd;
199
200 if (skel->data->skip_lacq_srel_tests) {
201 printf("%s:SKIP: ENABLE_ATOMICS_TESTS not defined, Clang doesn't support addr_space_cast, and/or JIT doesn't support store-release\n",
202 __func__);
203 test__skip();
204 return;
205 }
206
207 /* No need to attach it, just run it directly */
208 prog_fd = bpf_program__fd(skel->progs.store_release);
209 err = bpf_prog_test_run_opts(prog_fd, &topts);
210 if (!ASSERT_OK(err, "test_run_opts err"))
211 return;
212 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
213 return;
214
215 ASSERT_EQ(skel->arena->store_release8_result, 0x12,
216 "store_release8_result");
217 ASSERT_EQ(skel->arena->store_release16_result, 0x1234,
218 "store_release16_result");
219 ASSERT_EQ(skel->arena->store_release32_result, 0x12345678,
220 "store_release32_result");
221 ASSERT_EQ(skel->arena->store_release64_result, 0x1234567890abcdef,
222 "store_release64_result");
223 }
224
test_arena_atomics(void)225 void test_arena_atomics(void)
226 {
227 struct arena_atomics *skel;
228 int err;
229
230 skel = arena_atomics__open();
231 if (!ASSERT_OK_PTR(skel, "arena atomics skeleton open"))
232 return;
233
234 if (skel->data->skip_all_tests) {
235 printf("%s:SKIP:no ENABLE_ATOMICS_TESTS or no addr_space_cast support in clang",
236 __func__);
237 test__skip();
238 goto cleanup;
239 }
240 err = arena_atomics__load(skel);
241 if (!ASSERT_OK(err, "arena atomics skeleton load"))
242 return;
243 skel->bss->pid = getpid();
244
245 if (test__start_subtest("add"))
246 test_add(skel);
247 if (test__start_subtest("sub"))
248 test_sub(skel);
249 if (test__start_subtest("and"))
250 test_and(skel);
251 if (test__start_subtest("or"))
252 test_or(skel);
253 if (test__start_subtest("xor"))
254 test_xor(skel);
255 if (test__start_subtest("cmpxchg"))
256 test_cmpxchg(skel);
257 if (test__start_subtest("xchg"))
258 test_xchg(skel);
259 if (test__start_subtest("uaf"))
260 test_uaf(skel);
261 if (test__start_subtest("load_acquire"))
262 test_load_acquire(skel);
263 if (test__start_subtest("store_release"))
264 test_store_release(skel);
265
266 cleanup:
267 arena_atomics__destroy(skel);
268 }
269