bpf: offload: add map offload infrastructure

BPF map offload follow similar path to program offload.  At creation
time users may specify ifindex of the device on which they want to
create the map.  Map will be validated by the kernel's
.map_alloc_check callback and device driver will be called for the
actual allocation.  Map will have an empty set of operations
associated with it (save for alloc and free callbacks).  The real
device callbacks are kept in map->offload->dev_ops because they
have slightly different signatures.  Map operations are called in
process context so the driver may communicate with HW freely,
msleep(), wait() etc.

Map alloc and free callbacks are muxed via existing .ndo_bpf, and
are always called with rtnl lock held.  Maps and programs are
guaranteed to be destroyed before .ndo_uninit (i.e. before
unregister_netdev() returns).  Map callbacks are invoked with
bpf_devs_lock *read* locked, drivers must take care of exclusive
locking if necessary.

All offload-specific branches are marked with unlikely() (through
bpf_map_is_dev_bound()), given that branch penalty will be
negligible compared to IO anyway, and we don't want to penalize
SW path unnecessarily.

Signed-off-by: Jakub Kicinski <jakub.kicinski@netronome.com>
Reviewed-by: Quentin Monnet <quentin.monnet@netronome.com>
Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>

1 files changed, 38 insertions, 6 deletions

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index a3f726bb42ea..c691b9e972e3 100644
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -94,6 +94,11 @@ 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;
@@ -111,6 +116,8 @@ static struct bpf_map *find_and_alloc_map(union bpf_attr *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;
@@ -208,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);
@@ -397,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)
 {
@@ -585,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);
@@ -673,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;
         }
@@ -750,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();
@@ -757,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);
@@ -807,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;