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