1 #ifndef _LINUX_KERNEL_TRACE_H 2 #define _LINUX_KERNEL_TRACE_H 3 4 #include <linux/fs.h> 5 #include <asm/atomic.h> 6 #include <linux/sched.h> 7 #include <linux/clocksource.h> 8 #include <linux/ring_buffer.h> 9 #include <linux/mmiotrace.h> 10 #include <linux/ftrace.h> 11 #include <trace/boot.h> 12 #include <trace/kmemtrace.h> 13 #include <trace/power.h> 14 15 enum trace_type { 16 __TRACE_FIRST_TYPE = 0, 17 18 TRACE_FN, 19 TRACE_CTX, 20 TRACE_WAKE, 21 TRACE_STACK, 22 TRACE_PRINT, 23 TRACE_BPRINT, 24 TRACE_SPECIAL, 25 TRACE_MMIO_RW, 26 TRACE_MMIO_MAP, 27 TRACE_BRANCH, 28 TRACE_BOOT_CALL, 29 TRACE_BOOT_RET, 30 TRACE_GRAPH_RET, 31 TRACE_GRAPH_ENT, 32 TRACE_USER_STACK, 33 TRACE_HW_BRANCHES, 34 TRACE_SYSCALL_ENTER, 35 TRACE_SYSCALL_EXIT, 36 TRACE_KMEM_ALLOC, 37 TRACE_KMEM_FREE, 38 TRACE_POWER, 39 TRACE_BLK, 40 41 __TRACE_LAST_TYPE, 42 }; 43 44 /* 45 * The trace entry - the most basic unit of tracing. This is what 46 * is printed in the end as a single line in the trace output, such as: 47 * 48 * bash-15816 [01] 235.197585: idle_cpu <- irq_enter 49 */ 50 struct trace_entry { 51 unsigned char type; 52 unsigned char flags; 53 unsigned char preempt_count; 54 int pid; 55 int tgid; 56 }; 57 58 /* 59 * Function trace entry - function address and parent function addres: 60 */ 61 struct ftrace_entry { 62 struct trace_entry ent; 63 unsigned long ip; 64 unsigned long parent_ip; 65 }; 66 67 /* Function call entry */ 68 struct ftrace_graph_ent_entry { 69 struct trace_entry ent; 70 struct ftrace_graph_ent graph_ent; 71 }; 72 73 /* Function return entry */ 74 struct ftrace_graph_ret_entry { 75 struct trace_entry ent; 76 struct ftrace_graph_ret ret; 77 }; 78 extern struct tracer boot_tracer; 79 80 /* 81 * Context switch trace entry - which task (and prio) we switched from/to: 82 */ 83 struct ctx_switch_entry { 84 struct trace_entry ent; 85 unsigned int prev_pid; 86 unsigned char prev_prio; 87 unsigned char prev_state; 88 unsigned int next_pid; 89 unsigned char next_prio; 90 unsigned char next_state; 91 unsigned int next_cpu; 92 }; 93 94 /* 95 * Special (free-form) trace entry: 96 */ 97 struct special_entry { 98 struct trace_entry ent; 99 unsigned long arg1; 100 unsigned long arg2; 101 unsigned long arg3; 102 }; 103 104 /* 105 * Stack-trace entry: 106 */ 107 108 #define FTRACE_STACK_ENTRIES 8 109 110 struct stack_entry { 111 struct trace_entry ent; 112 unsigned long caller[FTRACE_STACK_ENTRIES]; 113 }; 114 115 struct userstack_entry { 116 struct trace_entry ent; 117 unsigned long caller[FTRACE_STACK_ENTRIES]; 118 }; 119 120 /* 121 * trace_printk entry: 122 */ 123 struct bprint_entry { 124 struct trace_entry ent; 125 unsigned long ip; 126 const char *fmt; 127 u32 buf[]; 128 }; 129 130 struct print_entry { 131 struct trace_entry ent; 132 unsigned long ip; 133 char buf[]; 134 }; 135 136 #define TRACE_OLD_SIZE 88 137 138 struct trace_field_cont { 139 unsigned char type; 140 /* Temporary till we get rid of this completely */ 141 char buf[TRACE_OLD_SIZE - 1]; 142 }; 143 144 struct trace_mmiotrace_rw { 145 struct trace_entry ent; 146 struct mmiotrace_rw rw; 147 }; 148 149 struct trace_mmiotrace_map { 150 struct trace_entry ent; 151 struct mmiotrace_map map; 152 }; 153 154 struct trace_boot_call { 155 struct trace_entry ent; 156 struct boot_trace_call boot_call; 157 }; 158 159 struct trace_boot_ret { 160 struct trace_entry ent; 161 struct boot_trace_ret boot_ret; 162 }; 163 164 #define TRACE_FUNC_SIZE 30 165 #define TRACE_FILE_SIZE 20 166 struct trace_branch { 167 struct trace_entry ent; 168 unsigned line; 169 char func[TRACE_FUNC_SIZE+1]; 170 char file[TRACE_FILE_SIZE+1]; 171 char correct; 172 }; 173 174 struct hw_branch_entry { 175 struct trace_entry ent; 176 u64 from; 177 u64 to; 178 }; 179 180 struct trace_power { 181 struct trace_entry ent; 182 struct power_trace state_data; 183 }; 184 185 struct kmemtrace_alloc_entry { 186 struct trace_entry ent; 187 enum kmemtrace_type_id type_id; 188 unsigned long call_site; 189 const void *ptr; 190 size_t bytes_req; 191 size_t bytes_alloc; 192 gfp_t gfp_flags; 193 int node; 194 }; 195 196 struct kmemtrace_free_entry { 197 struct trace_entry ent; 198 enum kmemtrace_type_id type_id; 199 unsigned long call_site; 200 const void *ptr; 201 }; 202 203 struct syscall_trace_enter { 204 struct trace_entry ent; 205 int nr; 206 unsigned long args[]; 207 }; 208 209 struct syscall_trace_exit { 210 struct trace_entry ent; 211 int nr; 212 unsigned long ret; 213 }; 214 215 216 /* 217 * trace_flag_type is an enumeration that holds different 218 * states when a trace occurs. These are: 219 * IRQS_OFF - interrupts were disabled 220 * IRQS_NOSUPPORT - arch does not support irqs_disabled_flags 221 * NEED_RESCED - reschedule is requested 222 * HARDIRQ - inside an interrupt handler 223 * SOFTIRQ - inside a softirq handler 224 */ 225 enum trace_flag_type { 226 TRACE_FLAG_IRQS_OFF = 0x01, 227 TRACE_FLAG_IRQS_NOSUPPORT = 0x02, 228 TRACE_FLAG_NEED_RESCHED = 0x04, 229 TRACE_FLAG_HARDIRQ = 0x08, 230 TRACE_FLAG_SOFTIRQ = 0x10, 231 }; 232 233 #define TRACE_BUF_SIZE 1024 234 235 /* 236 * The CPU trace array - it consists of thousands of trace entries 237 * plus some other descriptor data: (for example which task started 238 * the trace, etc.) 239 */ 240 struct trace_array_cpu { 241 atomic_t disabled; 242 void *buffer_page; /* ring buffer spare */ 243 244 /* these fields get copied into max-trace: */ 245 unsigned long trace_idx; 246 unsigned long overrun; 247 unsigned long saved_latency; 248 unsigned long critical_start; 249 unsigned long critical_end; 250 unsigned long critical_sequence; 251 unsigned long nice; 252 unsigned long policy; 253 unsigned long rt_priority; 254 cycle_t preempt_timestamp; 255 pid_t pid; 256 uid_t uid; 257 char comm[TASK_COMM_LEN]; 258 }; 259 260 struct trace_iterator; 261 262 /* 263 * The trace array - an array of per-CPU trace arrays. This is the 264 * highest level data structure that individual tracers deal with. 265 * They have on/off state as well: 266 */ 267 struct trace_array { 268 struct ring_buffer *buffer; 269 unsigned long entries; 270 int cpu; 271 cycle_t time_start; 272 struct task_struct *waiter; 273 struct trace_array_cpu *data[NR_CPUS]; 274 }; 275 276 #define FTRACE_CMP_TYPE(var, type) \ 277 __builtin_types_compatible_p(typeof(var), type *) 278 279 #undef IF_ASSIGN 280 #define IF_ASSIGN(var, entry, etype, id) \ 281 if (FTRACE_CMP_TYPE(var, etype)) { \ 282 var = (typeof(var))(entry); \ 283 WARN_ON(id && (entry)->type != id); \ 284 break; \ 285 } 286 287 /* Will cause compile errors if type is not found. */ 288 extern void __ftrace_bad_type(void); 289 290 /* 291 * The trace_assign_type is a verifier that the entry type is 292 * the same as the type being assigned. To add new types simply 293 * add a line with the following format: 294 * 295 * IF_ASSIGN(var, ent, type, id); 296 * 297 * Where "type" is the trace type that includes the trace_entry 298 * as the "ent" item. And "id" is the trace identifier that is 299 * used in the trace_type enum. 300 * 301 * If the type can have more than one id, then use zero. 302 */ 303 #define trace_assign_type(var, ent) \ 304 do { \ 305 IF_ASSIGN(var, ent, struct ftrace_entry, TRACE_FN); \ 306 IF_ASSIGN(var, ent, struct ctx_switch_entry, 0); \ 307 IF_ASSIGN(var, ent, struct stack_entry, TRACE_STACK); \ 308 IF_ASSIGN(var, ent, struct userstack_entry, TRACE_USER_STACK);\ 309 IF_ASSIGN(var, ent, struct print_entry, TRACE_PRINT); \ 310 IF_ASSIGN(var, ent, struct bprint_entry, TRACE_BPRINT); \ 311 IF_ASSIGN(var, ent, struct special_entry, 0); \ 312 IF_ASSIGN(var, ent, struct trace_mmiotrace_rw, \ 313 TRACE_MMIO_RW); \ 314 IF_ASSIGN(var, ent, struct trace_mmiotrace_map, \ 315 TRACE_MMIO_MAP); \ 316 IF_ASSIGN(var, ent, struct trace_boot_call, TRACE_BOOT_CALL);\ 317 IF_ASSIGN(var, ent, struct trace_boot_ret, TRACE_BOOT_RET);\ 318 IF_ASSIGN(var, ent, struct trace_branch, TRACE_BRANCH); \ 319 IF_ASSIGN(var, ent, struct ftrace_graph_ent_entry, \ 320 TRACE_GRAPH_ENT); \ 321 IF_ASSIGN(var, ent, struct ftrace_graph_ret_entry, \ 322 TRACE_GRAPH_RET); \ 323 IF_ASSIGN(var, ent, struct hw_branch_entry, TRACE_HW_BRANCHES);\ 324 IF_ASSIGN(var, ent, struct trace_power, TRACE_POWER); \ 325 IF_ASSIGN(var, ent, struct kmemtrace_alloc_entry, \ 326 TRACE_KMEM_ALLOC); \ 327 IF_ASSIGN(var, ent, struct kmemtrace_free_entry, \ 328 TRACE_KMEM_FREE); \ 329 IF_ASSIGN(var, ent, struct syscall_trace_enter, \ 330 TRACE_SYSCALL_ENTER); \ 331 IF_ASSIGN(var, ent, struct syscall_trace_exit, \ 332 TRACE_SYSCALL_EXIT); \ 333 __ftrace_bad_type(); \ 334 } while (0) 335 336 /* Return values for print_line callback */ 337 enum print_line_t { 338 TRACE_TYPE_PARTIAL_LINE = 0, /* Retry after flushing the seq */ 339 TRACE_TYPE_HANDLED = 1, 340 TRACE_TYPE_UNHANDLED = 2, /* Relay to other output functions */ 341 TRACE_TYPE_NO_CONSUME = 3 /* Handled but ask to not consume */ 342 }; 343 344 345 /* 346 * An option specific to a tracer. This is a boolean value. 347 * The bit is the bit index that sets its value on the 348 * flags value in struct tracer_flags. 349 */ 350 struct tracer_opt { 351 const char *name; /* Will appear on the trace_options file */ 352 u32 bit; /* Mask assigned in val field in tracer_flags */ 353 }; 354 355 /* 356 * The set of specific options for a tracer. Your tracer 357 * have to set the initial value of the flags val. 358 */ 359 struct tracer_flags { 360 u32 val; 361 struct tracer_opt *opts; 362 }; 363 364 /* Makes more easy to define a tracer opt */ 365 #define TRACER_OPT(s, b) .name = #s, .bit = b 366 367 368 /** 369 * struct tracer - a specific tracer and its callbacks to interact with debugfs 370 * @name: the name chosen to select it on the available_tracers file 371 * @init: called when one switches to this tracer (echo name > current_tracer) 372 * @reset: called when one switches to another tracer 373 * @start: called when tracing is unpaused (echo 1 > tracing_enabled) 374 * @stop: called when tracing is paused (echo 0 > tracing_enabled) 375 * @open: called when the trace file is opened 376 * @pipe_open: called when the trace_pipe file is opened 377 * @wait_pipe: override how the user waits for traces on trace_pipe 378 * @close: called when the trace file is released 379 * @read: override the default read callback on trace_pipe 380 * @splice_read: override the default splice_read callback on trace_pipe 381 * @selftest: selftest to run on boot (see trace_selftest.c) 382 * @print_headers: override the first lines that describe your columns 383 * @print_line: callback that prints a trace 384 * @set_flag: signals one of your private flags changed (trace_options file) 385 * @flags: your private flags 386 */ 387 struct tracer { 388 const char *name; 389 int (*init)(struct trace_array *tr); 390 void (*reset)(struct trace_array *tr); 391 void (*start)(struct trace_array *tr); 392 void (*stop)(struct trace_array *tr); 393 void (*open)(struct trace_iterator *iter); 394 void (*pipe_open)(struct trace_iterator *iter); 395 void (*wait_pipe)(struct trace_iterator *iter); 396 void (*close)(struct trace_iterator *iter); 397 ssize_t (*read)(struct trace_iterator *iter, 398 struct file *filp, char __user *ubuf, 399 size_t cnt, loff_t *ppos); 400 ssize_t (*splice_read)(struct trace_iterator *iter, 401 struct file *filp, 402 loff_t *ppos, 403 struct pipe_inode_info *pipe, 404 size_t len, 405 unsigned int flags); 406 #ifdef CONFIG_FTRACE_STARTUP_TEST 407 int (*selftest)(struct tracer *trace, 408 struct trace_array *tr); 409 #endif 410 void (*print_header)(struct seq_file *m); 411 enum print_line_t (*print_line)(struct trace_iterator *iter); 412 /* If you handled the flag setting, return 0 */ 413 int (*set_flag)(u32 old_flags, u32 bit, int set); 414 struct tracer *next; 415 int print_max; 416 struct tracer_flags *flags; 417 struct tracer_stat *stats; 418 }; 419 420 struct trace_seq { 421 unsigned char buffer[PAGE_SIZE]; 422 unsigned int len; 423 unsigned int readpos; 424 }; 425 426 static inline void 427 trace_seq_init(struct trace_seq *s) 428 { 429 s->len = 0; 430 s->readpos = 0; 431 } 432 433 434 #define TRACE_PIPE_ALL_CPU -1 435 436 /* 437 * Trace iterator - used by printout routines who present trace 438 * results to users and which routines might sleep, etc: 439 */ 440 struct trace_iterator { 441 struct trace_array *tr; 442 struct tracer *trace; 443 void *private; 444 int cpu_file; 445 struct mutex mutex; 446 struct ring_buffer_iter *buffer_iter[NR_CPUS]; 447 448 /* The below is zeroed out in pipe_read */ 449 struct trace_seq seq; 450 struct trace_entry *ent; 451 int cpu; 452 u64 ts; 453 454 unsigned long iter_flags; 455 loff_t pos; 456 long idx; 457 458 cpumask_var_t started; 459 }; 460 461 int tracer_init(struct tracer *t, struct trace_array *tr); 462 int tracing_is_enabled(void); 463 void trace_wake_up(void); 464 void tracing_reset(struct trace_array *tr, int cpu); 465 void tracing_reset_online_cpus(struct trace_array *tr); 466 int tracing_open_generic(struct inode *inode, struct file *filp); 467 struct dentry *tracing_init_dentry(void); 468 void init_tracer_sysprof_debugfs(struct dentry *d_tracer); 469 470 struct ring_buffer_event; 471 472 struct ring_buffer_event *trace_buffer_lock_reserve(struct trace_array *tr, 473 unsigned char type, 474 unsigned long len, 475 unsigned long flags, 476 int pc); 477 void trace_buffer_unlock_commit(struct trace_array *tr, 478 struct ring_buffer_event *event, 479 unsigned long flags, int pc); 480 481 struct ring_buffer_event * 482 trace_current_buffer_lock_reserve(unsigned char type, unsigned long len, 483 unsigned long flags, int pc); 484 void trace_current_buffer_unlock_commit(struct ring_buffer_event *event, 485 unsigned long flags, int pc); 486 void trace_nowake_buffer_unlock_commit(struct ring_buffer_event *event, 487 unsigned long flags, int pc); 488 489 struct trace_entry *tracing_get_trace_entry(struct trace_array *tr, 490 struct trace_array_cpu *data); 491 492 struct trace_entry *trace_find_next_entry(struct trace_iterator *iter, 493 int *ent_cpu, u64 *ent_ts); 494 495 void tracing_generic_entry_update(struct trace_entry *entry, 496 unsigned long flags, 497 int pc); 498 499 void default_wait_pipe(struct trace_iterator *iter); 500 void poll_wait_pipe(struct trace_iterator *iter); 501 502 void ftrace(struct trace_array *tr, 503 struct trace_array_cpu *data, 504 unsigned long ip, 505 unsigned long parent_ip, 506 unsigned long flags, int pc); 507 void tracing_sched_switch_trace(struct trace_array *tr, 508 struct task_struct *prev, 509 struct task_struct *next, 510 unsigned long flags, int pc); 511 void tracing_record_cmdline(struct task_struct *tsk); 512 513 void tracing_sched_wakeup_trace(struct trace_array *tr, 514 struct task_struct *wakee, 515 struct task_struct *cur, 516 unsigned long flags, int pc); 517 void trace_special(struct trace_array *tr, 518 struct trace_array_cpu *data, 519 unsigned long arg1, 520 unsigned long arg2, 521 unsigned long arg3, int pc); 522 void trace_function(struct trace_array *tr, 523 unsigned long ip, 524 unsigned long parent_ip, 525 unsigned long flags, int pc); 526 527 void trace_graph_return(struct ftrace_graph_ret *trace); 528 int trace_graph_entry(struct ftrace_graph_ent *trace); 529 530 void tracing_start_cmdline_record(void); 531 void tracing_stop_cmdline_record(void); 532 void tracing_sched_switch_assign_trace(struct trace_array *tr); 533 void tracing_stop_sched_switch_record(void); 534 void tracing_start_sched_switch_record(void); 535 int register_tracer(struct tracer *type); 536 void unregister_tracer(struct tracer *type); 537 538 extern unsigned long nsecs_to_usecs(unsigned long nsecs); 539 540 extern unsigned long tracing_max_latency; 541 extern unsigned long tracing_thresh; 542 543 void update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu); 544 void update_max_tr_single(struct trace_array *tr, 545 struct task_struct *tsk, int cpu); 546 547 void __trace_stack(struct trace_array *tr, 548 unsigned long flags, 549 int skip, int pc); 550 551 extern cycle_t ftrace_now(int cpu); 552 553 #ifdef CONFIG_CONTEXT_SWITCH_TRACER 554 typedef void 555 (*tracer_switch_func_t)(void *private, 556 void *__rq, 557 struct task_struct *prev, 558 struct task_struct *next); 559 560 struct tracer_switch_ops { 561 tracer_switch_func_t func; 562 void *private; 563 struct tracer_switch_ops *next; 564 }; 565 #endif /* CONFIG_CONTEXT_SWITCH_TRACER */ 566 567 extern void trace_find_cmdline(int pid, char comm[]); 568 569 #ifdef CONFIG_DYNAMIC_FTRACE 570 extern unsigned long ftrace_update_tot_cnt; 571 #define DYN_FTRACE_TEST_NAME trace_selftest_dynamic_test_func 572 extern int DYN_FTRACE_TEST_NAME(void); 573 #endif 574 575 #ifdef CONFIG_FTRACE_STARTUP_TEST 576 extern int trace_selftest_startup_function(struct tracer *trace, 577 struct trace_array *tr); 578 extern int trace_selftest_startup_function_graph(struct tracer *trace, 579 struct trace_array *tr); 580 extern int trace_selftest_startup_irqsoff(struct tracer *trace, 581 struct trace_array *tr); 582 extern int trace_selftest_startup_preemptoff(struct tracer *trace, 583 struct trace_array *tr); 584 extern int trace_selftest_startup_preemptirqsoff(struct tracer *trace, 585 struct trace_array *tr); 586 extern int trace_selftest_startup_wakeup(struct tracer *trace, 587 struct trace_array *tr); 588 extern int trace_selftest_startup_nop(struct tracer *trace, 589 struct trace_array *tr); 590 extern int trace_selftest_startup_sched_switch(struct tracer *trace, 591 struct trace_array *tr); 592 extern int trace_selftest_startup_sysprof(struct tracer *trace, 593 struct trace_array *tr); 594 extern int trace_selftest_startup_branch(struct tracer *trace, 595 struct trace_array *tr); 596 #endif /* CONFIG_FTRACE_STARTUP_TEST */ 597 598 extern void *head_page(struct trace_array_cpu *data); 599 extern long ns2usecs(cycle_t nsec); 600 extern int 601 trace_vbprintk(unsigned long ip, const char *fmt, va_list args); 602 extern int 603 trace_vprintk(unsigned long ip, const char *fmt, va_list args); 604 605 extern unsigned long trace_flags; 606 607 /* Standard output formatting function used for function return traces */ 608 #ifdef CONFIG_FUNCTION_GRAPH_TRACER 609 extern enum print_line_t print_graph_function(struct trace_iterator *iter); 610 611 #ifdef CONFIG_DYNAMIC_FTRACE 612 /* TODO: make this variable */ 613 #define FTRACE_GRAPH_MAX_FUNCS 32 614 extern int ftrace_graph_count; 615 extern unsigned long ftrace_graph_funcs[FTRACE_GRAPH_MAX_FUNCS]; 616 617 static inline int ftrace_graph_addr(unsigned long addr) 618 { 619 int i; 620 621 if (!ftrace_graph_count || test_tsk_trace_graph(current)) 622 return 1; 623 624 for (i = 0; i < ftrace_graph_count; i++) { 625 if (addr == ftrace_graph_funcs[i]) 626 return 1; 627 } 628 629 return 0; 630 } 631 #else 632 static inline int ftrace_trace_addr(unsigned long addr) 633 { 634 return 1; 635 } 636 static inline int ftrace_graph_addr(unsigned long addr) 637 { 638 return 1; 639 } 640 #endif /* CONFIG_DYNAMIC_FTRACE */ 641 642 #else /* CONFIG_FUNCTION_GRAPH_TRACER */ 643 static inline enum print_line_t 644 print_graph_function(struct trace_iterator *iter) 645 { 646 return TRACE_TYPE_UNHANDLED; 647 } 648 #endif /* CONFIG_FUNCTION_GRAPH_TRACER */ 649 650 extern struct pid *ftrace_pid_trace; 651 652 static inline int ftrace_trace_task(struct task_struct *task) 653 { 654 if (!ftrace_pid_trace) 655 return 1; 656 657 return test_tsk_trace_trace(task); 658 } 659 660 /* 661 * trace_iterator_flags is an enumeration that defines bit 662 * positions into trace_flags that controls the output. 663 * 664 * NOTE: These bits must match the trace_options array in 665 * trace.c. 666 */ 667 enum trace_iterator_flags { 668 TRACE_ITER_PRINT_PARENT = 0x01, 669 TRACE_ITER_SYM_OFFSET = 0x02, 670 TRACE_ITER_SYM_ADDR = 0x04, 671 TRACE_ITER_VERBOSE = 0x08, 672 TRACE_ITER_RAW = 0x10, 673 TRACE_ITER_HEX = 0x20, 674 TRACE_ITER_BIN = 0x40, 675 TRACE_ITER_BLOCK = 0x80, 676 TRACE_ITER_STACKTRACE = 0x100, 677 TRACE_ITER_SCHED_TREE = 0x200, 678 TRACE_ITER_PRINTK = 0x400, 679 TRACE_ITER_PREEMPTONLY = 0x800, 680 TRACE_ITER_BRANCH = 0x1000, 681 TRACE_ITER_ANNOTATE = 0x2000, 682 TRACE_ITER_USERSTACKTRACE = 0x4000, 683 TRACE_ITER_SYM_USEROBJ = 0x8000, 684 TRACE_ITER_PRINTK_MSGONLY = 0x10000, 685 TRACE_ITER_CONTEXT_INFO = 0x20000, /* Print pid/cpu/time */ 686 TRACE_ITER_LATENCY_FMT = 0x40000, 687 TRACE_ITER_GLOBAL_CLK = 0x80000, 688 TRACE_ITER_SLEEP_TIME = 0x100000, 689 }; 690 691 /* 692 * TRACE_ITER_SYM_MASK masks the options in trace_flags that 693 * control the output of kernel symbols. 694 */ 695 #define TRACE_ITER_SYM_MASK \ 696 (TRACE_ITER_PRINT_PARENT|TRACE_ITER_SYM_OFFSET|TRACE_ITER_SYM_ADDR) 697 698 extern struct tracer nop_trace; 699 700 /** 701 * ftrace_preempt_disable - disable preemption scheduler safe 702 * 703 * When tracing can happen inside the scheduler, there exists 704 * cases that the tracing might happen before the need_resched 705 * flag is checked. If this happens and the tracer calls 706 * preempt_enable (after a disable), a schedule might take place 707 * causing an infinite recursion. 708 * 709 * To prevent this, we read the need_resched flag before 710 * disabling preemption. When we want to enable preemption we 711 * check the flag, if it is set, then we call preempt_enable_no_resched. 712 * Otherwise, we call preempt_enable. 713 * 714 * The rational for doing the above is that if need_resched is set 715 * and we have yet to reschedule, we are either in an atomic location 716 * (where we do not need to check for scheduling) or we are inside 717 * the scheduler and do not want to resched. 718 */ 719 static inline int ftrace_preempt_disable(void) 720 { 721 int resched; 722 723 resched = need_resched(); 724 preempt_disable_notrace(); 725 726 return resched; 727 } 728 729 /** 730 * ftrace_preempt_enable - enable preemption scheduler safe 731 * @resched: the return value from ftrace_preempt_disable 732 * 733 * This is a scheduler safe way to enable preemption and not miss 734 * any preemption checks. The disabled saved the state of preemption. 735 * If resched is set, then we are either inside an atomic or 736 * are inside the scheduler (we would have already scheduled 737 * otherwise). In this case, we do not want to call normal 738 * preempt_enable, but preempt_enable_no_resched instead. 739 */ 740 static inline void ftrace_preempt_enable(int resched) 741 { 742 if (resched) 743 preempt_enable_no_resched_notrace(); 744 else 745 preempt_enable_notrace(); 746 } 747 748 #ifdef CONFIG_BRANCH_TRACER 749 extern int enable_branch_tracing(struct trace_array *tr); 750 extern void disable_branch_tracing(void); 751 static inline int trace_branch_enable(struct trace_array *tr) 752 { 753 if (trace_flags & TRACE_ITER_BRANCH) 754 return enable_branch_tracing(tr); 755 return 0; 756 } 757 static inline void trace_branch_disable(void) 758 { 759 /* due to races, always disable */ 760 disable_branch_tracing(); 761 } 762 #else 763 static inline int trace_branch_enable(struct trace_array *tr) 764 { 765 return 0; 766 } 767 static inline void trace_branch_disable(void) 768 { 769 } 770 #endif /* CONFIG_BRANCH_TRACER */ 771 772 /* set ring buffers to default size if not already done so */ 773 int tracing_update_buffers(void); 774 775 /* trace event type bit fields, not numeric */ 776 enum { 777 TRACE_EVENT_TYPE_PRINTF = 1, 778 TRACE_EVENT_TYPE_RAW = 2, 779 }; 780 781 struct ftrace_event_field { 782 struct list_head link; 783 char *name; 784 char *type; 785 int offset; 786 int size; 787 }; 788 789 struct ftrace_event_call { 790 char *name; 791 char *system; 792 struct dentry *dir; 793 int enabled; 794 int (*regfunc)(void); 795 void (*unregfunc)(void); 796 int id; 797 int (*raw_init)(void); 798 int (*show_format)(struct trace_seq *s); 799 int (*define_fields)(void); 800 struct list_head fields; 801 struct filter_pred **preds; 802 803 #ifdef CONFIG_EVENT_PROFILE 804 atomic_t profile_count; 805 int (*profile_enable)(struct ftrace_event_call *); 806 void (*profile_disable)(struct ftrace_event_call *); 807 #endif 808 }; 809 810 struct event_subsystem { 811 struct list_head list; 812 const char *name; 813 struct dentry *entry; 814 struct filter_pred **preds; 815 }; 816 817 #define events_for_each(event) \ 818 for (event = __start_ftrace_events; \ 819 (unsigned long)event < (unsigned long)__stop_ftrace_events; \ 820 event++) 821 822 #define MAX_FILTER_PRED 8 823 824 struct filter_pred; 825 826 typedef int (*filter_pred_fn_t) (struct filter_pred *pred, void *event); 827 828 struct filter_pred { 829 filter_pred_fn_t fn; 830 u64 val; 831 char *str_val; 832 int str_len; 833 char *field_name; 834 int offset; 835 int not; 836 int or; 837 int compound; 838 int clear; 839 }; 840 841 int trace_define_field(struct ftrace_event_call *call, char *type, 842 char *name, int offset, int size); 843 extern void filter_free_pred(struct filter_pred *pred); 844 extern void filter_print_preds(struct filter_pred **preds, 845 struct trace_seq *s); 846 extern int filter_parse(char **pbuf, struct filter_pred *pred); 847 extern int filter_add_pred(struct ftrace_event_call *call, 848 struct filter_pred *pred); 849 extern void filter_free_preds(struct ftrace_event_call *call); 850 extern int filter_match_preds(struct ftrace_event_call *call, void *rec); 851 extern void filter_free_subsystem_preds(struct event_subsystem *system); 852 extern int filter_add_subsystem_pred(struct event_subsystem *system, 853 struct filter_pred *pred); 854 855 void event_trace_printk(unsigned long ip, const char *fmt, ...); 856 extern struct ftrace_event_call __start_ftrace_events[]; 857 extern struct ftrace_event_call __stop_ftrace_events[]; 858 859 #define for_each_event(event) \ 860 for (event = __start_ftrace_events; \ 861 (unsigned long)event < (unsigned long)__stop_ftrace_events; \ 862 event++) 863 864 extern const char *__start___trace_bprintk_fmt[]; 865 extern const char *__stop___trace_bprintk_fmt[]; 866 867 /* 868 * The double __builtin_constant_p is because gcc will give us an error 869 * if we try to allocate the static variable to fmt if it is not a 870 * constant. Even with the outer if statement optimizing out. 871 */ 872 #define event_trace_printk(ip, fmt, args...) \ 873 do { \ 874 __trace_printk_check_format(fmt, ##args); \ 875 tracing_record_cmdline(current); \ 876 if (__builtin_constant_p(fmt)) { \ 877 static const char *trace_printk_fmt \ 878 __attribute__((section("__trace_printk_fmt"))) = \ 879 __builtin_constant_p(fmt) ? fmt : NULL; \ 880 \ 881 __trace_bprintk(ip, trace_printk_fmt, ##args); \ 882 } else \ 883 __trace_printk(ip, fmt, ##args); \ 884 } while (0) 885 886 #endif /* _LINUX_KERNEL_TRACE_H */ 887