bpf: Factor out fd returning from bpf_btf_find_by_name_kind

In next few patches, we need a helper that searches all kernel BTFs
(vmlinux and module BTFs), and finds the type denoted by 'name' and
'kind'. Turns out bpf_btf_find_by_name_kind already does the same thing,
but it instead returns a BTF ID and optionally fd (if module BTF). This
is used for relocating ksyms in BPF loader code (bpftool gen skel -L).

We extract the core code out into a new helper bpf_find_btf_id, which
returns the BTF ID in the return value, and BTF pointer in an out
parameter. The reference for the returned BTF pointer is always raised,
hence user must either transfer it (e.g. to a fd), or release it after
use.

Signed-off-by: Kumar Kartikeya Dwivedi <memxor@gmail.com>
Signed-off-by: Alexei Starovoitov <ast@kernel.org>
Link: https://lore.kernel.org/bpf/20220317115957.3193097-2-memxor@gmail.com

diff --git a/kernel/bpf/btf.c b/kernel/bpf/btf.c
index 8b34563..17b9adc 100644 (file)
--- a/kernel/bpf/btf.c
+++ b/kernel/bpf/btf.c
@@ -525,6 +525,48 @@ s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind)
        return -ENOENT;
 }
 
+static s32 bpf_find_btf_id(const char *name, u32 kind, struct btf **btf_p)
+{
+       struct btf *btf;
+       s32 ret;
+       int id;
+
+       btf = bpf_get_btf_vmlinux();
+       if (IS_ERR(btf))
+               return PTR_ERR(btf);
+
+       ret = btf_find_by_name_kind(btf, name, kind);
+       /* ret is never zero, since btf_find_by_name_kind returns
+        * positive btf_id or negative error.
+        */
+       if (ret > 0) {
+               btf_get(btf);
+               *btf_p = btf;
+               return ret;
+       }
+
+       /* If name is not found in vmlinux's BTF then search in module's BTFs */
+       spin_lock_bh(&btf_idr_lock);
+       idr_for_each_entry(&btf_idr, btf, id) {
+               if (!btf_is_module(btf))
+                       continue;
+               /* linear search could be slow hence unlock/lock
+                * the IDR to avoiding holding it for too long
+                */
+               btf_get(btf);
+               spin_unlock_bh(&btf_idr_lock);
+               ret = btf_find_by_name_kind(btf, name, kind);
+               if (ret > 0) {
+                       *btf_p = btf;
+                       return ret;
+               }
+               spin_lock_bh(&btf_idr_lock);
+               btf_put(btf);
+       }
+       spin_unlock_bh(&btf_idr_lock);
+       return ret;
+}
+
 const struct btf_type *btf_type_skip_modifiers(const struct btf *btf,
                                               u32 id, u32 *res_id)
 {
@@ -6562,7 +6604,8 @@ static struct btf *btf_get_module_btf(const struct module *module)
 
 BPF_CALL_4(bpf_btf_find_by_name_kind, char *, name, int, name_sz, u32, kind, int, flags)
 {
-       struct btf *btf;
+       struct btf *btf = NULL;
+       int btf_obj_fd = 0;
        long ret;
 
        if (flags)
@@ -6571,44 +6614,17 @@ BPF_CALL_4(bpf_btf_find_by_name_kind, char *, name, int, name_sz, u32, kind, int
        if (name_sz <= 1 || name[name_sz - 1])
                return -EINVAL;
 
-       btf = bpf_get_btf_vmlinux();
-       if (IS_ERR(btf))
-               return PTR_ERR(btf);
-
-       ret = btf_find_by_name_kind(btf, name, kind);
-       /* ret is never zero, since btf_find_by_name_kind returns
-        * positive btf_id or negative error.
-        */
-       if (ret < 0) {
-               struct btf *mod_btf;
-               int id;
-
-               /* If name is not found in vmlinux's BTF then search in module's BTFs */
-               spin_lock_bh(&btf_idr_lock);
-               idr_for_each_entry(&btf_idr, mod_btf, id) {
-                       if (!btf_is_module(mod_btf))
-                               continue;
-                       /* linear search could be slow hence unlock/lock
-                        * the IDR to avoiding holding it for too long
-                        */
-                       btf_get(mod_btf);
-                       spin_unlock_bh(&btf_idr_lock);
-                       ret = btf_find_by_name_kind(mod_btf, name, kind);
-                       if (ret > 0) {
-                               int btf_obj_fd;
-
-                               btf_obj_fd = __btf_new_fd(mod_btf);
-                               if (btf_obj_fd < 0) {
-                                       btf_put(mod_btf);
-                                       return btf_obj_fd;
-                               }
-                               return ret | (((u64)btf_obj_fd) << 32);
-                       }
-                       spin_lock_bh(&btf_idr_lock);
-                       btf_put(mod_btf);
+       ret = bpf_find_btf_id(name, kind, &btf);
+       if (ret > 0 && btf_is_module(btf)) {
+               btf_obj_fd = __btf_new_fd(btf);
+               if (btf_obj_fd < 0) {
+                       btf_put(btf);
+                       return btf_obj_fd;
                }
-               spin_unlock_bh(&btf_idr_lock);
+               return ret | (((u64)btf_obj_fd) << 32);
        }
+       if (ret > 0)
+               btf_put(btf);
        return ret;
 }