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