arch/s390/kernel/ftrace.c

   1 /*
   2  * Dynamic function tracer architecture backend.
   3  *
   4  * Copyright IBM Corp. 2009,2014
   5  *
   6  *   Author(s): Heiko Carstens <heiko.carstens@de.ibm.com>,
   7  *              Martin Schwidefsky <schwidefsky@de.ibm.com>
   8  */
   9
  10 #include <linux/moduleloader.h>
  11 #include <linux/hardirq.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/ftrace.h>
  14 #include <linux/kernel.h>
  15 #include <linux/types.h>
  16 #include <linux/kprobes.h>
  17 #include <trace/syscall.h>
  18 #include <asm/asm-offsets.h>
  19 #include <asm/cacheflush.h>
  20 #include <asm/set_memory.h>
  21 #include "entry.h"
  22
  23 /*
  24  * The mcount code looks like this:
  25  *      stg     %r14,8(%r15)            # offset 0
  26  *      larl    %r1,<&counter>          # offset 6
  27  *      brasl   %r14,_mcount            # offset 12
  28  *      lg      %r14,8(%r15)            # offset 18
  29  * Total length is 24 bytes. Only the first instruction will be patched
  30  * by ftrace_make_call / ftrace_make_nop.
  31  * The enabled ftrace code block looks like this:
  32  * >    brasl   %r0,ftrace_caller       # offset 0
  33  *      larl    %r1,<&counter>          # offset 6
  34  *      brasl   %r14,_mcount            # offset 12
  35  *      lg      %r14,8(%r15)            # offset 18
  36  * The ftrace function gets called with a non-standard C function call ABI
  37  * where r0 contains the return address. It is also expected that the called
  38  * function only clobbers r0 and r1, but restores r2-r15.
  39  * For module code we can't directly jump to ftrace caller, but need a
  40  * trampoline (ftrace_plt), which clobbers also r1.
  41  * The return point of the ftrace function has offset 24, so execution
  42  * continues behind the mcount block.
  43  * The disabled ftrace code block looks like this:
  44  * >    jg      .+24                    # offset 0
  45  *      larl    %r1,<&counter>          # offset 6
  46  *      brasl   %r14,_mcount            # offset 12
  47  *      lg      %r14,8(%r15)            # offset 18
  48  * The jg instruction branches to offset 24 to skip as many instructions
  49  * as possible.
  50  * In case we use gcc's hotpatch feature the original and also the disabled
  51  * function prologue contains only a single six byte instruction and looks
  52  * like this:
  53  * >    brcl    0,0                     # offset 0
  54  * To enable ftrace the code gets patched like above and afterwards looks
  55  * like this:
  56  * >    brasl   %r0,ftrace_caller       # offset 0
  57  */
  58
  59 unsigned long ftrace_plt;
  60
  61 static inline void ftrace_generate_orig_insn(struct ftrace_insn *insn)
  62 {
  63 #ifdef CC_USING_HOTPATCH
  64         /* brcl 0,0 */
  65         insn->opc = 0xc004;
  66         insn->disp = 0;
  67 #else
  68         /* stg r14,8(r15) */
  69         insn->opc = 0xe3e0;
  70         insn->disp = 0xf0080024;
  71 #endif
  72 }
  73
  74 static inline int is_kprobe_on_ftrace(struct ftrace_insn *insn)
  75 {
  76 #ifdef CONFIG_KPROBES
  77         if (insn->opc == BREAKPOINT_INSTRUCTION)
  78                 return 1;
  79 #endif
  80         return 0;
  81 }
  82
  83 static inline void ftrace_generate_kprobe_nop_insn(struct ftrace_insn *insn)
  84 {
  85 #ifdef CONFIG_KPROBES
  86         insn->opc = BREAKPOINT_INSTRUCTION;
  87         insn->disp = KPROBE_ON_FTRACE_NOP;
  88 #endif
  89 }
  90
  91 static inline void ftrace_generate_kprobe_call_insn(struct ftrace_insn *insn)
  92 {
  93 #ifdef CONFIG_KPROBES
  94         insn->opc = BREAKPOINT_INSTRUCTION;
  95         insn->disp = KPROBE_ON_FTRACE_CALL;
  96 #endif
  97 }
  98
  99 int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
 100                        unsigned long addr)
 101 {
 102         return 0;
 103 }
 104
 105 int ftrace_make_nop(struct module *mod, struct dyn_ftrace *rec,
 106                     unsigned long addr)
 107 {
 108         struct ftrace_insn orig, new, old;
 109
 110         if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
 111                 return -EFAULT;
 112         if (addr == MCOUNT_ADDR) {
 113                 /* Initial code replacement */
 114                 ftrace_generate_orig_insn(&orig);
 115                 ftrace_generate_nop_insn(&new);
 116         } else if (is_kprobe_on_ftrace(&old)) {
 117                 /*
 118                  * If we find a breakpoint instruction, a kprobe has been
 119                  * placed at the beginning of the function. We write the
 120                  * constant KPROBE_ON_FTRACE_NOP into the remaining four
 121                  * bytes of the original instruction so that the kprobes
 122                  * handler can execute a nop, if it reaches this breakpoint.
 123                  */
 124                 ftrace_generate_kprobe_call_insn(&orig);
 125                 ftrace_generate_kprobe_nop_insn(&new);
 126         } else {
 127                 /* Replace ftrace call with a nop. */
 128                 ftrace_generate_call_insn(&orig, rec->ip);
 129                 ftrace_generate_nop_insn(&new);
 130         }
 131         /* Verify that the to be replaced code matches what we expect. */
 132         if (memcmp(&orig, &old, sizeof(old)))
 133                 return -EINVAL;
 134         s390_kernel_write((void *) rec->ip, &new, sizeof(new));
 135         return 0;
 136 }
 137
 138 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 139 {
 140         struct ftrace_insn orig, new, old;
 141
 142         if (probe_kernel_read(&old, (void *) rec->ip, sizeof(old)))
 143                 return -EFAULT;
 144         if (is_kprobe_on_ftrace(&old)) {
 145                 /*
 146                  * If we find a breakpoint instruction, a kprobe has been
 147                  * placed at the beginning of the function. We write the
 148                  * constant KPROBE_ON_FTRACE_CALL into the remaining four
 149                  * bytes of the original instruction so that the kprobes
 150                  * handler can execute a brasl if it reaches this breakpoint.
 151                  */
 152                 ftrace_generate_kprobe_nop_insn(&orig);
 153                 ftrace_generate_kprobe_call_insn(&new);
 154         } else {
 155                 /* Replace nop with an ftrace call. */
 156                 ftrace_generate_nop_insn(&orig);
 157                 ftrace_generate_call_insn(&new, rec->ip);
 158         }
 159         /* Verify that the to be replaced code matches what we expect. */
 160         if (memcmp(&orig, &old, sizeof(old)))
 161                 return -EINVAL;
 162         s390_kernel_write((void *) rec->ip, &new, sizeof(new));
 163         return 0;
 164 }
 165
 166 int ftrace_update_ftrace_func(ftrace_func_t func)
 167 {
 168         return 0;
 169 }
 170
 171 int __init ftrace_dyn_arch_init(void)
 172 {
 173         return 0;
 174 }
 175
 176 static int __init ftrace_plt_init(void)
 177 {
 178         unsigned int *ip;
 179
 180         ftrace_plt = (unsigned long) module_alloc(PAGE_SIZE);
 181         if (!ftrace_plt)
 182                 panic("cannot allocate ftrace plt\n");
 183         ip = (unsigned int *) ftrace_plt;
 184         ip[0] = 0x0d10e310; /* basr 1,0; lg 1,10(1); br 1 */
 185         ip[1] = 0x100a0004;
 186         ip[2] = 0x07f10000;
 187         ip[3] = FTRACE_ADDR >> 32;
 188         ip[4] = FTRACE_ADDR & 0xffffffff;
 189         set_memory_ro(ftrace_plt, 1);
 190         return 0;
 191 }
 192 device_initcall(ftrace_plt_init);
 193
 194 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 195 /*
 196  * Hook the return address and push it in the stack of return addresses
 197  * in current thread info.
 198  */
 199 unsigned long prepare_ftrace_return(unsigned long parent, unsigned long ip)
 200 {
 201         struct ftrace_graph_ent trace;
 202
 203         if (unlikely(ftrace_graph_is_dead()))
 204                 goto out;
 205         if (unlikely(atomic_read(&current->tracing_graph_pause)))
 206                 goto out;
 207         ip -= MCOUNT_INSN_SIZE;
 208         trace.func = ip;
 209         trace.depth = current->curr_ret_stack + 1;
 210         /* Only trace if the calling function expects to. */
 211         if (!ftrace_graph_entry(&trace))
 212                 goto out;
 213         if (ftrace_push_return_trace(parent, ip, &trace.depth, 0,
 214                                      NULL) == -EBUSY)
 215                 goto out;
 216         parent = (unsigned long) return_to_handler;
 217 out:
 218         return parent;
 219 }
 220 NOKPROBE_SYMBOL(prepare_ftrace_return);
 221
 222 /*
 223  * Patch the kernel code at ftrace_graph_caller location. The instruction
 224  * there is branch relative on condition. To enable the ftrace graph code
 225  * block, we simply patch the mask field of the instruction to zero and
 226  * turn the instruction into a nop.
 227  * To disable the ftrace graph code the mask field will be patched to
 228  * all ones, which turns the instruction into an unconditional branch.
 229  */
 230 int ftrace_enable_ftrace_graph_caller(void)
 231 {
 232         u8 op = 0x04; /* set mask field to zero */
 233
 234         s390_kernel_write(__va(ftrace_graph_caller)+1, &op, sizeof(op));
 235         return 0;
 236 }
 237
 238 int ftrace_disable_ftrace_graph_caller(void)
 239 {
 240         u8 op = 0xf4; /* set mask field to all ones */
 241
 242         s390_kernel_write(__va(ftrace_graph_caller)+1, &op, sizeof(op));
 243         return 0;
 244 }
 245
 246 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */