perf: perf_arch_fetch_regs_caller API change
Subsystems (7)
cover perf: perf_arch_fetch_regs_caller API change
Hi,
I did some updates in this function, we don't need anymore to skip further the first caller now. So I think it's worth the simplification to lower the overhead in the tracing fast path.
I took Paul updates for PowerPc and I did the changes on x86. But I'm clearly useless about the sparc part, I'm still confused about these window things. So all I did in this arch is to wrap the older API with the new one, always passing the skip to 1. I suspect David can be more useful than me to do a real change there :)
Tell me what you think,
Thanks.
Frederic Weisbecker (2):
x86: Unify dumpstack.h and stacktrace.h
perf: Drop the skip argument from perf_arch_fetch_regs_caller
arch/powerpc/include/asm/perf_event.h | 12 +++++++ arch/powerpc/kernel/misc.S | 26 --------------- arch/sparc/include/asm/perf_event.h | 4 ++ arch/sparc/kernel/helpers.S | 6 ++-- arch/x86/include/asm/perf_event.h | 9 +++++ arch/x86/include/asm/stacktrace.h | 49 ++++++++++++++++++++++++++++ arch/x86/kernel/cpu/perf_event.c | 14 -------- arch/x86/kernel/dumpstack.c | 1 - arch/x86/kernel/dumpstack.h | 56 --------------------------------- arch/x86/kernel/dumpstack_32.c | 2 - arch/x86/kernel/dumpstack_64.c | 1 - arch/x86/kernel/stacktrace.c | 7 ++-- include/linux/perf_event.h | 32 ++++-------------- include/trace/ftrace.h | 2 +- kernel/perf_event.c | 5 --- kernel/trace/trace_event_perf.c | 2 - 16 files changed, 89 insertions(+), 139 deletions(-) delete mode 100644 arch/x86/kernel/dumpstack.h
PATCH 1/2 x86: Unify dumpstack.h and stacktrace.h
arch/x86/include/asm/stacktrace.h and arch/x86/kernel/dumpstack.h declare headers of objects that deal with the same topic. Actually most of the files that include stacktrace.h also include dumpstack.h
Although dumpstack.h seems more reserved for internals of stack traces, those are quite often needed to define specialized stack trace operations. And perf event arch headers are going to need access to such low level operations anyway. So don't continue to bother with dumpstack.h as it's not anymore about isolated deep internals.
--- arch/x86/include/asm/stacktrace.h | 52 ++++++++++++++++++++++++++++++++++ arch/x86/kernel/cpu/perf_event.c | 2 - arch/x86/kernel/dumpstack.c | 1 - arch/x86/kernel/dumpstack.h | 56 ------------------------------------- arch/x86/kernel/dumpstack_32.c | 2 - arch/x86/kernel/dumpstack_64.c | 1 - arch/x86/kernel/stacktrace.c | 7 ++-- 7 files changed, 56 insertions(+), 65 deletions(-) delete mode 100644 arch/x86/kernel/dumpstack.h
arch/x86/include/asm/stacktrace.h +52 -0
@@ -1,6 +1,13 @@ +/* +* Copyright (C) 1991, 1992 Linus Torvalds +* Copyright (C) 2000, 2001, 2002 Andi Kleen, SuSE Labs +*/ +#ifndef _ASM_X86_STACKTRACE_H#define _ASM_X86_STACKTRACE_H +#include <linux/uaccess.h> +extern int kstack_depth_to_print;struct thread_info ;
@@ -42,4 +49,49 @@ void dump_trace(struct task_struct *tsk, struct pt_regs *regs, unsigned long *stack, unsigned long bp, const struct stacktrace_ops *ops, void *data); +#ifdef CONFIG_X86_32 +#define STACKSLOTS_PER_LINE 8 +#define get_bp (bp) asm("movl %%ebp, %0" : "=r" (bp) :) +#else +#define STACKSLOTS_PER_LINE 4 +#define get_bp (bp) asm("movq %%rbp, %0" : "=r" (bp) :) +#endif + +extern void +show_trace_log_lvl (struct task_struct *task,struct pt_regs *regs, +unsigned long *stack,unsigned long bp,char *log_lvl); + +extern void +show_stack_log_lvl (struct task_struct *task,struct pt_regs *regs, +unsigned long *sp,unsigned long bp,char *log_lvl); + +extern unsigned int code_bytes; + +/* The form of the top of the frame on the stack */ +struct stack_frame { +struct stack_frame *next_frame; +unsigned long return_address; +}; + +struct stack_frame_ia32 { +u32 next_frame; +u32 return_address; +}; + +static inline unsigned long rewind_frame_pointer (int n) +{ +struct stack_frame *frame; + +get_bp (frame); + +#ifdef CONFIG_FRAME_POINTER +while (n--) { +if (probe_kernel_address (&frame->next_frame, frame)) +break ; + } +#endif + +return (unsigned long )frame; +} +#endif /* _ASM_X86_STACKTRACE_H */
arch/x86/kernel/cpu/perf_event.c +0 -2
@@ -1585,8 +1585,6 @@ static const struct stacktrace_ops backtrace_ops = { .walk_stack = print_context_stack_bp, }; -#include "../dumpstack.h" -static void perf_callchain_kernel (struct pt_regs *regs,struct perf_callchain_entry *entry) {
arch/x86/kernel/dumpstack.c +0 -1
@@ -18,7 +18,6 @@#include <asm/stacktrace.h> -#include "dumpstack.h" int panic_on_unrecovered_nmi;int panic_on_io_nmi;
arch/x86/kernel/dumpstack.h deleted +0 -56
56 lines not on this page · raw message
arch/x86/kernel/dumpstack_32.c +0 -2
@@ -16,8 +16,6 @@#include <asm/stacktrace.h> -#include "dumpstack.h" - void dump_trace(struct task_struct *task, struct pt_regs *regs, unsigned long *stack, unsigned long bp,
arch/x86/kernel/dumpstack_64.c +0 -1
@@ -16,7 +16,6 @@#include <asm/stacktrace.h> -#include "dumpstack.h" #define N_EXCEPTION_STACKS_END \ (N_EXCEPTION_STACKS + DEBUG_STKSZ/EXCEPTION_STKSZ - 2)
arch/x86/kernel/stacktrace.c +4 -3
@@ -96,12 +96,13 @@ EXPORT_SYMBOL_GPL(save_stack_trace_tsk);/* Userspace stacktrace - based on kernel/trace/trace_sysprof.c */ -struct stack_frame { +struct stack_frame_user {const void __user *next_fp;unsigned long ret_addr; }; -static int copy_stack_frame (const void __user *fp,struct stack_frame *frame) +static int +copy_stack_frame (const void __user *fp,struct stack_frame_user *frame) {int ret;
@@ -126,7 +127,7 @@ static inline void __save_stack_trace_user(struct stack_trace *trace) trace->entries[trace->nr_entries++] = regs->ip;while (trace->nr_entries < trace->max_entries) { -struct stack_frame frame; +struct stack_frame_user frame; frame.next_fp =NULL ; frame.ret_addr =0 ;
Signature · 1 line
1.6.2.3
PATCH 2/2 perf: Drop the skip argument from perf_arch_fetch_regs_caller
In reply to Frederic WeisbeckerDrop this argument now that we always want to rewind only to the state of the first caller.
It means frame pointers are not necessary anymore to reliably get the source of an event. But this also means we need this helper to be a macro now, as an inline function is not an option since we need to know when to provide a default implentation.
--- arch/powerpc/include/asm/perf_event.h | 12 ++++++++++++ arch/powerpc/kernel/misc.S | 26 -------------------------- arch/sparc/include/asm/perf_event.h | 4 ++++ arch/sparc/kernel/helpers.S | 6 +++--- arch/x86/include/asm/perf_event.h | 9 +++++++++ arch/x86/include/asm/stacktrace.h | 7 ++----- arch/x86/kernel/cpu/perf_event.c | 12 ------------ include/linux/perf_event.h | 32 +++++++------------------------- include/trace/ftrace.h | 2 +- kernel/perf_event.c | 5 ----- kernel/trace/trace_event_perf.c | 2 -- 11 files changed, 38 insertions(+), 79 deletions(-)
arch/powerpc/include/asm/perf_event.h +12 -0
@@ -21,3 +21,15 @@#ifdef CONFIG_FSL_EMB_PERF_EVENT #include <asm/perf_event_fsl_emb.h> #endif + +#ifdef CONFIG_PERF_EVENTS +#include <asm/ptrace.h> +#include <asm/reg.h> + +#define perf_arch_fetch_caller_regs (regs, __ip) \ + do { \ + (regs)->nip = __ip; \ + (regs)->gpr[1] = *(unsigned long *)__get_SP(); \ + asm volatile("mfmsr %0" : "=r" ((regs)->msr)); \ + } while (0) +#endif
arch/powerpc/kernel/misc.S +0 -26
@@ -127,29 +127,3 @@ _GLOBAL(__setup_cpu_power7) _GLOBAL(__restore_cpu_power7) /* place holder */ blr - -/* - * Get a minimal set of registers for our caller's nth caller. - * r3 = regs pointer, r5 = n. - * - * We only get R1 (stack pointer), NIP (next instruction pointer) - * and LR (link register). These are all we can get in the - * general case without doing complicated stack unwinding, but - * fortunately they are enough to do a stack backtrace, which - * is all we need them for. - */ -_GLOBAL(perf_arch_fetch_caller_regs) - mr r6,r1 - cmpwi r5,0 - mflr r4 - ble 2f - mtctr r5 -1: PPC_LL r6,0(r6) - bdnz 1b - PPC_LL r4,PPC_LR_STKOFF(r6) -2: PPC_LL r7,0(r6) - PPC_LL r7,PPC_LR_STKOFF(r7) - PPC_STL r6,GPR1-STACK_FRAME_OVERHEAD(r3) - PPC_STL r4,_NIP-STACK_FRAME_OVERHEAD(r3) - PPC_STL r7,_LINK-STACK_FRAME_OVERHEAD(r3) - blr
arch/sparc/include/asm/perf_event.h +4 -0
@@ -7,6 +7,10 @@ extern void set_perf_event_pending(void);#ifdef CONFIG_PERF_EVENTS extern void init_hw_perf_events (void ); + +#define perf_arch_fetch_caller_regs (pt_regs, ip) \ + __perf_arch_fetch_caller_regs(pt_regs, ip, 1); +#endif #else static inline void init_hw_perf_events (void ) { }#endif
arch/sparc/kernel/helpers.S +3 -3
@@ -47,9 +47,9 @@ stack_trace_flush: .size stack_trace_flush,.-stack_trace_flush #ifdef CONFIG_PERF_EVENTS - .globl perf_arch_fetch_caller_regs - .type perf_arch_fetch_caller_regs,#function -perf_arch_fetch_caller_regs: + .globl __perf_arch_fetch_caller_regs + .type __perf_arch_fetch_caller_regs,#function +__perf_arch_fetch_caller_regs: /* We always read the %pstate into %o5 since we will use * that to construct a fake %tstate to store into the regs. */
arch/x86/include/asm/perf_event.h +9 -0
@@ -140,6 +140,15 @@ extern unsigned long perf_instruction_pointer(struct pt_regs *regs);extern unsigned long perf_misc_flags (struct pt_regs *regs);#define perf_misc_flags (regs) perf_misc_flags(regs) +#include <asm/stacktrace.h> + +#define perf_arch_fetch_caller_regs (regs, __ip) { \ + (regs)->ip = (__ip); \ + (regs)->bp = caller_frame_pointer(); \ + (regs)->cs = __KERNEL_CS; \ + local_save_flags((regs)->flags); \ +} +#else static inline void init_hw_perf_events (void ) { }static inline void perf_events_lapic_init (void ) { }
arch/x86/include/asm/stacktrace.h +2 -5
@@ -78,17 +78,14 @@ struct stack_frame_ia32 {u32 return_address; }; -static inline unsigned long rewind_frame_pointer (int n) +static inline unsigned long caller_frame_pointer (void ) {struct stack_frame *frame;get_bp (frame);#ifdef CONFIG_FRAME_POINTER -while (n--) { -if (probe_kernel_address (&frame->next_frame, frame)) -break ; - } + frame = frame->next_frame;#endif return (unsigned long )frame;
arch/x86/kernel/cpu/perf_event.c +0 -12
@@ -1706,18 +1706,6 @@ struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)return entry; } -void perf_arch_fetch_caller_regs (struct pt_regs *regs,unsigned long ip,int skip) -{ - regs->ip = ip; -/* -* perf_arch_fetch_caller_regs adds another call, we need to increment -* the skip level -*/ - regs->bp =rewind_frame_pointer (skip +1 ); - regs->cs = __KERNEL_CS; -local_save_flags (regs->flags); -} -unsigned long perf_instruction_pointer (struct pt_regs *regs) {unsigned long ip;
include/linux/perf_event.h +7 -25
@@ -903,8 +903,10 @@ extern atomic_t perf_swevent_enabled[PERF_COUNT_SW_MAX];extern void __perf_sw_event (u32 ,u64 ,int ,struct pt_regs *,u64 ); -extern void -perf_arch_fetch_caller_regs (struct pt_regs *regs,unsigned long ip,int skip); +#ifndef perf_arch_fetch_caller_regs +static inline void +perf_arch_fetch_caller_regs (struct regs *regs,unsigned long ip) { } +#endif /* * Take a snapshot of the regs. Skip ip and frame pointer to
@@ -914,31 +916,11 @@ perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip, int skip);* - bp for callchains * - eflags, for future purposes, just in case */ -static inline void perf_fetch_caller_regs (struct pt_regs *regs,int skip) +static inline void perf_fetch_caller_regs (struct pt_regs *regs) { -unsigned long ip; -memset (regs,0 ,sizeof (*regs)); -switch (skip) { -case 1 : - ip =CALLER_ADDR0 ; -break ; -case 2 : - ip =CALLER_ADDR1 ; -break ; -case 3 : - ip =CALLER_ADDR2 ; -break ; -case 4 : - ip =CALLER_ADDR3 ; -break ; -/* No need to support further for now */ -default : - ip =0 ; - } - -return perf_arch_fetch_caller_regs (regs, ip, skip); +perf_arch_fetch_caller_regs (regs,CALLER_ADDR0 ); } static inline void
@@ -948,7 +930,7 @@ perf_sw_event(u32 event_id, u64 nr, int nmi, struct pt_regs *regs, u64 addr)struct pt_regs hot_regs;if (!regs) { -perf_fetch_caller_regs (&hot_regs,1 ); +perf_fetch_caller_regs (&hot_regs); regs = &hot_regs; }__perf_sw_event (event_id, nr, nmi, regs, addr);
include/trace/ftrace.h +1 -1
@@ -801,7 +801,7 @@ static notrace void perf_trace_##call(proto) \ struct ftrace_event_call *event_call = &event_##call; \ struct pt_regs *__regs = &get_cpu_var(perf_trace_regs); \ \ - perf_fetch_caller_regs(__regs, 1); \ + perf_fetch_caller_regs(__regs); \ \ perf_trace_templ_##template(event_call, __regs, args); \ \
kernel/perf_event.c +0 -5
@@ -2842,11 +2842,6 @@ __weak struct perf_callchain_entry *perf_callchain(struct pt_regs *regs)return NULL ; } -__weak -void perf_arch_fetch_caller_regs (struct pt_regs *regs,unsigned long ip,int skip) -{ -} -/* * We assume there is only KVM supporting the callbacks.
kernel/trace/trace_event_perf.c +0 -2
@@ -12,8 +12,6 @@ DEFINE_PER_CPU(struct pt_regs, perf_trace_regs);EXPORT_PER_CPU_SYMBOL_GPL (perf_trace_regs); -EXPORT_SYMBOL_GPL (perf_arch_fetch_caller_regs); -static char *perf_trace_buf;static char *perf_trace_buf_nmi;
Signature · 1 line
1.6.2.3
Peter Zijlstra
maintainerRe: [PATCH 2/2] perf: Drop the skip argument from perf_arch_fetch_regs_caller
include/linux/perf_event.h perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip, int skip); · line 921
Quoted 5 lines · Frederic Weisbecker
include/linux/perf_event.h +1
-2+static inline void perf_fetch_caller_regs (struct pt_regs *regs) { -unsigned long ip; -memset (regs,0 ,sizeof (*regs));
btw, do we really need that memset?
As long as we don't actually copy out to userspace, it really doesn't matter what is in there, and we should be setting all relevant registers anyway.
Re: [PATCH 2/2] perf: Drop the skip argument from perf_arch_fetch_regs_caller
Quoted 9 lines · Peter Zijlstra
include/linux/perf_event.h perf_arch_fetch_caller_regs(struct pt_regs *regs, unsigned long ip, int skip); · line 921
Quoted 5 lines · Frederic Weisbecker
include/linux/perf_event.h +1
-2+static inline void perf_fetch_caller_regs (struct pt_regs *regs) { -unsigned long ip; -memset (regs,0 ,sizeof (*regs));btw, do we really need that memset?
Quoted 3 lines
As long as we don't actually copy out to userspace, it really doesn't matter what is in there, and we should be setting all relevant registers anyway.
We probably need to decouple that yeah.
- If we don't do callchains, we don't need to deref bp
- If we don't copy to userspace, we don't need to zeroe
We should do the filling much later for tracepoints in fact, but that doesn't concern syscalls or kprobes.
But well, I'll iterate that step by step.