Commit 7605f94b authored by Eduard Zingerman's avatar Eduard Zingerman Committed by Alexei Starovoitov
Browse files

selftests/bpf: verifier/bounds_deduction.c converted to inline assembly 



Test verifier/bounds_deduction.c automatically converted to use inline assembly.

Signed-off-by: default avatarEduard Zingerman <eddyz87@gmail.com>
Link: https://lore.kernel.org/r/20230325025524.144043-10-eddyz87@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 0ccbe495

tools/testing/selftests/bpf/prog_tests/verifier.c

+2 −0
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ 
#include "verifier_and.skel.h"

#include "verifier_array_access.skel.h"

#include "verifier_basic_stack.skel.h"

#include "verifier_bounds_deduction.skel.h"



__maybe_unused

static void run_tests_aux(const char *skel_name, skel_elf_bytes_fn elf_bytes_factory)
@@ -34,3 +35,4 @@ static void run_tests_aux(const char *skel_name, skel_elf_bytes_fn elf_bytes_fac 
void test_verifier_and(void)                  { RUN(verifier_and); }

void test_verifier_array_access(void)         { RUN(verifier_array_access); }

void test_verifier_basic_stack(void)          { RUN(verifier_basic_stack); }

void test_verifier_bounds_deduction(void)     { RUN(verifier_bounds_deduction); }

tools/testing/selftests/bpf/progs/verifier_bounds_deduction.c

0 → 100644
+171 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Converted from tools/testing/selftests/bpf/verifier/bounds_deduction.c */



#include <linux/bpf.h>

#include <bpf/bpf_helpers.h>

#include "bpf_misc.h"



SEC("socket")

__description("check deducing bounds from const, 1")

__failure __msg("R0 tried to subtract pointer from scalar")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__naked void deducing_bounds_from_const_1(void)

{

	asm volatile ("					\

	r0 = 1;						\

	if r0 s>= 1 goto l0_%=;				\

l0_%=:	r0 -= r1;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 2")

__success __failure_unpriv

__msg_unpriv("R1 has pointer with unsupported alu operation")

__retval(1)

__naked void deducing_bounds_from_const_2(void)

{

	asm volatile ("					\

	r0 = 1;						\

	if r0 s>= 1 goto l0_%=;				\

	exit;						\

l0_%=:	if r0 s<= 1 goto l1_%=;				\

	exit;						\

l1_%=:	r1 -= r0;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 3")

__failure __msg("R0 tried to subtract pointer from scalar")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__naked void deducing_bounds_from_const_3(void)

{

	asm volatile ("					\

	r0 = 0;						\

	if r0 s<= 0 goto l0_%=;				\

l0_%=:	r0 -= r1;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 4")

__success __failure_unpriv

__msg_unpriv("R6 has pointer with unsupported alu operation")

__retval(0)

__naked void deducing_bounds_from_const_4(void)

{

	asm volatile ("					\

	r6 = r1;					\

	r0 = 0;						\

	if r0 s<= 0 goto l0_%=;				\

	exit;						\

l0_%=:	if r0 s>= 0 goto l1_%=;				\

	exit;						\

l1_%=:	r6 -= r0;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 5")

__failure __msg("R0 tried to subtract pointer from scalar")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__naked void deducing_bounds_from_const_5(void)

{

	asm volatile ("					\

	r0 = 0;						\

	if r0 s>= 1 goto l0_%=;				\

	r0 -= r1;					\

l0_%=:	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 6")

__failure __msg("R0 tried to subtract pointer from scalar")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__naked void deducing_bounds_from_const_6(void)

{

	asm volatile ("					\

	r0 = 0;						\

	if r0 s>= 0 goto l0_%=;				\

	exit;						\

l0_%=:	r0 -= r1;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 7")

__failure __msg("dereference of modified ctx ptr")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__flag(BPF_F_ANY_ALIGNMENT)

__naked void deducing_bounds_from_const_7(void)

{

	asm volatile ("					\

	r0 = %[__imm_0];				\

	if r0 s>= 0 goto l0_%=;				\

l0_%=:	r1 -= r0;					\

	r0 = *(u32*)(r1 + %[__sk_buff_mark]);		\

	exit;						\

"	:

	: __imm_const(__imm_0, ~0),

	  __imm_const(__sk_buff_mark, offsetof(struct __sk_buff, mark))

	: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 8")

__failure __msg("negative offset ctx ptr R1 off=-1 disallowed")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__flag(BPF_F_ANY_ALIGNMENT)

__naked void deducing_bounds_from_const_8(void)

{

	asm volatile ("					\

	r0 = %[__imm_0];				\

	if r0 s>= 0 goto l0_%=;				\

	r1 += r0;					\

l0_%=:	r0 = *(u32*)(r1 + %[__sk_buff_mark]);		\

	exit;						\

"	:

	: __imm_const(__imm_0, ~0),

	  __imm_const(__sk_buff_mark, offsetof(struct __sk_buff, mark))

	: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 9")

__failure __msg("R0 tried to subtract pointer from scalar")

__msg_unpriv("R1 has pointer with unsupported alu operation")

__naked void deducing_bounds_from_const_9(void)

{

	asm volatile ("					\

	r0 = 0;						\

	if r0 s>= 0 goto l0_%=;				\

l0_%=:	r0 -= r1;					\

	exit;						\

"	::: __clobber_all);

}



SEC("socket")

__description("check deducing bounds from const, 10")

__failure

__msg("math between ctx pointer and register with unbounded min value is not allowed")

__failure_unpriv

__naked void deducing_bounds_from_const_10(void)

{

	asm volatile ("					\

	r0 = 0;						\

	if r0 s<= 0 goto l0_%=;				\

l0_%=:	/* Marks reg as unknown. */			\

	r0 = -r0;					\

	r0 -= r1;					\

	exit;						\

"	::: __clobber_all);

}



char _license[] SEC("license") = "GPL";

tools/testing/selftests/bpf/verifier/bounds_deduction.c

deleted100644 → 0
+0 −136
Original line number Diff line number Diff line 
{

	"check deducing bounds from const, 1",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 1),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 1, 0),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "R0 tried to subtract pointer from scalar",

	.result = REJECT,

},

{

	"check deducing bounds from const, 2",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 1),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 1, 1),

		BPF_EXIT_INSN(),

		BPF_JMP_IMM(BPF_JSLE, BPF_REG_0, 1, 1),

		BPF_EXIT_INSN(),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.result_unpriv = REJECT,

	.result = ACCEPT,

	.retval = 1,

},

{

	"check deducing bounds from const, 3",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSLE, BPF_REG_0, 0, 0),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "R0 tried to subtract pointer from scalar",

	.result = REJECT,

},

{

	"check deducing bounds from const, 4",

	.insns = {

		BPF_MOV64_REG(BPF_REG_6, BPF_REG_1),

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSLE, BPF_REG_0, 0, 1),

		BPF_EXIT_INSN(),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 0, 1),

		BPF_EXIT_INSN(),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_6, BPF_REG_0),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R6 has pointer with unsupported alu operation",

	.result_unpriv = REJECT,

	.result = ACCEPT,

},

{

	"check deducing bounds from const, 5",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 1, 1),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "R0 tried to subtract pointer from scalar",

	.result = REJECT,

},

{

	"check deducing bounds from const, 6",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 0, 1),

		BPF_EXIT_INSN(),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "R0 tried to subtract pointer from scalar",

	.result = REJECT,

},

{

	"check deducing bounds from const, 7",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, ~0),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 0, 0),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_1, BPF_REG_0),

		BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,

			    offsetof(struct __sk_buff, mark)),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "dereference of modified ctx ptr",

	.result = REJECT,

	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

},

{

	"check deducing bounds from const, 8",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, ~0),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 0, 1),

		BPF_ALU64_REG(BPF_ADD, BPF_REG_1, BPF_REG_0),

		BPF_LDX_MEM(BPF_W, BPF_REG_0, BPF_REG_1,

			    offsetof(struct __sk_buff, mark)),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "negative offset ctx ptr R1 off=-1 disallowed",

	.result = REJECT,

	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,

},

{

	"check deducing bounds from const, 9",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSGE, BPF_REG_0, 0, 0),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr_unpriv = "R1 has pointer with unsupported alu operation",

	.errstr = "R0 tried to subtract pointer from scalar",

	.result = REJECT,

},

{

	"check deducing bounds from const, 10",

	.insns = {

		BPF_MOV64_IMM(BPF_REG_0, 0),

		BPF_JMP_IMM(BPF_JSLE, BPF_REG_0, 0, 0),

		/* Marks reg as unknown. */

		BPF_ALU64_IMM(BPF_NEG, BPF_REG_0, 0),

		BPF_ALU64_REG(BPF_SUB, BPF_REG_0, BPF_REG_1),

		BPF_EXIT_INSN(),

	},

	.errstr = "math between ctx pointer and register with unbounded min value is not allowed",

	.result = REJECT,

},