MIPS: Tracing: Add function graph tracer support for MIPS

[mv-sheeva.git] / arch / mips / kernel / ftrace.c

diff --git a/arch/mips/kernel/ftrace.c b/arch/mips/kernel/ftrace.c
index 5459a7838370557c41ba0689920da3b878a477a8..65a3f8a89927937cbdec43fbf90007d0add81b28 100644 (file)
--- a/arch/mips/kernel/ftrace.c
+++ b/arch/mips/kernel/ftrace.c
@@ -13,6 +13,8 @@
 #include <linux/ftrace.h>
 
 #include <asm/cacheflush.h>
+#include <asm/asm.h>
+#include <asm/asm-offsets.h>
 
 #ifdef CONFIG_DYNAMIC_FTRACE
 
@@ -110,3 +112,107 @@ int __init ftrace_dyn_arch_init(void *data)
        return 0;
 }
 #endif                         /* CONFIG_DYNAMIC_FTRACE */
+
+#ifdef CONFIG_FUNCTION_GRAPH_TRACER
+
+#define S_RA_SP        (0xafbf << 16)  /* s{d,w} ra, offset(sp) */
+#define S_R_SP (0xafb0 << 16)  /* s{d,w} R, offset(sp) */
+#define OFFSET_MASK    0xffff  /* stack offset range: 0 ~ PT_SIZE */
+
+unsigned long ftrace_get_parent_addr(unsigned long self_addr,
+                                    unsigned long parent,
+                                    unsigned long parent_addr,
+                                    unsigned long fp)
+{
+       unsigned long sp, ip, ra;
+       unsigned int code;
+
+       /* in module or kernel? */
+       if (self_addr & 0x40000000) {
+               /* module: move to the instruction "lui v1, HI_16BIT_OF_MCOUNT" */
+               ip = self_addr - 20;
+       } else {
+               /* kernel: move to the instruction "move ra, at" */
+               ip = self_addr - 12;
+       }
+
+       /* search the text until finding the non-store instruction or "s{d,w}
+        * ra, offset(sp)" instruction */
+       do {
+               ip -= 4;
+
+               /* get the code at "ip" */
+               code = *(unsigned int *)ip;
+
+               /* If we hit the non-store instruction before finding where the
+                * ra is stored, then this is a leaf function and it does not
+                * store the ra on the stack. */
+               if ((code & S_R_SP) != S_R_SP)
+                       return parent_addr;
+
+       } while (((code & S_RA_SP) != S_RA_SP));
+
+       sp = fp + (code & OFFSET_MASK);
+       ra = *(unsigned long *)sp;
+
+       if (ra == parent)
+               return sp;
+
+       return 0;
+}
+
+/*
+ * Hook the return address and push it in the stack of return addrs
+ * in current thread info.
+ */
+void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
+                          unsigned long fp)
+{
+       unsigned long old;
+       struct ftrace_graph_ent trace;
+       unsigned long return_hooker = (unsigned long)
+           &return_to_handler;
+
+       if (unlikely(atomic_read(&current->tracing_graph_pause)))
+               return;
+
+       /* "parent" is the stack address saved the return address of the caller
+        * of _mcount, for a leaf function not save the return address in the
+        * stack address, so, we "emulate" one in _mcount's stack space, and
+        * hijack it directly, but for a non-leaf function, it will save the
+        * return address to the its stack space, so, we can not hijack the
+        * "parent" directly, but need to find the real stack address,
+        * ftrace_get_parent_addr() does it!
+        */
+
+       old = *parent;
+
+       parent = (unsigned long *)ftrace_get_parent_addr(self_addr, old,
+                                                        (unsigned long)parent,
+                                                        fp);
+
+       /* If fails when getting the stack address of the non-leaf function's
+        * ra, stop function graph tracer and return */
+       if (parent == 0) {
+               ftrace_graph_stop();
+               WARN_ON(1);
+               return;
+       }
+
+       *parent = return_hooker;
+
+       if (ftrace_push_return_trace(old, self_addr, &trace.depth, fp) ==
+           -EBUSY) {
+               *parent = old;
+               return;
+       }
+
+       trace.func = self_addr;
+
+       /* Only trace if the calling function expects to */
+       if (!ftrace_graph_entry(&trace)) {
+               current->curr_ret_stack--;
+               *parent = old;
+       }
+}
+#endif                         /* CONFIG_FUNCTION_GRAPH_TRACER */