Loading...
1// SPDX-License-Identifier: GPL-2.0
2
3#include <test_progs.h>
4
5#include "atomics.lskel.h"
6
7static void test_add(struct atomics_lskel *skel)
8{
9 int err, prog_fd;
10 LIBBPF_OPTS(bpf_test_run_opts, topts);
11
12 /* No need to attach it, just run it directly */
13 prog_fd = skel->progs.add.prog_fd;
14 err = bpf_prog_test_run_opts(prog_fd, &topts);
15 if (!ASSERT_OK(err, "test_run_opts err"))
16 return;
17 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
18 return;
19
20 ASSERT_EQ(skel->data->add64_value, 3, "add64_value");
21 ASSERT_EQ(skel->bss->add64_result, 1, "add64_result");
22
23 ASSERT_EQ(skel->data->add32_value, 3, "add32_value");
24 ASSERT_EQ(skel->bss->add32_result, 1, "add32_result");
25
26 ASSERT_EQ(skel->bss->add_stack_value_copy, 3, "add_stack_value");
27 ASSERT_EQ(skel->bss->add_stack_result, 1, "add_stack_result");
28
29 ASSERT_EQ(skel->data->add_noreturn_value, 3, "add_noreturn_value");
30}
31
32static void test_sub(struct atomics_lskel *skel)
33{
34 int err, prog_fd;
35 LIBBPF_OPTS(bpf_test_run_opts, topts);
36
37 /* No need to attach it, just run it directly */
38 prog_fd = skel->progs.sub.prog_fd;
39 err = bpf_prog_test_run_opts(prog_fd, &topts);
40 if (!ASSERT_OK(err, "test_run_opts err"))
41 return;
42 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
43 return;
44
45 ASSERT_EQ(skel->data->sub64_value, -1, "sub64_value");
46 ASSERT_EQ(skel->bss->sub64_result, 1, "sub64_result");
47
48 ASSERT_EQ(skel->data->sub32_value, -1, "sub32_value");
49 ASSERT_EQ(skel->bss->sub32_result, 1, "sub32_result");
50
51 ASSERT_EQ(skel->bss->sub_stack_value_copy, -1, "sub_stack_value");
52 ASSERT_EQ(skel->bss->sub_stack_result, 1, "sub_stack_result");
53
54 ASSERT_EQ(skel->data->sub_noreturn_value, -1, "sub_noreturn_value");
55}
56
57static void test_and(struct atomics_lskel *skel)
58{
59 int err, prog_fd;
60 LIBBPF_OPTS(bpf_test_run_opts, topts);
61
62 /* No need to attach it, just run it directly */
63 prog_fd = skel->progs.and.prog_fd;
64 err = bpf_prog_test_run_opts(prog_fd, &topts);
65 if (!ASSERT_OK(err, "test_run_opts err"))
66 return;
67 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
68 return;
69
70 ASSERT_EQ(skel->data->and64_value, 0x010ull << 32, "and64_value");
71 ASSERT_EQ(skel->bss->and64_result, 0x110ull << 32, "and64_result");
72
73 ASSERT_EQ(skel->data->and32_value, 0x010, "and32_value");
74 ASSERT_EQ(skel->bss->and32_result, 0x110, "and32_result");
75
76 ASSERT_EQ(skel->data->and_noreturn_value, 0x010ull << 32, "and_noreturn_value");
77}
78
79static void test_or(struct atomics_lskel *skel)
80{
81 int err, prog_fd;
82 LIBBPF_OPTS(bpf_test_run_opts, topts);
83
84 /* No need to attach it, just run it directly */
85 prog_fd = skel->progs.or.prog_fd;
86 err = bpf_prog_test_run_opts(prog_fd, &topts);
87 if (!ASSERT_OK(err, "test_run_opts err"))
88 return;
89 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
90 return;
91
92 ASSERT_EQ(skel->data->or64_value, 0x111ull << 32, "or64_value");
93 ASSERT_EQ(skel->bss->or64_result, 0x110ull << 32, "or64_result");
94
95 ASSERT_EQ(skel->data->or32_value, 0x111, "or32_value");
96 ASSERT_EQ(skel->bss->or32_result, 0x110, "or32_result");
97
98 ASSERT_EQ(skel->data->or_noreturn_value, 0x111ull << 32, "or_noreturn_value");
99}
100
101static void test_xor(struct atomics_lskel *skel)
102{
103 int err, prog_fd;
104 LIBBPF_OPTS(bpf_test_run_opts, topts);
105
106 /* No need to attach it, just run it directly */
107 prog_fd = skel->progs.xor.prog_fd;
108 err = bpf_prog_test_run_opts(prog_fd, &topts);
109 if (!ASSERT_OK(err, "test_run_opts err"))
110 return;
111 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
112 return;
113
114 ASSERT_EQ(skel->data->xor64_value, 0x101ull << 32, "xor64_value");
115 ASSERT_EQ(skel->bss->xor64_result, 0x110ull << 32, "xor64_result");
116
117 ASSERT_EQ(skel->data->xor32_value, 0x101, "xor32_value");
118 ASSERT_EQ(skel->bss->xor32_result, 0x110, "xor32_result");
119
120 ASSERT_EQ(skel->data->xor_noreturn_value, 0x101ull << 32, "xor_nxoreturn_value");
121}
122
123static void test_cmpxchg(struct atomics_lskel *skel)
124{
125 int err, prog_fd;
126 LIBBPF_OPTS(bpf_test_run_opts, topts);
127
128 /* No need to attach it, just run it directly */
129 prog_fd = skel->progs.cmpxchg.prog_fd;
130 err = bpf_prog_test_run_opts(prog_fd, &topts);
131 if (!ASSERT_OK(err, "test_run_opts err"))
132 return;
133 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
134 return;
135
136 ASSERT_EQ(skel->data->cmpxchg64_value, 2, "cmpxchg64_value");
137 ASSERT_EQ(skel->bss->cmpxchg64_result_fail, 1, "cmpxchg_result_fail");
138 ASSERT_EQ(skel->bss->cmpxchg64_result_succeed, 1, "cmpxchg_result_succeed");
139
140 ASSERT_EQ(skel->data->cmpxchg32_value, 2, "lcmpxchg32_value");
141 ASSERT_EQ(skel->bss->cmpxchg32_result_fail, 1, "cmpxchg_result_fail");
142 ASSERT_EQ(skel->bss->cmpxchg32_result_succeed, 1, "cmpxchg_result_succeed");
143}
144
145static void test_xchg(struct atomics_lskel *skel)
146{
147 int err, prog_fd;
148 LIBBPF_OPTS(bpf_test_run_opts, topts);
149
150 /* No need to attach it, just run it directly */
151 prog_fd = skel->progs.xchg.prog_fd;
152 err = bpf_prog_test_run_opts(prog_fd, &topts);
153 if (!ASSERT_OK(err, "test_run_opts err"))
154 return;
155 if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
156 return;
157
158 ASSERT_EQ(skel->data->xchg64_value, 2, "xchg64_value");
159 ASSERT_EQ(skel->bss->xchg64_result, 1, "xchg64_result");
160
161 ASSERT_EQ(skel->data->xchg32_value, 2, "xchg32_value");
162 ASSERT_EQ(skel->bss->xchg32_result, 1, "xchg32_result");
163}
164
165void test_atomics(void)
166{
167 struct atomics_lskel *skel;
168
169 skel = atomics_lskel__open_and_load();
170 if (!ASSERT_OK_PTR(skel, "atomics skeleton load"))
171 return;
172
173 if (skel->data->skip_tests) {
174 printf("%s:SKIP:no ENABLE_ATOMICS_TESTS (missing Clang BPF atomics support)",
175 __func__);
176 test__skip();
177 goto cleanup;
178 }
179 skel->bss->pid = getpid();
180
181 if (test__start_subtest("add"))
182 test_add(skel);
183 if (test__start_subtest("sub"))
184 test_sub(skel);
185 if (test__start_subtest("and"))
186 test_and(skel);
187 if (test__start_subtest("or"))
188 test_or(skel);
189 if (test__start_subtest("xor"))
190 test_xor(skel);
191 if (test__start_subtest("cmpxchg"))
192 test_cmpxchg(skel);
193 if (test__start_subtest("xchg"))
194 test_xchg(skel);
195
196cleanup:
197 atomics_lskel__destroy(skel);
198}
1// SPDX-License-Identifier: GPL-2.0
2
3#include <test_progs.h>
4
5#include "atomics.lskel.h"
6
7static void test_add(struct atomics *skel)
8{
9 int err, prog_fd;
10 __u32 duration = 0, retval;
11 int link_fd;
12
13 link_fd = atomics__add__attach(skel);
14 if (!ASSERT_GT(link_fd, 0, "attach(add)"))
15 return;
16
17 prog_fd = skel->progs.add.prog_fd;
18 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
19 NULL, NULL, &retval, &duration);
20 if (CHECK(err || retval, "test_run add",
21 "err %d errno %d retval %d duration %d\n", err, errno, retval, duration))
22 goto cleanup;
23
24 ASSERT_EQ(skel->data->add64_value, 3, "add64_value");
25 ASSERT_EQ(skel->bss->add64_result, 1, "add64_result");
26
27 ASSERT_EQ(skel->data->add32_value, 3, "add32_value");
28 ASSERT_EQ(skel->bss->add32_result, 1, "add32_result");
29
30 ASSERT_EQ(skel->bss->add_stack_value_copy, 3, "add_stack_value");
31 ASSERT_EQ(skel->bss->add_stack_result, 1, "add_stack_result");
32
33 ASSERT_EQ(skel->data->add_noreturn_value, 3, "add_noreturn_value");
34
35cleanup:
36 close(link_fd);
37}
38
39static void test_sub(struct atomics *skel)
40{
41 int err, prog_fd;
42 __u32 duration = 0, retval;
43 int link_fd;
44
45 link_fd = atomics__sub__attach(skel);
46 if (!ASSERT_GT(link_fd, 0, "attach(sub)"))
47 return;
48
49 prog_fd = skel->progs.sub.prog_fd;
50 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
51 NULL, NULL, &retval, &duration);
52 if (CHECK(err || retval, "test_run sub",
53 "err %d errno %d retval %d duration %d\n",
54 err, errno, retval, duration))
55 goto cleanup;
56
57 ASSERT_EQ(skel->data->sub64_value, -1, "sub64_value");
58 ASSERT_EQ(skel->bss->sub64_result, 1, "sub64_result");
59
60 ASSERT_EQ(skel->data->sub32_value, -1, "sub32_value");
61 ASSERT_EQ(skel->bss->sub32_result, 1, "sub32_result");
62
63 ASSERT_EQ(skel->bss->sub_stack_value_copy, -1, "sub_stack_value");
64 ASSERT_EQ(skel->bss->sub_stack_result, 1, "sub_stack_result");
65
66 ASSERT_EQ(skel->data->sub_noreturn_value, -1, "sub_noreturn_value");
67
68cleanup:
69 close(link_fd);
70}
71
72static void test_and(struct atomics *skel)
73{
74 int err, prog_fd;
75 __u32 duration = 0, retval;
76 int link_fd;
77
78 link_fd = atomics__and__attach(skel);
79 if (!ASSERT_GT(link_fd, 0, "attach(and)"))
80 return;
81
82 prog_fd = skel->progs.and.prog_fd;
83 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
84 NULL, NULL, &retval, &duration);
85 if (CHECK(err || retval, "test_run and",
86 "err %d errno %d retval %d duration %d\n", err, errno, retval, duration))
87 goto cleanup;
88
89 ASSERT_EQ(skel->data->and64_value, 0x010ull << 32, "and64_value");
90 ASSERT_EQ(skel->bss->and64_result, 0x110ull << 32, "and64_result");
91
92 ASSERT_EQ(skel->data->and32_value, 0x010, "and32_value");
93 ASSERT_EQ(skel->bss->and32_result, 0x110, "and32_result");
94
95 ASSERT_EQ(skel->data->and_noreturn_value, 0x010ull << 32, "and_noreturn_value");
96cleanup:
97 close(link_fd);
98}
99
100static void test_or(struct atomics *skel)
101{
102 int err, prog_fd;
103 __u32 duration = 0, retval;
104 int link_fd;
105
106 link_fd = atomics__or__attach(skel);
107 if (!ASSERT_GT(link_fd, 0, "attach(or)"))
108 return;
109
110 prog_fd = skel->progs.or.prog_fd;
111 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
112 NULL, NULL, &retval, &duration);
113 if (CHECK(err || retval, "test_run or",
114 "err %d errno %d retval %d duration %d\n",
115 err, errno, retval, duration))
116 goto cleanup;
117
118 ASSERT_EQ(skel->data->or64_value, 0x111ull << 32, "or64_value");
119 ASSERT_EQ(skel->bss->or64_result, 0x110ull << 32, "or64_result");
120
121 ASSERT_EQ(skel->data->or32_value, 0x111, "or32_value");
122 ASSERT_EQ(skel->bss->or32_result, 0x110, "or32_result");
123
124 ASSERT_EQ(skel->data->or_noreturn_value, 0x111ull << 32, "or_noreturn_value");
125cleanup:
126 close(link_fd);
127}
128
129static void test_xor(struct atomics *skel)
130{
131 int err, prog_fd;
132 __u32 duration = 0, retval;
133 int link_fd;
134
135 link_fd = atomics__xor__attach(skel);
136 if (!ASSERT_GT(link_fd, 0, "attach(xor)"))
137 return;
138
139 prog_fd = skel->progs.xor.prog_fd;
140 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
141 NULL, NULL, &retval, &duration);
142 if (CHECK(err || retval, "test_run xor",
143 "err %d errno %d retval %d duration %d\n", err, errno, retval, duration))
144 goto cleanup;
145
146 ASSERT_EQ(skel->data->xor64_value, 0x101ull << 32, "xor64_value");
147 ASSERT_EQ(skel->bss->xor64_result, 0x110ull << 32, "xor64_result");
148
149 ASSERT_EQ(skel->data->xor32_value, 0x101, "xor32_value");
150 ASSERT_EQ(skel->bss->xor32_result, 0x110, "xor32_result");
151
152 ASSERT_EQ(skel->data->xor_noreturn_value, 0x101ull << 32, "xor_nxoreturn_value");
153cleanup:
154 close(link_fd);
155}
156
157static void test_cmpxchg(struct atomics *skel)
158{
159 int err, prog_fd;
160 __u32 duration = 0, retval;
161 int link_fd;
162
163 link_fd = atomics__cmpxchg__attach(skel);
164 if (!ASSERT_GT(link_fd, 0, "attach(cmpxchg)"))
165 return;
166
167 prog_fd = skel->progs.cmpxchg.prog_fd;
168 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
169 NULL, NULL, &retval, &duration);
170 if (CHECK(err || retval, "test_run add",
171 "err %d errno %d retval %d duration %d\n", err, errno, retval, duration))
172 goto cleanup;
173
174 ASSERT_EQ(skel->data->cmpxchg64_value, 2, "cmpxchg64_value");
175 ASSERT_EQ(skel->bss->cmpxchg64_result_fail, 1, "cmpxchg_result_fail");
176 ASSERT_EQ(skel->bss->cmpxchg64_result_succeed, 1, "cmpxchg_result_succeed");
177
178 ASSERT_EQ(skel->data->cmpxchg32_value, 2, "lcmpxchg32_value");
179 ASSERT_EQ(skel->bss->cmpxchg32_result_fail, 1, "cmpxchg_result_fail");
180 ASSERT_EQ(skel->bss->cmpxchg32_result_succeed, 1, "cmpxchg_result_succeed");
181
182cleanup:
183 close(link_fd);
184}
185
186static void test_xchg(struct atomics *skel)
187{
188 int err, prog_fd;
189 __u32 duration = 0, retval;
190 int link_fd;
191
192 link_fd = atomics__xchg__attach(skel);
193 if (!ASSERT_GT(link_fd, 0, "attach(xchg)"))
194 return;
195
196 prog_fd = skel->progs.xchg.prog_fd;
197 err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
198 NULL, NULL, &retval, &duration);
199 if (CHECK(err || retval, "test_run add",
200 "err %d errno %d retval %d duration %d\n", err, errno, retval, duration))
201 goto cleanup;
202
203 ASSERT_EQ(skel->data->xchg64_value, 2, "xchg64_value");
204 ASSERT_EQ(skel->bss->xchg64_result, 1, "xchg64_result");
205
206 ASSERT_EQ(skel->data->xchg32_value, 2, "xchg32_value");
207 ASSERT_EQ(skel->bss->xchg32_result, 1, "xchg32_result");
208
209cleanup:
210 close(link_fd);
211}
212
213void test_atomics(void)
214{
215 struct atomics *skel;
216 __u32 duration = 0;
217
218 skel = atomics__open_and_load();
219 if (CHECK(!skel, "skel_load", "atomics skeleton failed\n"))
220 return;
221
222 if (skel->data->skip_tests) {
223 printf("%s:SKIP:no ENABLE_ATOMICS_TESTS (missing Clang BPF atomics support)",
224 __func__);
225 test__skip();
226 goto cleanup;
227 }
228
229 if (test__start_subtest("add"))
230 test_add(skel);
231 if (test__start_subtest("sub"))
232 test_sub(skel);
233 if (test__start_subtest("and"))
234 test_and(skel);
235 if (test__start_subtest("or"))
236 test_or(skel);
237 if (test__start_subtest("xor"))
238 test_xor(skel);
239 if (test__start_subtest("cmpxchg"))
240 test_cmpxchg(skel);
241 if (test__start_subtest("xchg"))
242 test_xchg(skel);
243
244cleanup:
245 atomics__destroy(skel);
246}