bpf: Move owner type, jited info into array auxiliary data

We're going to extend this with further information which is only
relevant for prog array at this point. Given this info is not used
in critical path, move it into its own structure such that the main
array map structure can be kept on diet.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Acked-by: Andrii Nakryiko <andriin@fb.com>
Link: https://lore.kernel.org/bpf/b9ddccdb0f6f7026489ee955f16c96381e1e7238.1574452833.git.daniel@iogearbox.net

diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 561b920f0bf71e42f7af306ffe08c886e584e028..c3b29061284e542cd2a7c0451387b299dd030899 100644 (file)
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -560,17 +560,21 @@ struct bpf_prog_aux {
        };
 };
 
+struct bpf_array_aux {
+       /* 'Ownership' of prog array is claimed by the first program that
+        * is going to use this map or by the first program which FD is
+        * stored in the map to make sure that all callers and callees have
+        * the same prog type and JITed flag.
+        */
+       enum bpf_prog_type type;
+       bool jited;
+};
+
 struct bpf_array {
        struct bpf_map map;
        u32 elem_size;
        u32 index_mask;
-       /* 'ownership' of prog_array is claimed by the first program that
-        * is going to use this map or by the first program which FD is stored
-        * in the map to make sure that all callers and callees have the same
-        * prog_type and JITed flag
-        */
-       enum bpf_prog_type owner_prog_type;
-       bool owner_jited;
+       struct bpf_array_aux *aux;
        union {
                char value[0] __aligned(8);
                void *ptrs[0] __aligned(8);

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index 633c8c701ff66cb7839247982f0d739bf3bd4bcb..57da950ee55b51d94208935f43cadfb7152e1750 100644 (file)
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -671,10 +671,38 @@ static void prog_array_map_seq_show_elem(struct bpf_map *map, void *key,
        rcu_read_unlock();
 }
 
+static struct bpf_map *prog_array_map_alloc(union bpf_attr *attr)
+{
+       struct bpf_array_aux *aux;
+       struct bpf_map *map;
+
+       aux = kzalloc(sizeof(*aux), GFP_KERNEL);
+       if (!aux)
+               return ERR_PTR(-ENOMEM);
+
+       map = array_map_alloc(attr);
+       if (IS_ERR(map)) {
+               kfree(aux);
+               return map;
+       }
+
+       container_of(map, struct bpf_array, map)->aux = aux;
+       return map;
+}
+
+static void prog_array_map_free(struct bpf_map *map)
+{
+       struct bpf_array_aux *aux;
+
+       aux = container_of(map, struct bpf_array, map)->aux;
+       kfree(aux);
+       fd_array_map_free(map);
+}
+
 const struct bpf_map_ops prog_array_map_ops = {
        .map_alloc_check = fd_array_map_alloc_check,
-       .map_alloc = array_map_alloc,
-       .map_free = fd_array_map_free,
+       .map_alloc = prog_array_map_alloc,
+       .map_free = prog_array_map_free,
        .map_get_next_key = array_map_get_next_key,
        .map_lookup_elem = fd_array_map_lookup_elem,
        .map_delete_elem = fd_array_map_delete_elem,

diff --git a/kernel/bpf/core.c b/kernel/bpf/core.c
index 0e825c164f1a2ba5a526928dff07e6026d67896d..07af9c1d9cf177ce132993ff5456ea8ce34861eb 100644 (file)
--- a/kernel/bpf/core.c
+++ b/kernel/bpf/core.c
@@ -1691,18 +1691,17 @@ bool bpf_prog_array_compatible(struct bpf_array *array,
        if (fp->kprobe_override)
                return false;
 
-       if (!array->owner_prog_type) {
+       if (!array->aux->type) {
                /* There's no owner yet where we could check for
                 * compatibility.
                 */
-               array->owner_prog_type = fp->type;
-               array->owner_jited = fp->jited;
-
+               array->aux->type  = fp->type;
+               array->aux->jited = fp->jited;
                return true;
        }
 
-       return array->owner_prog_type == fp->type &&
-              array->owner_jited == fp->jited;
+       return array->aux->type  == fp->type &&
+              array->aux->jited == fp->jited;
 }
 
 static int bpf_check_tail_call(const struct bpf_prog *fp)

diff --git a/kernel/bpf/map_in_map.c b/kernel/bpf/map_in_map.c
index 4cbe987be35b4062deeba73ae828cab706efaa4b..5e9366b33f0f41108a83a53c169407ab37ea43da 100644 (file)
--- a/kernel/bpf/map_in_map.c
+++ b/kernel/bpf/map_in_map.c
@@ -17,9 +17,8 @@ struct bpf_map *bpf_map_meta_alloc(int inner_map_ufd)
        if (IS_ERR(inner_map))
                return inner_map;
 
-       /* prog_array->owner_prog_type and owner_jited
-        * is a runtime binding.  Doing static check alone
-        * in the verifier is not enough.
+       /* prog_array->aux->{type,jited} is a runtime binding.
+        * Doing static check alone in the verifier is not enough.
         */
        if (inner_map->map_type == BPF_MAP_TYPE_PROG_ARRAY ||
            inner_map->map_type == BPF_MAP_TYPE_CGROUP_STORAGE ||

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 373778da848917b1219ab3ac32ff061f3464578b..b904d56ec6860828898894ab5bab47b5d21fac61 100644 (file)
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -389,13 +389,12 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
 {
        const struct bpf_map *map = filp->private_data;
        const struct bpf_array *array;
-       u32 owner_prog_type = 0;
-       u32 owner_jited = 0;
+       u32 type = 0, jited = 0;
 
        if (map->map_type == BPF_MAP_TYPE_PROG_ARRAY) {
                array = container_of(map, struct bpf_array, map);
-               owner_prog_type = array->owner_prog_type;
-               owner_jited = array->owner_jited;
+               type  = array->aux->type;
+               jited = array->aux->jited;
        }
 
        seq_printf(m,
@@ -415,12 +414,9 @@ static void bpf_map_show_fdinfo(struct seq_file *m, struct file *filp)
                   map->memory.pages * 1ULL << PAGE_SHIFT,
                   map->id,
                   READ_ONCE(map->frozen));
-
-       if (owner_prog_type) {
-               seq_printf(m, "owner_prog_type:\t%u\n",
-                          owner_prog_type);
-               seq_printf(m, "owner_jited:\t%u\n",
-                          owner_jited);
+       if (type) {
+               seq_printf(m, "owner_prog_type:\t%u\n", type);
+               seq_printf(m, "owner_jited:\t%u\n", jited);
        }
 }
 #endif