powerpc/ftrace: Remove unused macros
[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  * Added function graph tracer code, taken from x86 that was written
9  * by Frederic Weisbecker, and ported to PPC by Steven Rostedt.
10  *
11  */
12
13 #include <linux/spinlock.h>
14 #include <linux/hardirq.h>
15 #include <linux/uaccess.h>
16 #include <linux/module.h>
17 #include <linux/ftrace.h>
18 #include <linux/percpu.h>
19 #include <linux/init.h>
20 #include <linux/list.h>
21
22 #include <asm/cacheflush.h>
23 #include <asm/code-patching.h>
24 #include <asm/ftrace.h>
25
26
27 #ifdef CONFIG_DYNAMIC_FTRACE
28 static unsigned int ftrace_nop_replace(void)
29 {
30         return PPC_INST_NOP;
31 }
32
33 static unsigned int
34 ftrace_call_replace(unsigned long ip, unsigned long addr, int link)
35 {
36         unsigned int op;
37
38         addr = ppc_function_entry((void *)addr);
39
40         /* if (link) set op to 'bl' else 'b' */
41         op = create_branch((unsigned int *)ip, addr, link ? 1 : 0);
42
43         return op;
44 }
45
46 static int
47 ftrace_modify_code(unsigned long ip, unsigned int old, unsigned int new)
48 {
49         unsigned int replaced;
50
51         /*
52          * Note: Due to modules and __init, code can
53          *  disappear and change, we need to protect against faulting
54          *  as well as code changing. We do this by using the
55          *  probe_kernel_* functions.
56          *
57          * No real locking needed, this code is run through
58          * kstop_machine, or before SMP starts.
59          */
60
61         /* read the text we want to modify */
62         if (probe_kernel_read(&replaced, (void *)ip, MCOUNT_INSN_SIZE))
63                 return -EFAULT;
64
65         /* Make sure it is what we expect it to be */
66         if (replaced != old)
67                 return -EINVAL;
68
69         /* replace the text with the new text */
70         if (probe_kernel_write((void *)ip, &new, MCOUNT_INSN_SIZE))
71                 return -EPERM;
72
73         flush_icache_range(ip, ip + 8);
74
75         return 0;
76 }
77
78 /*
79  * Helper functions that are the same for both PPC64 and PPC32.
80  */
81 static int test_24bit_addr(unsigned long ip, unsigned long addr)
82 {
83
84         /* use the create_branch to verify that this offset can be branched */
85         return create_branch((unsigned int *)ip, addr, 0);
86 }
87
88 #ifdef CONFIG_MODULES
89
90 static int is_bl_op(unsigned int op)
91 {
92         return (op & 0xfc000003) == 0x48000001;
93 }
94
95 static unsigned long find_bl_target(unsigned long ip, unsigned int op)
96 {
97         static int offset;
98
99         offset = (op & 0x03fffffc);
100         /* make it signed */
101         if (offset & 0x02000000)
102                 offset |= 0xfe000000;
103
104         return ip + (long)offset;
105 }
106
107 #ifdef CONFIG_PPC64
108 static int
109 __ftrace_make_nop(struct module *mod,
110                   struct dyn_ftrace *rec, unsigned long addr)
111 {
112         unsigned int op;
113         unsigned int jmp[5];
114         unsigned long ptr;
115         unsigned long ip = rec->ip;
116         unsigned long tramp;
117         int offset;
118
119         /* read where this goes */
120         if (probe_kernel_read(&op, (void *)ip, sizeof(int)))
121                 return -EFAULT;
122
123         /* Make sure that that this is still a 24bit jump */
124         if (!is_bl_op(op)) {
125                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
126                 return -EINVAL;
127         }
128
129         /* lets find where the pointer goes */
130         tramp = find_bl_target(ip, op);
131
132         /*
133          * On PPC64 the trampoline looks like:
134          * 0x3d, 0x82, 0x00, 0x00,    addis   r12,r2, <high>
135          * 0x39, 0x8c, 0x00, 0x00,    addi    r12,r12, <low>
136          *   Where the bytes 2,3,6 and 7 make up the 32bit offset
137          *   to the TOC that holds the pointer.
138          *   to jump to.
139          * 0xf8, 0x41, 0x00, 0x28,    std     r2,40(r1)
140          * 0xe9, 0x6c, 0x00, 0x20,    ld      r11,32(r12)
141          *   The actually address is 32 bytes from the offset
142          *   into the TOC.
143          * 0xe8, 0x4c, 0x00, 0x28,    ld      r2,40(r12)
144          */
145
146         pr_devel("ip:%lx jumps to %lx r2: %lx", ip, tramp, mod->arch.toc);
147
148         /* Find where the trampoline jumps to */
149         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
150                 printk(KERN_ERR "Failed to read %lx\n", tramp);
151                 return -EFAULT;
152         }
153
154         pr_devel(" %08x %08x", jmp[0], jmp[1]);
155
156         /* verify that this is what we expect it to be */
157         if (((jmp[0] & 0xffff0000) != 0x3d820000) ||
158             ((jmp[1] & 0xffff0000) != 0x398c0000) ||
159             (jmp[2] != 0xf8410028) ||
160             (jmp[3] != 0xe96c0020) ||
161             (jmp[4] != 0xe84c0028)) {
162                 printk(KERN_ERR "Not a trampoline\n");
163                 return -EINVAL;
164         }
165
166         /* The bottom half is signed extended */
167         offset = ((unsigned)((unsigned short)jmp[0]) << 16) +
168                 (int)((short)jmp[1]);
169
170         pr_devel(" %x ", offset);
171
172         /* get the address this jumps too */
173         tramp = mod->arch.toc + offset + 32;
174         pr_devel("toc: %lx", tramp);
175
176         if (probe_kernel_read(jmp, (void *)tramp, 8)) {
177                 printk(KERN_ERR "Failed to read %lx\n", tramp);
178                 return -EFAULT;
179         }
180
181         pr_devel(" %08x %08x\n", jmp[0], jmp[1]);
182
183         ptr = ((unsigned long)jmp[0] << 32) + jmp[1];
184
185         /* This should match what was called */
186         if (ptr != ppc_function_entry((void *)addr)) {
187                 printk(KERN_ERR "addr does not match %lx\n", ptr);
188                 return -EINVAL;
189         }
190
191         /*
192          * We want to nop the line, but the next line is
193          *  0xe8, 0x41, 0x00, 0x28   ld r2,40(r1)
194          * This needs to be turned to a nop too.
195          */
196         if (probe_kernel_read(&op, (void *)(ip+4), MCOUNT_INSN_SIZE))
197                 return -EFAULT;
198
199         if (op != 0xe8410028) {
200                 printk(KERN_ERR "Next line is not ld! (%08x)\n", op);
201                 return -EINVAL;
202         }
203
204         /*
205          * Milton Miller pointed out that we can not blindly do nops.
206          * If a task was preempted when calling a trace function,
207          * the nops will remove the way to restore the TOC in r2
208          * and the r2 TOC will get corrupted.
209          */
210
211         /*
212          * Replace:
213          *   bl <tramp>  <==== will be replaced with "b 1f"
214          *   ld r2,40(r1)
215          *  1:
216          */
217         op = 0x48000008;        /* b +8 */
218
219         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
220                 return -EPERM;
221
222
223         flush_icache_range(ip, ip + 8);
224
225         return 0;
226 }
227
228 #else /* !PPC64 */
229 static int
230 __ftrace_make_nop(struct module *mod,
231                   struct dyn_ftrace *rec, unsigned long addr)
232 {
233         unsigned int op;
234         unsigned int jmp[4];
235         unsigned long ip = rec->ip;
236         unsigned long tramp;
237
238         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
239                 return -EFAULT;
240
241         /* Make sure that that this is still a 24bit jump */
242         if (!is_bl_op(op)) {
243                 printk(KERN_ERR "Not expected bl: opcode is %x\n", op);
244                 return -EINVAL;
245         }
246
247         /* lets find where the pointer goes */
248         tramp = find_bl_target(ip, op);
249
250         /*
251          * On PPC32 the trampoline looks like:
252          *  0x3d, 0x60, 0x00, 0x00  lis r11,sym@ha
253          *  0x39, 0x6b, 0x00, 0x00  addi r11,r11,sym@l
254          *  0x7d, 0x69, 0x03, 0xa6  mtctr r11
255          *  0x4e, 0x80, 0x04, 0x20  bctr
256          */
257
258         pr_devel("ip:%lx jumps to %lx", ip, tramp);
259
260         /* Find where the trampoline jumps to */
261         if (probe_kernel_read(jmp, (void *)tramp, sizeof(jmp))) {
262                 printk(KERN_ERR "Failed to read %lx\n", tramp);
263                 return -EFAULT;
264         }
265
266         pr_devel(" %08x %08x ", jmp[0], jmp[1]);
267
268         /* verify that this is what we expect it to be */
269         if (((jmp[0] & 0xffff0000) != 0x3d600000) ||
270             ((jmp[1] & 0xffff0000) != 0x396b0000) ||
271             (jmp[2] != 0x7d6903a6) ||
272             (jmp[3] != 0x4e800420)) {
273                 printk(KERN_ERR "Not a trampoline\n");
274                 return -EINVAL;
275         }
276
277         tramp = (jmp[1] & 0xffff) |
278                 ((jmp[0] & 0xffff) << 16);
279         if (tramp & 0x8000)
280                 tramp -= 0x10000;
281
282         pr_devel(" %lx ", tramp);
283
284         if (tramp != addr) {
285                 printk(KERN_ERR
286                        "Trampoline location %08lx does not match addr\n",
287                        tramp);
288                 return -EINVAL;
289         }
290
291         op = PPC_INST_NOP;
292
293         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
294                 return -EPERM;
295
296         flush_icache_range(ip, ip + 8);
297
298         return 0;
299 }
300 #endif /* PPC64 */
301 #endif /* CONFIG_MODULES */
302
303 int ftrace_make_nop(struct module *mod,
304                     struct dyn_ftrace *rec, unsigned long addr)
305 {
306         unsigned long ip = rec->ip;
307         unsigned int old, new;
308
309         /*
310          * If the calling address is more that 24 bits away,
311          * then we had to use a trampoline to make the call.
312          * Otherwise just update the call site.
313          */
314         if (test_24bit_addr(ip, addr)) {
315                 /* within range */
316                 old = ftrace_call_replace(ip, addr, 1);
317                 new = ftrace_nop_replace();
318                 return ftrace_modify_code(ip, old, new);
319         }
320
321 #ifdef CONFIG_MODULES
322         /*
323          * Out of range jumps are called from modules.
324          * We should either already have a pointer to the module
325          * or it has been passed in.
326          */
327         if (!rec->arch.mod) {
328                 if (!mod) {
329                         printk(KERN_ERR "No module loaded addr=%lx\n",
330                                addr);
331                         return -EFAULT;
332                 }
333                 rec->arch.mod = mod;
334         } else if (mod) {
335                 if (mod != rec->arch.mod) {
336                         printk(KERN_ERR
337                                "Record mod %p not equal to passed in mod %p\n",
338                                rec->arch.mod, mod);
339                         return -EINVAL;
340                 }
341                 /* nothing to do if mod == rec->arch.mod */
342         } else
343                 mod = rec->arch.mod;
344
345         return __ftrace_make_nop(mod, rec, addr);
346 #else
347         /* We should not get here without modules */
348         return -EINVAL;
349 #endif /* CONFIG_MODULES */
350 }
351
352 #ifdef CONFIG_MODULES
353 #ifdef CONFIG_PPC64
354 static int
355 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
356 {
357         unsigned int op[2];
358         unsigned long ip = rec->ip;
359
360         /* read where this goes */
361         if (probe_kernel_read(op, (void *)ip, MCOUNT_INSN_SIZE * 2))
362                 return -EFAULT;
363
364         /*
365          * It should be pointing to two nops or
366          *  b +8; ld r2,40(r1)
367          */
368         if (((op[0] != 0x48000008) || (op[1] != 0xe8410028)) &&
369             ((op[0] != PPC_INST_NOP) || (op[1] != PPC_INST_NOP))) {
370                 printk(KERN_ERR "Expected NOPs but have %x %x\n", op[0], op[1]);
371                 return -EINVAL;
372         }
373
374         /* If we never set up a trampoline to ftrace_caller, then bail */
375         if (!rec->arch.mod->arch.tramp) {
376                 printk(KERN_ERR "No ftrace trampoline\n");
377                 return -EINVAL;
378         }
379
380         /* create the branch to the trampoline */
381         op[0] = create_branch((unsigned int *)ip,
382                               rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
383         if (!op[0]) {
384                 printk(KERN_ERR "REL24 out of range!\n");
385                 return -EINVAL;
386         }
387
388         /* ld r2,40(r1) */
389         op[1] = 0xe8410028;
390
391         pr_devel("write to %lx\n", rec->ip);
392
393         if (probe_kernel_write((void *)ip, op, MCOUNT_INSN_SIZE * 2))
394                 return -EPERM;
395
396         flush_icache_range(ip, ip + 8);
397
398         return 0;
399 }
400 #else
401 static int
402 __ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
403 {
404         unsigned int op;
405         unsigned long ip = rec->ip;
406
407         /* read where this goes */
408         if (probe_kernel_read(&op, (void *)ip, MCOUNT_INSN_SIZE))
409                 return -EFAULT;
410
411         /* It should be pointing to a nop */
412         if (op != PPC_INST_NOP) {
413                 printk(KERN_ERR "Expected NOP but have %x\n", op);
414                 return -EINVAL;
415         }
416
417         /* If we never set up a trampoline to ftrace_caller, then bail */
418         if (!rec->arch.mod->arch.tramp) {
419                 printk(KERN_ERR "No ftrace trampoline\n");
420                 return -EINVAL;
421         }
422
423         /* create the branch to the trampoline */
424         op = create_branch((unsigned int *)ip,
425                            rec->arch.mod->arch.tramp, BRANCH_SET_LINK);
426         if (!op) {
427                 printk(KERN_ERR "REL24 out of range!\n");
428                 return -EINVAL;
429         }
430
431         pr_devel("write to %lx\n", rec->ip);
432
433         if (probe_kernel_write((void *)ip, &op, MCOUNT_INSN_SIZE))
434                 return -EPERM;
435
436         flush_icache_range(ip, ip + 8);
437
438         return 0;
439 }
440 #endif /* CONFIG_PPC64 */
441 #endif /* CONFIG_MODULES */
442
443 int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr)
444 {
445         unsigned long ip = rec->ip;
446         unsigned int old, new;
447
448         /*
449          * If the calling address is more that 24 bits away,
450          * then we had to use a trampoline to make the call.
451          * Otherwise just update the call site.
452          */
453         if (test_24bit_addr(ip, addr)) {
454                 /* within range */
455                 old = ftrace_nop_replace();
456                 new = ftrace_call_replace(ip, addr, 1);
457                 return ftrace_modify_code(ip, old, new);
458         }
459
460 #ifdef CONFIG_MODULES
461         /*
462          * Out of range jumps are called from modules.
463          * Being that we are converting from nop, it had better
464          * already have a module defined.
465          */
466         if (!rec->arch.mod) {
467                 printk(KERN_ERR "No module loaded\n");
468                 return -EINVAL;
469         }
470
471         return __ftrace_make_call(rec, addr);
472 #else
473         /* We should not get here without modules */
474         return -EINVAL;
475 #endif /* CONFIG_MODULES */
476 }
477
478 int ftrace_update_ftrace_func(ftrace_func_t func)
479 {
480         unsigned long ip = (unsigned long)(&ftrace_call);
481         unsigned int old, new;
482         int ret;
483
484         old = *(unsigned int *)&ftrace_call;
485         new = ftrace_call_replace(ip, (unsigned long)func, 1);
486         ret = ftrace_modify_code(ip, old, new);
487
488         return ret;
489 }
490
491 int __init ftrace_dyn_arch_init(void *data)
492 {
493         /* caller expects data to be zero */
494         unsigned long *p = data;
495
496         *p = 0;
497
498         return 0;
499 }
500 #endif /* CONFIG_DYNAMIC_FTRACE */
501
502 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
503
504 #ifdef CONFIG_DYNAMIC_FTRACE
505 extern void ftrace_graph_call(void);
506 extern void ftrace_graph_stub(void);
507
508 int ftrace_enable_ftrace_graph_caller(void)
509 {
510         unsigned long ip = (unsigned long)(&ftrace_graph_call);
511         unsigned long addr = (unsigned long)(&ftrace_graph_caller);
512         unsigned long stub = (unsigned long)(&ftrace_graph_stub);
513         unsigned int old, new;
514
515         old = ftrace_call_replace(ip, stub, 0);
516         new = ftrace_call_replace(ip, addr, 0);
517
518         return ftrace_modify_code(ip, old, new);
519 }
520
521 int ftrace_disable_ftrace_graph_caller(void)
522 {
523         unsigned long ip = (unsigned long)(&ftrace_graph_call);
524         unsigned long addr = (unsigned long)(&ftrace_graph_caller);
525         unsigned long stub = (unsigned long)(&ftrace_graph_stub);
526         unsigned int old, new;
527
528         old = ftrace_call_replace(ip, addr, 0);
529         new = ftrace_call_replace(ip, stub, 0);
530
531         return ftrace_modify_code(ip, old, new);
532 }
533 #endif /* CONFIG_DYNAMIC_FTRACE */
534
535 #ifdef CONFIG_PPC64
536 extern void mod_return_to_handler(void);
537 #endif
538
539 /*
540  * Hook the return address and push it in the stack of return addrs
541  * in current thread info.
542  */
543 void prepare_ftrace_return(unsigned long *parent, unsigned long self_addr)
544 {
545         unsigned long old;
546         int faulted;
547         struct ftrace_graph_ent trace;
548         unsigned long return_hooker = (unsigned long)&return_to_handler;
549
550         if (unlikely(atomic_read(&current->tracing_graph_pause)))
551                 return;
552
553 #ifdef CONFIG_PPC64
554         /* non core kernel code needs to save and restore the TOC */
555         if (REGION_ID(self_addr) != KERNEL_REGION_ID)
556                 return_hooker = (unsigned long)&mod_return_to_handler;
557 #endif
558
559         return_hooker = ppc_function_entry((void *)return_hooker);
560
561         /*
562          * Protect against fault, even if it shouldn't
563          * happen. This tool is too much intrusive to
564          * ignore such a protection.
565          */
566         asm volatile(
567                 "1: " PPC_LL "%[old], 0(%[parent])\n"
568                 "2: " PPC_STL "%[return_hooker], 0(%[parent])\n"
569                 "   li %[faulted], 0\n"
570                 "3:\n"
571
572                 ".section .fixup, \"ax\"\n"
573                 "4: li %[faulted], 1\n"
574                 "   b 3b\n"
575                 ".previous\n"
576
577                 ".section __ex_table,\"a\"\n"
578                         PPC_LONG_ALIGN "\n"
579                         PPC_LONG "1b,4b\n"
580                         PPC_LONG "2b,4b\n"
581                 ".previous"
582
583                 : [old] "=&r" (old), [faulted] "=r" (faulted)
584                 : [parent] "r" (parent), [return_hooker] "r" (return_hooker)
585                 : "memory"
586         );
587
588         if (unlikely(faulted)) {
589                 ftrace_graph_stop();
590                 WARN_ON(1);
591                 return;
592         }
593
594         if (ftrace_push_return_trace(old, self_addr, &trace.depth) == -EBUSY) {
595                 *parent = old;
596                 return;
597         }
598
599         trace.func = self_addr;
600
601         /* Only trace if the calling function expects to */
602         if (!ftrace_graph_entry(&trace)) {
603                 current->curr_ret_stack--;
604                 *parent = old;
605         }
606 }
607 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */