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