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