bpf/tests: Add more BPF_END byte order conversion tests

This patch adds tests of the high 32 bits of 64-bit BPF_END conversions.

It also adds a mirrored set of tests where the source bytes are reversed.
The MSB of each byte is now set on the high word instead, possibly
affecting sign-extension during conversion in a different way. Mainly
for JIT testing.

Signed-off-by: Johan Almbladh <johan.almbladh@anyfinetworks.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20210914091842.4186267-13-johan.almbladh@anyfinetworks.com

diff --git a/lib/test_bpf.c b/lib/test_bpf.c
index dd6bb00..7f8ad4f 100644 (file)
--- a/lib/test_bpf.c
+++ b/lib/test_bpf.c
@@ -6748,6 +6748,67 @@ static struct bpf_test tests[] = {
                { },
                { { 0, (u32) cpu_to_be64(0x0123456789abcdefLL) } },
        },
+       {
+               "ALU_END_FROM_BE 64: 0x0123456789abcdef >> 32 -> 0x01234567",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
+                       BPF_ENDIAN(BPF_FROM_BE, R0, 64),
+                       BPF_ALU64_IMM(BPF_RSH, R0, 32),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) (cpu_to_be64(0x0123456789abcdefLL) >> 32) } },
+       },
+       /* BPF_ALU | BPF_END | BPF_FROM_BE, reversed */
+       {
+               "ALU_END_FROM_BE 16: 0xfedcba9876543210 -> 0x3210",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_BE, R0, 16),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0,  cpu_to_be16(0x3210) } },
+       },
+       {
+               "ALU_END_FROM_BE 32: 0xfedcba9876543210 -> 0x76543210",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_BE, R0, 32),
+                       BPF_ALU64_REG(BPF_MOV, R1, R0),
+                       BPF_ALU64_IMM(BPF_RSH, R1, 32),
+                       BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, cpu_to_be32(0x76543210) } },
+       },
+       {
+               "ALU_END_FROM_BE 64: 0xfedcba9876543210 -> 0x76543210",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_BE, R0, 64),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) cpu_to_be64(0xfedcba9876543210ULL) } },
+       },
+       {
+               "ALU_END_FROM_BE 64: 0xfedcba9876543210 >> 32 -> 0xfedcba98",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_BE, R0, 64),
+                       BPF_ALU64_IMM(BPF_RSH, R0, 32),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) (cpu_to_be64(0xfedcba9876543210ULL) >> 32) } },
+       },
        /* BPF_ALU | BPF_END | BPF_FROM_LE */
        {
                "ALU_END_FROM_LE 16: 0x0123456789abcdef -> 0xefcd",
@@ -6785,6 +6846,67 @@ static struct bpf_test tests[] = {
                { },
                { { 0, (u32) cpu_to_le64(0x0123456789abcdefLL) } },
        },
+       {
+               "ALU_END_FROM_LE 64: 0x0123456789abcdef >> 32 -> 0xefcdab89",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0x0123456789abcdefLL),
+                       BPF_ENDIAN(BPF_FROM_LE, R0, 64),
+                       BPF_ALU64_IMM(BPF_RSH, R0, 32),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) (cpu_to_le64(0x0123456789abcdefLL) >> 32) } },
+       },
+       /* BPF_ALU | BPF_END | BPF_FROM_LE, reversed */
+       {
+               "ALU_END_FROM_LE 16: 0xfedcba9876543210 -> 0x1032",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_LE, R0, 16),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0,  cpu_to_le16(0x3210) } },
+       },
+       {
+               "ALU_END_FROM_LE 32: 0xfedcba9876543210 -> 0x10325476",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_LE, R0, 32),
+                       BPF_ALU64_REG(BPF_MOV, R1, R0),
+                       BPF_ALU64_IMM(BPF_RSH, R1, 32),
+                       BPF_ALU32_REG(BPF_ADD, R0, R1), /* R1 = 0 */
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, cpu_to_le32(0x76543210) } },
+       },
+       {
+               "ALU_END_FROM_LE 64: 0xfedcba9876543210 -> 0x10325476",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_LE, R0, 64),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) cpu_to_le64(0xfedcba9876543210ULL) } },
+       },
+       {
+               "ALU_END_FROM_LE 64: 0xfedcba9876543210 >> 32 -> 0x98badcfe",
+               .u.insns_int = {
+                       BPF_LD_IMM64(R0, 0xfedcba9876543210ULL),
+                       BPF_ENDIAN(BPF_FROM_LE, R0, 64),
+                       BPF_ALU64_IMM(BPF_RSH, R0, 32),
+                       BPF_EXIT_INSN(),
+               },
+               INTERNAL,
+               { },
+               { { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },
+       },
        /* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */
        {
                "ST_MEM_B: Store/Load byte: max negative",