selftests: bpf: functional and min/max reasoning unit tests for JMP32

This patch adds unit tests for new JMP32 instructions.

This patch also added the new BPF_JMP32_REG and BPF_JMP32_IMM macros to
samples/bpf/bpf_insn.h so that JMP32 insn builders are available to tests
under 'samples' directory.

Reviewed-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: Jiong Wang <jiong.wang@netronome.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/samples/bpf/bpf_insn.h b/samples/bpf/bpf_insn.h
index 20dc5ce..5442379 100644 (file)
--- a/samples/bpf/bpf_insn.h
+++ b/samples/bpf/bpf_insn.h
@@ -164,6 +164,16 @@ struct bpf_insn;
                .off   = OFF,                                   \
                .imm   = 0 })
 
+/* Like BPF_JMP_REG, but with 32-bit wide operands for comparison. */
+
+#define BPF_JMP32_REG(OP, DST, SRC, OFF)                       \
+       ((struct bpf_insn) {                                    \
+               .code  = BPF_JMP32 | BPF_OP(OP) | BPF_X,        \
+               .dst_reg = DST,                                 \
+               .src_reg = SRC,                                 \
+               .off   = OFF,                                   \
+               .imm   = 0 })
+
 /* Conditional jumps against immediates, if (dst_reg 'op' imm32) goto pc + off16 */
 
 #define BPF_JMP_IMM(OP, DST, IMM, OFF)                         \
@@ -174,6 +184,16 @@ struct bpf_insn;
                .off   = OFF,                                   \
                .imm   = IMM })
 
+/* Like BPF_JMP_IMM, but with 32-bit wide operands for comparison. */
+
+#define BPF_JMP32_IMM(OP, DST, IMM, OFF)                       \
+       ((struct bpf_insn) {                                    \
+               .code  = BPF_JMP32 | BPF_OP(OP) | BPF_K,        \
+               .dst_reg = DST,                                 \
+               .src_reg = 0,                                   \
+               .off   = OFF,                                   \
+               .imm   = IMM })
+
 /* Raw code statement block */
 
 #define BPF_RAW_INSN(CODE, DST, SRC, OFF, IMM)                 \

diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index e4fef6c..1df7576 100644 (file)
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -211,6 +211,42 @@ static void bpf_fill_rand_ld_dw(struct bpf_test *self)
        BPF_MOV64_IMM(BPF_REG_5, 0),                                    \
        BPF_EMIT_CALL(BPF_FUNC_sk_lookup_tcp)
 
+/* BPF_DIRECT_PKT_R2 contains 7 instructions, it initializes default return
+ * value into 0 and does necessary preparation for direct packet access
+ * through r2. The allowed access range is 8 bytes.
+ */
+#define BPF_DIRECT_PKT_R2                                              \
+       BPF_MOV64_IMM(BPF_REG_0, 0),                                    \
+       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,                        \
+                   offsetof(struct __sk_buff, data)),                  \
+       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,                        \
+                   offsetof(struct __sk_buff, data_end)),              \
+       BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),                            \
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),                           \
+       BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),                  \
+       BPF_EXIT_INSN()
+
+/* BPF_RAND_UEXT_R7 contains 4 instructions, it initializes R7 into a random
+ * positive u32, and zero-extend it into 64-bit.
+ */
+#define BPF_RAND_UEXT_R7                                               \
+       BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,                       \
+                    BPF_FUNC_get_prandom_u32),                         \
+       BPF_MOV64_REG(BPF_REG_7, BPF_REG_0),                            \
+       BPF_ALU64_IMM(BPF_LSH, BPF_REG_7, 33),                          \
+       BPF_ALU64_IMM(BPF_RSH, BPF_REG_7, 33)
+
+/* BPF_RAND_SEXT_R7 contains 5 instructions, it initializes R7 into a random
+ * negative u32, and sign-extend it into 64-bit.
+ */
+#define BPF_RAND_SEXT_R7                                               \
+       BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0,                       \
+                    BPF_FUNC_get_prandom_u32),                         \
+       BPF_MOV64_REG(BPF_REG_7, BPF_REG_0),                            \
+       BPF_ALU64_IMM(BPF_OR, BPF_REG_7, 0x80000000),                   \
+       BPF_ALU64_IMM(BPF_LSH, BPF_REG_7, 32),                          \
+       BPF_ALU64_IMM(BPF_ARSH, BPF_REG_7, 32)
+
 static struct bpf_test tests[] = {
        {
                "add+sub+mul",
@@ -15447,18 +15483,7 @@ static struct bpf_test tests[] = {
        {
                "jset: functional",
                .insns = {
-                       /* r0 = 0 */
-                       BPF_MOV64_IMM(BPF_REG_0, 0),
-                       /* prep for direct packet access via r2 */
-                       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
-                                   offsetof(struct __sk_buff, data)),
-                       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
-                                   offsetof(struct __sk_buff, data_end)),
-                       BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
-                       BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
-                       BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
-                       BPF_EXIT_INSN(),
-
+                       BPF_DIRECT_PKT_R2,
                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 
                        /* reg, bit 63 or bit 0 set, taken */
@@ -15514,18 +15539,7 @@ static struct bpf_test tests[] = {
        {
                "jset: sign-extend",
                .insns = {
-                       /* r0 = 0 */
-                       BPF_MOV64_IMM(BPF_REG_0, 0),
-                       /* prep for direct packet access via r2 */
-                       BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
-                                   offsetof(struct __sk_buff, data)),
-                       BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
-                                   offsetof(struct __sk_buff, data_end)),
-                       BPF_MOV64_REG(BPF_REG_4, BPF_REG_2),
-                       BPF_ALU64_IMM(BPF_ADD, BPF_REG_4, 8),
-                       BPF_JMP_REG(BPF_JLE, BPF_REG_4, BPF_REG_3, 1),
-                       BPF_EXIT_INSN(),
-
+                       BPF_DIRECT_PKT_R2,
                        BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
 
                        BPF_JMP_IMM(BPF_JSET, BPF_REG_7, 0x80000000, 1),
@@ -15795,6 +15809,730 @@ static struct bpf_test tests[] = {
                .result = ACCEPT,
                .retval = 2,
        },
+       {
+               "jset32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       /* reg, high bits shouldn't be tested */
+                       BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, -2, 1),
+                       BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+                       BPF_EXIT_INSN(),
+
+                       BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { 1ULL << 63, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1ULL << 63 | 1, }
+                       },
+               },
+       },
+       {
+               "jset32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_LD_IMM64(BPF_REG_8, 0x8000000000000000),
+                       BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_JMP_IMM(BPF_JA, 0, 0, 1),
+                       BPF_EXIT_INSN(),
+
+                       BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
+                       BPF_JMP32_REG(BPF_JSET, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { 1ULL << 63, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1ULL << 63 | 1, }
+                       },
+               },
+       },
+       {
+               "jset32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_MOV64_IMM(BPF_REG_0, 0),
+                       BPF_JMP32_IMM(BPF_JSET, BPF_REG_7, 0x10, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x10, 1),
+                       BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+       },
+       {
+               "jeq32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 2,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { -2, }
+                       },
+                       { .retval = 2,
+                         .data64 = { -1, }
+                       },
+               },
+       },
+       {
+               "jeq32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7000000000000001),
+                       BPF_JMP32_REG(BPF_JEQ, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { 2, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1ULL << 63 | 1, }
+                       },
+               },
+       },
+       {
+               "jeq32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_MOV64_IMM(BPF_REG_0, 0),
+                       BPF_JMP32_IMM(BPF_JEQ, BPF_REG_7, 0x10, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, 0xf, 1),
+                       BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+       },
+       {
+               "jne32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 2,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { 1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { -1, }
+                       },
+               },
+       },
+       {
+               "jne32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_LD_IMM64(BPF_REG_8, 0x8000000000000001),
+                       BPF_JMP32_REG(BPF_JNE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_MOV64_IMM(BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { 1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 2, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1ULL << 63 | 2, }
+                       },
+               },
+       },
+       {
+               "jne32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_MOV64_IMM(BPF_REG_0, 0),
+                       BPF_JMP32_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
+                       BPF_JMP_IMM(BPF_JNE, BPF_REG_7, 0x10, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_LDX_MEM(BPF_B, BPF_REG_8, BPF_REG_9, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+       },
+       {
+               "jge32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, UINT_MAX - 1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 2,
+                         .data64 = { UINT_MAX - 1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 0, }
+                       },
+               },
+       },
+       {
+               "jge32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, UINT_MAX | 1ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 0,
+                         .data64 = { INT_MAX, }
+                       },
+                       { .retval = 0,
+                         .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
+                       },
+               },
+       },
+       {
+               "jge32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JGE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP32_IMM(BPF_JGE, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jgt32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JGT, BPF_REG_7, UINT_MAX - 1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX - 1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 0, }
+                       },
+               },
+       },
+       {
+               "jgt32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, (UINT_MAX - 1) | 1ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX - 1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { (UINT_MAX - 1) | 2ULL << 32, }
+                       },
+               },
+       },
+       {
+               "jgt32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JGT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP_IMM(BPF_JGT, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jle32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, INT_MAX, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { INT_MAX - 1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 2,
+                         .data64 = { INT_MAX, }
+                       },
+               },
+       },
+       {
+               "jle32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, (INT_MAX - 1) | 2ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { INT_MAX | 1ULL << 32, }
+                       },
+                       { .retval = 2,
+                         .data64 = { INT_MAX - 2, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX, }
+                       },
+               },
+       },
+       {
+               "jle32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JLE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP32_IMM(BPF_JLE, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jlt32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JLT, BPF_REG_7, INT_MAX, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { INT_MAX, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 2,
+                         .data64 = { INT_MAX - 1, }
+                       },
+               },
+       },
+       {
+               "jlt32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, INT_MAX | 2ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { INT_MAX | 1ULL << 32, }
+                       },
+                       { .retval = 0,
+                         .data64 = { UINT_MAX, }
+                       },
+                       { .retval = 2,
+                         .data64 = { (INT_MAX - 1) | 3ULL << 32, }
+                       },
+               },
+       },
+       {
+               "jlt32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JLT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP_IMM(BPF_JSLT, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jsge32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JSGE, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { 0, }
+                       },
+                       { .retval = 2,
+                         .data64 = { -1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { -2, }
+                       },
+               },
+       },
+       {
+               "jsge32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, (__u32)-1 | 2ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { -1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 0x7fffffff | 1ULL << 32, }
+                       },
+                       { .retval = 0,
+                         .data64 = { -2, }
+                       },
+               },
+       },
+       {
+               "jsge32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JSGE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP_IMM(BPF_JSGE, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jsgt32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JSGT, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { (__u32)-2, }
+                       },
+                       { .retval = 0,
+                         .data64 = { -1, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 1, }
+                       },
+               },
+       },
+       {
+               "jsgt32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 0,
+                         .data64 = { 0x7ffffffe, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 0x1ffffffffULL, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 0x7fffffff, }
+                       },
+               },
+       },
+       {
+               "jsgt32: min/max deduction",
+               .insns = {
+                       BPF_RAND_SEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, (__u32)(-2) | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JSGT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP_IMM(BPF_JSGT, BPF_REG_7, -2, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jsle32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JSLE, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { (__u32)-2, }
+                       },
+                       { .retval = 2,
+                         .data64 = { -1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 1, }
+                       },
+               },
+       },
+       {
+               "jsle32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffffe | 1ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { 0x7ffffffe, }
+                       },
+                       { .retval = 2,
+                         .data64 = { (__u32)-1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 0x7fffffff | 2ULL << 32, }
+                       },
+               },
+       },
+       {
+               "jsle32: min/max deduction",
+               .insns = {
+                       BPF_RAND_UEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, 0x7ffffff0 | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JSLE, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP_IMM(BPF_JSLE, BPF_REG_7, 0x7ffffff0, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
+       {
+               "jslt32: BPF_K",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { (__u32)-2, }
+                       },
+                       { .retval = 0,
+                         .data64 = { -1, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 1, }
+                       },
+               },
+       },
+       {
+               "jslt32: BPF_X",
+               .insns = {
+                       BPF_DIRECT_PKT_R2,
+                       BPF_LD_IMM64(BPF_REG_8, 0x7fffffff | 1ULL << 32),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_7, BPF_REG_2, 0),
+                       BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_EXIT_INSN(),
+               },
+               .prog_type = BPF_PROG_TYPE_SCHED_CLS,
+               .result = ACCEPT,
+               .runs = 3,
+               .retvals = {
+                       { .retval = 2,
+                         .data64 = { 0x7ffffffe, }
+                       },
+                       { .retval = 2,
+                         .data64 = { 0xffffffff, }
+                       },
+                       { .retval = 0,
+                         .data64 = { 0x7fffffff | 2ULL << 32, }
+                       },
+               },
+       },
+       {
+               "jslt32: min/max deduction",
+               .insns = {
+                       BPF_RAND_SEXT_R7,
+                       BPF_ALU32_IMM(BPF_MOV, BPF_REG_0, 2),
+                       BPF_LD_IMM64(BPF_REG_8, (__u32)(-1) | 1ULL << 32),
+                       BPF_JMP32_REG(BPF_JSLT, BPF_REG_7, BPF_REG_8, 1),
+                       BPF_EXIT_INSN(),
+                       BPF_JMP32_IMM(BPF_JSLT, BPF_REG_7, -1, 1),
+                       BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_0, 0),
+                       BPF_EXIT_INSN(),
+               },
+               .result = ACCEPT,
+               .retval = 2,
+       },
 };
 
 static int probe_filter_length(const struct bpf_insn *fp)