1 /* 2 * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com> 3 * 4 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; version 2 of the License (not later!) 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 20 * 21 * The parts for function graph printing was taken and modified from the 22 * Linux Kernel that were written by Frederic Weisbecker. 23 */ 24 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <string.h> 28 #include <errno.h> 29 30 #include "../perf.h" 31 #include "util.h" 32 #include "trace-event.h" 33 34 int header_page_ts_offset; 35 int header_page_ts_size; 36 int header_page_size_offset; 37 int header_page_size_size; 38 int header_page_overwrite_offset; 39 int header_page_overwrite_size; 40 int header_page_data_offset; 41 int header_page_data_size; 42 43 bool latency_format; 44 45 static char *input_buf; 46 static unsigned long long input_buf_ptr; 47 static unsigned long long input_buf_siz; 48 49 static int cpus; 50 static int long_size; 51 static int is_flag_field; 52 static int is_symbolic_field; 53 54 static struct format_field * 55 find_any_field(struct event *event, const char *name); 56 57 static void init_input_buf(char *buf, unsigned long long size) 58 { 59 input_buf = buf; 60 input_buf_siz = size; 61 input_buf_ptr = 0; 62 } 63 64 struct cmdline { 65 char *comm; 66 int pid; 67 }; 68 69 static struct cmdline *cmdlines; 70 static int cmdline_count; 71 72 static int cmdline_cmp(const void *a, const void *b) 73 { 74 const struct cmdline *ca = a; 75 const struct cmdline *cb = b; 76 77 if (ca->pid < cb->pid) 78 return -1; 79 if (ca->pid > cb->pid) 80 return 1; 81 82 return 0; 83 } 84 85 void parse_cmdlines(char *file, int size __unused) 86 { 87 struct cmdline_list { 88 struct cmdline_list *next; 89 char *comm; 90 int pid; 91 } *list = NULL, *item; 92 char *line; 93 char *next = NULL; 94 int i; 95 96 line = strtok_r(file, "\n", &next); 97 while (line) { 98 item = malloc_or_die(sizeof(*item)); 99 sscanf(line, "%d %as", &item->pid, 100 (float *)(void *)&item->comm); /* workaround gcc warning */ 101 item->next = list; 102 list = item; 103 line = strtok_r(NULL, "\n", &next); 104 cmdline_count++; 105 } 106 107 cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count); 108 109 i = 0; 110 while (list) { 111 cmdlines[i].pid = list->pid; 112 cmdlines[i].comm = list->comm; 113 i++; 114 item = list; 115 list = list->next; 116 free(item); 117 } 118 119 qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp); 120 } 121 122 static struct func_map { 123 unsigned long long addr; 124 char *func; 125 char *mod; 126 } *func_list; 127 static unsigned int func_count; 128 129 static int func_cmp(const void *a, const void *b) 130 { 131 const struct func_map *fa = a; 132 const struct func_map *fb = b; 133 134 if (fa->addr < fb->addr) 135 return -1; 136 if (fa->addr > fb->addr) 137 return 1; 138 139 return 0; 140 } 141 142 void parse_proc_kallsyms(char *file, unsigned int size __unused) 143 { 144 struct func_list { 145 struct func_list *next; 146 unsigned long long addr; 147 char *func; 148 char *mod; 149 } *list = NULL, *item; 150 char *line; 151 char *next = NULL; 152 char *addr_str; 153 char ch; 154 int ret __used; 155 int i; 156 157 line = strtok_r(file, "\n", &next); 158 while (line) { 159 item = malloc_or_die(sizeof(*item)); 160 item->mod = NULL; 161 ret = sscanf(line, "%as %c %as\t[%as", 162 (float *)(void *)&addr_str, /* workaround gcc warning */ 163 &ch, 164 (float *)(void *)&item->func, 165 (float *)(void *)&item->mod); 166 item->addr = strtoull(addr_str, NULL, 16); 167 free(addr_str); 168 169 /* truncate the extra ']' */ 170 if (item->mod) 171 item->mod[strlen(item->mod) - 1] = 0; 172 173 174 item->next = list; 175 list = item; 176 line = strtok_r(NULL, "\n", &next); 177 func_count++; 178 } 179 180 func_list = malloc_or_die(sizeof(*func_list) * (func_count + 1)); 181 182 i = 0; 183 while (list) { 184 func_list[i].func = list->func; 185 func_list[i].addr = list->addr; 186 func_list[i].mod = list->mod; 187 i++; 188 item = list; 189 list = list->next; 190 free(item); 191 } 192 193 qsort(func_list, func_count, sizeof(*func_list), func_cmp); 194 195 /* 196 * Add a special record at the end. 197 */ 198 func_list[func_count].func = NULL; 199 func_list[func_count].addr = 0; 200 func_list[func_count].mod = NULL; 201 } 202 203 /* 204 * We are searching for a record in between, not an exact 205 * match. 206 */ 207 static int func_bcmp(const void *a, const void *b) 208 { 209 const struct func_map *fa = a; 210 const struct func_map *fb = b; 211 212 if ((fa->addr == fb->addr) || 213 214 (fa->addr > fb->addr && 215 fa->addr < (fb+1)->addr)) 216 return 0; 217 218 if (fa->addr < fb->addr) 219 return -1; 220 221 return 1; 222 } 223 224 static struct func_map *find_func(unsigned long long addr) 225 { 226 struct func_map *func; 227 struct func_map key; 228 229 key.addr = addr; 230 231 func = bsearch(&key, func_list, func_count, sizeof(*func_list), 232 func_bcmp); 233 234 return func; 235 } 236 237 void print_funcs(void) 238 { 239 int i; 240 241 for (i = 0; i < (int)func_count; i++) { 242 printf("%016llx %s", 243 func_list[i].addr, 244 func_list[i].func); 245 if (func_list[i].mod) 246 printf(" [%s]\n", func_list[i].mod); 247 else 248 printf("\n"); 249 } 250 } 251 252 static struct printk_map { 253 unsigned long long addr; 254 char *printk; 255 } *printk_list; 256 static unsigned int printk_count; 257 258 static int printk_cmp(const void *a, const void *b) 259 { 260 const struct func_map *fa = a; 261 const struct func_map *fb = b; 262 263 if (fa->addr < fb->addr) 264 return -1; 265 if (fa->addr > fb->addr) 266 return 1; 267 268 return 0; 269 } 270 271 static struct printk_map *find_printk(unsigned long long addr) 272 { 273 struct printk_map *printk; 274 struct printk_map key; 275 276 key.addr = addr; 277 278 printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list), 279 printk_cmp); 280 281 return printk; 282 } 283 284 void parse_ftrace_printk(char *file, unsigned int size __unused) 285 { 286 struct printk_list { 287 struct printk_list *next; 288 unsigned long long addr; 289 char *printk; 290 } *list = NULL, *item; 291 char *line; 292 char *next = NULL; 293 char *addr_str; 294 int i; 295 296 line = strtok_r(file, "\n", &next); 297 while (line) { 298 addr_str = strsep(&line, ":"); 299 if (!line) { 300 warning("error parsing print strings"); 301 break; 302 } 303 item = malloc_or_die(sizeof(*item)); 304 item->addr = strtoull(addr_str, NULL, 16); 305 /* fmt still has a space, skip it */ 306 item->printk = strdup(line+1); 307 item->next = list; 308 list = item; 309 line = strtok_r(NULL, "\n", &next); 310 printk_count++; 311 } 312 313 printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1); 314 315 i = 0; 316 while (list) { 317 printk_list[i].printk = list->printk; 318 printk_list[i].addr = list->addr; 319 i++; 320 item = list; 321 list = list->next; 322 free(item); 323 } 324 325 qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp); 326 } 327 328 void print_printk(void) 329 { 330 int i; 331 332 for (i = 0; i < (int)printk_count; i++) { 333 printf("%016llx %s\n", 334 printk_list[i].addr, 335 printk_list[i].printk); 336 } 337 } 338 339 static struct event *alloc_event(void) 340 { 341 struct event *event; 342 343 event = malloc_or_die(sizeof(*event)); 344 memset(event, 0, sizeof(*event)); 345 346 return event; 347 } 348 349 enum event_type { 350 EVENT_ERROR, 351 EVENT_NONE, 352 EVENT_SPACE, 353 EVENT_NEWLINE, 354 EVENT_OP, 355 EVENT_DELIM, 356 EVENT_ITEM, 357 EVENT_DQUOTE, 358 EVENT_SQUOTE, 359 }; 360 361 static struct event *event_list; 362 363 static void add_event(struct event *event) 364 { 365 event->next = event_list; 366 event_list = event; 367 } 368 369 static int event_item_type(enum event_type type) 370 { 371 switch (type) { 372 case EVENT_ITEM ... EVENT_SQUOTE: 373 return 1; 374 case EVENT_ERROR ... EVENT_DELIM: 375 default: 376 return 0; 377 } 378 } 379 380 static void free_arg(struct print_arg *arg) 381 { 382 if (!arg) 383 return; 384 385 switch (arg->type) { 386 case PRINT_ATOM: 387 if (arg->atom.atom) 388 free(arg->atom.atom); 389 break; 390 case PRINT_NULL: 391 case PRINT_FIELD ... PRINT_OP: 392 default: 393 /* todo */ 394 break; 395 } 396 397 free(arg); 398 } 399 400 static enum event_type get_type(int ch) 401 { 402 if (ch == '\n') 403 return EVENT_NEWLINE; 404 if (isspace(ch)) 405 return EVENT_SPACE; 406 if (isalnum(ch) || ch == '_') 407 return EVENT_ITEM; 408 if (ch == '\'') 409 return EVENT_SQUOTE; 410 if (ch == '"') 411 return EVENT_DQUOTE; 412 if (!isprint(ch)) 413 return EVENT_NONE; 414 if (ch == '(' || ch == ')' || ch == ',') 415 return EVENT_DELIM; 416 417 return EVENT_OP; 418 } 419 420 static int __read_char(void) 421 { 422 if (input_buf_ptr >= input_buf_siz) 423 return -1; 424 425 return input_buf[input_buf_ptr++]; 426 } 427 428 static int __peek_char(void) 429 { 430 if (input_buf_ptr >= input_buf_siz) 431 return -1; 432 433 return input_buf[input_buf_ptr]; 434 } 435 436 static enum event_type __read_token(char **tok) 437 { 438 char buf[BUFSIZ]; 439 int ch, last_ch, quote_ch, next_ch; 440 int i = 0; 441 int tok_size = 0; 442 enum event_type type; 443 444 *tok = NULL; 445 446 447 ch = __read_char(); 448 if (ch < 0) 449 return EVENT_NONE; 450 451 type = get_type(ch); 452 if (type == EVENT_NONE) 453 return type; 454 455 buf[i++] = ch; 456 457 switch (type) { 458 case EVENT_NEWLINE: 459 case EVENT_DELIM: 460 *tok = malloc_or_die(2); 461 (*tok)[0] = ch; 462 (*tok)[1] = 0; 463 return type; 464 465 case EVENT_OP: 466 switch (ch) { 467 case '-': 468 next_ch = __peek_char(); 469 if (next_ch == '>') { 470 buf[i++] = __read_char(); 471 break; 472 } 473 /* fall through */ 474 case '+': 475 case '|': 476 case '&': 477 case '>': 478 case '<': 479 last_ch = ch; 480 ch = __peek_char(); 481 if (ch != last_ch) 482 goto test_equal; 483 buf[i++] = __read_char(); 484 switch (last_ch) { 485 case '>': 486 case '<': 487 goto test_equal; 488 default: 489 break; 490 } 491 break; 492 case '!': 493 case '=': 494 goto test_equal; 495 default: /* what should we do instead? */ 496 break; 497 } 498 buf[i] = 0; 499 *tok = strdup(buf); 500 return type; 501 502 test_equal: 503 ch = __peek_char(); 504 if (ch == '=') 505 buf[i++] = __read_char(); 506 break; 507 508 case EVENT_DQUOTE: 509 case EVENT_SQUOTE: 510 /* don't keep quotes */ 511 i--; 512 quote_ch = ch; 513 last_ch = 0; 514 do { 515 if (i == (BUFSIZ - 1)) { 516 buf[i] = 0; 517 if (*tok) { 518 *tok = realloc(*tok, tok_size + BUFSIZ); 519 if (!*tok) 520 return EVENT_NONE; 521 strcat(*tok, buf); 522 } else 523 *tok = strdup(buf); 524 525 if (!*tok) 526 return EVENT_NONE; 527 tok_size += BUFSIZ; 528 i = 0; 529 } 530 last_ch = ch; 531 ch = __read_char(); 532 buf[i++] = ch; 533 /* the '\' '\' will cancel itself */ 534 if (ch == '\\' && last_ch == '\\') 535 last_ch = 0; 536 } while (ch != quote_ch || last_ch == '\\'); 537 /* remove the last quote */ 538 i--; 539 goto out; 540 541 case EVENT_ERROR ... EVENT_SPACE: 542 case EVENT_ITEM: 543 default: 544 break; 545 } 546 547 while (get_type(__peek_char()) == type) { 548 if (i == (BUFSIZ - 1)) { 549 buf[i] = 0; 550 if (*tok) { 551 *tok = realloc(*tok, tok_size + BUFSIZ); 552 if (!*tok) 553 return EVENT_NONE; 554 strcat(*tok, buf); 555 } else 556 *tok = strdup(buf); 557 558 if (!*tok) 559 return EVENT_NONE; 560 tok_size += BUFSIZ; 561 i = 0; 562 } 563 ch = __read_char(); 564 buf[i++] = ch; 565 } 566 567 out: 568 buf[i] = 0; 569 if (*tok) { 570 *tok = realloc(*tok, tok_size + i); 571 if (!*tok) 572 return EVENT_NONE; 573 strcat(*tok, buf); 574 } else 575 *tok = strdup(buf); 576 if (!*tok) 577 return EVENT_NONE; 578 579 return type; 580 } 581 582 static void free_token(char *tok) 583 { 584 if (tok) 585 free(tok); 586 } 587 588 static enum event_type read_token(char **tok) 589 { 590 enum event_type type; 591 592 for (;;) { 593 type = __read_token(tok); 594 if (type != EVENT_SPACE) 595 return type; 596 597 free_token(*tok); 598 } 599 600 /* not reached */ 601 return EVENT_NONE; 602 } 603 604 /* no newline */ 605 static enum event_type read_token_item(char **tok) 606 { 607 enum event_type type; 608 609 for (;;) { 610 type = __read_token(tok); 611 if (type != EVENT_SPACE && type != EVENT_NEWLINE) 612 return type; 613 614 free_token(*tok); 615 } 616 617 /* not reached */ 618 return EVENT_NONE; 619 } 620 621 static int test_type(enum event_type type, enum event_type expect) 622 { 623 if (type != expect) { 624 warning("Error: expected type %d but read %d", 625 expect, type); 626 return -1; 627 } 628 return 0; 629 } 630 631 static int __test_type_token(enum event_type type, char *token, 632 enum event_type expect, const char *expect_tok, 633 bool warn) 634 { 635 if (type != expect) { 636 if (warn) 637 warning("Error: expected type %d but read %d", 638 expect, type); 639 return -1; 640 } 641 642 if (strcmp(token, expect_tok) != 0) { 643 if (warn) 644 warning("Error: expected '%s' but read '%s'", 645 expect_tok, token); 646 return -1; 647 } 648 return 0; 649 } 650 651 static int test_type_token(enum event_type type, char *token, 652 enum event_type expect, const char *expect_tok) 653 { 654 return __test_type_token(type, token, expect, expect_tok, true); 655 } 656 657 static int __read_expect_type(enum event_type expect, char **tok, int newline_ok) 658 { 659 enum event_type type; 660 661 if (newline_ok) 662 type = read_token(tok); 663 else 664 type = read_token_item(tok); 665 return test_type(type, expect); 666 } 667 668 static int read_expect_type(enum event_type expect, char **tok) 669 { 670 return __read_expect_type(expect, tok, 1); 671 } 672 673 static int __read_expected(enum event_type expect, const char *str, 674 int newline_ok, bool warn) 675 { 676 enum event_type type; 677 char *token; 678 int ret; 679 680 if (newline_ok) 681 type = read_token(&token); 682 else 683 type = read_token_item(&token); 684 685 ret = __test_type_token(type, token, expect, str, warn); 686 687 free_token(token); 688 689 return ret; 690 } 691 692 static int read_expected(enum event_type expect, const char *str) 693 { 694 return __read_expected(expect, str, 1, true); 695 } 696 697 static int read_expected_item(enum event_type expect, const char *str) 698 { 699 return __read_expected(expect, str, 0, true); 700 } 701 702 static char *event_read_name(void) 703 { 704 char *token; 705 706 if (read_expected(EVENT_ITEM, "name") < 0) 707 return NULL; 708 709 if (read_expected(EVENT_OP, ":") < 0) 710 return NULL; 711 712 if (read_expect_type(EVENT_ITEM, &token) < 0) 713 goto fail; 714 715 return token; 716 717 fail: 718 free_token(token); 719 return NULL; 720 } 721 722 static int event_read_id(void) 723 { 724 char *token; 725 int id; 726 727 if (read_expected_item(EVENT_ITEM, "ID") < 0) 728 return -1; 729 730 if (read_expected(EVENT_OP, ":") < 0) 731 return -1; 732 733 if (read_expect_type(EVENT_ITEM, &token) < 0) 734 goto fail; 735 736 id = strtoul(token, NULL, 0); 737 free_token(token); 738 return id; 739 740 fail: 741 free_token(token); 742 return -1; 743 } 744 745 static int field_is_string(struct format_field *field) 746 { 747 if ((field->flags & FIELD_IS_ARRAY) && 748 (!strstr(field->type, "char") || !strstr(field->type, "u8") || 749 !strstr(field->type, "s8"))) 750 return 1; 751 752 return 0; 753 } 754 755 static int field_is_dynamic(struct format_field *field) 756 { 757 if (!strncmp(field->type, "__data_loc", 10)) 758 return 1; 759 760 return 0; 761 } 762 763 static int event_read_fields(struct event *event, struct format_field **fields) 764 { 765 struct format_field *field = NULL; 766 enum event_type type; 767 char *token; 768 char *last_token; 769 int count = 0; 770 771 do { 772 type = read_token(&token); 773 if (type == EVENT_NEWLINE) { 774 free_token(token); 775 return count; 776 } 777 778 count++; 779 780 if (test_type_token(type, token, EVENT_ITEM, "field")) 781 goto fail; 782 free_token(token); 783 784 type = read_token(&token); 785 /* 786 * The ftrace fields may still use the "special" name. 787 * Just ignore it. 788 */ 789 if (event->flags & EVENT_FL_ISFTRACE && 790 type == EVENT_ITEM && strcmp(token, "special") == 0) { 791 free_token(token); 792 type = read_token(&token); 793 } 794 795 if (test_type_token(type, token, EVENT_OP, ":") < 0) 796 return -1; 797 798 if (read_expect_type(EVENT_ITEM, &token) < 0) 799 goto fail; 800 801 last_token = token; 802 803 field = malloc_or_die(sizeof(*field)); 804 memset(field, 0, sizeof(*field)); 805 806 /* read the rest of the type */ 807 for (;;) { 808 type = read_token(&token); 809 if (type == EVENT_ITEM || 810 (type == EVENT_OP && strcmp(token, "*") == 0) || 811 /* 812 * Some of the ftrace fields are broken and have 813 * an illegal "." in them. 814 */ 815 (event->flags & EVENT_FL_ISFTRACE && 816 type == EVENT_OP && strcmp(token, ".") == 0)) { 817 818 if (strcmp(token, "*") == 0) 819 field->flags |= FIELD_IS_POINTER; 820 821 if (field->type) { 822 field->type = realloc(field->type, 823 strlen(field->type) + 824 strlen(last_token) + 2); 825 strcat(field->type, " "); 826 strcat(field->type, last_token); 827 } else 828 field->type = last_token; 829 last_token = token; 830 continue; 831 } 832 833 break; 834 } 835 836 if (!field->type) { 837 die("no type found"); 838 goto fail; 839 } 840 field->name = last_token; 841 842 if (test_type(type, EVENT_OP)) 843 goto fail; 844 845 if (strcmp(token, "[") == 0) { 846 enum event_type last_type = type; 847 char *brackets = token; 848 int len; 849 850 field->flags |= FIELD_IS_ARRAY; 851 852 type = read_token(&token); 853 while (strcmp(token, "]") != 0) { 854 if (last_type == EVENT_ITEM && 855 type == EVENT_ITEM) 856 len = 2; 857 else 858 len = 1; 859 last_type = type; 860 861 brackets = realloc(brackets, 862 strlen(brackets) + 863 strlen(token) + len); 864 if (len == 2) 865 strcat(brackets, " "); 866 strcat(brackets, token); 867 free_token(token); 868 type = read_token(&token); 869 if (type == EVENT_NONE) { 870 die("failed to find token"); 871 goto fail; 872 } 873 } 874 875 free_token(token); 876 877 brackets = realloc(brackets, strlen(brackets) + 2); 878 strcat(brackets, "]"); 879 880 /* add brackets to type */ 881 882 type = read_token(&token); 883 /* 884 * If the next token is not an OP, then it is of 885 * the format: type [] item; 886 */ 887 if (type == EVENT_ITEM) { 888 field->type = realloc(field->type, 889 strlen(field->type) + 890 strlen(field->name) + 891 strlen(brackets) + 2); 892 strcat(field->type, " "); 893 strcat(field->type, field->name); 894 free_token(field->name); 895 strcat(field->type, brackets); 896 field->name = token; 897 type = read_token(&token); 898 } else { 899 field->type = realloc(field->type, 900 strlen(field->type) + 901 strlen(brackets) + 1); 902 strcat(field->type, brackets); 903 } 904 free(brackets); 905 } 906 907 if (field_is_string(field)) { 908 field->flags |= FIELD_IS_STRING; 909 if (field_is_dynamic(field)) 910 field->flags |= FIELD_IS_DYNAMIC; 911 } 912 913 if (test_type_token(type, token, EVENT_OP, ";")) 914 goto fail; 915 free_token(token); 916 917 if (read_expected(EVENT_ITEM, "offset") < 0) 918 goto fail_expect; 919 920 if (read_expected(EVENT_OP, ":") < 0) 921 goto fail_expect; 922 923 if (read_expect_type(EVENT_ITEM, &token)) 924 goto fail; 925 field->offset = strtoul(token, NULL, 0); 926 free_token(token); 927 928 if (read_expected(EVENT_OP, ";") < 0) 929 goto fail_expect; 930 931 if (read_expected(EVENT_ITEM, "size") < 0) 932 goto fail_expect; 933 934 if (read_expected(EVENT_OP, ":") < 0) 935 goto fail_expect; 936 937 if (read_expect_type(EVENT_ITEM, &token)) 938 goto fail; 939 field->size = strtoul(token, NULL, 0); 940 free_token(token); 941 942 if (read_expected(EVENT_OP, ";") < 0) 943 goto fail_expect; 944 945 type = read_token(&token); 946 if (type != EVENT_NEWLINE) { 947 /* newer versions of the kernel have a "signed" type */ 948 if (test_type_token(type, token, EVENT_ITEM, "signed")) 949 goto fail; 950 951 free_token(token); 952 953 if (read_expected(EVENT_OP, ":") < 0) 954 goto fail_expect; 955 956 if (read_expect_type(EVENT_ITEM, &token)) 957 goto fail; 958 959 if (strtoul(token, NULL, 0)) 960 field->flags |= FIELD_IS_SIGNED; 961 962 free_token(token); 963 if (read_expected(EVENT_OP, ";") < 0) 964 goto fail_expect; 965 966 if (read_expect_type(EVENT_NEWLINE, &token)) 967 goto fail; 968 } 969 970 free_token(token); 971 972 *fields = field; 973 fields = &field->next; 974 975 } while (1); 976 977 return 0; 978 979 fail: 980 free_token(token); 981 fail_expect: 982 if (field) 983 free(field); 984 return -1; 985 } 986 987 static int event_read_format(struct event *event) 988 { 989 char *token; 990 int ret; 991 992 if (read_expected_item(EVENT_ITEM, "format") < 0) 993 return -1; 994 995 if (read_expected(EVENT_OP, ":") < 0) 996 return -1; 997 998 if (read_expect_type(EVENT_NEWLINE, &token)) 999 goto fail; 1000 free_token(token); 1001 1002 ret = event_read_fields(event, &event->format.common_fields); 1003 if (ret < 0) 1004 return ret; 1005 event->format.nr_common = ret; 1006 1007 ret = event_read_fields(event, &event->format.fields); 1008 if (ret < 0) 1009 return ret; 1010 event->format.nr_fields = ret; 1011 1012 return 0; 1013 1014 fail: 1015 free_token(token); 1016 return -1; 1017 } 1018 1019 enum event_type 1020 process_arg_token(struct event *event, struct print_arg *arg, 1021 char **tok, enum event_type type); 1022 1023 static enum event_type 1024 process_arg(struct event *event, struct print_arg *arg, char **tok) 1025 { 1026 enum event_type type; 1027 char *token; 1028 1029 type = read_token(&token); 1030 *tok = token; 1031 1032 return process_arg_token(event, arg, tok, type); 1033 } 1034 1035 static enum event_type 1036 process_cond(struct event *event, struct print_arg *top, char **tok) 1037 { 1038 struct print_arg *arg, *left, *right; 1039 enum event_type type; 1040 char *token = NULL; 1041 1042 arg = malloc_or_die(sizeof(*arg)); 1043 memset(arg, 0, sizeof(*arg)); 1044 1045 left = malloc_or_die(sizeof(*left)); 1046 1047 right = malloc_or_die(sizeof(*right)); 1048 1049 arg->type = PRINT_OP; 1050 arg->op.left = left; 1051 arg->op.right = right; 1052 1053 *tok = NULL; 1054 type = process_arg(event, left, &token); 1055 if (test_type_token(type, token, EVENT_OP, ":")) 1056 goto out_free; 1057 1058 arg->op.op = token; 1059 1060 type = process_arg(event, right, &token); 1061 1062 top->op.right = arg; 1063 1064 *tok = token; 1065 return type; 1066 1067 out_free: 1068 free_token(*tok); 1069 free(right); 1070 free(left); 1071 free_arg(arg); 1072 return EVENT_ERROR; 1073 } 1074 1075 static enum event_type 1076 process_array(struct event *event, struct print_arg *top, char **tok) 1077 { 1078 struct print_arg *arg; 1079 enum event_type type; 1080 char *token = NULL; 1081 1082 arg = malloc_or_die(sizeof(*arg)); 1083 memset(arg, 0, sizeof(*arg)); 1084 1085 *tok = NULL; 1086 type = process_arg(event, arg, &token); 1087 if (test_type_token(type, token, EVENT_OP, "]")) 1088 goto out_free; 1089 1090 top->op.right = arg; 1091 1092 free_token(token); 1093 type = read_token_item(&token); 1094 *tok = token; 1095 1096 return type; 1097 1098 out_free: 1099 free_token(*tok); 1100 free_arg(arg); 1101 return EVENT_ERROR; 1102 } 1103 1104 static int get_op_prio(char *op) 1105 { 1106 if (!op[1]) { 1107 switch (op[0]) { 1108 case '*': 1109 case '/': 1110 case '%': 1111 return 6; 1112 case '+': 1113 case '-': 1114 return 7; 1115 /* '>>' and '<<' are 8 */ 1116 case '<': 1117 case '>': 1118 return 9; 1119 /* '==' and '!=' are 10 */ 1120 case '&': 1121 return 11; 1122 case '^': 1123 return 12; 1124 case '|': 1125 return 13; 1126 case '?': 1127 return 16; 1128 default: 1129 die("unknown op '%c'", op[0]); 1130 return -1; 1131 } 1132 } else { 1133 if (strcmp(op, "++") == 0 || 1134 strcmp(op, "--") == 0) { 1135 return 3; 1136 } else if (strcmp(op, ">>") == 0 || 1137 strcmp(op, "<<") == 0) { 1138 return 8; 1139 } else if (strcmp(op, ">=") == 0 || 1140 strcmp(op, "<=") == 0) { 1141 return 9; 1142 } else if (strcmp(op, "==") == 0 || 1143 strcmp(op, "!=") == 0) { 1144 return 10; 1145 } else if (strcmp(op, "&&") == 0) { 1146 return 14; 1147 } else if (strcmp(op, "||") == 0) { 1148 return 15; 1149 } else { 1150 die("unknown op '%s'", op); 1151 return -1; 1152 } 1153 } 1154 } 1155 1156 static void set_op_prio(struct print_arg *arg) 1157 { 1158 1159 /* single ops are the greatest */ 1160 if (!arg->op.left || arg->op.left->type == PRINT_NULL) { 1161 arg->op.prio = 0; 1162 return; 1163 } 1164 1165 arg->op.prio = get_op_prio(arg->op.op); 1166 } 1167 1168 static enum event_type 1169 process_op(struct event *event, struct print_arg *arg, char **tok) 1170 { 1171 struct print_arg *left, *right = NULL; 1172 enum event_type type; 1173 char *token; 1174 1175 /* the op is passed in via tok */ 1176 token = *tok; 1177 1178 if (arg->type == PRINT_OP && !arg->op.left) { 1179 /* handle single op */ 1180 if (token[1]) { 1181 die("bad op token %s", token); 1182 return EVENT_ERROR; 1183 } 1184 switch (token[0]) { 1185 case '!': 1186 case '+': 1187 case '-': 1188 break; 1189 default: 1190 die("bad op token %s", token); 1191 return EVENT_ERROR; 1192 } 1193 1194 /* make an empty left */ 1195 left = malloc_or_die(sizeof(*left)); 1196 left->type = PRINT_NULL; 1197 arg->op.left = left; 1198 1199 right = malloc_or_die(sizeof(*right)); 1200 arg->op.right = right; 1201 1202 type = process_arg(event, right, tok); 1203 1204 } else if (strcmp(token, "?") == 0) { 1205 1206 left = malloc_or_die(sizeof(*left)); 1207 /* copy the top arg to the left */ 1208 *left = *arg; 1209 1210 arg->type = PRINT_OP; 1211 arg->op.op = token; 1212 arg->op.left = left; 1213 arg->op.prio = 0; 1214 1215 type = process_cond(event, arg, tok); 1216 1217 } else if (strcmp(token, ">>") == 0 || 1218 strcmp(token, "<<") == 0 || 1219 strcmp(token, "&") == 0 || 1220 strcmp(token, "|") == 0 || 1221 strcmp(token, "&&") == 0 || 1222 strcmp(token, "||") == 0 || 1223 strcmp(token, "-") == 0 || 1224 strcmp(token, "+") == 0 || 1225 strcmp(token, "*") == 0 || 1226 strcmp(token, "^") == 0 || 1227 strcmp(token, "/") == 0 || 1228 strcmp(token, "<") == 0 || 1229 strcmp(token, ">") == 0 || 1230 strcmp(token, "==") == 0 || 1231 strcmp(token, "!=") == 0) { 1232 1233 left = malloc_or_die(sizeof(*left)); 1234 1235 /* copy the top arg to the left */ 1236 *left = *arg; 1237 1238 arg->type = PRINT_OP; 1239 arg->op.op = token; 1240 arg->op.left = left; 1241 1242 set_op_prio(arg); 1243 1244 right = malloc_or_die(sizeof(*right)); 1245 1246 type = read_token_item(&token); 1247 *tok = token; 1248 1249 /* could just be a type pointer */ 1250 if ((strcmp(arg->op.op, "*") == 0) && 1251 type == EVENT_DELIM && (strcmp(token, ")") == 0)) { 1252 if (left->type != PRINT_ATOM) 1253 die("bad pointer type"); 1254 left->atom.atom = realloc(left->atom.atom, 1255 sizeof(left->atom.atom) + 3); 1256 strcat(left->atom.atom, " *"); 1257 *arg = *left; 1258 free(arg); 1259 1260 return type; 1261 } 1262 1263 type = process_arg_token(event, right, tok, type); 1264 1265 arg->op.right = right; 1266 1267 } else if (strcmp(token, "[") == 0) { 1268 1269 left = malloc_or_die(sizeof(*left)); 1270 *left = *arg; 1271 1272 arg->type = PRINT_OP; 1273 arg->op.op = token; 1274 arg->op.left = left; 1275 1276 arg->op.prio = 0; 1277 type = process_array(event, arg, tok); 1278 1279 } else { 1280 warning("unknown op '%s'", token); 1281 event->flags |= EVENT_FL_FAILED; 1282 /* the arg is now the left side */ 1283 return EVENT_NONE; 1284 } 1285 1286 if (type == EVENT_OP) { 1287 int prio; 1288 1289 /* higher prios need to be closer to the root */ 1290 prio = get_op_prio(*tok); 1291 1292 if (prio > arg->op.prio) 1293 return process_op(event, arg, tok); 1294 1295 return process_op(event, right, tok); 1296 } 1297 1298 return type; 1299 } 1300 1301 static enum event_type 1302 process_entry(struct event *event __unused, struct print_arg *arg, 1303 char **tok) 1304 { 1305 enum event_type type; 1306 char *field; 1307 char *token; 1308 1309 if (read_expected(EVENT_OP, "->") < 0) 1310 return EVENT_ERROR; 1311 1312 if (read_expect_type(EVENT_ITEM, &token) < 0) 1313 goto fail; 1314 field = token; 1315 1316 arg->type = PRINT_FIELD; 1317 arg->field.name = field; 1318 1319 if (is_flag_field) { 1320 arg->field.field = find_any_field(event, arg->field.name); 1321 arg->field.field->flags |= FIELD_IS_FLAG; 1322 is_flag_field = 0; 1323 } else if (is_symbolic_field) { 1324 arg->field.field = find_any_field(event, arg->field.name); 1325 arg->field.field->flags |= FIELD_IS_SYMBOLIC; 1326 is_symbolic_field = 0; 1327 } 1328 1329 type = read_token(&token); 1330 *tok = token; 1331 1332 return type; 1333 1334 fail: 1335 free_token(token); 1336 return EVENT_ERROR; 1337 } 1338 1339 static char *arg_eval (struct print_arg *arg); 1340 1341 static long long arg_num_eval(struct print_arg *arg) 1342 { 1343 long long left, right; 1344 long long val = 0; 1345 1346 switch (arg->type) { 1347 case PRINT_ATOM: 1348 val = strtoll(arg->atom.atom, NULL, 0); 1349 break; 1350 case PRINT_TYPE: 1351 val = arg_num_eval(arg->typecast.item); 1352 break; 1353 case PRINT_OP: 1354 switch (arg->op.op[0]) { 1355 case '|': 1356 left = arg_num_eval(arg->op.left); 1357 right = arg_num_eval(arg->op.right); 1358 if (arg->op.op[1]) 1359 val = left || right; 1360 else 1361 val = left | right; 1362 break; 1363 case '&': 1364 left = arg_num_eval(arg->op.left); 1365 right = arg_num_eval(arg->op.right); 1366 if (arg->op.op[1]) 1367 val = left && right; 1368 else 1369 val = left & right; 1370 break; 1371 case '<': 1372 left = arg_num_eval(arg->op.left); 1373 right = arg_num_eval(arg->op.right); 1374 switch (arg->op.op[1]) { 1375 case 0: 1376 val = left < right; 1377 break; 1378 case '<': 1379 val = left << right; 1380 break; 1381 case '=': 1382 val = left <= right; 1383 break; 1384 default: 1385 die("unknown op '%s'", arg->op.op); 1386 } 1387 break; 1388 case '>': 1389 left = arg_num_eval(arg->op.left); 1390 right = arg_num_eval(arg->op.right); 1391 switch (arg->op.op[1]) { 1392 case 0: 1393 val = left > right; 1394 break; 1395 case '>': 1396 val = left >> right; 1397 break; 1398 case '=': 1399 val = left >= right; 1400 break; 1401 default: 1402 die("unknown op '%s'", arg->op.op); 1403 } 1404 break; 1405 case '=': 1406 left = arg_num_eval(arg->op.left); 1407 right = arg_num_eval(arg->op.right); 1408 1409 if (arg->op.op[1] != '=') 1410 die("unknown op '%s'", arg->op.op); 1411 1412 val = left == right; 1413 break; 1414 case '!': 1415 left = arg_num_eval(arg->op.left); 1416 right = arg_num_eval(arg->op.right); 1417 1418 switch (arg->op.op[1]) { 1419 case '=': 1420 val = left != right; 1421 break; 1422 default: 1423 die("unknown op '%s'", arg->op.op); 1424 } 1425 break; 1426 case '+': 1427 left = arg_num_eval(arg->op.left); 1428 right = arg_num_eval(arg->op.right); 1429 val = left + right; 1430 break; 1431 default: 1432 die("unknown op '%s'", arg->op.op); 1433 } 1434 break; 1435 1436 case PRINT_NULL: 1437 case PRINT_FIELD ... PRINT_SYMBOL: 1438 case PRINT_STRING: 1439 default: 1440 die("invalid eval type %d", arg->type); 1441 1442 } 1443 return val; 1444 } 1445 1446 static char *arg_eval (struct print_arg *arg) 1447 { 1448 long long val; 1449 static char buf[20]; 1450 1451 switch (arg->type) { 1452 case PRINT_ATOM: 1453 return arg->atom.atom; 1454 case PRINT_TYPE: 1455 return arg_eval(arg->typecast.item); 1456 case PRINT_OP: 1457 val = arg_num_eval(arg); 1458 sprintf(buf, "%lld", val); 1459 return buf; 1460 1461 case PRINT_NULL: 1462 case PRINT_FIELD ... PRINT_SYMBOL: 1463 case PRINT_STRING: 1464 default: 1465 die("invalid eval type %d", arg->type); 1466 break; 1467 } 1468 1469 return NULL; 1470 } 1471 1472 static enum event_type 1473 process_fields(struct event *event, struct print_flag_sym **list, char **tok) 1474 { 1475 enum event_type type; 1476 struct print_arg *arg = NULL; 1477 struct print_flag_sym *field; 1478 char *token = NULL; 1479 char *value; 1480 1481 do { 1482 free_token(token); 1483 type = read_token_item(&token); 1484 if (test_type_token(type, token, EVENT_OP, "{")) 1485 break; 1486 1487 arg = malloc_or_die(sizeof(*arg)); 1488 1489 free_token(token); 1490 type = process_arg(event, arg, &token); 1491 1492 if (type == EVENT_OP) 1493 type = process_op(event, arg, &token); 1494 1495 if (type == EVENT_ERROR) 1496 goto out_free; 1497 1498 if (test_type_token(type, token, EVENT_DELIM, ",")) 1499 goto out_free; 1500 1501 field = malloc_or_die(sizeof(*field)); 1502 memset(field, 0, sizeof(*field)); 1503 1504 value = arg_eval(arg); 1505 field->value = strdup(value); 1506 1507 free_token(token); 1508 type = process_arg(event, arg, &token); 1509 if (test_type_token(type, token, EVENT_OP, "}")) 1510 goto out_free; 1511 1512 value = arg_eval(arg); 1513 field->str = strdup(value); 1514 free_arg(arg); 1515 arg = NULL; 1516 1517 *list = field; 1518 list = &field->next; 1519 1520 free_token(token); 1521 type = read_token_item(&token); 1522 } while (type == EVENT_DELIM && strcmp(token, ",") == 0); 1523 1524 *tok = token; 1525 return type; 1526 1527 out_free: 1528 free_arg(arg); 1529 free_token(token); 1530 1531 return EVENT_ERROR; 1532 } 1533 1534 static enum event_type 1535 process_flags(struct event *event, struct print_arg *arg, char **tok) 1536 { 1537 struct print_arg *field; 1538 enum event_type type; 1539 char *token; 1540 1541 memset(arg, 0, sizeof(*arg)); 1542 arg->type = PRINT_FLAGS; 1543 1544 if (read_expected_item(EVENT_DELIM, "(") < 0) 1545 return EVENT_ERROR; 1546 1547 field = malloc_or_die(sizeof(*field)); 1548 1549 type = process_arg(event, field, &token); 1550 while (type == EVENT_OP) 1551 type = process_op(event, field, &token); 1552 if (test_type_token(type, token, EVENT_DELIM, ",")) 1553 goto out_free; 1554 1555 arg->flags.field = field; 1556 1557 type = read_token_item(&token); 1558 if (event_item_type(type)) { 1559 arg->flags.delim = token; 1560 type = read_token_item(&token); 1561 } 1562 1563 if (test_type_token(type, token, EVENT_DELIM, ",")) 1564 goto out_free; 1565 1566 type = process_fields(event, &arg->flags.flags, &token); 1567 if (test_type_token(type, token, EVENT_DELIM, ")")) 1568 goto out_free; 1569 1570 free_token(token); 1571 type = read_token_item(tok); 1572 return type; 1573 1574 out_free: 1575 free_token(token); 1576 return EVENT_ERROR; 1577 } 1578 1579 static enum event_type 1580 process_symbols(struct event *event, struct print_arg *arg, char **tok) 1581 { 1582 struct print_arg *field; 1583 enum event_type type; 1584 char *token; 1585 1586 memset(arg, 0, sizeof(*arg)); 1587 arg->type = PRINT_SYMBOL; 1588 1589 if (read_expected_item(EVENT_DELIM, "(") < 0) 1590 return EVENT_ERROR; 1591 1592 field = malloc_or_die(sizeof(*field)); 1593 1594 type = process_arg(event, field, &token); 1595 if (test_type_token(type, token, EVENT_DELIM, ",")) 1596 goto out_free; 1597 1598 arg->symbol.field = field; 1599 1600 type = process_fields(event, &arg->symbol.symbols, &token); 1601 if (test_type_token(type, token, EVENT_DELIM, ")")) 1602 goto out_free; 1603 1604 free_token(token); 1605 type = read_token_item(tok); 1606 return type; 1607 1608 out_free: 1609 free_token(token); 1610 return EVENT_ERROR; 1611 } 1612 1613 static enum event_type 1614 process_paren(struct event *event, struct print_arg *arg, char **tok) 1615 { 1616 struct print_arg *item_arg; 1617 enum event_type type; 1618 char *token; 1619 1620 type = process_arg(event, arg, &token); 1621 1622 if (type == EVENT_ERROR) 1623 return EVENT_ERROR; 1624 1625 if (type == EVENT_OP) 1626 type = process_op(event, arg, &token); 1627 1628 if (type == EVENT_ERROR) 1629 return EVENT_ERROR; 1630 1631 if (test_type_token(type, token, EVENT_DELIM, ")")) { 1632 free_token(token); 1633 return EVENT_ERROR; 1634 } 1635 1636 free_token(token); 1637 type = read_token_item(&token); 1638 1639 /* 1640 * If the next token is an item or another open paren, then 1641 * this was a typecast. 1642 */ 1643 if (event_item_type(type) || 1644 (type == EVENT_DELIM && strcmp(token, "(") == 0)) { 1645 1646 /* make this a typecast and contine */ 1647 1648 /* prevous must be an atom */ 1649 if (arg->type != PRINT_ATOM) 1650 die("previous needed to be PRINT_ATOM"); 1651 1652 item_arg = malloc_or_die(sizeof(*item_arg)); 1653 1654 arg->type = PRINT_TYPE; 1655 arg->typecast.type = arg->atom.atom; 1656 arg->typecast.item = item_arg; 1657 type = process_arg_token(event, item_arg, &token, type); 1658 1659 } 1660 1661 *tok = token; 1662 return type; 1663 } 1664 1665 1666 static enum event_type 1667 process_str(struct event *event __unused, struct print_arg *arg, char **tok) 1668 { 1669 enum event_type type; 1670 char *token; 1671 1672 if (read_expected(EVENT_DELIM, "(") < 0) 1673 return EVENT_ERROR; 1674 1675 if (read_expect_type(EVENT_ITEM, &token) < 0) 1676 goto fail; 1677 1678 arg->type = PRINT_STRING; 1679 arg->string.string = token; 1680 arg->string.offset = -1; 1681 1682 if (read_expected(EVENT_DELIM, ")") < 0) 1683 return EVENT_ERROR; 1684 1685 type = read_token(&token); 1686 *tok = token; 1687 1688 return type; 1689 fail: 1690 free_token(token); 1691 return EVENT_ERROR; 1692 } 1693 1694 enum event_type 1695 process_arg_token(struct event *event, struct print_arg *arg, 1696 char **tok, enum event_type type) 1697 { 1698 char *token; 1699 char *atom; 1700 1701 token = *tok; 1702 1703 switch (type) { 1704 case EVENT_ITEM: 1705 if (strcmp(token, "REC") == 0) { 1706 free_token(token); 1707 type = process_entry(event, arg, &token); 1708 } else if (strcmp(token, "__print_flags") == 0) { 1709 free_token(token); 1710 is_flag_field = 1; 1711 type = process_flags(event, arg, &token); 1712 } else if (strcmp(token, "__print_symbolic") == 0) { 1713 free_token(token); 1714 is_symbolic_field = 1; 1715 type = process_symbols(event, arg, &token); 1716 } else if (strcmp(token, "__get_str") == 0) { 1717 free_token(token); 1718 type = process_str(event, arg, &token); 1719 } else { 1720 atom = token; 1721 /* test the next token */ 1722 type = read_token_item(&token); 1723 1724 /* atoms can be more than one token long */ 1725 while (type == EVENT_ITEM) { 1726 atom = realloc(atom, strlen(atom) + strlen(token) + 2); 1727 strcat(atom, " "); 1728 strcat(atom, token); 1729 free_token(token); 1730 type = read_token_item(&token); 1731 } 1732 1733 /* todo, test for function */ 1734 1735 arg->type = PRINT_ATOM; 1736 arg->atom.atom = atom; 1737 } 1738 break; 1739 case EVENT_DQUOTE: 1740 case EVENT_SQUOTE: 1741 arg->type = PRINT_ATOM; 1742 arg->atom.atom = token; 1743 type = read_token_item(&token); 1744 break; 1745 case EVENT_DELIM: 1746 if (strcmp(token, "(") == 0) { 1747 free_token(token); 1748 type = process_paren(event, arg, &token); 1749 break; 1750 } 1751 case EVENT_OP: 1752 /* handle single ops */ 1753 arg->type = PRINT_OP; 1754 arg->op.op = token; 1755 arg->op.left = NULL; 1756 type = process_op(event, arg, &token); 1757 1758 break; 1759 1760 case EVENT_ERROR ... EVENT_NEWLINE: 1761 default: 1762 die("unexpected type %d", type); 1763 } 1764 *tok = token; 1765 1766 return type; 1767 } 1768 1769 static int event_read_print_args(struct event *event, struct print_arg **list) 1770 { 1771 enum event_type type = EVENT_ERROR; 1772 struct print_arg *arg; 1773 char *token; 1774 int args = 0; 1775 1776 do { 1777 if (type == EVENT_NEWLINE) { 1778 free_token(token); 1779 type = read_token_item(&token); 1780 continue; 1781 } 1782 1783 arg = malloc_or_die(sizeof(*arg)); 1784 memset(arg, 0, sizeof(*arg)); 1785 1786 type = process_arg(event, arg, &token); 1787 1788 if (type == EVENT_ERROR) { 1789 free_arg(arg); 1790 return -1; 1791 } 1792 1793 *list = arg; 1794 args++; 1795 1796 if (type == EVENT_OP) { 1797 type = process_op(event, arg, &token); 1798 list = &arg->next; 1799 continue; 1800 } 1801 1802 if (type == EVENT_DELIM && strcmp(token, ",") == 0) { 1803 free_token(token); 1804 *list = arg; 1805 list = &arg->next; 1806 continue; 1807 } 1808 break; 1809 } while (type != EVENT_NONE); 1810 1811 if (type != EVENT_NONE) 1812 free_token(token); 1813 1814 return args; 1815 } 1816 1817 static int event_read_print(struct event *event) 1818 { 1819 enum event_type type; 1820 char *token; 1821 int ret; 1822 1823 if (read_expected_item(EVENT_ITEM, "print") < 0) 1824 return -1; 1825 1826 if (read_expected(EVENT_ITEM, "fmt") < 0) 1827 return -1; 1828 1829 if (read_expected(EVENT_OP, ":") < 0) 1830 return -1; 1831 1832 if (read_expect_type(EVENT_DQUOTE, &token) < 0) 1833 goto fail; 1834 1835 concat: 1836 event->print_fmt.format = token; 1837 event->print_fmt.args = NULL; 1838 1839 /* ok to have no arg */ 1840 type = read_token_item(&token); 1841 1842 if (type == EVENT_NONE) 1843 return 0; 1844 1845 /* Handle concatination of print lines */ 1846 if (type == EVENT_DQUOTE) { 1847 char *cat; 1848 1849 cat = malloc_or_die(strlen(event->print_fmt.format) + 1850 strlen(token) + 1); 1851 strcpy(cat, event->print_fmt.format); 1852 strcat(cat, token); 1853 free_token(token); 1854 free_token(event->print_fmt.format); 1855 event->print_fmt.format = NULL; 1856 token = cat; 1857 goto concat; 1858 } 1859 1860 if (test_type_token(type, token, EVENT_DELIM, ",")) 1861 goto fail; 1862 1863 free_token(token); 1864 1865 ret = event_read_print_args(event, &event->print_fmt.args); 1866 if (ret < 0) 1867 return -1; 1868 1869 return ret; 1870 1871 fail: 1872 free_token(token); 1873 return -1; 1874 } 1875 1876 static struct format_field * 1877 find_common_field(struct event *event, const char *name) 1878 { 1879 struct format_field *format; 1880 1881 for (format = event->format.common_fields; 1882 format; format = format->next) { 1883 if (strcmp(format->name, name) == 0) 1884 break; 1885 } 1886 1887 return format; 1888 } 1889 1890 static struct format_field * 1891 find_field(struct event *event, const char *name) 1892 { 1893 struct format_field *format; 1894 1895 for (format = event->format.fields; 1896 format; format = format->next) { 1897 if (strcmp(format->name, name) == 0) 1898 break; 1899 } 1900 1901 return format; 1902 } 1903 1904 static struct format_field * 1905 find_any_field(struct event *event, const char *name) 1906 { 1907 struct format_field *format; 1908 1909 format = find_common_field(event, name); 1910 if (format) 1911 return format; 1912 return find_field(event, name); 1913 } 1914 1915 unsigned long long read_size(void *ptr, int size) 1916 { 1917 switch (size) { 1918 case 1: 1919 return *(unsigned char *)ptr; 1920 case 2: 1921 return data2host2(ptr); 1922 case 4: 1923 return data2host4(ptr); 1924 case 8: 1925 return data2host8(ptr); 1926 default: 1927 /* BUG! */ 1928 return 0; 1929 } 1930 } 1931 1932 unsigned long long 1933 raw_field_value(struct event *event, const char *name, void *data) 1934 { 1935 struct format_field *field; 1936 1937 field = find_any_field(event, name); 1938 if (!field) 1939 return 0ULL; 1940 1941 return read_size(data + field->offset, field->size); 1942 } 1943 1944 void *raw_field_ptr(struct event *event, const char *name, void *data) 1945 { 1946 struct format_field *field; 1947 1948 field = find_any_field(event, name); 1949 if (!field) 1950 return NULL; 1951 1952 if (field->flags & FIELD_IS_DYNAMIC) { 1953 int offset; 1954 1955 offset = *(int *)(data + field->offset); 1956 offset &= 0xffff; 1957 1958 return data + offset; 1959 } 1960 1961 return data + field->offset; 1962 } 1963 1964 static int get_common_info(const char *type, int *offset, int *size) 1965 { 1966 struct event *event; 1967 struct format_field *field; 1968 1969 /* 1970 * All events should have the same common elements. 1971 * Pick any event to find where the type is; 1972 */ 1973 if (!event_list) 1974 die("no event_list!"); 1975 1976 event = event_list; 1977 field = find_common_field(event, type); 1978 if (!field) 1979 die("field '%s' not found", type); 1980 1981 *offset = field->offset; 1982 *size = field->size; 1983 1984 return 0; 1985 } 1986 1987 static int __parse_common(void *data, int *size, int *offset, 1988 const char *name) 1989 { 1990 int ret; 1991 1992 if (!*size) { 1993 ret = get_common_info(name, offset, size); 1994 if (ret < 0) 1995 return ret; 1996 } 1997 return read_size(data + *offset, *size); 1998 } 1999 2000 int trace_parse_common_type(void *data) 2001 { 2002 static int type_offset; 2003 static int type_size; 2004 2005 return __parse_common(data, &type_size, &type_offset, 2006 "common_type"); 2007 } 2008 2009 int trace_parse_common_pid(void *data) 2010 { 2011 static int pid_offset; 2012 static int pid_size; 2013 2014 return __parse_common(data, &pid_size, &pid_offset, 2015 "common_pid"); 2016 } 2017 2018 int parse_common_pc(void *data) 2019 { 2020 static int pc_offset; 2021 static int pc_size; 2022 2023 return __parse_common(data, &pc_size, &pc_offset, 2024 "common_preempt_count"); 2025 } 2026 2027 int parse_common_flags(void *data) 2028 { 2029 static int flags_offset; 2030 static int flags_size; 2031 2032 return __parse_common(data, &flags_size, &flags_offset, 2033 "common_flags"); 2034 } 2035 2036 int parse_common_lock_depth(void *data) 2037 { 2038 static int ld_offset; 2039 static int ld_size; 2040 int ret; 2041 2042 ret = __parse_common(data, &ld_size, &ld_offset, 2043 "common_lock_depth"); 2044 if (ret < 0) 2045 return -1; 2046 2047 return ret; 2048 } 2049 2050 struct event *trace_find_event(int id) 2051 { 2052 struct event *event; 2053 2054 for (event = event_list; event; event = event->next) { 2055 if (event->id == id) 2056 break; 2057 } 2058 return event; 2059 } 2060 2061 struct event *trace_find_next_event(struct event *event) 2062 { 2063 if (!event) 2064 return event_list; 2065 2066 return event->next; 2067 } 2068 2069 static unsigned long long eval_num_arg(void *data, int size, 2070 struct event *event, struct print_arg *arg) 2071 { 2072 unsigned long long val = 0; 2073 unsigned long long left, right; 2074 struct print_arg *larg; 2075 2076 switch (arg->type) { 2077 case PRINT_NULL: 2078 /* ?? */ 2079 return 0; 2080 case PRINT_ATOM: 2081 return strtoull(arg->atom.atom, NULL, 0); 2082 case PRINT_FIELD: 2083 if (!arg->field.field) { 2084 arg->field.field = find_any_field(event, arg->field.name); 2085 if (!arg->field.field) 2086 die("field %s not found", arg->field.name); 2087 } 2088 /* must be a number */ 2089 val = read_size(data + arg->field.field->offset, 2090 arg->field.field->size); 2091 break; 2092 case PRINT_FLAGS: 2093 case PRINT_SYMBOL: 2094 break; 2095 case PRINT_TYPE: 2096 return eval_num_arg(data, size, event, arg->typecast.item); 2097 case PRINT_STRING: 2098 return 0; 2099 break; 2100 case PRINT_OP: 2101 if (strcmp(arg->op.op, "[") == 0) { 2102 /* 2103 * Arrays are special, since we don't want 2104 * to read the arg as is. 2105 */ 2106 if (arg->op.left->type != PRINT_FIELD) 2107 goto default_op; /* oops, all bets off */ 2108 larg = arg->op.left; 2109 if (!larg->field.field) { 2110 larg->field.field = 2111 find_any_field(event, larg->field.name); 2112 if (!larg->field.field) 2113 die("field %s not found", larg->field.name); 2114 } 2115 right = eval_num_arg(data, size, event, arg->op.right); 2116 val = read_size(data + larg->field.field->offset + 2117 right * long_size, long_size); 2118 break; 2119 } 2120 default_op: 2121 left = eval_num_arg(data, size, event, arg->op.left); 2122 right = eval_num_arg(data, size, event, arg->op.right); 2123 switch (arg->op.op[0]) { 2124 case '|': 2125 if (arg->op.op[1]) 2126 val = left || right; 2127 else 2128 val = left | right; 2129 break; 2130 case '&': 2131 if (arg->op.op[1]) 2132 val = left && right; 2133 else 2134 val = left & right; 2135 break; 2136 case '<': 2137 switch (arg->op.op[1]) { 2138 case 0: 2139 val = left < right; 2140 break; 2141 case '<': 2142 val = left << right; 2143 break; 2144 case '=': 2145 val = left <= right; 2146 break; 2147 default: 2148 die("unknown op '%s'", arg->op.op); 2149 } 2150 break; 2151 case '>': 2152 switch (arg->op.op[1]) { 2153 case 0: 2154 val = left > right; 2155 break; 2156 case '>': 2157 val = left >> right; 2158 break; 2159 case '=': 2160 val = left >= right; 2161 break; 2162 default: 2163 die("unknown op '%s'", arg->op.op); 2164 } 2165 break; 2166 case '=': 2167 if (arg->op.op[1] != '=') 2168 die("unknown op '%s'", arg->op.op); 2169 val = left == right; 2170 break; 2171 case '-': 2172 val = left - right; 2173 break; 2174 case '+': 2175 val = left + right; 2176 break; 2177 default: 2178 die("unknown op '%s'", arg->op.op); 2179 } 2180 break; 2181 default: /* not sure what to do there */ 2182 return 0; 2183 } 2184 return val; 2185 } 2186 2187 struct flag { 2188 const char *name; 2189 unsigned long long value; 2190 }; 2191 2192 static const struct flag flags[] = { 2193 { "HI_SOFTIRQ", 0 }, 2194 { "TIMER_SOFTIRQ", 1 }, 2195 { "NET_TX_SOFTIRQ", 2 }, 2196 { "NET_RX_SOFTIRQ", 3 }, 2197 { "BLOCK_SOFTIRQ", 4 }, 2198 { "BLOCK_IOPOLL_SOFTIRQ", 5 }, 2199 { "TASKLET_SOFTIRQ", 6 }, 2200 { "SCHED_SOFTIRQ", 7 }, 2201 { "HRTIMER_SOFTIRQ", 8 }, 2202 { "RCU_SOFTIRQ", 9 }, 2203 2204 { "HRTIMER_NORESTART", 0 }, 2205 { "HRTIMER_RESTART", 1 }, 2206 }; 2207 2208 unsigned long long eval_flag(const char *flag) 2209 { 2210 int i; 2211 2212 /* 2213 * Some flags in the format files do not get converted. 2214 * If the flag is not numeric, see if it is something that 2215 * we already know about. 2216 */ 2217 if (isdigit(flag[0])) 2218 return strtoull(flag, NULL, 0); 2219 2220 for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++) 2221 if (strcmp(flags[i].name, flag) == 0) 2222 return flags[i].value; 2223 2224 return 0; 2225 } 2226 2227 static void print_str_arg(void *data, int size, 2228 struct event *event, struct print_arg *arg) 2229 { 2230 struct print_flag_sym *flag; 2231 unsigned long long val, fval; 2232 char *str; 2233 int print; 2234 2235 switch (arg->type) { 2236 case PRINT_NULL: 2237 /* ?? */ 2238 return; 2239 case PRINT_ATOM: 2240 printf("%s", arg->atom.atom); 2241 return; 2242 case PRINT_FIELD: 2243 if (!arg->field.field) { 2244 arg->field.field = find_any_field(event, arg->field.name); 2245 if (!arg->field.field) 2246 die("field %s not found", arg->field.name); 2247 } 2248 str = malloc_or_die(arg->field.field->size + 1); 2249 memcpy(str, data + arg->field.field->offset, 2250 arg->field.field->size); 2251 str[arg->field.field->size] = 0; 2252 printf("%s", str); 2253 free(str); 2254 break; 2255 case PRINT_FLAGS: 2256 val = eval_num_arg(data, size, event, arg->flags.field); 2257 print = 0; 2258 for (flag = arg->flags.flags; flag; flag = flag->next) { 2259 fval = eval_flag(flag->value); 2260 if (!val && !fval) { 2261 printf("%s", flag->str); 2262 break; 2263 } 2264 if (fval && (val & fval) == fval) { 2265 if (print && arg->flags.delim) 2266 printf("%s", arg->flags.delim); 2267 printf("%s", flag->str); 2268 print = 1; 2269 val &= ~fval; 2270 } 2271 } 2272 break; 2273 case PRINT_SYMBOL: 2274 val = eval_num_arg(data, size, event, arg->symbol.field); 2275 for (flag = arg->symbol.symbols; flag; flag = flag->next) { 2276 fval = eval_flag(flag->value); 2277 if (val == fval) { 2278 printf("%s", flag->str); 2279 break; 2280 } 2281 } 2282 break; 2283 2284 case PRINT_TYPE: 2285 break; 2286 case PRINT_STRING: { 2287 int str_offset; 2288 2289 if (arg->string.offset == -1) { 2290 struct format_field *f; 2291 2292 f = find_any_field(event, arg->string.string); 2293 arg->string.offset = f->offset; 2294 } 2295 str_offset = *(int *)(data + arg->string.offset); 2296 str_offset &= 0xffff; 2297 printf("%s", ((char *)data) + str_offset); 2298 break; 2299 } 2300 case PRINT_OP: 2301 /* 2302 * The only op for string should be ? : 2303 */ 2304 if (arg->op.op[0] != '?') 2305 return; 2306 val = eval_num_arg(data, size, event, arg->op.left); 2307 if (val) 2308 print_str_arg(data, size, event, arg->op.right->op.left); 2309 else 2310 print_str_arg(data, size, event, arg->op.right->op.right); 2311 break; 2312 default: 2313 /* well... */ 2314 break; 2315 } 2316 } 2317 2318 static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event) 2319 { 2320 static struct format_field *field, *ip_field; 2321 struct print_arg *args, *arg, **next; 2322 unsigned long long ip, val; 2323 char *ptr; 2324 void *bptr; 2325 2326 if (!field) { 2327 field = find_field(event, "buf"); 2328 if (!field) 2329 die("can't find buffer field for binary printk"); 2330 ip_field = find_field(event, "ip"); 2331 if (!ip_field) 2332 die("can't find ip field for binary printk"); 2333 } 2334 2335 ip = read_size(data + ip_field->offset, ip_field->size); 2336 2337 /* 2338 * The first arg is the IP pointer. 2339 */ 2340 args = malloc_or_die(sizeof(*args)); 2341 arg = args; 2342 arg->next = NULL; 2343 next = &arg->next; 2344 2345 arg->type = PRINT_ATOM; 2346 arg->atom.atom = malloc_or_die(32); 2347 sprintf(arg->atom.atom, "%lld", ip); 2348 2349 /* skip the first "%pf : " */ 2350 for (ptr = fmt + 6, bptr = data + field->offset; 2351 bptr < data + size && *ptr; ptr++) { 2352 int ls = 0; 2353 2354 if (*ptr == '%') { 2355 process_again: 2356 ptr++; 2357 switch (*ptr) { 2358 case '%': 2359 break; 2360 case 'l': 2361 ls++; 2362 goto process_again; 2363 case 'L': 2364 ls = 2; 2365 goto process_again; 2366 case '0' ... '9': 2367 goto process_again; 2368 case 'p': 2369 ls = 1; 2370 /* fall through */ 2371 case 'd': 2372 case 'u': 2373 case 'x': 2374 case 'i': 2375 /* the pointers are always 4 bytes aligned */ 2376 bptr = (void *)(((unsigned long)bptr + 3) & 2377 ~3); 2378 switch (ls) { 2379 case 0: 2380 case 1: 2381 ls = long_size; 2382 break; 2383 case 2: 2384 ls = 8; 2385 default: 2386 break; 2387 } 2388 val = read_size(bptr, ls); 2389 bptr += ls; 2390 arg = malloc_or_die(sizeof(*arg)); 2391 arg->next = NULL; 2392 arg->type = PRINT_ATOM; 2393 arg->atom.atom = malloc_or_die(32); 2394 sprintf(arg->atom.atom, "%lld", val); 2395 *next = arg; 2396 next = &arg->next; 2397 break; 2398 case 's': 2399 arg = malloc_or_die(sizeof(*arg)); 2400 arg->next = NULL; 2401 arg->type = PRINT_STRING; 2402 arg->string.string = strdup(bptr); 2403 bptr += strlen(bptr) + 1; 2404 *next = arg; 2405 next = &arg->next; 2406 default: 2407 break; 2408 } 2409 } 2410 } 2411 2412 return args; 2413 } 2414 2415 static void free_args(struct print_arg *args) 2416 { 2417 struct print_arg *next; 2418 2419 while (args) { 2420 next = args->next; 2421 2422 if (args->type == PRINT_ATOM) 2423 free(args->atom.atom); 2424 else 2425 free(args->string.string); 2426 free(args); 2427 args = next; 2428 } 2429 } 2430 2431 static char *get_bprint_format(void *data, int size __unused, struct event *event) 2432 { 2433 unsigned long long addr; 2434 static struct format_field *field; 2435 struct printk_map *printk; 2436 char *format; 2437 char *p; 2438 2439 if (!field) { 2440 field = find_field(event, "fmt"); 2441 if (!field) 2442 die("can't find format field for binary printk"); 2443 printf("field->offset = %d size=%d\n", field->offset, field->size); 2444 } 2445 2446 addr = read_size(data + field->offset, field->size); 2447 2448 printk = find_printk(addr); 2449 if (!printk) { 2450 format = malloc_or_die(45); 2451 sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n", 2452 addr); 2453 return format; 2454 } 2455 2456 p = printk->printk; 2457 /* Remove any quotes. */ 2458 if (*p == '"') 2459 p++; 2460 format = malloc_or_die(strlen(p) + 10); 2461 sprintf(format, "%s : %s", "%pf", p); 2462 /* remove ending quotes and new line since we will add one too */ 2463 p = format + strlen(format) - 1; 2464 if (*p == '"') 2465 *p = 0; 2466 2467 p -= 2; 2468 if (strcmp(p, "\\n") == 0) 2469 *p = 0; 2470 2471 return format; 2472 } 2473 2474 static void pretty_print(void *data, int size, struct event *event) 2475 { 2476 struct print_fmt *print_fmt = &event->print_fmt; 2477 struct print_arg *arg = print_fmt->args; 2478 struct print_arg *args = NULL; 2479 const char *ptr = print_fmt->format; 2480 unsigned long long val; 2481 struct func_map *func; 2482 const char *saveptr; 2483 char *bprint_fmt = NULL; 2484 char format[32]; 2485 int show_func; 2486 int len; 2487 int ls; 2488 2489 if (event->flags & EVENT_FL_ISFUNC) 2490 ptr = " %pF <-- %pF"; 2491 2492 if (event->flags & EVENT_FL_ISBPRINT) { 2493 bprint_fmt = get_bprint_format(data, size, event); 2494 args = make_bprint_args(bprint_fmt, data, size, event); 2495 arg = args; 2496 ptr = bprint_fmt; 2497 } 2498 2499 for (; *ptr; ptr++) { 2500 ls = 0; 2501 if (*ptr == '\\') { 2502 ptr++; 2503 switch (*ptr) { 2504 case 'n': 2505 printf("\n"); 2506 break; 2507 case 't': 2508 printf("\t"); 2509 break; 2510 case 'r': 2511 printf("\r"); 2512 break; 2513 case '\\': 2514 printf("\\"); 2515 break; 2516 default: 2517 printf("%c", *ptr); 2518 break; 2519 } 2520 2521 } else if (*ptr == '%') { 2522 saveptr = ptr; 2523 show_func = 0; 2524 cont_process: 2525 ptr++; 2526 switch (*ptr) { 2527 case '%': 2528 printf("%%"); 2529 break; 2530 case 'l': 2531 ls++; 2532 goto cont_process; 2533 case 'L': 2534 ls = 2; 2535 goto cont_process; 2536 case 'z': 2537 case 'Z': 2538 case '0' ... '9': 2539 goto cont_process; 2540 case 'p': 2541 if (long_size == 4) 2542 ls = 1; 2543 else 2544 ls = 2; 2545 2546 if (*(ptr+1) == 'F' || 2547 *(ptr+1) == 'f') { 2548 ptr++; 2549 show_func = *ptr; 2550 } 2551 2552 /* fall through */ 2553 case 'd': 2554 case 'i': 2555 case 'x': 2556 case 'X': 2557 case 'u': 2558 if (!arg) 2559 die("no argument match"); 2560 2561 len = ((unsigned long)ptr + 1) - 2562 (unsigned long)saveptr; 2563 2564 /* should never happen */ 2565 if (len > 32) 2566 die("bad format!"); 2567 2568 memcpy(format, saveptr, len); 2569 format[len] = 0; 2570 2571 val = eval_num_arg(data, size, event, arg); 2572 arg = arg->next; 2573 2574 if (show_func) { 2575 func = find_func(val); 2576 if (func) { 2577 printf("%s", func->func); 2578 if (show_func == 'F') 2579 printf("+0x%llx", 2580 val - func->addr); 2581 break; 2582 } 2583 } 2584 switch (ls) { 2585 case 0: 2586 printf(format, (int)val); 2587 break; 2588 case 1: 2589 printf(format, (long)val); 2590 break; 2591 case 2: 2592 printf(format, (long long)val); 2593 break; 2594 default: 2595 die("bad count (%d)", ls); 2596 } 2597 break; 2598 case 's': 2599 if (!arg) 2600 die("no matching argument"); 2601 2602 print_str_arg(data, size, event, arg); 2603 arg = arg->next; 2604 break; 2605 default: 2606 printf(">%c<", *ptr); 2607 2608 } 2609 } else 2610 printf("%c", *ptr); 2611 } 2612 2613 if (args) { 2614 free_args(args); 2615 free(bprint_fmt); 2616 } 2617 } 2618 2619 static inline int log10_cpu(int nb) 2620 { 2621 if (nb / 100) 2622 return 3; 2623 if (nb / 10) 2624 return 2; 2625 return 1; 2626 } 2627 2628 static void print_lat_fmt(void *data, int size __unused) 2629 { 2630 unsigned int lat_flags; 2631 unsigned int pc; 2632 int lock_depth; 2633 int hardirq; 2634 int softirq; 2635 2636 lat_flags = parse_common_flags(data); 2637 pc = parse_common_pc(data); 2638 lock_depth = parse_common_lock_depth(data); 2639 2640 hardirq = lat_flags & TRACE_FLAG_HARDIRQ; 2641 softirq = lat_flags & TRACE_FLAG_SOFTIRQ; 2642 2643 printf("%c%c%c", 2644 (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' : 2645 (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 2646 'X' : '.', 2647 (lat_flags & TRACE_FLAG_NEED_RESCHED) ? 2648 'N' : '.', 2649 (hardirq && softirq) ? 'H' : 2650 hardirq ? 'h' : softirq ? 's' : '.'); 2651 2652 if (pc) 2653 printf("%x", pc); 2654 else 2655 printf("."); 2656 2657 if (lock_depth < 0) 2658 printf(". "); 2659 else 2660 printf("%d ", lock_depth); 2661 } 2662 2663 #define TRACE_GRAPH_INDENT 2 2664 2665 static struct record * 2666 get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func, 2667 struct record *next) 2668 { 2669 struct format_field *field; 2670 struct event *event; 2671 unsigned long val; 2672 int type; 2673 int pid; 2674 2675 type = trace_parse_common_type(next->data); 2676 event = trace_find_event(type); 2677 if (!event) 2678 return NULL; 2679 2680 if (!(event->flags & EVENT_FL_ISFUNCRET)) 2681 return NULL; 2682 2683 pid = trace_parse_common_pid(next->data); 2684 field = find_field(event, "func"); 2685 if (!field) 2686 die("function return does not have field func"); 2687 2688 val = read_size(next->data + field->offset, field->size); 2689 2690 if (cur_pid != pid || cur_func != val) 2691 return NULL; 2692 2693 /* this is a leaf, now advance the iterator */ 2694 return trace_read_data(cpu); 2695 } 2696 2697 /* Signal a overhead of time execution to the output */ 2698 static void print_graph_overhead(unsigned long long duration) 2699 { 2700 /* Non nested entry or return */ 2701 if (duration == ~0ULL) 2702 return (void)printf(" "); 2703 2704 /* Duration exceeded 100 msecs */ 2705 if (duration > 100000ULL) 2706 return (void)printf("! "); 2707 2708 /* Duration exceeded 10 msecs */ 2709 if (duration > 10000ULL) 2710 return (void)printf("+ "); 2711 2712 printf(" "); 2713 } 2714 2715 static void print_graph_duration(unsigned long long duration) 2716 { 2717 unsigned long usecs = duration / 1000; 2718 unsigned long nsecs_rem = duration % 1000; 2719 /* log10(ULONG_MAX) + '\0' */ 2720 char msecs_str[21]; 2721 char nsecs_str[5]; 2722 int len; 2723 int i; 2724 2725 sprintf(msecs_str, "%lu", usecs); 2726 2727 /* Print msecs */ 2728 len = printf("%lu", usecs); 2729 2730 /* Print nsecs (we don't want to exceed 7 numbers) */ 2731 if (len < 7) { 2732 snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem); 2733 len += printf(".%s", nsecs_str); 2734 } 2735 2736 printf(" us "); 2737 2738 /* Print remaining spaces to fit the row's width */ 2739 for (i = len; i < 7; i++) 2740 printf(" "); 2741 2742 printf("| "); 2743 } 2744 2745 static void 2746 print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec) 2747 { 2748 unsigned long long rettime, calltime; 2749 unsigned long long duration, depth; 2750 unsigned long long val; 2751 struct format_field *field; 2752 struct func_map *func; 2753 struct event *ret_event; 2754 int type; 2755 int i; 2756 2757 type = trace_parse_common_type(ret_rec->data); 2758 ret_event = trace_find_event(type); 2759 2760 field = find_field(ret_event, "rettime"); 2761 if (!field) 2762 die("can't find rettime in return graph"); 2763 rettime = read_size(ret_rec->data + field->offset, field->size); 2764 2765 field = find_field(ret_event, "calltime"); 2766 if (!field) 2767 die("can't find rettime in return graph"); 2768 calltime = read_size(ret_rec->data + field->offset, field->size); 2769 2770 duration = rettime - calltime; 2771 2772 /* Overhead */ 2773 print_graph_overhead(duration); 2774 2775 /* Duration */ 2776 print_graph_duration(duration); 2777 2778 field = find_field(event, "depth"); 2779 if (!field) 2780 die("can't find depth in entry graph"); 2781 depth = read_size(data + field->offset, field->size); 2782 2783 /* Function */ 2784 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2785 printf(" "); 2786 2787 field = find_field(event, "func"); 2788 if (!field) 2789 die("can't find func in entry graph"); 2790 val = read_size(data + field->offset, field->size); 2791 func = find_func(val); 2792 2793 if (func) 2794 printf("%s();", func->func); 2795 else 2796 printf("%llx();", val); 2797 } 2798 2799 static void print_graph_nested(struct event *event, void *data) 2800 { 2801 struct format_field *field; 2802 unsigned long long depth; 2803 unsigned long long val; 2804 struct func_map *func; 2805 int i; 2806 2807 /* No overhead */ 2808 print_graph_overhead(-1); 2809 2810 /* No time */ 2811 printf(" | "); 2812 2813 field = find_field(event, "depth"); 2814 if (!field) 2815 die("can't find depth in entry graph"); 2816 depth = read_size(data + field->offset, field->size); 2817 2818 /* Function */ 2819 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2820 printf(" "); 2821 2822 field = find_field(event, "func"); 2823 if (!field) 2824 die("can't find func in entry graph"); 2825 val = read_size(data + field->offset, field->size); 2826 func = find_func(val); 2827 2828 if (func) 2829 printf("%s() {", func->func); 2830 else 2831 printf("%llx() {", val); 2832 } 2833 2834 static void 2835 pretty_print_func_ent(void *data, int size, struct event *event, 2836 int cpu, int pid) 2837 { 2838 struct format_field *field; 2839 struct record *rec; 2840 void *copy_data; 2841 unsigned long val; 2842 2843 if (latency_format) { 2844 print_lat_fmt(data, size); 2845 printf(" | "); 2846 } 2847 2848 field = find_field(event, "func"); 2849 if (!field) 2850 die("function entry does not have func field"); 2851 2852 val = read_size(data + field->offset, field->size); 2853 2854 /* 2855 * peek_data may unmap the data pointer. Copy it first. 2856 */ 2857 copy_data = malloc_or_die(size); 2858 memcpy(copy_data, data, size); 2859 data = copy_data; 2860 2861 rec = trace_peek_data(cpu); 2862 if (rec) { 2863 rec = get_return_for_leaf(cpu, pid, val, rec); 2864 if (rec) { 2865 print_graph_entry_leaf(event, data, rec); 2866 goto out_free; 2867 } 2868 } 2869 print_graph_nested(event, data); 2870 out_free: 2871 free(data); 2872 } 2873 2874 static void 2875 pretty_print_func_ret(void *data, int size __unused, struct event *event) 2876 { 2877 unsigned long long rettime, calltime; 2878 unsigned long long duration, depth; 2879 struct format_field *field; 2880 int i; 2881 2882 if (latency_format) { 2883 print_lat_fmt(data, size); 2884 printf(" | "); 2885 } 2886 2887 field = find_field(event, "rettime"); 2888 if (!field) 2889 die("can't find rettime in return graph"); 2890 rettime = read_size(data + field->offset, field->size); 2891 2892 field = find_field(event, "calltime"); 2893 if (!field) 2894 die("can't find calltime in return graph"); 2895 calltime = read_size(data + field->offset, field->size); 2896 2897 duration = rettime - calltime; 2898 2899 /* Overhead */ 2900 print_graph_overhead(duration); 2901 2902 /* Duration */ 2903 print_graph_duration(duration); 2904 2905 field = find_field(event, "depth"); 2906 if (!field) 2907 die("can't find depth in entry graph"); 2908 depth = read_size(data + field->offset, field->size); 2909 2910 /* Function */ 2911 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2912 printf(" "); 2913 2914 printf("}"); 2915 } 2916 2917 static void 2918 pretty_print_func_graph(void *data, int size, struct event *event, 2919 int cpu, int pid) 2920 { 2921 if (event->flags & EVENT_FL_ISFUNCENT) 2922 pretty_print_func_ent(data, size, event, cpu, pid); 2923 else if (event->flags & EVENT_FL_ISFUNCRET) 2924 pretty_print_func_ret(data, size, event); 2925 printf("\n"); 2926 } 2927 2928 void print_trace_event(int cpu, void *data, int size) 2929 { 2930 struct event *event; 2931 int type; 2932 int pid; 2933 2934 type = trace_parse_common_type(data); 2935 2936 event = trace_find_event(type); 2937 if (!event) { 2938 warning("ug! no event found for type %d", type); 2939 return; 2940 } 2941 2942 pid = trace_parse_common_pid(data); 2943 2944 if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET)) 2945 return pretty_print_func_graph(data, size, event, cpu, pid); 2946 2947 if (latency_format) 2948 print_lat_fmt(data, size); 2949 2950 if (event->flags & EVENT_FL_FAILED) { 2951 printf("EVENT '%s' FAILED TO PARSE\n", 2952 event->name); 2953 return; 2954 } 2955 2956 pretty_print(data, size, event); 2957 } 2958 2959 static void print_fields(struct print_flag_sym *field) 2960 { 2961 printf("{ %s, %s }", field->value, field->str); 2962 if (field->next) { 2963 printf(", "); 2964 print_fields(field->next); 2965 } 2966 } 2967 2968 static void print_args(struct print_arg *args) 2969 { 2970 int print_paren = 1; 2971 2972 switch (args->type) { 2973 case PRINT_NULL: 2974 printf("null"); 2975 break; 2976 case PRINT_ATOM: 2977 printf("%s", args->atom.atom); 2978 break; 2979 case PRINT_FIELD: 2980 printf("REC->%s", args->field.name); 2981 break; 2982 case PRINT_FLAGS: 2983 printf("__print_flags("); 2984 print_args(args->flags.field); 2985 printf(", %s, ", args->flags.delim); 2986 print_fields(args->flags.flags); 2987 printf(")"); 2988 break; 2989 case PRINT_SYMBOL: 2990 printf("__print_symbolic("); 2991 print_args(args->symbol.field); 2992 printf(", "); 2993 print_fields(args->symbol.symbols); 2994 printf(")"); 2995 break; 2996 case PRINT_STRING: 2997 printf("__get_str(%s)", args->string.string); 2998 break; 2999 case PRINT_TYPE: 3000 printf("(%s)", args->typecast.type); 3001 print_args(args->typecast.item); 3002 break; 3003 case PRINT_OP: 3004 if (strcmp(args->op.op, ":") == 0) 3005 print_paren = 0; 3006 if (print_paren) 3007 printf("("); 3008 print_args(args->op.left); 3009 printf(" %s ", args->op.op); 3010 print_args(args->op.right); 3011 if (print_paren) 3012 printf(")"); 3013 break; 3014 default: 3015 /* we should warn... */ 3016 return; 3017 } 3018 if (args->next) { 3019 printf("\n"); 3020 print_args(args->next); 3021 } 3022 } 3023 3024 int parse_ftrace_file(char *buf, unsigned long size) 3025 { 3026 struct format_field *field; 3027 struct print_arg *arg, **list; 3028 struct event *event; 3029 int ret; 3030 3031 init_input_buf(buf, size); 3032 3033 event = alloc_event(); 3034 if (!event) 3035 return -ENOMEM; 3036 3037 event->flags |= EVENT_FL_ISFTRACE; 3038 3039 event->name = event_read_name(); 3040 if (!event->name) 3041 die("failed to read ftrace event name"); 3042 3043 if (strcmp(event->name, "function") == 0) 3044 event->flags |= EVENT_FL_ISFUNC; 3045 3046 else if (strcmp(event->name, "funcgraph_entry") == 0) 3047 event->flags |= EVENT_FL_ISFUNCENT; 3048 3049 else if (strcmp(event->name, "funcgraph_exit") == 0) 3050 event->flags |= EVENT_FL_ISFUNCRET; 3051 3052 else if (strcmp(event->name, "bprint") == 0) 3053 event->flags |= EVENT_FL_ISBPRINT; 3054 3055 event->id = event_read_id(); 3056 if (event->id < 0) 3057 die("failed to read ftrace event id"); 3058 3059 add_event(event); 3060 3061 ret = event_read_format(event); 3062 if (ret < 0) 3063 die("failed to read ftrace event format"); 3064 3065 ret = event_read_print(event); 3066 if (ret < 0) 3067 die("failed to read ftrace event print fmt"); 3068 3069 /* New ftrace handles args */ 3070 if (ret > 0) 3071 return 0; 3072 /* 3073 * The arguments for ftrace files are parsed by the fields. 3074 * Set up the fields as their arguments. 3075 */ 3076 list = &event->print_fmt.args; 3077 for (field = event->format.fields; field; field = field->next) { 3078 arg = malloc_or_die(sizeof(*arg)); 3079 memset(arg, 0, sizeof(*arg)); 3080 *list = arg; 3081 list = &arg->next; 3082 arg->type = PRINT_FIELD; 3083 arg->field.name = field->name; 3084 arg->field.field = field; 3085 } 3086 return 0; 3087 } 3088 3089 int parse_event_file(char *buf, unsigned long size, char *sys) 3090 { 3091 struct event *event; 3092 int ret; 3093 3094 init_input_buf(buf, size); 3095 3096 event = alloc_event(); 3097 if (!event) 3098 return -ENOMEM; 3099 3100 event->name = event_read_name(); 3101 if (!event->name) 3102 die("failed to read event name"); 3103 3104 event->id = event_read_id(); 3105 if (event->id < 0) 3106 die("failed to read event id"); 3107 3108 ret = event_read_format(event); 3109 if (ret < 0) { 3110 warning("failed to read event format for %s", event->name); 3111 goto event_failed; 3112 } 3113 3114 ret = event_read_print(event); 3115 if (ret < 0) { 3116 warning("failed to read event print fmt for %s", event->name); 3117 goto event_failed; 3118 } 3119 3120 event->system = strdup(sys); 3121 3122 #define PRINT_ARGS 0 3123 if (PRINT_ARGS && event->print_fmt.args) 3124 print_args(event->print_fmt.args); 3125 3126 add_event(event); 3127 return 0; 3128 3129 event_failed: 3130 event->flags |= EVENT_FL_FAILED; 3131 /* still add it even if it failed */ 3132 add_event(event); 3133 return -1; 3134 } 3135 3136 void parse_set_info(int nr_cpus, int long_sz) 3137 { 3138 cpus = nr_cpus; 3139 long_size = long_sz; 3140 } 3141 3142 int common_pc(struct scripting_context *context) 3143 { 3144 return parse_common_pc(context->event_data); 3145 } 3146 3147 int common_flags(struct scripting_context *context) 3148 { 3149 return parse_common_flags(context->event_data); 3150 } 3151 3152 int common_lock_depth(struct scripting_context *context) 3153 { 3154 return parse_common_lock_depth(context->event_data); 3155 } 3156