2014-05-08 19:21:52 +00:00
|
|
|
/*
|
|
|
|
|
* linux/arch/x86_64/mcount_64.S
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2014 Steven Rostedt, Red Hat Inc
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/linkage.h>
|
|
|
|
|
#include <asm/ptrace.h>
|
|
|
|
|
#include <asm/ftrace.h>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
.code64
|
|
|
|
|
.section .entry.text, "ax"
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FUNCTION_TRACER
|
|
|
|
|
|
|
|
|
|
#ifdef CC_USING_FENTRY
|
|
|
|
|
# define function_hook __fentry__
|
|
|
|
|
#else
|
|
|
|
|
# define function_hook mcount
|
|
|
|
|
#endif
|
|
|
|
|
|
2014-11-24 16:43:39 +00:00
|
|
|
/*
|
|
|
|
|
* gcc -pg option adds a call to 'mcount' in most functions.
|
|
|
|
|
* When -mfentry is used, the call is to 'fentry' and not 'mcount'
|
|
|
|
|
* and is done before the function's stack frame is set up.
|
|
|
|
|
* They both require a set of regs to be saved before calling
|
|
|
|
|
* any C code and restored before returning back to the function.
|
|
|
|
|
*
|
|
|
|
|
* On boot up, all these calls are converted into nops. When tracing
|
|
|
|
|
* is enabled, the call can jump to either ftrace_caller or
|
|
|
|
|
* ftrace_regs_caller. Callbacks (tracing functions) that require
|
|
|
|
|
* ftrace_regs_caller (like kprobes) need to have pt_regs passed to
|
|
|
|
|
* it. For this reason, the size of the pt_regs structure will be
|
|
|
|
|
* allocated on the stack and the required mcount registers will
|
|
|
|
|
* be saved in the locations that pt_regs has them in.
|
|
|
|
|
*/
|
|
|
|
|
|
2014-11-24 16:30:58 +00:00
|
|
|
/* skip is set if the stack was already partially adjusted */
|
2014-11-24 16:43:39 +00:00
|
|
|
.macro save_mcount_regs skip=0
|
2014-11-24 16:30:58 +00:00
|
|
|
/*
|
|
|
|
|
* We add enough stack to save all regs.
|
|
|
|
|
*/
|
|
|
|
|
subq $(SS+8-\skip), %rsp
|
|
|
|
|
movq %rax, RAX(%rsp)
|
|
|
|
|
movq %rcx, RCX(%rsp)
|
|
|
|
|
movq %rdx, RDX(%rsp)
|
|
|
|
|
movq %rsi, RSI(%rsp)
|
|
|
|
|
movq %rdi, RDI(%rsp)
|
|
|
|
|
movq %r8, R8(%rsp)
|
|
|
|
|
movq %r9, R9(%rsp)
|
|
|
|
|
/* Move RIP to its proper location */
|
2014-11-24 18:21:09 +00:00
|
|
|
movq SS+8(%rsp), %rdi
|
|
|
|
|
movq %rdi, RIP(%rsp)
|
2014-11-24 16:30:58 +00:00
|
|
|
.endm
|
|
|
|
|
|
2014-11-24 16:43:39 +00:00
|
|
|
.macro restore_mcount_regs skip=0
|
2014-11-24 16:30:58 +00:00
|
|
|
movq R9(%rsp), %r9
|
|
|
|
|
movq R8(%rsp), %r8
|
|
|
|
|
movq RDI(%rsp), %rdi
|
|
|
|
|
movq RSI(%rsp), %rsi
|
|
|
|
|
movq RDX(%rsp), %rdx
|
|
|
|
|
movq RCX(%rsp), %rcx
|
|
|
|
|
movq RAX(%rsp), %rax
|
|
|
|
|
addq $(SS+8-\skip), %rsp
|
|
|
|
|
.endm
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
/* skip is set if stack has been adjusted */
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
.macro ftrace_caller_setup trace_label skip=0
|
2014-11-24 16:43:39 +00:00
|
|
|
save_mcount_regs \skip
|
2014-05-08 19:21:52 +00:00
|
|
|
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
/* Save this location */
|
|
|
|
|
GLOBAL(\trace_label)
|
2014-05-08 19:21:52 +00:00
|
|
|
/* Load the ftrace_ops into the 3rd parameter */
|
|
|
|
|
movq function_trace_op(%rip), %rdx
|
|
|
|
|
|
2014-11-24 18:21:09 +00:00
|
|
|
/* %rdi already has %rip from the save_mcount_regs macro */
|
2014-05-08 19:21:52 +00:00
|
|
|
subq $MCOUNT_INSN_SIZE, %rdi
|
|
|
|
|
/* Load the parent_ip into the second parameter */
|
|
|
|
|
#ifdef CC_USING_FENTRY
|
|
|
|
|
movq SS+16(%rsp), %rsi
|
|
|
|
|
#else
|
|
|
|
|
movq 8(%rbp), %rsi
|
|
|
|
|
#endif
|
|
|
|
|
.endm
|
|
|
|
|
|
2014-11-24 19:54:27 +00:00
|
|
|
#ifdef CONFIG_DYNAMIC_FTRACE
|
|
|
|
|
|
|
|
|
|
ENTRY(function_hook)
|
|
|
|
|
retq
|
|
|
|
|
END(function_hook)
|
|
|
|
|
|
2014-11-19 00:13:25 +00:00
|
|
|
#ifdef CONFIG_FRAME_POINTER
|
|
|
|
|
/*
|
|
|
|
|
* Stack traces will stop at the ftrace trampoline if the frame pointer
|
|
|
|
|
* is not set up properly. If fentry is used, we need to save a frame
|
|
|
|
|
* pointer for the parent as well as the function traced, because the
|
|
|
|
|
* fentry is called before the stack frame is set up, where as mcount
|
|
|
|
|
* is called afterward.
|
|
|
|
|
*/
|
|
|
|
|
.macro create_frame parent rip
|
|
|
|
|
#ifdef CC_USING_FENTRY
|
|
|
|
|
pushq \parent
|
|
|
|
|
pushq %rbp
|
|
|
|
|
movq %rsp, %rbp
|
|
|
|
|
#endif
|
|
|
|
|
pushq \rip
|
|
|
|
|
pushq %rbp
|
|
|
|
|
movq %rsp, %rbp
|
|
|
|
|
.endm
|
|
|
|
|
|
|
|
|
|
.macro restore_frame
|
|
|
|
|
#ifdef CC_USING_FENTRY
|
|
|
|
|
addq $16, %rsp
|
|
|
|
|
#endif
|
|
|
|
|
popq %rbp
|
|
|
|
|
addq $8, %rsp
|
|
|
|
|
.endm
|
|
|
|
|
#else
|
|
|
|
|
.macro create_frame parent rip
|
|
|
|
|
.endm
|
|
|
|
|
.macro restore_frame
|
|
|
|
|
.endm
|
|
|
|
|
#endif /* CONFIG_FRAME_POINTER */
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
ENTRY(ftrace_caller)
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
ftrace_caller_setup ftrace_caller_op_ptr
|
2014-05-08 19:21:52 +00:00
|
|
|
/* regs go into 4th parameter (but make it NULL) */
|
|
|
|
|
movq $0, %rcx
|
|
|
|
|
|
2014-11-19 00:13:25 +00:00
|
|
|
create_frame %rsi, %rdi
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
GLOBAL(ftrace_call)
|
|
|
|
|
call ftrace_stub
|
|
|
|
|
|
2014-11-19 00:13:25 +00:00
|
|
|
restore_frame
|
|
|
|
|
|
2014-11-24 16:43:39 +00:00
|
|
|
restore_mcount_regs
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* The copied trampoline must call ftrace_return as it
|
|
|
|
|
* still may need to call the function graph tracer.
|
|
|
|
|
*/
|
|
|
|
|
GLOBAL(ftrace_caller_end)
|
|
|
|
|
|
|
|
|
|
GLOBAL(ftrace_return)
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
|
GLOBAL(ftrace_graph_call)
|
|
|
|
|
jmp ftrace_stub
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
GLOBAL(ftrace_stub)
|
|
|
|
|
retq
|
|
|
|
|
END(ftrace_caller)
|
|
|
|
|
|
|
|
|
|
ENTRY(ftrace_regs_caller)
|
|
|
|
|
/* Save the current flags before compare (in SS location)*/
|
|
|
|
|
pushfq
|
|
|
|
|
|
|
|
|
|
/* skip=8 to skip flags saved in SS */
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
ftrace_caller_setup ftrace_regs_caller_op_ptr 8
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
/* Save the rest of pt_regs */
|
|
|
|
|
movq %r15, R15(%rsp)
|
|
|
|
|
movq %r14, R14(%rsp)
|
|
|
|
|
movq %r13, R13(%rsp)
|
|
|
|
|
movq %r12, R12(%rsp)
|
|
|
|
|
movq %r11, R11(%rsp)
|
|
|
|
|
movq %r10, R10(%rsp)
|
|
|
|
|
movq %rbp, RBP(%rsp)
|
|
|
|
|
movq %rbx, RBX(%rsp)
|
|
|
|
|
/* Copy saved flags */
|
|
|
|
|
movq SS(%rsp), %rcx
|
|
|
|
|
movq %rcx, EFLAGS(%rsp)
|
|
|
|
|
/* Kernel segments */
|
|
|
|
|
movq $__KERNEL_DS, %rcx
|
|
|
|
|
movq %rcx, SS(%rsp)
|
|
|
|
|
movq $__KERNEL_CS, %rcx
|
|
|
|
|
movq %rcx, CS(%rsp)
|
|
|
|
|
/* Stack - skipping return address */
|
|
|
|
|
leaq SS+16(%rsp), %rcx
|
|
|
|
|
movq %rcx, RSP(%rsp)
|
|
|
|
|
|
|
|
|
|
/* regs go into 4th parameter */
|
|
|
|
|
leaq (%rsp), %rcx
|
|
|
|
|
|
2014-11-19 00:13:25 +00:00
|
|
|
create_frame %rsi, %rdi
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
GLOBAL(ftrace_regs_call)
|
|
|
|
|
call ftrace_stub
|
|
|
|
|
|
2014-11-19 00:13:25 +00:00
|
|
|
restore_frame
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
/* Copy flags back to SS, to restore them */
|
|
|
|
|
movq EFLAGS(%rsp), %rax
|
|
|
|
|
movq %rax, SS(%rsp)
|
|
|
|
|
|
|
|
|
|
/* Handlers can change the RIP */
|
|
|
|
|
movq RIP(%rsp), %rax
|
|
|
|
|
movq %rax, SS+8(%rsp)
|
|
|
|
|
|
|
|
|
|
/* restore the rest of pt_regs */
|
|
|
|
|
movq R15(%rsp), %r15
|
|
|
|
|
movq R14(%rsp), %r14
|
|
|
|
|
movq R13(%rsp), %r13
|
|
|
|
|
movq R12(%rsp), %r12
|
|
|
|
|
movq R10(%rsp), %r10
|
|
|
|
|
movq RBP(%rsp), %rbp
|
|
|
|
|
movq RBX(%rsp), %rbx
|
|
|
|
|
|
|
|
|
|
/* skip=8 to skip flags saved in SS */
|
2014-11-24 16:43:39 +00:00
|
|
|
restore_mcount_regs 8
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
/* Restore flags */
|
|
|
|
|
popfq
|
|
|
|
|
|
ftrace/x86: Add dynamic allocated trampoline for ftrace_ops
The current method of handling multiple function callbacks is to register
a list function callback that calls all the other callbacks based on
their hash tables and compare it to the function that the callback was
called on. But this is very inefficient.
For example, if you are tracing all functions in the kernel and then
add a kprobe to a function such that the kprobe uses ftrace, the
mcount trampoline will switch from calling the function trace callback
to calling the list callback that will iterate over all registered
ftrace_ops (in this case, the function tracer and the kprobes callback).
That means for every function being traced it checks the hash of the
ftrace_ops for function tracing and kprobes, even though the kprobes
is only set at a single function. The kprobes ftrace_ops is checked
for every function being traced!
Instead of calling the list function for functions that are only being
traced by a single callback, we can call a dynamically allocated
trampoline that calls the callback directly. The function graph tracer
already uses a direct call trampoline when it is being traced by itself
but it is not dynamically allocated. It's trampoline is static in the
kernel core. The infrastructure that called the function graph trampoline
can also be used to call a dynamically allocated one.
For now, only ftrace_ops that are not dynamically allocated can have
a trampoline. That is, users such as function tracer or stack tracer.
kprobes and perf allocate their ftrace_ops, and until there's a safe
way to free the trampoline, it can not be used. The dynamically allocated
ftrace_ops may, although, use the trampoline if the kernel is not
compiled with CONFIG_PREEMPT. But that will come later.
Tested-by: Masami Hiramatsu <masami.hiramatsu.pt@hitachi.com>
Tested-by: Jiri Kosina <jkosina@suse.cz>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
2014-07-03 03:23:31 +00:00
|
|
|
/*
|
|
|
|
|
* As this jmp to ftrace_return can be a short jump
|
|
|
|
|
* it must not be copied into the trampoline.
|
|
|
|
|
* The trampoline will add the code to jump
|
|
|
|
|
* to the return.
|
|
|
|
|
*/
|
|
|
|
|
GLOBAL(ftrace_regs_caller_end)
|
|
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
jmp ftrace_return
|
2014-06-25 15:59:45 +00:00
|
|
|
|
2014-05-08 19:21:52 +00:00
|
|
|
popfq
|
|
|
|
|
jmp ftrace_stub
|
|
|
|
|
|
|
|
|
|
END(ftrace_regs_caller)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#else /* ! CONFIG_DYNAMIC_FTRACE */
|
|
|
|
|
|
|
|
|
|
ENTRY(function_hook)
|
|
|
|
|
cmpq $ftrace_stub, ftrace_trace_function
|
|
|
|
|
jnz trace
|
|
|
|
|
|
2014-11-24 19:58:17 +00:00
|
|
|
fgraph_trace:
|
2014-05-08 19:21:52 +00:00
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
|
cmpq $ftrace_stub, ftrace_graph_return
|
|
|
|
|
jnz ftrace_graph_caller
|
|
|
|
|
|
|
|
|
|
cmpq $ftrace_graph_entry_stub, ftrace_graph_entry
|
|
|
|
|
jnz ftrace_graph_caller
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
GLOBAL(ftrace_stub)
|
|
|
|
|
retq
|
|
|
|
|
|
|
|
|
|
trace:
|
2014-11-24 19:54:27 +00:00
|
|
|
ftrace_caller_setup ftrace_caller_op_ptr
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
call *ftrace_trace_function
|
|
|
|
|
|
2014-11-24 16:43:39 +00:00
|
|
|
restore_mcount_regs
|
2014-05-08 19:21:52 +00:00
|
|
|
|
2014-11-24 19:58:17 +00:00
|
|
|
jmp fgraph_trace
|
2014-05-08 19:21:52 +00:00
|
|
|
END(function_hook)
|
|
|
|
|
#endif /* CONFIG_DYNAMIC_FTRACE */
|
|
|
|
|
#endif /* CONFIG_FUNCTION_TRACER */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_FUNCTION_GRAPH_TRACER
|
|
|
|
|
ENTRY(ftrace_graph_caller)
|
2014-11-24 16:43:39 +00:00
|
|
|
save_mcount_regs
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
#ifdef CC_USING_FENTRY
|
|
|
|
|
leaq SS+16(%rsp), %rdi
|
|
|
|
|
movq $0, %rdx /* No framepointers needed */
|
|
|
|
|
#else
|
|
|
|
|
leaq 8(%rbp), %rdi
|
|
|
|
|
movq (%rbp), %rdx
|
|
|
|
|
#endif
|
|
|
|
|
movq RIP(%rsp), %rsi
|
|
|
|
|
subq $MCOUNT_INSN_SIZE, %rsi
|
|
|
|
|
|
|
|
|
|
call prepare_ftrace_return
|
|
|
|
|
|
2014-11-24 16:43:39 +00:00
|
|
|
restore_mcount_regs
|
2014-05-08 19:21:52 +00:00
|
|
|
|
|
|
|
|
retq
|
|
|
|
|
END(ftrace_graph_caller)
|
|
|
|
|
|
|
|
|
|
GLOBAL(return_to_handler)
|
|
|
|
|
subq $24, %rsp
|
|
|
|
|
|
|
|
|
|
/* Save the return values */
|
|
|
|
|
movq %rax, (%rsp)
|
|
|
|
|
movq %rdx, 8(%rsp)
|
|
|
|
|
movq %rbp, %rdi
|
|
|
|
|
|
|
|
|
|
call ftrace_return_to_handler
|
|
|
|
|
|
|
|
|
|
movq %rax, %rdi
|
|
|
|
|
movq 8(%rsp), %rdx
|
|
|
|
|
movq (%rsp), %rax
|
|
|
|
|
addq $24, %rsp
|
|
|
|
|
jmp *%rdi
|
|
|
|
|
#endif
|