1/* 2 * trace_output.c 3 * 4 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> 5 * 6 */ 7 8#include <linux/module.h> 9#include <linux/mutex.h> 10#include <linux/ftrace.h> 11 12#include "trace_output.h" 13 14/* must be a power of 2 */ 15#define EVENT_HASHSIZE 128 16 17DECLARE_RWSEM(trace_event_sem); 18 19static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly; 20 21static int next_event_type = __TRACE_LAST_TYPE + 1; 22 23enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter) 24{ 25 struct trace_seq *s = &iter->seq; 26 struct trace_entry *entry = iter->ent; 27 struct bputs_entry *field; 28 29 trace_assign_type(field, entry); 30 31 trace_seq_puts(s, field->str); 32 33 return trace_handle_return(s); 34} 35 36enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter) 37{ 38 struct trace_seq *s = &iter->seq; 39 struct trace_entry *entry = iter->ent; 40 struct bprint_entry *field; 41 42 trace_assign_type(field, entry); 43 44 trace_seq_bprintf(s, field->fmt, field->buf); 45 46 return trace_handle_return(s); 47} 48 49enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter) 50{ 51 struct trace_seq *s = &iter->seq; 52 struct trace_entry *entry = iter->ent; 53 struct print_entry *field; 54 55 trace_assign_type(field, entry); 56 57 trace_seq_puts(s, field->buf); 58 59 return trace_handle_return(s); 60} 61 62const char * 63ftrace_print_flags_seq(struct trace_seq *p, const char *delim, 64 unsigned long flags, 65 const struct trace_print_flags *flag_array) 66{ 67 unsigned long mask; 68 const char *str; 69 const char *ret = trace_seq_buffer_ptr(p); 70 int i, first = 1; 71 72 for (i = 0; flag_array[i].name && flags; i++) { 73 74 mask = flag_array[i].mask; 75 if ((flags & mask) != mask) 76 continue; 77 78 str = flag_array[i].name; 79 flags &= ~mask; 80 if (!first && delim) 81 trace_seq_puts(p, delim); 82 else 83 first = 0; 84 trace_seq_puts(p, str); 85 } 86 87 /* check for left over flags */ 88 if (flags) { 89 if (!first && delim) 90 trace_seq_puts(p, delim); 91 trace_seq_printf(p, "0x%lx", flags); 92 } 93 94 trace_seq_putc(p, 0); 95 96 return ret; 97} 98EXPORT_SYMBOL(ftrace_print_flags_seq); 99 100const char * 101ftrace_print_symbols_seq(struct trace_seq *p, unsigned long val, 102 const struct trace_print_flags *symbol_array) 103{ 104 int i; 105 const char *ret = trace_seq_buffer_ptr(p); 106 107 for (i = 0; symbol_array[i].name; i++) { 108 109 if (val != symbol_array[i].mask) 110 continue; 111 112 trace_seq_puts(p, symbol_array[i].name); 113 break; 114 } 115 116 if (ret == (const char *)(trace_seq_buffer_ptr(p))) 117 trace_seq_printf(p, "0x%lx", val); 118 119 trace_seq_putc(p, 0); 120 121 return ret; 122} 123EXPORT_SYMBOL(ftrace_print_symbols_seq); 124 125#if BITS_PER_LONG == 32 126const char * 127ftrace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val, 128 const struct trace_print_flags_u64 *symbol_array) 129{ 130 int i; 131 const char *ret = trace_seq_buffer_ptr(p); 132 133 for (i = 0; symbol_array[i].name; i++) { 134 135 if (val != symbol_array[i].mask) 136 continue; 137 138 trace_seq_puts(p, symbol_array[i].name); 139 break; 140 } 141 142 if (ret == (const char *)(trace_seq_buffer_ptr(p))) 143 trace_seq_printf(p, "0x%llx", val); 144 145 trace_seq_putc(p, 0); 146 147 return ret; 148} 149EXPORT_SYMBOL(ftrace_print_symbols_seq_u64); 150#endif 151 152const char * 153ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr, 154 unsigned int bitmask_size) 155{ 156 const char *ret = trace_seq_buffer_ptr(p); 157 158 trace_seq_bitmask(p, bitmask_ptr, bitmask_size * 8); 159 trace_seq_putc(p, 0); 160 161 return ret; 162} 163EXPORT_SYMBOL_GPL(ftrace_print_bitmask_seq); 164 165const char * 166ftrace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len) 167{ 168 int i; 169 const char *ret = trace_seq_buffer_ptr(p); 170 171 for (i = 0; i < buf_len; i++) 172 trace_seq_printf(p, "%s%2.2x", i == 0 ? "" : " ", buf[i]); 173 174 trace_seq_putc(p, 0); 175 176 return ret; 177} 178EXPORT_SYMBOL(ftrace_print_hex_seq); 179 180const char * 181ftrace_print_array_seq(struct trace_seq *p, const void *buf, int count, 182 size_t el_size) 183{ 184 const char *ret = trace_seq_buffer_ptr(p); 185 const char *prefix = ""; 186 void *ptr = (void *)buf; 187 size_t buf_len = count * el_size; 188 189 trace_seq_putc(p, '{'); 190 191 while (ptr < buf + buf_len) { 192 switch (el_size) { 193 case 1: 194 trace_seq_printf(p, "%s0x%x", prefix, 195 *(u8 *)ptr); 196 break; 197 case 2: 198 trace_seq_printf(p, "%s0x%x", prefix, 199 *(u16 *)ptr); 200 break; 201 case 4: 202 trace_seq_printf(p, "%s0x%x", prefix, 203 *(u32 *)ptr); 204 break; 205 case 8: 206 trace_seq_printf(p, "%s0x%llx", prefix, 207 *(u64 *)ptr); 208 break; 209 default: 210 trace_seq_printf(p, "BAD SIZE:%zu 0x%x", el_size, 211 *(u8 *)ptr); 212 el_size = 1; 213 } 214 prefix = ","; 215 ptr += el_size; 216 } 217 218 trace_seq_putc(p, '}'); 219 trace_seq_putc(p, 0); 220 221 return ret; 222} 223EXPORT_SYMBOL(ftrace_print_array_seq); 224 225int ftrace_raw_output_prep(struct trace_iterator *iter, 226 struct trace_event *trace_event) 227{ 228 struct ftrace_event_call *event; 229 struct trace_seq *s = &iter->seq; 230 struct trace_seq *p = &iter->tmp_seq; 231 struct trace_entry *entry; 232 233 event = container_of(trace_event, struct ftrace_event_call, event); 234 entry = iter->ent; 235 236 if (entry->type != event->event.type) { 237 WARN_ON_ONCE(1); 238 return TRACE_TYPE_UNHANDLED; 239 } 240 241 trace_seq_init(p); 242 trace_seq_printf(s, "%s: ", ftrace_event_name(event)); 243 244 return trace_handle_return(s); 245} 246EXPORT_SYMBOL(ftrace_raw_output_prep); 247 248static int ftrace_output_raw(struct trace_iterator *iter, char *name, 249 char *fmt, va_list ap) 250{ 251 struct trace_seq *s = &iter->seq; 252 253 trace_seq_printf(s, "%s: ", name); 254 trace_seq_vprintf(s, fmt, ap); 255 256 return trace_handle_return(s); 257} 258 259int ftrace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...) 260{ 261 va_list ap; 262 int ret; 263 264 va_start(ap, fmt); 265 ret = ftrace_output_raw(iter, name, fmt, ap); 266 va_end(ap); 267 268 return ret; 269} 270EXPORT_SYMBOL_GPL(ftrace_output_call); 271 272#ifdef CONFIG_KRETPROBES 273static inline const char *kretprobed(const char *name) 274{ 275 static const char tramp_name[] = "kretprobe_trampoline"; 276 int size = sizeof(tramp_name); 277 278 if (strncmp(tramp_name, name, size) == 0) 279 return "[unknown/kretprobe'd]"; 280 return name; 281} 282#else 283static inline const char *kretprobed(const char *name) 284{ 285 return name; 286} 287#endif /* CONFIG_KRETPROBES */ 288 289static void 290seq_print_sym_short(struct trace_seq *s, const char *fmt, unsigned long address) 291{ 292#ifdef CONFIG_KALLSYMS 293 char str[KSYM_SYMBOL_LEN]; 294 const char *name; 295 296 kallsyms_lookup(address, NULL, NULL, NULL, str); 297 298 name = kretprobed(str); 299 300 trace_seq_printf(s, fmt, name); 301#endif 302} 303 304static void 305seq_print_sym_offset(struct trace_seq *s, const char *fmt, 306 unsigned long address) 307{ 308#ifdef CONFIG_KALLSYMS 309 char str[KSYM_SYMBOL_LEN]; 310 const char *name; 311 312 sprint_symbol(str, address); 313 name = kretprobed(str); 314 315 trace_seq_printf(s, fmt, name); 316#endif 317} 318 319#ifndef CONFIG_64BIT 320# define IP_FMT "%08lx" 321#else 322# define IP_FMT "%016lx" 323#endif 324 325int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm, 326 unsigned long ip, unsigned long sym_flags) 327{ 328 struct file *file = NULL; 329 unsigned long vmstart = 0; 330 int ret = 1; 331 332 if (s->full) 333 return 0; 334 335 if (mm) { 336 const struct vm_area_struct *vma; 337 338 down_read(&mm->mmap_sem); 339 vma = find_vma(mm, ip); 340 if (vma) { 341 file = vma->vm_file; 342 vmstart = vma->vm_start; 343 } 344 if (file) { 345 ret = trace_seq_path(s, &file->f_path); 346 if (ret) 347 trace_seq_printf(s, "[+0x%lx]", 348 ip - vmstart); 349 } 350 up_read(&mm->mmap_sem); 351 } 352 if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file)) 353 trace_seq_printf(s, " <" IP_FMT ">", ip); 354 return !trace_seq_has_overflowed(s); 355} 356 357int 358seq_print_userip_objs(const struct userstack_entry *entry, struct trace_seq *s, 359 unsigned long sym_flags) 360{ 361 struct mm_struct *mm = NULL; 362 unsigned int i; 363 364 if (trace_flags & TRACE_ITER_SYM_USEROBJ) { 365 struct task_struct *task; 366 /* 367 * we do the lookup on the thread group leader, 368 * since individual threads might have already quit! 369 */ 370 rcu_read_lock(); 371 task = find_task_by_vpid(entry->tgid); 372 if (task) 373 mm = get_task_mm(task); 374 rcu_read_unlock(); 375 } 376 377 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) { 378 unsigned long ip = entry->caller[i]; 379 380 if (ip == ULONG_MAX || trace_seq_has_overflowed(s)) 381 break; 382 383 trace_seq_puts(s, " => "); 384 385 if (!ip) { 386 trace_seq_puts(s, "??"); 387 trace_seq_putc(s, '\n'); 388 continue; 389 } 390 391 seq_print_user_ip(s, mm, ip, sym_flags); 392 trace_seq_putc(s, '\n'); 393 } 394 395 if (mm) 396 mmput(mm); 397 398 return !trace_seq_has_overflowed(s); 399} 400 401int 402seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags) 403{ 404 if (!ip) { 405 trace_seq_putc(s, '0'); 406 goto out; 407 } 408 409 if (sym_flags & TRACE_ITER_SYM_OFFSET) 410 seq_print_sym_offset(s, "%s", ip); 411 else 412 seq_print_sym_short(s, "%s", ip); 413 414 if (sym_flags & TRACE_ITER_SYM_ADDR) 415 trace_seq_printf(s, " <" IP_FMT ">", ip); 416 417 out: 418 return !trace_seq_has_overflowed(s); 419} 420 421/** 422 * trace_print_lat_fmt - print the irq, preempt and lockdep fields 423 * @s: trace seq struct to write to 424 * @entry: The trace entry field from the ring buffer 425 * 426 * Prints the generic fields of irqs off, in hard or softirq, preempt 427 * count. 428 */ 429int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry) 430{ 431 char hardsoft_irq; 432 char need_resched; 433 char irqs_off; 434 int hardirq; 435 int softirq; 436 437 hardirq = entry->flags & TRACE_FLAG_HARDIRQ; 438 softirq = entry->flags & TRACE_FLAG_SOFTIRQ; 439 440 irqs_off = 441 (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : 442 (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : 443 '.'; 444 445 switch (entry->flags & (TRACE_FLAG_NEED_RESCHED | 446 TRACE_FLAG_PREEMPT_RESCHED)) { 447 case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED: 448 need_resched = 'N'; 449 break; 450 case TRACE_FLAG_NEED_RESCHED: 451 need_resched = 'n'; 452 break; 453 case TRACE_FLAG_PREEMPT_RESCHED: 454 need_resched = 'p'; 455 break; 456 default: 457 need_resched = '.'; 458 break; 459 } 460 461 hardsoft_irq = 462 (hardirq && softirq) ? 'H' : 463 hardirq ? 'h' : 464 softirq ? 's' : 465 '.'; 466 467 trace_seq_printf(s, "%c%c%c", 468 irqs_off, need_resched, hardsoft_irq); 469 470 if (entry->preempt_count) 471 trace_seq_printf(s, "%x", entry->preempt_count); 472 else 473 trace_seq_putc(s, '.'); 474 475 return !trace_seq_has_overflowed(s); 476} 477 478static int 479lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu) 480{ 481 char comm[TASK_COMM_LEN]; 482 483 trace_find_cmdline(entry->pid, comm); 484 485 trace_seq_printf(s, "%8.8s-%-5d %3d", 486 comm, entry->pid, cpu); 487 488 return trace_print_lat_fmt(s, entry); 489} 490 491#undef MARK 492#define MARK(v, s) {.val = v, .sym = s} 493/* trace overhead mark */ 494static const struct trace_mark { 495 unsigned long long val; /* unit: nsec */ 496 char sym; 497} mark[] = { 498 MARK(1000000000ULL , '$'), /* 1 sec */ 499 MARK(1000000ULL , '#'), /* 1000 usecs */ 500 MARK(100000ULL , '!'), /* 100 usecs */ 501 MARK(10000ULL , '+'), /* 10 usecs */ 502}; 503#undef MARK 504 505char trace_find_mark(unsigned long long d) 506{ 507 int i; 508 int size = ARRAY_SIZE(mark); 509 510 for (i = 0; i < size; i++) { 511 if (d >= mark[i].val) 512 break; 513 } 514 515 return (i == size) ? ' ' : mark[i].sym; 516} 517 518static int 519lat_print_timestamp(struct trace_iterator *iter, u64 next_ts) 520{ 521 unsigned long verbose = trace_flags & TRACE_ITER_VERBOSE; 522 unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS; 523 unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start; 524 unsigned long long rel_ts = next_ts - iter->ts; 525 struct trace_seq *s = &iter->seq; 526 527 if (in_ns) { 528 abs_ts = ns2usecs(abs_ts); 529 rel_ts = ns2usecs(rel_ts); 530 } 531 532 if (verbose && in_ns) { 533 unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC); 534 unsigned long abs_msec = (unsigned long)abs_ts; 535 unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC); 536 unsigned long rel_msec = (unsigned long)rel_ts; 537 538 trace_seq_printf( 539 s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ", 540 ns2usecs(iter->ts), 541 abs_msec, abs_usec, 542 rel_msec, rel_usec); 543 544 } else if (verbose && !in_ns) { 545 trace_seq_printf( 546 s, "[%016llx] %lld (+%lld): ", 547 iter->ts, abs_ts, rel_ts); 548 549 } else if (!verbose && in_ns) { 550 trace_seq_printf( 551 s, " %4lldus%c: ", 552 abs_ts, 553 trace_find_mark(rel_ts * NSEC_PER_USEC)); 554 555 } else { /* !verbose && !in_ns */ 556 trace_seq_printf(s, " %4lld: ", abs_ts); 557 } 558 559 return !trace_seq_has_overflowed(s); 560} 561 562int trace_print_context(struct trace_iterator *iter) 563{ 564 struct trace_seq *s = &iter->seq; 565 struct trace_entry *entry = iter->ent; 566 unsigned long long t; 567 unsigned long secs, usec_rem; 568 char comm[TASK_COMM_LEN]; 569 570 trace_find_cmdline(entry->pid, comm); 571 572 trace_seq_printf(s, "%16s-%-5d [%03d] ", 573 comm, entry->pid, iter->cpu); 574 575 if (trace_flags & TRACE_ITER_IRQ_INFO) 576 trace_print_lat_fmt(s, entry); 577 578 if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) { 579 t = ns2usecs(iter->ts); 580 usec_rem = do_div(t, USEC_PER_SEC); 581 secs = (unsigned long)t; 582 trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem); 583 } else 584 trace_seq_printf(s, " %12llu: ", iter->ts); 585 586 return !trace_seq_has_overflowed(s); 587} 588 589int trace_print_lat_context(struct trace_iterator *iter) 590{ 591 u64 next_ts; 592 /* trace_find_next_entry will reset ent_size */ 593 int ent_size = iter->ent_size; 594 struct trace_seq *s = &iter->seq; 595 struct trace_entry *entry = iter->ent, 596 *next_entry = trace_find_next_entry(iter, NULL, 597 &next_ts); 598 unsigned long verbose = (trace_flags & TRACE_ITER_VERBOSE); 599 600 /* Restore the original ent_size */ 601 iter->ent_size = ent_size; 602 603 if (!next_entry) 604 next_ts = iter->ts; 605 606 if (verbose) { 607 char comm[TASK_COMM_LEN]; 608 609 trace_find_cmdline(entry->pid, comm); 610 611 trace_seq_printf( 612 s, "%16s %5d %3d %d %08x %08lx ", 613 comm, entry->pid, iter->cpu, entry->flags, 614 entry->preempt_count, iter->idx); 615 } else { 616 lat_print_generic(s, entry, iter->cpu); 617 } 618 619 lat_print_timestamp(iter, next_ts); 620 621 return !trace_seq_has_overflowed(s); 622} 623 624static const char state_to_char[] = TASK_STATE_TO_CHAR_STR; 625 626static int task_state_char(unsigned long state) 627{ 628 int bit = state ? __ffs(state) + 1 : 0; 629 630 return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?'; 631} 632 633/** 634 * ftrace_find_event - find a registered event 635 * @type: the type of event to look for 636 * 637 * Returns an event of type @type otherwise NULL 638 * Called with trace_event_read_lock() held. 639 */ 640struct trace_event *ftrace_find_event(int type) 641{ 642 struct trace_event *event; 643 unsigned key; 644 645 key = type & (EVENT_HASHSIZE - 1); 646 647 hlist_for_each_entry(event, &event_hash[key], node) { 648 if (event->type == type) 649 return event; 650 } 651 652 return NULL; 653} 654 655static LIST_HEAD(ftrace_event_list); 656 657static int trace_search_list(struct list_head **list) 658{ 659 struct trace_event *e; 660 int last = __TRACE_LAST_TYPE; 661 662 if (list_empty(&ftrace_event_list)) { 663 *list = &ftrace_event_list; 664 return last + 1; 665 } 666 667 /* 668 * We used up all possible max events, 669 * lets see if somebody freed one. 670 */ 671 list_for_each_entry(e, &ftrace_event_list, list) { 672 if (e->type != last + 1) 673 break; 674 last++; 675 } 676 677 /* Did we used up all 65 thousand events??? */ 678 if ((last + 1) > FTRACE_MAX_EVENT) 679 return 0; 680 681 *list = &e->list; 682 return last + 1; 683} 684 685void trace_event_read_lock(void) 686{ 687 down_read(&trace_event_sem); 688} 689 690void trace_event_read_unlock(void) 691{ 692 up_read(&trace_event_sem); 693} 694 695/** 696 * register_ftrace_event - register output for an event type 697 * @event: the event type to register 698 * 699 * Event types are stored in a hash and this hash is used to 700 * find a way to print an event. If the @event->type is set 701 * then it will use that type, otherwise it will assign a 702 * type to use. 703 * 704 * If you assign your own type, please make sure it is added 705 * to the trace_type enum in trace.h, to avoid collisions 706 * with the dynamic types. 707 * 708 * Returns the event type number or zero on error. 709 */ 710int register_ftrace_event(struct trace_event *event) 711{ 712 unsigned key; 713 int ret = 0; 714 715 down_write(&trace_event_sem); 716 717 if (WARN_ON(!event)) 718 goto out; 719 720 if (WARN_ON(!event->funcs)) 721 goto out; 722 723 INIT_LIST_HEAD(&event->list); 724 725 if (!event->type) { 726 struct list_head *list = NULL; 727 728 if (next_event_type > FTRACE_MAX_EVENT) { 729 730 event->type = trace_search_list(&list); 731 if (!event->type) 732 goto out; 733 734 } else { 735 736 event->type = next_event_type++; 737 list = &ftrace_event_list; 738 } 739 740 if (WARN_ON(ftrace_find_event(event->type))) 741 goto out; 742 743 list_add_tail(&event->list, list); 744 745 } else if (event->type > __TRACE_LAST_TYPE) { 746 printk(KERN_WARNING "Need to add type to trace.h\n"); 747 WARN_ON(1); 748 goto out; 749 } else { 750 /* Is this event already used */ 751 if (ftrace_find_event(event->type)) 752 goto out; 753 } 754 755 if (event->funcs->trace == NULL) 756 event->funcs->trace = trace_nop_print; 757 if (event->funcs->raw == NULL) 758 event->funcs->raw = trace_nop_print; 759 if (event->funcs->hex == NULL) 760 event->funcs->hex = trace_nop_print; 761 if (event->funcs->binary == NULL) 762 event->funcs->binary = trace_nop_print; 763 764 key = event->type & (EVENT_HASHSIZE - 1); 765 766 hlist_add_head(&event->node, &event_hash[key]); 767 768 ret = event->type; 769 out: 770 up_write(&trace_event_sem); 771 772 return ret; 773} 774EXPORT_SYMBOL_GPL(register_ftrace_event); 775 776/* 777 * Used by module code with the trace_event_sem held for write. 778 */ 779int __unregister_ftrace_event(struct trace_event *event) 780{ 781 hlist_del(&event->node); 782 list_del(&event->list); 783 return 0; 784} 785 786/** 787 * unregister_ftrace_event - remove a no longer used event 788 * @event: the event to remove 789 */ 790int unregister_ftrace_event(struct trace_event *event) 791{ 792 down_write(&trace_event_sem); 793 __unregister_ftrace_event(event); 794 up_write(&trace_event_sem); 795 796 return 0; 797} 798EXPORT_SYMBOL_GPL(unregister_ftrace_event); 799 800/* 801 * Standard events 802 */ 803 804enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags, 805 struct trace_event *event) 806{ 807 trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type); 808 809 return trace_handle_return(&iter->seq); 810} 811 812/* TRACE_FN */ 813static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags, 814 struct trace_event *event) 815{ 816 struct ftrace_entry *field; 817 struct trace_seq *s = &iter->seq; 818 819 trace_assign_type(field, iter->ent); 820 821 seq_print_ip_sym(s, field->ip, flags); 822 823 if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) { 824 trace_seq_puts(s, " <-"); 825 seq_print_ip_sym(s, field->parent_ip, flags); 826 } 827 828 trace_seq_putc(s, '\n'); 829 830 return trace_handle_return(s); 831} 832 833static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags, 834 struct trace_event *event) 835{ 836 struct ftrace_entry *field; 837 838 trace_assign_type(field, iter->ent); 839 840 trace_seq_printf(&iter->seq, "%lx %lx\n", 841 field->ip, 842 field->parent_ip); 843 844 return trace_handle_return(&iter->seq); 845} 846 847static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags, 848 struct trace_event *event) 849{ 850 struct ftrace_entry *field; 851 struct trace_seq *s = &iter->seq; 852 853 trace_assign_type(field, iter->ent); 854 855 SEQ_PUT_HEX_FIELD(s, field->ip); 856 SEQ_PUT_HEX_FIELD(s, field->parent_ip); 857 858 return trace_handle_return(s); 859} 860 861static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags, 862 struct trace_event *event) 863{ 864 struct ftrace_entry *field; 865 struct trace_seq *s = &iter->seq; 866 867 trace_assign_type(field, iter->ent); 868 869 SEQ_PUT_FIELD(s, field->ip); 870 SEQ_PUT_FIELD(s, field->parent_ip); 871 872 return trace_handle_return(s); 873} 874 875static struct trace_event_functions trace_fn_funcs = { 876 .trace = trace_fn_trace, 877 .raw = trace_fn_raw, 878 .hex = trace_fn_hex, 879 .binary = trace_fn_bin, 880}; 881 882static struct trace_event trace_fn_event = { 883 .type = TRACE_FN, 884 .funcs = &trace_fn_funcs, 885}; 886 887/* TRACE_CTX an TRACE_WAKE */ 888static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter, 889 char *delim) 890{ 891 struct ctx_switch_entry *field; 892 char comm[TASK_COMM_LEN]; 893 int S, T; 894 895 896 trace_assign_type(field, iter->ent); 897 898 T = task_state_char(field->next_state); 899 S = task_state_char(field->prev_state); 900 trace_find_cmdline(field->next_pid, comm); 901 trace_seq_printf(&iter->seq, 902 " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n", 903 field->prev_pid, 904 field->prev_prio, 905 S, delim, 906 field->next_cpu, 907 field->next_pid, 908 field->next_prio, 909 T, comm); 910 911 return trace_handle_return(&iter->seq); 912} 913 914static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags, 915 struct trace_event *event) 916{ 917 return trace_ctxwake_print(iter, "==>"); 918} 919 920static enum print_line_t trace_wake_print(struct trace_iterator *iter, 921 int flags, struct trace_event *event) 922{ 923 return trace_ctxwake_print(iter, " +"); 924} 925 926static int trace_ctxwake_raw(struct trace_iterator *iter, char S) 927{ 928 struct ctx_switch_entry *field; 929 int T; 930 931 trace_assign_type(field, iter->ent); 932 933 if (!S) 934 S = task_state_char(field->prev_state); 935 T = task_state_char(field->next_state); 936 trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n", 937 field->prev_pid, 938 field->prev_prio, 939 S, 940 field->next_cpu, 941 field->next_pid, 942 field->next_prio, 943 T); 944 945 return trace_handle_return(&iter->seq); 946} 947 948static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags, 949 struct trace_event *event) 950{ 951 return trace_ctxwake_raw(iter, 0); 952} 953 954static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags, 955 struct trace_event *event) 956{ 957 return trace_ctxwake_raw(iter, '+'); 958} 959 960 961static int trace_ctxwake_hex(struct trace_iterator *iter, char S) 962{ 963 struct ctx_switch_entry *field; 964 struct trace_seq *s = &iter->seq; 965 int T; 966 967 trace_assign_type(field, iter->ent); 968 969 if (!S) 970 S = task_state_char(field->prev_state); 971 T = task_state_char(field->next_state); 972 973 SEQ_PUT_HEX_FIELD(s, field->prev_pid); 974 SEQ_PUT_HEX_FIELD(s, field->prev_prio); 975 SEQ_PUT_HEX_FIELD(s, S); 976 SEQ_PUT_HEX_FIELD(s, field->next_cpu); 977 SEQ_PUT_HEX_FIELD(s, field->next_pid); 978 SEQ_PUT_HEX_FIELD(s, field->next_prio); 979 SEQ_PUT_HEX_FIELD(s, T); 980 981 return trace_handle_return(s); 982} 983 984static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags, 985 struct trace_event *event) 986{ 987 return trace_ctxwake_hex(iter, 0); 988} 989 990static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags, 991 struct trace_event *event) 992{ 993 return trace_ctxwake_hex(iter, '+'); 994} 995 996static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter, 997 int flags, struct trace_event *event) 998{ 999 struct ctx_switch_entry *field; 1000 struct trace_seq *s = &iter->seq; 1001 1002 trace_assign_type(field, iter->ent); 1003 1004 SEQ_PUT_FIELD(s, field->prev_pid); 1005 SEQ_PUT_FIELD(s, field->prev_prio); 1006 SEQ_PUT_FIELD(s, field->prev_state); 1007 SEQ_PUT_FIELD(s, field->next_cpu); 1008 SEQ_PUT_FIELD(s, field->next_pid); 1009 SEQ_PUT_FIELD(s, field->next_prio); 1010 SEQ_PUT_FIELD(s, field->next_state); 1011 1012 return trace_handle_return(s); 1013} 1014 1015static struct trace_event_functions trace_ctx_funcs = { 1016 .trace = trace_ctx_print, 1017 .raw = trace_ctx_raw, 1018 .hex = trace_ctx_hex, 1019 .binary = trace_ctxwake_bin, 1020}; 1021 1022static struct trace_event trace_ctx_event = { 1023 .type = TRACE_CTX, 1024 .funcs = &trace_ctx_funcs, 1025}; 1026 1027static struct trace_event_functions trace_wake_funcs = { 1028 .trace = trace_wake_print, 1029 .raw = trace_wake_raw, 1030 .hex = trace_wake_hex, 1031 .binary = trace_ctxwake_bin, 1032}; 1033 1034static struct trace_event trace_wake_event = { 1035 .type = TRACE_WAKE, 1036 .funcs = &trace_wake_funcs, 1037}; 1038 1039/* TRACE_STACK */ 1040 1041static enum print_line_t trace_stack_print(struct trace_iterator *iter, 1042 int flags, struct trace_event *event) 1043{ 1044 struct stack_entry *field; 1045 struct trace_seq *s = &iter->seq; 1046 unsigned long *p; 1047 unsigned long *end; 1048 1049 trace_assign_type(field, iter->ent); 1050 end = (unsigned long *)((long)iter->ent + iter->ent_size); 1051 1052 trace_seq_puts(s, "<stack trace>\n"); 1053 1054 for (p = field->caller; p && *p != ULONG_MAX && p < end; p++) { 1055 1056 if (trace_seq_has_overflowed(s)) 1057 break; 1058 1059 trace_seq_puts(s, " => "); 1060 seq_print_ip_sym(s, *p, flags); 1061 trace_seq_putc(s, '\n'); 1062 } 1063 1064 return trace_handle_return(s); 1065} 1066 1067static struct trace_event_functions trace_stack_funcs = { 1068 .trace = trace_stack_print, 1069}; 1070 1071static struct trace_event trace_stack_event = { 1072 .type = TRACE_STACK, 1073 .funcs = &trace_stack_funcs, 1074}; 1075 1076/* TRACE_USER_STACK */ 1077static enum print_line_t trace_user_stack_print(struct trace_iterator *iter, 1078 int flags, struct trace_event *event) 1079{ 1080 struct userstack_entry *field; 1081 struct trace_seq *s = &iter->seq; 1082 1083 trace_assign_type(field, iter->ent); 1084 1085 trace_seq_puts(s, "<user stack trace>\n"); 1086 seq_print_userip_objs(field, s, flags); 1087 1088 return trace_handle_return(s); 1089} 1090 1091static struct trace_event_functions trace_user_stack_funcs = { 1092 .trace = trace_user_stack_print, 1093}; 1094 1095static struct trace_event trace_user_stack_event = { 1096 .type = TRACE_USER_STACK, 1097 .funcs = &trace_user_stack_funcs, 1098}; 1099 1100/* TRACE_BPUTS */ 1101static enum print_line_t 1102trace_bputs_print(struct trace_iterator *iter, int flags, 1103 struct trace_event *event) 1104{ 1105 struct trace_entry *entry = iter->ent; 1106 struct trace_seq *s = &iter->seq; 1107 struct bputs_entry *field; 1108 1109 trace_assign_type(field, entry); 1110 1111 seq_print_ip_sym(s, field->ip, flags); 1112 trace_seq_puts(s, ": "); 1113 trace_seq_puts(s, field->str); 1114 1115 return trace_handle_return(s); 1116} 1117 1118 1119static enum print_line_t 1120trace_bputs_raw(struct trace_iterator *iter, int flags, 1121 struct trace_event *event) 1122{ 1123 struct bputs_entry *field; 1124 struct trace_seq *s = &iter->seq; 1125 1126 trace_assign_type(field, iter->ent); 1127 1128 trace_seq_printf(s, ": %lx : ", field->ip); 1129 trace_seq_puts(s, field->str); 1130 1131 return trace_handle_return(s); 1132} 1133 1134static struct trace_event_functions trace_bputs_funcs = { 1135 .trace = trace_bputs_print, 1136 .raw = trace_bputs_raw, 1137}; 1138 1139static struct trace_event trace_bputs_event = { 1140 .type = TRACE_BPUTS, 1141 .funcs = &trace_bputs_funcs, 1142}; 1143 1144/* TRACE_BPRINT */ 1145static enum print_line_t 1146trace_bprint_print(struct trace_iterator *iter, int flags, 1147 struct trace_event *event) 1148{ 1149 struct trace_entry *entry = iter->ent; 1150 struct trace_seq *s = &iter->seq; 1151 struct bprint_entry *field; 1152 1153 trace_assign_type(field, entry); 1154 1155 seq_print_ip_sym(s, field->ip, flags); 1156 trace_seq_puts(s, ": "); 1157 trace_seq_bprintf(s, field->fmt, field->buf); 1158 1159 return trace_handle_return(s); 1160} 1161 1162 1163static enum print_line_t 1164trace_bprint_raw(struct trace_iterator *iter, int flags, 1165 struct trace_event *event) 1166{ 1167 struct bprint_entry *field; 1168 struct trace_seq *s = &iter->seq; 1169 1170 trace_assign_type(field, iter->ent); 1171 1172 trace_seq_printf(s, ": %lx : ", field->ip); 1173 trace_seq_bprintf(s, field->fmt, field->buf); 1174 1175 return trace_handle_return(s); 1176} 1177 1178static struct trace_event_functions trace_bprint_funcs = { 1179 .trace = trace_bprint_print, 1180 .raw = trace_bprint_raw, 1181}; 1182 1183static struct trace_event trace_bprint_event = { 1184 .type = TRACE_BPRINT, 1185 .funcs = &trace_bprint_funcs, 1186}; 1187 1188/* TRACE_PRINT */ 1189static enum print_line_t trace_print_print(struct trace_iterator *iter, 1190 int flags, struct trace_event *event) 1191{ 1192 struct print_entry *field; 1193 struct trace_seq *s = &iter->seq; 1194 1195 trace_assign_type(field, iter->ent); 1196 1197 seq_print_ip_sym(s, field->ip, flags); 1198 trace_seq_printf(s, ": %s", field->buf); 1199 1200 return trace_handle_return(s); 1201} 1202 1203static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags, 1204 struct trace_event *event) 1205{ 1206 struct print_entry *field; 1207 1208 trace_assign_type(field, iter->ent); 1209 1210 trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf); 1211 1212 return trace_handle_return(&iter->seq); 1213} 1214 1215static struct trace_event_functions trace_print_funcs = { 1216 .trace = trace_print_print, 1217 .raw = trace_print_raw, 1218}; 1219 1220static struct trace_event trace_print_event = { 1221 .type = TRACE_PRINT, 1222 .funcs = &trace_print_funcs, 1223}; 1224 1225 1226static struct trace_event *events[] __initdata = { 1227 &trace_fn_event, 1228 &trace_ctx_event, 1229 &trace_wake_event, 1230 &trace_stack_event, 1231 &trace_user_stack_event, 1232 &trace_bputs_event, 1233 &trace_bprint_event, 1234 &trace_print_event, 1235 NULL 1236}; 1237 1238__init static int init_events(void) 1239{ 1240 struct trace_event *event; 1241 int i, ret; 1242 1243 for (i = 0; events[i]; i++) { 1244 event = events[i]; 1245 1246 ret = register_ftrace_event(event); 1247 if (!ret) { 1248 printk(KERN_WARNING "event %d failed to register\n", 1249 event->type); 1250 WARN_ON_ONCE(1); 1251 } 1252 } 1253 1254 return 0; 1255} 1256early_initcall(init_events); 1257