1/* SPDX-License-Identifier: GPL-2.0 */
 2#ifndef _ASM_X86_FTRACE_H
 3#define _ASM_X86_FTRACE_H
 4
 5#ifdef CONFIG_FUNCTION_TRACER
 6#ifdef CC_USING_FENTRY
 7# define MCOUNT_ADDR		((unsigned long)(__fentry__))
 8#else
 9# define MCOUNT_ADDR		((unsigned long)(mcount))
10# define HAVE_FUNCTION_GRAPH_FP_TEST
11#endif
 
12#define MCOUNT_INSN_SIZE	5 /* sizeof mcount call */
13
 
 
 
 
 
 
 
14#ifdef CONFIG_DYNAMIC_FTRACE
15#define ARCH_SUPPORTS_FTRACE_OPS 1
16#endif
17
18#define HAVE_FUNCTION_GRAPH_RET_ADDR_PTR
19
20#ifndef __ASSEMBLY__
21extern void mcount(void);
22extern atomic_t modifying_ftrace_code;
23extern void __fentry__(void);
24
25static inline unsigned long ftrace_call_adjust(unsigned long addr)
26{
27	/*
28	 * addr is the address of the mcount call instruction.
29	 * recordmcount does the necessary offset calculation.
30	 */
31	return addr;
32}
33
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
34#ifdef CONFIG_DYNAMIC_FTRACE
35
36struct dyn_arch_ftrace {
37	/* No extra data needed for x86 */
38};
39
40int ftrace_int3_handler(struct pt_regs *regs);
41
42#define FTRACE_GRAPH_TRAMP_ADDR FTRACE_GRAPH_ADDR
43
44#endif /*  CONFIG_DYNAMIC_FTRACE */
45#endif /* __ASSEMBLY__ */
46#endif /* CONFIG_FUNCTION_TRACER */
47
48
49#ifndef __ASSEMBLY__
50
 
 
 
 
 
 
51#define ARCH_HAS_SYSCALL_MATCH_SYM_NAME
52static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
53{
54	/*
55	 * Compare the symbol name with the system call name. Skip the
56	 * "__x64_sys", "__ia32_sys" or simple "sys" prefix.
57	 */
58	return !strcmp(sym + 3, name + 3) ||
59		(!strncmp(sym, "__x64_", 6) && !strcmp(sym + 9, name + 3)) ||
60		(!strncmp(sym, "__ia32_", 7) && !strcmp(sym + 10, name + 3));
 
61}
62
63#ifndef COMPILE_OFFSETS
64
65#if defined(CONFIG_FTRACE_SYSCALLS) && defined(CONFIG_IA32_EMULATION)
66#include <asm/compat.h>
67
68/*
69 * Because ia32 syscalls do not map to x86_64 syscall numbers
70 * this screws up the trace output when tracing a ia32 task.
71 * Instead of reporting bogus syscalls, just do not trace them.
72 *
73 * If the user really wants these, then they should use the
74 * raw syscall tracepoints with filtering.
75 */
76#define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS 1
77static inline bool arch_trace_is_compat_syscall(struct pt_regs *regs)
78{
79	if (in_compat_syscall())
80		return true;
81	return false;
82}
83#endif /* CONFIG_FTRACE_SYSCALLS && CONFIG_IA32_EMULATION */
84#endif /* !COMPILE_OFFSETS */
85#endif /* !__ASSEMBLY__ */
86
87#endif /* _ASM_X86_FTRACE_H */

  1/* SPDX-License-Identifier: GPL-2.0 */
  2#ifndef _ASM_X86_FTRACE_H
  3#define _ASM_X86_FTRACE_H
  4
  5#ifdef CONFIG_FUNCTION_TRACER
  6#ifndef CC_USING_FENTRY
  7# error Compiler does not support fentry?
 
 
 
  8#endif
  9# define MCOUNT_ADDR		((unsigned long)(__fentry__))
 10#define MCOUNT_INSN_SIZE	5 /* sizeof mcount call */
 11
 12/* Ignore unused weak functions which will have non zero offsets */
 13#ifdef CONFIG_HAVE_FENTRY
 14# include <asm/ibt.h>
 15/* Add offset for endbr64 if IBT enabled */
 16# define FTRACE_MCOUNT_MAX_OFFSET	ENDBR_INSN_SIZE
 17#endif
 18
 19#ifdef CONFIG_DYNAMIC_FTRACE
 20#define ARCH_SUPPORTS_FTRACE_OPS 1
 21#endif
 22
 23#define HAVE_FUNCTION_GRAPH_RET_ADDR_PTR
 24
 25#ifndef __ASSEMBLY__
 
 
 26extern void __fentry__(void);
 27
 28static inline unsigned long ftrace_call_adjust(unsigned long addr)
 29{
 30	/*
 31	 * addr is the address of the mcount call instruction.
 32	 * recordmcount does the necessary offset calculation.
 33	 */
 34	return addr;
 35}
 36
 37#ifdef CONFIG_HAVE_DYNAMIC_FTRACE_WITH_ARGS
 38struct ftrace_regs {
 39	struct pt_regs		regs;
 40};
 41
 42static __always_inline struct pt_regs *
 43arch_ftrace_get_regs(struct ftrace_regs *fregs)
 44{
 45	/* Only when FL_SAVE_REGS is set, cs will be non zero */
 46	if (!fregs->regs.cs)
 47		return NULL;
 48	return &fregs->regs;
 49}
 50
 51#define ftrace_regs_set_instruction_pointer(fregs, _ip)	\
 52	do { (fregs)->regs.ip = (_ip); } while (0)
 53
 54#define ftrace_regs_get_instruction_pointer(fregs) \
 55	((fregs)->regs.ip)
 56
 57#define ftrace_regs_get_argument(fregs, n) \
 58	regs_get_kernel_argument(&(fregs)->regs, n)
 59#define ftrace_regs_get_stack_pointer(fregs) \
 60	kernel_stack_pointer(&(fregs)->regs)
 61#define ftrace_regs_return_value(fregs) \
 62	regs_return_value(&(fregs)->regs)
 63#define ftrace_regs_set_return_value(fregs, ret) \
 64	regs_set_return_value(&(fregs)->regs, ret)
 65#define ftrace_override_function_with_return(fregs) \
 66	override_function_with_return(&(fregs)->regs)
 67#define ftrace_regs_query_register_offset(name) \
 68	regs_query_register_offset(name)
 69
 70struct ftrace_ops;
 71#define ftrace_graph_func ftrace_graph_func
 72void ftrace_graph_func(unsigned long ip, unsigned long parent_ip,
 73		       struct ftrace_ops *op, struct ftrace_regs *fregs);
 74#else
 75#define FTRACE_GRAPH_TRAMP_ADDR FTRACE_GRAPH_ADDR
 76#endif
 77
 78#ifdef CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS
 79/*
 80 * When a ftrace registered caller is tracing a function that is
 81 * also set by a register_ftrace_direct() call, it needs to be
 82 * differentiated in the ftrace_caller trampoline. To do this, we
 83 * place the direct caller in the ORIG_AX part of pt_regs. This
 84 * tells the ftrace_caller that there's a direct caller.
 85 */
 86static inline void
 87__arch_ftrace_set_direct_caller(struct pt_regs *regs, unsigned long addr)
 88{
 89	/* Emulate a call */
 90	regs->orig_ax = addr;
 91}
 92#define arch_ftrace_set_direct_caller(fregs, addr) \
 93	__arch_ftrace_set_direct_caller(&(fregs)->regs, addr)
 94#endif /* CONFIG_DYNAMIC_FTRACE_WITH_DIRECT_CALLS */
 95
 96#ifdef CONFIG_DYNAMIC_FTRACE
 97
 98struct dyn_arch_ftrace {
 99	/* No extra data needed for x86 */
100};
101
 
 
 
 
102#endif /*  CONFIG_DYNAMIC_FTRACE */
103#endif /* __ASSEMBLY__ */
104#endif /* CONFIG_FUNCTION_TRACER */
105
106
107#ifndef __ASSEMBLY__
108
109#if defined(CONFIG_FUNCTION_TRACER) && defined(CONFIG_DYNAMIC_FTRACE)
110extern void set_ftrace_ops_ro(void);
111#else
112static inline void set_ftrace_ops_ro(void) { }
113#endif
114
115#define ARCH_HAS_SYSCALL_MATCH_SYM_NAME
116static inline bool arch_syscall_match_sym_name(const char *sym, const char *name)
117{
118	/*
119	 * Compare the symbol name with the system call name. Skip the
120	 * "__x64_sys", "__ia32_sys", "__do_sys" or simple "sys" prefix.
121	 */
122	return !strcmp(sym + 3, name + 3) ||
123		(!strncmp(sym, "__x64_", 6) && !strcmp(sym + 9, name + 3)) ||
124		(!strncmp(sym, "__ia32_", 7) && !strcmp(sym + 10, name + 3)) ||
125		(!strncmp(sym, "__do_sys", 8) && !strcmp(sym + 8, name + 3));
126}
127
128#ifndef COMPILE_OFFSETS
129
130#if defined(CONFIG_FTRACE_SYSCALLS) && defined(CONFIG_IA32_EMULATION)
131#include <linux/compat.h>
132
133/*
134 * Because ia32 syscalls do not map to x86_64 syscall numbers
135 * this screws up the trace output when tracing a ia32 task.
136 * Instead of reporting bogus syscalls, just do not trace them.
137 *
138 * If the user really wants these, then they should use the
139 * raw syscall tracepoints with filtering.
140 */
141#define ARCH_TRACE_IGNORE_COMPAT_SYSCALLS 1
142static inline bool arch_trace_is_compat_syscall(struct pt_regs *regs)
143{
144	return in_32bit_syscall();
 
 
145}
146#endif /* CONFIG_FTRACE_SYSCALLS && CONFIG_IA32_EMULATION */
147#endif /* !COMPILE_OFFSETS */
148#endif /* !__ASSEMBLY__ */
149
150#endif /* _ASM_X86_FTRACE_H */