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;