]> git.karo-electronics.de Git - karo-tx-linux.git/blob - arch/x86/kernel/mcount_64.S
Merge tag 'iio-fixes-for-4.7a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23...
[karo-tx-linux.git] / arch / x86 / kernel / mcount_64.S
1 /*
2  *  linux/arch/x86_64/mcount_64.S
3  *
4  *  Copyright (C) 2014  Steven Rostedt, Red Hat Inc
5  */
6
7 #include <linux/linkage.h>
8 #include <asm/ptrace.h>
9 #include <asm/ftrace.h>
10
11
12         .code64
13         .section .entry.text, "ax"
14
15
16 #ifdef CONFIG_FUNCTION_TRACER
17
18 #ifdef CC_USING_FENTRY
19 # define function_hook  __fentry__
20 #else
21 # define function_hook  mcount
22 #endif
23
24 /* All cases save the original rbp (8 bytes) */
25 #ifdef CONFIG_FRAME_POINTER
26 # ifdef CC_USING_FENTRY
27 /* Save parent and function stack frames (rip and rbp) */
28 #  define MCOUNT_FRAME_SIZE     (8+16*2)
29 # else
30 /* Save just function stack frame (rip and rbp) */
31 #  define MCOUNT_FRAME_SIZE     (8+16)
32 # endif
33 #else
34 /* No need to save a stack frame */
35 # define MCOUNT_FRAME_SIZE      8
36 #endif /* CONFIG_FRAME_POINTER */
37
38 /* Size of stack used to save mcount regs in save_mcount_regs */
39 #define MCOUNT_REG_SIZE         (SS+8 + MCOUNT_FRAME_SIZE)
40
41 /*
42  * gcc -pg option adds a call to 'mcount' in most functions.
43  * When -mfentry is used, the call is to 'fentry' and not 'mcount'
44  * and is done before the function's stack frame is set up.
45  * They both require a set of regs to be saved before calling
46  * any C code and restored before returning back to the function.
47  *
48  * On boot up, all these calls are converted into nops. When tracing
49  * is enabled, the call can jump to either ftrace_caller or
50  * ftrace_regs_caller. Callbacks (tracing functions) that require
51  * ftrace_regs_caller (like kprobes) need to have pt_regs passed to
52  * it. For this reason, the size of the pt_regs structure will be
53  * allocated on the stack and the required mcount registers will
54  * be saved in the locations that pt_regs has them in.
55  */
56
57 /*
58  * @added: the amount of stack added before calling this
59  *
60  * After this is called, the following registers contain:
61  *
62  *  %rdi - holds the address that called the trampoline
63  *  %rsi - holds the parent function (traced function's return address)
64  *  %rdx - holds the original %rbp
65  */
66 .macro save_mcount_regs added=0
67
68         /* Always save the original rbp */
69         pushq %rbp
70
71 #ifdef CONFIG_FRAME_POINTER
72         /*
73          * Stack traces will stop at the ftrace trampoline if the frame pointer
74          * is not set up properly. If fentry is used, we need to save a frame
75          * pointer for the parent as well as the function traced, because the
76          * fentry is called before the stack frame is set up, where as mcount
77          * is called afterward.
78          */
79 #ifdef CC_USING_FENTRY
80         /* Save the parent pointer (skip orig rbp and our return address) */
81         pushq \added+8*2(%rsp)
82         pushq %rbp
83         movq %rsp, %rbp
84         /* Save the return address (now skip orig rbp, rbp and parent) */
85         pushq \added+8*3(%rsp)
86 #else
87         /* Can't assume that rip is before this (unless added was zero) */
88         pushq \added+8(%rsp)
89 #endif
90         pushq %rbp
91         movq %rsp, %rbp
92 #endif /* CONFIG_FRAME_POINTER */
93
94         /*
95          * We add enough stack to save all regs.
96          */
97         subq $(MCOUNT_REG_SIZE - MCOUNT_FRAME_SIZE), %rsp
98         movq %rax, RAX(%rsp)
99         movq %rcx, RCX(%rsp)
100         movq %rdx, RDX(%rsp)
101         movq %rsi, RSI(%rsp)
102         movq %rdi, RDI(%rsp)
103         movq %r8, R8(%rsp)
104         movq %r9, R9(%rsp)
105         /*
106          * Save the original RBP. Even though the mcount ABI does not
107          * require this, it helps out callers.
108          */
109         movq MCOUNT_REG_SIZE-8(%rsp), %rdx
110         movq %rdx, RBP(%rsp)
111
112         /* Copy the parent address into %rsi (second parameter) */
113 #ifdef CC_USING_FENTRY
114         movq MCOUNT_REG_SIZE+8+\added(%rsp), %rsi
115 #else
116         /* %rdx contains original %rbp */
117         movq 8(%rdx), %rsi
118 #endif
119
120          /* Move RIP to its proper location */
121         movq MCOUNT_REG_SIZE+\added(%rsp), %rdi
122         movq %rdi, RIP(%rsp)
123
124         /*
125          * Now %rdi (the first parameter) has the return address of
126          * where ftrace_call returns. But the callbacks expect the
127          * address of the call itself.
128          */
129         subq $MCOUNT_INSN_SIZE, %rdi
130         .endm
131
132 .macro restore_mcount_regs
133         movq R9(%rsp), %r9
134         movq R8(%rsp), %r8
135         movq RDI(%rsp), %rdi
136         movq RSI(%rsp), %rsi
137         movq RDX(%rsp), %rdx
138         movq RCX(%rsp), %rcx
139         movq RAX(%rsp), %rax
140
141         /* ftrace_regs_caller can modify %rbp */
142         movq RBP(%rsp), %rbp
143
144         addq $MCOUNT_REG_SIZE, %rsp
145
146         .endm
147
148 #ifdef CONFIG_DYNAMIC_FTRACE
149
150 ENTRY(function_hook)
151         retq
152 END(function_hook)
153
154 ENTRY(ftrace_caller)
155         /* save_mcount_regs fills in first two parameters */
156         save_mcount_regs
157
158 GLOBAL(ftrace_caller_op_ptr)
159         /* Load the ftrace_ops into the 3rd parameter */
160         movq function_trace_op(%rip), %rdx
161
162         /* regs go into 4th parameter (but make it NULL) */
163         movq $0, %rcx
164
165 GLOBAL(ftrace_call)
166         call ftrace_stub
167
168         restore_mcount_regs
169
170         /*
171          * The copied trampoline must call ftrace_epilogue as it
172          * still may need to call the function graph tracer.
173          *
174          * The code up to this label is copied into trampolines so
175          * think twice before adding any new code or changing the
176          * layout here.
177          */
178 GLOBAL(ftrace_epilogue)
179
180 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
181 GLOBAL(ftrace_graph_call)
182         jmp ftrace_stub
183 #endif
184
185 /* This is weak to keep gas from relaxing the jumps */
186 WEAK(ftrace_stub)
187         retq
188 END(ftrace_caller)
189
190 ENTRY(ftrace_regs_caller)
191         /* Save the current flags before any operations that can change them */
192         pushfq
193
194         /* added 8 bytes to save flags */
195         save_mcount_regs 8
196         /* save_mcount_regs fills in first two parameters */
197
198 GLOBAL(ftrace_regs_caller_op_ptr)
199         /* Load the ftrace_ops into the 3rd parameter */
200         movq function_trace_op(%rip), %rdx
201
202         /* Save the rest of pt_regs */
203         movq %r15, R15(%rsp)
204         movq %r14, R14(%rsp)
205         movq %r13, R13(%rsp)
206         movq %r12, R12(%rsp)
207         movq %r11, R11(%rsp)
208         movq %r10, R10(%rsp)
209         movq %rbx, RBX(%rsp)
210         /* Copy saved flags */
211         movq MCOUNT_REG_SIZE(%rsp), %rcx
212         movq %rcx, EFLAGS(%rsp)
213         /* Kernel segments */
214         movq $__KERNEL_DS, %rcx
215         movq %rcx, SS(%rsp)
216         movq $__KERNEL_CS, %rcx
217         movq %rcx, CS(%rsp)
218         /* Stack - skipping return address and flags */
219         leaq MCOUNT_REG_SIZE+8*2(%rsp), %rcx
220         movq %rcx, RSP(%rsp)
221
222         /* regs go into 4th parameter */
223         leaq (%rsp), %rcx
224
225 GLOBAL(ftrace_regs_call)
226         call ftrace_stub
227
228         /* Copy flags back to SS, to restore them */
229         movq EFLAGS(%rsp), %rax
230         movq %rax, MCOUNT_REG_SIZE(%rsp)
231
232         /* Handlers can change the RIP */
233         movq RIP(%rsp), %rax
234         movq %rax, MCOUNT_REG_SIZE+8(%rsp)
235
236         /* restore the rest of pt_regs */
237         movq R15(%rsp), %r15
238         movq R14(%rsp), %r14
239         movq R13(%rsp), %r13
240         movq R12(%rsp), %r12
241         movq R10(%rsp), %r10
242         movq RBX(%rsp), %rbx
243
244         restore_mcount_regs
245
246         /* Restore flags */
247         popfq
248
249         /*
250          * As this jmp to ftrace_epilogue can be a short jump
251          * it must not be copied into the trampoline.
252          * The trampoline will add the code to jump
253          * to the return.
254          */
255 GLOBAL(ftrace_regs_caller_end)
256
257         jmp ftrace_epilogue
258
259 END(ftrace_regs_caller)
260
261
262 #else /* ! CONFIG_DYNAMIC_FTRACE */
263
264 ENTRY(function_hook)
265         cmpq $ftrace_stub, ftrace_trace_function
266         jnz trace
267
268 fgraph_trace:
269 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
270         cmpq $ftrace_stub, ftrace_graph_return
271         jnz ftrace_graph_caller
272
273         cmpq $ftrace_graph_entry_stub, ftrace_graph_entry
274         jnz ftrace_graph_caller
275 #endif
276
277 GLOBAL(ftrace_stub)
278         retq
279
280 trace:
281         /* save_mcount_regs fills in first two parameters */
282         save_mcount_regs
283
284         /*
285          * When DYNAMIC_FTRACE is not defined, ARCH_SUPPORTS_FTRACE_OPS is not
286          * set (see include/asm/ftrace.h and include/linux/ftrace.h).  Only the
287          * ip and parent ip are used and the list function is called when
288          * function tracing is enabled.
289          */
290         call   *ftrace_trace_function
291
292         restore_mcount_regs
293
294         jmp fgraph_trace
295 END(function_hook)
296 #endif /* CONFIG_DYNAMIC_FTRACE */
297 #endif /* CONFIG_FUNCTION_TRACER */
298
299 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
300 ENTRY(ftrace_graph_caller)
301         /* Saves rbp into %rdx and fills first parameter  */
302         save_mcount_regs
303
304 #ifdef CC_USING_FENTRY
305         leaq MCOUNT_REG_SIZE+8(%rsp), %rsi
306         movq $0, %rdx   /* No framepointers needed */
307 #else
308         /* Save address of the return address of traced function */
309         leaq 8(%rdx), %rsi
310         /* ftrace does sanity checks against frame pointers */
311         movq (%rdx), %rdx
312 #endif
313         call    prepare_ftrace_return
314
315         restore_mcount_regs
316
317         retq
318 END(ftrace_graph_caller)
319
320 GLOBAL(return_to_handler)
321         subq  $24, %rsp
322
323         /* Save the return values */
324         movq %rax, (%rsp)
325         movq %rdx, 8(%rsp)
326         movq %rbp, %rdi
327
328         call ftrace_return_to_handler
329
330         movq %rax, %rdi
331         movq 8(%rsp), %rdx
332         movq (%rsp), %rax
333         addq $24, %rsp
334         jmp *%rdi
335 #endif