1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * trace_output.c 4 * 5 * Copyright (C) 2008 Red Hat Inc, Steven Rostedt <srostedt@redhat.com> 6 * 7 */ 8 #include <linux/module.h> 9 #include <linux/mutex.h> 10 #include <linux/ftrace.h> 11 #include <linux/kprobes.h> 12 #include <linux/sched/clock.h> 13 #include <linux/sched/mm.h> 14 #include <linux/idr.h> 15 16 #include "trace_output.h" 17 18 /* must be a power of 2 */ 19 #define EVENT_HASHSIZE 128 20 21 DECLARE_RWSEM(trace_event_sem); 22 23 static struct hlist_head event_hash[EVENT_HASHSIZE] __read_mostly; 24 25 enum print_line_t trace_print_bputs_msg_only(struct trace_iterator *iter) 26 { 27 struct trace_seq *s = &iter->seq; 28 struct trace_entry *entry = iter->ent; 29 struct bputs_entry *field; 30 31 trace_assign_type(field, entry); 32 33 trace_seq_puts(s, field->str); 34 35 return trace_handle_return(s); 36 } 37 38 enum print_line_t trace_print_bprintk_msg_only(struct trace_iterator *iter) 39 { 40 struct trace_seq *s = &iter->seq; 41 struct trace_entry *entry = iter->ent; 42 struct bprint_entry *field; 43 44 trace_assign_type(field, entry); 45 46 trace_seq_bprintf(s, field->fmt, field->buf); 47 48 return trace_handle_return(s); 49 } 50 51 enum print_line_t trace_print_printk_msg_only(struct trace_iterator *iter) 52 { 53 struct trace_seq *s = &iter->seq; 54 struct trace_entry *entry = iter->ent; 55 struct print_entry *field; 56 57 trace_assign_type(field, entry); 58 59 trace_seq_puts(s, field->buf); 60 61 return trace_handle_return(s); 62 } 63 64 const char * 65 trace_print_flags_seq(struct trace_seq *p, const char *delim, 66 unsigned long flags, 67 const struct trace_print_flags *flag_array) 68 { 69 unsigned long mask; 70 const char *str; 71 const char *ret = trace_seq_buffer_ptr(p); 72 int i, first = 1; 73 74 for (i = 0; flag_array[i].name && flags; i++) { 75 76 mask = flag_array[i].mask; 77 if ((flags & mask) != mask) 78 continue; 79 80 str = flag_array[i].name; 81 flags &= ~mask; 82 if (!first && delim) 83 trace_seq_puts(p, delim); 84 else 85 first = 0; 86 trace_seq_puts(p, str); 87 } 88 89 /* check for left over flags */ 90 if (flags) { 91 if (!first && delim) 92 trace_seq_puts(p, delim); 93 trace_seq_printf(p, "0x%lx", flags); 94 } 95 96 trace_seq_putc(p, 0); 97 98 return ret; 99 } 100 EXPORT_SYMBOL(trace_print_flags_seq); 101 102 const char * 103 trace_print_symbols_seq(struct trace_seq *p, unsigned long val, 104 const struct trace_print_flags *symbol_array) 105 { 106 int i; 107 const char *ret = trace_seq_buffer_ptr(p); 108 109 for (i = 0; symbol_array[i].name; i++) { 110 111 if (val != symbol_array[i].mask) 112 continue; 113 114 trace_seq_puts(p, symbol_array[i].name); 115 break; 116 } 117 118 if (ret == (const char *)(trace_seq_buffer_ptr(p))) 119 trace_seq_printf(p, "0x%lx", val); 120 121 trace_seq_putc(p, 0); 122 123 return ret; 124 } 125 EXPORT_SYMBOL(trace_print_symbols_seq); 126 127 #if BITS_PER_LONG == 32 128 const char * 129 trace_print_flags_seq_u64(struct trace_seq *p, const char *delim, 130 unsigned long long flags, 131 const struct trace_print_flags_u64 *flag_array) 132 { 133 unsigned long long mask; 134 const char *str; 135 const char *ret = trace_seq_buffer_ptr(p); 136 int i, first = 1; 137 138 for (i = 0; flag_array[i].name && flags; i++) { 139 140 mask = flag_array[i].mask; 141 if ((flags & mask) != mask) 142 continue; 143 144 str = flag_array[i].name; 145 flags &= ~mask; 146 if (!first && delim) 147 trace_seq_puts(p, delim); 148 else 149 first = 0; 150 trace_seq_puts(p, str); 151 } 152 153 /* check for left over flags */ 154 if (flags) { 155 if (!first && delim) 156 trace_seq_puts(p, delim); 157 trace_seq_printf(p, "0x%llx", flags); 158 } 159 160 trace_seq_putc(p, 0); 161 162 return ret; 163 } 164 EXPORT_SYMBOL(trace_print_flags_seq_u64); 165 166 const char * 167 trace_print_symbols_seq_u64(struct trace_seq *p, unsigned long long val, 168 const struct trace_print_flags_u64 *symbol_array) 169 { 170 int i; 171 const char *ret = trace_seq_buffer_ptr(p); 172 173 for (i = 0; symbol_array[i].name; i++) { 174 175 if (val != symbol_array[i].mask) 176 continue; 177 178 trace_seq_puts(p, symbol_array[i].name); 179 break; 180 } 181 182 if (ret == (const char *)(trace_seq_buffer_ptr(p))) 183 trace_seq_printf(p, "0x%llx", val); 184 185 trace_seq_putc(p, 0); 186 187 return ret; 188 } 189 EXPORT_SYMBOL(trace_print_symbols_seq_u64); 190 #endif 191 192 const char * 193 trace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr, 194 unsigned int bitmask_size) 195 { 196 const char *ret = trace_seq_buffer_ptr(p); 197 198 trace_seq_bitmask(p, bitmask_ptr, bitmask_size * 8); 199 trace_seq_putc(p, 0); 200 201 return ret; 202 } 203 EXPORT_SYMBOL_GPL(trace_print_bitmask_seq); 204 205 /** 206 * trace_print_hex_seq - print buffer as hex sequence 207 * @p: trace seq struct to write to 208 * @buf: The buffer to print 209 * @buf_len: Length of @buf in bytes 210 * @concatenate: Print @buf as single hex string or with spacing 211 * 212 * Prints the passed buffer as a hex sequence either as a whole, 213 * single hex string if @concatenate is true or with spacing after 214 * each byte in case @concatenate is false. 215 */ 216 const char * 217 trace_print_hex_seq(struct trace_seq *p, const unsigned char *buf, int buf_len, 218 bool concatenate) 219 { 220 int i; 221 const char *ret = trace_seq_buffer_ptr(p); 222 const char *fmt = concatenate ? "%*phN" : "%*ph"; 223 224 for (i = 0; i < buf_len; i += 16) { 225 if (!concatenate && i != 0) 226 trace_seq_putc(p, ' '); 227 trace_seq_printf(p, fmt, min(buf_len - i, 16), &buf[i]); 228 } 229 trace_seq_putc(p, 0); 230 231 return ret; 232 } 233 EXPORT_SYMBOL(trace_print_hex_seq); 234 235 const char * 236 trace_print_array_seq(struct trace_seq *p, const void *buf, int count, 237 size_t el_size) 238 { 239 const char *ret = trace_seq_buffer_ptr(p); 240 const char *prefix = ""; 241 void *ptr = (void *)buf; 242 size_t buf_len = count * el_size; 243 244 trace_seq_putc(p, '{'); 245 246 while (ptr < buf + buf_len) { 247 switch (el_size) { 248 case 1: 249 trace_seq_printf(p, "%s0x%x", prefix, 250 *(u8 *)ptr); 251 break; 252 case 2: 253 trace_seq_printf(p, "%s0x%x", prefix, 254 *(u16 *)ptr); 255 break; 256 case 4: 257 trace_seq_printf(p, "%s0x%x", prefix, 258 *(u32 *)ptr); 259 break; 260 case 8: 261 trace_seq_printf(p, "%s0x%llx", prefix, 262 *(u64 *)ptr); 263 break; 264 default: 265 trace_seq_printf(p, "BAD SIZE:%zu 0x%x", el_size, 266 *(u8 *)ptr); 267 el_size = 1; 268 } 269 prefix = ","; 270 ptr += el_size; 271 } 272 273 trace_seq_putc(p, '}'); 274 trace_seq_putc(p, 0); 275 276 return ret; 277 } 278 EXPORT_SYMBOL(trace_print_array_seq); 279 280 const char * 281 trace_print_hex_dump_seq(struct trace_seq *p, const char *prefix_str, 282 int prefix_type, int rowsize, int groupsize, 283 const void *buf, size_t len, bool ascii) 284 { 285 const char *ret = trace_seq_buffer_ptr(p); 286 287 trace_seq_putc(p, '\n'); 288 trace_seq_hex_dump(p, prefix_str, prefix_type, 289 rowsize, groupsize, buf, len, ascii); 290 trace_seq_putc(p, 0); 291 return ret; 292 } 293 EXPORT_SYMBOL(trace_print_hex_dump_seq); 294 295 int trace_raw_output_prep(struct trace_iterator *iter, 296 struct trace_event *trace_event) 297 { 298 struct trace_event_call *event; 299 struct trace_seq *s = &iter->seq; 300 struct trace_seq *p = &iter->tmp_seq; 301 struct trace_entry *entry; 302 303 event = container_of(trace_event, struct trace_event_call, event); 304 entry = iter->ent; 305 306 if (entry->type != event->event.type) { 307 WARN_ON_ONCE(1); 308 return TRACE_TYPE_UNHANDLED; 309 } 310 311 trace_seq_init(p); 312 trace_seq_printf(s, "%s: ", trace_event_name(event)); 313 314 return trace_handle_return(s); 315 } 316 EXPORT_SYMBOL(trace_raw_output_prep); 317 318 void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...) 319 { 320 struct trace_seq *s = &iter->seq; 321 va_list ap; 322 323 if (ignore_event(iter)) 324 return; 325 326 va_start(ap, fmt); 327 trace_seq_vprintf(s, trace_event_format(iter, fmt), ap); 328 va_end(ap); 329 } 330 EXPORT_SYMBOL(trace_event_printf); 331 332 static __printf(3, 0) 333 int trace_output_raw(struct trace_iterator *iter, char *name, 334 char *fmt, va_list ap) 335 { 336 struct trace_seq *s = &iter->seq; 337 338 trace_seq_printf(s, "%s: ", name); 339 trace_seq_vprintf(s, trace_event_format(iter, fmt), ap); 340 341 return trace_handle_return(s); 342 } 343 344 int trace_output_call(struct trace_iterator *iter, char *name, char *fmt, ...) 345 { 346 va_list ap; 347 int ret; 348 349 va_start(ap, fmt); 350 ret = trace_output_raw(iter, name, fmt, ap); 351 va_end(ap); 352 353 return ret; 354 } 355 EXPORT_SYMBOL_GPL(trace_output_call); 356 357 static inline const char *kretprobed(const char *name, unsigned long addr) 358 { 359 if (is_kretprobe_trampoline(addr)) 360 return "[unknown/kretprobe'd]"; 361 return name; 362 } 363 364 void 365 trace_seq_print_sym(struct trace_seq *s, unsigned long address, bool offset) 366 { 367 #ifdef CONFIG_KALLSYMS 368 char str[KSYM_SYMBOL_LEN]; 369 const char *name; 370 371 if (offset) 372 sprint_symbol(str, address); 373 else 374 kallsyms_lookup(address, NULL, NULL, NULL, str); 375 name = kretprobed(str, address); 376 377 if (name && strlen(name)) { 378 trace_seq_puts(s, name); 379 return; 380 } 381 #endif 382 trace_seq_printf(s, "0x%08lx", address); 383 } 384 385 #ifndef CONFIG_64BIT 386 # define IP_FMT "%08lx" 387 #else 388 # define IP_FMT "%016lx" 389 #endif 390 391 static int seq_print_user_ip(struct trace_seq *s, struct mm_struct *mm, 392 unsigned long ip, unsigned long sym_flags) 393 { 394 struct file *file = NULL; 395 unsigned long vmstart = 0; 396 int ret = 1; 397 398 if (s->full) 399 return 0; 400 401 if (mm) { 402 const struct vm_area_struct *vma; 403 404 mmap_read_lock(mm); 405 vma = find_vma(mm, ip); 406 if (vma) { 407 file = vma->vm_file; 408 vmstart = vma->vm_start; 409 } 410 if (file) { 411 ret = trace_seq_path(s, file_user_path(file)); 412 if (ret) 413 trace_seq_printf(s, "[+0x%lx]", 414 ip - vmstart); 415 } 416 mmap_read_unlock(mm); 417 } 418 if (ret && ((sym_flags & TRACE_ITER_SYM_ADDR) || !file)) 419 trace_seq_printf(s, " <" IP_FMT ">", ip); 420 return !trace_seq_has_overflowed(s); 421 } 422 423 int 424 seq_print_ip_sym(struct trace_seq *s, unsigned long ip, unsigned long sym_flags) 425 { 426 if (!ip) { 427 trace_seq_putc(s, '0'); 428 goto out; 429 } 430 431 trace_seq_print_sym(s, ip, sym_flags & TRACE_ITER_SYM_OFFSET); 432 433 if (sym_flags & TRACE_ITER_SYM_ADDR) 434 trace_seq_printf(s, " <" IP_FMT ">", ip); 435 436 out: 437 return !trace_seq_has_overflowed(s); 438 } 439 440 /** 441 * trace_print_lat_fmt - print the irq, preempt and lockdep fields 442 * @s: trace seq struct to write to 443 * @entry: The trace entry field from the ring buffer 444 * 445 * Prints the generic fields of irqs off, in hard or softirq, preempt 446 * count. 447 */ 448 int trace_print_lat_fmt(struct trace_seq *s, struct trace_entry *entry) 449 { 450 char hardsoft_irq; 451 char need_resched; 452 char irqs_off; 453 int hardirq; 454 int softirq; 455 int bh_off; 456 int nmi; 457 458 nmi = entry->flags & TRACE_FLAG_NMI; 459 hardirq = entry->flags & TRACE_FLAG_HARDIRQ; 460 softirq = entry->flags & TRACE_FLAG_SOFTIRQ; 461 bh_off = entry->flags & TRACE_FLAG_BH_OFF; 462 463 irqs_off = 464 (entry->flags & TRACE_FLAG_IRQS_OFF && bh_off) ? 'D' : 465 (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : 466 bh_off ? 'b' : 467 '.'; 468 469 switch (entry->flags & (TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_NEED_RESCHED_LAZY | 470 TRACE_FLAG_PREEMPT_RESCHED)) { 471 case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_NEED_RESCHED_LAZY | TRACE_FLAG_PREEMPT_RESCHED: 472 need_resched = 'B'; 473 break; 474 case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_PREEMPT_RESCHED: 475 need_resched = 'N'; 476 break; 477 case TRACE_FLAG_NEED_RESCHED_LAZY | TRACE_FLAG_PREEMPT_RESCHED: 478 need_resched = 'L'; 479 break; 480 case TRACE_FLAG_NEED_RESCHED | TRACE_FLAG_NEED_RESCHED_LAZY: 481 need_resched = 'b'; 482 break; 483 case TRACE_FLAG_NEED_RESCHED: 484 need_resched = 'n'; 485 break; 486 case TRACE_FLAG_PREEMPT_RESCHED: 487 need_resched = 'p'; 488 break; 489 case TRACE_FLAG_NEED_RESCHED_LAZY: 490 need_resched = 'l'; 491 break; 492 default: 493 need_resched = '.'; 494 break; 495 } 496 497 hardsoft_irq = 498 (nmi && hardirq) ? 'Z' : 499 nmi ? 'z' : 500 (hardirq && softirq) ? 'H' : 501 hardirq ? 'h' : 502 softirq ? 's' : 503 '.' ; 504 505 trace_seq_printf(s, "%c%c%c", 506 irqs_off, need_resched, hardsoft_irq); 507 508 if (entry->preempt_count & 0xf) 509 trace_seq_printf(s, "%x", entry->preempt_count & 0xf); 510 else 511 trace_seq_putc(s, '.'); 512 513 if (entry->preempt_count & 0xf0) 514 trace_seq_printf(s, "%x", entry->preempt_count >> 4); 515 else 516 trace_seq_putc(s, '.'); 517 518 return !trace_seq_has_overflowed(s); 519 } 520 521 static int 522 lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu) 523 { 524 char comm[TASK_COMM_LEN]; 525 526 trace_find_cmdline(entry->pid, comm); 527 528 trace_seq_printf(s, "%8.8s-%-7d %3d", 529 comm, entry->pid, cpu); 530 531 return trace_print_lat_fmt(s, entry); 532 } 533 534 #undef MARK 535 #define MARK(v, s) {.val = v, .sym = s} 536 /* trace overhead mark */ 537 static const struct trace_mark { 538 unsigned long long val; /* unit: nsec */ 539 char sym; 540 } mark[] = { 541 MARK(1000000000ULL , '$'), /* 1 sec */ 542 MARK(100000000ULL , '@'), /* 100 msec */ 543 MARK(10000000ULL , '*'), /* 10 msec */ 544 MARK(1000000ULL , '#'), /* 1000 usecs */ 545 MARK(100000ULL , '!'), /* 100 usecs */ 546 MARK(10000ULL , '+'), /* 10 usecs */ 547 }; 548 #undef MARK 549 550 char trace_find_mark(unsigned long long d) 551 { 552 int i; 553 int size = ARRAY_SIZE(mark); 554 555 for (i = 0; i < size; i++) { 556 if (d > mark[i].val) 557 break; 558 } 559 560 return (i == size) ? ' ' : mark[i].sym; 561 } 562 563 static int 564 lat_print_timestamp(struct trace_iterator *iter, u64 next_ts) 565 { 566 struct trace_array *tr = iter->tr; 567 unsigned long verbose = tr->trace_flags & TRACE_ITER_VERBOSE; 568 unsigned long in_ns = iter->iter_flags & TRACE_FILE_TIME_IN_NS; 569 unsigned long long abs_ts = iter->ts - iter->array_buffer->time_start; 570 unsigned long long rel_ts = next_ts - iter->ts; 571 struct trace_seq *s = &iter->seq; 572 573 if (in_ns) { 574 abs_ts = ns2usecs(abs_ts); 575 rel_ts = ns2usecs(rel_ts); 576 } 577 578 if (verbose && in_ns) { 579 unsigned long abs_usec = do_div(abs_ts, USEC_PER_MSEC); 580 unsigned long abs_msec = (unsigned long)abs_ts; 581 unsigned long rel_usec = do_div(rel_ts, USEC_PER_MSEC); 582 unsigned long rel_msec = (unsigned long)rel_ts; 583 584 trace_seq_printf( 585 s, "[%08llx] %ld.%03ldms (+%ld.%03ldms): ", 586 ns2usecs(iter->ts), 587 abs_msec, abs_usec, 588 rel_msec, rel_usec); 589 590 } else if (verbose && !in_ns) { 591 trace_seq_printf( 592 s, "[%016llx] %lld (+%lld): ", 593 iter->ts, abs_ts, rel_ts); 594 595 } else if (!verbose && in_ns) { 596 trace_seq_printf( 597 s, " %4lldus%c: ", 598 abs_ts, 599 trace_find_mark(rel_ts * NSEC_PER_USEC)); 600 601 } else { /* !verbose && !in_ns */ 602 trace_seq_printf(s, " %4lld: ", abs_ts); 603 } 604 605 return !trace_seq_has_overflowed(s); 606 } 607 608 static void trace_print_time(struct trace_seq *s, struct trace_iterator *iter, 609 unsigned long long ts) 610 { 611 unsigned long secs, usec_rem; 612 unsigned long long t; 613 614 if (iter->iter_flags & TRACE_FILE_TIME_IN_NS) { 615 t = ns2usecs(ts); 616 usec_rem = do_div(t, USEC_PER_SEC); 617 secs = (unsigned long)t; 618 trace_seq_printf(s, " %5lu.%06lu", secs, usec_rem); 619 } else 620 trace_seq_printf(s, " %12llu", ts); 621 } 622 623 int trace_print_context(struct trace_iterator *iter) 624 { 625 struct trace_array *tr = iter->tr; 626 struct trace_seq *s = &iter->seq; 627 struct trace_entry *entry = iter->ent; 628 char comm[TASK_COMM_LEN]; 629 630 trace_find_cmdline(entry->pid, comm); 631 632 trace_seq_printf(s, "%16s-%-7d ", comm, entry->pid); 633 634 if (tr->trace_flags & TRACE_ITER_RECORD_TGID) { 635 unsigned int tgid = trace_find_tgid(entry->pid); 636 637 if (!tgid) 638 trace_seq_printf(s, "(-------) "); 639 else 640 trace_seq_printf(s, "(%7d) ", tgid); 641 } 642 643 trace_seq_printf(s, "[%03d] ", iter->cpu); 644 645 if (tr->trace_flags & TRACE_ITER_IRQ_INFO) 646 trace_print_lat_fmt(s, entry); 647 648 trace_print_time(s, iter, iter->ts); 649 trace_seq_puts(s, ": "); 650 651 return !trace_seq_has_overflowed(s); 652 } 653 654 int trace_print_lat_context(struct trace_iterator *iter) 655 { 656 struct trace_entry *entry, *next_entry; 657 struct trace_array *tr = iter->tr; 658 struct trace_seq *s = &iter->seq; 659 unsigned long verbose = (tr->trace_flags & TRACE_ITER_VERBOSE); 660 u64 next_ts; 661 662 next_entry = trace_find_next_entry(iter, NULL, &next_ts); 663 if (!next_entry) 664 next_ts = iter->ts; 665 666 /* trace_find_next_entry() may change iter->ent */ 667 entry = iter->ent; 668 669 if (verbose) { 670 char comm[TASK_COMM_LEN]; 671 672 trace_find_cmdline(entry->pid, comm); 673 674 trace_seq_printf( 675 s, "%16s %7d %3d %d %08x %08lx ", 676 comm, entry->pid, iter->cpu, entry->flags, 677 entry->preempt_count & 0xf, iter->idx); 678 } else { 679 lat_print_generic(s, entry, iter->cpu); 680 } 681 682 lat_print_timestamp(iter, next_ts); 683 684 return !trace_seq_has_overflowed(s); 685 } 686 687 /** 688 * ftrace_find_event - find a registered event 689 * @type: the type of event to look for 690 * 691 * Returns an event of type @type otherwise NULL 692 * Called with trace_event_read_lock() held. 693 */ 694 struct trace_event *ftrace_find_event(int type) 695 { 696 struct trace_event *event; 697 unsigned key; 698 699 key = type & (EVENT_HASHSIZE - 1); 700 701 hlist_for_each_entry(event, &event_hash[key], node) { 702 if (event->type == type) 703 return event; 704 } 705 706 return NULL; 707 } 708 709 static DEFINE_IDA(trace_event_ida); 710 711 static void free_trace_event_type(int type) 712 { 713 if (type >= __TRACE_LAST_TYPE) 714 ida_free(&trace_event_ida, type); 715 } 716 717 static int alloc_trace_event_type(void) 718 { 719 int next; 720 721 /* Skip static defined type numbers */ 722 next = ida_alloc_range(&trace_event_ida, __TRACE_LAST_TYPE, 723 TRACE_EVENT_TYPE_MAX, GFP_KERNEL); 724 if (next < 0) 725 return 0; 726 return next; 727 } 728 729 void trace_event_read_lock(void) 730 { 731 down_read(&trace_event_sem); 732 } 733 734 void trace_event_read_unlock(void) 735 { 736 up_read(&trace_event_sem); 737 } 738 739 /** 740 * register_trace_event - register output for an event type 741 * @event: the event type to register 742 * 743 * Event types are stored in a hash and this hash is used to 744 * find a way to print an event. If the @event->type is set 745 * then it will use that type, otherwise it will assign a 746 * type to use. 747 * 748 * If you assign your own type, please make sure it is added 749 * to the trace_type enum in trace.h, to avoid collisions 750 * with the dynamic types. 751 * 752 * Returns the event type number or zero on error. 753 */ 754 int register_trace_event(struct trace_event *event) 755 { 756 unsigned key; 757 int ret = 0; 758 759 down_write(&trace_event_sem); 760 761 if (WARN_ON(!event)) 762 goto out; 763 764 if (WARN_ON(!event->funcs)) 765 goto out; 766 767 if (!event->type) { 768 event->type = alloc_trace_event_type(); 769 if (!event->type) 770 goto out; 771 } else if (WARN(event->type > __TRACE_LAST_TYPE, 772 "Need to add type to trace.h")) { 773 goto out; 774 } else { 775 /* Is this event already used */ 776 if (ftrace_find_event(event->type)) 777 goto out; 778 } 779 780 if (event->funcs->trace == NULL) 781 event->funcs->trace = trace_nop_print; 782 if (event->funcs->raw == NULL) 783 event->funcs->raw = trace_nop_print; 784 if (event->funcs->hex == NULL) 785 event->funcs->hex = trace_nop_print; 786 if (event->funcs->binary == NULL) 787 event->funcs->binary = trace_nop_print; 788 789 key = event->type & (EVENT_HASHSIZE - 1); 790 791 hlist_add_head(&event->node, &event_hash[key]); 792 793 ret = event->type; 794 out: 795 up_write(&trace_event_sem); 796 797 return ret; 798 } 799 EXPORT_SYMBOL_GPL(register_trace_event); 800 801 /* 802 * Used by module code with the trace_event_sem held for write. 803 */ 804 int __unregister_trace_event(struct trace_event *event) 805 { 806 hlist_del(&event->node); 807 free_trace_event_type(event->type); 808 return 0; 809 } 810 811 /** 812 * unregister_trace_event - remove a no longer used event 813 * @event: the event to remove 814 */ 815 int unregister_trace_event(struct trace_event *event) 816 { 817 down_write(&trace_event_sem); 818 __unregister_trace_event(event); 819 up_write(&trace_event_sem); 820 821 return 0; 822 } 823 EXPORT_SYMBOL_GPL(unregister_trace_event); 824 825 /* 826 * Standard events 827 */ 828 829 static void print_array(struct trace_iterator *iter, void *pos, 830 struct ftrace_event_field *field) 831 { 832 int offset; 833 int len; 834 int i; 835 836 offset = *(int *)pos & 0xffff; 837 len = *(int *)pos >> 16; 838 839 if (field) 840 offset += field->offset + sizeof(int); 841 842 if (offset + len > iter->ent_size) { 843 trace_seq_puts(&iter->seq, "<OVERFLOW>"); 844 return; 845 } 846 847 pos = (void *)iter->ent + offset; 848 849 for (i = 0; i < len; i++, pos++) { 850 if (i) 851 trace_seq_putc(&iter->seq, ','); 852 trace_seq_printf(&iter->seq, "%02x", *(unsigned char *)pos); 853 } 854 } 855 856 static void print_fields(struct trace_iterator *iter, struct trace_event_call *call, 857 struct list_head *head) 858 { 859 struct ftrace_event_field *field; 860 int offset; 861 int len; 862 int ret; 863 void *pos; 864 865 list_for_each_entry_reverse(field, head, link) { 866 trace_seq_printf(&iter->seq, " %s=", field->name); 867 if (field->offset + field->size > iter->ent_size) { 868 trace_seq_puts(&iter->seq, "<OVERFLOW>"); 869 continue; 870 } 871 pos = (void *)iter->ent + field->offset; 872 873 switch (field->filter_type) { 874 case FILTER_COMM: 875 case FILTER_STATIC_STRING: 876 trace_seq_printf(&iter->seq, "%.*s", field->size, (char *)pos); 877 break; 878 case FILTER_RDYN_STRING: 879 case FILTER_DYN_STRING: 880 offset = *(int *)pos & 0xffff; 881 len = *(int *)pos >> 16; 882 883 if (field->filter_type == FILTER_RDYN_STRING) 884 offset += field->offset + sizeof(int); 885 886 if (offset + len > iter->ent_size) { 887 trace_seq_puts(&iter->seq, "<OVERFLOW>"); 888 break; 889 } 890 pos = (void *)iter->ent + offset; 891 trace_seq_printf(&iter->seq, "%.*s", len, (char *)pos); 892 break; 893 case FILTER_PTR_STRING: 894 if (!iter->fmt_size) 895 trace_iter_expand_format(iter); 896 pos = *(void **)pos; 897 ret = strncpy_from_kernel_nofault(iter->fmt, pos, 898 iter->fmt_size); 899 if (ret < 0) 900 trace_seq_printf(&iter->seq, "(0x%px)", pos); 901 else 902 trace_seq_printf(&iter->seq, "(0x%px:%s)", 903 pos, iter->fmt); 904 break; 905 case FILTER_TRACE_FN: 906 pos = *(void **)pos; 907 trace_seq_printf(&iter->seq, "%pS", pos); 908 break; 909 case FILTER_CPU: 910 case FILTER_OTHER: 911 switch (field->size) { 912 case 1: 913 if (isprint(*(char *)pos)) { 914 trace_seq_printf(&iter->seq, "'%c'", 915 *(unsigned char *)pos); 916 } 917 trace_seq_printf(&iter->seq, "(%d)", 918 *(unsigned char *)pos); 919 break; 920 case 2: 921 trace_seq_printf(&iter->seq, "0x%x (%d)", 922 *(unsigned short *)pos, 923 *(unsigned short *)pos); 924 break; 925 case 4: 926 /* dynamic array info is 4 bytes */ 927 if (strstr(field->type, "__data_loc")) { 928 print_array(iter, pos, NULL); 929 break; 930 } 931 932 if (strstr(field->type, "__rel_loc")) { 933 print_array(iter, pos, field); 934 break; 935 } 936 937 trace_seq_printf(&iter->seq, "0x%x (%d)", 938 *(unsigned int *)pos, 939 *(unsigned int *)pos); 940 break; 941 case 8: 942 trace_seq_printf(&iter->seq, "0x%llx (%lld)", 943 *(unsigned long long *)pos, 944 *(unsigned long long *)pos); 945 break; 946 default: 947 trace_seq_puts(&iter->seq, "<INVALID-SIZE>"); 948 break; 949 } 950 break; 951 default: 952 trace_seq_puts(&iter->seq, "<INVALID-TYPE>"); 953 } 954 } 955 trace_seq_putc(&iter->seq, '\n'); 956 } 957 958 enum print_line_t print_event_fields(struct trace_iterator *iter, 959 struct trace_event *event) 960 { 961 struct trace_event_call *call; 962 struct list_head *head; 963 964 /* ftrace defined events have separate call structures */ 965 if (event->type <= __TRACE_LAST_TYPE) { 966 bool found = false; 967 968 down_read(&trace_event_sem); 969 list_for_each_entry(call, &ftrace_events, list) { 970 if (call->event.type == event->type) { 971 found = true; 972 break; 973 } 974 /* No need to search all events */ 975 if (call->event.type > __TRACE_LAST_TYPE) 976 break; 977 } 978 up_read(&trace_event_sem); 979 if (!found) { 980 trace_seq_printf(&iter->seq, "UNKNOWN TYPE %d\n", event->type); 981 goto out; 982 } 983 } else { 984 call = container_of(event, struct trace_event_call, event); 985 } 986 head = trace_get_fields(call); 987 988 trace_seq_printf(&iter->seq, "%s:", trace_event_name(call)); 989 990 if (head && !list_empty(head)) 991 print_fields(iter, call, head); 992 else 993 trace_seq_puts(&iter->seq, "No fields found\n"); 994 995 out: 996 return trace_handle_return(&iter->seq); 997 } 998 999 enum print_line_t trace_nop_print(struct trace_iterator *iter, int flags, 1000 struct trace_event *event) 1001 { 1002 trace_seq_printf(&iter->seq, "type: %d\n", iter->ent->type); 1003 1004 return trace_handle_return(&iter->seq); 1005 } 1006 1007 static void print_fn_trace(struct trace_seq *s, unsigned long ip, 1008 unsigned long parent_ip, long delta, int flags) 1009 { 1010 ip += delta; 1011 parent_ip += delta; 1012 1013 seq_print_ip_sym(s, ip, flags); 1014 1015 if ((flags & TRACE_ITER_PRINT_PARENT) && parent_ip) { 1016 trace_seq_puts(s, " <-"); 1017 seq_print_ip_sym(s, parent_ip, flags); 1018 } 1019 } 1020 1021 /* TRACE_FN */ 1022 static enum print_line_t trace_fn_trace(struct trace_iterator *iter, int flags, 1023 struct trace_event *event) 1024 { 1025 struct ftrace_entry *field; 1026 struct trace_seq *s = &iter->seq; 1027 1028 trace_assign_type(field, iter->ent); 1029 1030 print_fn_trace(s, field->ip, field->parent_ip, iter->tr->text_delta, flags); 1031 trace_seq_putc(s, '\n'); 1032 1033 return trace_handle_return(s); 1034 } 1035 1036 static enum print_line_t trace_fn_raw(struct trace_iterator *iter, int flags, 1037 struct trace_event *event) 1038 { 1039 struct ftrace_entry *field; 1040 1041 trace_assign_type(field, iter->ent); 1042 1043 trace_seq_printf(&iter->seq, "%lx %lx\n", 1044 field->ip, 1045 field->parent_ip); 1046 1047 return trace_handle_return(&iter->seq); 1048 } 1049 1050 static enum print_line_t trace_fn_hex(struct trace_iterator *iter, int flags, 1051 struct trace_event *event) 1052 { 1053 struct ftrace_entry *field; 1054 struct trace_seq *s = &iter->seq; 1055 1056 trace_assign_type(field, iter->ent); 1057 1058 SEQ_PUT_HEX_FIELD(s, field->ip); 1059 SEQ_PUT_HEX_FIELD(s, field->parent_ip); 1060 1061 return trace_handle_return(s); 1062 } 1063 1064 static enum print_line_t trace_fn_bin(struct trace_iterator *iter, int flags, 1065 struct trace_event *event) 1066 { 1067 struct ftrace_entry *field; 1068 struct trace_seq *s = &iter->seq; 1069 1070 trace_assign_type(field, iter->ent); 1071 1072 SEQ_PUT_FIELD(s, field->ip); 1073 SEQ_PUT_FIELD(s, field->parent_ip); 1074 1075 return trace_handle_return(s); 1076 } 1077 1078 static struct trace_event_functions trace_fn_funcs = { 1079 .trace = trace_fn_trace, 1080 .raw = trace_fn_raw, 1081 .hex = trace_fn_hex, 1082 .binary = trace_fn_bin, 1083 }; 1084 1085 static struct trace_event trace_fn_event = { 1086 .type = TRACE_FN, 1087 .funcs = &trace_fn_funcs, 1088 }; 1089 1090 /* TRACE_CTX an TRACE_WAKE */ 1091 static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter, 1092 char *delim) 1093 { 1094 struct ctx_switch_entry *field; 1095 char comm[TASK_COMM_LEN]; 1096 int S, T; 1097 1098 1099 trace_assign_type(field, iter->ent); 1100 1101 T = task_index_to_char(field->next_state); 1102 S = task_index_to_char(field->prev_state); 1103 trace_find_cmdline(field->next_pid, comm); 1104 trace_seq_printf(&iter->seq, 1105 " %7d:%3d:%c %s [%03d] %7d:%3d:%c %s\n", 1106 field->prev_pid, 1107 field->prev_prio, 1108 S, delim, 1109 field->next_cpu, 1110 field->next_pid, 1111 field->next_prio, 1112 T, comm); 1113 1114 return trace_handle_return(&iter->seq); 1115 } 1116 1117 static enum print_line_t trace_ctx_print(struct trace_iterator *iter, int flags, 1118 struct trace_event *event) 1119 { 1120 return trace_ctxwake_print(iter, "==>"); 1121 } 1122 1123 static enum print_line_t trace_wake_print(struct trace_iterator *iter, 1124 int flags, struct trace_event *event) 1125 { 1126 return trace_ctxwake_print(iter, " +"); 1127 } 1128 1129 static int trace_ctxwake_raw(struct trace_iterator *iter, char S) 1130 { 1131 struct ctx_switch_entry *field; 1132 int T; 1133 1134 trace_assign_type(field, iter->ent); 1135 1136 if (!S) 1137 S = task_index_to_char(field->prev_state); 1138 T = task_index_to_char(field->next_state); 1139 trace_seq_printf(&iter->seq, "%d %d %c %d %d %d %c\n", 1140 field->prev_pid, 1141 field->prev_prio, 1142 S, 1143 field->next_cpu, 1144 field->next_pid, 1145 field->next_prio, 1146 T); 1147 1148 return trace_handle_return(&iter->seq); 1149 } 1150 1151 static enum print_line_t trace_ctx_raw(struct trace_iterator *iter, int flags, 1152 struct trace_event *event) 1153 { 1154 return trace_ctxwake_raw(iter, 0); 1155 } 1156 1157 static enum print_line_t trace_wake_raw(struct trace_iterator *iter, int flags, 1158 struct trace_event *event) 1159 { 1160 return trace_ctxwake_raw(iter, '+'); 1161 } 1162 1163 1164 static int trace_ctxwake_hex(struct trace_iterator *iter, char S) 1165 { 1166 struct ctx_switch_entry *field; 1167 struct trace_seq *s = &iter->seq; 1168 int T; 1169 1170 trace_assign_type(field, iter->ent); 1171 1172 if (!S) 1173 S = task_index_to_char(field->prev_state); 1174 T = task_index_to_char(field->next_state); 1175 1176 SEQ_PUT_HEX_FIELD(s, field->prev_pid); 1177 SEQ_PUT_HEX_FIELD(s, field->prev_prio); 1178 SEQ_PUT_HEX_FIELD(s, S); 1179 SEQ_PUT_HEX_FIELD(s, field->next_cpu); 1180 SEQ_PUT_HEX_FIELD(s, field->next_pid); 1181 SEQ_PUT_HEX_FIELD(s, field->next_prio); 1182 SEQ_PUT_HEX_FIELD(s, T); 1183 1184 return trace_handle_return(s); 1185 } 1186 1187 static enum print_line_t trace_ctx_hex(struct trace_iterator *iter, int flags, 1188 struct trace_event *event) 1189 { 1190 return trace_ctxwake_hex(iter, 0); 1191 } 1192 1193 static enum print_line_t trace_wake_hex(struct trace_iterator *iter, int flags, 1194 struct trace_event *event) 1195 { 1196 return trace_ctxwake_hex(iter, '+'); 1197 } 1198 1199 static enum print_line_t trace_ctxwake_bin(struct trace_iterator *iter, 1200 int flags, struct trace_event *event) 1201 { 1202 struct ctx_switch_entry *field; 1203 struct trace_seq *s = &iter->seq; 1204 1205 trace_assign_type(field, iter->ent); 1206 1207 SEQ_PUT_FIELD(s, field->prev_pid); 1208 SEQ_PUT_FIELD(s, field->prev_prio); 1209 SEQ_PUT_FIELD(s, field->prev_state); 1210 SEQ_PUT_FIELD(s, field->next_cpu); 1211 SEQ_PUT_FIELD(s, field->next_pid); 1212 SEQ_PUT_FIELD(s, field->next_prio); 1213 SEQ_PUT_FIELD(s, field->next_state); 1214 1215 return trace_handle_return(s); 1216 } 1217 1218 static struct trace_event_functions trace_ctx_funcs = { 1219 .trace = trace_ctx_print, 1220 .raw = trace_ctx_raw, 1221 .hex = trace_ctx_hex, 1222 .binary = trace_ctxwake_bin, 1223 }; 1224 1225 static struct trace_event trace_ctx_event = { 1226 .type = TRACE_CTX, 1227 .funcs = &trace_ctx_funcs, 1228 }; 1229 1230 static struct trace_event_functions trace_wake_funcs = { 1231 .trace = trace_wake_print, 1232 .raw = trace_wake_raw, 1233 .hex = trace_wake_hex, 1234 .binary = trace_ctxwake_bin, 1235 }; 1236 1237 static struct trace_event trace_wake_event = { 1238 .type = TRACE_WAKE, 1239 .funcs = &trace_wake_funcs, 1240 }; 1241 1242 /* TRACE_STACK */ 1243 1244 static enum print_line_t trace_stack_print(struct trace_iterator *iter, 1245 int flags, struct trace_event *event) 1246 { 1247 struct stack_entry *field; 1248 struct trace_seq *s = &iter->seq; 1249 unsigned long *p; 1250 unsigned long *end; 1251 long delta = iter->tr->text_delta; 1252 1253 trace_assign_type(field, iter->ent); 1254 end = (unsigned long *)((long)iter->ent + iter->ent_size); 1255 1256 trace_seq_puts(s, "<stack trace>\n"); 1257 1258 for (p = field->caller; p && p < end && *p != ULONG_MAX; p++) { 1259 1260 if (trace_seq_has_overflowed(s)) 1261 break; 1262 1263 trace_seq_puts(s, " => "); 1264 if ((*p) == FTRACE_TRAMPOLINE_MARKER) { 1265 trace_seq_puts(s, "[FTRACE TRAMPOLINE]\n"); 1266 continue; 1267 } 1268 seq_print_ip_sym(s, (*p) + delta, flags); 1269 trace_seq_putc(s, '\n'); 1270 } 1271 1272 return trace_handle_return(s); 1273 } 1274 1275 static struct trace_event_functions trace_stack_funcs = { 1276 .trace = trace_stack_print, 1277 }; 1278 1279 static struct trace_event trace_stack_event = { 1280 .type = TRACE_STACK, 1281 .funcs = &trace_stack_funcs, 1282 }; 1283 1284 /* TRACE_USER_STACK */ 1285 static enum print_line_t trace_user_stack_print(struct trace_iterator *iter, 1286 int flags, struct trace_event *event) 1287 { 1288 struct trace_array *tr = iter->tr; 1289 struct userstack_entry *field; 1290 struct trace_seq *s = &iter->seq; 1291 struct mm_struct *mm = NULL; 1292 unsigned int i; 1293 1294 trace_assign_type(field, iter->ent); 1295 1296 trace_seq_puts(s, "<user stack trace>\n"); 1297 1298 if (tr->trace_flags & TRACE_ITER_SYM_USEROBJ) { 1299 struct task_struct *task; 1300 /* 1301 * we do the lookup on the thread group leader, 1302 * since individual threads might have already quit! 1303 */ 1304 rcu_read_lock(); 1305 task = find_task_by_vpid(field->tgid); 1306 if (task) 1307 mm = get_task_mm(task); 1308 rcu_read_unlock(); 1309 } 1310 1311 for (i = 0; i < FTRACE_STACK_ENTRIES; i++) { 1312 unsigned long ip = field->caller[i]; 1313 1314 if (!ip || trace_seq_has_overflowed(s)) 1315 break; 1316 1317 trace_seq_puts(s, " => "); 1318 seq_print_user_ip(s, mm, ip, flags); 1319 trace_seq_putc(s, '\n'); 1320 } 1321 1322 if (mm) 1323 mmput(mm); 1324 1325 return trace_handle_return(s); 1326 } 1327 1328 static struct trace_event_functions trace_user_stack_funcs = { 1329 .trace = trace_user_stack_print, 1330 }; 1331 1332 static struct trace_event trace_user_stack_event = { 1333 .type = TRACE_USER_STACK, 1334 .funcs = &trace_user_stack_funcs, 1335 }; 1336 1337 /* TRACE_HWLAT */ 1338 static enum print_line_t 1339 trace_hwlat_print(struct trace_iterator *iter, int flags, 1340 struct trace_event *event) 1341 { 1342 struct trace_entry *entry = iter->ent; 1343 struct trace_seq *s = &iter->seq; 1344 struct hwlat_entry *field; 1345 1346 trace_assign_type(field, entry); 1347 1348 trace_seq_printf(s, "#%-5u inner/outer(us): %4llu/%-5llu ts:%lld.%09ld count:%d", 1349 field->seqnum, 1350 field->duration, 1351 field->outer_duration, 1352 (long long)field->timestamp.tv_sec, 1353 field->timestamp.tv_nsec, field->count); 1354 1355 if (field->nmi_count) { 1356 /* 1357 * The generic sched_clock() is not NMI safe, thus 1358 * we only record the count and not the time. 1359 */ 1360 if (!IS_ENABLED(CONFIG_GENERIC_SCHED_CLOCK)) 1361 trace_seq_printf(s, " nmi-total:%llu", 1362 field->nmi_total_ts); 1363 trace_seq_printf(s, " nmi-count:%u", 1364 field->nmi_count); 1365 } 1366 1367 trace_seq_putc(s, '\n'); 1368 1369 return trace_handle_return(s); 1370 } 1371 1372 static enum print_line_t 1373 trace_hwlat_raw(struct trace_iterator *iter, int flags, 1374 struct trace_event *event) 1375 { 1376 struct hwlat_entry *field; 1377 struct trace_seq *s = &iter->seq; 1378 1379 trace_assign_type(field, iter->ent); 1380 1381 trace_seq_printf(s, "%llu %lld %lld %09ld %u\n", 1382 field->duration, 1383 field->outer_duration, 1384 (long long)field->timestamp.tv_sec, 1385 field->timestamp.tv_nsec, 1386 field->seqnum); 1387 1388 return trace_handle_return(s); 1389 } 1390 1391 static struct trace_event_functions trace_hwlat_funcs = { 1392 .trace = trace_hwlat_print, 1393 .raw = trace_hwlat_raw, 1394 }; 1395 1396 static struct trace_event trace_hwlat_event = { 1397 .type = TRACE_HWLAT, 1398 .funcs = &trace_hwlat_funcs, 1399 }; 1400 1401 /* TRACE_OSNOISE */ 1402 static enum print_line_t 1403 trace_osnoise_print(struct trace_iterator *iter, int flags, 1404 struct trace_event *event) 1405 { 1406 struct trace_entry *entry = iter->ent; 1407 struct trace_seq *s = &iter->seq; 1408 struct osnoise_entry *field; 1409 u64 ratio, ratio_dec; 1410 u64 net_runtime; 1411 1412 trace_assign_type(field, entry); 1413 1414 /* 1415 * compute the available % of cpu time. 1416 */ 1417 net_runtime = field->runtime - field->noise; 1418 ratio = net_runtime * 10000000; 1419 do_div(ratio, field->runtime); 1420 ratio_dec = do_div(ratio, 100000); 1421 1422 trace_seq_printf(s, "%llu %10llu %3llu.%05llu %7llu", 1423 field->runtime, 1424 field->noise, 1425 ratio, ratio_dec, 1426 field->max_sample); 1427 1428 trace_seq_printf(s, " %6u", field->hw_count); 1429 trace_seq_printf(s, " %6u", field->nmi_count); 1430 trace_seq_printf(s, " %6u", field->irq_count); 1431 trace_seq_printf(s, " %6u", field->softirq_count); 1432 trace_seq_printf(s, " %6u", field->thread_count); 1433 1434 trace_seq_putc(s, '\n'); 1435 1436 return trace_handle_return(s); 1437 } 1438 1439 static enum print_line_t 1440 trace_osnoise_raw(struct trace_iterator *iter, int flags, 1441 struct trace_event *event) 1442 { 1443 struct osnoise_entry *field; 1444 struct trace_seq *s = &iter->seq; 1445 1446 trace_assign_type(field, iter->ent); 1447 1448 trace_seq_printf(s, "%lld %llu %llu %u %u %u %u %u\n", 1449 field->runtime, 1450 field->noise, 1451 field->max_sample, 1452 field->hw_count, 1453 field->nmi_count, 1454 field->irq_count, 1455 field->softirq_count, 1456 field->thread_count); 1457 1458 return trace_handle_return(s); 1459 } 1460 1461 static struct trace_event_functions trace_osnoise_funcs = { 1462 .trace = trace_osnoise_print, 1463 .raw = trace_osnoise_raw, 1464 }; 1465 1466 static struct trace_event trace_osnoise_event = { 1467 .type = TRACE_OSNOISE, 1468 .funcs = &trace_osnoise_funcs, 1469 }; 1470 1471 /* TRACE_TIMERLAT */ 1472 1473 static char *timerlat_lat_context[] = {"irq", "thread", "user-ret"}; 1474 static enum print_line_t 1475 trace_timerlat_print(struct trace_iterator *iter, int flags, 1476 struct trace_event *event) 1477 { 1478 struct trace_entry *entry = iter->ent; 1479 struct trace_seq *s = &iter->seq; 1480 struct timerlat_entry *field; 1481 1482 trace_assign_type(field, entry); 1483 1484 trace_seq_printf(s, "#%-5u context %6s timer_latency %9llu ns\n", 1485 field->seqnum, 1486 timerlat_lat_context[field->context], 1487 field->timer_latency); 1488 1489 return trace_handle_return(s); 1490 } 1491 1492 static enum print_line_t 1493 trace_timerlat_raw(struct trace_iterator *iter, int flags, 1494 struct trace_event *event) 1495 { 1496 struct timerlat_entry *field; 1497 struct trace_seq *s = &iter->seq; 1498 1499 trace_assign_type(field, iter->ent); 1500 1501 trace_seq_printf(s, "%u %d %llu\n", 1502 field->seqnum, 1503 field->context, 1504 field->timer_latency); 1505 1506 return trace_handle_return(s); 1507 } 1508 1509 static struct trace_event_functions trace_timerlat_funcs = { 1510 .trace = trace_timerlat_print, 1511 .raw = trace_timerlat_raw, 1512 }; 1513 1514 static struct trace_event trace_timerlat_event = { 1515 .type = TRACE_TIMERLAT, 1516 .funcs = &trace_timerlat_funcs, 1517 }; 1518 1519 /* TRACE_BPUTS */ 1520 static enum print_line_t 1521 trace_bputs_print(struct trace_iterator *iter, int flags, 1522 struct trace_event *event) 1523 { 1524 struct trace_entry *entry = iter->ent; 1525 struct trace_seq *s = &iter->seq; 1526 struct bputs_entry *field; 1527 1528 trace_assign_type(field, entry); 1529 1530 seq_print_ip_sym(s, field->ip, flags); 1531 trace_seq_puts(s, ": "); 1532 trace_seq_puts(s, field->str); 1533 1534 return trace_handle_return(s); 1535 } 1536 1537 1538 static enum print_line_t 1539 trace_bputs_raw(struct trace_iterator *iter, int flags, 1540 struct trace_event *event) 1541 { 1542 struct bputs_entry *field; 1543 struct trace_seq *s = &iter->seq; 1544 1545 trace_assign_type(field, iter->ent); 1546 1547 trace_seq_printf(s, ": %lx : ", field->ip); 1548 trace_seq_puts(s, field->str); 1549 1550 return trace_handle_return(s); 1551 } 1552 1553 static struct trace_event_functions trace_bputs_funcs = { 1554 .trace = trace_bputs_print, 1555 .raw = trace_bputs_raw, 1556 }; 1557 1558 static struct trace_event trace_bputs_event = { 1559 .type = TRACE_BPUTS, 1560 .funcs = &trace_bputs_funcs, 1561 }; 1562 1563 /* TRACE_BPRINT */ 1564 static enum print_line_t 1565 trace_bprint_print(struct trace_iterator *iter, int flags, 1566 struct trace_event *event) 1567 { 1568 struct trace_entry *entry = iter->ent; 1569 struct trace_seq *s = &iter->seq; 1570 struct bprint_entry *field; 1571 1572 trace_assign_type(field, entry); 1573 1574 seq_print_ip_sym(s, field->ip, flags); 1575 trace_seq_puts(s, ": "); 1576 trace_seq_bprintf(s, field->fmt, field->buf); 1577 1578 return trace_handle_return(s); 1579 } 1580 1581 1582 static enum print_line_t 1583 trace_bprint_raw(struct trace_iterator *iter, int flags, 1584 struct trace_event *event) 1585 { 1586 struct bprint_entry *field; 1587 struct trace_seq *s = &iter->seq; 1588 1589 trace_assign_type(field, iter->ent); 1590 1591 trace_seq_printf(s, ": %lx : ", field->ip); 1592 trace_seq_bprintf(s, field->fmt, field->buf); 1593 1594 return trace_handle_return(s); 1595 } 1596 1597 static struct trace_event_functions trace_bprint_funcs = { 1598 .trace = trace_bprint_print, 1599 .raw = trace_bprint_raw, 1600 }; 1601 1602 static struct trace_event trace_bprint_event = { 1603 .type = TRACE_BPRINT, 1604 .funcs = &trace_bprint_funcs, 1605 }; 1606 1607 /* TRACE_PRINT */ 1608 static enum print_line_t trace_print_print(struct trace_iterator *iter, 1609 int flags, struct trace_event *event) 1610 { 1611 struct print_entry *field; 1612 struct trace_seq *s = &iter->seq; 1613 unsigned long ip; 1614 1615 trace_assign_type(field, iter->ent); 1616 1617 ip = field->ip + iter->tr->text_delta; 1618 1619 seq_print_ip_sym(s, ip, flags); 1620 trace_seq_printf(s, ": %s", field->buf); 1621 1622 return trace_handle_return(s); 1623 } 1624 1625 static enum print_line_t trace_print_raw(struct trace_iterator *iter, int flags, 1626 struct trace_event *event) 1627 { 1628 struct print_entry *field; 1629 1630 trace_assign_type(field, iter->ent); 1631 1632 trace_seq_printf(&iter->seq, "# %lx %s", field->ip, field->buf); 1633 1634 return trace_handle_return(&iter->seq); 1635 } 1636 1637 static struct trace_event_functions trace_print_funcs = { 1638 .trace = trace_print_print, 1639 .raw = trace_print_raw, 1640 }; 1641 1642 static struct trace_event trace_print_event = { 1643 .type = TRACE_PRINT, 1644 .funcs = &trace_print_funcs, 1645 }; 1646 1647 static enum print_line_t trace_raw_data(struct trace_iterator *iter, int flags, 1648 struct trace_event *event) 1649 { 1650 struct raw_data_entry *field; 1651 int i; 1652 1653 trace_assign_type(field, iter->ent); 1654 1655 trace_seq_printf(&iter->seq, "# %x buf:", field->id); 1656 1657 for (i = 0; i < iter->ent_size - offsetof(struct raw_data_entry, buf); i++) 1658 trace_seq_printf(&iter->seq, " %02x", 1659 (unsigned char)field->buf[i]); 1660 1661 trace_seq_putc(&iter->seq, '\n'); 1662 1663 return trace_handle_return(&iter->seq); 1664 } 1665 1666 static struct trace_event_functions trace_raw_data_funcs = { 1667 .trace = trace_raw_data, 1668 .raw = trace_raw_data, 1669 }; 1670 1671 static struct trace_event trace_raw_data_event = { 1672 .type = TRACE_RAW_DATA, 1673 .funcs = &trace_raw_data_funcs, 1674 }; 1675 1676 static enum print_line_t 1677 trace_func_repeats_raw(struct trace_iterator *iter, int flags, 1678 struct trace_event *event) 1679 { 1680 struct func_repeats_entry *field; 1681 struct trace_seq *s = &iter->seq; 1682 1683 trace_assign_type(field, iter->ent); 1684 1685 trace_seq_printf(s, "%lu %lu %u %llu\n", 1686 field->ip, 1687 field->parent_ip, 1688 field->count, 1689 FUNC_REPEATS_GET_DELTA_TS(field)); 1690 1691 return trace_handle_return(s); 1692 } 1693 1694 static enum print_line_t 1695 trace_func_repeats_print(struct trace_iterator *iter, int flags, 1696 struct trace_event *event) 1697 { 1698 struct func_repeats_entry *field; 1699 struct trace_seq *s = &iter->seq; 1700 1701 trace_assign_type(field, iter->ent); 1702 1703 print_fn_trace(s, field->ip, field->parent_ip, iter->tr->text_delta, flags); 1704 trace_seq_printf(s, " (repeats: %u, last_ts:", field->count); 1705 trace_print_time(s, iter, 1706 iter->ts - FUNC_REPEATS_GET_DELTA_TS(field)); 1707 trace_seq_puts(s, ")\n"); 1708 1709 return trace_handle_return(s); 1710 } 1711 1712 static struct trace_event_functions trace_func_repeats_funcs = { 1713 .trace = trace_func_repeats_print, 1714 .raw = trace_func_repeats_raw, 1715 }; 1716 1717 static struct trace_event trace_func_repeats_event = { 1718 .type = TRACE_FUNC_REPEATS, 1719 .funcs = &trace_func_repeats_funcs, 1720 }; 1721 1722 static struct trace_event *events[] __initdata = { 1723 &trace_fn_event, 1724 &trace_ctx_event, 1725 &trace_wake_event, 1726 &trace_stack_event, 1727 &trace_user_stack_event, 1728 &trace_bputs_event, 1729 &trace_bprint_event, 1730 &trace_print_event, 1731 &trace_hwlat_event, 1732 &trace_osnoise_event, 1733 &trace_timerlat_event, 1734 &trace_raw_data_event, 1735 &trace_func_repeats_event, 1736 NULL 1737 }; 1738 1739 __init int init_events(void) 1740 { 1741 struct trace_event *event; 1742 int i, ret; 1743 1744 for (i = 0; events[i]; i++) { 1745 event = events[i]; 1746 ret = register_trace_event(event); 1747 WARN_ONCE(!ret, "event %d failed to register", event->type); 1748 } 1749 1750 return 0; 1751 } 1752