drm: merge Linux master into HEAD
[linux-2.6] / arch / powerpc / kernel / ftrace.c
1 /*
2  * Code for replacing ftrace calls with jumps.
3  *
4  * Copyright (C) 2007-2008 Steven Rostedt <srostedt@redhat.com>
5  *
6  * Thanks goes out to P.A. Semi, Inc for supplying me with a PPC64 box.
7  *
8  */
9
10 #include <linux/spinlock.h>
11 #include <linux/hardirq.h>
12 #include <linux/uaccess.h>
13 #include <linux/module.h>
14 #include <linux/ftrace.h>
15 #include <linux/percpu.h>
16 #include <linux/init.h>
17 #include <linux/list.h>
18
19 #include <asm/cacheflush.h>
20 #include <asm/code-patching.h>
21 #include <asm/ftrace.h>
22
23 #if 0
24 #define DEBUGP printk
25 #else
26 #define DEBUGP(fmt , ...)       do { } while (0)
27 #endif
28
29 static unsigned int ftrace_nop = PPC_NOP_INSTR;
30
31 #ifdef CONFIG_PPC32
32 # define GET_ADDR(addr) addr
33 #else
34 /* PowerPC64's functions are data that points to the functions */
35 # define GET_ADDR(addr) (*(unsigned long *)addr)
36 #endif
37
38
39 static unsigned int ftrace_calc_offset(long ip, long addr)
40 {
41         return (int)(addr - ip);
42 }
43
44 static unsigned char *ftrace_nop_replace(void)
45 {
46         return (char *)&ftrace_nop;
47 }
48
49 static unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr)
50 {
51         static unsigned int op;
52
53         /*
54          * It would be nice to just use create_function_call, but that will
55          * update the code itself. Here we need to just return the
56          * instruction that is going to be modified, without modifying the
57          * code.
58          */
59         addr = GET_ADDR(addr);
60
61         /* Set to "bl addr" */
62         op = 0x48000001 | (ftrace_calc_offset(ip, addr) & 0x03fffffc);
63
64         /*
65          * No locking needed, this must be called via kstop_machine
66          * which in essence is like running on a uniprocessor machine.
67          */
68         return (unsigned char *)&op;
69 }
70
71 #ifdef CONFIG_PPC64
72 # define _ASM_ALIGN     " .align 3 "
73 # define _ASM_PTR       " .llong "
74 #else
75 # define _ASM_ALIGN     " .align 2 "
76 # define _ASM_PTR       " .long "
77 #endif
78
79 static int
80 ftrace_modify_code(unsigned long ip, unsigned char *old_code,
81                    unsigned char *new_code)
82 {
83         unsigned char replaced[MCOUNT_INSN_SIZE];
84
85         /*
86          * Note: Due to modules and __init, code can
87          *  disappear and change, we need to protect against faulting
88          *  as well as code changing. We do this by using the
89          *  probe_kernel_* functions.
90          *
91          * No real locking needed, this code is run through
92          * kstop_machine, or before SMP starts.
93          */
94
95         /* read the text we want to modify */
96         if (probe_kernel_read(replaced, (void *)ip, MCOUNT_INSN_SIZE))
97                 return -EFAULT;
98
99         /* Make sure it is what we expect it to be */
100         if (memcmp(replaced, old_code, MCOUNT_INSN_SIZE) != 0)
101                 return -EINVAL;
102
103         /* replace the text with the new text */
104         if (probe_kernel_write((void *)ip, new_code, MCOUNT_INSN_SIZE))
105                 return -EPERM;
106
107         flush_icache_range(ip, ip + 8);
108
109         return 0;
110 }
111
112 /*
113  * Helper functions that are the same for both PPC64 and PPC32.
114  */
115 static int test_24bit_addr(unsigned long ip, unsigned long addr)
116 {
117
118         /* use the create_branch to verify that this offset can be branched */
119         return create_branch((unsigned int *)ip, addr, 0);
120 }
121
122 static int is_bl_op(unsigned int op)
123 {
124         return (op & 0xfc000003) == 0x48000001;
125 }
126
127 static unsigned long find_bl_target(unsigned long ip, unsigned int op)
128 {
129         static int offset;
130
131         offset = (op & 0x03fffffc);
132         /* make it signed */
133         if (offset & 0x02000000)
134                 offset |= 0xfe000000;
135
136         return ip + (long)offset;
137 }
138
139 #ifdef CONFIG_PPC64
140 static int
141 __ftrace_make_nop(struct module *mod,
142                   struct dyn_ftrace *rec, unsigned long addr)
143 {
144         unsigned int op;
145         unsigned int jmp[5];
146         unsigned long ptr;
147         unsigned long ip = rec->ip;
148         unsigned long tramp;
149         int offset;
150
151         /* read where this goes */
152         if (probe_kernel_read(&op, (void *)ip, sizeof(int)))
153                 return -EFAULT;
154
155         /* Make sure that that this is still a 24bit jump */
156         if (!is_bl_op(op)) {
157                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
158                 return -EINVAL;
159         }
160
161         /* lets find where the pointer goes */
162         tramp = find_bl_target(ip, op);
163
164         /*
165          * On PPC64 the trampoline looks like:
166          * 0x3d, 0x82, 0x00, 0x00,    addis   r12,r2, <high>
167          * 0x39, 0x8c, 0x00, 0x00,    addi    r12,r12, <low>
168          *   Where the bytes 2,3,6 and 7 make up the 32bit offset
169          *   to the TOC that holds the pointer.
170          *   to jump to.
171          * 0xf8, 0x41, 0x00, 0x28,    std     r2,40(r1)
172          * 0xe9, 0x6c, 0x00, 0x20,    ld      r11,32(r12)
173          *   The actually address is 32 bytes from the offset
174          *   into the TOC.
175          * 0xe8, 0x4c, 0x00, 0x28,    ld      r2,40(r12)
176          */
177
178         DEBUGP("ip:%lx jumps to %lx r2: %lx", ip, tramp, mod->arch.toc);
179
180         /* Find where the trampoline jumps to */
181         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
182                 printk(KERN_ERR "Failed to read %lx\n", tramp);
183                 return -EFAULT;
184         }
185
186         DEBUGP(" %08x %08x", jmp[0], jmp[1]);
187
188         /* verify that this is what we expect it to be */
189         if (((jmp[0] & 0xffff0000) != 0x3d820000) ||
190             ((jmp[1] & 0xffff0000) != 0x398c0000) ||
191             (jmp[2] != 0xf8410028) ||
192             (jmp[3] != 0xe96c0020) ||
193             (jmp[4] != 0xe84c0028)) {
194                 printk(KERN_ERR "Not a trampoline\n");
195                 return -EINVAL;
196         }
197
198         /* The bottom half is signed extended */
199         offset = ((unsigned)((unsigned short)jmp[0]) << 16) +
200                 (int)((short)jmp[1]);
201
202         DEBUGP(" %x ", offset);
203
204         /* get the address this jumps too */
205         tramp = mod->arch.toc + offset + 32;
206         DEBUGP("toc: %lx", tramp);
207
208         if (probe_kernel_read(jmp, (void *)tramp, 8)) {
209                 printk(KERN_ERR "Failed to read %lx\n", tramp);
210                 return -EFAULT;
211         }
212
213         DEBUGP(" %08x %08x\n", jmp[0], jmp[1]);
214
215         ptr = ((unsigned long)jmp[0] << 32) + jmp[1];
216
217         /* This should match what was called */
218         if (ptr != GET_ADDR(addr)) {
219                 printk(KERN_ERR "addr does not match %lx\n", ptr);
220                 return -EINVAL;
221         }
222
223         /*
224          * We want to nop the line, but the next line is
225          *  0xe8, 0x41, 0x00, 0x28   ld r2,40(r1)
226          * This needs to be turned to a nop too.
227          */
228         if (probe_kernel_read(&op, (void *)(ip+4), MCOUNT_INSN_SIZE))
229                 return -EFAULT;
230
231         if (op != 0xe8410028) {
232                 printk(KERN_ERR "Next line is not ld! (%08x)\n", op);
233                 return -EINVAL;
234         }
235
236         /*
237          * Milton Miller pointed out that we can not blindly do nops.
238          * If a task was preempted when calling a trace function,
239          * the nops will remove the way to restore the TOC in r2
240          * and the r2 TOC will get corrupted.
241          */
242
243         /*
244          * Replace:
245          *   bl <tramp>  <==== will be replaced with "b 1f"
246          *   ld r2,40(r1)
247          *  1:
248          */
249         op = 0x48000008;        /* b +8 */
250
251         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
252                 return -EPERM;
253
254
255         flush_icache_range(ip, ip + 8);
256
257         return 0;
258 }
259
260 #else /* !PPC64 */
261 static int
262 __ftrace_make_nop(struct module *mod,
263                   struct dyn_ftrace *rec, unsigned long addr)
264 {
265         unsigned int op;
266         unsigned int jmp[4];
267         unsigned long ip = rec->ip;
268         unsigned long tramp;
269
270         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
271                 return -EFAULT;
272
273         /* Make sure that that this is still a 24bit jump */
274         if (!is_bl_op(op)) {
275                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
276                 return -EINVAL;
277         }
278
279         /* lets find where the pointer goes */
280         tramp = find_bl_target(ip, op);
281
282         /*
283          * On PPC32 the trampoline looks like:
284          *  0x3d, 0x60, 0x00, 0x00  lis r11,sym@ha
285          *  0x39, 0x6b, 0x00, 0x00  addi r11,r11,sym@l
286          *  0x7d, 0x69, 0x03, 0xa6  mtctr r11
287          *  0x4e, 0x80, 0x04, 0x20  bctr
288          */
289
290         DEBUGP("ip:%lx jumps to %lx", ip, tramp);
291
292         /* Find where the trampoline jumps to */
293         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
294                 printk(KERN_ERR "Failed to read %lx\n", tramp);
295                 return -EFAULT;
296         }
297
298         DEBUGP(" %08x %08x ", jmp[0], jmp[1]);
299
300         /* verify that this is what we expect it to be */
301         if (((jmp[0] & 0xffff0000) != 0x3d600000) ||
302             ((jmp[1] & 0xffff0000) != 0x396b0000) ||
303             (jmp[2] != 0x7d6903a6) ||
304             (jmp[3] != 0x4e800420)) {
305                 printk(KERN_ERR "Not a trampoline\n");
306                 return -EINVAL;
307         }
308
309         tramp = (jmp[1] & 0xffff) |
310                 ((jmp[0] & 0xffff) << 16);
311         if (tramp & 0x8000)
312                 tramp -= 0x10000;
313
314         DEBUGP(" %x ", tramp);
315
316         if (tramp != addr) {
317                 printk(KERN_ERR
318                        "Trampoline location %08lx does not match addr\n",
319                        tramp);
320                 return -EINVAL;
321         }
322
323         op = PPC_NOP_INSTR;
324
325         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
326                 return -EPERM;
327
328         flush_icache_range(ip, ip + 8);
329
330         return 0;
331 }
332 #endif /* PPC64 */
333
334 int ftrace_make_nop(struct module *mod,
335                     struct dyn_ftrace *rec, unsigned long addr)
336 {
337         unsigned char *old, *new;
338         unsigned long ip = rec->ip;
339
340         /*
341          * If the calling address is more that 24 bits away,
342          * then we had to use a trampoline to make the call.
343          * Otherwise just update the call site.
344          */
345         if (test_24bit_addr(ip, addr)) {
346                 /* within range */
347                 old = ftrace_call_replace(ip, addr);
348                 new = ftrace_nop_replace();
349                 return ftrace_modify_code(ip, old, new);
350         }
351
352         /*
353          * Out of range jumps are called from modules.
354          * We should either already have a pointer to the module
355          * or it has been passed in.
356          */
357         if (!rec->arch.mod) {
358                 if (!mod) {
359                         printk(KERN_ERR "No module loaded addr=%lx\n",
360                                addr);
361                         return -EFAULT;
362                 }
363                 rec->arch.mod = mod;
364         } else if (mod) {
365                 if (mod != rec->arch.mod) {
366                         printk(KERN_ERR
367                                "Record mod %p not equal to passed in mod %p\n",
368                                rec->arch.mod, mod);
369                         return -EINVAL;
370                 }
371                 /* nothing to do if mod == rec->arch.mod */
372         } else
373                 mod = rec->arch.mod;
374
375         return __ftrace_make_nop(mod, rec, addr);
376
377 }
378
379 #ifdef CONFIG_PPC64
380 static int
381 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
382 {
383         unsigned int op[2];
384         unsigned long ip = rec->ip;
385
386         /* read where this goes */
387         if (probe_kernel_read(op, (void *)ip, MCOUNT_INSN_SIZE * 2))
388                 return -EFAULT;
389
390         /*
391          * It should be pointing to two nops or
392          *  b +8; ld r2,40(r1)
393          */
394         if (((op[0] != 0x48000008) || (op[1] != 0xe8410028)) &&
395             ((op[0] != PPC_NOP_INSTR) || (op[1] != PPC_NOP_INSTR))) {
396                 printk(KERN_ERR "Expected NOPs but have %x %x\n", op[0], op[1]);
397                 return -EINVAL;
398         }
399
400         /* If we never set up a trampoline to ftrace_caller, then bail */
401         if (!rec->arch.mod->arch.tramp) {
402                 printk(KERN_ERR "No ftrace trampoline\n");
403                 return -EINVAL;
404         }
405
406         /* create the branch to the trampoline */
407         op[0] = create_branch((unsigned int *)ip,
408                               rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
409         if (!op[0]) {
410                 printk(KERN_ERR "REL24 out of range!\n");
411                 return -EINVAL;
412         }
413
414         /* ld r2,40(r1) */
415         op[1] = 0xe8410028;
416
417         DEBUGP("write to %lx\n", rec->ip);
418
419         if (probe_kernel_write((void *)ip, op, MCOUNT_INSN_SIZE * 2))
420                 return -EPERM;
421
422         flush_icache_range(ip, ip + 8);
423
424         return 0;
425 }
426 #else
427 static int
428 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
429 {
430         unsigned int op;
431         unsigned long ip = rec->ip;
432
433         /* read where this goes */
434         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
435                 return -EFAULT;
436
437         /* It should be pointing to a nop */
438         if (op != PPC_NOP_INSTR) {
439                 printk(KERN_ERR "Expected NOP but have %x\n", op);
440                 return -EINVAL;
441         }
442
443         /* If we never set up a trampoline to ftrace_caller, then bail */
444         if (!rec->arch.mod->arch.tramp) {
445                 printk(KERN_ERR "No ftrace trampoline\n");
446                 return -EINVAL;
447         }
448
449         /* create the branch to the trampoline */
450         op = create_branch((unsigned int *)ip,
451                            rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
452         if (!op) {
453                 printk(KERN_ERR "REL24 out of range!\n");
454                 return -EINVAL;
455         }
456
457         DEBUGP("write to %lx\n", rec->ip);
458
459         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
460                 return -EPERM;
461
462         flush_icache_range(ip, ip + 8);
463
464         return 0;
465 }
466 #endif /* CONFIG_PPC64 */
467
468 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
469 {
470         unsigned char *old, *new;
471         unsigned long ip = rec->ip;
472
473         /*
474          * If the calling address is more that 24 bits away,
475          * then we had to use a trampoline to make the call.
476          * Otherwise just update the call site.
477          */
478         if (test_24bit_addr(ip, addr)) {
479                 /* within range */
480                 old = ftrace_nop_replace();
481                 new = ftrace_call_replace(ip, addr);
482                 return ftrace_modify_code(ip, old, new);
483         }
484
485         /*
486          * Out of range jumps are called from modules.
487          * Being that we are converting from nop, it had better
488          * already have a module defined.
489          */
490         if (!rec->arch.mod) {
491                 printk(KERN_ERR "No module loaded\n");
492                 return -EINVAL;
493         }
494
495         return __ftrace_make_call(rec, addr);
496 }
497
498 int ftrace_update_ftrace_func(ftrace_func_t func)
499 {
500         unsigned long ip = (unsigned long)(&ftrace_call);
501         unsigned char old[MCOUNT_INSN_SIZE], *new;
502         int ret;
503
504         memcpy(old, &ftrace_call, MCOUNT_INSN_SIZE);
505         new = ftrace_call_replace(ip, (unsigned long)func);
506         ret = ftrace_modify_code(ip, old, new);
507
508         return ret;
509 }
510
511 int __init ftrace_dyn_arch_init(void *data)
512 {
513         /* caller expects data to be zero */
514         unsigned long *p = data;
515
516         *p = 0;
517
518         return 0;
519 }