tracing/probes: Move finding func-proto API and getting func-param API to trace_btf

Move generic function-proto find API and getting function parameter API
to BTF library code from trace_probe.c. This will avoid redundant efforts
on different feature.

Link: https://lore.kernel.org/all/169272155255.160970.719426926348706349.stgit@devnote2/
Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Acked-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index 64b61f6..057cd97 100644 (file)
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -99,6 +99,7 @@ obj-$(CONFIG_KGDB_KDB) += trace_kdb.o
 endif
 obj-$(CONFIG_DYNAMIC_EVENTS) += trace_dynevent.o
 obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o
+obj-$(CONFIG_PROBE_EVENTS_BTF_ARGS) += trace_btf.o
 obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o
 obj-$(CONFIG_BOOTTIME_TRACING) += trace_boot.o
 obj-$(CONFIG_FTRACE_RECORD_RECURSION) += trace_recursion_record.o

diff --git a/kernel/trace/trace_btf.c b/kernel/trace/trace_btf.c
new file mode 100644 (file)
index 0000000..d70b8ee
--- /dev/null
+++ b/kernel/trace/trace_btf.c
@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: GPL-2.0
+#include <linux/btf.h>
+#include <linux/kernel.h>
+
+#include "trace_btf.h"
+
+/*
+ * Find a function proto type by name, and return the btf_type with its btf
+ * in *@btf_p. Return NULL if not found.
+ * Note that caller has to call btf_put(*@btf_p) after using the btf_type.
+ */
+const struct btf_type *btf_find_func_proto(const char *func_name, struct btf **btf_p)
+{
+       const struct btf_type *t;
+       s32 id;
+
+       id = bpf_find_btf_id(func_name, BTF_KIND_FUNC, btf_p);
+       if (id < 0)
+               return NULL;
+
+       /* Get BTF_KIND_FUNC type */
+       t = btf_type_by_id(*btf_p, id);
+       if (!t || !btf_type_is_func(t))
+               goto err;
+
+       /* The type of BTF_KIND_FUNC is BTF_KIND_FUNC_PROTO */
+       t = btf_type_by_id(*btf_p, t->type);
+       if (!t || !btf_type_is_func_proto(t))
+               goto err;
+
+       return t;
+err:
+       btf_put(*btf_p);
+       return NULL;
+}
+
+/*
+ * Get function parameter with the number of parameters.
+ * This can return NULL if the function has no parameters.
+ * It can return -EINVAL if the @func_proto is not a function proto type.
+ */
+const struct btf_param *btf_get_func_param(const struct btf_type *func_proto, s32 *nr)
+{
+       if (!btf_type_is_func_proto(func_proto))
+               return ERR_PTR(-EINVAL);
+
+       *nr = btf_type_vlen(func_proto);
+       if (*nr > 0)
+               return (const struct btf_param *)(func_proto + 1);
+       else
+               return NULL;
+}
+

diff --git a/kernel/trace/trace_btf.h b/kernel/trace/trace_btf.h
new file mode 100644 (file)
index 0000000..98685e9
--- /dev/null
+++ b/kernel/trace/trace_btf.h
@@ -0,0 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#include <linux/btf.h>
+
+const struct btf_type *btf_find_func_proto(const char *func_name,
+                                          struct btf **btf_p);
+const struct btf_param *btf_get_func_param(const struct btf_type *func_proto,
+                                          s32 *nr);

diff --git a/kernel/trace/trace_probe.c b/kernel/trace/trace_probe.c
index ecbe28f..c3ac569 100644 (file)
--- a/kernel/trace/trace_probe.c
+++ b/kernel/trace/trace_probe.c
@@ -12,6 +12,7 @@
 #define pr_fmt(fmt)    "trace_probe: " fmt
 
 #include <linux/bpf.h>
+#include "trace_btf.h"
 
 #include "trace_probe.h"
 
@@ -361,38 +362,6 @@ static const char *type_from_btf_id(struct btf *btf, s32 id)
        return NULL;
 }
 
-static const struct btf_type *find_btf_func_proto(const char *funcname,
-                                                 struct btf **btf_p)
-{
-       const struct btf_type *t;
-       struct btf *btf = NULL;
-       s32 id;
-
-       if (!funcname)
-               return ERR_PTR(-EINVAL);
-
-       id = bpf_find_btf_id(funcname, BTF_KIND_FUNC, &btf);
-       if (id <= 0)
-               return ERR_PTR(-ENOENT);
-
-       /* Get BTF_KIND_FUNC type */
-       t = btf_type_by_id(btf, id);
-       if (!t || !btf_type_is_func(t))
-               goto err;
-
-       /* The type of BTF_KIND_FUNC is BTF_KIND_FUNC_PROTO */
-       t = btf_type_by_id(btf, t->type);
-       if (!t || !btf_type_is_func_proto(t))
-               goto err;
-
-       *btf_p = btf;
-       return t;
-
-err:
-       btf_put(btf);
-       return ERR_PTR(-ENOENT);
-}
-
 static const struct btf_param *find_btf_func_param(const char *funcname, s32 *nr,
                                                   struct btf **btf_p, bool tracepoint)
 {
@@ -403,12 +372,13 @@ static const struct btf_param *find_btf_func_param(const char *funcname, s32 *nr
        if (!funcname || !nr)
                return ERR_PTR(-EINVAL);
 
-       t = find_btf_func_proto(funcname, &btf);
-       if (IS_ERR(t))
+       t = btf_find_func_proto(funcname, &btf);
+       if (!t)
                return (const struct btf_param *)t;
 
-       *nr = btf_type_vlen(t);
-       param = (const struct btf_param *)(t + 1);
+       param = btf_get_func_param(t, nr);
+       if (IS_ERR_OR_NULL(param))
+               goto err;
 
        /* Hide the first 'data' argument of tracepoint */
        if (tracepoint) {
@@ -421,6 +391,7 @@ static const struct btf_param *find_btf_func_param(const char *funcname, s32 *nr
                return param;
        }
 
+err:
        btf_put(btf);
        return NULL;
 }
@@ -496,8 +467,8 @@ static const struct fetch_type *parse_btf_retval_type(
 
        if (ctx->funcname) {
                /* Do not use ctx->btf, because it must be used with ctx->param */
-               t = find_btf_func_proto(ctx->funcname, &btf);
-               if (!IS_ERR(t)) {
+               t = btf_find_func_proto(ctx->funcname, &btf);
+               if (t) {
                        typestr = type_from_btf_id(btf, t->type);
                        btf_put(btf);
                }
@@ -512,8 +483,8 @@ static bool is_btf_retval_void(const char *funcname)
        struct btf *btf;
        bool ret;
 
-       t = find_btf_func_proto(funcname, &btf);
-       if (IS_ERR(t))
+       t = btf_find_func_proto(funcname, &btf);
+       if (!t)
                return false;
 
        ret = (t->type == 0);