fprobe: Introduce fprobe function entry/exit probe
Subsystems (14)
Masami Hiramatsu
maintainerv7 cover fprobe: Introduce fprobe function entry/exit probe
Hi,
Here is the 7th version of fprobe. This version fixes unregister_fprobe() ensures that exit_handler is not called after returning from the unregister_fprobe(), and fixes some comments and documents.
The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the FPROBE_FL_KPROBE_SHARED flag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.
Thank you,
---
Jiri Olsa (1):
ftrace: Add ftrace_set_filter_ips function
Masami Hiramatsu (9):
fprobe: Add ftrace based probe APIs
rethook: Add a generic return hook
rethook: x86: Add rethook x86 implementation
ARM: rethook: Add rethook arm implementation
arm64: rethook: Add arm64 rethook implementation
fprobe: Add exit_handler support
fprobe: Add sample program for fprobe
fprobe: Introduce FPROBE_FL_KPROBE_SHARED flag for fprobe
docs: fprobe: Add fprobe description to ftrace-use.rst
Documentation/trace/fprobe.rst | 171 +++++++++++++ Documentation/trace/index.rst | 1 arch/arm/Kconfig | 1 arch/arm/include/asm/stacktrace.h | 4 arch/arm/kernel/stacktrace.c | 6 arch/arm/probes/Makefile | 1 arch/arm/probes/rethook.c | 71 +++++ arch/arm64/Kconfig | 1 arch/arm64/include/asm/stacktrace.h | 2 arch/arm64/kernel/probes/Makefile | 1 arch/arm64/kernel/probes/rethook.c | 25 ++ arch/arm64/kernel/probes/rethook_trampoline.S | 87 ++++++ arch/arm64/kernel/stacktrace.c | 7 - arch/x86/Kconfig | 1 arch/x86/include/asm/unwind.h | 8 + arch/x86/kernel/Makefile | 1 arch/x86/kernel/kprobes/common.h | 1 arch/x86/kernel/rethook.c | 115 ++++++++ include/linux/fprobe.h | 97 +++++++ include/linux/ftrace.h | 3 include/linux/kprobes.h | 3 include/linux/rethook.h | 100 +++++++ include/linux/sched.h | 3 kernel/exit.c | 2 kernel/fork.c | 3 kernel/trace/Kconfig | 26 ++ kernel/trace/Makefile | 2 kernel/trace/fprobe.c | 341 +++++++++++++++++++++++++ kernel/trace/ftrace.c | 58 ++++ kernel/trace/rethook.c | 313 +++++++++++++++++++++++ samples/Kconfig | 7 + samples/Makefile | 1 samples/fprobe/Makefile | 3 samples/fprobe/fprobe_example.c | 120 +++++++++ 34 files changed, 1572 insertions(+), 14 deletions(-) create mode 100644 Documentation/trace/fprobe.rst create mode 100644 arch/arm/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook_trampoline.S create mode 100644 arch/x86/kernel/rethook.c create mode 100644 include/linux/fprobe.h create mode 100644 include/linux/rethook.h create mode 100644 kernel/trace/fprobe.c create mode 100644 kernel/trace/rethook.c create mode 100644 samples/fprobe/Makefile create mode 100644 samples/fprobe/fprobe_example.c
--
Masami Hiramatsu (Linaro) <[email protected]>
Masami Hiramatsu
maintainerPATCH v7 1/10 ftrace: Add ftrace_set_filter_ips function
From: Jiri Olsa <[email protected]>
Adding ftrace_set_filter_ips function to be able to set filter on multiple ip addresses at once.
With the kprobe multi attach interface we have cases where we need to initialize ftrace_ops object with thousands of functions, so having single function diving into ftrace_hash_move_and_update_ops with ftrace_lock is faster.
The functions ips are passed as unsigned long array with count.
---
Changes in v6: [Masami]
- Fix a typo and add a comment.
--- include/linux/ftrace.h | 3 ++ kernel/trace/ftrace.c | 58 +++++++++++++++++++++++++++++++++++++++++------- 2 files changed, 52 insertions(+), 9 deletions(-)
include/linux/ftrace.h +3 -0
@@ -512,6 +512,8 @@ struct dyn_ftrace {int ftrace_set_filter_ip (struct ftrace_ops *ops,unsigned long ip,int remove,int reset); +int ftrace_set_filter_ips (struct ftrace_ops *ops,unsigned long *ips, +unsigned int cnt,int remove,int reset);int ftrace_set_filter (struct ftrace_ops *ops,unsigned char *buf,int len,int reset); int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
@@ -802,6 +804,7 @@ static inline unsigned long ftrace_location(unsigned long ip)#define ftrace_regex_open (ops, flag, inod, file) ({ -ENODEV; })#define ftrace_set_early_filter (ops, buf, enable) do { } while (0)#define ftrace_set_filter_ip (ops, ip, remove, reset) ({ -ENODEV; }) +#define ftrace_set_filter_ips (ops, ips, cnt, remove, reset) ({ -ENODEV; })#define ftrace_set_filter (ops, buf, len, reset) ({ -ENODEV; })#define ftrace_set_notrace (ops, buf, len, reset) ({ -ENODEV; })#define ftrace_free_filter (ops) do { } while (0)
kernel/trace/ftrace.c +49 -9
100 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 2/10 fprobe: Add ftrace based probe APIs
In reply to Masami HiramatsuThe fprobe is a wrapper API for ftrace function tracer. Unlike kprobes, this probes only supports the function entry, but this can probe multiple functions by one fprobe. The usage is similar, user will set their callback to fprobe::entry_handler and call register_fprobe*() with probed functions.
There are 3 registration interfaces,
- register_fprobe() takes filtering patterns of the functin names.
- register_fprobe_ips() takes an array of ftrace-location addresses.
- register_fprobe_syms() takes an array of function names.
The registered fprobes can be unregistered with unregister_fprobe(). e.g.
struct fprobe fp = { .entry_handler = user_handler }; const char *targets[] = { "func1", "func2", "func3"};
...
ret = register_fprobe_syms(&fp, targets, ARRAY_SIZE(targets));
...
unregister_fprobe(&fp);
---
Changes in v7:
- Fix kerneldoc for the APIs.
Changes in v6:
- Remove syms, addrs, and nentry fields from struct fprobe.
- Introduce 3 variants of registration functions.
- Call ftrace_free_filter() at unregistration.
Changes in v4:
- Fix a memory leak when symbol lookup failed.
- Use ftrace location address instead of symbol address.
- Convert the given symbol address to ftrace location automatically.
- Rename fprobe::ftrace to fprobe::ops.
- Update the Kconfig description.
--- include/linux/fprobe.h | 79 +++++++++++++++++ kernel/trace/Kconfig | 12 +++ kernel/trace/Makefile | 1 kernel/trace/fprobe.c | 218 ++++++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 310 insertions(+) create mode 100644 include/linux/fprobe.h create mode 100644 kernel/trace/fprobe.c
include/linux/fprobe.h new file +79 -0
@@ -0,0 +1,79 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* Simple ftrace probe wrapper */ +#ifndef _LINUX_FPROBE_H +#define _LINUX_FPROBE_H + +#include <linux/compiler.h> +#include <linux/ftrace.h> + +/** +* struct fprobe - ftrace based probe. +* @ops: The ftrace_ops. +* @nmissed: The counter for missing events. +* @flags: The status flag. +* @entry_handler: The callback function for function entry. +*/ +struct fprobe { +struct ftrace_ops ops; +unsigned long nmissed; +unsigned int flags; +void (*entry_handler)(struct fprobe *fp,unsigned long entry_ip,struct pt_regs *regs); +}; + +#define FPROBE_FL_DISABLED 1 + +static inline bool fprobe_disabled (struct fprobe *fp) +{ +return (fp) ? fp->flags &FPROBE_FL_DISABLED : false; +} + +#ifdef CONFIG_FPROBE +int register_fprobe (struct fprobe *fp,const char *filter,const char *notfilter); +int register_fprobe_ips (struct fprobe *fp,unsigned long *addrs,int num); +int register_fprobe_syms (struct fprobe *fp,const char **syms,int num); +int unregister_fprobe (struct fprobe *fp); +#else +static inline int register_fprobe (struct fprobe *fp,const char *filter,const char *notfilter) +{ +return -EOPNOTSUPP ; +} +static inline int register_fprobe_ips (struct fprobe *fp,unsigned long *addrs,int num) +{ +return -EOPNOTSUPP ; +} +static inline int register_fprobe_syms (struct fprobe *fp,const char **syms,int num) +{ +return -EOPNOTSUPP ; +} +static inline int unregister_fprobe (struct fprobe *fp) +{ +return -EOPNOTSUPP ; +} +#endif + +/** +* disable_fprobe() - Disable fprobe +* @fp: The fprobe to be disabled. +* +* This will soft-disable @fp. Note that this doesn't remove the ftrace +* hooks from the function entry. +*/ +static inline void disable_fprobe (struct fprobe *fp) +{ +if (fp) + fp->flags |=FPROBE_FL_DISABLED ; +} + +/** +* enable_fprobe() - Enable fprobe +* @fp: The fprobe to be enabled. +* +* This will soft-enable @fp. +*/ +static inline void enable_fprobe (struct fprobe *fp) +{ +if (fp) + fp->flags &= ~FPROBE_FL_DISABLED ; +} + +#endif
kernel/trace/Kconfig +12 -0
@@ -230,6 +230,18 @@ config DYNAMIC_FTRACE_WITH_ARGS depends on DYNAMIC_FTRACE depends on HAVE_DYNAMIC_FTRACE_WITH_ARGS +config FPROBE + bool "Kernel Function Probe (fprobe)" + depends on FUNCTION_TRACER + depends on DYNAMIC_FTRACE_WITH_REGS + default n + help + This option enables kernel function probe (fprobe) based on ftrace, + which is similar to kprobes, but probes only for kernel function + entries and it can probe multiple functions by one fprobe. + + If unsure, say N. + config FUNCTION_PROFILER bool "Kernel function profiler" depends on FUNCTION_TRACER
kernel/trace/Makefile +1 -0
@@ -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_FPROBE) += fprobe.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o
kernel/trace/fprobe.c new file +218 -0
218 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 3/10 rethook: Add a generic return hook
In reply to Masami HiramatsuAdd a return hook framework which hooks the function return. Most of the logic came from the kretprobe, but this is independent from kretprobe.
Note that this is expected to be used with other function entry hooking feature, like ftrace, fprobe, adn kprobes. Eventually this will replace the kretprobe (e.g. kprobe + rethook = kretprobe), but at this moment, this is just an additional hook.
---
Changes in v6:
- Fix typos.
- Use dereference_symbol_descriptor() to check the trampoline address.
- Shrink down the preempt-disabled section for recycling nodes.
- Reject stack searching if the task is not current and is running in rethook_find_ret_addr().
Changes in v4:
- Fix rethook_trampoline_handler() loops as same as
what currently kretprobe does. This will fix some stacktrace issue in the rethook handler.
--- include/linux/rethook.h | 100 +++++++++++++++ include/linux/sched.h | 3 kernel/exit.c | 2 kernel/fork.c | 3 kernel/trace/Kconfig | 11 ++ kernel/trace/Makefile | 1 kernel/trace/rethook.c | 313 +++++++++++++++++++++++++++++++++++++++++++++++ 7 files changed, 433 insertions(+) create mode 100644 include/linux/rethook.h create mode 100644 kernel/trace/rethook.c
include/linux/rethook.h new file +100 -0
@@ -0,0 +1,100 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Return hooking with list-based shadow stack. +*/ +#ifndef _LINUX_RETHOOK_H +#define _LINUX_RETHOOK_H + +#include <linux/compiler.h> +#include <linux/freelist.h> +#include <linux/kallsyms.h> +#include <linux/llist.h> +#include <linux/rcupdate.h> +#include <linux/refcount.h> + +struct rethook_node ; + +typedef void (*rethook_handler_t ) (struct rethook_node *,void *,struct pt_regs *); + +/** +* struct rethook - The rethook management data structure. +* @data: The user-defined data storage. +* @handler: The user-defined return hook handler. +* @pool: The pool of struct rethook_node. +* @ref: The reference counter. +* @rcu: The rcu_head for deferred freeing. +* +* Don't embed to another data structure, because this is a self-destructive +* data structure when all rethook_node are freed. +*/ +struct rethook { +void *data; +rethook_handler_t handler; +struct freelist_head pool; +refcount_t ref; +struct rcu_head rcu; +}; + +/** +* struct rethook_node - The rethook shadow-stack entry node. +* @freelist: The freelist, linked to struct rethook::pool. +* @rcu: The rcu_head for deferred freeing. +* @llist: The llist, linked to a struct task_struct::rethooks. +* @rethook: The pointer to the struct rethook. +* @ret_addr: The storage for the real return address. +* @frame: The storage for the frame pointer. +* +* You can embed this to your extended data structure to store any data +* on each entry of the shadow stack. +*/ +struct rethook_node { +union { +struct freelist_node freelist; +struct rcu_head rcu; + }; +struct llist_node llist; +struct rethook *rethook; +unsigned long ret_addr; +unsigned long frame; +}; + +struct rethook *rethook_alloc (void *data,rethook_handler_t handler); +void rethook_free (struct rethook *rh); +void rethook_add_node (struct rethook *rh,struct rethook_node *node); +struct rethook_node *rethook_try_get (struct rethook *rh); +void rethook_recycle (struct rethook_node *node); +void rethook_hook (struct rethook_node *node,struct pt_regs *regs); +unsigned long rethook_find_ret_addr (struct task_struct *tsk,unsigned long frame, +struct llist_node **cur); + +/* Arch dependent code must implement arch_* and trampoline code */ +void arch_rethook_prepare (struct rethook_node *node,struct pt_regs *regs); +void arch_rethook_trampoline (void ); + +/** +* is_rethook_trampoline() - Check whether the address is rethook trampoline +* @addr: The address to be checked +* +* Return true if the @addr is the rethook trampoline address. +*/ +static inline bool is_rethook_trampoline (unsigned long addr) +{ +return addr == (unsigned long )dereference_symbol_descriptor (arch_rethook_trampoline); +} + +/* If the architecture needs to fixup the return address, implement it. */ +void arch_rethook_fixup_return (struct pt_regs *regs, +unsigned long correct_ret_addr); + +/* Generic trampoline handler, arch code must prepare asm stub */ +unsigned long rethook_trampoline_handler (struct pt_regs *regs, +unsigned long frame); + +#ifdef CONFIG_RETHOOK +void rethook_flush_task (struct task_struct *tk); +#else +#define rethook_flush_task (tsk) do { } while (0) +#endif + +#endif +
include/linux/sched.h +3 -0
@@ -1473,6 +1473,9 @@ struct task_struct {#ifdef CONFIG_KRETPROBES struct llist_head kretprobe_instances;#endif +#ifdef CONFIG_RETHOOK +struct llist_head rethooks; +#endif #ifdef CONFIG_ARCH_HAS_PARANOID_L1D_FLUSH /*
kernel/exit.c +2 -0
@@ -64,6 +64,7 @@#include <linux/compat.h> #include <linux/io_uring.h> #include <linux/kprobes.h> +#include <linux/rethook.h> #include <linux/uaccess.h> #include <asm/unistd.h>
@@ -169,6 +170,7 @@ static void delayed_put_task_struct(struct rcu_head *rhp) struct task_struct *tsk = container_of(rhp, struct task_struct, rcu);kprobe_flush_task (tsk); +rethook_flush_task (tsk);perf_event_delayed_put (tsk);trace_sched_process_free (tsk);put_task_struct (tsk);
kernel/fork.c +3 -0
@@ -2282,6 +2282,9 @@ static __latent_entropy struct task_struct *copy_process(#ifdef CONFIG_KRETPROBES p->kretprobe_instances.first =NULL ;#endif +#ifdef CONFIG_RETHOOK + p->rethooks.first =NULL ; +#endif /* * Ensure that the cgroup subsystem policies allow the new process to be
kernel/trace/Kconfig +11 -0
@@ -10,6 +10,17 @@ config USER_STACKTRACE_SUPPORT config NOP_TRACER bool +config HAVE_RETHOOK + bool + +config RETHOOK + bool + depends on HAVE_RETHOOK + help + Enable generic return hooking feature. This is an internal + API, which will be used by other function-entry hooking + features like fprobe and kprobes. + config HAVE_FUNCTION_TRACER bool help
kernel/trace/Makefile +1 -0
@@ -98,6 +98,7 @@ 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_FPROBE) += fprobe.o +obj-$(CONFIG_RETHOOK) += rethook.o obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o
kernel/trace/rethook.c new file +313 -0
313 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 4/10 rethook: x86: Add rethook x86 implementation
In reply to Masami HiramatsuAdd rethook for x86 implementation. Most of the code has been copied from kretprobes on x86.
---
Changes in v5:
- Fix a build error if !CONFIG_KRETPROBES and !CONFIG_RETHOOK.
Changes in v4:
- fix stack backtrace as same as kretprobe does.
--- arch/x86/Kconfig | 1 arch/x86/include/asm/unwind.h | 8 ++- arch/x86/kernel/Makefile | 1 arch/x86/kernel/kprobes/common.h | 1 arch/x86/kernel/rethook.c | 115 ++++++++++++++++++++++++++++++++++++++ 5 files changed, 125 insertions(+), 1 deletion(-) create mode 100644 arch/x86/kernel/rethook.c
arch/x86/Kconfig +1 -0
@@ -219,6 +219,7 @@ config X86 select HAVE_KPROBES_ON_FTRACE select HAVE_FUNCTION_ERROR_INJECTION select HAVE_KRETPROBES + select HAVE_RETHOOK select HAVE_KVM select HAVE_LIVEPATCH if X86_64 select HAVE_MIXED_BREAKPOINTS_REGS
arch/x86/include/asm/unwind.h +7 -1
@@ -5,6 +5,7 @@#include <linux/sched.h> #include <linux/ftrace.h> #include <linux/kprobes.h> +#include <linux/rethook.h> #include <asm/ptrace.h> #include <asm/stacktrace.h>
@@ -16,7 +17,7 @@ struct unwind_state {unsigned long stack_mask;struct task_struct *task;int graph_idx; -#ifdef CONFIG_KRETPROBES +#if defined(CONFIG_KRETPROBES ) || defined(CONFIG_RETHOOK )struct llist_node *kr_cur;#endif bool error;
@@ -107,6 +108,11 @@ static inlineunsigned long unwind_recover_kretprobe (struct unwind_state *state,unsigned long addr,unsigned long *addr_p) { +#ifdef CONFIG_RETHOOK +if (is_rethook_trampoline (addr)) +return rethook_find_ret_addr (state->task, (unsigned long )addr_p, + &state->kr_cur); +#endif #ifdef CONFIG_KRETPROBES return is_kretprobe_trampoline (addr) ? kretprobe_find_ret_addr(state->task, addr_p, &state->kr_cur) :
arch/x86/kernel/Makefile +1 -0
@@ -106,6 +106,7 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o obj-$(CONFIG_FTRACE_SYSCALLS) += ftrace.o obj-$(CONFIG_X86_TSC) += trace_clock.o obj-$(CONFIG_TRACING) += trace.o +obj-$(CONFIG_RETHOOK) += rethook.o obj-$(CONFIG_CRASH_CORE) += crash_core_$(BITS).o obj-$(CONFIG_KEXEC_CORE) += machine_kexec_$(BITS).o obj-$(CONFIG_KEXEC_CORE) += relocate_kernel_$(BITS).o crash.o
arch/x86/kernel/kprobes/common.h +1 -0
@@ -6,6 +6,7 @@#include <asm/asm.h> #include <asm/frame.h> +#include <asm/insn.h> #ifdef CONFIG_X86_64
arch/x86/kernel/rethook.c new file +115 -0
115 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 5/10 ARM: rethook: Add rethook arm implementation
In reply to Masami HiramatsuAdd rethook arm implementation. Most of the code has been copied from kretprobes on arm.
---
Changes in v5:
- Fix build error when !CONFIG_KRETPROBES
--- arch/arm/Kconfig | 1 + arch/arm/include/asm/stacktrace.h | 4 +- arch/arm/kernel/stacktrace.c | 6 +++ arch/arm/probes/Makefile | 1 + arch/arm/probes/rethook.c | 71 +++++++++++++++++++++++++++++++++++++ 5 files changed, 81 insertions(+), 2 deletions(-) create mode 100644 arch/arm/probes/rethook.c
arch/arm/Kconfig +1 -0
@@ -106,6 +106,7 @@ config ARM select HAVE_MOD_ARCH_SPECIFIC select HAVE_NMI select HAVE_OPTPROBES if !THUMB2_KERNEL + select HAVE_RETHOOK select HAVE_PERF_EVENTS select HAVE_PERF_REGS select HAVE_PERF_USER_STACK_DUMP
arch/arm/include/asm/stacktrace.h +2 -2
@@ -14,7 +14,7 @@ struct stackframe {unsigned long sp;unsigned long lr;unsigned long pc; -#ifdef CONFIG_KRETPROBES +#if defined(CONFIG_KRETPROBES ) || defined(CONFIG_RETHOOK )struct llist_node *kr_cur;struct task_struct *tsk;#endif
@@ -27,7 +27,7 @@ void arm_get_current_stackframe(struct pt_regs *regs, struct stackframe *frame) frame->sp = regs->ARM_sp; frame->lr = regs->ARM_lr; frame->pc = regs->ARM_pc; -#ifdef CONFIG_KRETPROBES +#if defined(CONFIG_KRETPROBES ) || defined(CONFIG_RETHOOK ) frame->kr_cur =NULL ; frame->tsk = current;#endif
arch/arm/kernel/stacktrace.c +6 -0
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only #include <linux/export.h> #include <linux/kprobes.h> +#include <linux/rethook.h> #include <linux/sched.h> #include <linux/sched/debug.h> #include <linux/stacktrace.h>
@@ -66,6 +67,11 @@ int notrace unwind_frame(struct stackframe *frame) frame->sp = *(unsigned long *)(fp -8 ); frame->pc = *(unsigned long *)(fp -4 );#endif +#ifdef CONFIG_RETHOOK +if (is_rethook_trampoline (frame->pc)) + frame->pc =rethook_find_ret_addr (frame->tsk, frame->fp, + &frame->kr_cur); +#endif #ifdef CONFIG_KRETPROBES if (is_kretprobe_trampoline (frame->pc)) frame->pc = kretprobe_find_ret_addr(frame->tsk,
arch/arm/probes/Makefile +1 -0
@@ -6,3 +6,4 @@ obj-$(CONFIG_KPROBES) += decode-thumb.o else obj-$(CONFIG_KPROBES) += decode-arm.o endif +obj-$(CONFIG_RETHOOK) += rethook.o
arch/arm/probes/rethook.c new file +71 -0
71 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 6/10 arm64: rethook: Add arm64 rethook implementation
In reply to Masami HiramatsuAdd rethook arm64 implementation. Most of the code has been copied from kretprobes on arm64.
---
Changes in v5:
- Add description.
- Fix build error if !CONFIG_KRETPROBES
--- arch/arm64/Kconfig | 1 arch/arm64/include/asm/stacktrace.h | 2 - arch/arm64/kernel/probes/Makefile | 1 arch/arm64/kernel/probes/rethook.c | 25 +++++++ arch/arm64/kernel/probes/rethook_trampoline.S | 87 +++++++++++++++++++++++++ arch/arm64/kernel/stacktrace.c | 7 ++ 6 files changed, 121 insertions(+), 2 deletions(-) create mode 100644 arch/arm64/kernel/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook_trampoline.S
arch/arm64/Kconfig +1 -0
@@ -201,6 +201,7 @@ config ARM64 select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES select HAVE_KRETPROBES + select HAVE_RETHOOK select HAVE_GENERIC_VDSO select IOMMU_DMA if IOMMU_SUPPORT select IRQ_DOMAIN
arch/arm64/include/asm/stacktrace.h +1 -1
@@ -54,7 +54,7 @@ struct stackframe {DECLARE_BITMAP (stacks_done, __NR_STACK_TYPES);unsigned long prev_fp;enum stack_type prev_type; -#ifdef CONFIG_KRETPROBES +#if defined(CONFIG_KRETPROBES ) || defined(CONFIG_RETHOOK )struct llist_node *kr_cur;#endif };
arch/arm64/kernel/probes/Makefile +1 -0
@@ -4,3 +4,4 @@ obj-$(CONFIG_KPROBES) += kprobes.o decode-insn.o \ simulate-insn.o obj-$(CONFIG_UPROBES) += uprobes.o decode-insn.o \ simulate-insn.o +obj-$(CONFIG_RETHOOK) += rethook.o rethook_trampoline.o
arch/arm64/kernel/probes/rethook.c new file +25 -0
@@ -0,0 +1,25 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* +* Generic return hook for arm64. +* Most of the code is copied from arch/arm64/kernel/probes/kprobes.c +*/ + +#include <linux/kprobes.h> +#include <linux/rethook.h> + +/* This is called from arch_rethook_trampoline() */ +unsigned long __used arch_rethook_trampoline_callback (struct pt_regs *regs) +{ +return rethook_trampoline_handler (regs, regs->regs[29 ]); +} +NOKPROBE_SYMBOL (arch_rethook_trampoline_callback); + +void arch_rethook_prepare (struct rethook_node *rhn,struct pt_regs *regs) +{ + rhn->ret_addr = regs->regs[30 ]; + rhn->frame = regs->regs[29 ]; + +/* replace return addr (x30) with trampoline */ + regs->regs[30 ] = (u64 )arch_rethook_trampoline; +} +NOKPROBE_SYMBOL (arch_rethook_prepare);
arch/arm64/kernel/probes/rethook_trampoline.S new file +87 -0
87 lines not on this page · raw message
arch/arm64/kernel/stacktrace.c +6 -1
@@ -8,6 +8,7 @@#include <linux/export.h> #include <linux/ftrace.h> #include <linux/kprobes.h> +#include <linux/rethook.h> #include <linux/sched.h> #include <linux/sched/debug.h> #include <linux/sched/task_stack.h>
@@ -38,7 +39,7 @@ void start_backtrace(struct stackframe *frame, unsigned long fp, { frame->fp = fp; frame->pc = pc; -#ifdef CONFIG_KRETPROBES +#if defined(CONFIG_KRETPROBES ) || defined(CONFIG_RETHOOK ) frame->kr_cur =NULL ;#endif
@@ -136,6 +137,10 @@ int notrace unwind_frame(struct task_struct *tsk, struct stackframe *frame)if (is_kretprobe_trampoline (frame->pc)) frame->pc =kretprobe_find_ret_addr (tsk, (void *)frame->fp, &frame->kr_cur);#endif +#ifdef CONFIG_RETHOOK +if (is_rethook_trampoline (frame->pc)) + frame->pc =rethook_find_ret_addr (tsk, frame->fp, &frame->kr_cur); +#endif return 0 ; }
Masami Hiramatsu
maintainerPATCH v7 7/10 fprobe: Add exit_handler support
In reply to Masami HiramatsuAdd exit_handler to fprobe. fprobe + rethook allows us to hook the kernel function return. The rethook will be enabled only if the fprobe::exit_handler is set.
---
Changes in v7:
- Fix unregister_fprobe() to ensure the rethook handlers are finished when it returns.
- Update Kconfig help.
Changes in v6:
- Update according to the fprobe update.
Changes in v5:
- Add dependency for HAVE_RETHOOK.
Changes in v4:
- Check fprobe is disabled in the exit handler.
Changes in v3:
- Make sure to clear rethook->data before free.
- Handler checks the data is not NULL.
- Free rethook only if the rethook is using.
--- include/linux/fprobe.h | 6 ++ kernel/trace/Kconfig | 9 ++- kernel/trace/fprobe.c | 130 ++++++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 130 insertions(+), 15 deletions(-)
include/linux/fprobe.h +6 -0
@@ -5,19 +5,25 @@#include <linux/compiler.h> #include <linux/ftrace.h> +#include <linux/rethook.h> /** * struct fprobe - ftrace based probe. * @ops: The ftrace_ops. * @nmissed: The counter for missing events. * @flags: The status flag. +* @rethook: The rethook data structure. (internal data) * @entry_handler: The callback function for function entry. +* @exit_handler: The callback function for function exit. */ struct fprobe {struct ftrace_ops ops;unsigned long nmissed;unsigned int flags; +struct rethook *rethook; +void (*entry_handler)(struct fprobe *fp,unsigned long entry_ip,struct pt_regs *regs); +void (*exit_handler)(struct fprobe *fp,unsigned long entry_ip,struct pt_regs *regs); };#define FPROBE_FL_DISABLED 1
kernel/trace/Kconfig +6 -3
@@ -245,11 +245,14 @@ config FPROBE bool "Kernel Function Probe (fprobe)" depends on FUNCTION_TRACER depends on DYNAMIC_FTRACE_WITH_REGS + depends on HAVE_RETHOOK + select RETHOOK default n help - This option enables kernel function probe (fprobe) based on ftrace, - which is similar to kprobes, but probes only for kernel function - entries and it can probe multiple functions by one fprobe. + This option enables kernel function probe (fprobe) based on ftrace. + The fprobe is similar to kprobes, but probes only for kernel function + entries and exits. This also can probe multiple functions by one + fprobe. If unsure, say N.
kernel/trace/fprobe.c +118 -12
198 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 8/10 fprobe: Add sample program for fprobe
In reply to Masami HiramatsuAdd a sample program for the fprobe. The sample_fprobe puts a fprobe on kernel_clone() by default. This dump stack and some called address info at the function entry and exit.
The sample_fprobe.ko gets 2 parameters.
- symbol: you can specify the comma separated symbols or wildcard symbol pattern (in this case you can not use comma)
- stackdump: a bool value to enable or disable stack dump in the fprobe handler.
---
Changes in v6:
- Dump stack on the handler as explained in the comment.
- Add "stackdump" option to enable/disable stackdump.
- Support wildcard filter.
Changes in v2:
- Fix infinit loop for multiple symbols.
- Fix memory leaks for copied string and entry array.
- Update for new fprobe APIs.
- Fix style issues.
--- samples/Kconfig | 7 ++ samples/Makefile | 1 samples/fprobe/Makefile | 3 + samples/fprobe/fprobe_example.c | 120 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 131 insertions(+) create mode 100644 samples/fprobe/Makefile create mode 100644 samples/fprobe/fprobe_example.c
samples/Kconfig +7 -0
@@ -73,6 +73,13 @@ config SAMPLE_HW_BREAKPOINT help This builds kernel hardware breakpoint example modules. +config SAMPLE_FPROBE + tristate "Build fprobe examples -- loadable modules only" + depends on FPROBE && m + help + This builds a fprobe example module. This module has an option 'symbol'. + You can specify a probed symbol or symbols separated with ','. + config SAMPLE_KFIFO tristate "Build kfifo examples -- loadable modules only" depends on m
samples/Makefile +1 -0
@@ -32,3 +32,4 @@ obj-$(CONFIG_SAMPLE_INTEL_MEI) += mei/ subdir-$(CONFIG_SAMPLE_WATCHDOG) += watchdog subdir-$(CONFIG_SAMPLE_WATCH_QUEUE) += watch_queue obj-$(CONFIG_DEBUG_KMEMLEAK_TEST) += kmemleak/ +obj-$(CONFIG_SAMPLE_FPROBE) += fprobe/
samples/fprobe/Makefile new file +3 -0
@@ -0,0 +1,3 @@ +# SPDX-License-Identifier: GPL-2.0-only + +obj-$(CONFIG_SAMPLE_FPROBE) += fprobe_example.o
samples/fprobe/fprobe_example.c new file +120 -0
120 lines not on this page · raw message
Masami Hiramatsu
maintainerPATCH v7 10/10 docs: fprobe: Add fprobe description to ftrace-use.rst
In reply to Masami HiramatsuAdd a documentation of fprobe for the user who needs this interface.
---
Changes in v7:
- Clarify unregister_fprobe() guarantee the callbacks will no longer being called after that.
- Fix some wording.
Changes in v6:
- Update document according to the latest spec.
--- Documentation/trace/fprobe.rst | 171 ++++++++++++++++++++++++++++++++++++++++ Documentation/trace/index.rst | 1 2 files changed, 172 insertions(+) create mode 100644 Documentation/trace/fprobe.rst
Documentation/trace/fprobe.rst new file +171 -0
@@ -0,0 +1,171 @@ +.. SPDX-License-Identifier: GPL-2.0 + +================================== +Fprobe - Function entry/exit probe +================================== + +.. Author: Masami Hiramatsu <[email protected]> + +Introduction +============ + +Instead of using ftrace full feature, if you only want to attach callbacks +on function entry and exit, similar to the kprobes and kretprobes, you can +use fprobe. Compared with kprobes and kretprobes, fprobe gives faster +instrumentation for multiple functions with single handler. This document +describes how to use fprobe. + +The usage of fprobe +=================== + +The fprobe is a wrapper of ftrace (+ kretprobe-like return callback) to +attach callbacks to multiple function entry and exit. User needs to set up +the `struct fprobe` and pass it to `register_fprobe()`. + +Typically, `fprobe` data structure is initialized with the `entry_handler` +and/or `exit_handler` as below. + +.. code-block:: c + + struct fprobe fp = { + .entry_handler = my_entry_callback, + .exit_handler = my_exit_callback, + }; + +To enable the fprobe, call one of register_fprobe(), register_fprobe_ips(), and +register_fprobe_syms(). These register the fprobe with different type of +parameters. + +The register_fprobe() enables a fprobe by function-name filters. +E.g. this enables @fp on "func*()" function except "func2()".:: + + register_fprobe(&fp, "func*", "func2"); + +The register_fprobe_ips() enables a fprobe by ftrace-location addresses. +E.g. + +.. code-block:: c + + unsigned long ips[] = { 0x.... }; + + register_fprobe_ips(&fp, ips, ARRAY_SIZE(ips)); + +And the register_fprobe_syms() enables a fprobe by symbol names. +E.g. + +.. code-block:: c + + char syms[] = {"func1", "func2", "func3"}; + + register_fprobe_syms(&fp, syms, ARRAY_SIZE(syms)); + +To disable (remove from functions) this fprobe, call:: + + unregister_fprobe(&fp); + +You can temporally (soft) disable the fprobe by:: + + disable_fprobe(&fp); + +and resume by:: + + enable_fprobe(&fp); + +The above is defined by including the header:: + + #include <linux/fprobe.h> + +Same as ftrace, the registered callback will start being called some time +after the register_fprobe() is called and before it returns. See +:file:`Documentation/trace/ftrace.rst`. + +Also, the unregister_fprobe() will guarantee that the both enter and exit +handlers are no longer being called by functions after unregister_fprobe() +returns as same as unregister_ftrace_function(). + +The fprobe entry/exit handler +============================= + +The prototype of the entry/exit callback function is as follows: + +.. code-block:: c + + void callback_func(struct fprobe *fp, unsigned long entry_ip, struct pt_regs *regs); + +Note that both entry and exit callback has same ptototype. The @entry_ip is +saved at function entry and passed to exit handler. + +@fp + This is the address of `fprobe` data structure related to this handler. + You can embed the `fprobe` to your data structure and get it by + container_of() macro from @fp. The @fp must not be NULL. + +@entry_ip + This is the entry address of the traced function (both entry and exit). + +@regs + This is the `pt_regs` data structure at the entry and exit. Note that + the instruction pointer of @regs may be different from the @entry_ip + in the entry_handler. If you need traced instruction pointer, you need + to use @entry_ip. On the other hand, in the exit_handler, the instruction + pointer of @regs is set to the currect return address. + +Share the callbacks with kprobes +================================ + +Since the recursion safety of the fprobe (and ftrace) is a bit different +from the kprobes, this may cause an issue if user wants to run the same +code from the fprobe and the kprobes. + +The kprobes has per-cpu 'current_kprobe' variable which protects the +kprobe handler from recursion in any case. On the other hand, the fprobe +uses only ftrace_test_recursion_trylock(), which will allow interrupt +context calls another (or same) fprobe during the fprobe user handler is +running. + +This is not a matter in cases if the common callback shared among the +kprobes and the fprobe has its own recursion detection, or it can handle +the recursion in the different contexts (normal/interrupt/NMI.) +But if it relies on the 'current_kprobe' recursion lock, it has to check +kprobe_running() and use kprobe_busy_*() APIs. + +Fprobe has FPROBE_FL_KPROBE_SHARED flag to do this. If your common callback +code will be shared with kprobes, please set FPROBE_FL_KPROBE_SHARED +*before* registering the fprobe, like: + +.. code-block:: c + + fprobe.flags = FPROBE_FL_KPROBE_SHARED; + + register_fprobe(&fprobe, "func*", NULL); + +This will protect your common callback from the nested call. + +The missed counter +================== + +The `fprobe` data structure has `fprobe::nmissed` counter field as same as +kprobes. +This counter counts up when; + + - fprobe fails to take ftrace_recursion lock. This usually means that a function + which is traced by other ftrace users is called from the entry_handler. + + - fprobe fails to setup the function exit because of the shortage of rethook + (the shadow stack for hooking the function return.) + +Since `fprobe::nmissed` field is counted up in both case, the former case +will skip both of entry and exit callback, and the latter case will skip exit +callback, but in both case the counter is just increased by 1. + +Note that if you set the FTRACE_OPS_FL_RECURSION and/or FTRACE_OPS_FL_RCU to +`fprobe::ops::flags` (ftrace_ops::flags) when registering the fprobe, this +counter may not work correctly, because those will skip fprobe's callback. + + +Functions and structures +======================== + +.. kernel-doc:: include/linux/fprobe.h +.. kernel-doc:: kernel/trace/fprobe.c +
Documentation/trace/index.rst +1 -0
@@ -9,6 +9,7 @@ Linux Tracing Technologies tracepoint-analysis ftrace ftrace-uses + fprobe kprobes kprobetrace uprobetracer
Masami Hiramatsu
maintainerPATCH v7 9/10 fprobe: Introduce FPROBE_FL_KPROBE_SHARED flag for fprobe
In reply to Masami HiramatsuIntroduce FPROBE_FL_KPROBE_SHARED flag for sharing fprobe callback with kprobes safely from the viewpoint of recursion.
Since the recursion safety of the fprobe (and ftrace) is a bit different from the kprobes, this may cause an issue if user wants to run the same code from the fprobe and the kprobes.
The kprobes has per-cpu 'current_kprobe' variable which protects the kprobe handler from recursion in any case. On the other hand, the fprobe uses only ftrace_test_recursion_trylock(), which will allow interrupt context calls another (or same) fprobe during the fprobe user handler is running.
This is not a matter in cases if the common callback shared among the kprobes and the fprobe has its own recursion detection, or it can handle the recursion in the different contexts (normal/interrupt/NMI.) But if it relies on the 'current_kprobe' recursion lock, it has to check kprobe_running() and use kprobe_busy_*() APIs.
Fprobe has FPROBE_FL_KPROBE_SHARED flag to do this. If your common callback code will be shared with kprobes, please set FPROBE_FL_KPROBE_SHARED *before* registering the fprobe, like;
fprobe.flags = FPROBE_FL_KPROBE_SHARED;
register_fprobe(&fprobe, "func*", NULL);
This will protect your common callback from the nested call.
--- include/linux/fprobe.h | 12 ++++++++++++ include/linux/kprobes.h | 3 +++ kernel/trace/fprobe.c | 19 ++++++++++++++++++- 3 files changed, 33 insertions(+), 1 deletion(-)
include/linux/fprobe.h +12 -0
@@ -26,13 +26,25 @@ struct fprobe {void (*exit_handler)(struct fprobe *fp,unsigned long entry_ip,struct pt_regs *regs); }; +/* This fprobe is soft-disabled. */ #define FPROBE_FL_DISABLED 1 +/* +* This fprobe handler will be shared with kprobes. +* This flag must be set before registering. +*/ +#define FPROBE_FL_KPROBE_SHARED 2 +static inline bool fprobe_disabled (struct fprobe *fp) {return (fp) ? fp->flags &FPROBE_FL_DISABLED : false; } +static inline bool fprobe_shared_with_kprobes (struct fprobe *fp) +{ +return (fp) ? fp->flags &FPROBE_FL_KPROBE_SHARED : false; +} +#ifdef CONFIG_FPROBE int register_fprobe (struct fprobe *fp,const char *filter,const char *notfilter);int register_fprobe_ips (struct fprobe *fp,unsigned long *addrs,int num);
include/linux/kprobes.h +3 -0
@@ -433,6 +433,9 @@ static inline struct kprobe *kprobe_running(void) {return NULL ; } +#define kprobe_busy_begin () do {} while (0) +#define kprobe_busy_end () do {} while (0) +static inline int register_kprobe (struct kprobe *p) {return -EOPNOTSUPP ;
kernel/trace/fprobe.c +18 -1
@@ -56,6 +56,20 @@ static void fprobe_handler(unsigned long ip, unsigned long parent_ip, }NOKPROBE_SYMBOL (fprobe_handler); +static void fprobe_kprobe_handler (unsigned long ip,unsigned long parent_ip, +struct ftrace_ops *ops,struct ftrace_regs *fregs) +{ + struct fprobe *fp = container_of(ops, struct fprobe, ops); + +if (unlikely (kprobe_running ())) { + fp->nmissed++; +return ; + } +kprobe_busy_begin (); +fprobe_handler (ip, parent_ip, ops, fregs); +kprobe_busy_end (); +} +static void fprobe_exit_handler (struct rethook_node *rh,void *data,struct pt_regs *regs) {
@@ -109,7 +123,10 @@ static unsigned long *get_ftrace_locations(const char **syms, int num)static void fprobe_init (struct fprobe *fp) { fp->nmissed =0 ; - fp->ops.func = fprobe_handler; +if (fprobe_shared_with_kprobes (fp)) + fp->ops.func = fprobe_kprobe_handler; +else + fp->ops.func = fprobe_handler; fp->ops.flags |=FTRACE_OPS_FL_SAVE_REGS ; }
Masami Hiramatsu
maintainerHi Jiri,
Quoted 17 lines · On Mon, 31 Jan 2022 14:00:24 +0900 Masami Hiramatsu <[email protected]> wrote:
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
Quoted 7 lines
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.
If you want to work on this series, I pushed my working branch on here;
https://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux.git/ kprobes/fprobe
Thank you,
Quoted 69 lines
Thank you,
---
Jiri Olsa (1):
ftrace: Addftrace_set_filter_ipsfunctionMasami Hiramatsu (9):
fprobe: Add ftrace based probe APIs
rethook: Add a generic return hook
rethook: x86: Add rethook x86 implementation
ARM: rethook: Add rethook arm implementation
arm64: rethook: Add arm64 rethook implementation
fprobe: Addexit_handlersupport
fprobe: Add sample program for fprobe
fprobe: IntroduceFPROBE_FL_KPROBE_SHAREDflag for fprobe
docs: fprobe: Add fprobe description toftrace-use.rstDocumentation/trace/fprobe.rst | 171 +++++++++++++ Documentation/trace/index.rst | 1 arch/arm/Kconfig | 1 arch/arm/include/asm/stacktrace.h | 4 arch/arm/kernel/stacktrace.c | 6 arch/arm/probes/Makefile | 1 arch/arm/probes/rethook.c | 71 +++++ arch/arm64/Kconfig | 1 arch/arm64/include/asm/stacktrace.h | 2 arch/arm64/kernel/probes/Makefile | 1 arch/arm64/kernel/probes/rethook.c | 25 ++ arch/arm64/kernel/probes/rethook_trampoline.S | 87 ++++++ arch/arm64/kernel/stacktrace.c | 7 - arch/x86/Kconfig | 1 arch/x86/include/asm/unwind.h | 8 + arch/x86/kernel/Makefile | 1 arch/x86/kernel/kprobes/common.h | 1 arch/x86/kernel/rethook.c | 115 ++++++++ include/linux/fprobe.h | 97 +++++++ include/linux/ftrace.h | 3 include/linux/kprobes.h | 3 include/linux/rethook.h | 100 +++++++ include/linux/sched.h | 3 kernel/exit.c | 2 kernel/fork.c | 3 kernel/trace/Kconfig | 26 ++ kernel/trace/Makefile | 2 kernel/trace/fprobe.c | 341 +++++++++++++++++++++++++ kernel/trace/ftrace.c | 58 ++++ kernel/trace/rethook.c | 313 +++++++++++++++++++++++ samples/Kconfig | 7 + samples/Makefile | 1 samples/fprobe/Makefile | 3 samples/fprobe/fprobe_example.c | 120 +++++++++ 34 files changed, 1572 insertions(+), 14 deletions(-) create mode 100644 Documentation/trace/fprobe.rst create mode 100644 arch/arm/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook_trampoline.S create mode 100644 arch/x86/kernel/rethook.c create mode 100644 include/linux/fprobe.h create mode 100644 include/linux/rethook.h create mode 100644 kernel/trace/fprobe.c create mode 100644 kernel/trace/rethook.c create mode 100644 samples/fprobe/Makefile create mode 100644 samples/fprobe/fprobe_example.c--
Masami Hiramatsu (Linaro) <[email protected]>
Signature · 1 line
Masami Hiramatsu <[email protected]>
Quoted 26 lines · Masami Hiramatsu
Hi Jiri,
Quoted 21 lines · On Mon, 31 Jan 2022 14:00:24 +0900 Masami Hiramatsu <[email protected]> wrote:
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
The patch [1/10] is from Jiri's series[2].
Quoted 7 lines
Quoted 3 lines
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.If you want to work on this series, I pushed my working branch on here;
https://git.kernel.org/pub/scm/linux/kernel/git/mhiramat/linux.git/ kprobes/fprobe
great, I was going to ask for that ;-) thanks
jirka
Quoted 77 lines
Thank you,
Quoted 69 lines
Thank you,
---
Jiri Olsa (1):
ftrace: Addftrace_set_filter_ipsfunctionMasami Hiramatsu (9):
fprobe: Add ftrace based probe APIs
rethook: Add a generic return hook
rethook: x86: Add rethook x86 implementation
ARM: rethook: Add rethook arm implementation
arm64: rethook: Add arm64 rethook implementation
fprobe: Addexit_handlersupport
fprobe: Add sample program for fprobe
fprobe: IntroduceFPROBE_FL_KPROBE_SHAREDflag for fprobe
docs: fprobe: Add fprobe description toftrace-use.rstDocumentation/trace/fprobe.rst | 171 +++++++++++++ Documentation/trace/index.rst | 1 arch/arm/Kconfig | 1 arch/arm/include/asm/stacktrace.h | 4 arch/arm/kernel/stacktrace.c | 6 arch/arm/probes/Makefile | 1 arch/arm/probes/rethook.c | 71 +++++ arch/arm64/Kconfig | 1 arch/arm64/include/asm/stacktrace.h | 2 arch/arm64/kernel/probes/Makefile | 1 arch/arm64/kernel/probes/rethook.c | 25 ++ arch/arm64/kernel/probes/rethook_trampoline.S | 87 ++++++ arch/arm64/kernel/stacktrace.c | 7 - arch/x86/Kconfig | 1 arch/x86/include/asm/unwind.h | 8 + arch/x86/kernel/Makefile | 1 arch/x86/kernel/kprobes/common.h | 1 arch/x86/kernel/rethook.c | 115 ++++++++ include/linux/fprobe.h | 97 +++++++ include/linux/ftrace.h | 3 include/linux/kprobes.h | 3 include/linux/rethook.h | 100 +++++++ include/linux/sched.h | 3 kernel/exit.c | 2 kernel/fork.c | 3 kernel/trace/Kconfig | 26 ++ kernel/trace/Makefile | 2 kernel/trace/fprobe.c | 341 +++++++++++++++++++++++++ kernel/trace/ftrace.c | 58 ++++ kernel/trace/rethook.c | 313 +++++++++++++++++++++++ samples/Kconfig | 7 + samples/Makefile | 1 samples/fprobe/Makefile | 3 samples/fprobe/fprobe_example.c | 120 +++++++++ 34 files changed, 1572 insertions(+), 14 deletions(-) create mode 100644 Documentation/trace/fprobe.rst create mode 100644 arch/arm/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook.c create mode 100644 arch/arm64/kernel/probes/rethook_trampoline.S create mode 100644 arch/x86/kernel/rethook.c create mode 100644 include/linux/fprobe.h create mode 100644 include/linux/rethook.h create mode 100644 kernel/trace/fprobe.c create mode 100644 kernel/trace/rethook.c create mode 100644 samples/fprobe/Makefile create mode 100644 samples/fprobe/fprobe_example.c--
Masami Hiramatsu (Linaro) <[email protected]>Signature · 1 line
Masami Hiramatsu <[email protected]>
Quoted 17 lines · Masami Hiramatsu
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
Quoted 7 lines
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.
hi,
it works fine for bpf selftests, but when I use it through bpftrace to attach more probes with:
# ./src/bpftrace -e 'kprobe:ksys_* { }'
Attaching 27 probesI'm getting stalls like:
krava33 login: [ 988.574069] INFO: task bpftrace:4137 blocked for more than 122 seconds.
[ 988.577577] Not tainted 5.16.0+ #89 [ 988.580173] "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. [ 988.585538] task:bpftrace state:D stack: 0 pid: 4137 ppid: 4123 flags:0x00004004 [ 988.589869] Call Trace: [ 988.591312] <TASK> [ 988.592577] __schedule+0x3a8/0xd30 [ 988.594469] ? wait_for_completion+0x84/0x110 [ 988.596753] schedule+0x4e/0xc0 [ 988.598480] schedule_timeout+0xed/0x130 [ 988.600524] ? rcu_read_lock_sched_held+0x12/0x70 [ 988.602901] ? lock_release+0x253/0x4a0 [ 988.604935] ? lock_acquired+0x1b7/0x410 [ 988.607041] ? trace_hardirqs_on+0x1b/0xe0 [ 988.609202] wait_for_completion+0xae/0x110 [ 988.613762] __wait_rcu_gp+0x127/0x130 [ 988.615787] synchronize_rcu_tasks_generic+0x46/0xa0 [ 988.618329] ? call_rcu_tasks+0x20/0x20 [ 988.620600] ? rcu_tasks_pregp_step+0x10/0x10 [ 988.623232] ftrace_shutdown.part.0+0x174/0x210 [ 988.625820] unregister_ftrace_function+0x37/0x60 [ 988.628480] unregister_fprobe+0x2d/0x50 [ 988.630928] bpf_link_free+0x4e/0x70 [ 988.633126] bpf_link_release+0x11/0x20 [ 988.635249] __fput+0xae/0x270 [ 988.637022] task_work_run+0x5c/0xa0 [ 988.639016] exit_to_user_mode_prepare+0x251/0x260 [ 988.641294] syscall_exit_to_user_mode+0x16/0x50 [ 988.646249] do_syscall_64+0x48/0x90 [ 988.648218] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 988.650787] RIP: 0033:0x7f9079e95fbb [ 988.652761] RSP: 002b:00007ffd474fa3b0 EFLAGS: 00000293 ORIG_RAX: 0000000000000003 [ 988.656718] RAX: 0000000000000000 RBX: 00000000011bf8d0 RCX: 00007f9079e95fbb [ 988.660110] RDX: 0000000000000000 RSI: 00007ffd474fa3b0 RDI: 0000000000000019 [ 988.663512] RBP: 00007ffd474faaf0 R08: 0000000000000000 R09: 000000000000001a [ 988.666673] R10: 0000000000000064 R11: 0000000000000293 R12: 0000000000000001 [ 988.669770] R13: 00000000004a19a1 R14: 00007f9083428c00 R15: 00000000008c02d8 [ 988.672601] </TASK> [ 988.675763] INFO: lockdep is turned off.
I have't investigated yet, any idea?
thanks,
jirka
Quoted 76 lines · Jiri Olsa
Quoted 17 lines · Masami Hiramatsu
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
Quoted 7 lines
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.hi,
it works fine for bpf selftests, but when I use it through bpftrace to attach more probes with:# ./src/bpftrace -e 'kprobe:ksys_* { }' Attaching 27 probesI'm getting stalls like:
krava33 login: [ 988.574069] INFO: task bpftrace:4137 blocked for more than 122 seconds.
[ 988.577577] Not tainted 5.16.0+ #89 [ 988.580173] "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. [ 988.585538] task:bpftrace state:D stack: 0 pid: 4137 ppid: 4123 flags:0x00004004 [ 988.589869] Call Trace: [ 988.591312] <TASK> [ 988.592577] __schedule+0x3a8/0xd30 [ 988.594469] ? wait_for_completion+0x84/0x110 [ 988.596753] schedule+0x4e/0xc0 [ 988.598480] schedule_timeout+0xed/0x130 [ 988.600524] ? rcu_read_lock_sched_held+0x12/0x70 [ 988.602901] ? lock_release+0x253/0x4a0 [ 988.604935] ? lock_acquired+0x1b7/0x410 [ 988.607041] ? trace_hardirqs_on+0x1b/0xe0 [ 988.609202] wait_for_completion+0xae/0x110 [ 988.613762] __wait_rcu_gp+0x127/0x130 [ 988.615787] synchronize_rcu_tasks_generic+0x46/0xa0 [ 988.618329] ? call_rcu_tasks+0x20/0x20 [ 988.620600] ? rcu_tasks_pregp_step+0x10/0x10 [ 988.623232] ftrace_shutdown.part.0+0x174/0x210 [ 988.625820] unregister_ftrace_function+0x37/0x60 [ 988.628480] unregister_fprobe+0x2d/0x50 [ 988.630928] bpf_link_free+0x4e/0x70 [ 988.633126] bpf_link_release+0x11/0x20 [ 988.635249] __fput+0xae/0x270 [ 988.637022] task_work_run+0x5c/0xa0 [ 988.639016] exit_to_user_mode_prepare+0x251/0x260 [ 988.641294] syscall_exit_to_user_mode+0x16/0x50 [ 988.646249] do_syscall_64+0x48/0x90 [ 988.648218] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 988.650787] RIP: 0033:0x7f9079e95fbb [ 988.652761] RSP: 002b:00007ffd474fa3b0 EFLAGS: 00000293 ORIG_RAX: 0000000000000003 [ 988.656718] RAX: 0000000000000000 RBX: 00000000011bf8d0 RCX: 00007f9079e95fbb [ 988.660110] RDX: 0000000000000000 RSI: 00007ffd474fa3b0 RDI: 0000000000000019 [ 988.663512] RBP: 00007ffd474faaf0 R08: 0000000000000000 R09: 000000000000001a [ 988.666673] R10: 0000000000000064 R11: 0000000000000293 R12: 0000000000000001 [ 988.669770] R13: 00000000004a19a1 R14: 00007f9083428c00 R15: 00000000008c02d8 [ 988.672601] </TASK> [ 988.675763] INFO: lockdep is turned off.
Quoted 2 lines
I have't investigated yet, any idea?
Do you happen to have a CPU count that's not a power of 2? Check if you have [0] in your tree, it might be that.
Quoted 3 lines
thanks,
jirka
Masami Hiramatsu
maintainerHi Jiri,
Quoted 75 lines · On Wed, 2 Feb 2022 01:02:43 +0100 Jiri Olsa <[email protected]> wrote:
Quoted 17 lines · Masami Hiramatsu
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
Quoted 7 lines
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.hi,
it works fine for bpf selftests, but when I use it through bpftrace to attach more probes with:# ./src/bpftrace -e 'kprobe:ksys_* { }' Attaching 27 probesI'm getting stalls like:
krava33 login: [ 988.574069] INFO: task bpftrace:4137 blocked for more than 122 seconds.
[ 988.577577] Not tainted 5.16.0+ #89 [ 988.580173] "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. [ 988.585538] task:bpftrace state:D stack: 0 pid: 4137 ppid: 4123 flags:0x00004004 [ 988.589869] Call Trace: [ 988.591312] <TASK> [ 988.592577] __schedule+0x3a8/0xd30 [ 988.594469] ? wait_for_completion+0x84/0x110 [ 988.596753] schedule+0x4e/0xc0 [ 988.598480] schedule_timeout+0xed/0x130 [ 988.600524] ? rcu_read_lock_sched_held+0x12/0x70 [ 988.602901] ? lock_release+0x253/0x4a0 [ 988.604935] ? lock_acquired+0x1b7/0x410 [ 988.607041] ? trace_hardirqs_on+0x1b/0xe0 [ 988.609202] wait_for_completion+0xae/0x110 [ 988.613762] __wait_rcu_gp+0x127/0x130 [ 988.615787] synchronize_rcu_tasks_generic+0x46/0xa0 [ 988.618329] ? call_rcu_tasks+0x20/0x20 [ 988.620600] ? rcu_tasks_pregp_step+0x10/0x10 [ 988.623232] ftrace_shutdown.part.0+0x174/0x210 [ 988.625820] unregister_ftrace_function+0x37/0x60 [ 988.628480] unregister_fprobe+0x2d/0x50 [ 988.630928] bpf_link_free+0x4e/0x70 [ 988.633126] bpf_link_release+0x11/0x20 [ 988.635249] __fput+0xae/0x270 [ 988.637022] task_work_run+0x5c/0xa0 [ 988.639016] exit_to_user_mode_prepare+0x251/0x260 [ 988.641294] syscall_exit_to_user_mode+0x16/0x50 [ 988.646249] do_syscall_64+0x48/0x90 [ 988.648218] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 988.650787] RIP: 0033:0x7f9079e95fbb [ 988.652761] RSP: 002b:00007ffd474fa3b0 EFLAGS: 00000293 ORIG_RAX: 0000000000000003 [ 988.656718] RAX: 0000000000000000 RBX: 00000000011bf8d0 RCX: 00007f9079e95fbb [ 988.660110] RDX: 0000000000000000 RSI: 00007ffd474fa3b0 RDI: 0000000000000019 [ 988.663512] RBP: 00007ffd474faaf0 R08: 0000000000000000 R09: 000000000000001a [ 988.666673] R10: 0000000000000064 R11: 0000000000000293 R12: 0000000000000001 [ 988.669770] R13: 00000000004a19a1 R14: 00007f9083428c00 R15: 00000000008c02d8 [ 988.672601] </TASK> [ 988.675763] INFO: lockdep is turned off.
Quoted 1 line
I have't investigated yet, any idea?
Hmm, no, as far as I tested with my example module, it works well as below;
# insmod fprobe_example.ko symbol='ksys_*' && ls && sleep 1 && rmmod fprobe_example.ko [ 125.820113] fprobe_init: Planted fprobe at ksys_* [ 125.823153] sample_entry_handler: Enter <ksys_write+0x0/0xf0> ip = 0x000000008d8da91f [ 125.824247] fprobe_handler.part.0+0xb1/0x150 [ 125.825024] fprobe_handler+0x1e/0x20 [ 125.825799] 0xffffffffa000e0e3 [ 125.826540] ksys_write+0x5/0xf0 [ 125.827344] do_syscall_64+0x3b/0x90 [ 125.828144] entry_SYSCALL_64_after_hwframe+0x44/0xae fprobe_example.ko [ 125.829178] sample_exit_handler: Return from <ksys_write+0x0/0xf0> ip = 0x000000008d8da91f to rip = 0x00000000be5e197e (__x64_sys_write+0x1a/0x20) [ 125.830707] fprobe_exit_handler+0x29/0x30 [ 125.831415] rethook_trampoline_handler+0x99/0x140 [ 125.832259] arch_rethook_trampoline_callback+0x3f/0x50 [ 125.833110] arch_rethook_trampoline+0x2f/0x50 [ 125.833803] __x64_sys_write+0x1a/0x20 [ 125.834448] do_syscall_64+0x3b/0x90 [ 125.835055] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 126.878825] fprobe_exit: fprobe at ksys_* unregistered #
Even with NR_CPUS=3, it didn't cause the stall. But maybe you'd better test with Paul's fix as Andrii pointed.
Thank you,
Quoted 4 lines
thanks,
jirka
Signature · 1 line
Masami Hiramatsu <[email protected]>
Quoted 77 lines · Andrii Nakryiko
Quoted 76 lines · Jiri Olsa
Quoted 17 lines · Masami Hiramatsu
Hi,
Here is the 7th version of fprobe. This version fixes
unregister_fprobe()ensures thatexit_handleris not called after returning from theunregister_fprobe(), and fixes some comments and documents.The previous version is here[1];
[1] https://lore.kernel.org/all/164338031590.2429999.6203979005944292576.stgit@devnote2/T/#u
This series introduces the fprobe, the function entry/exit probe with multiple probe point support. This also introduces the rethook for hooking function return as same as the kretprobe does. This abstraction will help us to generalize the fgraph tracer, because we can just switch to it from the rethook in fprobe, depending on the kernel configuration.
Quoted 7 lines
The patch [1/10] is from Jiri's series[2].
[2] https://lore.kernel.org/all/[email protected]/T/#u
And the patch [9/10] adds the
FPROBE_FL_KPROBE_SHAREDflag for the case if user wants to share the same code (or share a same resource) on the fprobe and the kprobes.hi,
it works fine for bpf selftests, but when I use it through bpftrace to attach more probes with:# ./src/bpftrace -e 'kprobe:ksys_* { }' Attaching 27 probesI'm getting stalls like:
krava33 login: [ 988.574069] INFO: task bpftrace:4137 blocked for more than 122 seconds.
[ 988.577577] Not tainted 5.16.0+ #89 [ 988.580173] "echo 0 > /proc/sys/kernel/hung_task_timeout_secs" disables this message. [ 988.585538] task:bpftrace state:D stack: 0 pid: 4137 ppid: 4123 flags:0x00004004 [ 988.589869] Call Trace: [ 988.591312] <TASK> [ 988.592577] __schedule+0x3a8/0xd30 [ 988.594469] ? wait_for_completion+0x84/0x110 [ 988.596753] schedule+0x4e/0xc0 [ 988.598480] schedule_timeout+0xed/0x130 [ 988.600524] ? rcu_read_lock_sched_held+0x12/0x70 [ 988.602901] ? lock_release+0x253/0x4a0 [ 988.604935] ? lock_acquired+0x1b7/0x410 [ 988.607041] ? trace_hardirqs_on+0x1b/0xe0 [ 988.609202] wait_for_completion+0xae/0x110 [ 988.613762] __wait_rcu_gp+0x127/0x130 [ 988.615787] synchronize_rcu_tasks_generic+0x46/0xa0 [ 988.618329] ? call_rcu_tasks+0x20/0x20 [ 988.620600] ? rcu_tasks_pregp_step+0x10/0x10 [ 988.623232] ftrace_shutdown.part.0+0x174/0x210 [ 988.625820] unregister_ftrace_function+0x37/0x60 [ 988.628480] unregister_fprobe+0x2d/0x50 [ 988.630928] bpf_link_free+0x4e/0x70 [ 988.633126] bpf_link_release+0x11/0x20 [ 988.635249] __fput+0xae/0x270 [ 988.637022] task_work_run+0x5c/0xa0 [ 988.639016] exit_to_user_mode_prepare+0x251/0x260 [ 988.641294] syscall_exit_to_user_mode+0x16/0x50 [ 988.646249] do_syscall_64+0x48/0x90 [ 988.648218] entry_SYSCALL_64_after_hwframe+0x44/0xae [ 988.650787] RIP: 0033:0x7f9079e95fbb [ 988.652761] RSP: 002b:00007ffd474fa3b0 EFLAGS: 00000293 ORIG_RAX: 0000000000000003 [ 988.656718] RAX: 0000000000000000 RBX: 00000000011bf8d0 RCX: 00007f9079e95fbb [ 988.660110] RDX: 0000000000000000 RSI: 00007ffd474fa3b0 RDI: 0000000000000019 [ 988.663512] RBP: 00007ffd474faaf0 R08: 0000000000000000 R09: 000000000000001a [ 988.666673] R10: 0000000000000064 R11: 0000000000000293 R12: 0000000000000001 [ 988.669770] R13: 00000000004a19a1 R14: 00007f9083428c00 R15: 00000000008c02d8 [ 988.672601] </TASK> [ 988.675763] INFO: lockdep is turned off.
Quoted 7 lines
Quoted 2 lines
I have't investigated yet, any idea?
Do you happen to have a CPU count that's not a power of 2? Check if you have [0] in your tree, it might be that.
yes, that helped, thanks
jirka