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