arch/arm/kernel/ftrace.c

   1 /*
   2  * Dynamic function tracing support.
   3  *
   4  * Copyright (C) 2008 Abhishek Sagar <sagar.abhishek@gmail.com>
   5  * Copyright (C) 2010 Rabin Vincent <rabin@rab.in>
   6  *
   7  * For licencing details, see COPYING.
   8  *
   9  * Defines low-level handling of mcount calls when the kernel
  10  * is compiled with the -pg flag. When using dynamic ftrace, the
  11  * mcount call-sites get patched with NOP till they are enabled.
  12  * All code mutation routines here are called under stop_machine().
  13  */
  14
  15 #include <linux/ftrace.h>
  16 #include <linux/uaccess.h>
  17
  18 #include <asm/cacheflush.h>
  19 #include <asm/ftrace.h>
  20
  21 #ifdef CONFIG_THUMB2_KERNEL
  22 #define NOP             0xeb04f85d      /* pop.w {lr} */
  23 #else
  24 #define NOP             0xe8bd4000      /* pop {lr} */
  25 #endif
  26
  27 #ifdef CONFIG_DYNAMIC_FTRACE
  28 #ifdef CONFIG_OLD_MCOUNT
  29 #define OLD_MCOUNT_ADDR ((unsigned long) mcount)
  30 #define OLD_FTRACE_ADDR ((unsigned long) ftrace_caller_old)
  31
  32 #define OLD_NOP         0xe1a00000      /* mov r0, r0 */
  33
  34 static unsigned long ftrace_nop_replace(struct dyn_ftrace *rec)
  35 {
  36         return rec->arch.old_mcount ? OLD_NOP : NOP;
  37 }
  38
  39 static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
  40 {
  41         if (!rec->arch.old_mcount)
  42                 return addr;
  43
  44         if (addr == MCOUNT_ADDR)
  45                 addr = OLD_MCOUNT_ADDR;
  46         else if (addr == FTRACE_ADDR)
  47                 addr = OLD_FTRACE_ADDR;
  48
  49         return addr;
  50 }
  51 #else
  52 static unsigned long ftrace_nop_replace(struct dyn_ftrace *rec)
  53 {
  54         return NOP;
  55 }
  56
  57 static unsigned long adjust_address(struct dyn_ftrace *rec, unsigned long addr)
  58 {
  59         return addr;
  60 }
  61 #endif
  62
  63 /* construct a branch (BL) instruction to addr */
  64 #ifdef CONFIG_THUMB2_KERNEL
  65 static unsigned long ftrace_call_replace(unsigned long pc, unsigned long addr)
  66 {
  67         unsigned long s, j1, j2, i1, i2, imm10, imm11;
  68         unsigned long first, second;
  69         long offset;
  70
  71         offset = (long)addr - (long)(pc + 4);
  72         if (offset < -16777216 || offset > 16777214) {
  73                 WARN_ON_ONCE(1);
  74                 return 0;
  75         }
  76
  77         s       = (offset >> 24) & 0x1;
  78         i1      = (offset >> 23) & 0x1;
  79         i2      = (offset >> 22) & 0x1;
  80         imm10   = (offset >> 12) & 0x3ff;
  81         imm11   = (offset >>  1) & 0x7ff;
  82
  83         j1 = (!i1) ^ s;
  84         j2 = (!i2) ^ s;
  85
  86         first = 0xf000 | (s << 10) | imm10;
  87         second = 0xd000 | (j1 << 13) | (j2 << 11) | imm11;
  88
  89         return (second << 16) | first;
  90 }
  91 #else
  92 static unsigned long ftrace_call_replace(unsigned long pc, unsigned long addr)
  93 {
  94         long offset;
  95
  96         offset = (long)addr - (long)(pc + 8);
  97         if (unlikely(offset < -33554432 || offset > 33554428)) {
  98                 /* Can't generate branches that far (from ARM ARM). Ftrace
  99                  * doesn't generate branches outside of kernel text.
 100                  */
 101                 WARN_ON_ONCE(1);
 102                 return 0;
 103         }
 104
 105         offset = (offset >> 2) & 0x00ffffff;
 106
 107         return 0xeb000000 | offset;
 108 }
 109 #endif
 110
 111 static int ftrace_modify_code(unsigned long pc, unsigned long old,
 112                               unsigned long new)
 113 {
 114         unsigned long replaced;
 115
 116         if (probe_kernel_read(&replaced, (void *)pc, MCOUNT_INSN_SIZE))
 117                 return -EFAULT;
 118
 119         if (replaced != old)
 120                 return -EINVAL;
 121
 122         if (probe_kernel_write((void *)pc, &new, MCOUNT_INSN_SIZE))
 123                 return -EPERM;
 124
 125         flush_icache_range(pc, pc + MCOUNT_INSN_SIZE);
 126
 127         return 0;
 128 }
 129
 130 int ftrace_update_ftrace_func(ftrace_func_t func)
 131 {
 132         unsigned long pc, old;
 133         unsigned long new;
 134         int ret;
 135
 136         pc = (unsigned long)&ftrace_call;
 137         memcpy(&old, &ftrace_call, MCOUNT_INSN_SIZE);
 138         new = ftrace_call_replace(pc, (unsigned long)func);
 139
 140         ret = ftrace_modify_code(pc, old, new);
 141
 142 #ifdef CONFIG_OLD_MCOUNT
 143         if (!ret) {
 144                 pc = (unsigned long)&ftrace_call_old;
 145                 memcpy(&old, &ftrace_call_old, MCOUNT_INSN_SIZE);
 146                 new = ftrace_call_replace(pc, (unsigned long)func);
 147
 148                 ret = ftrace_modify_code(pc, old, new);
 149         }
 150 #endif
 151
 152         return ret;
 153 }
 154
 155 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
 156 {
 157         unsigned long new, old;
 158         unsigned long ip = rec->ip;
 159
 160         old = ftrace_nop_replace(rec);
 161         new = ftrace_call_replace(ip, adjust_address(rec, addr));
 162
 163         return ftrace_modify_code(rec->ip, old, new);
 164 }
 165
 166 int ftrace_make_nop(struct module *mod,
 167                     struct dyn_ftrace *rec, unsigned long addr)
 168 {
 169         unsigned long ip = rec->ip;
 170         unsigned long old;
 171         unsigned long new;
 172         int ret;
 173
 174         old = ftrace_call_replace(ip, adjust_address(rec, addr));
 175         new = ftrace_nop_replace(rec);
 176         ret = ftrace_modify_code(ip, old, new);
 177
 178 #ifdef CONFIG_OLD_MCOUNT
 179         if (ret == -EINVAL && addr == MCOUNT_ADDR) {
 180                 rec->arch.old_mcount = true;
 181
 182                 old = ftrace_call_replace(ip, adjust_address(rec, addr));
 183                 new = ftrace_nop_replace(rec);
 184                 ret = ftrace_modify_code(ip, old, new);
 185         }
 186 #endif
 187
 188         return ret;
 189 }
 190
 191 int __init ftrace_dyn_arch_init(void *data)
 192 {
 193         *(unsigned long *)data = 0;
 194
 195         return 0;
 196 }
 197 #endif /* CONFIG_DYNAMIC_FTRACE */
 198
 199 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
 200 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr,
 201                            unsigned long frame_pointer)
 202 {
 203         unsigned long return_hooker = (unsigned long) &return_to_handler;
 204         struct ftrace_graph_ent trace;
 205         unsigned long old;
 206         int err;
 207
 208         if (unlikely(atomic_read(&current->tracing_graph_pause)))
 209                 return;
 210
 211         old = *parent;
 212         *parent = return_hooker;
 213
 214         err = ftrace_push_return_trace(old, self_addr, &trace.depth,
 215                                        frame_pointer);
 216         if (err == -EBUSY) {
 217                 *parent = old;
 218                 return;
 219         }
 220
 221         trace.func = self_addr;
 222
 223         /* Only trace if the calling function expects to */
 224         if (!ftrace_graph_entry(&trace)) {
 225                 current->curr_ret_stack--;
 226                 *parent = old;
 227         }
 228 }
 229 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */