1 #ifndef _LINUX_FTRACE_H 2 #define _LINUX_FTRACE_H 3 4 #include <linux/linkage.h> 5 #include <linux/fs.h> 6 #include <linux/ktime.h> 7 #include <linux/init.h> 8 #include <linux/types.h> 9 #include <linux/kallsyms.h> 10 11 #ifdef CONFIG_FUNCTION_TRACER 12 13 extern int ftrace_enabled; 14 extern int 15 ftrace_enable_sysctl(struct ctl_table *table, int write, 16 struct file *filp, void __user *buffer, size_t *lenp, 17 loff_t *ppos); 18 19 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip); 20 21 struct ftrace_ops { 22 ftrace_func_t func; 23 struct ftrace_ops *next; 24 }; 25 26 /* 27 * The ftrace_ops must be a static and should also 28 * be read_mostly. These functions do modify read_mostly variables 29 * so use them sparely. Never free an ftrace_op or modify the 30 * next pointer after it has been registered. Even after unregistering 31 * it, the next pointer may still be used internally. 32 */ 33 int register_ftrace_function(struct ftrace_ops *ops); 34 int unregister_ftrace_function(struct ftrace_ops *ops); 35 void clear_ftrace_function(void); 36 37 extern void ftrace_stub(unsigned long a0, unsigned long a1); 38 39 #else /* !CONFIG_FUNCTION_TRACER */ 40 # define register_ftrace_function(ops) do { } while (0) 41 # define unregister_ftrace_function(ops) do { } while (0) 42 # define clear_ftrace_function(ops) do { } while (0) 43 static inline void ftrace_kill(void) { } 44 #endif /* CONFIG_FUNCTION_TRACER */ 45 46 #ifdef CONFIG_DYNAMIC_FTRACE 47 48 enum { 49 FTRACE_FL_FREE = (1 << 0), 50 FTRACE_FL_FAILED = (1 << 1), 51 FTRACE_FL_FILTER = (1 << 2), 52 FTRACE_FL_ENABLED = (1 << 3), 53 FTRACE_FL_NOTRACE = (1 << 4), 54 FTRACE_FL_CONVERTED = (1 << 5), 55 FTRACE_FL_FROZEN = (1 << 6), 56 }; 57 58 struct dyn_ftrace { 59 struct list_head list; 60 unsigned long ip; /* address of mcount call-site */ 61 unsigned long flags; 62 }; 63 64 int ftrace_force_update(void); 65 void ftrace_set_filter(unsigned char *buf, int len, int reset); 66 67 /* defined in arch */ 68 extern int ftrace_ip_converted(unsigned long ip); 69 extern unsigned char *ftrace_nop_replace(void); 70 extern unsigned char *ftrace_call_replace(unsigned long ip, unsigned long addr); 71 extern int ftrace_dyn_arch_init(void *data); 72 extern int ftrace_update_ftrace_func(ftrace_func_t func); 73 extern void ftrace_caller(void); 74 extern void ftrace_call(void); 75 extern void mcount_call(void); 76 77 /** 78 * ftrace_modify_code - modify code segment 79 * @ip: the address of the code segment 80 * @old_code: the contents of what is expected to be there 81 * @new_code: the code to patch in 82 * 83 * This is a very sensitive operation and great care needs 84 * to be taken by the arch. The operation should carefully 85 * read the location, check to see if what is read is indeed 86 * what we expect it to be, and then on success of the compare, 87 * it should write to the location. 88 * 89 * Return must be: 90 * 0 on success 91 * -EFAULT on error reading the location 92 * -EINVAL on a failed compare of the contents 93 * -EPERM on error writing to the location 94 * Any other value will be considered a failure. 95 */ 96 extern int ftrace_modify_code(unsigned long ip, unsigned char *old_code, 97 unsigned char *new_code); 98 99 extern int skip_trace(unsigned long ip); 100 101 extern void ftrace_release(void *start, unsigned long size); 102 103 extern void ftrace_disable_daemon(void); 104 extern void ftrace_enable_daemon(void); 105 106 #else 107 # define skip_trace(ip) ({ 0; }) 108 # define ftrace_force_update() ({ 0; }) 109 # define ftrace_set_filter(buf, len, reset) do { } while (0) 110 # define ftrace_disable_daemon() do { } while (0) 111 # define ftrace_enable_daemon() do { } while (0) 112 static inline void ftrace_release(void *start, unsigned long size) { } 113 #endif /* CONFIG_DYNAMIC_FTRACE */ 114 115 /* totally disable ftrace - can not re-enable after this */ 116 void ftrace_kill(void); 117 118 static inline void tracer_disable(void) 119 { 120 #ifdef CONFIG_FUNCTION_TRACER 121 ftrace_enabled = 0; 122 #endif 123 } 124 125 /* 126 * Ftrace disable/restore without lock. Some synchronization mechanism 127 * must be used to prevent ftrace_enabled to be changed between 128 * disable/restore. 129 */ 130 static inline int __ftrace_enabled_save(void) 131 { 132 #ifdef CONFIG_FUNCTION_TRACER 133 int saved_ftrace_enabled = ftrace_enabled; 134 ftrace_enabled = 0; 135 return saved_ftrace_enabled; 136 #else 137 return 0; 138 #endif 139 } 140 141 static inline void __ftrace_enabled_restore(int enabled) 142 { 143 #ifdef CONFIG_FUNCTION_TRACER 144 ftrace_enabled = enabled; 145 #endif 146 } 147 148 #ifdef CONFIG_FRAME_POINTER 149 /* TODO: need to fix this for ARM */ 150 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 151 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1)) 152 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2)) 153 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3)) 154 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4)) 155 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5)) 156 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6)) 157 #else 158 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 159 # define CALLER_ADDR1 0UL 160 # define CALLER_ADDR2 0UL 161 # define CALLER_ADDR3 0UL 162 # define CALLER_ADDR4 0UL 163 # define CALLER_ADDR5 0UL 164 # define CALLER_ADDR6 0UL 165 #endif 166 167 #ifdef CONFIG_IRQSOFF_TRACER 168 extern void time_hardirqs_on(unsigned long a0, unsigned long a1); 169 extern void time_hardirqs_off(unsigned long a0, unsigned long a1); 170 #else 171 # define time_hardirqs_on(a0, a1) do { } while (0) 172 # define time_hardirqs_off(a0, a1) do { } while (0) 173 #endif 174 175 #ifdef CONFIG_PREEMPT_TRACER 176 extern void trace_preempt_on(unsigned long a0, unsigned long a1); 177 extern void trace_preempt_off(unsigned long a0, unsigned long a1); 178 #else 179 # define trace_preempt_on(a0, a1) do { } while (0) 180 # define trace_preempt_off(a0, a1) do { } while (0) 181 #endif 182 183 #ifdef CONFIG_TRACING 184 extern void 185 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3); 186 187 /** 188 * ftrace_printk - printf formatting in the ftrace buffer 189 * @fmt: the printf format for printing 190 * 191 * Note: __ftrace_printk is an internal function for ftrace_printk and 192 * the @ip is passed in via the ftrace_printk macro. 193 * 194 * This function allows a kernel developer to debug fast path sections 195 * that printk is not appropriate for. By scattering in various 196 * printk like tracing in the code, a developer can quickly see 197 * where problems are occurring. 198 * 199 * This is intended as a debugging tool for the developer only. 200 * Please refrain from leaving ftrace_printks scattered around in 201 * your code. 202 */ 203 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt) 204 extern int 205 __ftrace_printk(unsigned long ip, const char *fmt, ...) 206 __attribute__ ((format (printf, 2, 3))); 207 extern void ftrace_dump(void); 208 #else 209 static inline void 210 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { } 211 static inline int 212 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 0))); 213 214 static inline int 215 ftrace_printk(const char *fmt, ...) 216 { 217 return 0; 218 } 219 static inline void ftrace_dump(void) { } 220 #endif 221 222 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 223 extern void ftrace_init(void); 224 extern void ftrace_init_module(unsigned long *start, unsigned long *end); 225 #else 226 static inline void ftrace_init(void) { } 227 static inline void 228 ftrace_init_module(unsigned long *start, unsigned long *end) { } 229 #endif 230 231 232 struct boot_trace { 233 pid_t caller; 234 char func[KSYM_NAME_LEN]; 235 int result; 236 unsigned long long duration; /* usecs */ 237 ktime_t calltime; 238 ktime_t rettime; 239 }; 240 241 #ifdef CONFIG_BOOT_TRACER 242 extern void trace_boot(struct boot_trace *it, initcall_t fn); 243 extern void start_boot_trace(void); 244 extern void stop_boot_trace(void); 245 #else 246 static inline void trace_boot(struct boot_trace *it, initcall_t fn) { } 247 static inline void start_boot_trace(void) { } 248 static inline void stop_boot_trace(void) { } 249 #endif 250 251 252 253 #endif /* _LINUX_FTRACE_H */ 254