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