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 * 63trace_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(trace_print_flags_seq); 99 100const char * 101trace_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(trace_print_symbols_seq); 124 125#if BITS_PER_LONG == 32 126const char * 127trace_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(trace_print_symbols_seq_u64); 150#endif 151 152const char * 153trace_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(trace_print_bitmask_seq); 164 165const char * 166trace_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(trace_print_hex_seq); 179 180const char * 181trace_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(trace_print_array_seq); 224 225int trace_raw_output_prep(struct trace_iterator *iter, 226 struct trace_event *trace_event) 227{ 228 struct trace_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 trace_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: ", trace_event_name(event)); 243 244 return trace_handle_return(s); 245} 246EXPORT_SYMBOL(trace_raw_output_prep); 247 248static int trace_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 trace_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 = trace_output_raw(iter, name, fmt, ap); 266 va_end(ap); 267 268 return ret; 269} 270EXPORT_SYMBOL_GPL(trace_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 325static int 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_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags) 359{ 360 if (!ip) { 361 trace_seq_putc(s, '0'); 362 goto out; 363 } 364 365 if (sym_flags & TRACE_ITER_SYM_OFFSET) 366 seq_print_sym_offset(s, "%s", ip); 367 else 368 seq_print_sym_short(s, "%s", ip); 369 370 if (sym_flags & TRACE_ITER_SYM_ADDR) 371 trace_seq_printf(s, " <" IP_FMT ">", ip); 372 373 out: 374 return !trace_seq_has_overflowed(s); 375} 376 377/** 378 * trace_print_lat_fmt - print the irq, preempt and lockdep fields 379 * @s: trace seq struct to write to 380 * @entry: The trace entry field from the ring buffer 381 * 382 * Prints the generic fields of irqs off, in hard or softirq, preempt 383 * count. 384 */ 385int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry) 386{ 387 char hardsoft_irq; 388 char need_resched; 389 char irqs_off; 390 int hardirq; 391 int softirq; 392 393 hardirq = entry->flags & TRACE_FLAG_HARDIRQ; 394 softirq = entry->flags & TRACE_FLAG_SOFTIRQ; 395 396 irqs_off = 397 (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : 398 (entry->flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 'X' : 399 '.'; 400 401 switch (entry->flags & (TRACE_FLAG_NEED_RESCHED | 402 TRACE_FLAG_PREEMPT_RESCHED)) { 403 case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED: 404 need_resched = 'N'; 405 break; 406 case TRACE_FLAG_NEED_RESCHED: 407 need_resched = 'n'; 408 break; 409 case TRACE_FLAG_PREEMPT_RESCHED: 410 need_resched = 'p'; 411 break; 412 default: 413 need_resched = '.'; 414 break; 415 } 416 417 hardsoft_irq = 418 (hardirq && softirq) ? 'H' : 419 hardirq ? 'h' : 420 softirq ? 's' : 421 '.'; 422 423 trace_seq_printf(s, "%c%c%c", 424 irqs_off, need_resched, hardsoft_irq); 425 426 if (entry->preempt_count) 427 trace_seq_printf(s, "%x", entry->preempt_count); 428 else 429 trace_seq_putc(s, '.'); 430 431 return !trace_seq_has_overflowed(s); 432} 433 434static int 435lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu) 436{ 437 char comm[TASK_COMM_LEN]; 438 439 trace_find_cmdline(entry->pid, comm); 440 441 trace_seq_printf(s, "%8.8s-%-5d %3d", 442 comm, entry->pid, cpu); 443 444 return trace_print_lat_fmt(s, entry); 445} 446 447#undef MARK 448#define MARK(v, s) {.val = v, .sym = s} 449/* trace overhead mark */ 450static const struct trace_mark { 451 unsigned long long val; /* unit: nsec */ 452 char sym; 453} mark[] = { 454 MARK(1000000000ULL , '$'), /* 1 sec */ 455 MARK(100000000ULL , '@'), /* 100 msec */ 456 MARK(10000000ULL , '*'), /* 10 msec */ 457 MARK(1000000ULL , '#'), /* 1000 usecs */ 458 MARK(100000ULL , '!'), /* 100 usecs */ 459 MARK(10000ULL , '+'), /* 10 usecs */ 460}; 461#undef MARK 462 463char trace_find_mark(unsigned long long d) 464{ 465 int i; 466 int size = ARRAY_SIZE(mark); 467 468 for (i = 0; i < size; i++) { 469 if (d > mark[i].val) 470 break; 471 } 472 473 return (i == size) ? ' ' : mark[i].sym; 474} 475 476static int 477lat_print_timestamp(struct trace_iterator *iter, u64 next_ts) 478{ 479 struct trace_array *tr = iter->tr; 480 unsigned long verbose = tr->trace_flags & TRACE_ITER_VERBOSE; 481 unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS; 482 unsigned long long abs_ts = iter->ts - iter->trace_buffer->time_start; 483 unsigned long long rel_ts = next_ts - iter->ts; 484 struct trace_seq *s = &iter->seq; 485 486 if (in_ns) { 487 abs_ts = ns2usecs(abs_ts); 488 rel_ts = ns2usecs(rel_ts); 489 } 490 491 if (verbose && in_ns) { 492 unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC); 493 unsigned long abs_msec = (unsigned long)abs_ts; 494 unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC); 495 unsigned long rel_msec = (unsigned long)rel_ts; 496 497 trace_seq_printf( 498 s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ", 499 ns2usecs(iter->ts), 500 abs_msec, abs_usec, 501 rel_msec, rel_usec); 502 503 } else if (verbose && !in_ns) { 504 trace_seq_printf( 505 s, "[%016llx] %lld (+%lld): ", 506 iter->ts, abs_ts, rel_ts); 507 508 } else if (!verbose && in_ns) { 509 trace_seq_printf( 510 s, " %4lldus%c: ", 511 abs_ts, 512 trace_find_mark(rel_ts * NSEC_PER_USEC)); 513 514 } else { /* !verbose && !in_ns */ 515 trace_seq_printf(s, " %4lld: ", abs_ts); 516 } 517 518 return !trace_seq_has_overflowed(s); 519} 520 521int trace_print_context(struct trace_iterator *iter) 522{ 523 struct trace_array *tr = iter->tr; 524 struct trace_seq *s = &iter->seq; 525 struct trace_entry *entry = iter->ent; 526 unsigned long long t; 527 unsigned long secs, usec_rem; 528 char comm[TASK_COMM_LEN]; 529 530 trace_find_cmdline(entry->pid, comm); 531 532 trace_seq_printf(s, "%16s-%-5d [%03d] ", 533 comm, entry->pid, iter->cpu); 534 535 if (tr->trace_flags & TRACE_ITER_IRQ_INFO) 536 trace_print_lat_fmt(s, entry); 537 538 if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) { 539 t = ns2usecs(iter->ts); 540 usec_rem = do_div(t, USEC_PER_SEC); 541 secs = (unsigned long)t; 542 trace_seq_printf(s, " %5lu.%06lu: ", secs, usec_rem); 543 } else 544 trace_seq_printf(s, " %12llu: ", iter->ts); 545 546 return !trace_seq_has_overflowed(s); 547} 548 549int trace_print_lat_context(struct trace_iterator *iter) 550{ 551 struct trace_array *tr = iter->tr; 552 /* trace_find_next_entry will reset ent_size */ 553 int ent_size = iter->ent_size; 554 struct trace_seq *s = &iter->seq; 555 u64 next_ts; 556 struct trace_entry *entry = iter->ent, 557 *next_entry = trace_find_next_entry(iter, NULL, 558 &next_ts); 559 unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE); 560 561 /* Restore the original ent_size */ 562 iter->ent_size = ent_size; 563 564 if (!next_entry) 565 next_ts = iter->ts; 566 567 if (verbose) { 568 char comm[TASK_COMM_LEN]; 569 570 trace_find_cmdline(entry->pid, comm); 571 572 trace_seq_printf( 573 s, "%16s %5d %3d %d %08x %08lx ", 574 comm, entry->pid, iter->cpu, entry->flags, 575 entry->preempt_count, iter->idx); 576 } else { 577 lat_print_generic(s, entry, iter->cpu); 578 } 579 580 lat_print_timestamp(iter, next_ts); 581 582 return !trace_seq_has_overflowed(s); 583} 584 585static const char state_to_char[] = TASK_STATE_TO_CHAR_STR; 586 587static int task_state_char(unsigned long state) 588{ 589 int bit = state ? __ffs(state) + 1 : 0; 590 591 return bit < sizeof(state_to_char) - 1 ? state_to_char[bit] : '?'; 592} 593 594/** 595 * ftrace_find_event - find a registered event 596 * @type: the type of event to look for 597 * 598 * Returns an event of type @type otherwise NULL 599 * Called with trace_event_read_lock() held. 600 */ 601struct trace_event *ftrace_find_event(int type) 602{ 603 struct trace_event *event; 604 unsigned key; 605 606 key = type & (EVENT_HASHSIZE - 1); 607 608 hlist_for_each_entry(event, &event_hash[key], node) { 609 if (event->type == type) 610 return event; 611 } 612 613 return NULL; 614} 615 616static LIST_HEAD(ftrace_event_list); 617 618static int trace_search_list(struct list_head **list) 619{ 620 struct trace_event *e; 621 int last = __TRACE_LAST_TYPE; 622 623 if (list_empty(&ftrace_event_list)) { 624 *list = &ftrace_event_list; 625 return last + 1; 626 } 627 628 /* 629 * We used up all possible max events, 630 * lets see if somebody freed one. 631 */ 632 list_for_each_entry(e, &ftrace_event_list, list) { 633 if (e->type != last + 1) 634 break; 635 last++; 636 } 637 638 /* Did we used up all 65 thousand events??? */ 639 if ((last + 1) > TRACE_EVENT_TYPE_MAX) 640 return 0; 641 642 *list = &e->list; 643 return last + 1; 644} 645 646void trace_event_read_lock(void) 647{ 648 down_read(&trace_event_sem); 649} 650 651void trace_event_read_unlock(void) 652{ 653 up_read(&trace_event_sem); 654} 655 656/** 657 * register_trace_event - register output for an event type 658 * @event: the event type to register 659 * 660 * Event types are stored in a hash and this hash is used to 661 * find a way to print an event. If the @event->type is set 662 * then it will use that type, otherwise it will assign a 663 * type to use. 664 * 665 * If you assign your own type, please make sure it is added 666 * to the trace_type enum in trace.h, to avoid collisions 667 * with the dynamic types. 668 * 669 * Returns the event type number or zero on error. 670 */ 671int register_trace_event(struct trace_event *event) 672{ 673 unsigned key; 674 int ret = 0; 675 676 down_write(&trace_event_sem); 677 678 if (WARN_ON(!event)) 679 goto out; 680 681 if (WARN_ON(!event->funcs)) 682 goto out; 683 684 INIT_LIST_HEAD(&event->list); 685 686 if (!event->type) { 687 struct list_head *list = NULL; 688 689 if (next_event_type > TRACE_EVENT_TYPE_MAX) { 690 691 event->type = trace_search_list(&list); 692 if (!event->type) 693 goto out; 694 695 } else { 696 697 event->type = next_event_type++; 698 list = &ftrace_event_list; 699 } 700 701 if (WARN_ON(ftrace_find_event(event->type))) 702 goto out; 703 704 list_add_tail(&event->list, list); 705 706 } else if (event->type > __TRACE_LAST_TYPE) { 707 printk(KERN_WARNING "Need to add type to trace.h\n"); 708 WARN_ON(1); 709 goto out; 710 } else { 711 /* Is this event already used */ 712 if (ftrace_find_event(event->type)) 713 goto out; 714 } 715 716 if (event->funcs->trace == NULL) 717 event->funcs->trace = trace_nop_print; 718 if (event->funcs->raw == NULL) 719 event->funcs->raw = trace_nop_print; 720 if (event->funcs->hex == NULL) 721 event->funcs->hex = trace_nop_print; 722 if (event->funcs->binary == NULL) 723 event->funcs->binary = trace_nop_print; 724 725 key = event->type & (EVENT_HASHSIZE - 1); 726 727 hlist_add_head(&event->node, &event_hash[key]); 728 729 ret = event->type; 730 out: 731 up_write(&trace_event_sem); 732 733 return ret; 734} 735EXPORT_SYMBOL_GPL(register_trace_event); 736 737/* 738 * Used by module code with the trace_event_sem held for write. 739 */ 740int __unregister_trace_event(struct trace_event *event) 741{ 742 hlist_del(&event->node); 743 list_del(&event->list); 744 return 0; 745} 746 747/** 748 * unregister_trace_event - remove a no longer used event 749 * @event: the event to remove 750 */ 751int unregister_trace_event(struct trace_event *event) 752{ 753 down_write(&trace_event_sem); 754 __unregister_trace_event(event); 755 up_write(&trace_event_sem); 756 757 return 0; 758} 759EXPORT_SYMBOL_GPL(unregister_trace_event); 760 761/* 762 * Standard events 763 */ 764 765enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags, 766 struct trace_event *event) 767{ 768 trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type); 769 770 return trace_handle_return(&iter->seq); 771} 772 773/* TRACE_FN */ 774static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags, 775 struct trace_event *event) 776{ 777 struct ftrace_entry *field; 778 struct trace_seq *s = &iter->seq; 779 780 trace_assign_type(field, iter->ent); 781 782 seq_print_ip_sym(s, field->ip, flags); 783 784 if ((flags & TRACE_ITER_PRINT_PARENT) && field->parent_ip) { 785 trace_seq_puts(s, " <-"); 786 seq_print_ip_sym(s, field->parent_ip, flags); 787 } 788 789 trace_seq_putc(s, '\n'); 790 791 return trace_handle_return(s); 792} 793 794static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags, 795 struct trace_event *event) 796{ 797 struct ftrace_entry *field; 798 799 trace_assign_type(field, iter->ent); 800 801 trace_seq_printf(&iter->seq, "%lx %lx\n", 802 field->ip, 803 field->parent_ip); 804 805 return trace_handle_return(&iter->seq); 806} 807 808static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags, 809 struct trace_event *event) 810{ 811 struct ftrace_entry *field; 812 struct trace_seq *s = &iter->seq; 813 814 trace_assign_type(field, iter->ent); 815 816 SEQ_PUT_HEX_FIELD(s, field->ip); 817 SEQ_PUT_HEX_FIELD(s, field->parent_ip); 818 819 return trace_handle_return(s); 820} 821 822static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags, 823 struct trace_event *event) 824{ 825 struct ftrace_entry *field; 826 struct trace_seq *s = &iter->seq; 827 828 trace_assign_type(field, iter->ent); 829 830 SEQ_PUT_FIELD(s, field->ip); 831 SEQ_PUT_FIELD(s, field->parent_ip); 832 833 return trace_handle_return(s); 834} 835 836static struct trace_event_functions trace_fn_funcs = { 837 .trace = trace_fn_trace, 838 .raw = trace_fn_raw, 839 .hex = trace_fn_hex, 840 .binary = trace_fn_bin, 841}; 842 843static struct trace_event trace_fn_event = { 844 .type = TRACE_FN, 845 .funcs = &trace_fn_funcs, 846}; 847 848/* TRACE_CTX an TRACE_WAKE */ 849static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter, 850 char *delim) 851{ 852 struct ctx_switch_entry *field; 853 char comm[TASK_COMM_LEN]; 854 int S, T; 855 856 857 trace_assign_type(field, iter->ent); 858 859 T = task_state_char(field->next_state); 860 S = task_state_char(field->prev_state); 861 trace_find_cmdline(field->next_pid, comm); 862 trace_seq_printf(&iter->seq, 863 " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n", 864 field->prev_pid, 865 field->prev_prio, 866 S, delim, 867 field->next_cpu, 868 field->next_pid, 869 field->next_prio, 870 T, comm); 871 872 return trace_handle_return(&iter->seq); 873} 874 875static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags, 876 struct trace_event *event) 877{ 878 return trace_ctxwake_print(iter, "==>"); 879} 880 881static enum print_line_t trace_wake_print(struct trace_iterator *iter, 882 int flags, struct trace_event *event) 883{ 884 return trace_ctxwake_print(iter, " +"); 885} 886 887static int trace_ctxwake_raw(struct trace_iterator *iter, char S) 888{ 889 struct ctx_switch_entry *field; 890 int T; 891 892 trace_assign_type(field, iter->ent); 893 894 if (!S) 895 S = task_state_char(field->prev_state); 896 T = task_state_char(field->next_state); 897 trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n", 898 field->prev_pid, 899 field->prev_prio, 900 S, 901 field->next_cpu, 902 field->next_pid, 903 field->next_prio, 904 T); 905 906 return trace_handle_return(&iter->seq); 907} 908 909static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags, 910 struct trace_event *event) 911{ 912 return trace_ctxwake_raw(iter, 0); 913} 914 915static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags, 916 struct trace_event *event) 917{ 918 return trace_ctxwake_raw(iter, '+'); 919} 920 921 922static int trace_ctxwake_hex(struct trace_iterator *iter, char S) 923{ 924 struct ctx_switch_entry *field; 925 struct trace_seq *s = &iter->seq; 926 int T; 927 928 trace_assign_type(field, iter->ent); 929 930 if (!S) 931 S = task_state_char(field->prev_state); 932 T = task_state_char(field->next_state); 933 934 SEQ_PUT_HEX_FIELD(s, field->prev_pid); 935 SEQ_PUT_HEX_FIELD(s, field->prev_prio); 936 SEQ_PUT_HEX_FIELD(s, S); 937 SEQ_PUT_HEX_FIELD(s, field->next_cpu); 938 SEQ_PUT_HEX_FIELD(s, field->next_pid); 939 SEQ_PUT_HEX_FIELD(s, field->next_prio); 940 SEQ_PUT_HEX_FIELD(s, T); 941 942 return trace_handle_return(s); 943} 944 945static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags, 946 struct trace_event *event) 947{ 948 return trace_ctxwake_hex(iter, 0); 949} 950 951static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags, 952 struct trace_event *event) 953{ 954 return trace_ctxwake_hex(iter, '+'); 955} 956 957static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter, 958 int flags, struct trace_event *event) 959{ 960 struct ctx_switch_entry *field; 961 struct trace_seq *s = &iter->seq; 962 963 trace_assign_type(field, iter->ent); 964 965 SEQ_PUT_FIELD(s, field->prev_pid); 966 SEQ_PUT_FIELD(s, field->prev_prio); 967 SEQ_PUT_FIELD(s, field->prev_state); 968 SEQ_PUT_FIELD(s, field->next_cpu); 969 SEQ_PUT_FIELD(s, field->next_pid); 970 SEQ_PUT_FIELD(s, field->next_prio); 971 SEQ_PUT_FIELD(s, field->next_state); 972 973 return trace_handle_return(s); 974} 975 976static struct trace_event_functions trace_ctx_funcs = { 977 .trace = trace_ctx_print, 978 .raw = trace_ctx_raw, 979 .hex = trace_ctx_hex, 980 .binary = trace_ctxwake_bin, 981}; 982 983static struct trace_event trace_ctx_event = { 984 .type = TRACE_CTX, 985 .funcs = &trace_ctx_funcs, 986}; 987 988static struct trace_event_functions trace_wake_funcs = { 989 .trace = trace_wake_print, 990 .raw = trace_wake_raw, 991 .hex = trace_wake_hex, 992 .binary = trace_ctxwake_bin, 993}; 994 995static struct trace_event trace_wake_event = { 996 .type = TRACE_WAKE, 997 .funcs = &trace_wake_funcs, 998}; 999 1000/* TRACE_STACK */ 1001 1002static enum print_line_t trace_stack_print(struct trace_iterator *iter, 1003 int flags, struct trace_event *event) 1004{ 1005 struct stack_entry *field; 1006 struct trace_seq *s = &iter->seq; 1007 unsigned long *p; 1008 unsigned long *end; 1009 1010 trace_assign_type(field, iter->ent); 1011 end = (unsigned long *)((long)iter->ent + iter->ent_size); 1012 1013 trace_seq_puts(s, "<stack trace>\n"); 1014 1015 for (p = field->caller; p && *p != ULONG_MAX && p < end; p++) { 1016 1017 if (trace_seq_has_overflowed(s)) 1018 break; 1019 1020 trace_seq_puts(s, " => "); 1021 seq_print_ip_sym(s, *p, flags); 1022 trace_seq_putc(s, '\n'); 1023 } 1024 1025 return trace_handle_return(s); 1026} 1027 1028static struct trace_event_functions trace_stack_funcs = { 1029 .trace = trace_stack_print, 1030}; 1031 1032static struct trace_event trace_stack_event = { 1033 .type = TRACE_STACK, 1034 .funcs = &trace_stack_funcs, 1035}; 1036 1037/* TRACE_USER_STACK */ 1038static enum print_line_t trace_user_stack_print(struct trace_iterator *iter, 1039 int flags, struct trace_event *event) 1040{ 1041 struct trace_array *tr = iter->tr; 1042 struct userstack_entry *field; 1043 struct trace_seq *s = &iter->seq; 1044 struct mm_struct *mm = NULL; 1045 unsigned int i; 1046 1047 trace_assign_type(field, iter->ent); 1048 1049 trace_seq_puts(s, "<user stack trace>\n"); 1050 1051 if (tr->trace_flags & TRACE_ITER_SYM_USEROBJ) { 1052 struct task_struct *task; 1053 /* 1054 * we do the lookup on the thread group leader, 1055 * since individual threads might have already quit! 1056 */ 1057 rcu_read_lock(); 1058 task = find_task_by_vpid(field->tgid); 1059 if (task) 1060 mm = get_task_mm(task); 1061 rcu_read_unlock(); 1062 } 1063 1064 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) { 1065 unsigned long ip = field->caller[i]; 1066 1067 if (ip == ULONG_MAX || trace_seq_has_overflowed(s)) 1068 break; 1069 1070 trace_seq_puts(s, " => "); 1071 1072 if (!ip) { 1073 trace_seq_puts(s, "??"); 1074 trace_seq_putc(s, '\n'); 1075 continue; 1076 } 1077 1078 seq_print_user_ip(s, mm, ip, flags); 1079 trace_seq_putc(s, '\n'); 1080 } 1081 1082 if (mm) 1083 mmput(mm); 1084 1085 return trace_handle_return(s); 1086} 1087 1088static struct trace_event_functions trace_user_stack_funcs = { 1089 .trace = trace_user_stack_print, 1090}; 1091 1092static struct trace_event trace_user_stack_event = { 1093 .type = TRACE_USER_STACK, 1094 .funcs = &trace_user_stack_funcs, 1095}; 1096 1097/* TRACE_BPUTS */ 1098static enum print_line_t 1099trace_bputs_print(struct trace_iterator *iter, int flags, 1100 struct trace_event *event) 1101{ 1102 struct trace_entry *entry = iter->ent; 1103 struct trace_seq *s = &iter->seq; 1104 struct bputs_entry *field; 1105 1106 trace_assign_type(field, entry); 1107 1108 seq_print_ip_sym(s, field->ip, flags); 1109 trace_seq_puts(s, ": "); 1110 trace_seq_puts(s, field->str); 1111 1112 return trace_handle_return(s); 1113} 1114 1115 1116static enum print_line_t 1117trace_bputs_raw(struct trace_iterator *iter, int flags, 1118 struct trace_event *event) 1119{ 1120 struct bputs_entry *field; 1121 struct trace_seq *s = &iter->seq; 1122 1123 trace_assign_type(field, iter->ent); 1124 1125 trace_seq_printf(s, ": %lx : ", field->ip); 1126 trace_seq_puts(s, field->str); 1127 1128 return trace_handle_return(s); 1129} 1130 1131static struct trace_event_functions trace_bputs_funcs = { 1132 .trace = trace_bputs_print, 1133 .raw = trace_bputs_raw, 1134}; 1135 1136static struct trace_event trace_bputs_event = { 1137 .type = TRACE_BPUTS, 1138 .funcs = &trace_bputs_funcs, 1139}; 1140 1141/* TRACE_BPRINT */ 1142static enum print_line_t 1143trace_bprint_print(struct trace_iterator *iter, int flags, 1144 struct trace_event *event) 1145{ 1146 struct trace_entry *entry = iter->ent; 1147 struct trace_seq *s = &iter->seq; 1148 struct bprint_entry *field; 1149 1150 trace_assign_type(field, entry); 1151 1152 seq_print_ip_sym(s, field->ip, flags); 1153 trace_seq_puts(s, ": "); 1154 trace_seq_bprintf(s, field->fmt, field->buf); 1155 1156 return trace_handle_return(s); 1157} 1158 1159 1160static enum print_line_t 1161trace_bprint_raw(struct trace_iterator *iter, int flags, 1162 struct trace_event *event) 1163{ 1164 struct bprint_entry *field; 1165 struct trace_seq *s = &iter->seq; 1166 1167 trace_assign_type(field, iter->ent); 1168 1169 trace_seq_printf(s, ": %lx : ", field->ip); 1170 trace_seq_bprintf(s, field->fmt, field->buf); 1171 1172 return trace_handle_return(s); 1173} 1174 1175static struct trace_event_functions trace_bprint_funcs = { 1176 .trace = trace_bprint_print, 1177 .raw = trace_bprint_raw, 1178}; 1179 1180static struct trace_event trace_bprint_event = { 1181 .type = TRACE_BPRINT, 1182 .funcs = &trace_bprint_funcs, 1183}; 1184 1185/* TRACE_PRINT */ 1186static enum print_line_t trace_print_print(struct trace_iterator *iter, 1187 int flags, struct trace_event *event) 1188{ 1189 struct print_entry *field; 1190 struct trace_seq *s = &iter->seq; 1191 1192 trace_assign_type(field, iter->ent); 1193 1194 seq_print_ip_sym(s, field->ip, flags); 1195 trace_seq_printf(s, ": %s", field->buf); 1196 1197 return trace_handle_return(s); 1198} 1199 1200static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags, 1201 struct trace_event *event) 1202{ 1203 struct print_entry *field; 1204 1205 trace_assign_type(field, iter->ent); 1206 1207 trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf); 1208 1209 return trace_handle_return(&iter->seq); 1210} 1211 1212static struct trace_event_functions trace_print_funcs = { 1213 .trace = trace_print_print, 1214 .raw = trace_print_raw, 1215}; 1216 1217static struct trace_event trace_print_event = { 1218 .type = TRACE_PRINT, 1219 .funcs = &trace_print_funcs, 1220}; 1221 1222 1223static struct trace_event *events[] __initdata = { 1224 &trace_fn_event, 1225 &trace_ctx_event, 1226 &trace_wake_event, 1227 &trace_stack_event, 1228 &trace_user_stack_event, 1229 &trace_bputs_event, 1230 &trace_bprint_event, 1231 &trace_print_event, 1232 NULL 1233}; 1234 1235__init static int init_events(void) 1236{ 1237 struct trace_event *event; 1238 int i, ret; 1239 1240 for (i = 0; events[i]; i++) { 1241 event = events[i]; 1242 1243 ret = register_trace_event(event); 1244 if (!ret) { 1245 printk(KERN_WARNING "event %d failed to register\n", 1246 event->type); 1247 WARN_ON_ONCE(1); 1248 } 1249 } 1250 1251 return 0; 1252} 1253early_initcall(init_events); 1254