Skip to contentSkip to conversation

bpf: precision tracking tests

PATCH Applied Alexei Starovoitov 5 participants 12 messages Aug 23, 2019 – Aug 27, 2019

Subsystems (6)
lore
Share & tools
lore

Alexei Starovoitov

author maintainer
#0 lore raw

cover bpf: precision tracking tests

Add few additional tests for precision tracking in the verifier.

Alexei Starovoitov (4):
bpf: introduce verifier internal test flag
tools/bpf: sync bpf.h
selftests/bpf: verifier precise tests
selftests/bpf: add precision tracking test

 include/linux/bpf_verifier.h                  |   1 +
 include/uapi/linux/bpf.h                      |   3 +
 kernel/bpf/syscall.c                          |   1 +
 kernel/bpf/verifier.c                         |   5 +-
 tools/include/uapi/linux/bpf.h                |   3 +
 tools/testing/selftests/bpf/test_verifier.c   |  68 +++++++--
 .../testing/selftests/bpf/verifier/precise.c  | 142 ++++++++++++++++++
 7 files changed, 211 insertions(+), 12 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/verifier/precise.c
Signature · 1 line
2.20.0
author maintainer
#1 lore raw

PATCH 1/4 bpf: introduce verifier internal test flag

Introduce BPF_F_TEST_STATE_FREQ flag to stress test parentage chain and state pruning.

---
 include/linux/bpf_verifier.h | 1 +
 include/uapi/linux/bpf.h     | 3 +++
 kernel/bpf/syscall.c         | 1 +
 kernel/bpf/verifier.c        | 5 ++++-
 4 files changed, 9 insertions(+), 1 deletion(-)
include/linux/bpf_verifier.h +1 -0
index 5fe99f322b1c..26a6d58ca78c 100644
@@ -355,6 +355,7 @@ struct bpf_verifier_env {
 	struct bpf_verifier_stack_elem *head; /* stack of verifier states to be processed */
 	int stack_size;			/* number of states to be processed */
 	bool strict_alignment;		/* perform strict pointer alignment checks */
+	bool test_state_freq;		/* test verifier with different pruning frequency */
 	struct bpf_verifier_state *cur_state; /* current verifier state */
 	struct bpf_verifier_state_list **explored_states; /* search pruning optimization */
 	struct bpf_verifier_state_list *free_list;
include/uapi/linux/bpf.h +3 -0
index b5889257cc33..5d2fb183ee2d 100644
@@ -285,6 +285,9 @@ enum bpf_attach_type {
  */
 #define BPF_F_TEST_RND_HI32	(1U << 2)
 
+/* The verifier internal test flag. Behavior is undefined */
+#define BPF_F_TEST_STATE_FREQ	(1U << 3)
+
 /* When BPF ldimm64's insn[0].src_reg != 0 then this can have
  * two extensions:
  *
kernel/bpf/syscall.c +1 -0
index c0f62fd67c6b..ca60eafa6922 100644
@@ -1629,6 +1629,7 @@ static int bpf_prog_load(union bpf_attr *attr, union bpf_attr __user *uattr)
 
 	if (attr->prog_flags & ~(BPF_F_STRICT_ALIGNMENT |
 				 BPF_F_ANY_ALIGNMENT |
+				 BPF_F_TEST_STATE_FREQ |
 				 BPF_F_TEST_RND_HI32))
 		return -EINVAL;
 
kernel/bpf/verifier.c +4 -1
index 16d66bd7af09..3fb50757e812 100644
@@ -7223,7 +7223,7 @@ static int is_state_visited(struct bpf_verifier_env *env, int insn_idx)
 	struct bpf_verifier_state_list *sl, **pprev;
 	struct bpf_verifier_state *cur = env->cur_state, *new;
 	int i, j, err, states_cnt = 0;
-	bool add_new_state = false;
+	bool add_new_state = env->test_state_freq ? true : false;
 
 	cur->last_insn_idx = env->prev_insn_idx;
 	if (!env->insn_aux_data[insn_idx].prune_point)
@@ -9263,6 +9263,9 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr,
 
 	env->allow_ptr_leaks = is_priv;
 
+	if (is_priv)
+		env->test_state_freq = attr->prog_flags & BPF_F_TEST_STATE_FREQ;
+
 	ret = replace_map_fd_with_map_ptr(env);
 	if (ret < 0)
 		goto skip_full_check;
Signature · 1 line
2.20.0
author maintainer
#3 lore raw

PATCH 2/4 tools/bpf: sync bpf.h

In reply to Alexei Starovoitov

sync bpf.h from kernel/ to tools/

---
 tools/include/uapi/linux/bpf.h | 3 +++
 1 file changed, 3 insertions(+)
tools/include/uapi/linux/bpf.h +3 -0
index b5889257cc33..5d2fb183ee2d 100644
@@ -285,6 +285,9 @@ enum bpf_attach_type {
  */
 #define BPF_F_TEST_RND_HI32	(1U << 2)
 
+/* The verifier internal test flag. Behavior is undefined */
+#define BPF_F_TEST_STATE_FREQ	(1U << 3)
+
 /* When BPF ldimm64's insn[0].src_reg != 0 then this can have
  * two extensions:
  *
Signature · 1 line
2.20.0
author maintainer
#5 lore raw

PATCH 3/4 selftests/bpf: verifier precise tests

In reply to Alexei Starovoitov

Use BPF_F_TEST_STATE_FREQ flag to check that precision tracking works as expected by comparing every step it takes.

---
 tools/testing/selftests/bpf/test_verifier.c   |  68 ++++++++--
 .../testing/selftests/bpf/verifier/precise.c  | 117 ++++++++++++++++++
 2 files changed, 174 insertions(+), 11 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/verifier/precise.c
tools/testing/selftests/bpf/test_verifier.c +57 -11
index 44e2d640b088..d27fd929abb9 100644
@@ -61,6 +61,7 @@
 #define UNPRIV_SYSCTL "kernel/unprivileged_bpf_disabled"
 static bool unpriv_disabled = false;
 static int skips;
+static bool verbose = false;
 
 struct bpf_test {
 	const char *descr;
@@ -92,7 +93,8 @@ struct bpf_test {
 	enum {
 		UNDEF,
 		ACCEPT,
-		REJECT
+		REJECT,
+		VERBOSE_ACCEPT,
 	} result, result_unpriv;
 	enum bpf_prog_type prog_type;
 	uint8_t flags;
@@ -859,6 +861,36 @@ static int do_prog_test_run(int fd_prog, bool unpriv, uint32_t expected_val,
 	return 0;
 }
 
+static bool cmp_str_seq(const char *log, const char *exp)
+{
+	char needle[80];
+	const char *p, *q;
+	int len;
+
+	do {
+		p = strchr(exp, '\t');
+		if (!p)
+			p = exp + strlen(exp);
+
+		len = p - exp;
+		if (len >= sizeof(needle) || !len) {
+			printf("FAIL\nTestcase bug\n");
+			return false;
+		}
+		strncpy(needle, exp, len);
+		needle[len] = 0;
+		q = strstr(log, needle);
+		if (!q) {
+			printf("FAIL\nUnexpected verifier log in successful load!\n"
+			       "EXP: %s\nRES:\n", needle);
+			return false;
+		}
+		log = q + len;
+		exp = p + 1;
+	} while (*p);
+	return true;
+}
+
 static void do_test_single(struct bpf_test *test, bool unpriv,
 			   int *passes, int *errors)
 {
@@ -897,14 +929,20 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
 		pflags |= BPF_F_STRICT_ALIGNMENT;
 	if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
 		pflags |= BPF_F_ANY_ALIGNMENT;
+	if (test->flags & ~3)
+		pflags |= test->flags;
 
+	expected_ret = unpriv && test->result_unpriv != UNDEF ?
+		       test->result_unpriv : test->result;
+	expected_err = unpriv && test->errstr_unpriv ?
+		       test->errstr_unpriv : test->errstr;
 	memset(&attr, 0, sizeof(attr));
 	attr.prog_type = prog_type;
 	attr.expected_attach_type = test->expected_attach_type;
 	attr.insns = prog;
 	attr.insns_cnt = prog_len;
 	attr.license = "GPL";
-	attr.log_level = 4;
+	attr.log_level = verbose || expected_ret == VERBOSE_ACCEPT ? 1 : 4;
 	attr.prog_flags = pflags;
 
 	fd_prog = bpf_load_program_xattr(&attr, bpf_vlog, sizeof(bpf_vlog));
@@ -914,14 +952,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
 		goto close_fds;
 	}
 
-	expected_ret = unpriv && test->result_unpriv != UNDEF ?
-		       test->result_unpriv : test->result;
-	expected_err = unpriv && test->errstr_unpriv ?
-		       test->errstr_unpriv : test->errstr;
-
 	alignment_prevented_execution = 0;
 
-	if (expected_ret == ACCEPT) {
+	if (expected_ret == ACCEPT || expected_ret == VERBOSE_ACCEPT) {
 		if (fd_prog < 0) {
 			printf("FAIL\nFailed to load prog '%s'!\n",
 			       strerror(errno));
@@ -932,6 +965,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
 		    (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS))
 			alignment_prevented_execution = 1;
 #endif
+		if (expected_ret == VERBOSE_ACCEPT && !cmp_str_seq(bpf_vlog, expected_err)) {
+			goto fail_log;
+		}
 	} else {
 		if (fd_prog >= 0) {
 			printf("FAIL\nUnexpected success to load!\n");
@@ -957,6 +993,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
 		}
 	}
 
+	if (verbose)
+		printf(", verifier log:\n%s", bpf_vlog);
+
 	run_errs = 0;
 	run_successes = 0;
 	if (!alignment_prevented_execution && fd_prog >= 0) {
@@ -1097,17 +1136,24 @@ int main(int argc, char **argv)
 {
 	unsigned int from = 0, to = ARRAY_SIZE(tests);
 	bool unpriv = !is_admin();
+	int arg = 1;
+
+	if (argc > 1 && strcmp(argv[1], "-v") == 0) {
+		arg++;
+		verbose = true;
+		argc--;
+	}
 
 	if (argc == 3) {
-		unsigned int l = atoi(argv[argc - 2]);
-		unsigned int u = atoi(argv[argc - 1]);
+		unsigned int l = atoi(argv[arg]);
+		unsigned int u = atoi(argv[arg + 1]);
 
 		if (l < to && u < to) {
 			from = l;
 			to   = u + 1;
 		}
 	} else if (argc == 2) {
-		unsigned int t = atoi(argv[argc - 1]);
+		unsigned int t = atoi(argv[arg]);
 
 		if (t < to) {
 			from = t;
tools/testing/selftests/bpf/verifier/precise.c new file +117 -0

117 lines not on this page · raw message

Signature · 1 line
2.20.0
author maintainer
#9 lore raw

PATCH 4/4 selftests/bpf: add precision tracking test

In reply to Alexei Starovoitov

Copy-paste of existing test
"calls: cross frame pruning - liveness propagation" but ran with different parentage chain heuristic which stresses different path in precision tracking logic.

---
This test will be failing without this fix
https://patchwork.ozlabs.org/patch/1151172/

---
 .../testing/selftests/bpf/verifier/precise.c  | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
tools/testing/selftests/bpf/verifier/precise.c +25 -0
index a20953c23721..a455a4a71f11 100644
@@ -115,3 +115,28 @@
 	regs=300 stack=0 before 17\
 	parent already had regs=0 stack=0 marks",
 },
+{
+	"precise: cross frame pruning",
+	.insns = {
+	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32),
+	BPF_MOV64_IMM(BPF_REG_8, 0),
+	BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+	BPF_MOV64_IMM(BPF_REG_8, 1),
+	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_prandom_u32),
+	BPF_MOV64_IMM(BPF_REG_9, 0),
+	BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+	BPF_MOV64_IMM(BPF_REG_9, 1),
+	BPF_MOV64_REG(BPF_REG_1, BPF_REG_0),
+	BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 1, 0, 4),
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_8, 1, 1),
+	BPF_LDX_MEM(BPF_B, BPF_REG_1, BPF_REG_2, 0),
+	BPF_MOV64_IMM(BPF_REG_0, 0),
+	BPF_EXIT_INSN(),
+	BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 0),
+	BPF_EXIT_INSN(),
+	},
+	.prog_type = BPF_PROG_TYPE_XDP,
+	.flags = BPF_F_TEST_STATE_FREQ,
+	.errstr = "!read_ok",
+	.result = REJECT,
+},
Signature · 1 line
2.20.0
Acked-by on v1 1/4
#2 lore raw

Re: [PATCH bpf-next 1/4] bpf: introduce verifier internal test flag

In reply to Alexei Starovoitov
Quoted 5 lines · Alexei Starovoitov

Introduce BPF_F_TEST_STATE_FREQ flag to stress test parentage chain and state pruning.

Quoted 71 lines
---
 include/linux/bpf_verifier.h | 1 +
 include/uapi/linux/bpf.h     | 3 +++
 kernel/bpf/syscall.c         | 1 +
 kernel/bpf/verifier.c        | 5 ++++-
 4 files changed, 9 insertions(+), 1 deletion(-)
include/linux/bpf_verifier.h +1 -0
index 5fe99f322b1c..26a6d58ca78c 100644
@@ -355,6 +355,7 @@ struct bpf_verifier_env {
        struct bpf_verifier_stack_elem *head; /* stack of verifier states to be processed */
        int stack_size;                 /* number of states to be processed */
        bool strict_alignment;          /* perform strict pointer alignment checks */
+       bool test_state_freq;           /* test verifier with different pruning frequency */
        struct bpf_verifier_state *cur_state; /* current verifier state */
        struct bpf_verifier_state_list **explored_states; /* search pruning optimization */
        struct bpf_verifier_state_list *free_list;
include/uapi/linux/bpf.h +3 -0
index b5889257cc33..5d2fb183ee2d 100644
@@ -285,6 +285,9 @@ enum bpf_attach_type {
  */
 #define BPF_F_TEST_RND_HI32    (1U << 2)
 
+/* The verifier internal test flag. Behavior is undefined */
+#define BPF_F_TEST_STATE_FREQ  (1U << 3)
+
 /* When BPF ldimm64's insn[0].src_reg != 0 then this can have
  * two extensions:
  *
kernel/bpf/syscall.c +1 -0
index c0f62fd67c6b..ca60eafa6922 100644
@@ -1629,6 +1629,7 @@ static int bpf_prog_load(union bpf_attr *attr, union bpf_attr __user *uattr)
 
        if (attr->prog_flags & ~(BPF_F_STRICT_ALIGNMENT |
                                 BPF_F_ANY_ALIGNMENT |
+                                BPF_F_TEST_STATE_FREQ |
                                 BPF_F_TEST_RND_HI32))
                return -EINVAL;
 
kernel/bpf/verifier.c +4 -2
index 16d66bd7af09..3fb50757e812 100644
@@ -7223,7 +7223,7 @@ static int is_state_visited(struct bpf_verifier_env *env, int insn_idx)
        struct bpf_verifier_state_list *sl, **pprev;
        struct bpf_verifier_state *cur = env->cur_state, *new;
        int i, j, err, states_cnt = 0;
-       bool add_new_state = false;
+       bool add_new_state = env->test_state_freq ? true : false;
 
        cur->last_insn_idx = env->prev_insn_idx;
        if (!env->insn_aux_data[insn_idx].prune_point)
@@ -9263,6 +9263,9 @@ int bpf_check(struct bpf_prog **prog, union bpf_attr *attr,
 
        env->allow_ptr_leaks = is_priv;
 
+       if (is_priv)
+               env->test_state_freq = attr->prog_flags & BPF_F_TEST_STATE_FREQ;
+
        ret = replace_map_fd_with_map_ptr(env);
        if (ret < 0)
                goto skip_full_check;
--

2.20.0

#6 lore raw

Re: [PATCH bpf-next 3/4] selftests/bpf: verifier precise tests

In reply to Alexei Starovoitov
Quoted 34 lines · Alexei Starovoitov

Use BPF_F_TEST_STATE_FREQ flag to check that precision tracking works as expected by comparing every step it takes.

---
 tools/testing/selftests/bpf/test_verifier.c   |  68 ++++++++--
 .../testing/selftests/bpf/verifier/precise.c  | 117 ++++++++++++++++++
 2 files changed, 174 insertions(+), 11 deletions(-)
 create mode 100644 tools/testing/selftests/bpf/verifier/precise.c
tools/testing/selftests/bpf/test_verifier.c +3 -1
index 44e2d640b088..d27fd929abb9 100644
@@ -61,6 +61,7 @@
 #define UNPRIV_SYSCTL "kernel/unprivileged_bpf_disabled"
 static bool unpriv_disabled = false;
 static int skips;
+static bool verbose = false;
 
 struct bpf_test {
        const char *descr;
@@ -92,7 +93,8 @@ struct bpf_test {
        enum {
                UNDEF,
                ACCEPT,
-               REJECT
+               REJECT,
+               VERBOSE_ACCEPT,
        } result, result_unpriv;
        enum bpf_prog_type prog_type;
        uint8_t flags;

tools/testing/selftests/bpf/test_verifier.c static int do_prog_test_run(int fd_prog, bool unpriv, uint32_t expected_val, · line 864

Quoted 4 lines
tools/testing/selftests/bpf/test_verifier.c +1 -0
@@ -859,6 +861,36 @@ static int do_prog_test_run(int fd_prog, bool unpriv, uint32_t expected_val,
        return 0;
 }
 
+static bool cmp_str_seq(const char *log, const char *exp)

Maybe call it str_str_seq()?

Quoted 33 lines
tools/testing/selftests/bpf/test_verifier.c +29 -0
+{
+       char needle[80];
+       const char *p, *q;
+       int len;
+
+       do {
+               p = strchr(exp, '\t');
+               if (!p)
+                       p = exp + strlen(exp);
+
+               len = p - exp;
+               if (len >= sizeof(needle) || !len) {
+                       printf("FAIL\nTestcase bug\n");
+                       return false;
+               }
+               strncpy(needle, exp, len);
+               needle[len] = 0;
+               q = strstr(log, needle);
+               if (!q) {
+                       printf("FAIL\nUnexpected verifier log in successful load!\n"
+                              "EXP: %s\nRES:\n", needle);
+                       return false;
+               }
+               log = q + len;
+               exp = p + 1;
+       } while (*p);
+       return true;
+}
+
 static void do_test_single(struct bpf_test *test, bool unpriv,
                           int *passes, int *errors)
 {

tools/testing/selftests/bpf/test_verifier.c static void do_test_single(struct bpf_test *test, bool unpriv, · line 933

Quoted 5 lines
tools/testing/selftests/bpf/test_verifier.c +2 -0
@@ -897,14 +929,20 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                pflags |= BPF_F_STRICT_ALIGNMENT;
        if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
                pflags |= BPF_F_ANY_ALIGNMENT;
+       if (test->flags & ~3)
+               pflags |= test->flags;

^^^^^^ why do we need these two lines?

Quoted 206 lines
tools/testing/selftests/bpf/test_verifier.c +22 -10
+       expected_ret = unpriv && test->result_unpriv != UNDEF ?
+                      test->result_unpriv : test->result;
+       expected_err = unpriv && test->errstr_unpriv ?
+                      test->errstr_unpriv : test->errstr;
        memset(&attr, 0, sizeof(attr));
        attr.prog_type = prog_type;
        attr.expected_attach_type = test->expected_attach_type;
        attr.insns = prog;
        attr.insns_cnt = prog_len;
        attr.license = "GPL";
-       attr.log_level = 4;
+       attr.log_level = verbose || expected_ret == VERBOSE_ACCEPT ? 1 : 4;
        attr.prog_flags = pflags;
 
        fd_prog = bpf_load_program_xattr(&attr, bpf_vlog, sizeof(bpf_vlog));
@@ -914,14 +952,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                goto close_fds;
        }
 
-       expected_ret = unpriv && test->result_unpriv != UNDEF ?
-                      test->result_unpriv : test->result;
-       expected_err = unpriv && test->errstr_unpriv ?
-                      test->errstr_unpriv : test->errstr;
-
        alignment_prevented_execution = 0;
 
-       if (expected_ret == ACCEPT) {
+       if (expected_ret == ACCEPT || expected_ret == VERBOSE_ACCEPT) {
                if (fd_prog < 0) {
                        printf("FAIL\nFailed to load prog '%s'!\n",
                               strerror(errno));
@@ -932,6 +965,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                    (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS))
                        alignment_prevented_execution = 1;
 #endif
+               if (expected_ret == VERBOSE_ACCEPT && !cmp_str_seq(bpf_vlog, expected_err)) {
+                       goto fail_log;
+               }
        } else {
                if (fd_prog >= 0) {
                        printf("FAIL\nUnexpected success to load!\n");
@@ -957,6 +993,9 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                }
        }
 
+       if (verbose)
+               printf(", verifier log:\n%s", bpf_vlog);
+
        run_errs = 0;
        run_successes = 0;
        if (!alignment_prevented_execution && fd_prog >= 0) {
@@ -1097,17 +1136,24 @@ int main(int argc, char **argv)
 {
        unsigned int from = 0, to = ARRAY_SIZE(tests);
        bool unpriv = !is_admin();
+       int arg = 1;
+
+       if (argc > 1 && strcmp(argv[1], "-v") == 0) {
+               arg++;
+               verbose = true;
+               argc--;
+       }
 
        if (argc == 3) {
-               unsigned int l = atoi(argv[argc - 2]);
-               unsigned int u = atoi(argv[argc - 1]);
+               unsigned int l = atoi(argv[arg]);
+               unsigned int u = atoi(argv[arg + 1]);
 
                if (l < to && u < to) {
                        from = l;
                        to   = u + 1;
                }
        } else if (argc == 2) {
-               unsigned int t = atoi(argv[argc - 1]);
+               unsigned int t = atoi(argv[arg]);
 
                if (t < to) {
                        from = t;
tools/testing/selftests/bpf/verifier/precise.c new file +117 -1
new file mode 100644
index 000000000000..a20953c23721
@@ -0,0 +1,117 @@
+{
+       "precise: test 1",
+       .insns = {
+       BPF_MOV64_IMM(BPF_REG_0, 1),
+       BPF_LD_MAP_FD(BPF_REG_6, 0),
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+       BPF_ST_MEM(BPF_DW, BPF_REG_FP, -8, 0),
+       BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+       BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),
+
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+       BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+       BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
+
+       BPF_ALU64_REG(BPF_SUB, BPF_REG_9, BPF_REG_8), /* map_value_ptr -= map_value_ptr */
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_9),
+       BPF_JMP_IMM(BPF_JLT, BPF_REG_2, 8, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1), /* R2=inv(umin=1, umax=8) */
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8),
+       BPF_MOV64_IMM(BPF_REG_3, 0),
+       BPF_EMIT_CALL(BPF_FUNC_probe_read),
+       BPF_EXIT_INSN(),
+       },
+       .prog_type = BPF_PROG_TYPE_TRACEPOINT,
+       .fixup_map_array_48b = { 1 },
+       .result = VERBOSE_ACCEPT,
+       .errstr =
+       "26: (85) call bpf_probe_read#4\
+       last_idx 26 first_idx 20\
+       regs=4 stack=0 before 25\
+       regs=4 stack=0 before 24\
+       regs=4 stack=0 before 23\
+       regs=4 stack=0 before 22\
+       regs=4 stack=0 before 20\
+       parent didn't have regs=4 stack=0 marks\
+       last_idx 19 first_idx 10\
+       regs=4 stack=0 before 19\
+       regs=200 stack=0 before 18\
+       regs=300 stack=0 before 17\
+       regs=201 stack=0 before 15\
+       regs=201 stack=0 before 14\
+       regs=200 stack=0 before 13\
+       regs=200 stack=0 before 12\
+       regs=200 stack=0 before 11\
+       regs=200 stack=0 before 10\
+       parent already had regs=0 stack=0 marks",
+},
+{
+       "precise: test 2",
+       .insns = {
+       BPF_MOV64_IMM(BPF_REG_0, 1),
+       BPF_LD_MAP_FD(BPF_REG_6, 0),
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+       BPF_ST_MEM(BPF_DW, BPF_REG_FP, -8, 0),
+       BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+       BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_MOV64_REG(BPF_REG_9, BPF_REG_0),
+
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+       BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+       BPF_JMP_IMM(BPF_JNE, BPF_REG_0, 0, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_MOV64_REG(BPF_REG_8, BPF_REG_0),
+
+       BPF_ALU64_REG(BPF_SUB, BPF_REG_9, BPF_REG_8), /* map_value_ptr -= map_value_ptr */
+       BPF_MOV64_REG(BPF_REG_2, BPF_REG_9),
+       BPF_JMP_IMM(BPF_JLT, BPF_REG_2, 8, 1),
+       BPF_EXIT_INSN(),
+
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, 1), /* R2=inv(umin=1, umax=8) */
+       BPF_MOV64_REG(BPF_REG_1, BPF_REG_FP),
+       BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8),
+       BPF_MOV64_IMM(BPF_REG_3, 0),
+       BPF_EMIT_CALL(BPF_FUNC_probe_read),
+       BPF_EXIT_INSN(),
+       },
+       .prog_type = BPF_PROG_TYPE_TRACEPOINT,
+       .fixup_map_array_48b = { 1 },
+       .result = VERBOSE_ACCEPT,
+       .flags = BPF_F_TEST_STATE_FREQ,
+       .errstr =
+       "26: (85) call bpf_probe_read#4\
+       last_idx 26 first_idx 22\
+       regs=4 stack=0 before 25\
+       regs=4 stack=0 before 24\
+       regs=4 stack=0 before 23\
+       regs=4 stack=0 before 22\
+       parent didn't have regs=4 stack=0 marks\
+       last_idx 20 first_idx 20\
+       regs=4 stack=0 before 20\
+       parent didn't have regs=4 stack=0 marks\
+       last_idx 19 first_idx 17\
+       regs=4 stack=0 before 19\
+       regs=200 stack=0 before 18\
+       regs=300 stack=0 before 17\
+       parent already had regs=0 stack=0 marks",
+},
--

2.20.0

#7 lore raw

Re: [PATCH bpf-next 3/4] selftests/bpf: verifier precise tests

In reply to Song Liu
Quoted 10 lines · Song Liu
Quoted 7 lines · Alexei Starovoitov

Use BPF_F_TEST_STATE_FREQ flag to check that precision tracking works as expected by comparing every step it takes.

+static bool cmp_str_seq(const char *log, const char *exp)

Maybe call it str_str_seq()?

imo cmp*() returns the result of comparison.
Which is either boolean or -1,0,1.
Whereas str*() should return the address, index, or offset. Hence I used cmp_ prefix here.

Quoted 10 lines

tools/testing/selftests/bpf/test_verifier.c static void do_test_single(struct bpf_test *test, bool unpriv, · line 933

Quoted 9 lines

static void do_test_single(struct bpf_test *test, bool unpriv,
int *passes, int *errors)
{

tools/testing/selftests/bpf/test_verifier.c +2 -0
@@ -897,14 +929,20 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
                pflags |= BPF_F_STRICT_ALIGNMENT;
        if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
                pflags |= BPF_F_ANY_ALIGNMENT;
+       if (test->flags & ~3)
+               pflags |= test->flags;

^^^^^^ why do we need these two lines?

To pass flags from test into attr.prog_flags.
Older F_NEEDS_* and F_LOAD_* may use some cleanup and can be removed, but it would be a different patch.

Acked-by
#8 lore raw

Re: [PATCH bpf-next 3/4] selftests/bpf: verifier precise tests

Quoted 12 lines · Alexei Starovoitov
Quoted 7 lines · Song Liu
Quoted 6 lines · Alexei Starovoitov

Use BPF_F_TEST_STATE_FREQ flag to check that precision tracking works as expected by comparing every step it takes.

Quoted 8 lines
Quoted 3 lines
Quoted 1 line

+static bool cmp_str_seq(const char *log, const char *exp)

Maybe call it str_str_seq()?

imo cmp*() returns the result of comparison.
Which is either boolean or -1,0,1.
Whereas str*() should return the address, index, or offset. Hence I used cmp_ prefix here.

Good point. I didn't think about this.

Quoted 12 lines
Quoted 11 lines

tools/testing/selftests/bpf/test_verifier.c static void do_test_single(struct bpf_test *test, bool unpriv, · line 933

Quoted 10 lines

static void do_test_single(struct bpf_test *test, bool unpriv,
int *passes, int *errors)
{

tools/testing/selftests/bpf/test_verifier.c +2 -0
@@ -897,14 +929,20 @@ static void do_test_single(struct bpf_test *test, bool unpriv,
               pflags |= BPF_F_STRICT_ALIGNMENT;
       if (test->flags & F_NEEDS_EFFICIENT_UNALIGNED_ACCESS)
               pflags |= BPF_F_ANY_ALIGNMENT;
+       if (test->flags & ~3)
+               pflags |= test->flags;

^^^^^^ why do we need these two lines?

Quoted 3 lines

To pass flags from test into attr.prog_flags.
Older F_NEEDS_* and F_LOAD_* may use some cleanup and can be removed, but it would be a different patch.

Sounds good.

Thanks!

maintainer Applied
#11 lore raw
In reply to Alexei Starovoitov
Quoted 16 lines · Alexei Starovoitov

Add few additional tests for precision tracking in the verifier.

Alexei Starovoitov (4):
bpf: introduce verifier internal test flag
tools/bpf: sync bpf.h
selftests/bpf: verifier precise tests
selftests/bpf: add precision tracking test

  include/linux/bpf_verifier.h                  |   1 +
  include/uapi/linux/bpf.h                      |   3 +
  kernel/bpf/syscall.c                          |   1 +
  kernel/bpf/verifier.c                         |   5 +-
  tools/include/uapi/linux/bpf.h                |   3 +
  tools/testing/selftests/bpf/test_verifier.c   |  68 +++++++--
  .../testing/selftests/bpf/verifier/precise.c  | 142 ++++++++++++++++++
  7 files changed, 211 insertions(+), 12 deletions(-)
Quoted 2 lines

create mode 100644 tools/testing/selftests/bpf/verifier/precise.c

Applied, thanks!