Doug / smarc-fsl-linux-kernel

11 Jun, 2013

1 commit

05 Apr, 2013

1 commit

  • ad8c39693   MIPS: Unbreak function tracer for 64-bit kernel. ... Browse Code »

    Commit 58b69401c797 [MIPS: Function tracer: Fix broken function tracing]
    completely broke the function tracer for 64-bit kernels. The symptom is
    a system hang very early in the boot process.

    The fix: Remove/fix $sp adjustments for 64-bit case.

    Signed-off-by: David Daney
    Cc: linux-mips@linux-mips.org
    Cc: Al Cooper
    Cc: viric@viric.name
    Cc: stable@vger.kernel.org # 3.8.x
    Signed-off-by: Ralf Baechle

    David Daney
     

31 Jan, 2013

1 commit

  • 58b69401c   MIPS: Function tracer: Fix broken function tracing ... Browse Code »

    Function tracing is currently broken for all 32 bit MIPS platforms.
    When tracing is enabled, the kernel immediately hangs on boot.
    This is a result of commit b732d439cb43336cd6d7e804ecb2c81193ef63b0
    that changes the kernel/trace/Kconfig file so that is no longer
    forces FRAME_POINTER when FUNCTION_TRACING is enabled.

    MIPS frame pointers are generally considered to be useless because
    they cannot be used to unwind the stack. Unfortunately the MIPS
    function tracing code has bugs that are masked by the use of frame
    pointers. This commit fixes the bugs so that MIPS frame pointers
    don't need to be enabled.

    The bugs are a result of the odd calling sequence used to call the trace
    routine. This calling sequence is inserted into every traceable function
    when the tracing CONFIG option is enabled. This sequence is generated
    for 32bit MIPS platforms by the compiler via the "-pg" flag.

    Part of the sequence is "addiu sp,sp,-8" in the delay slot after every
    call to the trace routine "_mcount" (some legacy thing where 2 arguments
    used to be pushed on the stack). The _mcount routine is expected to
    adjust the sp by +8 before returning. So when not disabled, the original
    jalr and addiu will be there, so _mcount has to adjust sp.

    The problem is that when tracing is disabled for a function, the
    "jalr _mcount" instruction is replaced with a nop, but the
    "addiu sp,sp,-8" is still executed and the stack pointer is left
    trashed. When frame pointers are enabled the problem is masked
    because any access to the stack is done through the frame
    pointer and the stack pointer is restored from the frame pointer when
    the function returns.

    This patch writes two nops starting at the address of the "jalr _mcount"
    instruction whenever tracing is disabled. This means that the
    "addiu sp,sp.-8" will be converted to a nop along with the "jalr". When
    disabled, there will be two nops.

    This is SMP safe because the first time this happens is during
    ftrace_init() which is before any other processor has been started.
    Subsequent calls to enable/disable tracing when other CPUs ARE running
    will still be safe because the enable will only change the first nop
    to a "jalr" and the disable, while writing 2 nops, will only be changing
    the "jalr". This patch also stops using stop_machine() to call the
    tracer enable/disable routines and calls them directly because the
    routines are SMP safe.

    When the kernel first boots we have to be able to handle the gcc
    generated jalr, addui sequence until ftrace_init gets a chance to run
    and change the sequence. At this point mcount just adjusts the stack
    and returns. When ftrace_init runs, we convert the jalr/addui to nops.
    Then whenever tracing is enabled we convert the first nop to a "jalr
    mcount+8". The mcount+8 entry point skips the stack adjust.

    [ralf@linux-mips.org: Folded in Steven Rostedt's build fix.]

    Signed-off-by: Al Cooper
    Cc: rostedt@goodmis.org
    Cc: ddaney.cavm@gmail.com
    Cc: linux-mips@linux-mips.org
    Cc: linux-kernel@vger.kernel.org
    Patchwork: https://patchwork.linux-mips.org/patch/4806/
    Patchwork: https://patchwork.linux-mips.org/patch/4841/
    Signed-off-by: Ralf Baechle

    Al Cooper
     

05 Aug, 2010

1 commit

  • 65ab2826c   MIPS: tracing: Fix the indentation of mcount.S ... Browse Code »

    The commit "MIPS: Tracing: Cleanup the arguments passing of
    prepare_ftrace_return" has moved the "jal prepare_ftrace_return"
    instruction after the handling of the 3rd argument but forgot to remove
    the superfluous space before the related instructions.

    Signed-off-by: Wu Zhangjin
    Cc: linux-mips@linux-mips.org
    Patchwork: https://patchwork.linux-mips.org/patch/1475/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     

06 Jul, 2010

4 commits

27 Feb, 2010

1 commit

17 Dec, 2009

8 commits

  • 7326c4e56   MIPS: Tracing: Make function graph tracer work with -mmcount-ra-address ... Browse Code »

    That thread "MIPS: Add option to pass return address location to
    _mcount" from "David Daney " have added a new
    option -mmcount-ra-address to gcc(4.5) for MIPS to transfer the location
    of the return address to _mcount.

    Benefit from this new feature, function graph tracer on MIPS will be
    easier and safer to hijack the return address of the kernel function,
    which will save some overhead and make the whole thing more reliable.

    In this patch, at first, try to enable the option -mmcount-ra-address in
    arch/mips/Makefile with cc-option, if gcc support it, it will be
    enabled, otherwise, no side effect.

    and then, we need to support this new option of gcc 4.5 and also support
    the old gcc versions.

    with _mcount in the old gcc versions, it's not easy to get the location
    of return address(tracing: add function graph tracer support for MIPS),
    so, we do it in a C function: ftrace_get_parent_addr(ftrace.c), but
    with -mmcount-ra-address, only several instructions need to get what
    we want, so, I put into asm(mcount.S). and also, as the $12(t0) is
    used by -mmcount-ra-address for transferring the localtion of return
    address to _mcount, we need to save it into the stack and restore it
    when enabled dynamic function tracer, 'Cause we have called
    "ftrace_call" before "ftrace_graph_caller", which may destroy
    $12(t0).

    (Thanks to David for providing that -mcount-ra-address and giving the
    idea of KBUILD_MCOUNT_RA_ADDRESS, both of them have made the whole
    thing more beautiful!)

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/681/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • fc49a3be2   MIPS: Tracing: Reserve $12(t0) for mcount-ra-address of gcc 4.5 ... Browse Code »

    A new option -mmcount-ra-address for gcc 4.5 have been sent by David
    Daney in the thread "MIPS: Add option to
    pass return address location to _mcount", which help to record the
    location of the return address(ra) for the function graph tracer of MIPS
    to hijack the return address easier and safer. that option used the
    $12(t0) register by default, so, we reserve it for it, and use t1,t2,t3
    instead of t0,t1,t2.

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/680/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • 046199cae   MIPS: Tracing: Make ftrace for MIPS work without -fno-omit-frame-pointer ... Browse Code »

    When remove the -fno-omit-frame-pointer, gcc will not save the frame
    pointer for us, we need to save one ourselves.

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/679/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • e17ff5fec   MIPS: Tracing: Add dynamic function graph tracer for MIPS ... Browse Code »

    This patch make function graph tracer work with dynamic function tracer.

    To share the source code of dynamic function tracer(MCOUNT_SAVE_REGS),
    and avoid restoring the whole saved registers, we need to restore the ra
    register from the stack.

    (NOTE: This not work with 32bit! need to ensure why!)

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/678/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • 29c5d3462   MIPS: Tracing: Add function graph tracer support for MIPS ... Browse Code »

    The implementation of function graph tracer for MIPS is a little
    different from X86.

    in MIPS, gcc(with -pg) only transfer the caller's return address(at) and
    the _mcount's return address(ra) to us.

    For the kernel part without -mlong-calls:

    move at, ra
    jal _mcount

    For the module part with -mlong-calls:

    lui v1, hi16bit_of_mcount
    addiu v1, v1, low16bit_of_mcount
    move at, ra
    jal _mcount

    Without -mlong-calls,

    if the function is a leaf, it will not save the return address(ra):

    ffffffff80101298 :
    ffffffff80101298: 67bdfff0 daddiu sp,sp,-16
    ffffffff8010129c: ffbe0008 sd s8,8(sp)
    ffffffff801012a0: 03a0f02d move s8,sp
    ffffffff801012a4: 03e0082d move at,ra
    ffffffff801012a8: 0c042930 jal ffffffff8010a4c0
    ffffffff801012ac: 00020021 nop

    so, we can hijack it directly in _mcount, but if the function is non-leaf, the
    return address is saved in the stack.

    ffffffff80133030 :
    ffffffff80133030: 67bdff50 daddiu sp,sp,-176
    ffffffff80133034: ffbe00a0 sd s8,160(sp)
    ffffffff80133038: 03a0f02d move s8,sp
    ffffffff8013303c: ffbf00a8 sd ra,168(sp)
    ffffffff80133040: ffb70098 sd s7,152(sp)
    ffffffff80133044: ffb60090 sd s6,144(sp)
    ffffffff80133048: ffb50088 sd s5,136(sp)
    ffffffff8013304c: ffb40080 sd s4,128(sp)
    ffffffff80133050: ffb30078 sd s3,120(sp)
    ffffffff80133054: ffb20070 sd s2,112(sp)
    ffffffff80133058: ffb10068 sd s1,104(sp)
    ffffffff8013305c: ffb00060 sd s0,96(sp)
    ffffffff80133060: 03e0082d move at,ra
    ffffffff80133064: 0c042930 jal ffffffff8010a4c0
    ffffffff80133068: 00020021 nop

    but we can not get the exact stack address(which saved ra) directly in
    _mcount, we need to search the content of at register in the stack space
    or search the "s{d,w} ra, offset(sp)" instruction in the text. 'Cause we
    can not prove there is only a match in the stack space, so, we search
    the text instead.

    as we can see, if the first instruction above "move at, ra" is not a
    store instruction, there should be a leaf function, so we hijack the at
    register directly via putting &return_to_handler into it, otherwise, we
    search the "s{d,w} ra, offset(sp)" instruction to get the stack offset,
    and then the stack address. we use the above copy_process() as an
    example, we at last find "ffbf00a8", 0xa8 is the stack offset, we plus
    it with s8(fp), that is the stack address, we hijack the content via
    writing the &return_to_handler in.

    If with -mlong-calls, since there are two more instructions above "move
    at, ra", so, we can move the pointer to the position above "lui v1,
    hi16bit_of_mcount".

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/677/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • 538f19526   MIPS: Tracing: Add dynamic function tracer support ... Browse Code »

    With dynamic function tracer, by default, _mcount is defined as an
    "empty" function, it returns directly without any more action . When
    enabling it in user-space, it will jump to a real tracing
    function(ftrace_caller), and do the real job for us.

    Differ from the static function tracer, dynamic function tracer provides
    two functions ftrace_make_call()/ftrace_make_nop() to enable/disable the
    tracing of some indicated kernel functions(set_ftrace_filter).

    In the -v4 version, the implementation of this support is basically the same as
    X86 version does: _mcount is implemented as an empty function and ftrace_caller
    is implemented as a real tracing function respectively.

    But in this version, to support module tracing with the help of
    -mlong-calls in arch/mips/Makefile:

    MODFLAGS += -mlong-calls.

    The stuff becomes a little more complex. We need to cope with two
    different type of calling to _mcount.

    For the kernel part, the calling to _mcount(result of "objdump -hdr
    vmlinux"). is like this:

    108: 03e0082d move at,ra
    10c: 0c000000 jal 0
    10c: R_MIPS_26 _mcount
    10c: R_MIPS_NONE *ABS*
    10c: R_MIPS_NONE *ABS*
    110: 00020021 nop

    For the module with -mlong-calls, it looks like this:

    c: 3c030000 lui v1,0x0
    c: R_MIPS_HI16 _mcount
    c: R_MIPS_NONE *ABS*
    c: R_MIPS_NONE *ABS*
    10: 64630000 daddiu v1,v1,0
    10: R_MIPS_LO16 _mcount
    10: R_MIPS_NONE *ABS*
    10: R_MIPS_NONE *ABS*
    14: 03e0082d move at,ra
    18: 0060f809 jalr v1

    In the kernel version, there is only one "_mcount" string for every
    kernel function, so, we just need to match this one in mcount_regex of
    scripts/recordmcount.pl, but in the module version, we need to choose
    one of the two to match. Herein, I choose the first one with
    "R_MIPS_HI16 _mcount".

    and In the kernel verion, without module tracing support, we just need
    to replace "jal _mcount" by "jal ftrace_caller" to do real tracing, and
    filter the tracing of some kernel functions via replacing it by a nop
    instruction.

    but as we have described before, the instruction "jal ftrace_caller" only left
    32bit length for the address of ftrace_caller, it will fail when calling from
    the module space. so, herein, we must replace something else.

    the basic idea is loading the address of ftrace_caller to v1 via changing these
    two instructions:

    lui v1,0x0
    addiu v1,v1,0

    If we want to enable the tracing, we need to replace the above instructions to:

    lui v1, HI_16BIT_ftrace_caller
    addiu v1, v1, LOW_16BIT_ftrace_caller

    If we want to stop the tracing of the indicated kernel functions, we
    just need to replace the "jalr v1" to a nop instruction. but we need to
    replace two instructions and encode the above two instructions
    oursevles.

    Is there a simpler solution? Yes! Here it is, in this version, we put _mcount
    and ftrace_caller together, which means the address of _mcount and
    ftrace_caller is the same:

    _mcount:
    ftrace_caller:
    j ftrace_stub
    nop

    ...(do real tracing here)...

    ftrace_stub:
    jr ra
    move ra, at

    By default, the kernel functions call _mcount, and then jump to ftrace_stub and
    return. and when we want to do real tracing, we just need to remove that "j
    ftrace_stub", and it will run through the two "nop" instructions and then do
    the real tracing job.

    what about filtering job? we just need to do this:

    lui v1, hi_16bit_of_mcount b 1f (0x10000004)
    addiu v1, v1, low_16bit_of_mcount
    move at, ra
    jalr v1
    nop
    1f: (rec->ip + 12)

    In linux-mips64, there will be some local symbols, whose name are
    prefixed by $L, which need to be filtered. thanks goes to Steven for
    writing the mips64-specific function_regex.

    In a conclusion, with RISC, things becomes easier with such a "stupid"
    trick, RISC is something like K.I.S.S, and also, there are lots of
    "simple" tricks in the whole ftrace support, thanks goes to Steven and
    the other folks for providing such a wonderful tracing framework!

    Signed-off-by: Wu Zhangjin
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/675/
    Acked-by: Steven Rostedt
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • 69a7d1b3e   MIPS: Tracing: Enable HAVE_FUNCTION_TRACE_MCOUNT_TEST for MIPS ... Browse Code »

    There is an exisiting common ftrace_test_stop_func() in
    kernel/trace/ftrace.c, which is used to check the global variable
    ftrace_trace_stop to determine whether stop the function tracing.

    This patch implepment the MIPS specific one to speedup the procedure.

    Thanks goes to Zhang Le for Cleaning it up.

    Signed-off-by: Wu Zhangjin
    Cc: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/673/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin
     
  • d2bb07629   MIPS: Tracing: Add static function tracer support for MIPS ... Browse Code »

    If -pg of gcc is enabled with CONFIG_FUNCTION_TRACER=y. a calling to
    _mcount will be inserted into each kernel function. so, there is a
    possibility to trace the kernel functions in _mcount.

    This patch add the MIPS specific _mcount support for static function
    tracing. by default, ftrace_trace_function is initialized as
    ftrace_stub(an empty function), so, the default _mcount will introduce
    very little overhead. after enabling ftrace in user-space, it will jump
    to a real tracing function and do static function tracing for us.

    and -ffunction-sections is incompatible with -pg, so, disable it when
    ftracer is enabled.

    Signed-off-by: Wu Zhangjin
    Reviewed-by: Steven Rostedt
    Cc: Nicholas Mc Guire
    Cc: zhangfx@lemote.com
    Cc: Wu Zhangjin
    Cc: Ingo Molnar
    Cc: Thomas Gleixner
    Cc: Frederic Weisbecker
    Cc: linux-kernel@vger.kernel.org
    Cc: linux-mips@linux-mips.org
    Patchwork: http://patchwork.linux-mips.org/patch/672/
    Signed-off-by: Ralf Baechle

    Wu Zhangjin