From 269b86597c166d6d4c5dd564168237603533165a Mon Sep 17 00:00:00 2001 From: Masami Hiramatsu Date: Thu, 6 Jan 2022 15:40:36 +0900 Subject: [PATCH] fprobe: Add ftrace based probe APIs The fprobe is a wrapper API for ftrace function tracer. Unlike kprobes, this probes only supports the function entry, but it can probe multiple functions by one fprobe. The usage is almost same as the kprobe, user will specify the function names by fprobe::syms, the number of syms by fprobe::nsyms, and the user handler by fprobe::handler. struct fprobe = { 0 }; const char *targets[] = {"func1", "func2", "func3"}; fprobe.handler = user_handler; fprobe.nsyms = ARRAY_SIZE(targets); fprobe.syms = targets; ret = register_fprobe(&fprobe); ... Signed-off-by: Masami Hiramatsu --- include/linux/fprobes.h | 52 ++++++++++++++++ kernel/trace/Kconfig | 10 ++++ kernel/trace/Makefile | 1 + kernel/trace/fprobes.c | 128 ++++++++++++++++++++++++++++++++++++++++ 4 files changed, 191 insertions(+) create mode 100644 include/linux/fprobes.h create mode 100644 kernel/trace/fprobes.c diff --git a/include/linux/fprobes.h b/include/linux/fprobes.h new file mode 100644 index 000000000000..22db748bf491 --- /dev/null +++ b/include/linux/fprobes.h @@ -0,0 +1,52 @@ +#ifndef _LINUX_FPROBES_H +#define _LINUX_FPROBES_H +/* Simple ftrace probe wrapper */ + +#include +#include + +struct fprobe { + const char **syms; + unsigned long *addrs; + unsigned int nsyms; + + struct ftrace_ops ftrace; + unsigned long nmissed; + unsigned int flags; + void (*handler) (struct fprobe *, struct pt_regs *); +}; + +#define FPROBE_FL_DISABLED 1 + +static inline bool fprobe_disabled(struct fprobe *fp) +{ + return (fp) ? fp->flags & FPROBE_FL_DISABLED : false; +} + +#ifdef CONFIG_FPROBES +int register_fprobe(struct fprobe *fp); +int unregister_fprobe(struct fprobe *fp); +#else +static inline int register_fprobe(struct fprobe *fp) +{ + return -ENOTSUPP; +} +static inline int unregister_fprobe(struct fprobe *fp) +{ + return -ENOTSUPP; +} +#endif + +static inline void disable_fprobe(struct fprobe *fp) +{ + if (fp) + fp->flags |= FPROBE_FL_DISABLED; +} + +static inline void enable_fprobe(struct fprobe *fp) +{ + if (fp) + fp->flags &= ~FPROBE_FL_DISABLED; +} + +#endif diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index 420ff4bc67fd..45a3618a20a7 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -223,6 +223,16 @@ config DYNAMIC_FTRACE_WITH_ARGS depends on DYNAMIC_FTRACE depends on HAVE_DYNAMIC_FTRACE_WITH_ARGS +config FPROBES + bool "Kernel Function Probe (fprobe)" + depends on FUNCTION_TRACER + depends on DYNAMIC_FTRACE_WITH_REGS + default n + help + This option enables kernel function probe feature, which is + similar to kprobes, but probes only for kernel function entries + and it can probe multiple functions by one fprobe. + config FUNCTION_PROFILER bool "Kernel function profiler" depends on FUNCTION_TRACER diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile index bedc5caceec7..47a37a3bb974 100644 --- a/kernel/trace/Makefile +++ b/kernel/trace/Makefile @@ -97,6 +97,7 @@ obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o obj-$(CONFIG_BOOTTIME_TRACING) += trace_boot.o obj-$(CONFIG_FTRACE_RECORD_RECURSION) += trace_recursion_record.o +obj-$(CONFIG_FPROBES) += fprobes.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o diff --git a/kernel/trace/fprobes.c b/kernel/trace/fprobes.c new file mode 100644 index 000000000000..2ea118462afb --- /dev/null +++ b/kernel/trace/fprobes.c @@ -0,0 +1,128 @@ +// SPDX-License-Identifier: GPL-2.0 + +#define pr_fmt(fmt) "fprobes: " fmt + +#include +#include +#include +#include + +static void fprobe_handler(unsigned long ip, unsigned long parent_ip, + struct ftrace_ops *ops, struct ftrace_regs *fregs) +{ + struct fprobe *fp; + int bit; + + fp = container_of(ops, struct fprobe, ftrace); + if (fprobe_disabled(fp)) + return; + + bit = ftrace_test_recursion_trylock(ip, parent_ip); + if (bit < 0) { + fp->nmissed++; + return; + } + + if (fp->handler) + fp->handler(fp, ftrace_get_regs(fregs)); + + ftrace_test_recursion_unlock(bit); +} +NOKPROBE_SYMBOL(fprobe_handler); + +/* + * Populate fp::addrs array from fp::syms. Whether the functions are + * ftrace-able or not will be checked afterwards by ftrace_set_filter_ip(). + */ +static int populate_func_addresses(struct fprobe *fp) +{ + unsigned int i; + + fp->addrs = kmalloc(sizeof(void *) * fp->nsyms, GFP_KERNEL); + if (!fp->addrs) + return -ENOMEM; + + for (i = 0; i < fp->nsyms; i++) { + fp->addrs[i] = kallsyms_lookup_name(fp->syms[i]); + if (!fp->addrs[i]) { + kfree(fp->addrs); + fp->addrs = NULL; + return -ENOENT; + } + } + + return 0; +} + +/** + * register_fprobe - Register fprobe to ftrace + * @fp: A fprobe data structure to be registered. + * + * This expects the user set @fp::syms or @fp::addrs (not both), + * @fp::nsyms (number of entries of @fp::syms or @fp::addrs) and + * @fp::handler. Other fields are initialized by this function. + */ +int register_fprobe(struct fprobe *fp) +{ + unsigned int i; + int ret; + + if (!fp) + return -EINVAL; + + if (!fp->nsyms || (!fp->syms && !fp->addrs) || (fp->syms && fp->addrs)) + return -EINVAL; + + if (fp->syms) { + ret = populate_func_addresses(fp); + if (ret < 0) + return ret; + } + + fp->ftrace.func = fprobe_handler; + fp->ftrace.flags = FTRACE_OPS_FL_SAVE_REGS; + + for (i = 0; i < fp->nsyms; i++) { + ret = ftrace_set_filter_ip(&fp->ftrace, fp->addrs[i], 0, 0); + if (ret < 0) + goto error; + } + + fp->nmissed = 0; + ret = register_ftrace_function(&fp->ftrace); + if (!ret) + return ret; + +error: + if (fp->syms) { + kfree(fp->addrs); + fp->addrs = NULL; + } + + return ret; +} + +/** + * unregister_fprobe - Unregister fprobe from ftrace + * @fp: A fprobe data structure to be unregistered. + */ +int unregister_fprobe(struct fprobe *fp) +{ + int ret; + + if (!fp) + return -EINVAL; + + if (!fp->nsyms || !fp->addrs) + return -EINVAL; + + ret = unregister_ftrace_function(&fp->ftrace); + + if (fp->syms) { + /* fp->addrs is allocated by register_fprobe() */ + kfree(fp->addrs); + fp->addrs = NULL; + } + + return ret; +} -- 2.25.1