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

Daniel Borkmann says:

====================
pull-request: bpf-next 2018-01-17

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

The main changes are:

1) Add initial BPF map offloading for nfp driver. Currently only
   programs were supported so far w/o being able to access maps.
   Offloaded programs are right now only allowed to perform map
   lookups, and control path is responsible for populating the
   maps. BPF core infrastructure along with nfp implementation is
   provided, from Jakub.

2) Various follow-ups to Josef's BPF error injections. More
   specifically that includes: properly check whether the error
   injectable event is on function entry or not, remove the percpu
   bpf_kprobe_override and rather compare instruction pointer
   with original one, separate error-injection from kprobes since
   it's not limited to it, add injectable error types in order to
   specify what is the expected type of failure, and last but not
   least also support the kernel's fault injection framework, all
   from Masami.

3) Various misc improvements and cleanups to the libbpf Makefile.
   That is, fix permissions when installing BPF header files, remove
   unused variables and functions, and also install the libbpf.h
   header, from Jesper.

4) When offloading to nfp JIT and the BPF insn is unsupported in the
   JIT, then reject right at verification time. Also fix libbpf with
   regards to ELF section name matching by properly treating the
   program type as prefix. Both from Quentin.

5) Add -DPACKAGE to bpftool when including bfd.h for the disassembler.
   This is needed, for example, when building libfd from source as
   bpftool doesn't supply a config.h for bfd.h. Fix from Jiong.

6) xdp_convert_ctx_access() is simplified since it doesn't need to
   set target size during verification, from Jesper.

7) Let bpftool properly recognize BPF_PROG_TYPE_CGROUP_DEVICE
   program types, from Roman.

8) Various functions in BPF cpumap were not declared static, from Wei.

9) Fix a double semicolon in BPF samples, from Luis.
====================

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

1 files changed, 61 insertions, 10 deletions

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 2bac0dc8baba..c691b9e972e3 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -94,18 +94,34 @@ static int check_uarg_tail_zero(void __user *uaddr,
         return 0;
 }
 
+const struct bpf_map_ops bpf_map_offload_ops = {
+        .map_alloc = bpf_map_offload_map_alloc,
+        .map_free = bpf_map_offload_map_free,
+};
+
 static struct bpf_map *find_and_alloc_map(union bpf_attr *attr)
 {
+        const struct bpf_map_ops *ops;
         struct bpf_map *map;
+        int err;
 
-        if (attr->map_type >= ARRAY_SIZE(bpf_map_types) ||
-            !bpf_map_types[attr->map_type])
+        if (attr->map_type >= ARRAY_SIZE(bpf_map_types))
+                return ERR_PTR(-EINVAL);
+        ops = bpf_map_types[attr->map_type];
+        if (!ops)
                 return ERR_PTR(-EINVAL);
 
-        map = bpf_map_types[attr->map_type]->map_alloc(attr);
+        if (ops->map_alloc_check) {
+                err = ops->map_alloc_check(attr);
+                if (err)
+                        return ERR_PTR(err);
+        }
+        if (attr->map_ifindex)
+                ops = &bpf_map_offload_ops;
+        map = ops->map_alloc(attr);
         if (IS_ERR(map))
                 return map;
-        map->ops = bpf_map_types[attr->map_type];
+        map->ops = ops;
         map->map_type = attr->map_type;
         return map;
 }
@@ -134,6 +150,16 @@ void bpf_map_area_free(void *area)
         kvfree(area);
 }
 
+void bpf_map_init_from_attr(struct bpf_map *map, union bpf_attr *attr)
+{
+        map->map_type = attr->map_type;
+        map->key_size = attr->key_size;
+        map->value_size = attr->value_size;
+        map->max_entries = attr->max_entries;
+        map->map_flags = attr->map_flags;
+        map->numa_node = bpf_map_attr_numa_node(attr);
+}
+
 int bpf_map_precharge_memlock(u32 pages)
 {
         struct user_struct *user = get_current_user();
@@ -189,16 +215,25 @@ static int bpf_map_alloc_id(struct bpf_map *map)
         return id > 0 ? 0 : id;
 }
 
-static void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock)
+void bpf_map_free_id(struct bpf_map *map, bool do_idr_lock)
 {
         unsigned long flags;
 
+        /* Offloaded maps are removed from the IDR store when their device
+         * disappears - even if someone holds an fd to them they are unusable,
+         * the memory is gone, all ops will fail; they are simply waiting for
+         * refcnt to drop to be freed.
+         */
+        if (!map->id)
+                return;
+
         if (do_idr_lock)
                 spin_lock_irqsave(&map_idr_lock, flags);
         else
                 __acquire(&map_idr_lock);
 
         idr_remove(&map_idr, map->id);
+        map->id = 0;
 
         if (do_idr_lock)
                 spin_unlock_irqrestore(&map_idr_lock, flags);
@@ -378,7 +413,7 @@ static int bpf_obj_name_cpy(char *dst, const char *src)
         return 0;
 }
 
-#define BPF_MAP_CREATE_LAST_FIELD map_name
+#define BPF_MAP_CREATE_LAST_FIELD map_ifindex
 /* called via syscall */
 static int map_create(union bpf_attr *attr)
 {
@@ -566,8 +601,10 @@ static int map_lookup_elem(union bpf_attr *attr)
         if (!value)
                 goto free_key;
 
-        if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
-            map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) {
+        if (bpf_map_is_dev_bound(map)) {
+                err = bpf_map_offload_lookup_elem(map, key, value);
+        } else if (map->map_type == BPF_MAP_TYPE_PERCPU_HASH ||
+                   map->map_type == BPF_MAP_TYPE_LRU_PERCPU_HASH) {
                 err = bpf_percpu_hash_copy(map, key, value);
         } else if (map->map_type == BPF_MAP_TYPE_PERCPU_ARRAY) {
                 err = bpf_percpu_array_copy(map, key, value);
@@ -654,7 +691,10 @@ static int map_update_elem(union bpf_attr *attr)
                 goto free_value;
 
         /* Need to create a kthread, thus must support schedule */
-        if (map->map_type == BPF_MAP_TYPE_CPUMAP) {
+        if (bpf_map_is_dev_bound(map)) {
+                err = bpf_map_offload_update_elem(map, key, value, attr->flags);
+                goto out;
+        } else if (map->map_type == BPF_MAP_TYPE_CPUMAP) {
                 err = map->ops->map_update_elem(map, key, value, attr->flags);
                 goto out;
         }
@@ -731,6 +771,11 @@ static int map_delete_elem(union bpf_attr *attr)
                 goto err_put;
         }
 
+        if (bpf_map_is_dev_bound(map)) {
+                err = bpf_map_offload_delete_elem(map, key);
+                goto out;
+        }
+
         preempt_disable();
         __this_cpu_inc(bpf_prog_active);
         rcu_read_lock();
@@ -738,7 +783,7 @@ static int map_delete_elem(union bpf_attr *attr)
         rcu_read_unlock();
         __this_cpu_dec(bpf_prog_active);
         preempt_enable();
-
+out:
         if (!err)
                 trace_bpf_map_delete_elem(map, ufd, key);
         kfree(key);
@@ -788,9 +833,15 @@ static int map_get_next_key(union bpf_attr *attr)
         if (!next_key)
                 goto free_key;
 
+        if (bpf_map_is_dev_bound(map)) {
+                err = bpf_map_offload_get_next_key(map, key, next_key);
+                goto out;
+        }
+
         rcu_read_lock();
         err = map->ops->map_get_next_key(map, key, next_key);
         rcu_read_unlock();
+out:
         if (err)
                 goto free_next_key;