bpf, tests: Add tests for BPF_CMPXCHG

Tests for BPF_CMPXCHG with both word and double word operands. As with
the tests for other atomic operations, these tests only check the result
of the arithmetic operation. The atomicity of the operations is not tested.

Signed-off-by: Johan Almbladh <johan.almbladh@anyfinetworks.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Yonghong Song <yhs@fb.com>
Link: https://lore.kernel.org/bpf/20210809091829.810076-14-johan.almbladh@anyfinetworks.com

diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index 855f64093ca798bde3dbd74a3de7de023b11b837..d05fe7b4a9cb13709d0626954f7d27091b6bbb20 100644 (file)
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -5690,6 +5690,172 @@ static struct bpf_test tests[] = {
 #undef BPF_ATOMIC_OP_TEST2
 #undef BPF_ATOMIC_OP_TEST3
 #undef BPF_ATOMIC_OP_TEST4
+       /* BPF_ATOMIC | BPF_W, BPF_CMPXCHG */
+       {
+               "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful return",
+               .u.insns_int = {
+                       BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0x01234567 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test successful store",
+               .u.insns_int = {
+                       BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_LDX_MEM(BPF_W, R0, R10, -40),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0x89abcdef } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure return",
+               .u.insns_int = {
+                       BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
+                       BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0x01234567 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test failure store",
+               .u.insns_int = {
+                       BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R0, 0x76543210),
+                       BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_LDX_MEM(BPF_W, R0, R10, -40),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0x01234567 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_W, BPF_CMPXCHG: Test side effects",
+               .u.insns_int = {
+                       BPF_ST_MEM(BPF_W, R10, -40, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R0, 0x01234567),
+                       BPF_ALU32_IMM(BPF_MOV, R3, 0x89abcdef),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_ATOMIC_OP(BPF_W, BPF_CMPXCHG, R10, R3, -40),
+                       BPF_ALU32_REG(BPF_MOV, R0, R3),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0x89abcdef } },
+               .stack_depth = 40,
+       },
+       /* BPF_ATOMIC | BPF_DW, BPF_CMPXCHG */
+       {
+               "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful return",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
+                       BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
+                       BPF_ALU64_REG(BPF_MOV, R0, R1),
+                       BPF_STX_MEM(BPF_DW, R10, R1, -40),
+                       BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
+                       BPF_JMP_REG(BPF_JNE, R0, R1, 1),
+                       BPF_ALU64_REG(BPF_SUB, R0, R1),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test successful store",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
+                       BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
+                       BPF_ALU64_REG(BPF_MOV, R0, R1),
+                       BPF_STX_MEM(BPF_DW, R10, R0, -40),
+                       BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
+                       BPF_LDX_MEM(BPF_DW, R0, R10, -40),
+                       BPF_JMP_REG(BPF_JNE, R0, R2, 1),
+                       BPF_ALU64_REG(BPF_SUB, R0, R2),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure return",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
+                       BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
+                       BPF_ALU64_REG(BPF_MOV, R0, R1),
+                       BPF_ALU64_IMM(BPF_ADD, R0, 1),
+                       BPF_STX_MEM(BPF_DW, R10, R1, -40),
+                       BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
+                       BPF_JMP_REG(BPF_JNE, R0, R1, 1),
+                       BPF_ALU64_REG(BPF_SUB, R0, R1),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test failure store",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
+                       BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
+                       BPF_ALU64_REG(BPF_MOV, R0, R1),
+                       BPF_ALU64_IMM(BPF_ADD, R0, 1),
+                       BPF_STX_MEM(BPF_DW, R10, R1, -40),
+                       BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
+                       BPF_LDX_MEM(BPF_DW, R0, R10, -40),
+                       BPF_JMP_REG(BPF_JNE, R0, R1, 1),
+                       BPF_ALU64_REG(BPF_SUB, R0, R1),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0 } },
+               .stack_depth = 40,
+       },
+       {
+               "BPF_ATOMIC | BPF_DW, BPF_CMPXCHG: Test side effects",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R1, 0x0123456789abcdefULL),
+                       BPF_LD_IMM64(R2, 0xfecdba9876543210ULL),
+                       BPF_ALU64_REG(BPF_MOV, R0, R1),
+                       BPF_STX_MEM(BPF_DW, R10, R1, -40),
+                       BPF_ATOMIC_OP(BPF_DW, BPF_CMPXCHG, R10, R2, -40),
+                       BPF_LD_IMM64(R0, 0xfecdba9876543210ULL),
+                       BPF_JMP_REG(BPF_JNE, R0, R2, 1),
+                       BPF_ALU64_REG(BPF_SUB, R0, R2),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, 0 } },
+               .stack_depth = 40,
+       },
        /* BPF_JMP32 | BPF_JEQ | BPF_K */
        {
                "JMP32_JEQ_K: Small immediate",