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