lkml.org 
[lkml]   [2009]   [Feb]   [11]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    /
    Date
    From
    SubjectRe: [PATCH 0/7][RFC] function graph tracer port to PowerPC
    On Wed, Feb 11, 2009 at 08:10:51PM -0500, Steven Rostedt wrote:
    >
    > The following set of patches are RFC and not for inclusion
    > (unless everyone is fine with them as is).
    >
    > This is the port to PowerPC of the function graph tracer that was written
    > by Frederic Weisbecker for the x86 architecture. It is broken up
    > into a series of logical steps.
    >
    > 1) get generic code ready for other archs
    > 2) get PowerPC 64-bit working with just static function tracing
    > 3) get PowerPC 64-bit working with dynamic function tracing
    > 4) get PowerPC 32-bit working with just static function tracing
    > 5) get PowerPC 32-bit working with dynamic function tracing
    >
    > (with some clean ups in between)
    >


    Thanks a lot Steven!
    I'm sad to not having a Power Pc to test it...


    > The function graph tracer not only traces the start of a function
    > (uses the function tracer part for that) but also uses the kprobes
    > trick to replace the return address with a hook to trace the exit
    > of the function. These hooks are generic in that other tracers
    > can also use them. But the function graph tracer itself is very
    > powerful. Simply doing the following:
    >
    > # echo function_graph > /debug/tracing/current_tracer
    > # cat /debug/tracing/trace
    >
    > # tracer: function_graph
    > #
    > # CPU OVERHEAD/DURATION FUNCTION CALLS
    > # | | | | | | |
    > ------------------------------------------
    > 0) less-2228 => cat-2229
    > ------------------------------------------
    >
    > 0) | .__do_fault() {
    > 0) | .filemap_fault() {
    > 0) | .find_lock_page() {
    > 0) | .find_get_page() {
    > 0) 3.168 us | .__rcu_read_lock();
    > 0) 2.704 us | .__rcu_read_unlock();
    > 0) + 14.640 us | }
    > 0) + 20.112 us | }
    > 0) + 26.464 us | }
    > 0) 2.912 us | ._spin_lock();
    > 0) 2.656 us | .page_add_file_rmap();
    > 0) | .update_mmu_cache() {
    > 0) | .hash_preload() {
    > 0) 2.368 us | .get_slice_psize();
    > 0) 2.752 us | .hash_page_do_lazy_icache();
    > 0) 3.568 us | .native_hpte_insert();
    > 0) + 19.680 us | }
    > 0) + 24.960 us | }
    > 0) 2.336 us | ._spin_unlock();
    > 0) | .unlock_page() {
    > 0) 2.688 us | .page_waitqueue();
    > 0) 2.608 us | .__wake_up_bit();
    > 0) + 12.912 us | }
    > 0) ! 351.776 us | }
    > 0) ! 357.392 us | }
    > 0) 3.040 us | .up_read();
    > 0) | .compat_sys_ioctl() {
    > 0) 3.024 us | .fget_light();
    > 0) | .tty_compat_ioctl() {
    > 0) 2.704 us | .tty_paranoia_check();
    > 0) | .tty_ldisc_ref_wait() {
    > 0) | .tty_ldisc_try() {
    > 0) 2.880 us | ._spin_lock_irqsave();
    > 0) 2.928 us | ._spin_unlock_irqrestore();
    > 0) + 13.776 us | }
    > 0) + 19.424 us | }
    >
    > [...]
    >
    > As you can see, it gives a nice call trace of the functions being called
    > at run time, as well as a time stamp of how much time the function
    > took to execute.
    >
    > Adding dynamic tracing to the mix, we can trace a single function:
    >
    > # echo .do_fork > /debug/tracing/set_graph_function
    > # echo function_graph > /debug/tracing/current_tracer
    > # cat /debug/tracing/trace
    >
    > # tracer: function_graph
    > #
    > # CPU OVERHEAD/DURATION FUNCTION CALLS
    > # | | | | | | |
    > 1) | .do_fork() {
    > 1) | .copy_process() {
    > 1) | .prepare_to_copy() {
    > 1) 2.944 us | .flush_fp_to_thread();
    > 1) 2.800 us | .flush_altivec_to_thread();
    > 1) 2.608 us | .flush_vsx_to_thread();
    > 1) + 19.184 us | }
    > 1) | .kmem_cache_alloc() {
    > 1) 2.464 us | .slab_should_failslab();
    > 1) 8.304 us | }
    > 1) | .alloc_thread_info() {
    > 1) | .kmem_cache_alloc() {
    > 1) 2.512 us | .slab_should_failslab();
    > 1) 8.224 us | }
    > 1) + 13.344 us | }
    > 1) 7.584 us | .arch_dup_task_struct();
    > 1) | .copy_creds() {
    > 1) 2.736 us | .__mutex_init();
    > 1) | .prepare_creds() {
    > 1) | .kmem_cache_alloc() {
    > 1) 2.640 us | .slab_should_failslab();
    > 1) 8.368 us | }
    >
    > [...]
    >
    >
    > Note, the '.' in the '.do_fork' is a PowerPC64 thing. PowerPC32 and
    > other archs just need to do 'do_fork', without the dot.
    >
    >
    > The following patches are in:
    >
    > git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-2.6-trace.git
    >
    > branch: rfc/ppc/ftrace
    >
    >
    > Steven Rostedt (7):
    > tracing/function-graph-tracer: make arch generic push pop functions
    > powerpc64: port of the function graph tracer
    > powerpc64, tracing: add function graph tracer with dynamic tracing
    > powerpc64, ftrace: save toc only on modules for function graph
    > powerpc32, ftrace: save and restore mcount regs with macro
    > powerpc32, ftrace: port function graph tracer to ppc32, static only
    > powerpc32, ftrace: dynamic function graph tracer
    >
    > ----
    > arch/powerpc/Kconfig | 1 +
    > arch/powerpc/include/asm/ftrace.h | 39 ++++++++++-
    > arch/powerpc/kernel/Makefile | 9 +-
    > arch/powerpc/kernel/entry_32.S | 115 ++++++++++++++---------------
    > arch/powerpc/kernel/entry_64.S | 89 +++++++++++++++++++++-
    > arch/powerpc/kernel/ftrace.c | 135 ++++++++++++++++++++++++++++++++--
    > arch/powerpc/kernel/process.c | 16 ++++
    > arch/powerpc/kernel/vmlinux.lds.S | 1 +
    > arch/x86/include/asm/ftrace.h | 25 ------
    > arch/x86/kernel/ftrace.c | 75 +------------------
    > include/linux/ftrace.h | 24 ++++++
    > kernel/trace/trace_functions_graph.c | 75 +++++++++++++++++++
    > 12 files changed, 428 insertions(+), 176 deletions(-)
    > --



    \
     
     \ /
      Last update: 2009-02-12 02:57    [W:0.031 / U:119.380 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site