1 /* 2 * Copyright (C) 2009, Steven Rostedt <srostedt (at) 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 { "RCU_SOFTIRQ", 9 }, 2191 2192 { "HRTIMER_NORESTART", 0 }, 2193 { "HRTIMER_RESTART", 1 }, 2194 }; 2195 2196 unsigned long long eval_flag(const char *flag) 2197 { 2198 int i; 2199 2200 /* 2201 * Some flags in the format files do not get converted. 2202 * If the flag is not numeric, see if it is something that 2203 * we already know about. 2204 */ 2205 if (isdigit(flag[0])) 2206 return strtoull(flag, NULL, 0); 2207 2208 for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++) 2209 if (strcmp(flags[i].name, flag) == 0) 2210 return flags[i].value; 2211 2212 return 0; 2213 } 2214 2215 static void print_str_arg(void *data, int size, 2216 struct event *event, struct print_arg *arg) 2217 { 2218 struct print_flag_sym *flag; 2219 unsigned long long val, fval; 2220 char *str; 2221 int print; 2222 2223 switch (arg->type) { 2224 case PRINT_NULL: 2225 /* ?? */ 2226 return; 2227 case PRINT_ATOM: 2228 printf("%s", arg->atom.atom); 2229 return; 2230 case PRINT_FIELD: 2231 if (!arg->field.field) { 2232 arg->field.field = find_any_field(event, arg->field.name); 2233 if (!arg->field.field) 2234 die("field %s not found", arg->field.name); 2235 } 2236 str = malloc_or_die(arg->field.field->size + 1); 2237 memcpy(str, data + arg->field.field->offset, 2238 arg->field.field->size); 2239 str[arg->field.field->size] = 0; 2240 printf("%s", str); 2241 free(str); 2242 break; 2243 case PRINT_FLAGS: 2244 val = eval_num_arg(data, size, event, arg->flags.field); 2245 print = 0; 2246 for (flag = arg->flags.flags; flag; flag = flag->next) { 2247 fval = eval_flag(flag->value); 2248 if (!val && !fval) { 2249 printf("%s", flag->str); 2250 break; 2251 } 2252 if (fval && (val & fval) == fval) { 2253 if (print && arg->flags.delim) 2254 printf("%s", arg->flags.delim); 2255 printf("%s", flag->str); 2256 print = 1; 2257 val &= ~fval; 2258 } 2259 } 2260 break; 2261 case PRINT_SYMBOL: 2262 val = eval_num_arg(data, size, event, arg->symbol.field); 2263 for (flag = arg->symbol.symbols; flag; flag = flag->next) { 2264 fval = eval_flag(flag->value); 2265 if (val == fval) { 2266 printf("%s", flag->str); 2267 break; 2268 } 2269 } 2270 break; 2271 2272 case PRINT_TYPE: 2273 break; 2274 case PRINT_STRING: { 2275 int str_offset; 2276 2277 if (arg->string.offset == -1) { 2278 struct format_field *f; 2279 2280 f = find_any_field(event, arg->string.string); 2281 arg->string.offset = f->offset; 2282 } 2283 str_offset = *(int *)(data + arg->string.offset); 2284 str_offset &= 0xffff; 2285 printf("%s", ((char *)data) + str_offset); 2286 break; 2287 } 2288 case PRINT_OP: 2289 /* 2290 * The only op for string should be ? : 2291 */ 2292 if (arg->op.op[0] != '?') 2293 return; 2294 val = eval_num_arg(data, size, event, arg->op.left); 2295 if (val) 2296 print_str_arg(data, size, event, arg->op.right->op.left); 2297 else 2298 print_str_arg(data, size, event, arg->op.right->op.right); 2299 break; 2300 default: 2301 /* well... */ 2302 break; 2303 } 2304 } 2305 2306 static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event) 2307 { 2308 static struct format_field *field, *ip_field; 2309 struct print_arg *args, *arg, **next; 2310 unsigned long long ip, val; 2311 char *ptr; 2312 void *bptr; 2313 2314 if (!field) { 2315 field = find_field(event, "buf"); 2316 if (!field) 2317 die("can't find buffer field for binary printk"); 2318 ip_field = find_field(event, "ip"); 2319 if (!ip_field) 2320 die("can't find ip field for binary printk"); 2321 } 2322 2323 ip = read_size(data + ip_field->offset, ip_field->size); 2324 2325 /* 2326 * The first arg is the IP pointer. 2327 */ 2328 args = malloc_or_die(sizeof(*args)); 2329 arg = args; 2330 arg->next = NULL; 2331 next = &arg->next; 2332 2333 arg->type = PRINT_ATOM; 2334 arg->atom.atom = malloc_or_die(32); 2335 sprintf(arg->atom.atom, "%lld", ip); 2336 2337 /* skip the first "%pf : " */ 2338 for (ptr = fmt + 6, bptr = data + field->offset; 2339 bptr < data + size && *ptr; ptr++) { 2340 int ls = 0; 2341 2342 if (*ptr == '%') { 2343 process_again: 2344 ptr++; 2345 switch (*ptr) { 2346 case '%': 2347 break; 2348 case 'l': 2349 ls++; 2350 goto process_again; 2351 case 'L': 2352 ls = 2; 2353 goto process_again; 2354 case '0' ... '9': 2355 goto process_again; 2356 case 'p': 2357 ls = 1; 2358 /* fall through */ 2359 case 'd': 2360 case 'u': 2361 case 'x': 2362 case 'i': 2363 /* the pointers are always 4 bytes aligned */ 2364 bptr = (void *)(((unsigned long)bptr + 3) & 2365 ~3); 2366 switch (ls) { 2367 case 0: 2368 case 1: 2369 ls = long_size; 2370 break; 2371 case 2: 2372 ls = 8; 2373 default: 2374 break; 2375 } 2376 val = read_size(bptr, ls); 2377 bptr += ls; 2378 arg = malloc_or_die(sizeof(*arg)); 2379 arg->next = NULL; 2380 arg->type = PRINT_ATOM; 2381 arg->atom.atom = malloc_or_die(32); 2382 sprintf(arg->atom.atom, "%lld", val); 2383 *next = arg; 2384 next = &arg->next; 2385 break; 2386 case 's': 2387 arg = malloc_or_die(sizeof(*arg)); 2388 arg->next = NULL; 2389 arg->type = PRINT_STRING; 2390 arg->string.string = strdup(bptr); 2391 bptr += strlen(bptr) + 1; 2392 *next = arg; 2393 next = &arg->next; 2394 default: 2395 break; 2396 } 2397 } 2398 } 2399 2400 return args; 2401 } 2402 2403 static void free_args(struct print_arg *args) 2404 { 2405 struct print_arg *next; 2406 2407 while (args) { 2408 next = args->next; 2409 2410 if (args->type == PRINT_ATOM) 2411 free(args->atom.atom); 2412 else 2413 free(args->string.string); 2414 free(args); 2415 args = next; 2416 } 2417 } 2418 2419 static char *get_bprint_format(void *data, int size __unused, struct event *event) 2420 { 2421 unsigned long long addr; 2422 static struct format_field *field; 2423 struct printk_map *printk; 2424 char *format; 2425 char *p; 2426 2427 if (!field) { 2428 field = find_field(event, "fmt"); 2429 if (!field) 2430 die("can't find format field for binary printk"); 2431 printf("field->offset = %d size=%d\n", field->offset, field->size); 2432 } 2433 2434 addr = read_size(data + field->offset, field->size); 2435 2436 printk = find_printk(addr); 2437 if (!printk) { 2438 format = malloc_or_die(45); 2439 sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n", 2440 addr); 2441 return format; 2442 } 2443 2444 p = printk->printk; 2445 /* Remove any quotes. */ 2446 if (*p == '"') 2447 p++; 2448 format = malloc_or_die(strlen(p) + 10); 2449 sprintf(format, "%s : %s", "%pf", p); 2450 /* remove ending quotes and new line since we will add one too */ 2451 p = format + strlen(format) - 1; 2452 if (*p == '"') 2453 *p = 0; 2454 2455 p -= 2; 2456 if (strcmp(p, "\\n") == 0) 2457 *p = 0; 2458 2459 return format; 2460 } 2461 2462 static void pretty_print(void *data, int size, struct event *event) 2463 { 2464 struct print_fmt *print_fmt = &event->print_fmt; 2465 struct print_arg *arg = print_fmt->args; 2466 struct print_arg *args = NULL; 2467 const char *ptr = print_fmt->format; 2468 unsigned long long val; 2469 struct func_map *func; 2470 const char *saveptr; 2471 char *bprint_fmt = NULL; 2472 char format[32]; 2473 int show_func; 2474 int len; 2475 int ls; 2476 2477 if (event->flags & EVENT_FL_ISFUNC) 2478 ptr = " %pF <-- %pF"; 2479 2480 if (event->flags & EVENT_FL_ISBPRINT) { 2481 bprint_fmt = get_bprint_format(data, size, event); 2482 args = make_bprint_args(bprint_fmt, data, size, event); 2483 arg = args; 2484 ptr = bprint_fmt; 2485 } 2486 2487 for (; *ptr; ptr++) { 2488 ls = 0; 2489 if (*ptr == '\\') { 2490 ptr++; 2491 switch (*ptr) { 2492 case 'n': 2493 printf("\n"); 2494 break; 2495 case 't': 2496 printf("\t"); 2497 break; 2498 case 'r': 2499 printf("\r"); 2500 break; 2501 case '\\': 2502 printf("\\"); 2503 break; 2504 default: 2505 printf("%c", *ptr); 2506 break; 2507 } 2508 2509 } else if (*ptr == '%') { 2510 saveptr = ptr; 2511 show_func = 0; 2512 cont_process: 2513 ptr++; 2514 switch (*ptr) { 2515 case '%': 2516 printf("%%"); 2517 break; 2518 case 'l': 2519 ls++; 2520 goto cont_process; 2521 case 'L': 2522 ls = 2; 2523 goto cont_process; 2524 case 'z': 2525 case 'Z': 2526 case '0' ... '9': 2527 goto cont_process; 2528 case 'p': 2529 if (long_size == 4) 2530 ls = 1; 2531 else 2532 ls = 2; 2533 2534 if (*(ptr+1) == 'F' || 2535 *(ptr+1) == 'f') { 2536 ptr++; 2537 show_func = *ptr; 2538 } 2539 2540 /* fall through */ 2541 case 'd': 2542 case 'i': 2543 case 'x': 2544 case 'X': 2545 case 'u': 2546 if (!arg) 2547 die("no argument match"); 2548 2549 len = ((unsigned long)ptr + 1) - 2550 (unsigned long)saveptr; 2551 2552 /* should never happen */ 2553 if (len > 32) 2554 die("bad format!"); 2555 2556 memcpy(format, saveptr, len); 2557 format[len] = 0; 2558 2559 val = eval_num_arg(data, size, event, arg); 2560 arg = arg->next; 2561 2562 if (show_func) { 2563 func = find_func(val); 2564 if (func) { 2565 printf("%s", func->func); 2566 if (show_func == 'F') 2567 printf("+0x%llx", 2568 val - func->addr); 2569 break; 2570 } 2571 } 2572 switch (ls) { 2573 case 0: 2574 printf(format, (int)val); 2575 break; 2576 case 1: 2577 printf(format, (long)val); 2578 break; 2579 case 2: 2580 printf(format, (long long)val); 2581 break; 2582 default: 2583 die("bad count (%d)", ls); 2584 } 2585 break; 2586 case 's': 2587 if (!arg) 2588 die("no matching argument"); 2589 2590 print_str_arg(data, size, event, arg); 2591 arg = arg->next; 2592 break; 2593 default: 2594 printf(">%c<", *ptr); 2595 2596 } 2597 } else 2598 printf("%c", *ptr); 2599 } 2600 2601 if (args) { 2602 free_args(args); 2603 free(bprint_fmt); 2604 } 2605 } 2606 2607 static inline int log10_cpu(int nb) 2608 { 2609 if (nb / 100) 2610 return 3; 2611 if (nb / 10) 2612 return 2; 2613 return 1; 2614 } 2615 2616 static void print_lat_fmt(void *data, int size __unused) 2617 { 2618 unsigned int lat_flags; 2619 unsigned int pc; 2620 int lock_depth; 2621 int hardirq; 2622 int softirq; 2623 2624 lat_flags = parse_common_flags(data); 2625 pc = parse_common_pc(data); 2626 lock_depth = parse_common_lock_depth(data); 2627 2628 hardirq = lat_flags & TRACE_FLAG_HARDIRQ; 2629 softirq = lat_flags & TRACE_FLAG_SOFTIRQ; 2630 2631 printf("%c%c%c", 2632 (lat_flags & TRACE_FLAG_IRQS_OFF) ? 'd' : 2633 (lat_flags & TRACE_FLAG_IRQS_NOSUPPORT) ? 2634 'X' : '.', 2635 (lat_flags & TRACE_FLAG_NEED_RESCHED) ? 2636 'N' : '.', 2637 (hardirq && softirq) ? 'H' : 2638 hardirq ? 'h' : softirq ? 's' : '.'); 2639 2640 if (pc) 2641 printf("%x", pc); 2642 else 2643 printf("."); 2644 2645 if (lock_depth < 0) 2646 printf(". "); 2647 else 2648 printf("%d ", lock_depth); 2649 } 2650 2651 #define TRACE_GRAPH_INDENT 2 2652 2653 static struct record * 2654 get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func, 2655 struct record *next) 2656 { 2657 struct format_field *field; 2658 struct event *event; 2659 unsigned long val; 2660 int type; 2661 int pid; 2662 2663 type = trace_parse_common_type(next->data); 2664 event = trace_find_event(type); 2665 if (!event) 2666 return NULL; 2667 2668 if (!(event->flags & EVENT_FL_ISFUNCRET)) 2669 return NULL; 2670 2671 pid = trace_parse_common_pid(next->data); 2672 field = find_field(event, "func"); 2673 if (!field) 2674 die("function return does not have field func"); 2675 2676 val = read_size(next->data + field->offset, field->size); 2677 2678 if (cur_pid != pid || cur_func != val) 2679 return NULL; 2680 2681 /* this is a leaf, now advance the iterator */ 2682 return trace_read_data(cpu); 2683 } 2684 2685 /* Signal a overhead of time execution to the output */ 2686 static void print_graph_overhead(unsigned long long duration) 2687 { 2688 /* Non nested entry or return */ 2689 if (duration == ~0ULL) 2690 return (void)printf(" "); 2691 2692 /* Duration exceeded 100 msecs */ 2693 if (duration > 100000ULL) 2694 return (void)printf("! "); 2695 2696 /* Duration exceeded 10 msecs */ 2697 if (duration > 10000ULL) 2698 return (void)printf("+ "); 2699 2700 printf(" "); 2701 } 2702 2703 static void print_graph_duration(unsigned long long duration) 2704 { 2705 unsigned long usecs = duration / 1000; 2706 unsigned long nsecs_rem = duration % 1000; 2707 /* log10(ULONG_MAX) + '\0' */ 2708 char msecs_str[21]; 2709 char nsecs_str[5]; 2710 int len; 2711 int i; 2712 2713 sprintf(msecs_str, "%lu", usecs); 2714 2715 /* Print msecs */ 2716 len = printf("%lu", usecs); 2717 2718 /* Print nsecs (we don't want to exceed 7 numbers) */ 2719 if (len < 7) { 2720 snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem); 2721 len += printf(".%s", nsecs_str); 2722 } 2723 2724 printf(" us "); 2725 2726 /* Print remaining spaces to fit the row's width */ 2727 for (i = len; i < 7; i++) 2728 printf(" "); 2729 2730 printf("| "); 2731 } 2732 2733 static void 2734 print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec) 2735 { 2736 unsigned long long rettime, calltime; 2737 unsigned long long duration, depth; 2738 unsigned long long val; 2739 struct format_field *field; 2740 struct func_map *func; 2741 struct event *ret_event; 2742 int type; 2743 int i; 2744 2745 type = trace_parse_common_type(ret_rec->data); 2746 ret_event = trace_find_event(type); 2747 2748 field = find_field(ret_event, "rettime"); 2749 if (!field) 2750 die("can't find rettime in return graph"); 2751 rettime = read_size(ret_rec->data + field->offset, field->size); 2752 2753 field = find_field(ret_event, "calltime"); 2754 if (!field) 2755 die("can't find rettime in return graph"); 2756 calltime = read_size(ret_rec->data + field->offset, field->size); 2757 2758 duration = rettime - calltime; 2759 2760 /* Overhead */ 2761 print_graph_overhead(duration); 2762 2763 /* Duration */ 2764 print_graph_duration(duration); 2765 2766 field = find_field(event, "depth"); 2767 if (!field) 2768 die("can't find depth in entry graph"); 2769 depth = read_size(data + field->offset, field->size); 2770 2771 /* Function */ 2772 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2773 printf(" "); 2774 2775 field = find_field(event, "func"); 2776 if (!field) 2777 die("can't find func in entry graph"); 2778 val = read_size(data + field->offset, field->size); 2779 func = find_func(val); 2780 2781 if (func) 2782 printf("%s();", func->func); 2783 else 2784 printf("%llx();", val); 2785 } 2786 2787 static void print_graph_nested(struct event *event, void *data) 2788 { 2789 struct format_field *field; 2790 unsigned long long depth; 2791 unsigned long long val; 2792 struct func_map *func; 2793 int i; 2794 2795 /* No overhead */ 2796 print_graph_overhead(-1); 2797 2798 /* No time */ 2799 printf(" | "); 2800 2801 field = find_field(event, "depth"); 2802 if (!field) 2803 die("can't find depth in entry graph"); 2804 depth = read_size(data + field->offset, field->size); 2805 2806 /* Function */ 2807 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2808 printf(" "); 2809 2810 field = find_field(event, "func"); 2811 if (!field) 2812 die("can't find func in entry graph"); 2813 val = read_size(data + field->offset, field->size); 2814 func = find_func(val); 2815 2816 if (func) 2817 printf("%s() {", func->func); 2818 else 2819 printf("%llx() {", val); 2820 } 2821 2822 static void 2823 pretty_print_func_ent(void *data, int size, struct event *event, 2824 int cpu, int pid) 2825 { 2826 struct format_field *field; 2827 struct record *rec; 2828 void *copy_data; 2829 unsigned long val; 2830 2831 if (latency_format) { 2832 print_lat_fmt(data, size); 2833 printf(" | "); 2834 } 2835 2836 field = find_field(event, "func"); 2837 if (!field) 2838 die("function entry does not have func field"); 2839 2840 val = read_size(data + field->offset, field->size); 2841 2842 /* 2843 * peek_data may unmap the data pointer. Copy it first. 2844 */ 2845 copy_data = malloc_or_die(size); 2846 memcpy(copy_data, data, size); 2847 data = copy_data; 2848 2849 rec = trace_peek_data(cpu); 2850 if (rec) { 2851 rec = get_return_for_leaf(cpu, pid, val, rec); 2852 if (rec) { 2853 print_graph_entry_leaf(event, data, rec); 2854 goto out_free; 2855 } 2856 } 2857 print_graph_nested(event, data); 2858 out_free: 2859 free(data); 2860 } 2861 2862 static void 2863 pretty_print_func_ret(void *data, int size __unused, struct event *event) 2864 { 2865 unsigned long long rettime, calltime; 2866 unsigned long long duration, depth; 2867 struct format_field *field; 2868 int i; 2869 2870 if (latency_format) { 2871 print_lat_fmt(data, size); 2872 printf(" | "); 2873 } 2874 2875 field = find_field(event, "rettime"); 2876 if (!field) 2877 die("can't find rettime in return graph"); 2878 rettime = read_size(data + field->offset, field->size); 2879 2880 field = find_field(event, "calltime"); 2881 if (!field) 2882 die("can't find calltime in return graph"); 2883 calltime = read_size(data + field->offset, field->size); 2884 2885 duration = rettime - calltime; 2886 2887 /* Overhead */ 2888 print_graph_overhead(duration); 2889 2890 /* Duration */ 2891 print_graph_duration(duration); 2892 2893 field = find_field(event, "depth"); 2894 if (!field) 2895 die("can't find depth in entry graph"); 2896 depth = read_size(data + field->offset, field->size); 2897 2898 /* Function */ 2899 for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) 2900 printf(" "); 2901 2902 printf("}"); 2903 } 2904 2905 static void 2906 pretty_print_func_graph(void *data, int size, struct event *event, 2907 int cpu, int pid) 2908 { 2909 if (event->flags & EVENT_FL_ISFUNCENT) 2910 pretty_print_func_ent(data, size, event, cpu, pid); 2911 else if (event->flags & EVENT_FL_ISFUNCRET) 2912 pretty_print_func_ret(data, size, event); 2913 printf("\n"); 2914 } 2915 2916 void print_trace_event(int cpu, void *data, int size) 2917 { 2918 struct event *event; 2919 int type; 2920 int pid; 2921 2922 type = trace_parse_common_type(data); 2923 2924 event = trace_find_event(type); 2925 if (!event) { 2926 warning("ug! no event found for type %d", type); 2927 return; 2928 } 2929 2930 pid = trace_parse_common_pid(data); 2931 2932 if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET)) 2933 return pretty_print_func_graph(data, size, event, cpu, pid); 2934 2935 if (latency_format) 2936 print_lat_fmt(data, size); 2937 2938 if (event->flags & EVENT_FL_FAILED) { 2939 printf("EVENT '%s' FAILED TO PARSE\n", 2940 event->name); 2941 return; 2942 } 2943 2944 pretty_print(data, size, event); 2945 } 2946 2947 static void print_fields(struct print_flag_sym *field) 2948 { 2949 printf("{ %s, %s }", field->value, field->str); 2950 if (field->next) { 2951 printf(", "); 2952 print_fields(field->next); 2953 } 2954 } 2955 2956 static void print_args(struct print_arg *args) 2957 { 2958 int print_paren = 1; 2959 2960 switch (args->type) { 2961 case PRINT_NULL: 2962 printf("null"); 2963 break; 2964 case PRINT_ATOM: 2965 printf("%s", args->atom.atom); 2966 break; 2967 case PRINT_FIELD: 2968 printf("REC->%s", args->field.name); 2969 break; 2970 case PRINT_FLAGS: 2971 printf("__print_flags("); 2972 print_args(args->flags.field); 2973 printf(", %s, ", args->flags.delim); 2974 print_fields(args->flags.flags); 2975 printf(")"); 2976 break; 2977 case PRINT_SYMBOL: 2978 printf("__print_symbolic("); 2979 print_args(args->symbol.field); 2980 printf(", "); 2981 print_fields(args->symbol.symbols); 2982 printf(")"); 2983 break; 2984 case PRINT_STRING: 2985 printf("__get_str(%s)", args->string.string); 2986 break; 2987 case PRINT_TYPE: 2988 printf("(%s)", args->typecast.type); 2989 print_args(args->typecast.item); 2990 break; 2991 case PRINT_OP: 2992 if (strcmp(args->op.op, ":") == 0) 2993 print_paren = 0; 2994 if (print_paren) 2995 printf("("); 2996 print_args(args->op.left); 2997 printf(" %s ", args->op.op); 2998 print_args(args->op.right); 2999 if (print_paren) 3000 printf(")"); 3001 break; 3002 default: 3003 /* we should warn... */ 3004 return; 3005 } 3006 if (args->next) { 3007 printf("\n"); 3008 print_args(args->next); 3009 } 3010 } 3011 3012 int parse_ftrace_file(char *buf, unsigned long size) 3013 { 3014 struct format_field *field; 3015 struct print_arg *arg, **list; 3016 struct event *event; 3017 int ret; 3018 3019 init_input_buf(buf, size); 3020 3021 event = alloc_event(); 3022 if (!event) 3023 return -ENOMEM; 3024 3025 event->flags |= EVENT_FL_ISFTRACE; 3026 3027 event->name = event_read_name(); 3028 if (!event->name) 3029 die("failed to read ftrace event name"); 3030 3031 if (strcmp(event->name, "function") == 0) 3032 event->flags |= EVENT_FL_ISFUNC; 3033 3034 else if (strcmp(event->name, "funcgraph_entry") == 0) 3035 event->flags |= EVENT_FL_ISFUNCENT; 3036 3037 else if (strcmp(event->name, "funcgraph_exit") == 0) 3038 event->flags |= EVENT_FL_ISFUNCRET; 3039 3040 else if (strcmp(event->name, "bprint") == 0) 3041 event->flags |= EVENT_FL_ISBPRINT; 3042 3043 event->id = event_read_id(); 3044 if (event->id < 0) 3045 die("failed to read ftrace event id"); 3046 3047 add_event(event); 3048 3049 ret = event_read_format(event); 3050 if (ret < 0) 3051 die("failed to read ftrace event format"); 3052 3053 ret = event_read_print(event); 3054 if (ret < 0) 3055 die("failed to read ftrace event print fmt"); 3056 3057 /* New ftrace handles args */ 3058 if (ret > 0) 3059 return 0; 3060 /* 3061 * The arguments for ftrace files are parsed by the fields. 3062 * Set up the fields as their arguments. 3063 */ 3064 list = &event->print_fmt.args; 3065 for (field = event->format.fields; field; field = field->next) { 3066 arg = malloc_or_die(sizeof(*arg)); 3067 memset(arg, 0, sizeof(*arg)); 3068 *list = arg; 3069 list = &arg->next; 3070 arg->type = PRINT_FIELD; 3071 arg->field.name = field->name; 3072 arg->field.field = field; 3073 } 3074 return 0; 3075 } 3076 3077 int parse_event_file(char *buf, unsigned long size, char *sys) 3078 { 3079 struct event *event; 3080 int ret; 3081 3082 init_input_buf(buf, size); 3083 3084 event = alloc_event(); 3085 if (!event) 3086 return -ENOMEM; 3087 3088 event->name = event_read_name(); 3089 if (!event->name) 3090 die("failed to read event name"); 3091 3092 event->id = event_read_id(); 3093 if (event->id < 0) 3094 die("failed to read event id"); 3095 3096 ret = event_read_format(event); 3097 if (ret < 0) { 3098 warning("failed to read event format for %s", event->name); 3099 goto event_failed; 3100 } 3101 3102 ret = event_read_print(event); 3103 if (ret < 0) { 3104 warning("failed to read event print fmt for %s", event->name); 3105 goto event_failed; 3106 } 3107 3108 event->system = strdup(sys); 3109 3110 #define PRINT_ARGS 0 3111 if (PRINT_ARGS && event->print_fmt.args) 3112 print_args(event->print_fmt.args); 3113 3114 add_event(event); 3115 return 0; 3116 3117 event_failed: 3118 event->flags |= EVENT_FL_FAILED; 3119 /* still add it even if it failed */ 3120 add_event(event); 3121 return -1; 3122 } 3123 3124 void parse_set_info(int nr_cpus, int long_sz) 3125 { 3126 cpus = nr_cpus; 3127 long_size = long_sz; 3128 } 3129 3130 int common_pc(struct scripting_context *context) 3131 { 3132 return parse_common_pc(context->event_data); 3133 } 3134 3135 int common_flags(struct scripting_context *context) 3136 { 3137 return parse_common_flags(context->event_data); 3138 } 3139 3140 int common_lock_depth(struct scripting_context *context) 3141 { 3142 return parse_common_lock_depth(context->event_data); 3143 } 3144
