| /* |
| * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com> |
| * |
| * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; version 2 of the License (not later!) |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| * |
| * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| * |
| * The parts for function graph printing was taken and modified from the |
| * Linux Kernel that were written by Frederic Weisbecker. |
| */ |
| #define _GNU_SOURCE |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <ctype.h> |
| #include <errno.h> |
| |
| #undef _GNU_SOURCE |
| #include "../perf.h" |
| #include "util.h" |
| #include "trace-event.h" |
| |
| int header_page_ts_offset; |
| int header_page_ts_size; |
| int header_page_size_offset; |
| int header_page_size_size; |
| int header_page_data_offset; |
| int header_page_data_size; |
| |
| static char *input_buf; |
| static unsigned long long input_buf_ptr; |
| static unsigned long long input_buf_siz; |
| |
| static int cpus; |
| static int long_size; |
| |
| static void init_input_buf(char *buf, unsigned long long size) |
| { |
| input_buf = buf; |
| input_buf_siz = size; |
| input_buf_ptr = 0; |
| } |
| |
| struct cmdline { |
| char *comm; |
| int pid; |
| }; |
| |
| static struct cmdline *cmdlines; |
| static int cmdline_count; |
| |
| static int cmdline_cmp(const void *a, const void *b) |
| { |
| const struct cmdline *ca = a; |
| const struct cmdline *cb = b; |
| |
| if (ca->pid < cb->pid) |
| return -1; |
| if (ca->pid > cb->pid) |
| return 1; |
| |
| return 0; |
| } |
| |
| void parse_cmdlines(char *file, int size __unused) |
| { |
| struct cmdline_list { |
| struct cmdline_list *next; |
| char *comm; |
| int pid; |
| } *list = NULL, *item; |
| char *line; |
| char *next = NULL; |
| int i; |
| |
| line = strtok_r(file, "\n", &next); |
| while (line) { |
| item = malloc_or_die(sizeof(*item)); |
| sscanf(line, "%d %as", &item->pid, |
| (float *)(void *)&item->comm); /* workaround gcc warning */ |
| item->next = list; |
| list = item; |
| line = strtok_r(NULL, "\n", &next); |
| cmdline_count++; |
| } |
| |
| cmdlines = malloc_or_die(sizeof(*cmdlines) * cmdline_count); |
| |
| i = 0; |
| while (list) { |
| cmdlines[i].pid = list->pid; |
| cmdlines[i].comm = list->comm; |
| i++; |
| item = list; |
| list = list->next; |
| free(item); |
| } |
| |
| qsort(cmdlines, cmdline_count, sizeof(*cmdlines), cmdline_cmp); |
| } |
| |
| static struct func_map { |
| unsigned long long addr; |
| char *func; |
| char *mod; |
| } *func_list; |
| static unsigned int func_count; |
| |
| static int func_cmp(const void *a, const void *b) |
| { |
| const struct func_map *fa = a; |
| const struct func_map *fb = b; |
| |
| if (fa->addr < fb->addr) |
| return -1; |
| if (fa->addr > fb->addr) |
| return 1; |
| |
| return 0; |
| } |
| |
| void parse_proc_kallsyms(char *file, unsigned int size __unused) |
| { |
| struct func_list { |
| struct func_list *next; |
| unsigned long long addr; |
| char *func; |
| char *mod; |
| } *list = NULL, *item; |
| char *line; |
| char *next = NULL; |
| char *addr_str; |
| char ch; |
| int ret; |
| int i; |
| |
| line = strtok_r(file, "\n", &next); |
| while (line) { |
| item = malloc_or_die(sizeof(*item)); |
| item->mod = NULL; |
| ret = sscanf(line, "%as %c %as\t[%as", |
| (float *)(void *)&addr_str, /* workaround gcc warning */ |
| &ch, |
| (float *)(void *)&item->func, |
| (float *)(void *)&item->mod); |
| item->addr = strtoull(addr_str, NULL, 16); |
| free(addr_str); |
| |
| /* truncate the extra ']' */ |
| if (item->mod) |
| item->mod[strlen(item->mod) - 1] = 0; |
| |
| |
| item->next = list; |
| list = item; |
| line = strtok_r(NULL, "\n", &next); |
| func_count++; |
| } |
| |
| func_list = malloc_or_die(sizeof(*func_list) * func_count + 1); |
| |
| i = 0; |
| while (list) { |
| func_list[i].func = list->func; |
| func_list[i].addr = list->addr; |
| func_list[i].mod = list->mod; |
| i++; |
| item = list; |
| list = list->next; |
| free(item); |
| } |
| |
| qsort(func_list, func_count, sizeof(*func_list), func_cmp); |
| |
| /* |
| * Add a special record at the end. |
| */ |
| func_list[func_count].func = NULL; |
| func_list[func_count].addr = 0; |
| func_list[func_count].mod = NULL; |
| } |
| |
| /* |
| * We are searching for a record in between, not an exact |
| * match. |
| */ |
| static int func_bcmp(const void *a, const void *b) |
| { |
| const struct func_map *fa = a; |
| const struct func_map *fb = b; |
| |
| if ((fa->addr == fb->addr) || |
| |
| (fa->addr > fb->addr && |
| fa->addr < (fb+1)->addr)) |
| return 0; |
| |
| if (fa->addr < fb->addr) |
| return -1; |
| |
| return 1; |
| } |
| |
| static struct func_map *find_func(unsigned long long addr) |
| { |
| struct func_map *func; |
| struct func_map key; |
| |
| key.addr = addr; |
| |
| func = bsearch(&key, func_list, func_count, sizeof(*func_list), |
| func_bcmp); |
| |
| return func; |
| } |
| |
| void print_funcs(void) |
| { |
| int i; |
| |
| for (i = 0; i < (int)func_count; i++) { |
| printf("%016llx %s", |
| func_list[i].addr, |
| func_list[i].func); |
| if (func_list[i].mod) |
| printf(" [%s]\n", func_list[i].mod); |
| else |
| printf("\n"); |
| } |
| } |
| |
| static struct printk_map { |
| unsigned long long addr; |
| char *printk; |
| } *printk_list; |
| static unsigned int printk_count; |
| |
| static int printk_cmp(const void *a, const void *b) |
| { |
| const struct func_map *fa = a; |
| const struct func_map *fb = b; |
| |
| if (fa->addr < fb->addr) |
| return -1; |
| if (fa->addr > fb->addr) |
| return 1; |
| |
| return 0; |
| } |
| |
| static struct printk_map *find_printk(unsigned long long addr) |
| { |
| struct printk_map *printk; |
| struct printk_map key; |
| |
| key.addr = addr; |
| |
| printk = bsearch(&key, printk_list, printk_count, sizeof(*printk_list), |
| printk_cmp); |
| |
| return printk; |
| } |
| |
| void parse_ftrace_printk(char *file, unsigned int size __unused) |
| { |
| struct printk_list { |
| struct printk_list *next; |
| unsigned long long addr; |
| char *printk; |
| } *list = NULL, *item; |
| char *line; |
| char *next = NULL; |
| char *addr_str; |
| int ret; |
| int i; |
| |
| line = strtok_r(file, "\n", &next); |
| while (line) { |
| item = malloc_or_die(sizeof(*item)); |
| ret = sscanf(line, "%as : %as", |
| (float *)(void *)&addr_str, /* workaround gcc warning */ |
| (float *)(void *)&item->printk); |
| item->addr = strtoull(addr_str, NULL, 16); |
| free(addr_str); |
| |
| item->next = list; |
| list = item; |
| line = strtok_r(NULL, "\n", &next); |
| printk_count++; |
| } |
| |
| printk_list = malloc_or_die(sizeof(*printk_list) * printk_count + 1); |
| |
| i = 0; |
| while (list) { |
| printk_list[i].printk = list->printk; |
| printk_list[i].addr = list->addr; |
| i++; |
| item = list; |
| list = list->next; |
| free(item); |
| } |
| |
| qsort(printk_list, printk_count, sizeof(*printk_list), printk_cmp); |
| } |
| |
| void print_printk(void) |
| { |
| int i; |
| |
| for (i = 0; i < (int)printk_count; i++) { |
| printf("%016llx %s\n", |
| printk_list[i].addr, |
| printk_list[i].printk); |
| } |
| } |
| |
| static struct event *alloc_event(void) |
| { |
| struct event *event; |
| |
| event = malloc_or_die(sizeof(*event)); |
| memset(event, 0, sizeof(*event)); |
| |
| return event; |
| } |
| |
| enum event_type { |
| EVENT_ERROR, |
| EVENT_NONE, |
| EVENT_SPACE, |
| EVENT_NEWLINE, |
| EVENT_OP, |
| EVENT_DELIM, |
| EVENT_ITEM, |
| EVENT_DQUOTE, |
| EVENT_SQUOTE, |
| }; |
| |
| static struct event *event_list; |
| |
| static void add_event(struct event *event) |
| { |
| event->next = event_list; |
| event_list = event; |
| } |
| |
| static int event_item_type(enum event_type type) |
| { |
| switch (type) { |
| case EVENT_ITEM ... EVENT_SQUOTE: |
| return 1; |
| case EVENT_ERROR ... EVENT_DELIM: |
| default: |
| return 0; |
| } |
| } |
| |
| static void free_arg(struct print_arg *arg) |
| { |
| if (!arg) |
| return; |
| |
| switch (arg->type) { |
| case PRINT_ATOM: |
| if (arg->atom.atom) |
| free(arg->atom.atom); |
| break; |
| case PRINT_NULL: |
| case PRINT_FIELD ... PRINT_OP: |
| default: |
| /* todo */ |
| break; |
| } |
| |
| free(arg); |
| } |
| |
| static enum event_type get_type(int ch) |
| { |
| if (ch == '\n') |
| return EVENT_NEWLINE; |
| if (isspace(ch)) |
| return EVENT_SPACE; |
| if (isalnum(ch) || ch == '_') |
| return EVENT_ITEM; |
| if (ch == '\'') |
| return EVENT_SQUOTE; |
| if (ch == '"') |
| return EVENT_DQUOTE; |
| if (!isprint(ch)) |
| return EVENT_NONE; |
| if (ch == '(' || ch == ')' || ch == ',') |
| return EVENT_DELIM; |
| |
| return EVENT_OP; |
| } |
| |
| static int __read_char(void) |
| { |
| if (input_buf_ptr >= input_buf_siz) |
| return -1; |
| |
| return input_buf[input_buf_ptr++]; |
| } |
| |
| static int __peek_char(void) |
| { |
| if (input_buf_ptr >= input_buf_siz) |
| return -1; |
| |
| return input_buf[input_buf_ptr]; |
| } |
| |
| static enum event_type __read_token(char **tok) |
| { |
| char buf[BUFSIZ]; |
| int ch, last_ch, quote_ch, next_ch; |
| int i = 0; |
| int tok_size = 0; |
| enum event_type type; |
| |
| *tok = NULL; |
| |
| |
| ch = __read_char(); |
| if (ch < 0) |
| return EVENT_NONE; |
| |
| type = get_type(ch); |
| if (type == EVENT_NONE) |
| return type; |
| |
| buf[i++] = ch; |
| |
| switch (type) { |
| case EVENT_NEWLINE: |
| case EVENT_DELIM: |
| *tok = malloc_or_die(2); |
| (*tok)[0] = ch; |
| (*tok)[1] = 0; |
| return type; |
| |
| case EVENT_OP: |
| switch (ch) { |
| case '-': |
| next_ch = __peek_char(); |
| if (next_ch == '>') { |
| buf[i++] = __read_char(); |
| break; |
| } |
| /* fall through */ |
| case '+': |
| case '|': |
| case '&': |
| case '>': |
| case '<': |
| last_ch = ch; |
| ch = __peek_char(); |
| if (ch != last_ch) |
| goto test_equal; |
| buf[i++] = __read_char(); |
| switch (last_ch) { |
| case '>': |
| case '<': |
| goto test_equal; |
| default: |
| break; |
| } |
| break; |
| case '!': |
| case '=': |
| goto test_equal; |
| default: /* what should we do instead? */ |
| break; |
| } |
| buf[i] = 0; |
| *tok = strdup(buf); |
| return type; |
| |
| test_equal: |
| ch = __peek_char(); |
| if (ch == '=') |
| buf[i++] = __read_char(); |
| break; |
| |
| case EVENT_DQUOTE: |
| case EVENT_SQUOTE: |
| /* don't keep quotes */ |
| i--; |
| quote_ch = ch; |
| last_ch = 0; |
| do { |
| if (i == (BUFSIZ - 1)) { |
| buf[i] = 0; |
| if (*tok) { |
| *tok = realloc(*tok, tok_size + BUFSIZ); |
| if (!*tok) |
| return EVENT_NONE; |
| strcat(*tok, buf); |
| } else |
| *tok = strdup(buf); |
| |
| if (!*tok) |
| return EVENT_NONE; |
| tok_size += BUFSIZ; |
| i = 0; |
| } |
| last_ch = ch; |
| ch = __read_char(); |
| buf[i++] = ch; |
| } while (ch != quote_ch && last_ch != '\\'); |
| /* remove the last quote */ |
| i--; |
| goto out; |
| |
| case EVENT_ERROR ... EVENT_SPACE: |
| case EVENT_ITEM: |
| default: |
| break; |
| } |
| |
| while (get_type(__peek_char()) == type) { |
| if (i == (BUFSIZ - 1)) { |
| buf[i] = 0; |
| if (*tok) { |
| *tok = realloc(*tok, tok_size + BUFSIZ); |
| if (!*tok) |
| return EVENT_NONE; |
| strcat(*tok, buf); |
| } else |
| *tok = strdup(buf); |
| |
| if (!*tok) |
| return EVENT_NONE; |
| tok_size += BUFSIZ; |
| i = 0; |
| } |
| ch = __read_char(); |
| buf[i++] = ch; |
| } |
| |
| out: |
| buf[i] = 0; |
| if (*tok) { |
| *tok = realloc(*tok, tok_size + i); |
| if (!*tok) |
| return EVENT_NONE; |
| strcat(*tok, buf); |
| } else |
| *tok = strdup(buf); |
| if (!*tok) |
| return EVENT_NONE; |
| |
| return type; |
| } |
| |
| static void free_token(char *tok) |
| { |
| if (tok) |
| free(tok); |
| } |
| |
| static enum event_type read_token(char **tok) |
| { |
| enum event_type type; |
| |
| for (;;) { |
| type = __read_token(tok); |
| if (type != EVENT_SPACE) |
| return type; |
| |
| free_token(*tok); |
| } |
| |
| /* not reached */ |
| return EVENT_NONE; |
| } |
| |
| /* no newline */ |
| static enum event_type read_token_item(char **tok) |
| { |
| enum event_type type; |
| |
| for (;;) { |
| type = __read_token(tok); |
| if (type != EVENT_SPACE && type != EVENT_NEWLINE) |
| return type; |
| |
| free_token(*tok); |
| } |
| |
| /* not reached */ |
| return EVENT_NONE; |
| } |
| |
| static int test_type(enum event_type type, enum event_type expect) |
| { |
| if (type != expect) { |
| die("Error: expected type %d but read %d", |
| expect, type); |
| return -1; |
| } |
| return 0; |
| } |
| |
| static int test_type_token(enum event_type type, char *token, |
| enum event_type expect, const char *expect_tok) |
| { |
| if (type != expect) { |
| die("Error: expected type %d but read %d", |
| expect, type); |
| return -1; |
| } |
| |
| if (strcmp(token, expect_tok) != 0) { |
| die("Error: expected '%s' but read '%s'", |
| expect_tok, token); |
| return -1; |
| } |
| return 0; |
| } |
| |
| static int __read_expect_type(enum event_type expect, char **tok, int newline_ok) |
| { |
| enum event_type type; |
| |
| if (newline_ok) |
| type = read_token(tok); |
| else |
| type = read_token_item(tok); |
| return test_type(type, expect); |
| } |
| |
| static int read_expect_type(enum event_type expect, char **tok) |
| { |
| return __read_expect_type(expect, tok, 1); |
| } |
| |
| static int __read_expected(enum event_type expect, const char *str, int newline_ok) |
| { |
| enum event_type type; |
| char *token; |
| int ret; |
| |
| if (newline_ok) |
| type = read_token(&token); |
| else |
| type = read_token_item(&token); |
| |
| ret = test_type_token(type, token, expect, str); |
| |
| free_token(token); |
| |
| return 0; |
| } |
| |
| static int read_expected(enum event_type expect, const char *str) |
| { |
| return __read_expected(expect, str, 1); |
| } |
| |
| static int read_expected_item(enum event_type expect, const char *str) |
| { |
| return __read_expected(expect, str, 0); |
| } |
| |
| static char *event_read_name(void) |
| { |
| char *token; |
| |
| if (read_expected(EVENT_ITEM, (char *)"name") < 0) |
| return NULL; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return NULL; |
| |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| goto fail; |
| |
| return token; |
| |
| fail: |
| free_token(token); |
| return NULL; |
| } |
| |
| static int event_read_id(void) |
| { |
| char *token; |
| int id; |
| |
| if (read_expected_item(EVENT_ITEM, (char *)"ID") < 0) |
| return -1; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return -1; |
| |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| goto fail; |
| |
| id = strtoul(token, NULL, 0); |
| free_token(token); |
| return id; |
| |
| fail: |
| free_token(token); |
| return -1; |
| } |
| |
| static int field_is_string(struct format_field *field) |
| { |
| if ((field->flags & FIELD_IS_ARRAY) && |
| (!strstr(field->type, "char") || !strstr(field->type, "u8") || |
| !strstr(field->type, "s8"))) |
| return 1; |
| |
| return 0; |
| } |
| |
| static int field_is_dynamic(struct format_field *field) |
| { |
| if (!strcmp(field->type, "__data_loc")) |
| return 1; |
| |
| return 0; |
| } |
| |
| static int event_read_fields(struct event *event, struct format_field **fields) |
| { |
| struct format_field *field = NULL; |
| enum event_type type; |
| char *token; |
| char *last_token; |
| int count = 0; |
| |
| do { |
| type = read_token(&token); |
| if (type == EVENT_NEWLINE) { |
| free_token(token); |
| return count; |
| } |
| |
| count++; |
| |
| if (test_type_token(type, token, EVENT_ITEM, (char *)"field")) |
| goto fail; |
| free_token(token); |
| |
| type = read_token(&token); |
| /* |
| * The ftrace fields may still use the "special" name. |
| * Just ignore it. |
| */ |
| if (event->flags & EVENT_FL_ISFTRACE && |
| type == EVENT_ITEM && strcmp(token, "special") == 0) { |
| free_token(token); |
| type = read_token(&token); |
| } |
| |
| if (test_type_token(type, token, EVENT_OP, (char *)":") < 0) |
| return -1; |
| |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| goto fail; |
| |
| last_token = token; |
| |
| field = malloc_or_die(sizeof(*field)); |
| memset(field, 0, sizeof(*field)); |
| |
| /* read the rest of the type */ |
| for (;;) { |
| type = read_token(&token); |
| if (type == EVENT_ITEM || |
| (type == EVENT_OP && strcmp(token, "*") == 0) || |
| /* |
| * Some of the ftrace fields are broken and have |
| * an illegal "." in them. |
| */ |
| (event->flags & EVENT_FL_ISFTRACE && |
| type == EVENT_OP && strcmp(token, ".") == 0)) { |
| |
| if (strcmp(token, "*") == 0) |
| field->flags |= FIELD_IS_POINTER; |
| |
| if (field->type) { |
| field->type = realloc(field->type, |
| strlen(field->type) + |
| strlen(last_token) + 2); |
| strcat(field->type, " "); |
| strcat(field->type, last_token); |
| } else |
| field->type = last_token; |
| last_token = token; |
| continue; |
| } |
| |
| break; |
| } |
| |
| if (!field->type) { |
| die("no type found"); |
| goto fail; |
| } |
| field->name = last_token; |
| |
| if (test_type(type, EVENT_OP)) |
| goto fail; |
| |
| if (strcmp(token, "[") == 0) { |
| enum event_type last_type = type; |
| char *brackets = token; |
| int len; |
| |
| field->flags |= FIELD_IS_ARRAY; |
| |
| type = read_token(&token); |
| while (strcmp(token, "]") != 0) { |
| if (last_type == EVENT_ITEM && |
| type == EVENT_ITEM) |
| len = 2; |
| else |
| len = 1; |
| last_type = type; |
| |
| brackets = realloc(brackets, |
| strlen(brackets) + |
| strlen(token) + len); |
| if (len == 2) |
| strcat(brackets, " "); |
| strcat(brackets, token); |
| free_token(token); |
| type = read_token(&token); |
| if (type == EVENT_NONE) { |
| die("failed to find token"); |
| goto fail; |
| } |
| } |
| |
| free_token(token); |
| |
| brackets = realloc(brackets, strlen(brackets) + 2); |
| strcat(brackets, "]"); |
| |
| /* add brackets to type */ |
| |
| type = read_token(&token); |
| /* |
| * If the next token is not an OP, then it is of |
| * the format: type [] item; |
| */ |
| if (type == EVENT_ITEM) { |
| field->type = realloc(field->type, |
| strlen(field->type) + |
| strlen(field->name) + |
| strlen(brackets) + 2); |
| strcat(field->type, " "); |
| strcat(field->type, field->name); |
| free_token(field->name); |
| strcat(field->type, brackets); |
| field->name = token; |
| type = read_token(&token); |
| } else { |
| field->type = realloc(field->type, |
| strlen(field->type) + |
| strlen(brackets) + 1); |
| strcat(field->type, brackets); |
| } |
| free(brackets); |
| } |
| |
| if (field_is_string(field)) { |
| field->flags |= FIELD_IS_STRING; |
| if (field_is_dynamic(field)) |
| field->flags |= FIELD_IS_DYNAMIC; |
| } |
| |
| if (test_type_token(type, token, EVENT_OP, (char *)";")) |
| goto fail; |
| free_token(token); |
| |
| if (read_expected(EVENT_ITEM, (char *)"offset") < 0) |
| goto fail_expect; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| goto fail_expect; |
| |
| if (read_expect_type(EVENT_ITEM, &token)) |
| goto fail; |
| field->offset = strtoul(token, NULL, 0); |
| free_token(token); |
| |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| goto fail_expect; |
| |
| if (read_expected(EVENT_ITEM, (char *)"size") < 0) |
| goto fail_expect; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| goto fail_expect; |
| |
| if (read_expect_type(EVENT_ITEM, &token)) |
| goto fail; |
| field->size = strtoul(token, NULL, 0); |
| free_token(token); |
| |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| goto fail_expect; |
| |
| if (read_expected(EVENT_ITEM, (char *)"signed") < 0) |
| goto fail_expect; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| goto fail_expect; |
| |
| if (read_expect_type(EVENT_ITEM, &token)) |
| goto fail; |
| if (strtoul(token, NULL, 0)) |
| field->flags |= FIELD_IS_SIGNED; |
| free_token(token); |
| |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| goto fail_expect; |
| |
| if (read_expect_type(EVENT_NEWLINE, &token) < 0) |
| goto fail; |
| free_token(token); |
| |
| *fields = field; |
| fields = &field->next; |
| |
| } while (1); |
| |
| return 0; |
| |
| fail: |
| free_token(token); |
| fail_expect: |
| if (field) |
| free(field); |
| return -1; |
| } |
| |
| static int event_read_format(struct event *event) |
| { |
| char *token; |
| int ret; |
| |
| if (read_expected_item(EVENT_ITEM, (char *)"format") < 0) |
| return -1; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return -1; |
| |
| if (read_expect_type(EVENT_NEWLINE, &token)) |
| goto fail; |
| free_token(token); |
| |
| ret = event_read_fields(event, &event->format.common_fields); |
| if (ret < 0) |
| return ret; |
| event->format.nr_common = ret; |
| |
| ret = event_read_fields(event, &event->format.fields); |
| if (ret < 0) |
| return ret; |
| event->format.nr_fields = ret; |
| |
| return 0; |
| |
| fail: |
| free_token(token); |
| return -1; |
| } |
| |
| enum event_type |
| process_arg_token(struct event *event, struct print_arg *arg, |
| char **tok, enum event_type type); |
| |
| static enum event_type |
| process_arg(struct event *event, struct print_arg *arg, char **tok) |
| { |
| enum event_type type; |
| char *token; |
| |
| type = read_token(&token); |
| *tok = token; |
| |
| return process_arg_token(event, arg, tok, type); |
| } |
| |
| static enum event_type |
| process_cond(struct event *event, struct print_arg *top, char **tok) |
| { |
| struct print_arg *arg, *left, *right; |
| enum event_type type; |
| char *token = NULL; |
| |
| arg = malloc_or_die(sizeof(*arg)); |
| memset(arg, 0, sizeof(*arg)); |
| |
| left = malloc_or_die(sizeof(*left)); |
| |
| right = malloc_or_die(sizeof(*right)); |
| |
| arg->type = PRINT_OP; |
| arg->op.left = left; |
| arg->op.right = right; |
| |
| *tok = NULL; |
| type = process_arg(event, left, &token); |
| if (test_type_token(type, token, EVENT_OP, (char *)":")) |
| goto out_free; |
| |
| arg->op.op = token; |
| |
| type = process_arg(event, right, &token); |
| |
| top->op.right = arg; |
| |
| *tok = token; |
| return type; |
| |
| out_free: |
| free_token(*tok); |
| free(right); |
| free(left); |
| free_arg(arg); |
| return EVENT_ERROR; |
| } |
| |
| static int get_op_prio(char *op) |
| { |
| if (!op[1]) { |
| switch (op[0]) { |
| case '*': |
| case '/': |
| case '%': |
| return 6; |
| case '+': |
| case '-': |
| return 7; |
| /* '>>' and '<<' are 8 */ |
| case '<': |
| case '>': |
| return 9; |
| /* '==' and '!=' are 10 */ |
| case '&': |
| return 11; |
| case '^': |
| return 12; |
| case '|': |
| return 13; |
| case '?': |
| return 16; |
| default: |
| die("unknown op '%c'", op[0]); |
| return -1; |
| } |
| } else { |
| if (strcmp(op, "++") == 0 || |
| strcmp(op, "--") == 0) { |
| return 3; |
| } else if (strcmp(op, ">>") == 0 || |
| strcmp(op, "<<") == 0) { |
| return 8; |
| } else if (strcmp(op, ">=") == 0 || |
| strcmp(op, "<=") == 0) { |
| return 9; |
| } else if (strcmp(op, "==") == 0 || |
| strcmp(op, "!=") == 0) { |
| return 10; |
| } else if (strcmp(op, "&&") == 0) { |
| return 14; |
| } else if (strcmp(op, "||") == 0) { |
| return 15; |
| } else { |
| die("unknown op '%s'", op); |
| return -1; |
| } |
| } |
| } |
| |
| static void set_op_prio(struct print_arg *arg) |
| { |
| |
| /* single ops are the greatest */ |
| if (!arg->op.left || arg->op.left->type == PRINT_NULL) { |
| arg->op.prio = 0; |
| return; |
| } |
| |
| arg->op.prio = get_op_prio(arg->op.op); |
| } |
| |
| static enum event_type |
| process_op(struct event *event, struct print_arg *arg, char **tok) |
| { |
| struct print_arg *left, *right = NULL; |
| enum event_type type; |
| char *token; |
| |
| /* the op is passed in via tok */ |
| token = *tok; |
| |
| if (arg->type == PRINT_OP && !arg->op.left) { |
| /* handle single op */ |
| if (token[1]) { |
| die("bad op token %s", token); |
| return EVENT_ERROR; |
| } |
| switch (token[0]) { |
| case '!': |
| case '+': |
| case '-': |
| break; |
| default: |
| die("bad op token %s", token); |
| return EVENT_ERROR; |
| } |
| |
| /* make an empty left */ |
| left = malloc_or_die(sizeof(*left)); |
| left->type = PRINT_NULL; |
| arg->op.left = left; |
| |
| right = malloc_or_die(sizeof(*right)); |
| arg->op.right = right; |
| |
| type = process_arg(event, right, tok); |
| |
| } else if (strcmp(token, "?") == 0) { |
| |
| left = malloc_or_die(sizeof(*left)); |
| /* copy the top arg to the left */ |
| *left = *arg; |
| |
| arg->type = PRINT_OP; |
| arg->op.op = token; |
| arg->op.left = left; |
| arg->op.prio = 0; |
| |
| type = process_cond(event, arg, tok); |
| |
| } else if (strcmp(token, ">>") == 0 || |
| strcmp(token, "<<") == 0 || |
| strcmp(token, "&") == 0 || |
| strcmp(token, "|") == 0 || |
| strcmp(token, "&&") == 0 || |
| strcmp(token, "||") == 0 || |
| strcmp(token, "-") == 0 || |
| strcmp(token, "+") == 0 || |
| strcmp(token, "*") == 0 || |
| strcmp(token, "^") == 0 || |
| strcmp(token, "/") == 0 || |
| strcmp(token, "==") == 0 || |
| strcmp(token, "!=") == 0) { |
| |
| left = malloc_or_die(sizeof(*left)); |
| |
| /* copy the top arg to the left */ |
| *left = *arg; |
| |
| arg->type = PRINT_OP; |
| arg->op.op = token; |
| arg->op.left = left; |
| |
| set_op_prio(arg); |
| |
| right = malloc_or_die(sizeof(*right)); |
| |
| type = process_arg(event, right, tok); |
| |
| arg->op.right = right; |
| |
| } else { |
| die("unknown op '%s'", token); |
| /* the arg is now the left side */ |
| return EVENT_NONE; |
| } |
| |
| |
| if (type == EVENT_OP) { |
| int prio; |
| |
| /* higher prios need to be closer to the root */ |
| prio = get_op_prio(*tok); |
| |
| if (prio > arg->op.prio) |
| return process_op(event, arg, tok); |
| |
| return process_op(event, right, tok); |
| } |
| |
| return type; |
| } |
| |
| static enum event_type |
| process_entry(struct event *event __unused, struct print_arg *arg, |
| char **tok) |
| { |
| enum event_type type; |
| char *field; |
| char *token; |
| |
| if (read_expected(EVENT_OP, (char *)"->") < 0) |
| return EVENT_ERROR; |
| |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| goto fail; |
| field = token; |
| |
| arg->type = PRINT_FIELD; |
| arg->field.name = field; |
| |
| type = read_token(&token); |
| *tok = token; |
| |
| return type; |
| |
| fail: |
| free_token(token); |
| return EVENT_ERROR; |
| } |
| |
| static char *arg_eval (struct print_arg *arg); |
| |
| static long long arg_num_eval(struct print_arg *arg) |
| { |
| long long left, right; |
| long long val = 0; |
| |
| switch (arg->type) { |
| case PRINT_ATOM: |
| val = strtoll(arg->atom.atom, NULL, 0); |
| break; |
| case PRINT_TYPE: |
| val = arg_num_eval(arg->typecast.item); |
| break; |
| case PRINT_OP: |
| switch (arg->op.op[0]) { |
| case '|': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| if (arg->op.op[1]) |
| val = left || right; |
| else |
| val = left | right; |
| break; |
| case '&': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| if (arg->op.op[1]) |
| val = left && right; |
| else |
| val = left & right; |
| break; |
| case '<': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| switch (arg->op.op[1]) { |
| case 0: |
| val = left < right; |
| break; |
| case '<': |
| val = left << right; |
| break; |
| case '=': |
| val = left <= right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| case '>': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| switch (arg->op.op[1]) { |
| case 0: |
| val = left > right; |
| break; |
| case '>': |
| val = left >> right; |
| break; |
| case '=': |
| val = left >= right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| case '=': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| |
| if (arg->op.op[1] != '=') |
| die("unknown op '%s'", arg->op.op); |
| |
| val = left == right; |
| break; |
| case '!': |
| left = arg_num_eval(arg->op.left); |
| right = arg_num_eval(arg->op.right); |
| |
| switch (arg->op.op[1]) { |
| case '=': |
| val = left != right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| |
| case PRINT_NULL: |
| case PRINT_FIELD ... PRINT_SYMBOL: |
| case PRINT_STRING: |
| default: |
| die("invalid eval type %d", arg->type); |
| |
| } |
| return val; |
| } |
| |
| static char *arg_eval (struct print_arg *arg) |
| { |
| long long val; |
| static char buf[20]; |
| |
| switch (arg->type) { |
| case PRINT_ATOM: |
| return arg->atom.atom; |
| case PRINT_TYPE: |
| return arg_eval(arg->typecast.item); |
| case PRINT_OP: |
| val = arg_num_eval(arg); |
| sprintf(buf, "%lld", val); |
| return buf; |
| |
| case PRINT_NULL: |
| case PRINT_FIELD ... PRINT_SYMBOL: |
| case PRINT_STRING: |
| default: |
| die("invalid eval type %d", arg->type); |
| break; |
| } |
| |
| return NULL; |
| } |
| |
| static enum event_type |
| process_fields(struct event *event, struct print_flag_sym **list, char **tok) |
| { |
| enum event_type type; |
| struct print_arg *arg = NULL; |
| struct print_flag_sym *field; |
| char *token = NULL; |
| char *value; |
| |
| do { |
| free_token(token); |
| type = read_token_item(&token); |
| if (test_type_token(type, token, EVENT_OP, (char *)"{")) |
| break; |
| |
| arg = malloc_or_die(sizeof(*arg)); |
| |
| free_token(token); |
| type = process_arg(event, arg, &token); |
| if (test_type_token(type, token, EVENT_DELIM, (char *)",")) |
| goto out_free; |
| |
| field = malloc_or_die(sizeof(*field)); |
| memset(field, 0, sizeof(field)); |
| |
| value = arg_eval(arg); |
| field->value = strdup(value); |
| |
| free_token(token); |
| type = process_arg(event, arg, &token); |
| if (test_type_token(type, token, EVENT_OP, (char *)"}")) |
| goto out_free; |
| |
| value = arg_eval(arg); |
| field->str = strdup(value); |
| free_arg(arg); |
| arg = NULL; |
| |
| *list = field; |
| list = &field->next; |
| |
| free_token(token); |
| type = read_token_item(&token); |
| } while (type == EVENT_DELIM && strcmp(token, ",") == 0); |
| |
| *tok = token; |
| return type; |
| |
| out_free: |
| free_arg(arg); |
| free_token(token); |
| |
| return EVENT_ERROR; |
| } |
| |
| static enum event_type |
| process_flags(struct event *event, struct print_arg *arg, char **tok) |
| { |
| struct print_arg *field; |
| enum event_type type; |
| char *token; |
| |
| memset(arg, 0, sizeof(*arg)); |
| arg->type = PRINT_FLAGS; |
| |
| if (read_expected_item(EVENT_DELIM, (char *)"(") < 0) |
| return EVENT_ERROR; |
| |
| field = malloc_or_die(sizeof(*field)); |
| |
| type = process_arg(event, field, &token); |
| if (test_type_token(type, token, EVENT_DELIM, (char *)",")) |
| goto out_free; |
| |
| arg->flags.field = field; |
| |
| type = read_token_item(&token); |
| if (event_item_type(type)) { |
| arg->flags.delim = token; |
| type = read_token_item(&token); |
| } |
| |
| if (test_type_token(type, token, EVENT_DELIM, (char *)",")) |
| goto out_free; |
| |
| type = process_fields(event, &arg->flags.flags, &token); |
| if (test_type_token(type, token, EVENT_DELIM, (char *)")")) |
| goto out_free; |
| |
| free_token(token); |
| type = read_token_item(tok); |
| return type; |
| |
| out_free: |
| free_token(token); |
| return EVENT_ERROR; |
| } |
| |
| static enum event_type |
| process_symbols(struct event *event, struct print_arg *arg, char **tok) |
| { |
| struct print_arg *field; |
| enum event_type type; |
| char *token; |
| |
| memset(arg, 0, sizeof(*arg)); |
| arg->type = PRINT_SYMBOL; |
| |
| if (read_expected_item(EVENT_DELIM, (char *)"(") < 0) |
| return EVENT_ERROR; |
| |
| field = malloc_or_die(sizeof(*field)); |
| |
| type = process_arg(event, field, &token); |
| if (test_type_token(type, token, EVENT_DELIM, (char *)",")) |
| goto out_free; |
| |
| arg->symbol.field = field; |
| |
| type = process_fields(event, &arg->symbol.symbols, &token); |
| if (test_type_token(type, token, EVENT_DELIM, (char *)")")) |
| goto out_free; |
| |
| free_token(token); |
| type = read_token_item(tok); |
| return type; |
| |
| out_free: |
| free_token(token); |
| return EVENT_ERROR; |
| } |
| |
| static enum event_type |
| process_paren(struct event *event, struct print_arg *arg, char **tok) |
| { |
| struct print_arg *item_arg; |
| enum event_type type; |
| int ptr_cast = 0; |
| char *token; |
| |
| type = process_arg(event, arg, &token); |
| |
| if (type == EVENT_ERROR) |
| return EVENT_ERROR; |
| |
| if (type == EVENT_OP) { |
| /* handle the ptr casts */ |
| if (!strcmp(token, "*")) { |
| /* |
| * FIXME: should we zapp whitespaces before ')' ? |
| * (may require a peek_token_item()) |
| */ |
| if (__peek_char() == ')') { |
| ptr_cast = 1; |
| free_token(token); |
| type = read_token_item(&token); |
| } |
| } |
| if (!ptr_cast) { |
| type = process_op(event, arg, &token); |
| |
| if (type == EVENT_ERROR) |
| return EVENT_ERROR; |
| } |
| } |
| |
| if (test_type_token(type, token, EVENT_DELIM, (char *)")")) { |
| free_token(token); |
| return EVENT_ERROR; |
| } |
| |
| free_token(token); |
| type = read_token_item(&token); |
| |
| /* |
| * If the next token is an item or another open paren, then |
| * this was a typecast. |
| */ |
| if (event_item_type(type) || |
| (type == EVENT_DELIM && strcmp(token, "(") == 0)) { |
| |
| /* make this a typecast and contine */ |
| |
| /* prevous must be an atom */ |
| if (arg->type != PRINT_ATOM) |
| die("previous needed to be PRINT_ATOM"); |
| |
| item_arg = malloc_or_die(sizeof(*item_arg)); |
| |
| arg->type = PRINT_TYPE; |
| if (ptr_cast) { |
| char *old = arg->atom.atom; |
| |
| arg->atom.atom = malloc_or_die(strlen(old + 3)); |
| sprintf(arg->atom.atom, "%s *", old); |
| free(old); |
| } |
| arg->typecast.type = arg->atom.atom; |
| arg->typecast.item = item_arg; |
| type = process_arg_token(event, item_arg, &token, type); |
| |
| } |
| |
| *tok = token; |
| return type; |
| } |
| |
| |
| static enum event_type |
| process_str(struct event *event __unused, struct print_arg *arg, char **tok) |
| { |
| enum event_type type; |
| char *token; |
| |
| if (read_expected(EVENT_DELIM, (char *)"(") < 0) |
| return EVENT_ERROR; |
| |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| goto fail; |
| |
| arg->type = PRINT_STRING; |
| arg->string.string = token; |
| arg->string.offset = -1; |
| |
| if (read_expected(EVENT_DELIM, (char *)")") < 0) |
| return EVENT_ERROR; |
| |
| type = read_token(&token); |
| *tok = token; |
| |
| return type; |
| fail: |
| free_token(token); |
| return EVENT_ERROR; |
| } |
| |
| enum event_type |
| process_arg_token(struct event *event, struct print_arg *arg, |
| char **tok, enum event_type type) |
| { |
| char *token; |
| char *atom; |
| |
| token = *tok; |
| |
| switch (type) { |
| case EVENT_ITEM: |
| if (strcmp(token, "REC") == 0) { |
| free_token(token); |
| type = process_entry(event, arg, &token); |
| } else if (strcmp(token, "__print_flags") == 0) { |
| free_token(token); |
| type = process_flags(event, arg, &token); |
| } else if (strcmp(token, "__print_symbolic") == 0) { |
| free_token(token); |
| type = process_symbols(event, arg, &token); |
| } else if (strcmp(token, "__get_str") == 0) { |
| free_token(token); |
| type = process_str(event, arg, &token); |
| } else { |
| atom = token; |
| /* test the next token */ |
| type = read_token_item(&token); |
| |
| /* atoms can be more than one token long */ |
| while (type == EVENT_ITEM) { |
| atom = realloc(atom, strlen(atom) + strlen(token) + 2); |
| strcat(atom, " "); |
| strcat(atom, token); |
| free_token(token); |
| type = read_token_item(&token); |
| } |
| |
| /* todo, test for function */ |
| |
| arg->type = PRINT_ATOM; |
| arg->atom.atom = atom; |
| } |
| break; |
| case EVENT_DQUOTE: |
| case EVENT_SQUOTE: |
| arg->type = PRINT_ATOM; |
| arg->atom.atom = token; |
| type = read_token_item(&token); |
| break; |
| case EVENT_DELIM: |
| if (strcmp(token, "(") == 0) { |
| free_token(token); |
| type = process_paren(event, arg, &token); |
| break; |
| } |
| case EVENT_OP: |
| /* handle single ops */ |
| arg->type = PRINT_OP; |
| arg->op.op = token; |
| arg->op.left = NULL; |
| type = process_op(event, arg, &token); |
| |
| break; |
| |
| case EVENT_ERROR ... EVENT_NEWLINE: |
| default: |
| die("unexpected type %d", type); |
| } |
| *tok = token; |
| |
| return type; |
| } |
| |
| static int event_read_print_args(struct event *event, struct print_arg **list) |
| { |
| enum event_type type; |
| struct print_arg *arg; |
| char *token; |
| int args = 0; |
| |
| do { |
| arg = malloc_or_die(sizeof(*arg)); |
| memset(arg, 0, sizeof(*arg)); |
| |
| type = process_arg(event, arg, &token); |
| |
| if (type == EVENT_ERROR) { |
| free_arg(arg); |
| return -1; |
| } |
| |
| *list = arg; |
| args++; |
| |
| if (type == EVENT_OP) { |
| type = process_op(event, arg, &token); |
| list = &arg->next; |
| continue; |
| } |
| |
| if (type == EVENT_DELIM && strcmp(token, ",") == 0) { |
| free_token(token); |
| *list = arg; |
| list = &arg->next; |
| continue; |
| } |
| break; |
| } while (type != EVENT_NONE); |
| |
| if (type != EVENT_NONE) |
| free_token(token); |
| |
| return args; |
| } |
| |
| static int event_read_print(struct event *event) |
| { |
| enum event_type type; |
| char *token; |
| int ret; |
| |
| if (read_expected_item(EVENT_ITEM, (char *)"print") < 0) |
| return -1; |
| |
| if (read_expected(EVENT_ITEM, (char *)"fmt") < 0) |
| return -1; |
| |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return -1; |
| |
| if (read_expect_type(EVENT_DQUOTE, &token) < 0) |
| goto fail; |
| |
| concat: |
| event->print_fmt.format = token; |
| event->print_fmt.args = NULL; |
| |
| /* ok to have no arg */ |
| type = read_token_item(&token); |
| |
| if (type == EVENT_NONE) |
| return 0; |
| |
| /* Handle concatination of print lines */ |
| if (type == EVENT_DQUOTE) { |
| char *cat; |
| |
| cat = malloc_or_die(strlen(event->print_fmt.format) + |
| strlen(token) + 1); |
| strcpy(cat, event->print_fmt.format); |
| strcat(cat, token); |
| free_token(token); |
| free_token(event->print_fmt.format); |
| event->print_fmt.format = NULL; |
| token = cat; |
| goto concat; |
| } |
| |
| if (test_type_token(type, token, EVENT_DELIM, (char *)",")) |
| goto fail; |
| |
| free_token(token); |
| |
| ret = event_read_print_args(event, &event->print_fmt.args); |
| if (ret < 0) |
| return -1; |
| |
| return 0; |
| |
| fail: |
| free_token(token); |
| return -1; |
| } |
| |
| static struct format_field * |
| find_common_field(struct event *event, const char *name) |
| { |
| struct format_field *format; |
| |
| for (format = event->format.common_fields; |
| format; format = format->next) { |
| if (strcmp(format->name, name) == 0) |
| break; |
| } |
| |
| return format; |
| } |
| |
| static struct format_field * |
| find_field(struct event *event, const char *name) |
| { |
| struct format_field *format; |
| |
| for (format = event->format.fields; |
| format; format = format->next) { |
| if (strcmp(format->name, name) == 0) |
| break; |
| } |
| |
| return format; |
| } |
| |
| static struct format_field * |
| find_any_field(struct event *event, const char *name) |
| { |
| struct format_field *format; |
| |
| format = find_common_field(event, name); |
| if (format) |
| return format; |
| return find_field(event, name); |
| } |
| |
| static unsigned long long read_size(void *ptr, int size) |
| { |
| switch (size) { |
| case 1: |
| return *(unsigned char *)ptr; |
| case 2: |
| return data2host2(ptr); |
| case 4: |
| return data2host4(ptr); |
| case 8: |
| return data2host8(ptr); |
| default: |
| /* BUG! */ |
| return 0; |
| } |
| } |
| |
| unsigned long long |
| raw_field_value(struct event *event, const char *name, void *data) |
| { |
| struct format_field *field; |
| |
| field = find_any_field(event, name); |
| if (!field) |
| return 0ULL; |
| |
| return read_size(data + field->offset, field->size); |
| } |
| |
| void *raw_field_ptr(struct event *event, const char *name, void *data) |
| { |
| struct format_field *field; |
| |
| field = find_any_field(event, name); |
| if (!field) |
| return NULL; |
| |
| return data + field->offset; |
| } |
| |
| static int get_common_info(const char *type, int *offset, int *size) |
| { |
| struct event *event; |
| struct format_field *field; |
| |
| /* |
| * All events should have the same common elements. |
| * Pick any event to find where the type is; |
| */ |
| if (!event_list) |
| die("no event_list!"); |
| |
| event = event_list; |
| field = find_common_field(event, type); |
| if (!field) |
| die("field '%s' not found", type); |
| |
| *offset = field->offset; |
| *size = field->size; |
| |
| return 0; |
| } |
| |
| int trace_parse_common_type(void *data) |
| { |
| static int type_offset; |
| static int type_size; |
| int ret; |
| |
| if (!type_size) { |
| ret = get_common_info("common_type", |
| &type_offset, |
| &type_size); |
| if (ret < 0) |
| return ret; |
| } |
| return read_size(data + type_offset, type_size); |
| } |
| |
| static int parse_common_pid(void *data) |
| { |
| static int pid_offset; |
| static int pid_size; |
| int ret; |
| |
| if (!pid_size) { |
| ret = get_common_info("common_pid", |
| &pid_offset, |
| &pid_size); |
| if (ret < 0) |
| return ret; |
| } |
| |
| return read_size(data + pid_offset, pid_size); |
| } |
| |
| struct event *trace_find_event(int id) |
| { |
| struct event *event; |
| |
| for (event = event_list; event; event = event->next) { |
| if (event->id == id) |
| break; |
| } |
| return event; |
| } |
| |
| static unsigned long long eval_num_arg(void *data, int size, |
| struct event *event, struct print_arg *arg) |
| { |
| unsigned long long val = 0; |
| unsigned long long left, right; |
| |
| switch (arg->type) { |
| case PRINT_NULL: |
| /* ?? */ |
| return 0; |
| case PRINT_ATOM: |
| return strtoull(arg->atom.atom, NULL, 0); |
| case PRINT_FIELD: |
| if (!arg->field.field) { |
| arg->field.field = find_any_field(event, arg->field.name); |
| if (!arg->field.field) |
| die("field %s not found", arg->field.name); |
| } |
| /* must be a number */ |
| val = read_size(data + arg->field.field->offset, |
| arg->field.field->size); |
| break; |
| case PRINT_FLAGS: |
| case PRINT_SYMBOL: |
| break; |
| case PRINT_TYPE: |
| return eval_num_arg(data, size, event, arg->typecast.item); |
| case PRINT_STRING: |
| return 0; |
| break; |
| case PRINT_OP: |
| left = eval_num_arg(data, size, event, arg->op.left); |
| right = eval_num_arg(data, size, event, arg->op.right); |
| switch (arg->op.op[0]) { |
| case '|': |
| if (arg->op.op[1]) |
| val = left || right; |
| else |
| val = left | right; |
| break; |
| case '&': |
| if (arg->op.op[1]) |
| val = left && right; |
| else |
| val = left & right; |
| break; |
| case '<': |
| switch (arg->op.op[1]) { |
| case 0: |
| val = left < right; |
| break; |
| case '<': |
| val = left << right; |
| break; |
| case '=': |
| val = left <= right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| case '>': |
| switch (arg->op.op[1]) { |
| case 0: |
| val = left > right; |
| break; |
| case '>': |
| val = left >> right; |
| break; |
| case '=': |
| val = left >= right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| case '=': |
| if (arg->op.op[1] != '=') |
| die("unknown op '%s'", arg->op.op); |
| val = left == right; |
| break; |
| default: |
| die("unknown op '%s'", arg->op.op); |
| } |
| break; |
| default: /* not sure what to do there */ |
| return 0; |
| } |
| return val; |
| } |
| |
| struct flag { |
| const char *name; |
| unsigned long long value; |
| }; |
| |
| static const struct flag flags[] = { |
| { "HI_SOFTIRQ", 0 }, |
| { "TIMER_SOFTIRQ", 1 }, |
| { "NET_TX_SOFTIRQ", 2 }, |
| { "NET_RX_SOFTIRQ", 3 }, |
| { "BLOCK_SOFTIRQ", 4 }, |
| { "BLOCK_IOPOLL_SOFTIRQ", 5 }, |
| { "TASKLET_SOFTIRQ", 6 }, |
| { "SCHED_SOFTIRQ", 7 }, |
| { "HRTIMER_SOFTIRQ", 8 }, |
| { "RCU_SOFTIRQ", 9 }, |
| |
| { "HRTIMER_NORESTART", 0 }, |
| { "HRTIMER_RESTART", 1 }, |
| }; |
| |
| static unsigned long long eval_flag(const char *flag) |
| { |
| int i; |
| |
| /* |
| * Some flags in the format files do not get converted. |
| * If the flag is not numeric, see if it is something that |
| * we already know about. |
| */ |
| if (isdigit(flag[0])) |
| return strtoull(flag, NULL, 0); |
| |
| for (i = 0; i < (int)(sizeof(flags)/sizeof(flags[0])); i++) |
| if (strcmp(flags[i].name, flag) == 0) |
| return flags[i].value; |
| |
| return 0; |
| } |
| |
| static void print_str_arg(void *data, int size, |
| struct event *event, struct print_arg *arg) |
| { |
| struct print_flag_sym *flag; |
| unsigned long long val, fval; |
| char *str; |
| int print; |
| |
| switch (arg->type) { |
| case PRINT_NULL: |
| /* ?? */ |
| return; |
| case PRINT_ATOM: |
| printf("%s", arg->atom.atom); |
| return; |
| case PRINT_FIELD: |
| if (!arg->field.field) { |
| arg->field.field = find_any_field(event, arg->field.name); |
| if (!arg->field.field) |
| die("field %s not found", arg->field.name); |
| } |
| str = malloc_or_die(arg->field.field->size + 1); |
| memcpy(str, data + arg->field.field->offset, |
| arg->field.field->size); |
| str[arg->field.field->size] = 0; |
| printf("%s", str); |
| free(str); |
| break; |
| case PRINT_FLAGS: |
| val = eval_num_arg(data, size, event, arg->flags.field); |
| print = 0; |
| for (flag = arg->flags.flags; flag; flag = flag->next) { |
| fval = eval_flag(flag->value); |
| if (!val && !fval) { |
| printf("%s", flag->str); |
| break; |
| } |
| if (fval && (val & fval) == fval) { |
| if (print && arg->flags.delim) |
| printf("%s", arg->flags.delim); |
| printf("%s", flag->str); |
| print = 1; |
| val &= ~fval; |
| } |
| } |
| break; |
| case PRINT_SYMBOL: |
| val = eval_num_arg(data, size, event, arg->symbol.field); |
| for (flag = arg->symbol.symbols; flag; flag = flag->next) { |
| fval = eval_flag(flag->value); |
| if (val == fval) { |
| printf("%s", flag->str); |
| break; |
| } |
| } |
| break; |
| |
| case PRINT_TYPE: |
| break; |
| case PRINT_STRING: { |
| int str_offset; |
| |
| if (arg->string.offset == -1) { |
| struct format_field *f; |
| |
| f = find_any_field(event, arg->string.string); |
| arg->string.offset = f->offset; |
| } |
| str_offset = *(int *)(data + arg->string.offset); |
| str_offset &= 0xffff; |
| printf("%s", ((char *)data) + str_offset); |
| break; |
| } |
| case PRINT_OP: |
| /* |
| * The only op for string should be ? : |
| */ |
| if (arg->op.op[0] != '?') |
| return; |
| val = eval_num_arg(data, size, event, arg->op.left); |
| if (val) |
| print_str_arg(data, size, event, arg->op.right->op.left); |
| else |
| print_str_arg(data, size, event, arg->op.right->op.right); |
| break; |
| default: |
| /* well... */ |
| break; |
| } |
| } |
| |
| static struct print_arg *make_bprint_args(char *fmt, void *data, int size, struct event *event) |
| { |
| static struct format_field *field, *ip_field; |
| struct print_arg *args, *arg, **next; |
| unsigned long long ip, val; |
| char *ptr; |
| void *bptr; |
| |
| if (!field) { |
| field = find_field(event, "buf"); |
| if (!field) |
| die("can't find buffer field for binary printk"); |
| ip_field = find_field(event, "ip"); |
| if (!ip_field) |
| die("can't find ip field for binary printk"); |
| } |
| |
| ip = read_size(data + ip_field->offset, ip_field->size); |
| |
| /* |
| * The first arg is the IP pointer. |
| */ |
| args = malloc_or_die(sizeof(*args)); |
| arg = args; |
| arg->next = NULL; |
| next = &arg->next; |
| |
| arg->type = PRINT_ATOM; |
| arg->atom.atom = malloc_or_die(32); |
| sprintf(arg->atom.atom, "%lld", ip); |
| |
| /* skip the first "%pf : " */ |
| for (ptr = fmt + 6, bptr = data + field->offset; |
| bptr < data + size && *ptr; ptr++) { |
| int ls = 0; |
| |
| if (*ptr == '%') { |
| process_again: |
| ptr++; |
| switch (*ptr) { |
| case '%': |
| break; |
| case 'l': |
| ls++; |
| goto process_again; |
| case 'L': |
| ls = 2; |
| goto process_again; |
| case '0' ... '9': |
| goto process_again; |
| case 'p': |
| ls = 1; |
| /* fall through */ |
| case 'd': |
| case 'u': |
| case 'x': |
| case 'i': |
| bptr = (void *)(((unsigned long)bptr + (long_size - 1)) & |
| ~(long_size - 1)); |
| switch (ls) { |
| case 0: |
| case 1: |
| ls = long_size; |
| break; |
| case 2: |
| ls = 8; |
| default: |
| break; |
| } |
| val = read_size(bptr, ls); |
| bptr += ls; |
| arg = malloc_or_die(sizeof(*arg)); |
| arg->next = NULL; |
| arg->type = PRINT_ATOM; |
| arg->atom.atom = malloc_or_die(32); |
| sprintf(arg->atom.atom, "%lld", val); |
| *next = arg; |
| next = &arg->next; |
| break; |
| case 's': |
| arg = malloc_or_die(sizeof(*arg)); |
| arg->next = NULL; |
| arg->type = PRINT_STRING; |
| arg->string.string = strdup(bptr); |
| bptr += strlen(bptr) + 1; |
| *next = arg; |
| next = &arg->next; |
| default: |
| break; |
| } |
| } |
| } |
| |
| return args; |
| } |
| |
| static void free_args(struct print_arg *args) |
| { |
| struct print_arg *next; |
| |
| while (args) { |
| next = args->next; |
| |
| if (args->type == PRINT_ATOM) |
| free(args->atom.atom); |
| else |
| free(args->string.string); |
| free(args); |
| args = next; |
| } |
| } |
| |
| static char *get_bprint_format(void *data, int size __unused, struct event *event) |
| { |
| unsigned long long addr; |
| static struct format_field *field; |
| struct printk_map *printk; |
| char *format; |
| char *p; |
| |
| if (!field) { |
| field = find_field(event, "fmt"); |
| if (!field) |
| die("can't find format field for binary printk"); |
| printf("field->offset = %d size=%d\n", field->offset, field->size); |
| } |
| |
| addr = read_size(data + field->offset, field->size); |
| |
| printk = find_printk(addr); |
| if (!printk) { |
| format = malloc_or_die(45); |
| sprintf(format, "%%pf : (NO FORMAT FOUND at %llx)\n", |
| addr); |
| return format; |
| } |
| |
| p = printk->printk; |
| /* Remove any quotes. */ |
| if (*p == '"') |
| p++; |
| format = malloc_or_die(strlen(p) + 10); |
| sprintf(format, "%s : %s", "%pf", p); |
| /* remove ending quotes and new line since we will add one too */ |
| p = format + strlen(format) - 1; |
| if (*p == '"') |
| *p = 0; |
| |
| p -= 2; |
| if (strcmp(p, "\\n") == 0) |
| *p = 0; |
| |
| return format; |
| } |
| |
| static void pretty_print(void *data, int size, struct event *event) |
| { |
| struct print_fmt *print_fmt = &event->print_fmt; |
| struct print_arg *arg = print_fmt->args; |
| struct print_arg *args = NULL; |
| const char *ptr = print_fmt->format; |
| unsigned long long val; |
| struct func_map *func; |
| const char *saveptr; |
| char *bprint_fmt = NULL; |
| char format[32]; |
| int show_func; |
| int len; |
| int ls; |
| |
| if (event->flags & EVENT_FL_ISFUNC) |
| ptr = " %pF <-- %pF"; |
| |
| if (event->flags & EVENT_FL_ISBPRINT) { |
| bprint_fmt = get_bprint_format(data, size, event); |
| args = make_bprint_args(bprint_fmt, data, size, event); |
| arg = args; |
| ptr = bprint_fmt; |
| } |
| |
| for (; *ptr; ptr++) { |
| ls = 0; |
| if (*ptr == '%') { |
| saveptr = ptr; |
| show_func = 0; |
| cont_process: |
| ptr++; |
| switch (*ptr) { |
| case '%': |
| printf("%%"); |
| break; |
| case 'l': |
| ls++; |
| goto cont_process; |
| case 'L': |
| ls = 2; |
| goto cont_process; |
| case 'z': |
| case 'Z': |
| case '0' ... '9': |
| goto cont_process; |
| case 'p': |
| if (long_size == 4) |
| ls = 1; |
| else |
| ls = 2; |
| |
| if (*(ptr+1) == 'F' || |
| *(ptr+1) == 'f') { |
| ptr++; |
| show_func = *ptr; |
| } |
| |
| /* fall through */ |
| case 'd': |
| case 'i': |
| case 'x': |
| case 'X': |
| case 'u': |
| if (!arg) |
| die("no argument match"); |
| |
| len = ((unsigned long)ptr + 1) - |
| (unsigned long)saveptr; |
| |
| /* should never happen */ |
| if (len > 32) |
| die("bad format!"); |
| |
| memcpy(format, saveptr, len); |
| format[len] = 0; |
| |
| val = eval_num_arg(data, size, event, arg); |
| arg = arg->next; |
| |
| if (show_func) { |
| func = find_func(val); |
| if (func) { |
| printf("%s", func->func); |
| if (show_func == 'F') |
| printf("+0x%llx", |
| val - func->addr); |
| break; |
| } |
| } |
| switch (ls) { |
| case 0: |
| printf(format, (int)val); |
| break; |
| case 1: |
| printf(format, (long)val); |
| break; |
| case 2: |
| printf(format, (long long)val); |
| break; |
| default: |
| die("bad count (%d)", ls); |
| } |
| break; |
| case 's': |
| if (!arg) |
| die("no matching argument"); |
| |
| print_str_arg(data, size, event, arg); |
| arg = arg->next; |
| break; |
| default: |
| printf(">%c<", *ptr); |
| |
| } |
| } else |
| printf("%c", *ptr); |
| } |
| |
| if (args) { |
| free_args(args); |
| free(bprint_fmt); |
| } |
| } |
| |
| static inline int log10_cpu(int nb) |
| { |
| if (nb / 100) |
| return 3; |
| if (nb / 10) |
| return 2; |
| return 1; |
| } |
| |
| /* taken from Linux, written by Frederic Weisbecker */ |
| static void print_graph_cpu(int cpu) |
| { |
| int i; |
| int log10_this = log10_cpu(cpu); |
| int log10_all = log10_cpu(cpus); |
| |
| |
| /* |
| * Start with a space character - to make it stand out |
| * to the right a bit when trace output is pasted into |
| * email: |
| */ |
| printf(" "); |
| |
| /* |
| * Tricky - we space the CPU field according to the max |
| * number of online CPUs. On a 2-cpu system it would take |
| * a maximum of 1 digit - on a 128 cpu system it would |
| * take up to 3 digits: |
| */ |
| for (i = 0; i < log10_all - log10_this; i++) |
| printf(" "); |
| |
| printf("%d) ", cpu); |
| } |
| |
| #define TRACE_GRAPH_PROCINFO_LENGTH 14 |
| #define TRACE_GRAPH_INDENT 2 |
| |
| static void print_graph_proc(int pid, const char *comm) |
| { |
| /* sign + log10(MAX_INT) + '\0' */ |
| char pid_str[11]; |
| int spaces = 0; |
| int len; |
| int i; |
| |
| sprintf(pid_str, "%d", pid); |
| |
| /* 1 stands for the "-" character */ |
| len = strlen(comm) + strlen(pid_str) + 1; |
| |
| if (len < TRACE_GRAPH_PROCINFO_LENGTH) |
| spaces = TRACE_GRAPH_PROCINFO_LENGTH - len; |
| |
| /* First spaces to align center */ |
| for (i = 0; i < spaces / 2; i++) |
| printf(" "); |
| |
| printf("%s-%s", comm, pid_str); |
| |
| /* Last spaces to align center */ |
| for (i = 0; i < spaces - (spaces / 2); i++) |
| printf(" "); |
| } |
| |
| static struct record * |
| get_return_for_leaf(int cpu, int cur_pid, unsigned long long cur_func, |
| struct record *next) |
| { |
| struct format_field *field; |
| struct event *event; |
| unsigned long val; |
| int type; |
| int pid; |
| |
| type = trace_parse_common_type(next->data); |
| event = trace_find_event(type); |
| if (!event) |
| return NULL; |
| |
| if (!(event->flags & EVENT_FL_ISFUNCRET)) |
| return NULL; |
| |
| pid = parse_common_pid(next->data); |
| field = find_field(event, "func"); |
| if (!field) |
| die("function return does not have field func"); |
| |
| val = read_size(next->data + field->offset, field->size); |
| |
| if (cur_pid != pid || cur_func != val) |
| return NULL; |
| |
| /* this is a leaf, now advance the iterator */ |
| return trace_read_data(cpu); |
| } |
| |
| /* Signal a overhead of time execution to the output */ |
| static void print_graph_overhead(unsigned long long duration) |
| { |
| /* Non nested entry or return */ |
| if (duration == ~0ULL) |
| return (void)printf(" "); |
| |
| /* Duration exceeded 100 msecs */ |
| if (duration > 100000ULL) |
| return (void)printf("! "); |
| |
| /* Duration exceeded 10 msecs */ |
| if (duration > 10000ULL) |
| return (void)printf("+ "); |
| |
| printf(" "); |
| } |
| |
| static void print_graph_duration(unsigned long long duration) |
| { |
| unsigned long usecs = duration / 1000; |
| unsigned long nsecs_rem = duration % 1000; |
| /* log10(ULONG_MAX) + '\0' */ |
| char msecs_str[21]; |
| char nsecs_str[5]; |
| int len; |
| int i; |
| |
| sprintf(msecs_str, "%lu", usecs); |
| |
| /* Print msecs */ |
| len = printf("%lu", usecs); |
| |
| /* Print nsecs (we don't want to exceed 7 numbers) */ |
| if (len < 7) { |
| snprintf(nsecs_str, 8 - len, "%03lu", nsecs_rem); |
| len += printf(".%s", nsecs_str); |
| } |
| |
| printf(" us "); |
| |
| /* Print remaining spaces to fit the row's width */ |
| for (i = len; i < 7; i++) |
| printf(" "); |
| |
| printf("| "); |
| } |
| |
| static void |
| print_graph_entry_leaf(struct event *event, void *data, struct record *ret_rec) |
| { |
| unsigned long long rettime, calltime; |
| unsigned long long duration, depth; |
| unsigned long long val; |
| struct format_field *field; |
| struct func_map *func; |
| struct event *ret_event; |
| int type; |
| int i; |
| |
| type = trace_parse_common_type(ret_rec->data); |
| ret_event = trace_find_event(type); |
| |
| field = find_field(ret_event, "rettime"); |
| if (!field) |
| die("can't find rettime in return graph"); |
| rettime = read_size(ret_rec->data + field->offset, field->size); |
| |
| field = find_field(ret_event, "calltime"); |
| if (!field) |
| die("can't find rettime in return graph"); |
| calltime = read_size(ret_rec->data + field->offset, field->size); |
| |
| duration = rettime - calltime; |
| |
| /* Overhead */ |
| print_graph_overhead(duration); |
| |
| /* Duration */ |
| print_graph_duration(duration); |
| |
| field = find_field(event, "depth"); |
| if (!field) |
| die("can't find depth in entry graph"); |
| depth = read_size(data + field->offset, field->size); |
| |
| /* Function */ |
| for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) |
| printf(" "); |
| |
| field = find_field(event, "func"); |
| if (!field) |
| die("can't find func in entry graph"); |
| val = read_size(data + field->offset, field->size); |
| func = find_func(val); |
| |
| if (func) |
| printf("%s();", func->func); |
| else |
| printf("%llx();", val); |
| } |
| |
| static void print_graph_nested(struct event *event, void *data) |
| { |
| struct format_field *field; |
| unsigned long long depth; |
| unsigned long long val; |
| struct func_map *func; |
| int i; |
| |
| /* No overhead */ |
| print_graph_overhead(-1); |
| |
| /* No time */ |
| printf(" | "); |
| |
| field = find_field(event, "depth"); |
| if (!field) |
| die("can't find depth in entry graph"); |
| depth = read_size(data + field->offset, field->size); |
| |
| /* Function */ |
| for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) |
| printf(" "); |
| |
| field = find_field(event, "func"); |
| if (!field) |
| die("can't find func in entry graph"); |
| val = read_size(data + field->offset, field->size); |
| func = find_func(val); |
| |
| if (func) |
| printf("%s() {", func->func); |
| else |
| printf("%llx() {", val); |
| } |
| |
| static void |
| pretty_print_func_ent(void *data, int size, struct event *event, |
| int cpu, int pid, const char *comm, |
| unsigned long secs, unsigned long usecs) |
| { |
| struct format_field *field; |
| struct record *rec; |
| void *copy_data; |
| unsigned long val; |
| |
| printf("%5lu.%06lu | ", secs, usecs); |
| |
| print_graph_cpu(cpu); |
| print_graph_proc(pid, comm); |
| |
| printf(" | "); |
| |
| field = find_field(event, "func"); |
| if (!field) |
| die("function entry does not have func field"); |
| |
| val = read_size(data + field->offset, field->size); |
| |
| /* |
| * peek_data may unmap the data pointer. Copy it first. |
| */ |
| copy_data = malloc_or_die(size); |
| memcpy(copy_data, data, size); |
| data = copy_data; |
| |
| rec = trace_peek_data(cpu); |
| if (rec) { |
| rec = get_return_for_leaf(cpu, pid, val, rec); |
| if (rec) { |
| print_graph_entry_leaf(event, data, rec); |
| goto out_free; |
| } |
| } |
| print_graph_nested(event, data); |
| out_free: |
| free(data); |
| } |
| |
| static void |
| pretty_print_func_ret(void *data, int size __unused, struct event *event, |
| int cpu, int pid, const char *comm, |
| unsigned long secs, unsigned long usecs) |
| { |
| unsigned long long rettime, calltime; |
| unsigned long long duration, depth; |
| struct format_field *field; |
| int i; |
| |
| printf("%5lu.%06lu | ", secs, usecs); |
| |
| print_graph_cpu(cpu); |
| print_graph_proc(pid, comm); |
| |
| printf(" | "); |
| |
| field = find_field(event, "rettime"); |
| if (!field) |
| die("can't find rettime in return graph"); |
| rettime = read_size(data + field->offset, field->size); |
| |
| field = find_field(event, "calltime"); |
| if (!field) |
| die("can't find calltime in return graph"); |
| calltime = read_size(data + field->offset, field->size); |
| |
| duration = rettime - calltime; |
| |
| /* Overhead */ |
| print_graph_overhead(duration); |
| |
| /* Duration */ |
| print_graph_duration(duration); |
| |
| field = find_field(event, "depth"); |
| if (!field) |
| die("can't find depth in entry graph"); |
| depth = read_size(data + field->offset, field->size); |
| |
| /* Function */ |
| for (i = 0; i < (int)(depth * TRACE_GRAPH_INDENT); i++) |
| printf(" "); |
| |
| printf("}"); |
| } |
| |
| static void |
| pretty_print_func_graph(void *data, int size, struct event *event, |
| int cpu, int pid, const char *comm, |
| unsigned long secs, unsigned long usecs) |
| { |
| if (event->flags & EVENT_FL_ISFUNCENT) |
| pretty_print_func_ent(data, size, event, |
| cpu, pid, comm, secs, usecs); |
| else if (event->flags & EVENT_FL_ISFUNCRET) |
| pretty_print_func_ret(data, size, event, |
| cpu, pid, comm, secs, usecs); |
| printf("\n"); |
| } |
| |
| void print_event(int cpu, void *data, int size, unsigned long long nsecs, |
| char *comm) |
| { |
| struct event *event; |
| unsigned long secs; |
| unsigned long usecs; |
| int type; |
| int pid; |
| |
| secs = nsecs / NSECS_PER_SEC; |
| nsecs -= secs * NSECS_PER_SEC; |
| usecs = nsecs / NSECS_PER_USEC; |
| |
| type = trace_parse_common_type(data); |
| |
| event = trace_find_event(type); |
| if (!event) { |
| printf("ug! no event found for type %d\n", type); |
| return; |
| } |
| |
| pid = parse_common_pid(data); |
| |
| if (event->flags & (EVENT_FL_ISFUNCENT | EVENT_FL_ISFUNCRET)) |
| return pretty_print_func_graph(data, size, event, cpu, |
| pid, comm, secs, usecs); |
| |
| printf("%16s-%-5d [%03d] %5lu.%09Lu: %s: ", |
| comm, pid, cpu, |
| secs, nsecs, event->name); |
| |
| pretty_print(data, size, event); |
| printf("\n"); |
| } |
| |
| static void print_fields(struct print_flag_sym *field) |
| { |
| printf("{ %s, %s }", field->value, field->str); |
| if (field->next) { |
| printf(", "); |
| print_fields(field->next); |
| } |
| } |
| |
| static void print_args(struct print_arg *args) |
| { |
| int print_paren = 1; |
| |
| switch (args->type) { |
| case PRINT_NULL: |
| printf("null"); |
| break; |
| case PRINT_ATOM: |
| printf("%s", args->atom.atom); |
| break; |
| case PRINT_FIELD: |
| printf("REC->%s", args->field.name); |
| break; |
| case PRINT_FLAGS: |
| printf("__print_flags("); |
| print_args(args->flags.field); |
| printf(", %s, ", args->flags.delim); |
| print_fields(args->flags.flags); |
| printf(")"); |
| break; |
| case PRINT_SYMBOL: |
| printf("__print_symbolic("); |
| print_args(args->symbol.field); |
| printf(", "); |
| print_fields(args->symbol.symbols); |
| printf(")"); |
| break; |
| case PRINT_STRING: |
| printf("__get_str(%s)", args->string.string); |
| break; |
| case PRINT_TYPE: |
| printf("(%s)", args->typecast.type); |
| print_args(args->typecast.item); |
| break; |
| case PRINT_OP: |
| if (strcmp(args->op.op, ":") == 0) |
| print_paren = 0; |
| if (print_paren) |
| printf("("); |
| print_args(args->op.left); |
| printf(" %s ", args->op.op); |
| print_args(args->op.right); |
| if (print_paren) |
| printf(")"); |
| break; |
| default: |
| /* we should warn... */ |
| return; |
| } |
| if (args->next) { |
| printf("\n"); |
| print_args(args->next); |
| } |
| } |
| |
| static void parse_header_field(char *type, |
| int *offset, int *size) |
| { |
| char *token; |
| |
| if (read_expected(EVENT_ITEM, (char *)"field") < 0) |
| return; |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return; |
| /* type */ |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| return; |
| free_token(token); |
| |
| if (read_expected(EVENT_ITEM, type) < 0) |
| return; |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| return; |
| if (read_expected(EVENT_ITEM, (char *)"offset") < 0) |
| return; |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return; |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| return; |
| *offset = atoi(token); |
| free_token(token); |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| return; |
| if (read_expected(EVENT_ITEM, (char *)"size") < 0) |
| return; |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return; |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| return; |
| *size = atoi(token); |
| free_token(token); |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| return; |
| if (read_expected(EVENT_ITEM, (char *)"signed") < 0) |
| return; |
| if (read_expected(EVENT_OP, (char *)":") < 0) |
| return; |
| if (read_expect_type(EVENT_ITEM, &token) < 0) |
| return; |
| free_token(token); |
| if (read_expected(EVENT_OP, (char *)";") < 0) |
| return; |
| if (read_expect_type(EVENT_NEWLINE, &token) < 0) |
| return; |
| free_token(token); |
| } |
| |
| int parse_header_page(char *buf, unsigned long size) |
| { |
| init_input_buf(buf, size); |
| |
| parse_header_field((char *)"timestamp", &header_page_ts_offset, |
| &header_page_ts_size); |
| parse_header_field((char *)"commit", &header_page_size_offset, |
| &header_page_size_size); |
| parse_header_field((char *)"data", &header_page_data_offset, |
| &header_page_data_size); |
| |
| return 0; |
| } |
| |
| int parse_ftrace_file(char *buf, unsigned long size) |
| { |
| struct format_field *field; |
| struct print_arg *arg, **list; |
| struct event *event; |
| int ret; |
| |
| init_input_buf(buf, size); |
| |
| event = alloc_event(); |
| if (!event) |
| return -ENOMEM; |
| |
| event->flags |= EVENT_FL_ISFTRACE; |
| |
| event->name = event_read_name(); |
| if (!event->name) |
| die("failed to read ftrace event name"); |
| |
| if (strcmp(event->name, "function") == 0) |
| event->flags |= EVENT_FL_ISFUNC; |
| |
| else if (strcmp(event->name, "funcgraph_entry") == 0) |
| event->flags |= EVENT_FL_ISFUNCENT; |
| |
| else if (strcmp(event->name, "funcgraph_exit") == 0) |
| event->flags |= EVENT_FL_ISFUNCRET; |
| |
| else if (strcmp(event->name, "bprint") == 0) |
| event->flags |= EVENT_FL_ISBPRINT; |
| |
| event->id = event_read_id(); |
| if (event->id < 0) |
| die("failed to read ftrace event id"); |
| |
| add_event(event); |
| |
| ret = event_read_format(event); |
| if (ret < 0) |
| die("failed to read ftrace event format"); |
| |
| ret = event_read_print(event); |
| if (ret < 0) |
| die("failed to read ftrace event print fmt"); |
| |
| /* |
| * The arguments for ftrace files are parsed by the fields. |
| * Set up the fields as their arguments. |
| */ |
| list = &event->print_fmt.args; |
| for (field = event->format.fields; field; field = field->next) { |
| arg = malloc_or_die(sizeof(*arg)); |
| memset(arg, 0, sizeof(*arg)); |
| *list = arg; |
| list = &arg->next; |
| arg->type = PRINT_FIELD; |
| arg->field.name = field->name; |
| arg->field.field = field; |
| } |
| return 0; |
| } |
| |
| int parse_event_file(char *buf, unsigned long size, char *sys) |
| { |
| struct event *event; |
| int ret; |
| |
| init_input_buf(buf, size); |
| |
| event = alloc_event(); |
| if (!event) |
| return -ENOMEM; |
| |
| event->name = event_read_name(); |
| if (!event->name) |
| die("failed to read event name"); |
| |
| event->id = event_read_id(); |
| if (event->id < 0) |
| die("failed to read event id"); |
| |
| ret = event_read_format(event); |
| if (ret < 0) |
| die("failed to read event format"); |
| |
| ret = event_read_print(event); |
| if (ret < 0) |
| die("failed to read event print fmt"); |
| |
| event->system = strdup(sys); |
| |
| #define PRINT_ARGS 0 |
| if (PRINT_ARGS && event->print_fmt.args) |
| print_args(event->print_fmt.args); |
| |
| add_event(event); |
| return 0; |
| } |
| |
| void parse_set_info(int nr_cpus, int long_sz) |
| { |
| cpus = nr_cpus; |
| long_size = long_sz; |
| } |