Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf-next

Daniel Borkmann says:

====================
pull-request: bpf-next 2017-12-28

The following pull-request contains BPF updates for your *net-next* tree.

The main changes are:

1) Fix incorrect state pruning related to recognition of zero initialized
   stack slots, where stacksafe exploration would mistakenly return a
   positive pruning verdict too early ignoring other slots, from Gianluca.

2) Various BPF to BPF calls related follow-up fixes. Fix an off-by-one
   in maximum call depth check, and rework maximum stack depth tracking
   logic to fix a bypass of the total stack size check reported by Jann.
   Also fix a bug in arm64 JIT where prog->jited_len was uninitialized.
   Addition of various test cases to BPF selftests, from Alexei.

3) Addition of a BPF selftest to test_verifier that is related to BPF to
   BPF calls which demonstrates a late caller stack size increase and
   thus out of bounds access. Fixed above in 2). Test case from Jann.

4) Addition of correlating BPF helper calls, BPF to BPF calls as well
   as BPF maps to bpftool xlated dump in order to allow for better
   BPF program introspection and debugging, from Daniel.

5) Fixing several bugs in BPF to BPF calls kallsyms handling in order
   to get it actually to work for subprogs, from Daniel.

6) Extending sparc64 JIT support for BPF to BPF calls and fix a couple
   of build errors for libbpf on sparc64, from David.

7) Allow narrower context access for BPF dev cgroup typed programs in
   order to adapt to LLVM code generation. Also adjust memlock rlimit
   in the test_dev_cgroup BPF selftest, from Yonghong.

8) Add netdevsim Kconfig entry to BPF selftests since test_offload.py
   relies on netdevsim device being available, from Jakub.

9) Reduce scope of xdp_do_generic_redirect_map() to being static,
   from Xiongwei.

10) Minor cleanups and spelling fixes in BPF verifier, from Colin.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

5 files changed, 425 insertions, 12 deletions

diff --git a/tools/bpf/bpftool/prog.c b/tools/bpf/bpftool/prog.c
index 037484ceaeaf..42ee8892549c 100644
--- a/tools/bpf/bpftool/prog.c
+++ b/tools/bpf/bpftool/prog.c
@@ -401,6 +401,88 @@ static int do_show(int argc, char **argv)
         return err;
 }
 
+#define SYM_MAX_NAME    256
+
+struct kernel_sym {
+        unsigned long address;
+        char name[SYM_MAX_NAME];
+};
+
+struct dump_data {
+        unsigned long address_call_base;
+        struct kernel_sym *sym_mapping;
+        __u32 sym_count;
+        char scratch_buff[SYM_MAX_NAME];
+};
+
+static int kernel_syms_cmp(const void *sym_a, const void *sym_b)
+{
+        return ((struct kernel_sym *)sym_a)->address -
+               ((struct kernel_sym *)sym_b)->address;
+}
+
+static void kernel_syms_load(struct dump_data *dd)
+{
+        struct kernel_sym *sym;
+        char buff[256];
+        void *tmp, *address;
+        FILE *fp;
+
+        fp = fopen("/proc/kallsyms", "r");
+        if (!fp)
+                return;
+
+        while (!feof(fp)) {
+                if (!fgets(buff, sizeof(buff), fp))
+                        break;
+                tmp = realloc(dd->sym_mapping,
+                              (dd->sym_count + 1) *
+                              sizeof(*dd->sym_mapping));
+                if (!tmp) {
+out:
+                        free(dd->sym_mapping);
+                        dd->sym_mapping = NULL;
+                        fclose(fp);
+                        return;
+                }
+                dd->sym_mapping = tmp;
+                sym = &dd->sym_mapping[dd->sym_count];
+                if (sscanf(buff, "%p %*c %s", &address, sym->name) != 2)
+                        continue;
+                sym->address = (unsigned long)address;
+                if (!strcmp(sym->name, "__bpf_call_base")) {
+                        dd->address_call_base = sym->address;
+                        /* sysctl kernel.kptr_restrict was set */
+                        if (!sym->address)
+                                goto out;
+                }
+                if (sym->address)
+                        dd->sym_count++;
+        }
+
+        fclose(fp);
+
+        qsort(dd->sym_mapping, dd->sym_count,
+              sizeof(*dd->sym_mapping), kernel_syms_cmp);
+}
+
+static void kernel_syms_destroy(struct dump_data *dd)
+{
+        free(dd->sym_mapping);
+}
+
+static struct kernel_sym *kernel_syms_search(struct dump_data *dd,
+                                             unsigned long key)
+{
+        struct kernel_sym sym = {
+                .address = key,
+        };
+
+        return dd->sym_mapping ?
+               bsearch(&sym, dd->sym_mapping, dd->sym_count,
+                       sizeof(*dd->sym_mapping), kernel_syms_cmp) : NULL;
+}
+
 static void print_insn(struct bpf_verifier_env *env, const char *fmt, ...)
 {
         va_list args;
@@ -410,8 +492,71 @@ static void print_insn(struct bpf_verifier_env *env, const char *fmt, ...)
         va_end(args);
 }
 
-static void dump_xlated_plain(void *buf, unsigned int len, bool opcodes)
+static const char *print_call_pcrel(struct dump_data *dd,
+                                    struct kernel_sym *sym,
+                                    unsigned long address,
+                                    const struct bpf_insn *insn)
 {
+        if (sym)
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "%+d#%s", insn->off, sym->name);
+        else
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "%+d#0x%lx", insn->off, address);
+        return dd->scratch_buff;
+}
+
+static const char *print_call_helper(struct dump_data *dd,
+                                     struct kernel_sym *sym,
+                                     unsigned long address)
+{
+        if (sym)
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "%s", sym->name);
+        else
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "0x%lx", address);
+        return dd->scratch_buff;
+}
+
+static const char *print_call(void *private_data,
+                              const struct bpf_insn *insn)
+{
+        struct dump_data *dd = private_data;
+        unsigned long address = dd->address_call_base + insn->imm;
+        struct kernel_sym *sym;
+
+        sym = kernel_syms_search(dd, address);
+        if (insn->src_reg == BPF_PSEUDO_CALL)
+                return print_call_pcrel(dd, sym, address, insn);
+        else
+                return print_call_helper(dd, sym, address);
+}
+
+static const char *print_imm(void *private_data,
+                             const struct bpf_insn *insn,
+                             __u64 full_imm)
+{
+        struct dump_data *dd = private_data;
+
+        if (insn->src_reg == BPF_PSEUDO_MAP_FD)
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "map[id:%u]", insn->imm);
+        else
+                snprintf(dd->scratch_buff, sizeof(dd->scratch_buff),
+                         "0x%llx", (unsigned long long)full_imm);
+        return dd->scratch_buff;
+}
+
+static void dump_xlated_plain(struct dump_data *dd, void *buf,
+                              unsigned int len, bool opcodes)
+{
+        const struct bpf_insn_cbs cbs = {
+                .cb_print       = print_insn,
+                .cb_call        = print_call,
+                .cb_imm         = print_imm,
+                .private_data   = dd,
+        };
         struct bpf_insn *insn = buf;
         bool double_insn = false;
         unsigned int i;
@@ -425,7 +570,7 @@ static void dump_xlated_plain(void *buf, unsigned int len, bool opcodes)
                 double_insn = insn[i].code == (BPF_LD | BPF_IMM | BPF_DW);
 
                 printf("% 4d: ", i);
-                print_bpf_insn(print_insn, NULL, insn + i, true);
+                print_bpf_insn(&cbs, NULL, insn + i, true);
 
                 if (opcodes) {
                         printf("       ");
@@ -454,8 +599,15 @@ static void print_insn_json(struct bpf_verifier_env *env, const char *fmt, ...)
         va_end(args);
 }
 
-static void dump_xlated_json(void *buf, unsigned int len, bool opcodes)
+static void dump_xlated_json(struct dump_data *dd, void *buf,
+                             unsigned int len, bool opcodes)
 {
+        const struct bpf_insn_cbs cbs = {
+                .cb_print       = print_insn_json,
+                .cb_call        = print_call,
+                .cb_imm         = print_imm,
+                .private_data   = dd,
+        };
         struct bpf_insn *insn = buf;
         bool double_insn = false;
         unsigned int i;
@@ -470,7 +622,7 @@ static void dump_xlated_json(void *buf, unsigned int len, bool opcodes)
 
                 jsonw_start_object(json_wtr);
                 jsonw_name(json_wtr, "disasm");
-                print_bpf_insn(print_insn_json, NULL, insn + i, true);
+                print_bpf_insn(&cbs, NULL, insn + i, true);
 
                 if (opcodes) {
                         jsonw_name(json_wtr, "opcodes");
@@ -505,6 +657,7 @@ static void dump_xlated_json(void *buf, unsigned int len, bool opcodes)
 static int do_dump(int argc, char **argv)
 {
         struct bpf_prog_info info = {};
+        struct dump_data dd = {};
         __u32 len = sizeof(info);
         unsigned int buf_size;
         char *filepath = NULL;
@@ -592,6 +745,14 @@ static int do_dump(int argc, char **argv)
                 goto err_free;
         }
 
+        if ((member_len == &info.jited_prog_len &&
+             info.jited_prog_insns == 0) ||
+            (member_len == &info.xlated_prog_len &&
+             info.xlated_prog_insns == 0)) {
+                p_err("error retrieving insn dump: kernel.kptr_restrict set?");
+                goto err_free;
+        }
+
         if (filepath) {
                 fd = open(filepath, O_WRONLY | O_CREAT | O_TRUNC, 0600);
                 if (fd < 0) {
@@ -608,17 +769,19 @@ static int do_dump(int argc, char **argv)
                         goto err_free;
                 }
         } else {
-                if (member_len == &info.jited_prog_len)
+                if (member_len == &info.jited_prog_len) {
                         disasm_print_insn(buf, *member_len, opcodes);
-                else
+                } else {
+                        kernel_syms_load(&dd);
                         if (json_output)
-                                dump_xlated_json(buf, *member_len, opcodes);
+                                dump_xlated_json(&dd, buf, *member_len, opcodes);
                         else
-                                dump_xlated_plain(buf, *member_len, opcodes);
+                                dump_xlated_plain(&dd, buf, *member_len, opcodes);
+                        kernel_syms_destroy(&dd);
+                }
         }
 
         free(buf);
-
         return 0;
 
 err_free:
diff --git a/tools/lib/bpf/libbpf.c b/tools/lib/bpf/libbpf.c
index 5b83875b3594..e9c4b7cabcf2 100644
--- a/tools/lib/bpf/libbpf.c
+++ b/tools/lib/bpf/libbpf.c
@@ -910,8 +910,9 @@ bpf_program__collect_reloc(struct bpf_program *prog, GElf_Shdr *shdr,
                                    GELF_R_SYM(rel.r_info));
                         return -LIBBPF_ERRNO__FORMAT;
                 }
-                pr_debug("relo for %ld value %ld name %d\n",
-                         rel.r_info >> 32, sym.st_value, sym.st_name);
+                pr_debug("relo for %lld value %lld name %d\n",
+                         (long long) (rel.r_info >> 32),
+                         (long long) sym.st_value, sym.st_name);
 
                 if (sym.st_shndx != maps_shndx && sym.st_shndx != text_shndx) {
                         pr_warning("Program '%s' contains non-map related relo data pointing to section %u\n",
diff --git a/tools/testing/selftests/bpf/config b/tools/testing/selftests/bpf/config
index 9d4897317c77..983dd25d49f4 100644
--- a/tools/testing/selftests/bpf/config
+++ b/tools/testing/selftests/bpf/config
@@ -4,3 +4,4 @@ CONFIG_NET_CLS_BPF=m
 CONFIG_BPF_EVENTS=y
 CONFIG_TEST_BPF=m
 CONFIG_CGROUP_BPF=y
+CONFIG_NETDEVSIM=m
diff --git a/tools/testing/selftests/bpf/test_dev_cgroup.c b/tools/testing/selftests/bpf/test_dev_cgroup.c
index 02c85d6c89b0..c1535b34f14f 100644
--- a/tools/testing/selftests/bpf/test_dev_cgroup.c
+++ b/tools/testing/selftests/bpf/test_dev_cgroup.c
@@ -10,6 +10,8 @@
 #include <string.h>
 #include <errno.h>
 #include <assert.h>
+#include <sys/time.h>
+#include <sys/resource.h>
 
 #include <linux/bpf.h>
 #include <bpf/bpf.h>
@@ -23,15 +25,19 @@
 
 int main(int argc, char **argv)
 {
+        struct rlimit limit  = { RLIM_INFINITY, RLIM_INFINITY };
         struct bpf_object *obj;
         int error = EXIT_FAILURE;
         int prog_fd, cgroup_fd;
         __u32 prog_cnt;
 
+        if (setrlimit(RLIMIT_MEMLOCK, &limit) < 0)
+                perror("Unable to lift memlock rlimit");
+
         if (bpf_prog_load(DEV_CGROUP_PROG, BPF_PROG_TYPE_CGROUP_DEVICE,
                           &obj, &prog_fd)) {
                 printf("Failed to load DEV_CGROUP program\n");
-                goto err;
+                goto out;
         }
 
         if (setup_cgroup_environment()) {
@@ -89,5 +95,6 @@ int main(int argc, char **argv)
 err:
         cleanup_cgroup_environment();
 
+out:
         return error;
 }
diff --git a/tools/testing/selftests/bpf/test_verifier.c b/tools/testing/selftests/bpf/test_verifier.c
index d38334abb990..543847957fdd 100644
--- a/tools/testing/selftests/bpf/test_verifier.c
+++ b/tools/testing/selftests/bpf/test_verifier.c
@@ -9273,6 +9273,196 @@ static struct bpf_test tests[] = {
                 .result = ACCEPT,
         },
         {
+                "calls: stack overflow using two frames (pre-call access)",
+                .insns = {
+                        /* prog 1 */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1),
+                        BPF_EXIT_INSN(),
+
+                        /* prog 2 */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                .errstr = "combined stack size",
+                .result = REJECT,
+        },
+        {
+                "calls: stack overflow using two frames (post-call access)",
+                .insns = {
+                        /* prog 1 */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 2),
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_EXIT_INSN(),
+
+                        /* prog 2 */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                .errstr = "combined stack size",
+                .result = REJECT,
+        },
+        {
+                "calls: stack depth check using three frames. test1",
+                .insns = {
+                        /* main */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 5), /* call B */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -32, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                        /* A */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0),
+                        BPF_EXIT_INSN(),
+                        /* B */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -3), /* call A */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                /* stack_main=32, stack_A=256, stack_B=64
+                 * and max(main+A, main+A+B) < 512
+                 */
+                .result = ACCEPT,
+        },
+        {
+                "calls: stack depth check using three frames. test2",
+                .insns = {
+                        /* main */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 5), /* call B */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -32, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                        /* A */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0),
+                        BPF_EXIT_INSN(),
+                        /* B */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -3), /* call A */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                /* stack_main=32, stack_A=64, stack_B=256
+                 * and max(main+A, main+A+B) < 512
+                 */
+                .result = ACCEPT,
+        },
+        {
+                "calls: stack depth check using three frames. test3",
+                .insns = {
+                        /* main */
+                        BPF_MOV64_REG(BPF_REG_6, BPF_REG_1),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 6), /* call A */
+                        BPF_MOV64_REG(BPF_REG_1, BPF_REG_6),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 8), /* call B */
+                        BPF_JMP_IMM(BPF_JGE, BPF_REG_6, 0, 1),
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -64, 0),
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                        /* A */
+                        BPF_JMP_IMM(BPF_JLT, BPF_REG_1, 10, 1),
+                        BPF_EXIT_INSN(),
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -224, 0),
+                        BPF_JMP_IMM(BPF_JA, 0, 0, -3),
+                        /* B */
+                        BPF_JMP_IMM(BPF_JGT, BPF_REG_1, 2, 1),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, -6), /* call A */
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -256, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                /* stack_main=64, stack_A=224, stack_B=256
+                 * and max(main+A, main+A+B) > 512
+                 */
+                .errstr = "combined stack",
+                .result = REJECT,
+        },
+        {
+                "calls: stack depth check using three frames. test4",
+                /* void main(void) {
+                 *   func1(0);
+                 *   func1(1);
+                 *   func2(1);
+                 * }
+                 * void func1(int alloc_or_recurse) {
+                 *   if (alloc_or_recurse) {
+                 *     frame_pointer[-300] = 1;
+                 *   } else {
+                 *     func2(alloc_or_recurse);
+                 *   }
+                 * }
+                 * void func2(int alloc_or_recurse) {
+                 *   if (alloc_or_recurse) {
+                 *     frame_pointer[-300] = 1;
+                 *   }
+                 * }
+                 */
+                .insns = {
+                        /* main */
+                        BPF_MOV64_IMM(BPF_REG_1, 0),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 6), /* call A */
+                        BPF_MOV64_IMM(BPF_REG_1, 1),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 4), /* call A */
+                        BPF_MOV64_IMM(BPF_REG_1, 1),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 7), /* call B */
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                        /* A */
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 2),
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_EXIT_INSN(),
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call B */
+                        BPF_EXIT_INSN(),
+                        /* B */
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_1, 0, 1),
+                        BPF_ST_MEM(BPF_B, BPF_REG_10, -300, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                .result = REJECT,
+                .errstr = "combined stack",
+        },
+        {
+                "calls: stack depth check using three frames. test5",
+                .insns = {
+                        /* main */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call A */
+                        BPF_EXIT_INSN(),
+                        /* A */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call B */
+                        BPF_EXIT_INSN(),
+                        /* B */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call C */
+                        BPF_EXIT_INSN(),
+                        /* C */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call D */
+                        BPF_EXIT_INSN(),
+                        /* D */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call E */
+                        BPF_EXIT_INSN(),
+                        /* E */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call F */
+                        BPF_EXIT_INSN(),
+                        /* F */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call G */
+                        BPF_EXIT_INSN(),
+                        /* G */
+                        BPF_RAW_INSN(BPF_JMP|BPF_CALL, 0, 1, 0, 1), /* call H */
+                        BPF_EXIT_INSN(),
+                        /* H */
+                        BPF_MOV64_IMM(BPF_REG_0, 0),
+                        BPF_EXIT_INSN(),
+                },
+                .prog_type = BPF_PROG_TYPE_XDP,
+                .errstr = "call stack",
+                .result = REJECT,
+        },
+        {
                 "calls: spill into caller stack frame",
                 .insns = {
                         BPF_ST_MEM(BPF_DW, BPF_REG_10, -8, 0),
@@ -10258,6 +10448,57 @@ static struct bpf_test tests[] = {
                 .result = REJECT,
                 .prog_type = BPF_PROG_TYPE_XDP,
         },
+        {
+                "search pruning: all branches should be verified (nop operation)",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 11),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_0, 0),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_3, 0xbeef, 2),
+                        BPF_MOV64_IMM(BPF_REG_4, 0),
+                        BPF_JMP_A(1),
+                        BPF_MOV64_IMM(BPF_REG_4, 1),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_4, -16),
+                        BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_5, BPF_REG_10, -16),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_5, 0, 2),
+                        BPF_MOV64_IMM(BPF_REG_6, 0),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_6, 0, 0xdead),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map1 = { 3 },
+                .errstr = "R6 invalid mem access 'inv'",
+                .result = REJECT,
+                .prog_type = BPF_PROG_TYPE_TRACEPOINT,
+        },
+        {
+                "search pruning: all branches should be verified (invalid stack access)",
+                .insns = {
+                        BPF_MOV64_REG(BPF_REG_2, BPF_REG_10),
+                        BPF_ALU64_IMM(BPF_ADD, BPF_REG_2, -8),
+                        BPF_ST_MEM(BPF_DW, BPF_REG_2, 0, 0),
+                        BPF_LD_MAP_FD(BPF_REG_1, 0),
+                        BPF_EMIT_CALL(BPF_FUNC_map_lookup_elem),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_0, 0, 8),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_3, BPF_REG_0, 0),
+                        BPF_MOV64_IMM(BPF_REG_4, 0),
+                        BPF_JMP_IMM(BPF_JEQ, BPF_REG_3, 0xbeef, 2),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_4, -16),
+                        BPF_JMP_A(1),
+                        BPF_STX_MEM(BPF_DW, BPF_REG_10, BPF_REG_4, -24),
+                        BPF_EMIT_CALL(BPF_FUNC_ktime_get_ns),
+                        BPF_LDX_MEM(BPF_DW, BPF_REG_5, BPF_REG_10, -16),
+                        BPF_EXIT_INSN(),
+                },
+                .fixup_map1 = { 3 },
+                .errstr = "invalid read from stack off -16+0 size 8",
+                .result = REJECT,
+                .prog_type = BPF_PROG_TYPE_TRACEPOINT,
+        },
 };
 
 static int probe_filter_length(const struct bpf_insn *fp)