bpf: allow for key-less BTF in array map

Given we'll be reusing BPF array maps for global data/bss/rodata
sections, we need a way to associate BTF DataSec type as its map
value type. In usual cases we have this ugly BPF_ANNOTATE_KV_PAIR()
macro hack e.g. via 38d5d3b3d5db ("bpf: Introduce BPF_ANNOTATE_KV_PAIR")
to get initial map to type association going. While more use cases
for it are discouraged, this also won't work for global data since
the use of array map is a BPF loader detail and therefore unknown
at compilation time. For array maps with just a single entry we make
an exception in terms of BTF in that key type is declared optional
if value type is of DataSec type. The latter LLVM is guaranteed to
emit and it also aligns with how we regard global data maps as just
a plain buffer area reusing existing map facilities for allowing
things like introspection with existing tools.

Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
Acked-by: Martin KaFai Lau <kafai@fb.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

diff --git a/include/linux/btf.h b/include/linux/btf.h
index 455d31b55828d2240f3e0f27920be11b75dfee57..64cdf2a23d427cf2af3f2fd264d32aeffd6c582b 100644 (file)
--- a/include/linux/btf.h
+++ b/include/linux/btf.h
@@ -51,6 +51,7 @@ bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,
                           const struct btf_member *m,
                           u32 expected_offset, u32 expected_size);
 int btf_find_spin_lock(const struct btf *btf, const struct btf_type *t);
+bool btf_type_is_void(const struct btf_type *t);
 
 #ifdef CONFIG_BPF_SYSCALL
 const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);

diff --git a/kernel/bpf/arraymap.c b/kernel/bpf/arraymap.c
index 217b10bd9f4886f2e02e4fd6bf85c57a1dcf8946..584636c9e2eb0e27f235990f5e1306877bb7aad1 100644 (file)
--- a/kernel/bpf/arraymap.c
+++ b/kernel/bpf/arraymap.c
@@ -391,7 +391,8 @@ static void array_map_seq_show_elem(struct bpf_map *map, void *key,
                return;
        }
 
-       seq_printf(m, "%u: ", *(u32 *)key);
+       if (map->btf_key_type_id)
+               seq_printf(m, "%u: ", *(u32 *)key);
        btf_type_seq_show(map->btf, map->btf_value_type_id, value, m);
        seq_puts(m, "\n");
 
@@ -428,6 +429,18 @@ static int array_map_check_btf(const struct bpf_map *map,
 {
        u32 int_data;
 
+       /* One exception for keyless BTF: .bss/.data/.rodata map */
+       if (btf_type_is_void(key_type)) {
+               if (map->map_type != BPF_MAP_TYPE_ARRAY ||
+                   map->max_entries != 1)
+                       return -EINVAL;
+
+               if (BTF_INFO_KIND(value_type->info) != BTF_KIND_DATASEC)
+                       return -EINVAL;
+
+               return 0;
+       }
+
        if (BTF_INFO_KIND(key_type->info) != BTF_KIND_INT)
                return -EINVAL;
 

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 0cecf6bab61b026624cb6643d60dc633763c9ab3..cad09858a5f25beabb53aaaefeb1b4ad5a7a44f1 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -326,7 +326,7 @@ static bool btf_type_is_modifier(const struct btf_type *t)
        return false;
 }
 
-static bool btf_type_is_void(const struct btf_type *t)
+bool btf_type_is_void(const struct btf_type *t)
 {
        return t == &btf_void;
 }

diff --git a/kernel/bpf/syscall.c b/kernel/bpf/syscall.c
index 198c9680bf0d82f7da580adcd0d7988a301f656a..438199e2eca44538a6d0bfa7e30217ed4fb96112 100644 (file)
--- a/kernel/bpf/syscall.c
+++ b/kernel/bpf/syscall.c
@@ -504,9 +504,16 @@ static int map_check_btf(struct bpf_map *map, const struct btf *btf,
        u32 key_size, value_size;
        int ret = 0;
 
-       key_type = btf_type_id_size(btf, &btf_key_id, &key_size);
-       if (!key_type || key_size != map->key_size)
-               return -EINVAL;
+       /* Some maps allow key to be unspecified. */
+       if (btf_key_id) {
+               key_type = btf_type_id_size(btf, &btf_key_id, &key_size);
+               if (!key_type || key_size != map->key_size)
+                       return -EINVAL;
+       } else {
+               key_type = btf_type_by_id(btf, 0);
+               if (!map->ops->map_check_btf)
+                       return -EINVAL;
+       }
 
        value_type = btf_type_id_size(btf, &btf_value_id, &value_size);
        if (!value_type || value_size != map->value_size)
@@ -573,7 +580,7 @@ static int map_create(union bpf_attr *attr)
        if (attr->btf_key_type_id || attr->btf_value_type_id) {
                struct btf *btf;
 
-               if (!attr->btf_key_type_id || !attr->btf_value_type_id) {
+               if (!attr->btf_value_type_id) {
                        err = -EINVAL;
                        goto free_map_nouncharge;
                }