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 #include <linux/bitops.h> 12 #include <linux/sched.h> 13 14 #ifdef CONFIG_FUNCTION_TRACER 15 16 extern int ftrace_enabled; 17 extern int 18 ftrace_enable_sysctl(struct ctl_table *table, int write, 19 struct file *filp, void __user *buffer, size_t *lenp, 20 loff_t *ppos); 21 22 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip); 23 24 struct ftrace_ops { 25 ftrace_func_t func; 26 struct ftrace_ops *next; 27 }; 28 29 extern int function_trace_stop; 30 31 /* 32 * Type of the current tracing. 33 */ 34 enum ftrace_tracing_type_t { 35 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */ 36 FTRACE_TYPE_RETURN, /* Hook the return of the function */ 37 }; 38 39 /* Current tracing type, default is FTRACE_TYPE_ENTER */ 40 extern enum ftrace_tracing_type_t ftrace_tracing_type; 41 42 /** 43 * ftrace_stop - stop function tracer. 44 * 45 * A quick way to stop the function tracer. Note this an on off switch, 46 * it is not something that is recursive like preempt_disable. 47 * This does not disable the calling of mcount, it only stops the 48 * calling of functions from mcount. 49 */ 50 static inline void ftrace_stop(void) 51 { 52 function_trace_stop = 1; 53 } 54 55 /** 56 * ftrace_start - start the function tracer. 57 * 58 * This function is the inverse of ftrace_stop. This does not enable 59 * the function tracing if the function tracer is disabled. This only 60 * sets the function tracer flag to continue calling the functions 61 * from mcount. 62 */ 63 static inline void ftrace_start(void) 64 { 65 function_trace_stop = 0; 66 } 67 68 /* 69 * The ftrace_ops must be a static and should also 70 * be read_mostly. These functions do modify read_mostly variables 71 * so use them sparely. Never free an ftrace_op or modify the 72 * next pointer after it has been registered. Even after unregistering 73 * it, the next pointer may still be used internally. 74 */ 75 int register_ftrace_function(struct ftrace_ops *ops); 76 int unregister_ftrace_function(struct ftrace_ops *ops); 77 void clear_ftrace_function(void); 78 79 extern void ftrace_stub(unsigned long a0, unsigned long a1); 80 81 #else /* !CONFIG_FUNCTION_TRACER */ 82 # define register_ftrace_function(ops) do { } while (0) 83 # define unregister_ftrace_function(ops) do { } while (0) 84 # define clear_ftrace_function(ops) do { } while (0) 85 static inline void ftrace_kill(void) { } 86 static inline void ftrace_stop(void) { } 87 static inline void ftrace_start(void) { } 88 #endif /* CONFIG_FUNCTION_TRACER */ 89 90 #ifdef CONFIG_STACK_TRACER 91 extern int stack_tracer_enabled; 92 int 93 stack_trace_sysctl(struct ctl_table *table, int write, 94 struct file *file, void __user *buffer, size_t *lenp, 95 loff_t *ppos); 96 #endif 97 98 #ifdef CONFIG_DYNAMIC_FTRACE 99 /* asm/ftrace.h must be defined for archs supporting dynamic ftrace */ 100 #include <asm/ftrace.h> 101 102 enum { 103 FTRACE_FL_FREE = (1 << 0), 104 FTRACE_FL_FAILED = (1 << 1), 105 FTRACE_FL_FILTER = (1 << 2), 106 FTRACE_FL_ENABLED = (1 << 3), 107 FTRACE_FL_NOTRACE = (1 << 4), 108 FTRACE_FL_CONVERTED = (1 << 5), 109 FTRACE_FL_FROZEN = (1 << 6), 110 }; 111 112 struct dyn_ftrace { 113 struct list_head list; 114 unsigned long ip; /* address of mcount call-site */ 115 unsigned long flags; 116 struct dyn_arch_ftrace arch; 117 }; 118 119 int ftrace_force_update(void); 120 void ftrace_set_filter(unsigned char *buf, int len, int reset); 121 122 /* defined in arch */ 123 extern int ftrace_ip_converted(unsigned long ip); 124 extern int ftrace_dyn_arch_init(void *data); 125 extern int ftrace_update_ftrace_func(ftrace_func_t func); 126 extern void ftrace_caller(void); 127 extern void ftrace_call(void); 128 extern void mcount_call(void); 129 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 130 extern void ftrace_graph_caller(void); 131 extern int ftrace_enable_ftrace_graph_caller(void); 132 extern int ftrace_disable_ftrace_graph_caller(void); 133 #else 134 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; } 135 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; } 136 #endif 137 138 /** 139 * ftrace_make_nop - convert code into top 140 * @mod: module structure if called by module load initialization 141 * @rec: the mcount call site record 142 * @addr: the address that the call site should be calling 143 * 144 * This is a very sensitive operation and great care needs 145 * to be taken by the arch. The operation should carefully 146 * read the location, check to see if what is read is indeed 147 * what we expect it to be, and then on success of the compare, 148 * it should write to the location. 149 * 150 * The code segment at @rec->ip should be a caller to @addr 151 * 152 * Return must be: 153 * 0 on success 154 * -EFAULT on error reading the location 155 * -EINVAL on a failed compare of the contents 156 * -EPERM on error writing to the location 157 * Any other value will be considered a failure. 158 */ 159 extern int ftrace_make_nop(struct module *mod, 160 struct dyn_ftrace *rec, unsigned long addr); 161 162 /** 163 * ftrace_make_call - convert a nop call site into a call to addr 164 * @rec: the mcount call site record 165 * @addr: the address that the call site should call 166 * 167 * This is a very sensitive operation and great care needs 168 * to be taken by the arch. The operation should carefully 169 * read the location, check to see if what is read is indeed 170 * what we expect it to be, and then on success of the compare, 171 * it should write to the location. 172 * 173 * The code segment at @rec->ip should be a nop 174 * 175 * Return must be: 176 * 0 on success 177 * -EFAULT on error reading the location 178 * -EINVAL on a failed compare of the contents 179 * -EPERM on error writing to the location 180 * Any other value will be considered a failure. 181 */ 182 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); 183 184 185 /* May be defined in arch */ 186 extern int ftrace_arch_read_dyn_info(char *buf, int size); 187 188 extern int skip_trace(unsigned long ip); 189 190 extern void ftrace_release(void *start, unsigned long size); 191 192 extern void ftrace_disable_daemon(void); 193 extern void ftrace_enable_daemon(void); 194 #else 195 # define skip_trace(ip) ({ 0; }) 196 # define ftrace_force_update() ({ 0; }) 197 # define ftrace_set_filter(buf, len, reset) do { } while (0) 198 # define ftrace_disable_daemon() do { } while (0) 199 # define ftrace_enable_daemon() do { } while (0) 200 static inline void ftrace_release(void *start, unsigned long size) { } 201 #endif /* CONFIG_DYNAMIC_FTRACE */ 202 203 /* totally disable ftrace - can not re-enable after this */ 204 void ftrace_kill(void); 205 206 static inline void tracer_disable(void) 207 { 208 #ifdef CONFIG_FUNCTION_TRACER 209 ftrace_enabled = 0; 210 #endif 211 } 212 213 /* 214 * Ftrace disable/restore without lock. Some synchronization mechanism 215 * must be used to prevent ftrace_enabled to be changed between 216 * disable/restore. 217 */ 218 static inline int __ftrace_enabled_save(void) 219 { 220 #ifdef CONFIG_FUNCTION_TRACER 221 int saved_ftrace_enabled = ftrace_enabled; 222 ftrace_enabled = 0; 223 return saved_ftrace_enabled; 224 #else 225 return 0; 226 #endif 227 } 228 229 static inline void __ftrace_enabled_restore(int enabled) 230 { 231 #ifdef CONFIG_FUNCTION_TRACER 232 ftrace_enabled = enabled; 233 #endif 234 } 235 236 #ifdef CONFIG_FRAME_POINTER 237 /* TODO: need to fix this for ARM */ 238 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 239 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1)) 240 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2)) 241 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3)) 242 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4)) 243 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5)) 244 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6)) 245 #else 246 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 247 # define CALLER_ADDR1 0UL 248 # define CALLER_ADDR2 0UL 249 # define CALLER_ADDR3 0UL 250 # define CALLER_ADDR4 0UL 251 # define CALLER_ADDR5 0UL 252 # define CALLER_ADDR6 0UL 253 #endif 254 255 #ifdef CONFIG_IRQSOFF_TRACER 256 extern void time_hardirqs_on(unsigned long a0, unsigned long a1); 257 extern void time_hardirqs_off(unsigned long a0, unsigned long a1); 258 #else 259 # define time_hardirqs_on(a0, a1) do { } while (0) 260 # define time_hardirqs_off(a0, a1) do { } while (0) 261 #endif 262 263 #ifdef CONFIG_PREEMPT_TRACER 264 extern void trace_preempt_on(unsigned long a0, unsigned long a1); 265 extern void trace_preempt_off(unsigned long a0, unsigned long a1); 266 #else 267 # define trace_preempt_on(a0, a1) do { } while (0) 268 # define trace_preempt_off(a0, a1) do { } while (0) 269 #endif 270 271 #ifdef CONFIG_TRACING 272 extern int ftrace_dump_on_oops; 273 274 extern void tracing_start(void); 275 extern void tracing_stop(void); 276 extern void ftrace_off_permanent(void); 277 278 extern void 279 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3); 280 281 /** 282 * ftrace_printk - printf formatting in the ftrace buffer 283 * @fmt: the printf format for printing 284 * 285 * Note: __ftrace_printk is an internal function for ftrace_printk and 286 * the @ip is passed in via the ftrace_printk macro. 287 * 288 * This function allows a kernel developer to debug fast path sections 289 * that printk is not appropriate for. By scattering in various 290 * printk like tracing in the code, a developer can quickly see 291 * where problems are occurring. 292 * 293 * This is intended as a debugging tool for the developer only. 294 * Please refrain from leaving ftrace_printks scattered around in 295 * your code. 296 */ 297 # define ftrace_printk(fmt...) __ftrace_printk(_THIS_IP_, fmt) 298 extern int 299 __ftrace_printk(unsigned long ip, const char *fmt, ...) 300 __attribute__ ((format (printf, 2, 3))); 301 extern void ftrace_dump(void); 302 #else 303 static inline void 304 ftrace_special(unsigned long arg1, unsigned long arg2, unsigned long arg3) { } 305 static inline int 306 ftrace_printk(const char *fmt, ...) __attribute__ ((format (printf, 1, 2))); 307 308 static inline void tracing_start(void) { } 309 static inline void tracing_stop(void) { } 310 static inline void ftrace_off_permanent(void) { } 311 static inline int 312 ftrace_printk(const char *fmt, ...) 313 { 314 return 0; 315 } 316 static inline void ftrace_dump(void) { } 317 #endif 318 319 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 320 extern void ftrace_init(void); 321 extern void ftrace_init_module(struct module *mod, 322 unsigned long *start, unsigned long *end); 323 #else 324 static inline void ftrace_init(void) { } 325 static inline void 326 ftrace_init_module(struct module *mod, 327 unsigned long *start, unsigned long *end) { } 328 #endif 329 330 enum { 331 POWER_NONE = 0, 332 POWER_CSTATE = 1, 333 POWER_PSTATE = 2, 334 }; 335 336 struct power_trace { 337 #ifdef CONFIG_POWER_TRACER 338 ktime_t stamp; 339 ktime_t end; 340 int type; 341 int state; 342 #endif 343 }; 344 345 #ifdef CONFIG_POWER_TRACER 346 extern void trace_power_start(struct power_trace *it, unsigned int type, 347 unsigned int state); 348 extern void trace_power_mark(struct power_trace *it, unsigned int type, 349 unsigned int state); 350 extern void trace_power_end(struct power_trace *it); 351 #else 352 static inline void trace_power_start(struct power_trace *it, unsigned int type, 353 unsigned int state) { } 354 static inline void trace_power_mark(struct power_trace *it, unsigned int type, 355 unsigned int state) { } 356 static inline void trace_power_end(struct power_trace *it) { } 357 #endif 358 359 360 /* 361 * Structure that defines an entry function trace. 362 */ 363 struct ftrace_graph_ent { 364 unsigned long func; /* Current function */ 365 int depth; 366 }; 367 368 /* 369 * Structure that defines a return function trace. 370 */ 371 struct ftrace_graph_ret { 372 unsigned long func; /* Current function */ 373 unsigned long long calltime; 374 unsigned long long rettime; 375 /* Number of functions that overran the depth limit for current task */ 376 unsigned long overrun; 377 int depth; 378 }; 379 380 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 381 382 /* 383 * Sometimes we don't want to trace a function with the function 384 * graph tracer but we want them to keep traced by the usual function 385 * tracer if the function graph tracer is not configured. 386 */ 387 #define __notrace_funcgraph notrace 388 389 /* 390 * We want to which function is an entrypoint of a hardirq. 391 * That will help us to put a signal on output. 392 */ 393 #define __irq_entry __attribute__((__section__(".irqentry.text"))) 394 395 /* Limits of hardirq entrypoints */ 396 extern char __irqentry_text_start[]; 397 extern char __irqentry_text_end[]; 398 399 #define FTRACE_RETFUNC_DEPTH 50 400 #define FTRACE_RETSTACK_ALLOC_SIZE 32 401 /* Type of the callback handlers for tracing function graph*/ 402 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */ 403 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */ 404 405 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc, 406 trace_func_graph_ent_t entryfunc); 407 408 extern void ftrace_graph_stop(void); 409 410 /* The current handlers in use */ 411 extern trace_func_graph_ret_t ftrace_graph_return; 412 extern trace_func_graph_ent_t ftrace_graph_entry; 413 414 extern void unregister_ftrace_graph(void); 415 416 extern void ftrace_graph_init_task(struct task_struct *t); 417 extern void ftrace_graph_exit_task(struct task_struct *t); 418 419 static inline int task_curr_ret_stack(struct task_struct *t) 420 { 421 return t->curr_ret_stack; 422 } 423 424 static inline void pause_graph_tracing(void) 425 { 426 atomic_inc(¤t->tracing_graph_pause); 427 } 428 429 static inline void unpause_graph_tracing(void) 430 { 431 atomic_dec(¤t->tracing_graph_pause); 432 } 433 #else 434 435 #define __notrace_funcgraph 436 #define __irq_entry 437 438 static inline void ftrace_graph_init_task(struct task_struct *t) { } 439 static inline void ftrace_graph_exit_task(struct task_struct *t) { } 440 441 static inline int task_curr_ret_stack(struct task_struct *tsk) 442 { 443 return -1; 444 } 445 446 static inline void pause_graph_tracing(void) { } 447 static inline void unpause_graph_tracing(void) { } 448 #endif 449 450 #ifdef CONFIG_TRACING 451 #include <linux/sched.h> 452 453 /* flags for current->trace */ 454 enum { 455 TSK_TRACE_FL_TRACE_BIT = 0, 456 TSK_TRACE_FL_GRAPH_BIT = 1, 457 }; 458 enum { 459 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT, 460 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT, 461 }; 462 463 static inline void set_tsk_trace_trace(struct task_struct *tsk) 464 { 465 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 466 } 467 468 static inline void clear_tsk_trace_trace(struct task_struct *tsk) 469 { 470 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 471 } 472 473 static inline int test_tsk_trace_trace(struct task_struct *tsk) 474 { 475 return tsk->trace & TSK_TRACE_FL_TRACE; 476 } 477 478 static inline void set_tsk_trace_graph(struct task_struct *tsk) 479 { 480 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 481 } 482 483 static inline void clear_tsk_trace_graph(struct task_struct *tsk) 484 { 485 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 486 } 487 488 static inline int test_tsk_trace_graph(struct task_struct *tsk) 489 { 490 return tsk->trace & TSK_TRACE_FL_GRAPH; 491 } 492 493 #endif /* CONFIG_TRACING */ 494 495 #endif /* _LINUX_FTRACE_H */ 496