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

Daniel Borkmann says:

====================
pull-request: bpf-next 2019-04-12

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

The main changes are:

1) Improve BPF verifier scalability for large programs through two
   optimizations: i) remove verifier states that are not useful in pruning,
   ii) stop walking parentage chain once first LIVE_READ is seen. Combined
   gives approx 20x speedup. Increase limits for accepting large programs
   under root, and add various stress tests, from Alexei.

2) Implement global data support in BPF. This enables static global variables
   for .data, .rodata and .bss sections to be properly handled which allows
   for more natural program development. This also opens up the possibility
   to optimize program workflow by compiling ELFs only once and later only
   rewriting section data before reload, from Daniel and with test cases and
   libbpf refactoring from Joe.

3) Add config option to generate BTF type info for vmlinux as part of the
   kernel build process. DWARF debug info is converted via pahole to BTF.
   Latter relies on libbpf and makes use of BTF deduplication algorithm which
   results in 100x savings compared to DWARF data. Resulting .BTF section is
   typically about 2MB in size, from Andrii.

4) Add BPF verifier support for stack access with variable offset from
   helpers and add various test cases along with it, from Andrey.

5) Extend bpf_skb_adjust_room() growth BPF helper to mark inner MAC header
   so that L2 encapsulation can be used for tc tunnels, from Alan.

6) Add support for input __sk_buff context in BPF_PROG_TEST_RUN so that
   users can define a subset of allowed __sk_buff fields that get fed into
   the test program, from Stanislav.

7) Add bpf fs multi-dimensional array tests for BTF test suite and fix up
   various UBSAN warnings in bpftool, from Yonghong.

8) Generate a pkg-config file for libbpf, from Luca.

9) Dump program's BTF id in bpftool, from Prashant.

10) libbpf fix to use smaller BPF log buffer size for AF_XDP's XDP
    program, from Magnus.

11) kallsyms related fixes for the case when symbols are not present in
    BPF selftests and samples, from Daniel
====================

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

1 files changed, 96 insertions, 1 deletions

diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
index cf119c9b6f27..701e7e28ada3 100644
--- a/tools/lib/bpf/btf.c
+++ b/tools/lib/bpf/btf.c
@@ -24,6 +24,8 @@
                 ((k) == BTF_KIND_CONST) || \
                 ((k) == BTF_KIND_RESTRICT))
 
+#define IS_VAR(k) ((k) == BTF_KIND_VAR)
+
 static struct btf_type btf_void;
 
 struct btf {
@@ -212,6 +214,10 @@ static int btf_type_size(struct btf_type *t)
                 return base_size + vlen * sizeof(struct btf_member);
         case BTF_KIND_FUNC_PROTO:
                 return base_size + vlen * sizeof(struct btf_param);
+        case BTF_KIND_VAR:
+                return base_size + sizeof(struct btf_var);
+        case BTF_KIND_DATASEC:
+                return base_size + vlen * sizeof(struct btf_var_secinfo);
         default:
                 pr_debug("Unsupported BTF_KIND:%u\n", BTF_INFO_KIND(t->info));
                 return -EINVAL;
@@ -283,6 +289,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
                 case BTF_KIND_STRUCT:
                 case BTF_KIND_UNION:
                 case BTF_KIND_ENUM:
+                case BTF_KIND_DATASEC:
                         size = t->size;
                         goto done;
                 case BTF_KIND_PTR:
@@ -292,6 +299,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
                 case BTF_KIND_VOLATILE:
                 case BTF_KIND_CONST:
                 case BTF_KIND_RESTRICT:
+                case BTF_KIND_VAR:
                         type_id = t->type;
                         break;
                 case BTF_KIND_ARRAY:
@@ -326,7 +334,8 @@ int btf__resolve_type(const struct btf *btf, __u32 type_id)
         t = btf__type_by_id(btf, type_id);
         while (depth < MAX_RESOLVE_DEPTH &&
                !btf_type_is_void_or_null(t) &&
-               IS_MODIFIER(BTF_INFO_KIND(t->info))) {
+               (IS_MODIFIER(BTF_INFO_KIND(t->info)) ||
+                IS_VAR(BTF_INFO_KIND(t->info)))) {
                 type_id = t->type;
                 t = btf__type_by_id(btf, type_id);
                 depth++;
@@ -408,6 +417,92 @@ done:
         return btf;
 }
 
+static int compare_vsi_off(const void *_a, const void *_b)
+{
+        const struct btf_var_secinfo *a = _a;
+        const struct btf_var_secinfo *b = _b;
+
+        return a->offset - b->offset;
+}
+
+static int btf_fixup_datasec(struct bpf_object *obj, struct btf *btf,
+                             struct btf_type *t)
+{
+        __u32 size = 0, off = 0, i, vars = BTF_INFO_VLEN(t->info);
+        const char *name = btf__name_by_offset(btf, t->name_off);
+        const struct btf_type *t_var;
+        struct btf_var_secinfo *vsi;
+        struct btf_var *var;
+        int ret;
+
+        if (!name) {
+                pr_debug("No name found in string section for DATASEC kind.\n");
+                return -ENOENT;
+        }
+
+        ret = bpf_object__section_size(obj, name, &size);
+        if (ret || !size || (t->size && t->size != size)) {
+                pr_debug("Invalid size for section %s: %u bytes\n", name, size);
+                return -ENOENT;
+        }
+
+        t->size = size;
+
+        for (i = 0, vsi = (struct btf_var_secinfo *)(t + 1);
+             i < vars; i++, vsi++) {
+                t_var = btf__type_by_id(btf, vsi->type);
+                var = (struct btf_var *)(t_var + 1);
+
+                if (BTF_INFO_KIND(t_var->info) != BTF_KIND_VAR) {
+                        pr_debug("Non-VAR type seen in section %s\n", name);
+                        return -EINVAL;
+                }
+
+                if (var->linkage == BTF_VAR_STATIC)
+                        continue;
+
+                name = btf__name_by_offset(btf, t_var->name_off);
+                if (!name) {
+                        pr_debug("No name found in string section for VAR kind\n");
+                        return -ENOENT;
+                }
+
+                ret = bpf_object__variable_offset(obj, name, &off);
+                if (ret) {
+                        pr_debug("No offset found in symbol table for VAR %s\n", name);
+                        return -ENOENT;
+                }
+
+                vsi->offset = off;
+        }
+
+        qsort(t + 1, vars, sizeof(*vsi), compare_vsi_off);
+        return 0;
+}
+
+int btf__finalize_data(struct bpf_object *obj, struct btf *btf)
+{
+        int err = 0;
+        __u32 i;
+
+        for (i = 1; i <= btf->nr_types; i++) {
+                struct btf_type *t = btf->types[i];
+
+                /* Loader needs to fix up some of the things compiler
+                 * couldn't get its hands on while emitting BTF. This
+                 * is section size and global variable offset. We use
+                 * the info from the ELF itself for this purpose.
+                 */
+                if (BTF_INFO_KIND(t->info) == BTF_KIND_DATASEC) {
+                        err = btf_fixup_datasec(obj, btf, t);
+                        if (err)
+                                break;
+                }
+        }
+
+        return err;
+}
+
 int btf__load(struct btf *btf)
 {
         __u32 log_buf_size = BPF_LOG_BUF_SIZE;