Commit 6ea848b5 authored by Jiong Wang's avatar Jiong Wang Committed by Alexei Starovoitov
Browse files

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: default avatarJakub Kicinski <jakub.kicinski@netronome.com>
Signed-off-by: default avatarJiong Wang <jiong.wang@netronome.com>
Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 46144839

samples/bpf/bpf_insn.h

+20 −0
Original line number Diff line number Diff line
@@ -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)			\

tools/testing/selftests/bpf/test_verifier.c

+762 −24
Original line number Diff line number Diff line
@@ -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)

CRA Git | Maintained and supported by SUSTech CRA and CCSE