tracing/core changes for v2.6.34
Subsystems (9)
Linus,
Please pull the latest tracing-core-for-linus git tree from:
git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip.git tracing-core-for-linus
Thanks,
Ingo
------------------>
Frederic Weisbecker (1):
tracing: Drop the tr check from the graph tracing path
Heiko Carstens (3):
tracing/kprobes: Make Kconfig dependencies generic
s390: Add pt_regs register and stack access API tracing/kprobes: Add short documentation for HAVE_REGS_AND_STACK_ACCESS_API
Jeff Mahoney (1):
tracing: Fix ftrace_event_call alignment for use with gcc 4.5
Lai Jiangshan (8):
tracing: Have __dynamic_array() define a field
tracing: Add print_fmt field
tracing/syscalls: Init print_fmt for syscall events tracing/kprobes: Init print_fmt for kprobe events
tracing: Use defined fields and print_fmt to print formats
tracing: Remove show_format and related macros from TRACE_EVENT
tracing: Consolidate protection of reader access to the ring buffer
tracing: Simplify test for function_graph tracing start point
Li Zefan (2):
ftrace: Allow to remove a single function from function graph filter
tracing: Remove CONFIG_TRACE_POWER from kernel config
Mike Frysinger (1):
tracing: Unify arch_syscall_addr() implementations
Steven Rostedt (6):
tracing: Have syscall tracing call its own init function
tracing: Add stack dump to trace_printk if stacktrace option is set
tracing: Add correct/incorrect to sort keys for branch annotation output
tracing: Add notrace to TRACE_EVENT implementation functions
ftrace: Remove memory barriers from NMI code when not needed
ftrace: Add function names to dangling } in function graph tracer
Wenji Huang (4):
tracing: Fix typo in prof_sysexit_enable()
tracing: Fix typo of info text in trace_kprobe.c
tracing: Remove unnecessary variable in print_graph_return
tracing: Simplify memory recycle of trace_define_field
Wolfram Sang (2):
tracing: optimize recordmcount.pl for offsets-handling
tracing: Use appropriate perl constructs in recordmcount.pl
Documentation/trace/ftrace-design.txt | 5 +- arch/Kconfig | 8 ++ arch/s390/Kconfig | 1 + arch/s390/include/asm/ptrace.h | 13 ++- arch/s390/include/asm/syscall.h | 7 + arch/s390/kernel/ftrace.c | 10 -- arch/s390/kernel/ptrace.c | 58 ++++++++++ arch/sh/include/asm/syscall.h | 2 + arch/sh/kernel/ftrace.c | 9 -- arch/sparc/include/asm/syscall.h | 7 + arch/sparc/kernel/ftrace.c | 11 -- arch/x86/Kconfig | 1 + arch/x86/include/asm/syscall.h | 2 + arch/x86/kernel/ftrace.c | 36 +++++-- include/linux/ftrace.h | 6 + include/linux/ftrace_event.h | 3 +- include/linux/syscalls.h | 12 +- include/trace/ftrace.h | 195 +++++++++------------------------ include/trace/syscall.h | 4 - kernel/trace/Kconfig | 11 +-- kernel/trace/ftrace.c | 51 +++++---- kernel/trace/trace.c | 144 +++++++++++++++++------- kernel/trace/trace.h | 6 +- kernel/trace/trace_branch.c | 19 +++- kernel/trace/trace_events.c | 81 +++++++------- kernel/trace/trace_export.c | 87 ++------------- kernel/trace/trace_functions_graph.c | 78 +++++++++---- kernel/trace/trace_kprobe.c | 108 ++++++++----------- kernel/trace/trace_syscalls.c | 113 ++++++++++--------- scripts/recordmcount.pl | 39 +++---- 30 files changed, 580 insertions(+), 547 deletions(-)
Documentation/trace/ftrace-design.txt +2 -3
@@ -238,11 +238,10 @@ HAVE_SYSCALL_TRACEPOINTS You need very few things to get the syscalls tracing in an arch. +- Support HAVE_ARCH_TRACEHOOK (see arch/Kconfig). - Have a NR_syscalls variable in <asm/unistd.h> that provides the number of syscalls supported by the arch. -- Implement arch_syscall_addr() that resolves a syscall address from a - syscall number. -- Support the TIF_SYSCALL_TRACEPOINT thread flags +- Support the TIF_SYSCALL_TRACEPOINT thread flags. - Put the trace_sys_enter() and trace_sys_exit() tracepoints calls from ptrace in the ptrace syscalls tracing path. - Tag this arch as HAVE_SYSCALL_TRACEPOINTS.
arch/Kconfig +8 -0
@@ -121,6 +121,14 @@ config HAVE_DMA_ATTRS config USE_GENERIC_SMP_HELPERS bool +config HAVE_REGS_AND_STACK_ACCESS_API + bool + help + This symbol should be selected by an architecure if it supports + the API needed to access registers and stack entries from pt_regs, + declared in asm/ptrace.h + For example the kprobes-based event tracer needs this API. + config HAVE_CLK bool help
arch/s390/Kconfig +1 -0
@@ -87,6 +87,7 @@ config S390 select HAVE_SYSCALL_TRACEPOINTS select HAVE_DYNAMIC_FTRACE select HAVE_FUNCTION_GRAPH_TRACER + select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_DEFAULT_NO_SPIN_MUTEXES select HAVE_OPROFILE select HAVE_KPROBES
arch/s390/include/asm/ptrace.h +12 -1
@@ -492,13 +492,24 @@ struct user_regs_structstruct task_struct ;extern void user_enable_single_step (struct task_struct *);extern void user_disable_single_step (struct task_struct *); +extern void show_regs (struct pt_regs * regs);#define user_mode (regs) (((regs)->psw.mask & PSW_MASK_PSTATE) != 0)#define instruction_pointer (regs) ((regs)->psw.addr & PSW_ADDR_INSN)#define user_stack_pointer (regs)((regs)->gprs[15])#define regs_return_value (regs)((regs)->gprs[2])#define profile_pc (regs) instruction_pointer(regs) -extern void show_regs (struct pt_regs * regs); + +int regs_query_register_offset (const char *name); +const char *regs_query_register_name (unsigned int offset); +unsigned long regs_get_register (struct pt_regs *regs,unsigned int offset); +unsigned long regs_get_kernel_stack_nth (struct pt_regs *regs,unsigned int n); + +static inline unsigned long kernel_stack_pointer (struct pt_regs *regs) +{ +return regs->gprs[15 ] &PSW_ADDR_INSN ; +} +#endif /* __KERNEL__ */ #endif /* __ASSEMBLY__ */
arch/s390/include/asm/syscall.h +7 -0
@@ -15,6 +15,13 @@#include <linux/sched.h> #include <asm/ptrace.h> +/* +* The syscall table always contains 32 bit pointers since we know that the +* address of the function to be called is (way) below 4GB. So the "int" +* type here is what we want [need] for both 32 bit and 64 bit systems. +*/ +extern const unsigned int sys_call_table[]; +static inline long syscall_get_nr (struct task_struct *task,struct pt_regs *regs) {
arch/s390/kernel/ftrace.c +0 -10
@@ -200,13 +200,3 @@ out: return parent; }#endif /* CONFIG_FUNCTION_GRAPH_TRACER */ - -#ifdef CONFIG_FTRACE_SYSCALLS - -extern unsigned int sys_call_table[]; - -unsigned long __init arch_syscall_addr (int nr) -{ -return (unsigned long )sys_call_table[nr]; -} -#endif
arch/s390/kernel/ptrace.c +58 -0
61 lines not on this page · raw message
arch/sh/include/asm/syscall.h +2 -0
@@ -1,6 +1,8 @@#ifndef __ASM_SH_SYSCALL_H#define __ASM_SH_SYSCALL_H +extern const unsigned long sys_call_table[]; +#ifdef CONFIG_SUPERH32 # include "syscall_32.h" #else
arch/sh/kernel/ftrace.c +0 -9
@@ -399,12 +399,3 @@ void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr) } }#endif /* CONFIG_FUNCTION_GRAPH_TRACER */ - -#ifdef CONFIG_FTRACE_SYSCALLS -extern unsigned long *sys_call_table; - -unsigned long __init arch_syscall_addr (int nr) -{ -return (unsigned long )sys_call_table[nr]; -} -#endif /* CONFIG_FTRACE_SYSCALLS */
arch/sparc/include/asm/syscall.h +7 -0
@@ -5,6 +5,13 @@#include <linux/sched.h> #include <asm/ptrace.h> +/* +* The syscall table always contains 32 bit pointers since we know that the +* address of the function to be called is (way) below 4GB. So the "int" +* type here is what we want [need] for both 32 bit and 64 bit systems. +*/ +extern const unsigned int sys_call_table[]; +/* The system call number is given by the user in %g1 */ static inline long syscall_get_nr (struct task_struct *task,struct pt_regs *regs)
arch/sparc/kernel/ftrace.c +0 -11
@@ -91,14 +91,3 @@ int __init ftrace_dyn_arch_init(void *data) return 0; }#endif - -#ifdef CONFIG_FTRACE_SYSCALLS - -extern unsigned int sys_call_table[]; - -unsigned long __init arch_syscall_addr (int nr) -{ -return (unsigned long )sys_call_table[nr]; -} - -#endif
arch/x86/Kconfig +1 -0
@@ -45,6 +45,7 @@ config X86 select HAVE_GENERIC_DMA_COHERENT if X86_32 select HAVE_EFFICIENT_UNALIGNED_ACCESS select USER_STACKTRACE_SUPPORT + select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_DMA_API_DEBUG select HAVE_KERNEL_GZIP select HAVE_KERNEL_BZIP2
arch/x86/include/asm/syscall.h +2 -0
@@ -16,6 +16,8 @@#include <linux/sched.h> #include <linux/err.h> +extern const unsigned long sys_call_table[]; +/* * Only the low 32 bits of orig_ax are meaningful, so we return int. * This importantly ignores the high bits on 64-bit, so comparisons
arch/x86/kernel/ftrace.c +26 -10
@@ -30,14 +30,32 @@#ifdef CONFIG_DYNAMIC_FTRACE +/* +* modifying_code is set to notify NMIs that they need to use +* memory barriers when entering or exiting. But we don't want +* to burden NMIs with unnecessary memory barriers when code +* modification is not being done (which is most of the time). +* +* A mutex is already held when ftrace_arch_code_modify_prepare +* and post_process are called. No locks need to be taken here. +* +* Stop machine will make sure currently running NMIs are done +* and new NMIs will see the updated variable before we need +* to worry about NMIs doing memory barriers. +*/ +static int modifying_code__read_mostly ; +static DEFINE_PER_CPU(int, save_modifying_code); +int ftrace_arch_code_modify_prepare (void ) {set_kernel_text_rw (); + modifying_code =1 ;return 0 ; }int ftrace_arch_code_modify_post_process (void ) { + modifying_code =0 ;set_kernel_text_ro ();return 0 ; }
@@ -149,6 +167,11 @@ static void ftrace_mod_code(void)void ftrace_nmi_enter (void ) { +__get_cpu_var (save_modifying_code) = modifying_code; + +if (!__get_cpu_var (save_modifying_code)) +return ; +if (atomic_inc_return (&nmi_running) &MOD_CODE_WRITE_FLAG ) {smp_rmb ();ftrace_mod_code ();
@@ -160,6 +183,9 @@ void ftrace_nmi_enter(void)void ftrace_nmi_exit (void ) { +if (!__get_cpu_var (save_modifying_code)) +return ; +/* Finish all executions before clearing nmi_running */ smp_mb ();atomic_dec (&nmi_running);
@@ -484,13 +510,3 @@ void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr, } }#endif /* CONFIG_FUNCTION_GRAPH_TRACER */ - -#ifdef CONFIG_FTRACE_SYSCALLS - -extern unsigned long *sys_call_table; - -unsigned long __init arch_syscall_addr (int nr) -{ -return (unsigned long )(&sys_call_table)[nr]; -} -#endif
include/linux/ftrace.h +6 -0
@@ -511,4 +511,10 @@ static inline void trace_hw_branch_oops(void) {}#endif /* CONFIG_HW_BRANCH_TRACER */ +#ifdef CONFIG_FTRACE_SYSCALLS + +unsigned long arch_syscall_addr (int nr); + +#endif /* CONFIG_FTRACE_SYSCALLS */ +#endif /* _LINUX_FTRACE_H */
include/linux/ftrace_event.h +1 -2
@@ -121,9 +121,8 @@ struct ftrace_event_call {int (*regfunc)(struct ftrace_event_call *);void (*unregfunc)(struct ftrace_event_call *);int id; +const char *print_fmt;int (*raw_init)(struct ftrace_event_call *); -int (*show_format)(struct ftrace_event_call *, -struct trace_seq *);int (*define_fields)(struct ftrace_event_call *);struct list_head fields;int filter_active;
include/linux/syscalls.h +6 -6
@@ -132,7 +132,8 @@ struct perf_event_attr;#define SYSCALL_TRACE_ENTER_EVENT (sname) \ static const struct syscall_metadata __syscall_meta_##sname; \ - static struct ftrace_event_call event_enter_##sname; \ + static struct ftrace_event_call \ + __attribute__((__aligned__(4))) event_enter_##sname; \ static struct trace_event enter_syscall_print_##sname = { \ .trace = print_syscall_enter, \ }; \
@@ -143,8 +144,7 @@ struct perf_event_attr; .name = "sys_enter"#sname, \ .system = "syscalls", \ .event = &enter_syscall_print_##sname, \ - .raw_init = trace_event_raw_init, \ - .show_format = syscall_enter_format, \ + .raw_init = init_syscall_trace, \ .define_fields = syscall_enter_define_fields, \ .regfunc = reg_event_syscall_enter, \ .unregfunc = unreg_event_syscall_enter, \
@@ -154,7 +154,8 @@ struct perf_event_attr;#define SYSCALL_TRACE_EXIT_EVENT (sname) \ static const struct syscall_metadata __syscall_meta_##sname; \ - static struct ftrace_event_call event_exit_##sname; \ + static struct ftrace_event_call \ + __attribute__((__aligned__(4))) event_exit_##sname; \ static struct trace_event exit_syscall_print_##sname = { \ .trace = print_syscall_exit, \ }; \
@@ -165,8 +166,7 @@ struct perf_event_attr; .name = "sys_exit"#sname, \ .system = "syscalls", \ .event = &exit_syscall_print_##sname, \ - .raw_init = trace_event_raw_init, \ - .show_format = syscall_exit_format, \ + .raw_init = init_syscall_trace, \ .define_fields = syscall_exit_define_fields, \ .regfunc = reg_event_syscall_exit, \ .unregfunc = unreg_event_syscall_exit, \
include/trace/ftrace.h +53 -142
319 lines not on this page · raw message
include/trace/syscall.h +0 -4
@@ -34,10 +34,6 @@ struct syscall_metadata {extern unsigned long arch_syscall_addr (int nr);extern int init_syscall_trace (struct ftrace_event_call *call); -extern int syscall_enter_format (struct ftrace_event_call *call, -struct trace_seq *s); -extern int syscall_exit_format (struct ftrace_event_call *call, -struct trace_seq *s);extern int syscall_enter_define_fields (struct ftrace_event_call *call);extern int syscall_exit_define_fields (struct ftrace_event_call *call);extern int reg_event_syscall_enter (struct ftrace_event_call *call);
kernel/trace/Kconfig +1 -10
@@ -328,15 +328,6 @@ config BRANCH_TRACER Say N if unsure. -config POWER_TRACER - bool "Trace power consumption behavior" - depends on X86 - select GENERIC_TRACER - help - This tracer helps developers to analyze and optimize the kernel's - power management decisions, specifically the C-state and P-state - behavior. - config KSYM_TRACER bool "Trace read and write access on kernel memory locations" depends on HAVE_HW_BREAKPOINT
@@ -449,7 +440,7 @@ config BLK_DEV_IO_TRACE config KPROBE_EVENT depends on KPROBES - depends on X86 + depends on HAVE_REGS_AND_STACK_ACCESS_API bool "Enable kprobes-based dynamic events" select TRACING default y
kernel/trace/ftrace.c +31 -20
110 lines not on this page · raw message
kernel/trace/trace.c +103 -41
273 lines not on this page · raw message
kernel/trace/trace.h +4 -2
@@ -497,6 +497,7 @@ trace_print_graph_duration(unsigned long long duration, struct trace_seq *s);#ifdef CONFIG_DYNAMIC_FTRACE /* TODO: make this variable */ #define FTRACE_GRAPH_MAX_FUNCS 32 +extern int ftrace_graph_filter_enabled;extern int ftrace_graph_count;extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS ];
@@ -504,7 +505,7 @@ static inline int ftrace_graph_addr(unsigned long addr) {int i; -if (!ftrace_graph_count ||test_tsk_trace_graph (current)) +if (!ftrace_graph_filter_enabled)return 1 ;for (i =0 ; i < ftrace_graph_count; i++) {
@@ -791,7 +792,8 @@ extern const char *__stop___trace_bprintk_fmt[];#undef FTRACE_ENTRY#define FTRACE_ENTRY (call, struct_name, id, tstruct, print) \ - extern struct ftrace_event_call event_##call; + extern struct ftrace_event_call \ + __attribute__((__aligned__(4))) event_##call;#undef FTRACE_ENTRY_DUP#define FTRACE_ENTRY_DUP (call, struct_name, id, tstruct, print) \ FTRACE_ENTRY(call, struct_name, id, PARAMS(tstruct), PARAMS(print))
kernel/trace/trace_branch.c +17 -2
@@ -307,8 +307,23 @@ static int annotated_branch_stat_cmp(void *p1, void *p2)return -1 ;if (percent_a > percent_b)return 1 ; -else -return 0 ; + +if (a->incorrect < b->incorrect) +return -1 ; +if (a->incorrect > b->incorrect) +return 1 ; + +/* +* Since the above shows worse (incorrect) cases +* first, we continue that by showing best (correct) +* cases last. +*/ +if (a->correct > b->correct) +return -1 ; +if (a->correct < b->correct) +return 1 ; + +return 0 ; }static struct tracer_stat annotated_branch_stats = {
kernel/trace/trace_events.c +42 -39
117 lines not on this page · raw message
kernel/trace/trace_export.c +13 -74
117 lines not on this page · raw message
kernel/trace/trace_functions_graph.c +54 -24
163 lines not on this page · raw message
kernel/trace/trace_kprobe.c +46 -62
168 lines not on this page · raw message
kernel/trace/trace_syscalls.c +59 -54
148 lines not on this page · raw message
scripts/recordmcount.pl +18 -21
@@ -136,13 +136,14 @@ my %text_sections = ( ".text.unlikely" => 1, ); -$objdump = "objdump" if ((length $objdump) == 0); -$objcopy = "objcopy" if ((length $objcopy) == 0); -$cc = "gcc" if ((length $cc) == 0); -$ld = "ld" if ((length $ld) == 0); -$nm = "nm" if ((length $nm) == 0); -$rm = "rm" if ((length $rm) == 0); -$mv = "mv" if ((length $mv) == 0); +# Note: we are nice to C-programmers here, thus we skip the '||='-idiom. +$objdump = 'objdump' if (!$objdump); +$objcopy = 'objcopy' if (!$objcopy); +$cc = 'gcc' if (!$cc); +$ld = 'ld' if (!$ld); +$nm = 'nm' if (!$nm); +$rm = 'rm' if (!$rm); +$mv = 'mv' if (!$mv); #print STDERR "running: $P '$arch' '$objdump' '$objcopy' '$cc' '$ld' " . # "'$nm' '$rm' '$mv' '$inputfile'\n";
@@ -432,14 +433,14 @@ sub update_funcs # Loop through all the mcount caller offsets and print a reference # to the caller based from the ref_func. - for (my $i=0; $i <= $#offsets; $i++) { - if (!$opened) { - open(FILE, ">$mcount_s") || die "can't create $mcount_s\n"; - $opened = 1; - print FILE "\t.section $mcount_section,\"a\",$section_type\n"; - print FILE "\t.align $alignment\n" if (defined($alignment)); - } - printf FILE "\t%s %s + %d\n", $type, $ref_func, $offsets[$i] - $offset; + if (!$opened) { + open(FILE, ">$mcount_s") || die "can't create $mcount_s\n"; + $opened = 1; + print FILE "\t.section $mcount_section,\"a\",$section_type\n"; + print FILE "\t.align $alignment\n" if (defined($alignment)); + } + foreach my $cur_offset (@offsets) { + printf FILE "\t%s %s + %d\n", $type, $ref_func, $cur_offset - $offset; } }
@@ -476,11 +477,7 @@ while (<IN>) { $read_headers = 0; # Only record text sections that we know are safe - if (defined($text_sections{$1})) { - $read_function = 1; - } else { - $read_function = 0; - } + $read_function = defined($text_sections{$1}); # print out any recorded offsets update_funcs();
@@ -514,7 +511,7 @@ while (<IN>) { } # is this a call site to mcount? If so, record it to print later if ($text_found && /$mcount_regex/) { - $offsets[$#offsets + 1] = hex $1; + push(@offsets, hex $1); } }