1 /* 2 * Ftrace header. For implementation details beyond the random comments 3 * scattered below, see: Documentation/trace/ftrace-design.txt 4 */ 5 6 #ifndef _LINUX_FTRACE_H 7 #define _LINUX_FTRACE_H 8 9 #include <linux/trace_clock.h> 10 #include <linux/kallsyms.h> 11 #include <linux/linkage.h> 12 #include <linux/bitops.h> 13 #include <linux/ktime.h> 14 #include <linux/sched.h> 15 #include <linux/types.h> 16 #include <linux/init.h> 17 #include <linux/fs.h> 18 19 #include <asm/ftrace.h> 20 21 struct module; 22 struct ftrace_hash; 23 24 #ifdef CONFIG_FUNCTION_TRACER 25 26 extern int ftrace_enabled; 27 extern int 28 ftrace_enable_sysctl(struct ctl_table *table, int write, 29 void __user *buffer, size_t *lenp, 30 loff_t *ppos); 31 32 typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip); 33 34 enum { 35 FTRACE_OPS_FL_ENABLED = 1 << 0, 36 FTRACE_OPS_FL_GLOBAL = 1 << 1, 37 FTRACE_OPS_FL_DYNAMIC = 1 << 2, 38 }; 39 40 struct ftrace_ops { 41 ftrace_func_t func; 42 struct ftrace_ops *next; 43 unsigned long flags; 44 #ifdef CONFIG_DYNAMIC_FTRACE 45 struct ftrace_hash *notrace_hash; 46 struct ftrace_hash *filter_hash; 47 #endif 48 }; 49 50 extern int function_trace_stop; 51 52 /* 53 * Type of the current tracing. 54 */ 55 enum ftrace_tracing_type_t { 56 FTRACE_TYPE_ENTER = 0, /* Hook the call of the function */ 57 FTRACE_TYPE_RETURN, /* Hook the return of the function */ 58 }; 59 60 /* Current tracing type, default is FTRACE_TYPE_ENTER */ 61 extern enum ftrace_tracing_type_t ftrace_tracing_type; 62 63 /** 64 * ftrace_stop - stop function tracer. 65 * 66 * A quick way to stop the function tracer. Note this an on off switch, 67 * it is not something that is recursive like preempt_disable. 68 * This does not disable the calling of mcount, it only stops the 69 * calling of functions from mcount. 70 */ 71 static inline void ftrace_stop(void) 72 { 73 function_trace_stop = 1; 74 } 75 76 /** 77 * ftrace_start - start the function tracer. 78 * 79 * This function is the inverse of ftrace_stop. This does not enable 80 * the function tracing if the function tracer is disabled. This only 81 * sets the function tracer flag to continue calling the functions 82 * from mcount. 83 */ 84 static inline void ftrace_start(void) 85 { 86 function_trace_stop = 0; 87 } 88 89 /* 90 * The ftrace_ops must be a static and should also 91 * be read_mostly. These functions do modify read_mostly variables 92 * so use them sparely. Never free an ftrace_op or modify the 93 * next pointer after it has been registered. Even after unregistering 94 * it, the next pointer may still be used internally. 95 */ 96 int register_ftrace_function(struct ftrace_ops *ops); 97 int unregister_ftrace_function(struct ftrace_ops *ops); 98 void clear_ftrace_function(void); 99 100 extern void ftrace_stub(unsigned long a0, unsigned long a1); 101 102 #else /* !CONFIG_FUNCTION_TRACER */ 103 /* 104 * (un)register_ftrace_function must be a macro since the ops parameter 105 * must not be evaluated. 106 */ 107 #define register_ftrace_function(ops) ({ 0; }) 108 #define unregister_ftrace_function(ops) ({ 0; }) 109 static inline void clear_ftrace_function(void) { } 110 static inline void ftrace_kill(void) { } 111 static inline void ftrace_stop(void) { } 112 static inline void ftrace_start(void) { } 113 #endif /* CONFIG_FUNCTION_TRACER */ 114 115 #ifdef CONFIG_STACK_TRACER 116 extern int stack_tracer_enabled; 117 int 118 stack_trace_sysctl(struct ctl_table *table, int write, 119 void __user *buffer, size_t *lenp, 120 loff_t *ppos); 121 #endif 122 123 struct ftrace_func_command { 124 struct list_head list; 125 char *name; 126 int (*func)(struct ftrace_hash *hash, 127 char *func, char *cmd, 128 char *params, int enable); 129 }; 130 131 #ifdef CONFIG_DYNAMIC_FTRACE 132 133 int ftrace_arch_code_modify_prepare(void); 134 int ftrace_arch_code_modify_post_process(void); 135 136 void ftrace_bug(int err, unsigned long ip); 137 138 struct seq_file; 139 140 struct ftrace_probe_ops { 141 void (*func)(unsigned long ip, 142 unsigned long parent_ip, 143 void **data); 144 int (*callback)(unsigned long ip, void **data); 145 void (*free)(void **data); 146 int (*print)(struct seq_file *m, 147 unsigned long ip, 148 struct ftrace_probe_ops *ops, 149 void *data); 150 }; 151 152 extern int 153 register_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 154 void *data); 155 extern void 156 unregister_ftrace_function_probe(char *glob, struct ftrace_probe_ops *ops, 157 void *data); 158 extern void 159 unregister_ftrace_function_probe_func(char *glob, struct ftrace_probe_ops *ops); 160 extern void unregister_ftrace_function_probe_all(char *glob); 161 162 extern int ftrace_text_reserved(void *start, void *end); 163 164 enum { 165 FTRACE_FL_ENABLED = (1 << 30), 166 }; 167 168 #define FTRACE_FL_MASK (0x3UL << 30) 169 #define FTRACE_REF_MAX ((1 << 30) - 1) 170 171 struct dyn_ftrace { 172 union { 173 unsigned long ip; /* address of mcount call-site */ 174 struct dyn_ftrace *freelist; 175 }; 176 unsigned long flags; 177 struct dyn_arch_ftrace arch; 178 }; 179 180 int ftrace_force_update(void); 181 void ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf, 182 int len, int reset); 183 void ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf, 184 int len, int reset); 185 void ftrace_set_global_filter(unsigned char *buf, int len, int reset); 186 void ftrace_set_global_notrace(unsigned char *buf, int len, int reset); 187 188 int register_ftrace_command(struct ftrace_func_command *cmd); 189 int unregister_ftrace_command(struct ftrace_func_command *cmd); 190 191 enum { 192 FTRACE_UPDATE_CALLS = (1 << 0), 193 FTRACE_DISABLE_CALLS = (1 << 1), 194 FTRACE_UPDATE_TRACE_FUNC = (1 << 2), 195 FTRACE_START_FUNC_RET = (1 << 3), 196 FTRACE_STOP_FUNC_RET = (1 << 4), 197 }; 198 199 enum { 200 FTRACE_UPDATE_IGNORE, 201 FTRACE_UPDATE_MAKE_CALL, 202 FTRACE_UPDATE_MAKE_NOP, 203 }; 204 205 enum { 206 FTRACE_ITER_FILTER = (1 << 0), 207 FTRACE_ITER_NOTRACE = (1 << 1), 208 FTRACE_ITER_PRINTALL = (1 << 2), 209 FTRACE_ITER_DO_HASH = (1 << 3), 210 FTRACE_ITER_HASH = (1 << 4), 211 FTRACE_ITER_ENABLED = (1 << 5), 212 }; 213 214 void arch_ftrace_update_code(int command); 215 216 struct ftrace_rec_iter; 217 218 struct ftrace_rec_iter *ftrace_rec_iter_start(void); 219 struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter); 220 struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter); 221 222 int ftrace_update_record(struct dyn_ftrace *rec, int enable); 223 int ftrace_test_record(struct dyn_ftrace *rec, int enable); 224 void ftrace_run_stop_machine(int command); 225 int ftrace_location(unsigned long ip); 226 227 extern ftrace_func_t ftrace_trace_function; 228 229 int ftrace_regex_open(struct ftrace_ops *ops, int flag, 230 struct inode *inode, struct file *file); 231 ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf, 232 size_t cnt, loff_t *ppos); 233 ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf, 234 size_t cnt, loff_t *ppos); 235 loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin); 236 int ftrace_regex_release(struct inode *inode, struct file *file); 237 238 void __init 239 ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable); 240 241 /* defined in arch */ 242 extern int ftrace_ip_converted(unsigned long ip); 243 extern int ftrace_dyn_arch_init(void *data); 244 extern int ftrace_update_ftrace_func(ftrace_func_t func); 245 extern void ftrace_caller(void); 246 extern void ftrace_call(void); 247 extern void mcount_call(void); 248 249 #ifndef FTRACE_ADDR 250 #define FTRACE_ADDR ((unsigned long)ftrace_caller) 251 #endif 252 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 253 extern void ftrace_graph_caller(void); 254 extern int ftrace_enable_ftrace_graph_caller(void); 255 extern int ftrace_disable_ftrace_graph_caller(void); 256 #else 257 static inline int ftrace_enable_ftrace_graph_caller(void) { return 0; } 258 static inline int ftrace_disable_ftrace_graph_caller(void) { return 0; } 259 #endif 260 261 /** 262 * ftrace_make_nop - convert code into nop 263 * @mod: module structure if called by module load initialization 264 * @rec: the mcount call site record 265 * @addr: the address that the call site should be calling 266 * 267 * This is a very sensitive operation and great care needs 268 * to be taken by the arch. The operation should carefully 269 * read the location, check to see if what is read is indeed 270 * what we expect it to be, and then on success of the compare, 271 * it should write to the location. 272 * 273 * The code segment at @rec->ip should be a caller to @addr 274 * 275 * Return must be: 276 * 0 on success 277 * -EFAULT on error reading the location 278 * -EINVAL on a failed compare of the contents 279 * -EPERM on error writing to the location 280 * Any other value will be considered a failure. 281 */ 282 extern int ftrace_make_nop(struct module *mod, 283 struct dyn_ftrace *rec, unsigned long addr); 284 285 /** 286 * ftrace_make_call - convert a nop call site into a call to addr 287 * @rec: the mcount call site record 288 * @addr: the address that the call site should call 289 * 290 * This is a very sensitive operation and great care needs 291 * to be taken by the arch. The operation should carefully 292 * read the location, check to see if what is read is indeed 293 * what we expect it to be, and then on success of the compare, 294 * it should write to the location. 295 * 296 * The code segment at @rec->ip should be a nop 297 * 298 * Return must be: 299 * 0 on success 300 * -EFAULT on error reading the location 301 * -EINVAL on a failed compare of the contents 302 * -EPERM on error writing to the location 303 * Any other value will be considered a failure. 304 */ 305 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr); 306 307 /* May be defined in arch */ 308 extern int ftrace_arch_read_dyn_info(char *buf, int size); 309 310 extern int skip_trace(unsigned long ip); 311 312 extern void ftrace_disable_daemon(void); 313 extern void ftrace_enable_daemon(void); 314 #else 315 static inline int skip_trace(unsigned long ip) { return 0; } 316 static inline int ftrace_force_update(void) { return 0; } 317 static inline void ftrace_set_filter(unsigned char *buf, int len, int reset) 318 { 319 } 320 static inline void ftrace_disable_daemon(void) { } 321 static inline void ftrace_enable_daemon(void) { } 322 static inline void ftrace_release_mod(struct module *mod) {} 323 static inline int register_ftrace_command(struct ftrace_func_command *cmd) 324 { 325 return -EINVAL; 326 } 327 static inline int unregister_ftrace_command(char *cmd_name) 328 { 329 return -EINVAL; 330 } 331 static inline int ftrace_text_reserved(void *start, void *end) 332 { 333 return 0; 334 } 335 336 /* 337 * Again users of functions that have ftrace_ops may not 338 * have them defined when ftrace is not enabled, but these 339 * functions may still be called. Use a macro instead of inline. 340 */ 341 #define ftrace_regex_open(ops, flag, inod, file) ({ -ENODEV; }) 342 #define ftrace_set_early_filter(ops, buf, enable) do { } while (0) 343 344 static inline ssize_t ftrace_filter_write(struct file *file, const char __user *ubuf, 345 size_t cnt, loff_t *ppos) { return -ENODEV; } 346 static inline ssize_t ftrace_notrace_write(struct file *file, const char __user *ubuf, 347 size_t cnt, loff_t *ppos) { return -ENODEV; } 348 static inline loff_t ftrace_regex_lseek(struct file *file, loff_t offset, int origin) 349 { 350 return -ENODEV; 351 } 352 static inline int 353 ftrace_regex_release(struct inode *inode, struct file *file) { return -ENODEV; } 354 #endif /* CONFIG_DYNAMIC_FTRACE */ 355 356 /* totally disable ftrace - can not re-enable after this */ 357 void ftrace_kill(void); 358 359 static inline void tracer_disable(void) 360 { 361 #ifdef CONFIG_FUNCTION_TRACER 362 ftrace_enabled = 0; 363 #endif 364 } 365 366 /* 367 * Ftrace disable/restore without lock. Some synchronization mechanism 368 * must be used to prevent ftrace_enabled to be changed between 369 * disable/restore. 370 */ 371 static inline int __ftrace_enabled_save(void) 372 { 373 #ifdef CONFIG_FUNCTION_TRACER 374 int saved_ftrace_enabled = ftrace_enabled; 375 ftrace_enabled = 0; 376 return saved_ftrace_enabled; 377 #else 378 return 0; 379 #endif 380 } 381 382 static inline void __ftrace_enabled_restore(int enabled) 383 { 384 #ifdef CONFIG_FUNCTION_TRACER 385 ftrace_enabled = enabled; 386 #endif 387 } 388 389 #ifndef HAVE_ARCH_CALLER_ADDR 390 # ifdef CONFIG_FRAME_POINTER 391 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 392 # define CALLER_ADDR1 ((unsigned long)__builtin_return_address(1)) 393 # define CALLER_ADDR2 ((unsigned long)__builtin_return_address(2)) 394 # define CALLER_ADDR3 ((unsigned long)__builtin_return_address(3)) 395 # define CALLER_ADDR4 ((unsigned long)__builtin_return_address(4)) 396 # define CALLER_ADDR5 ((unsigned long)__builtin_return_address(5)) 397 # define CALLER_ADDR6 ((unsigned long)__builtin_return_address(6)) 398 # else 399 # define CALLER_ADDR0 ((unsigned long)__builtin_return_address(0)) 400 # define CALLER_ADDR1 0UL 401 # define CALLER_ADDR2 0UL 402 # define CALLER_ADDR3 0UL 403 # define CALLER_ADDR4 0UL 404 # define CALLER_ADDR5 0UL 405 # define CALLER_ADDR6 0UL 406 # endif 407 #endif /* ifndef HAVE_ARCH_CALLER_ADDR */ 408 409 #ifdef CONFIG_IRQSOFF_TRACER 410 extern void time_hardirqs_on(unsigned long a0, unsigned long a1); 411 extern void time_hardirqs_off(unsigned long a0, unsigned long a1); 412 #else 413 static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { } 414 static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { } 415 #endif 416 417 #ifdef CONFIG_PREEMPT_TRACER 418 extern void trace_preempt_on(unsigned long a0, unsigned long a1); 419 extern void trace_preempt_off(unsigned long a0, unsigned long a1); 420 #else 421 static inline void trace_preempt_on(unsigned long a0, unsigned long a1) { } 422 static inline void trace_preempt_off(unsigned long a0, unsigned long a1) { } 423 #endif 424 425 #ifdef CONFIG_FTRACE_MCOUNT_RECORD 426 extern void ftrace_init(void); 427 #else 428 static inline void ftrace_init(void) { } 429 #endif 430 431 /* 432 * Structure that defines an entry function trace. 433 */ 434 struct ftrace_graph_ent { 435 unsigned long func; /* Current function */ 436 int depth; 437 }; 438 439 /* 440 * Structure that defines a return function trace. 441 */ 442 struct ftrace_graph_ret { 443 unsigned long func; /* Current function */ 444 unsigned long long calltime; 445 unsigned long long rettime; 446 /* Number of functions that overran the depth limit for current task */ 447 unsigned long overrun; 448 int depth; 449 }; 450 451 /* Type of the callback handlers for tracing function graph*/ 452 typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *); /* return */ 453 typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *); /* entry */ 454 455 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 456 457 /* for init task */ 458 #define INIT_FTRACE_GRAPH .ret_stack = NULL, 459 460 /* 461 * Stack of return addresses for functions 462 * of a thread. 463 * Used in struct thread_info 464 */ 465 struct ftrace_ret_stack { 466 unsigned long ret; 467 unsigned long func; 468 unsigned long long calltime; 469 unsigned long long subtime; 470 unsigned long fp; 471 }; 472 473 /* 474 * Primary handler of a function return. 475 * It relays on ftrace_return_to_handler. 476 * Defined in entry_32/64.S 477 */ 478 extern void return_to_handler(void); 479 480 extern int 481 ftrace_push_return_trace(unsigned long ret, unsigned long func, int *depth, 482 unsigned long frame_pointer); 483 484 /* 485 * Sometimes we don't want to trace a function with the function 486 * graph tracer but we want them to keep traced by the usual function 487 * tracer if the function graph tracer is not configured. 488 */ 489 #define __notrace_funcgraph notrace 490 491 /* 492 * We want to which function is an entrypoint of a hardirq. 493 * That will help us to put a signal on output. 494 */ 495 #define __irq_entry __attribute__((__section__(".irqentry.text"))) 496 497 /* Limits of hardirq entrypoints */ 498 extern char __irqentry_text_start[]; 499 extern char __irqentry_text_end[]; 500 501 #define FTRACE_RETFUNC_DEPTH 50 502 #define FTRACE_RETSTACK_ALLOC_SIZE 32 503 extern int register_ftrace_graph(trace_func_graph_ret_t retfunc, 504 trace_func_graph_ent_t entryfunc); 505 506 extern void ftrace_graph_stop(void); 507 508 /* The current handlers in use */ 509 extern trace_func_graph_ret_t ftrace_graph_return; 510 extern trace_func_graph_ent_t ftrace_graph_entry; 511 512 extern void unregister_ftrace_graph(void); 513 514 extern void ftrace_graph_init_task(struct task_struct *t); 515 extern void ftrace_graph_exit_task(struct task_struct *t); 516 extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu); 517 518 static inline int task_curr_ret_stack(struct task_struct *t) 519 { 520 return t->curr_ret_stack; 521 } 522 523 static inline void pause_graph_tracing(void) 524 { 525 atomic_inc(¤t->tracing_graph_pause); 526 } 527 528 static inline void unpause_graph_tracing(void) 529 { 530 atomic_dec(¤t->tracing_graph_pause); 531 } 532 #else /* !CONFIG_FUNCTION_GRAPH_TRACER */ 533 534 #define __notrace_funcgraph 535 #define __irq_entry 536 #define INIT_FTRACE_GRAPH 537 538 static inline void ftrace_graph_init_task(struct task_struct *t) { } 539 static inline void ftrace_graph_exit_task(struct task_struct *t) { } 540 static inline void ftrace_graph_init_idle_task(struct task_struct *t, int cpu) { } 541 542 static inline int register_ftrace_graph(trace_func_graph_ret_t retfunc, 543 trace_func_graph_ent_t entryfunc) 544 { 545 return -1; 546 } 547 static inline void unregister_ftrace_graph(void) { } 548 549 static inline int task_curr_ret_stack(struct task_struct *tsk) 550 { 551 return -1; 552 } 553 554 static inline void pause_graph_tracing(void) { } 555 static inline void unpause_graph_tracing(void) { } 556 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 557 558 #ifdef CONFIG_TRACING 559 560 /* flags for current->trace */ 561 enum { 562 TSK_TRACE_FL_TRACE_BIT = 0, 563 TSK_TRACE_FL_GRAPH_BIT = 1, 564 }; 565 enum { 566 TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT, 567 TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT, 568 }; 569 570 static inline void set_tsk_trace_trace(struct task_struct *tsk) 571 { 572 set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 573 } 574 575 static inline void clear_tsk_trace_trace(struct task_struct *tsk) 576 { 577 clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace); 578 } 579 580 static inline int test_tsk_trace_trace(struct task_struct *tsk) 581 { 582 return tsk->trace & TSK_TRACE_FL_TRACE; 583 } 584 585 static inline void set_tsk_trace_graph(struct task_struct *tsk) 586 { 587 set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 588 } 589 590 static inline void clear_tsk_trace_graph(struct task_struct *tsk) 591 { 592 clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace); 593 } 594 595 static inline int test_tsk_trace_graph(struct task_struct *tsk) 596 { 597 return tsk->trace & TSK_TRACE_FL_GRAPH; 598 } 599 600 enum ftrace_dump_mode; 601 602 extern enum ftrace_dump_mode ftrace_dump_on_oops; 603 604 #ifdef CONFIG_PREEMPT 605 #define INIT_TRACE_RECURSION .trace_recursion = 0, 606 #endif 607 608 #endif /* CONFIG_TRACING */ 609 610 #ifndef INIT_TRACE_RECURSION 611 #define INIT_TRACE_RECURSION 612 #endif 613 614 #ifdef CONFIG_FTRACE_SYSCALLS 615 616 unsigned long arch_syscall_addr(int nr); 617 618 #endif /* CONFIG_FTRACE_SYSCALLS */ 619 620 #endif /* _LINUX_FTRACE_H */ 621