bpf/prog_tests/atomics.c

0001 // SPDX-License-Identifier: GPL-2.0
0002
0003 #include <test_progs.h>
0004
0005 #include "atomics.lskel.h"
0006
0007 static void test_add(struct atomics_lskel *skel)
0008 {
0009     int err, prog_fd;
0010     LIBBPF_OPTS(bpf_test_run_opts, topts);
0011
0012     /* No need to attach it, just run it directly */
0013     prog_fd = skel->progs.add.prog_fd;
0014     err = bpf_prog_test_run_opts(prog_fd, &topts);
0015     if (!ASSERT_OK(err, "test_run_opts err"))
0016         return;
0017     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0018         return;
0019
0020     ASSERT_EQ(skel->data->add64_value, 3, "add64_value");
0021     ASSERT_EQ(skel->bss->add64_result, 1, "add64_result");
0022
0023     ASSERT_EQ(skel->data->add32_value, 3, "add32_value");
0024     ASSERT_EQ(skel->bss->add32_result, 1, "add32_result");
0025
0026     ASSERT_EQ(skel->bss->add_stack_value_copy, 3, "add_stack_value");
0027     ASSERT_EQ(skel->bss->add_stack_result, 1, "add_stack_result");
0028
0029     ASSERT_EQ(skel->data->add_noreturn_value, 3, "add_noreturn_value");
0030 }
0031
0032 static void test_sub(struct atomics_lskel *skel)
0033 {
0034     int err, prog_fd;
0035     LIBBPF_OPTS(bpf_test_run_opts, topts);
0036
0037     /* No need to attach it, just run it directly */
0038     prog_fd = skel->progs.sub.prog_fd;
0039     err = bpf_prog_test_run_opts(prog_fd, &topts);
0040     if (!ASSERT_OK(err, "test_run_opts err"))
0041         return;
0042     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0043         return;
0044
0045     ASSERT_EQ(skel->data->sub64_value, -1, "sub64_value");
0046     ASSERT_EQ(skel->bss->sub64_result, 1, "sub64_result");
0047
0048     ASSERT_EQ(skel->data->sub32_value, -1, "sub32_value");
0049     ASSERT_EQ(skel->bss->sub32_result, 1, "sub32_result");
0050
0051     ASSERT_EQ(skel->bss->sub_stack_value_copy, -1, "sub_stack_value");
0052     ASSERT_EQ(skel->bss->sub_stack_result, 1, "sub_stack_result");
0053
0054     ASSERT_EQ(skel->data->sub_noreturn_value, -1, "sub_noreturn_value");
0055 }
0056
0057 static void test_and(struct atomics_lskel *skel)
0058 {
0059     int err, prog_fd;
0060     LIBBPF_OPTS(bpf_test_run_opts, topts);
0061
0062     /* No need to attach it, just run it directly */
0063     prog_fd = skel->progs.and.prog_fd;
0064     err = bpf_prog_test_run_opts(prog_fd, &topts);
0065     if (!ASSERT_OK(err, "test_run_opts err"))
0066         return;
0067     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0068         return;
0069
0070     ASSERT_EQ(skel->data->and64_value, 0x010ull << 32, "and64_value");
0071     ASSERT_EQ(skel->bss->and64_result, 0x110ull << 32, "and64_result");
0072
0073     ASSERT_EQ(skel->data->and32_value, 0x010, "and32_value");
0074     ASSERT_EQ(skel->bss->and32_result, 0x110, "and32_result");
0075
0076     ASSERT_EQ(skel->data->and_noreturn_value, 0x010ull << 32, "and_noreturn_value");
0077 }
0078
0079 static void test_or(struct atomics_lskel *skel)
0080 {
0081     int err, prog_fd;
0082     LIBBPF_OPTS(bpf_test_run_opts, topts);
0083
0084     /* No need to attach it, just run it directly */
0085     prog_fd = skel->progs.or.prog_fd;
0086     err = bpf_prog_test_run_opts(prog_fd, &topts);
0087     if (!ASSERT_OK(err, "test_run_opts err"))
0088         return;
0089     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0090         return;
0091
0092     ASSERT_EQ(skel->data->or64_value, 0x111ull << 32, "or64_value");
0093     ASSERT_EQ(skel->bss->or64_result, 0x110ull << 32, "or64_result");
0094
0095     ASSERT_EQ(skel->data->or32_value, 0x111, "or32_value");
0096     ASSERT_EQ(skel->bss->or32_result, 0x110, "or32_result");
0097
0098     ASSERT_EQ(skel->data->or_noreturn_value, 0x111ull << 32, "or_noreturn_value");
0099 }
0100
0101 static void test_xor(struct atomics_lskel *skel)
0102 {
0103     int err, prog_fd;
0104     LIBBPF_OPTS(bpf_test_run_opts, topts);
0105
0106     /* No need to attach it, just run it directly */
0107     prog_fd = skel->progs.xor.prog_fd;
0108     err = bpf_prog_test_run_opts(prog_fd, &topts);
0109     if (!ASSERT_OK(err, "test_run_opts err"))
0110         return;
0111     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0112         return;
0113
0114     ASSERT_EQ(skel->data->xor64_value, 0x101ull << 32, "xor64_value");
0115     ASSERT_EQ(skel->bss->xor64_result, 0x110ull << 32, "xor64_result");
0116
0117     ASSERT_EQ(skel->data->xor32_value, 0x101, "xor32_value");
0118     ASSERT_EQ(skel->bss->xor32_result, 0x110, "xor32_result");
0119
0120     ASSERT_EQ(skel->data->xor_noreturn_value, 0x101ull << 32, "xor_nxoreturn_value");
0121 }
0122
0123 static void test_cmpxchg(struct atomics_lskel *skel)
0124 {
0125     int err, prog_fd;
0126     LIBBPF_OPTS(bpf_test_run_opts, topts);
0127
0128     /* No need to attach it, just run it directly */
0129     prog_fd = skel->progs.cmpxchg.prog_fd;
0130     err = bpf_prog_test_run_opts(prog_fd, &topts);
0131     if (!ASSERT_OK(err, "test_run_opts err"))
0132         return;
0133     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0134         return;
0135
0136     ASSERT_EQ(skel->data->cmpxchg64_value, 2, "cmpxchg64_value");
0137     ASSERT_EQ(skel->bss->cmpxchg64_result_fail, 1, "cmpxchg_result_fail");
0138     ASSERT_EQ(skel->bss->cmpxchg64_result_succeed, 1, "cmpxchg_result_succeed");
0139
0140     ASSERT_EQ(skel->data->cmpxchg32_value, 2, "lcmpxchg32_value");
0141     ASSERT_EQ(skel->bss->cmpxchg32_result_fail, 1, "cmpxchg_result_fail");
0142     ASSERT_EQ(skel->bss->cmpxchg32_result_succeed, 1, "cmpxchg_result_succeed");
0143 }
0144
0145 static void test_xchg(struct atomics_lskel *skel)
0146 {
0147     int err, prog_fd;
0148     LIBBPF_OPTS(bpf_test_run_opts, topts);
0149
0150     /* No need to attach it, just run it directly */
0151     prog_fd = skel->progs.xchg.prog_fd;
0152     err = bpf_prog_test_run_opts(prog_fd, &topts);
0153     if (!ASSERT_OK(err, "test_run_opts err"))
0154         return;
0155     if (!ASSERT_OK(topts.retval, "test_run_opts retval"))
0156         return;
0157
0158     ASSERT_EQ(skel->data->xchg64_value, 2, "xchg64_value");
0159     ASSERT_EQ(skel->bss->xchg64_result, 1, "xchg64_result");
0160
0161     ASSERT_EQ(skel->data->xchg32_value, 2, "xchg32_value");
0162     ASSERT_EQ(skel->bss->xchg32_result, 1, "xchg32_result");
0163 }
0164
0165 void test_atomics(void)
0166 {
0167     struct atomics_lskel *skel;
0168
0169     skel = atomics_lskel__open_and_load();
0170     if (!ASSERT_OK_PTR(skel, "atomics skeleton load"))
0171         return;
0172
0173     if (skel->data->skip_tests) {
0174         printf("%s:SKIP:no ENABLE_ATOMICS_TESTS (missing Clang BPF atomics support)",
0175                __func__);
0176         test__skip();
0177         goto cleanup;
0178     }
0179     skel->bss->pid = getpid();
0180
0181     if (test__start_subtest("add"))
0182         test_add(skel);
0183     if (test__start_subtest("sub"))
0184         test_sub(skel);
0185     if (test__start_subtest("and"))
0186         test_and(skel);
0187     if (test__start_subtest("or"))
0188         test_or(skel);
0189     if (test__start_subtest("xor"))
0190         test_xor(skel);
0191     if (test__start_subtest("cmpxchg"))
0192         test_cmpxchg(skel);
0193     if (test__start_subtest("xchg"))
0194         test_xchg(skel);
0195
0196 cleanup:
0197     atomics_lskel__destroy(skel);
0198 }