Commit caaaa166 authored by Johan Almbladh's avatar Johan Almbladh Committed by Daniel Borkmann
Browse files

bpf/tests: Add tests of BPF_LDX and BPF_STX with small sizes 



This patch adds a series of tests to verify the behavior of BPF_LDX and
BPF_STX with BPF_B//W sizes in isolation. In particular, it checks that
BPF_LDX zero-extendeds the result, and that BPF_STX does not overwrite
adjacent bytes in memory.

BPF_ST and operations on BPF_DW size are deemed to be sufficiently
tested by existing tests.

Signed-off-by: default avatarJohan Almbladh <johan.almbladh@anyfinetworks.com>
Signed-off-by: default avatarDaniel Borkmann <daniel@iogearbox.net>
Link: https://lore.kernel.org/bpf/20211001130348.3670534-2-johan.almbladh@anyfinetworks.com
parent 6bbc7103

lib/test_bpf.c

+254 −0
Original line number Diff line number Diff line
@@ -6907,6 +6907,260 @@ static struct bpf_test tests[] = { 
		{ },

		{ { 0, (u32) (cpu_to_le64(0xfedcba9876543210ULL) >> 32) } },

	},

	/* BPF_LDX_MEM B/H/W/DW */

	{

		"BPF_LDX_MEM | BPF_B",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x0102030405060708ULL),

			BPF_LD_IMM64(R2, 0x0000000000000008ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_B, R0, R10, -1),

#else

			BPF_LDX_MEM(BPF_B, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_LDX_MEM | BPF_B, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8182838485868788ULL),

			BPF_LD_IMM64(R2, 0x0000000000000088ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_B, R0, R10, -1),

#else

			BPF_LDX_MEM(BPF_B, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_LDX_MEM | BPF_H",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x0102030405060708ULL),

			BPF_LD_IMM64(R2, 0x0000000000000708ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_H, R0, R10, -2),

#else

			BPF_LDX_MEM(BPF_H, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_LDX_MEM | BPF_H, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8182838485868788ULL),

			BPF_LD_IMM64(R2, 0x0000000000008788ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_H, R0, R10, -2),

#else

			BPF_LDX_MEM(BPF_H, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_LDX_MEM | BPF_W",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x0102030405060708ULL),

			BPF_LD_IMM64(R2, 0x0000000005060708ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_W, R0, R10, -4),

#else

			BPF_LDX_MEM(BPF_W, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_LDX_MEM | BPF_W, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8182838485868788ULL),

			BPF_LD_IMM64(R2, 0x0000000085868788ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_LDX_MEM(BPF_W, R0, R10, -4),

#else

			BPF_LDX_MEM(BPF_W, R0, R10, -8),

#endif

			BPF_JMP_REG(BPF_JNE, R0, R2, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	/* BPF_STX_MEM B/H/W/DW */

	{

		"BPF_STX_MEM | BPF_B",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x0102030405060708ULL),

			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e008ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_B, R10, R2, -1),

#else

			BPF_STX_MEM(BPF_B, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_STX_MEM | BPF_B, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x8182838485868788ULL),

			BPF_LD_IMM64(R3, 0x8090a0b0c0d0e088ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_B, R10, R2, -1),

#else

			BPF_STX_MEM(BPF_B, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_STX_MEM | BPF_H",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x0102030405060708ULL),

			BPF_LD_IMM64(R3, 0x8090a0b0c0d00708ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_H, R10, R2, -2),

#else

			BPF_STX_MEM(BPF_H, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_STX_MEM | BPF_H, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x8182838485868788ULL),

			BPF_LD_IMM64(R3, 0x8090a0b0c0d08788ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_H, R10, R2, -2),

#else

			BPF_STX_MEM(BPF_H, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_STX_MEM | BPF_W",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x0102030405060708ULL),

			BPF_LD_IMM64(R3, 0x8090a0b005060708ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_W, R10, R2, -4),

#else

			BPF_STX_MEM(BPF_W, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	{

		"BPF_STX_MEM | BPF_W, MSB set",

		.u.insns_int = {

			BPF_LD_IMM64(R1, 0x8090a0b0c0d0e0f0ULL),

			BPF_LD_IMM64(R2, 0x8182838485868788ULL),

			BPF_LD_IMM64(R3, 0x8090a0b085868788ULL),

			BPF_STX_MEM(BPF_DW, R10, R1, -8),

#ifdef __BIG_ENDIAN

			BPF_STX_MEM(BPF_W, R10, R2, -4),

#else

			BPF_STX_MEM(BPF_W, R10, R2, -8),

#endif

			BPF_LDX_MEM(BPF_DW, R0, R10, -8),

			BPF_JMP_REG(BPF_JNE, R0, R3, 1),

			BPF_ALU64_IMM(BPF_MOV, R0, 0),

			BPF_EXIT_INSN(),

		},

		INTERNAL,

		{ },

		{ { 0, 0 } },

		.stack_depth = 8,

	},

	/* BPF_ST(X) | BPF_MEM | BPF_B/H/W/DW */

	{

		"ST_MEM_B: Store/Load byte: max negative",