2 * Copyright (C) 2009, Steven Rostedt <srostedt@redhat.com>
4 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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!)
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.
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
19 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
21 * The parts for function graph printing was taken and modified from the
22 * Linux Kernel that were written by Frederic Weisbecker.
34 #include "trace-event.h"
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
;
47 static char *input_buf
;
48 static unsigned long long input_buf_ptr
;
49 static unsigned long long input_buf_siz
;
53 static int is_flag_field
;
54 static int is_symbolic_field
;
56 static struct format_field
*
57 find_any_field(struct event
*event
, const char *name
);
59 static void init_input_buf(char *buf
, unsigned long long size
)
71 static struct cmdline
*cmdlines
;
72 static int cmdline_count
;
74 static int cmdline_cmp(const void *a
, const void *b
)
76 const struct cmdline
*ca
= a
;
77 const struct cmdline
*cb
= b
;
79 if (ca
->pid
< cb
->pid
)
81 if (ca
->pid
> cb
->pid
)
87 void parse_cmdlines(char *file
, int size __unused
)
90 struct cmdline_list
*next
;
93 } *list
= NULL
, *item
;
98 line
= strtok_r(file
, "\n", &next
);
100 item
= malloc_or_die(sizeof(*item
));
101 sscanf(line
, "%d %as", &item
->pid
,
102 (float *)(void *)&item
->comm
); /* workaround gcc warning */
105 line
= strtok_r(NULL
, "\n", &next
);
109 cmdlines
= malloc_or_die(sizeof(*cmdlines
) * cmdline_count
);
113 cmdlines
[i
].pid
= list
->pid
;
114 cmdlines
[i
].comm
= list
->comm
;
121 qsort(cmdlines
, cmdline_count
, sizeof(*cmdlines
), cmdline_cmp
);
124 static struct func_map
{
125 unsigned long long addr
;
129 static unsigned int func_count
;
131 static int func_cmp(const void *a
, const void *b
)
133 const struct func_map
*fa
= a
;
134 const struct func_map
*fb
= b
;
136 if (fa
->addr
< fb
->addr
)
138 if (fa
->addr
> fb
->addr
)
144 void parse_proc_kallsyms(char *file
, unsigned int size __unused
)
147 struct func_list
*next
;
148 unsigned long long addr
;
151 } *list
= NULL
, *item
;
159 line
= strtok_r(file
, "\n", &next
);
161 item
= malloc_or_die(sizeof(*item
));
163 ret
= sscanf(line
, "%as %c %as\t[%as",
164 (float *)(void *)&addr_str
, /* workaround gcc warning */
166 (float *)(void *)&item
->func
,
167 (float *)(void *)&item
->mod
);
168 item
->addr
= strtoull(addr_str
, NULL
, 16);
171 /* truncate the extra ']' */
173 item
->mod
[strlen(item
->mod
) - 1] = 0;
178 line
= strtok_r(NULL
, "\n", &next
);
182 func_list
= malloc_or_die(sizeof(*func_list
) * (func_count
+ 1));
186 func_list
[i
].func
= list
->func
;
187 func_list
[i
].addr
= list
->addr
;
188 func_list
[i
].mod
= list
->mod
;
195 qsort(func_list
, func_count
, sizeof(*func_list
), func_cmp
);
198 * Add a special record at the end.
200 func_list
[func_count
].func
= NULL
;
201 func_list
[func_count
].addr
= 0;
202 func_list
[func_count
].mod
= NULL
;
206 * We are searching for a record in between, not an exact
209 static int func_bcmp(const void *a
, const void *b
)
211 const struct func_map
*fa
= a
;
212 const struct func_map
*fb
= b
;
214 if ((fa
->addr
== fb
->addr
) ||
216 (fa
->addr
> fb
->addr
&&
217 fa
->addr
< (fb
+1)->addr
))
220 if (fa
->addr
< fb
->addr
)
226 static struct func_map
*find_func(unsigned long long addr
)
228 struct func_map
*func
;
233 func
= bsearch(&key
, func_list
, func_count
, sizeof(*func_list
),
239 void print_funcs(void)
243 for (i
= 0; i
< (int)func_count
; i
++) {
247 if (func_list
[i
].mod
)
248 printf(" [%s]\n", func_list
[i
].mod
);
254 static struct printk_map
{
255 unsigned long long addr
;
258 static unsigned int printk_count
;
260 static int printk_cmp(const void *a
, const void *b
)
262 const struct func_map
*fa
= a
;
263 const struct func_map
*fb
= b
;
265 if (fa
->addr
< fb
->addr
)
267 if (fa
->addr
> fb
->addr
)
273 static struct printk_map
*find_printk(unsigned long long addr
)
275 struct printk_map
*printk
;
276 struct printk_map key
;
280 printk
= bsearch(&key
, printk_list
, printk_count
, sizeof(*printk_list
),
286 void parse_ftrace_printk(char *file
, unsigned int size __unused
)
289 struct printk_list
*next
;
290 unsigned long long addr
;
292 } *list
= NULL
, *item
;
298 line
= strtok_r(file
, "\n", &next
);
300 addr_str
= strsep(&line
, ":");
302 warning("error parsing print strings");
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);
311 line
= strtok_r(NULL
, "\n", &next
);
315 printk_list
= malloc_or_die(sizeof(*printk_list
) * printk_count
+ 1);
319 printk_list
[i
].printk
= list
->printk
;
320 printk_list
[i
].addr
= list
->addr
;
327 qsort(printk_list
, printk_count
, sizeof(*printk_list
), printk_cmp
);
330 void print_printk(void)
334 for (i
= 0; i
< (int)printk_count
; i
++) {
335 printf("%016llx %s\n",
337 printk_list
[i
].printk
);
341 static struct event
*alloc_event(void)
345 event
= malloc_or_die(sizeof(*event
));
346 memset(event
, 0, sizeof(*event
));
363 static struct event
*event_list
;
365 static void add_event(struct event
*event
)
367 event
->next
= event_list
;
371 static int event_item_type(enum event_type type
)
374 case EVENT_ITEM
... EVENT_SQUOTE
:
376 case EVENT_ERROR
... EVENT_DELIM
:
382 static void free_arg(struct print_arg
*arg
)
390 free(arg
->atom
.atom
);
393 case PRINT_FIELD
... PRINT_OP
:
402 static enum event_type
get_type(int ch
)
405 return EVENT_NEWLINE
;
408 if (isalnum(ch
) || ch
== '_')
416 if (ch
== '(' || ch
== ')' || ch
== ',')
422 static int __read_char(void)
424 if (input_buf_ptr
>= input_buf_siz
)
427 return input_buf
[input_buf_ptr
++];
430 static int __peek_char(void)
432 if (input_buf_ptr
>= input_buf_siz
)
435 return input_buf
[input_buf_ptr
];
438 static enum event_type
__read_token(char **tok
)
441 int ch
, last_ch
, quote_ch
, next_ch
;
444 enum event_type type
;
454 if (type
== EVENT_NONE
)
462 *tok
= malloc_or_die(2);
470 next_ch
= __peek_char();
471 if (next_ch
== '>') {
472 buf
[i
++] = __read_char();
485 buf
[i
++] = __read_char();
497 default: /* what should we do instead? */
507 buf
[i
++] = __read_char();
512 /* don't keep quotes */
517 if (i
== (BUFSIZ
- 1)) {
520 *tok
= realloc(*tok
, tok_size
+ BUFSIZ
);
535 /* the '\' '\' will cancel itself */
536 if (ch
== '\\' && last_ch
== '\\')
538 } while (ch
!= quote_ch
|| last_ch
== '\\');
539 /* remove the last quote */
543 case EVENT_ERROR
... EVENT_SPACE
:
549 while (get_type(__peek_char()) == type
) {
550 if (i
== (BUFSIZ
- 1)) {
553 *tok
= realloc(*tok
, tok_size
+ BUFSIZ
);
572 *tok
= realloc(*tok
, tok_size
+ i
);
584 static void free_token(char *tok
)
590 static enum event_type
read_token(char **tok
)
592 enum event_type type
;
595 type
= __read_token(tok
);
596 if (type
!= EVENT_SPACE
)
607 static enum event_type
read_token_item(char **tok
)
609 enum event_type type
;
612 type
= __read_token(tok
);
613 if (type
!= EVENT_SPACE
&& type
!= EVENT_NEWLINE
)
623 static int test_type(enum event_type type
, enum event_type expect
)
625 if (type
!= expect
) {
626 warning("Error: expected type %d but read %d",
633 static int __test_type_token(enum event_type type
, char *token
,
634 enum event_type expect
, const char *expect_tok
,
637 if (type
!= expect
) {
639 warning("Error: expected type %d but read %d",
644 if (strcmp(token
, expect_tok
) != 0) {
646 warning("Error: expected '%s' but read '%s'",
653 static int test_type_token(enum event_type type
, char *token
,
654 enum event_type expect
, const char *expect_tok
)
656 return __test_type_token(type
, token
, expect
, expect_tok
, true);
659 static int __read_expect_type(enum event_type expect
, char **tok
, int newline_ok
)
661 enum event_type type
;
664 type
= read_token(tok
);
666 type
= read_token_item(tok
);
667 return test_type(type
, expect
);
670 static int read_expect_type(enum event_type expect
, char **tok
)
672 return __read_expect_type(expect
, tok
, 1);
675 static int __read_expected(enum event_type expect
, const char *str
,
676 int newline_ok
, bool warn
)
678 enum event_type type
;
683 type
= read_token(&token
);
685 type
= read_token_item(&token
);
687 ret
= __test_type_token(type
, token
, expect
, str
, warn
);
694 static int read_expected(enum event_type expect
, const char *str
)
696 return __read_expected(expect
, str
, 1, true);
699 static int read_expected_item(enum event_type expect
, const char *str
)
701 return __read_expected(expect
, str
, 0, true);
704 static char *event_read_name(void)
708 if (read_expected(EVENT_ITEM
, "name") < 0)
711 if (read_expected(EVENT_OP
, ":") < 0)
714 if (read_expect_type(EVENT_ITEM
, &token
) < 0)
724 static int event_read_id(void)
729 if (read_expected_item(EVENT_ITEM
, "ID") < 0)
732 if (read_expected(EVENT_OP
, ":") < 0)
735 if (read_expect_type(EVENT_ITEM
, &token
) < 0)
738 id
= strtoul(token
, NULL
, 0);
747 static int field_is_string(struct format_field
*field
)
749 if ((field
->flags
& FIELD_IS_ARRAY
) &&
750 (!strstr(field
->type
, "char") || !strstr(field
->type
, "u8") ||
751 !strstr(field
->type
, "s8")))
757 static int field_is_dynamic(struct format_field
*field
)
759 if (!strncmp(field
->type
, "__data_loc", 10))
765 static int event_read_fields(struct event
*event
, struct format_field
**fields
)
767 struct format_field
*field
= NULL
;
768 enum event_type type
;
774 type
= read_token(&token
);
775 if (type
== EVENT_NEWLINE
) {
782 if (test_type_token(type
, token
, EVENT_ITEM
, "field"))
786 type
= read_token(&token
);
788 * The ftrace fields may still use the "special" name.
791 if (event
->flags
& EVENT_FL_ISFTRACE
&&
792 type
== EVENT_ITEM
&& strcmp(token
, "special") == 0) {
794 type
= read_token(&token
);
797 if (test_type_token(type
, token
, EVENT_OP
, ":") < 0)
800 if (read_expect_type(EVENT_ITEM
, &token
) < 0)
805 field
= malloc_or_die(sizeof(*field
));
806 memset(field
, 0, sizeof(*field
));
808 /* read the rest of the type */
810 type
= read_token(&token
);
811 if (type
== EVENT_ITEM
||
812 (type
== EVENT_OP
&& strcmp(token
, "*") == 0) ||
814 * Some of the ftrace fields are broken and have
815 * an illegal "." in them.
817 (event
->flags
& EVENT_FL_ISFTRACE
&&
818 type
== EVENT_OP
&& strcmp(token
, ".") == 0)) {
820 if (strcmp(token
, "*") == 0)
821 field
->flags
|= FIELD_IS_POINTER
;
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
);
830 field
->type
= last_token
;
839 die("no type found");
842 field
->name
= last_token
;
844 if (test_type(type
, EVENT_OP
))
847 if (strcmp(token
, "[") == 0) {
848 enum event_type last_type
= type
;
849 char *brackets
= token
;
852 field
->flags
|= FIELD_IS_ARRAY
;
854 type
= read_token(&token
);
855 while (strcmp(token
, "]") != 0) {
856 if (last_type
== EVENT_ITEM
&&
863 brackets
= realloc(brackets
,
865 strlen(token
) + len
);
867 strcat(brackets
, " ");
868 strcat(brackets
, token
);
870 type
= read_token(&token
);
871 if (type
== EVENT_NONE
) {
872 die("failed to find token");
879 brackets
= realloc(brackets
, strlen(brackets
) + 2);
880 strcat(brackets
, "]");
882 /* add brackets to type */
884 type
= read_token(&token
);
886 * If the next token is not an OP, then it is of
887 * the format: type [] item;
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
);
899 type
= read_token(&token
);
901 field
->type
= realloc(field
->type
,
902 strlen(field
->type
) +
903 strlen(brackets
) + 1);
904 strcat(field
->type
, brackets
);
909 if (field_is_string(field
)) {
910 field
->flags
|= FIELD_IS_STRING
;
911 if (field_is_dynamic(field
))
912 field
->flags
|= FIELD_IS_DYNAMIC
;
915 if (test_type_token(type
, token
, EVENT_OP
, ";"))
919 if (read_expected(EVENT_ITEM
, "offset") < 0)
922 if (read_expected(EVENT_OP
, ":") < 0)
925 if (read_expect_type(EVENT_ITEM
, &token
))
927 field
->offset
= strtoul(token
, NULL
, 0);
930 if (read_expected(EVENT_OP
, ";") < 0)
933 if (read_expected(EVENT_ITEM
, "size") < 0)
936 if (read_expected(EVENT_OP
, ":") < 0)
939 if (read_expect_type(EVENT_ITEM
, &token
))
941 field
->size
= strtoul(token
, NULL
, 0);
944 if (read_expected(EVENT_OP
, ";") < 0)
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"))
955 if (read_expected(EVENT_OP
, ":") < 0)
958 if (read_expect_type(EVENT_ITEM
, &token
))
961 if (strtoul(token
, NULL
, 0))
962 field
->flags
|= FIELD_IS_SIGNED
;
965 if (read_expected(EVENT_OP
, ";") < 0)
968 if (read_expect_type(EVENT_NEWLINE
, &token
))
975 fields
= &field
->next
;
989 static int event_read_format(struct event
*event
)
994 if (read_expected_item(EVENT_ITEM
, "format") < 0)
997 if (read_expected(EVENT_OP
, ":") < 0)
1000 if (read_expect_type(EVENT_NEWLINE
, &token
))
1004 ret
= event_read_fields(event
, &event
->format
.common_fields
);
1007 event
->format
.nr_common
= ret
;
1009 ret
= event_read_fields(event
, &event
->format
.fields
);
1012 event
->format
.nr_fields
= ret
;
1022 process_arg_token(struct event
*event
, struct print_arg
*arg
,
1023 char **tok
, enum event_type type
);
1025 static enum event_type
1026 process_arg(struct event
*event
, struct print_arg
*arg
, char **tok
)
1028 enum event_type type
;
1031 type
= read_token(&token
);
1034 return process_arg_token(event
, arg
, tok
, type
);
1037 static enum event_type
1038 process_cond(struct event
*event
, struct print_arg
*top
, char **tok
)
1040 struct print_arg
*arg
, *left
, *right
;
1041 enum event_type type
;
1044 arg
= malloc_or_die(sizeof(*arg
));
1045 memset(arg
, 0, sizeof(*arg
));
1047 left
= malloc_or_die(sizeof(*left
));
1049 right
= malloc_or_die(sizeof(*right
));
1051 arg
->type
= PRINT_OP
;
1052 arg
->op
.left
= left
;
1053 arg
->op
.right
= right
;
1056 type
= process_arg(event
, left
, &token
);
1057 if (test_type_token(type
, token
, EVENT_OP
, ":"))
1062 type
= process_arg(event
, right
, &token
);
1064 top
->op
.right
= arg
;
1077 static enum event_type
1078 process_array(struct event
*event
, struct print_arg
*top
, char **tok
)
1080 struct print_arg
*arg
;
1081 enum event_type type
;
1084 arg
= malloc_or_die(sizeof(*arg
));
1085 memset(arg
, 0, sizeof(*arg
));
1088 type
= process_arg(event
, arg
, &token
);
1089 if (test_type_token(type
, token
, EVENT_OP
, "]"))
1092 top
->op
.right
= arg
;
1095 type
= read_token_item(&token
);
1106 static int get_op_prio(char *op
)
1117 /* '>>' and '<<' are 8 */
1121 /* '==' and '!=' are 10 */
1131 die("unknown op '%c'", op
[0]);
1135 if (strcmp(op
, "++") == 0 ||
1136 strcmp(op
, "--") == 0) {
1138 } else if (strcmp(op
, ">>") == 0 ||
1139 strcmp(op
, "<<") == 0) {
1141 } else if (strcmp(op
, ">=") == 0 ||
1142 strcmp(op
, "<=") == 0) {
1144 } else if (strcmp(op
, "==") == 0 ||
1145 strcmp(op
, "!=") == 0) {
1147 } else if (strcmp(op
, "&&") == 0) {
1149 } else if (strcmp(op
, "||") == 0) {
1152 die("unknown op '%s'", op
);
1158 static void set_op_prio(struct print_arg
*arg
)
1161 /* single ops are the greatest */
1162 if (!arg
->op
.left
|| arg
->op
.left
->type
== PRINT_NULL
) {
1167 arg
->op
.prio
= get_op_prio(arg
->op
.op
);
1170 static enum event_type
1171 process_op(struct event
*event
, struct print_arg
*arg
, char **tok
)
1173 struct print_arg
*left
, *right
= NULL
;
1174 enum event_type type
;
1177 /* the op is passed in via tok */
1180 if (arg
->type
== PRINT_OP
&& !arg
->op
.left
) {
1181 /* handle single op */
1183 die("bad op token %s", token
);
1192 die("bad op token %s", token
);
1196 /* make an empty left */
1197 left
= malloc_or_die(sizeof(*left
));
1198 left
->type
= PRINT_NULL
;
1199 arg
->op
.left
= left
;
1201 right
= malloc_or_die(sizeof(*right
));
1202 arg
->op
.right
= right
;
1204 type
= process_arg(event
, right
, tok
);
1206 } else if (strcmp(token
, "?") == 0) {
1208 left
= malloc_or_die(sizeof(*left
));
1209 /* copy the top arg to the left */
1212 arg
->type
= PRINT_OP
;
1214 arg
->op
.left
= left
;
1217 type
= process_cond(event
, arg
, tok
);
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) {
1235 left
= malloc_or_die(sizeof(*left
));
1237 /* copy the top arg to the left */
1240 arg
->type
= PRINT_OP
;
1242 arg
->op
.left
= left
;
1246 right
= malloc_or_die(sizeof(*right
));
1248 type
= read_token_item(&token
);
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
, " *");
1265 type
= process_arg_token(event
, right
, tok
, type
);
1267 arg
->op
.right
= right
;
1269 } else if (strcmp(token
, "[") == 0) {
1271 left
= malloc_or_die(sizeof(*left
));
1274 arg
->type
= PRINT_OP
;
1276 arg
->op
.left
= left
;
1279 type
= process_array(event
, arg
, tok
);
1282 warning("unknown op '%s'", token
);
1283 event
->flags
|= EVENT_FL_FAILED
;
1284 /* the arg is now the left side */
1288 if (type
== EVENT_OP
) {
1291 /* higher prios need to be closer to the root */
1292 prio
= get_op_prio(*tok
);
1294 if (prio
> arg
->op
.prio
)
1295 return process_op(event
, arg
, tok
);
1297 return process_op(event
, right
, tok
);
1303 static enum event_type
1304 process_entry(struct event
*event __unused
, struct print_arg
*arg
,
1307 enum event_type type
;
1311 if (read_expected(EVENT_OP
, "->") < 0)
1314 if (read_expect_type(EVENT_ITEM
, &token
) < 0)
1318 arg
->type
= PRINT_FIELD
;
1319 arg
->field
.name
= field
;
1321 if (is_flag_field
) {
1322 arg
->field
.field
= find_any_field(event
, arg
->field
.name
);
1323 arg
->field
.field
->flags
|= FIELD_IS_FLAG
;
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;
1331 type
= read_token(&token
);
1341 static char *arg_eval (struct print_arg
*arg
);
1343 static long long arg_num_eval(struct print_arg
*arg
)
1345 long long left
, right
;
1348 switch (arg
->type
) {
1350 val
= strtoll(arg
->atom
.atom
, NULL
, 0);
1353 val
= arg_num_eval(arg
->typecast
.item
);
1356 switch (arg
->op
.op
[0]) {
1358 left
= arg_num_eval(arg
->op
.left
);
1359 right
= arg_num_eval(arg
->op
.right
);
1361 val
= left
|| right
;
1366 left
= arg_num_eval(arg
->op
.left
);
1367 right
= arg_num_eval(arg
->op
.right
);
1369 val
= left
&& right
;
1374 left
= arg_num_eval(arg
->op
.left
);
1375 right
= arg_num_eval(arg
->op
.right
);
1376 switch (arg
->op
.op
[1]) {
1381 val
= left
<< right
;
1384 val
= left
<= right
;
1387 die("unknown op '%s'", arg
->op
.op
);
1391 left
= arg_num_eval(arg
->op
.left
);
1392 right
= arg_num_eval(arg
->op
.right
);
1393 switch (arg
->op
.op
[1]) {
1398 val
= left
>> right
;
1401 val
= left
>= right
;
1404 die("unknown op '%s'", arg
->op
.op
);
1408 left
= arg_num_eval(arg
->op
.left
);
1409 right
= arg_num_eval(arg
->op
.right
);
1411 if (arg
->op
.op
[1] != '=')
1412 die("unknown op '%s'", arg
->op
.op
);
1414 val
= left
== right
;
1417 left
= arg_num_eval(arg
->op
.left
);
1418 right
= arg_num_eval(arg
->op
.right
);
1420 switch (arg
->op
.op
[1]) {
1422 val
= left
!= right
;
1425 die("unknown op '%s'", arg
->op
.op
);
1429 die("unknown op '%s'", arg
->op
.op
);
1434 case PRINT_FIELD
... PRINT_SYMBOL
:
1437 die("invalid eval type %d", arg
->type
);
1443 static char *arg_eval (struct print_arg
*arg
)
1446 static char buf
[20];
1448 switch (arg
->type
) {
1450 return arg
->atom
.atom
;
1452 return arg_eval(arg
->typecast
.item
);
1454 val
= arg_num_eval(arg
);
1455 sprintf(buf
, "%lld", val
);
1459 case PRINT_FIELD
... PRINT_SYMBOL
:
1462 die("invalid eval type %d", arg
->type
);
1469 static enum event_type
1470 process_fields(struct event
*event
, struct print_flag_sym
**list
, char **tok
)
1472 enum event_type type
;
1473 struct print_arg
*arg
= NULL
;
1474 struct print_flag_sym
*field
;
1480 type
= read_token_item(&token
);
1481 if (test_type_token(type
, token
, EVENT_OP
, "{"))
1484 arg
= malloc_or_die(sizeof(*arg
));
1487 type
= process_arg(event
, arg
, &token
);
1488 if (test_type_token(type
, token
, EVENT_DELIM
, ","))
1491 field
= malloc_or_die(sizeof(*field
));
1492 memset(field
, 0, sizeof(*field
));
1494 value
= arg_eval(arg
);
1495 field
->value
= strdup(value
);
1498 type
= process_arg(event
, arg
, &token
);
1499 if (test_type_token(type
, token
, EVENT_OP
, "}"))
1502 value
= arg_eval(arg
);
1503 field
->str
= strdup(value
);
1508 list
= &field
->next
;
1511 type
= read_token_item(&token
);
1512 } while (type
== EVENT_DELIM
&& strcmp(token
, ",") == 0);
1524 static enum event_type
1525 process_flags(struct event
*event
, struct print_arg
*arg
, char **tok
)
1527 struct print_arg
*field
;
1528 enum event_type type
;
1531 memset(arg
, 0, sizeof(*arg
));
1532 arg
->type
= PRINT_FLAGS
;
1534 if (read_expected_item(EVENT_DELIM
, "(") < 0)
1537 field
= malloc_or_die(sizeof(*field
));
1539 type
= process_arg(event
, field
, &token
);
1540 while (type
== EVENT_OP
)
1541 type
= process_op(event
, field
, &token
);
1542 if (test_type_token(type
, token
, EVENT_DELIM
, ","))
1545 arg
->flags
.field
= field
;
1547 type
= read_token_item(&token
);
1548 if (event_item_type(type
)) {
1549 arg
->flags
.delim
= token
;
1550 type
= read_token_item(&token
);
1553 if (test_type_token(type
, token
, EVENT_DELIM
, ","))
1556 type
= process_fields(event
, &arg
->flags
.flags
, &token
);
1557 if (test_type_token(type
, token
, EVENT_DELIM
, ")"))
1561 type
= read_token_item(tok
);
1569 static enum event_type
1570 process_symbols(struct event
*event
, struct print_arg
*arg
, char **tok
)
1572 struct print_arg
*field
;
1573 enum event_type type
;
1576 memset(arg
, 0, sizeof(*arg
));
1577 arg
->type
= PRINT_SYMBOL
;
1579 if (read_expected_item(EVENT_DELIM
, "(") < 0)
1582 field
= malloc_or_die(sizeof(*field
));
1584 type
= process_arg(event
, field
, &token
);
1585 while (type
== EVENT_OP
)
1586 type
= process_op(event
, field
, &token
);
1587 if (test_type_token(type
, token
, EVENT_DELIM
, ","))
1590 arg
->symbol
.field
= field
;
1592 type
= process_fields(event
, &arg
->symbol
.symbols
, &token
);
1593 if (test_type_token(type
, token
, EVENT_DELIM
, ")"))
1597 type
= read_token_item(tok
);
1605 static enum event_type
1606 process_paren(struct event
*event
, struct print_arg
*arg
, char **tok
)
1608 struct print_arg
*item_arg
;
1609 enum event_type type
;
1612 type
= process_arg(event
, arg
, &token
);
1614 if (type
== EVENT_ERROR
)
1617 if (type
== EVENT_OP
)
1618 type
= process_op(event
, arg
, &token
);
1620 if (type
== EVENT_ERROR
)
1623 if (test_type_token(type
, token
, EVENT_DELIM
, ")")) {
1629 type
= read_token_item(&token
);
1632 * If the next token is an item or another open paren, then
1633 * this was a typecast.
1635 if (event_item_type(type
) ||
1636 (type
== EVENT_DELIM
&& strcmp(token
, "(") == 0)) {
1638 /* make this a typecast and contine */
1640 /* prevous must be an atom */
1641 if (arg
->type
!= PRINT_ATOM
)
1642 die("previous needed to be PRINT_ATOM");
1644 item_arg
= malloc_or_die(sizeof(*item_arg
));
1646 arg
->type
= PRINT_TYPE
;
1647 arg
->typecast
.type
= arg
->atom
.atom
;
1648 arg
->typecast
.item
= item_arg
;
1649 type
= process_arg_token(event
, item_arg
, &token
, type
);
1658 static enum event_type
1659 process_str(struct event
*event __unused
, struct print_arg
*arg
, char **tok
)
1661 enum event_type type
;
1664 if (read_expected(EVENT_DELIM
, "(") < 0)
1667 if (read_expect_type(EVENT_ITEM
, &token
) < 0)
1670 arg
->type
= PRINT_STRING
;
1671 arg
->string
.string
= token
;
1672 arg
->string
.offset
= -1;
1674 if (read_expected(EVENT_DELIM
, ")") < 0)
1677 type
= read_token(&token
);
1687 process_arg_token(struct event
*event
, struct print_arg
*arg
,
1688 char **tok
, enum event_type type
)
1697 if (strcmp(token
, "REC") == 0) {
1699 type
= process_entry(event
, arg
, &token
);
1700 } else if (strcmp(token
, "__print_flags") == 0) {
1703 type
= process_flags(event
, arg
, &token
);
1704 } else if (strcmp(token
, "__print_symbolic") == 0) {
1706 is_symbolic_field
= 1;
1707 type
= process_symbols(event
, arg
, &token
);
1708 } else if (strcmp(token
, "__get_str") == 0) {
1710 type
= process_str(event
, arg
, &token
);
1713 /* test the next token */
1714 type
= read_token_item(&token
);
1716 /* atoms can be more than one token long */
1717 while (type
== EVENT_ITEM
) {
1718 atom
= realloc(atom
, strlen(atom
) + strlen(token
) + 2);
1720 strcat(atom
, token
);
1722 type
= read_token_item(&token
);
1725 /* todo, test for function */
1727 arg
->type
= PRINT_ATOM
;
1728 arg
->atom
.atom
= atom
;
1733 arg
->type
= PRINT_ATOM
;
1734 arg
->atom
.atom
= token
;
1735 type
= read_token_item(&token
);
1738 if (strcmp(token
, "(") == 0) {
1740 type
= process_paren(event
, arg
, &token
);
1744 /* handle single ops */
1745 arg
->type
= PRINT_OP
;
1747 arg
->op
.left
= NULL
;
1748 type
= process_op(event
, arg
, &token
);
1752 case EVENT_ERROR
... EVENT_NEWLINE
:
1754 die("unexpected type %d", type
);
1761 static int event_read_print_args(struct event
*event
, struct print_arg
**list
)
1763 enum event_type type
= EVENT_ERROR
;
1764 struct print_arg
*arg
;
1769 if (type
== EVENT_NEWLINE
) {
1771 type
= read_token_item(&token
);
1775 arg
= malloc_or_die(sizeof(*arg
));
1776 memset(arg
, 0, sizeof(*arg
));
1778 type
= process_arg(event
, arg
, &token
);
1780 if (type
== EVENT_ERROR
) {
1788 if (type
== EVENT_OP
) {
1789 type
= process_op(event
, arg
, &token
);
1794 if (type
== EVENT_DELIM
&& strcmp(token
, ",") == 0) {
1801 } while (type
!= EVENT_NONE
);
1803 if (type
!= EVENT_NONE
)
1809 static int event_read_print(struct event
*event
)
1811 enum event_type type
;
1815 if (read_expected_item(EVENT_ITEM
, "print") < 0)
1818 if (read_expected(EVENT_ITEM
, "fmt") < 0)
1821 if (read_expected(EVENT_OP
, ":") < 0)
1824 if (read_expect_type(EVENT_DQUOTE
, &token
) < 0)
1828 event
->print_fmt
.format
= token
;
1829 event
->print_fmt
.args
= NULL
;
1831 /* ok to have no arg */
1832 type
= read_token_item(&token
);
1834 if (type
== EVENT_NONE
)
1837 /* Handle concatination of print lines */
1838 if (type
== EVENT_DQUOTE
) {
1841 cat
= malloc_or_die(strlen(event
->print_fmt
.format
) +
1843 strcpy(cat
, event
->print_fmt
.format
);
1846 free_token(event
->print_fmt
.format
);
1847 event
->print_fmt
.format
= NULL
;
1852 if (test_type_token(type
, token
, EVENT_DELIM
, ","))
1857 ret
= event_read_print_args(event
, &event
->print_fmt
.args
);
1868 static struct format_field
*
1869 find_common_field(struct event
*event
, const char *name
)
1871 struct format_field
*format
;
1873 for (format
= event
->format
.common_fields
;
1874 format
; format
= format
->next
) {
1875 if (strcmp(format
->name
, name
) == 0)
1882 static struct format_field
*
1883 find_field(struct event
*event
, const char *name
)
1885 struct format_field
*format
;
1887 for (format
= event
->format
.fields
;
1888 format
; format
= format
->next
) {
1889 if (strcmp(format
->name
, name
) == 0)
1896 static struct format_field
*
1897 find_any_field(struct event
*event
, const char *name
)
1899 struct format_field
*format
;
1901 format
= find_common_field(event
, name
);
1904 return find_field(event
, name
);
1907 unsigned long long read_size(void *ptr
, int size
)
1911 return *(unsigned char *)ptr
;
1913 return data2host2(ptr
);
1915 return data2host4(ptr
);
1917 return data2host8(ptr
);
1925 raw_field_value(struct event
*event
, const char *name
, void *data
)
1927 struct format_field
*field
;
1929 field
= find_any_field(event
, name
);
1933 return read_size(data
+ field
->offset
, field
->size
);
1936 void *raw_field_ptr(struct event
*event
, const char *name
, void *data
)
1938 struct format_field
*field
;
1940 field
= find_any_field(event
, name
);
1944 if (field
->flags
& FIELD_IS_DYNAMIC
) {
1947 offset
= *(int *)(data
+ field
->offset
);
1950 return data
+ offset
;
1953 return data
+ field
->offset
;
1956 static int get_common_info(const char *type
, int *offset
, int *size
)
1958 struct event
*event
;
1959 struct format_field
*field
;
1962 * All events should have the same common elements.
1963 * Pick any event to find where the type is;
1966 die("no event_list!");
1969 field
= find_common_field(event
, type
);
1971 die("field '%s' not found", type
);
1973 *offset
= field
->offset
;
1974 *size
= field
->size
;
1979 static int __parse_common(void *data
, int *size
, int *offset
,
1985 ret
= get_common_info(name
, offset
, size
);
1989 return read_size(data
+ *offset
, *size
);
1992 int trace_parse_common_type(void *data
)
1994 static int type_offset
;
1995 static int type_size
;
1997 return __parse_common(data
, &type_size
, &type_offset
,
2001 int trace_parse_common_pid(void *data
)
2003 static int pid_offset
;
2004 static int pid_size
;
2006 return __parse_common(data
, &pid_size
, &pid_offset
,
2010 int parse_common_pc(void *data
)
2012 static int pc_offset
;
2015 return __parse_common(data
, &pc_size
, &pc_offset
,
2016 "common_preempt_count");
2019 int parse_common_flags(void *data
)
2021 static int flags_offset
;
2022 static int flags_size
;
2024 return __parse_common(data
, &flags_size
, &flags_offset
,
2028 int parse_common_lock_depth(void *data
)
2030 static int ld_offset
;
2034 ret
= __parse_common(data
, &ld_size
, &ld_offset
,
2035 "common_lock_depth");
2042 struct event
*trace_find_event(int id
)
2044 struct event
*event
;
2046 for (event
= event_list
; event
; event
= event
->next
) {
2047 if (event
->id
== id
)
2053 struct event
*trace_find_next_event(struct event
*event
)
2061 static unsigned long long eval_num_arg(void *data
, int size
,
2062 struct event
*event
, struct print_arg
*arg
)
2064 unsigned long long val
= 0;
2065 unsigned long long left
, right
;
2066 struct print_arg
*larg
;
2068 switch (arg
->type
) {
2073 return strtoull(arg
->atom
.atom
, NULL
, 0);
2075 if (!arg
->field
.field
) {
2076 arg
->field
.field
= find_any_field(event
, arg
->field
.name
);
2077 if (!arg
->field
.field
)
2078 die("field %s not found", arg
->field
.name
);
2080 /* must be a number */
2081 val
= read_size(data
+ arg
->field
.field
->offset
,
2082 arg
->field
.field
->size
);
2088 return eval_num_arg(data
, size
, event
, arg
->typecast
.item
);
2093 if (strcmp(arg
->op
.op
, "[") == 0) {
2095 * Arrays are special, since we don't want
2096 * to read the arg as is.
2098 if (arg
->op
.left
->type
!= PRINT_FIELD
)
2099 goto default_op
; /* oops, all bets off */
2100 larg
= arg
->op
.left
;
2101 if (!larg
->field
.field
) {
2103 find_any_field(event
, larg
->field
.name
);
2104 if (!larg
->field
.field
)
2105 die("field %s not found", larg
->field
.name
);
2107 right
= eval_num_arg(data
, size
, event
, arg
->op
.right
);
2108 val
= read_size(data
+ larg
->field
.field
->offset
+
2109 right
* long_size
, long_size
);
2113 left
= eval_num_arg(data
, size
, event
, arg
->op
.left
);
2114 right
= eval_num_arg(data
, size
, event
, arg
->op
.right
);
2115 switch (arg
->op
.op
[0]) {
2118 val
= left
|| right
;
2124 val
= left
&& right
;
2129 switch (arg
->op
.op
[1]) {
2134 val
= left
<< right
;
2137 val
= left
<= right
;
2140 die("unknown op '%s'", arg
->op
.op
);
2144 switch (arg
->op
.op
[1]) {
2149 val
= left
>> right
;
2152 val
= left
>= right
;
2155 die("unknown op '%s'", arg
->op
.op
);
2159 if (arg
->op
.op
[1] != '=')
2160 die("unknown op '%s'", arg
->op
.op
);
2161 val
= left
== right
;
2170 die("unknown op '%s'", arg
->op
.op
);
2173 default: /* not sure what to do there */
2181 unsigned long long value
;
2184 static const struct flag flags
[] = {
2185 { "HI_SOFTIRQ", 0 },
2186 { "TIMER_SOFTIRQ", 1 },
2187 { "NET_TX_SOFTIRQ", 2 },
2188 { "NET_RX_SOFTIRQ", 3 },
2189 { "BLOCK_SOFTIRQ", 4 },
2190 { "BLOCK_IOPOLL_SOFTIRQ", 5 },
2191 { "TASKLET_SOFTIRQ", 6 },
2192 { "SCHED_SOFTIRQ", 7 },
2193 { "HRTIMER_SOFTIRQ", 8 },
2194 { "RCU_SOFTIRQ", 9 },
2196 { "HRTIMER_NORESTART", 0 },
2197 { "HRTIMER_RESTART", 1 },
2200 unsigned long long eval_flag(const char *flag
)
2205 * Some flags in the format files do not get converted.
2206 * If the flag is not numeric, see if it is something that
2207 * we already know about.
2209 if (isdigit(flag
[0]))
2210 return strtoull(flag
, NULL
, 0);
2212 for (i
= 0; i
< (int)(sizeof(flags
)/sizeof(flags
[0])); i
++)
2213 if (strcmp(flags
[i
].name
, flag
) == 0)
2214 return flags
[i
].value
;
2219 static void print_str_arg(void *data
, int size
,
2220 struct event
*event
, struct print_arg
*arg
)
2222 struct print_flag_sym
*flag
;
2223 unsigned long long val
, fval
;
2227 switch (arg
->type
) {
2232 printf("%s", arg
->atom
.atom
);
2235 if (!arg
->field
.field
) {
2236 arg
->field
.field
= find_any_field(event
, arg
->field
.name
);
2237 if (!arg
->field
.field
)
2238 die("field %s not found", arg
->field
.name
);
2240 str
= malloc_or_die(arg
->field
.field
->size
+ 1);
2241 memcpy(str
, data
+ arg
->field
.field
->offset
,
2242 arg
->field
.field
->size
);
2243 str
[arg
->field
.field
->size
] = 0;
2248 val
= eval_num_arg(data
, size
, event
, arg
->flags
.field
);
2250 for (flag
= arg
->flags
.flags
; flag
; flag
= flag
->next
) {
2251 fval
= eval_flag(flag
->value
);
2252 if (!val
&& !fval
) {
2253 printf("%s", flag
->str
);
2256 if (fval
&& (val
& fval
) == fval
) {
2257 if (print
&& arg
->flags
.delim
)
2258 printf("%s", arg
->flags
.delim
);
2259 printf("%s", flag
->str
);
2266 val
= eval_num_arg(data
, size
, event
, arg
->symbol
.field
);
2267 for (flag
= arg
->symbol
.symbols
; flag
; flag
= flag
->next
) {
2268 fval
= eval_flag(flag
->value
);
2270 printf("%s", flag
->str
);
2278 case PRINT_STRING
: {
2281 if (arg
->string
.offset
== -1) {
2282 struct format_field
*f
;
2284 f
= find_any_field(event
, arg
->string
.string
);
2285 arg
->string
.offset
= f
->offset
;
2287 str_offset
= *(int *)(data
+ arg
->string
.offset
);
2288 str_offset
&= 0xffff;
2289 printf("%s", ((char *)data
) + str_offset
);
2294 * The only op for string should be ? :
2296 if (arg
->op
.op
[0] != '?')
2298 val
= eval_num_arg(data
, size
, event
, arg
->op
.left
);
2300 print_str_arg(data
, size
, event
, arg
->op
.right
->op
.left
);
2302 print_str_arg(data
, size
, event
, arg
->op
.right
->op
.right
);
2310 static struct print_arg
*make_bprint_args(char *fmt
, void *data
, int size
, struct event
*event
)
2312 static struct format_field
*field
, *ip_field
;
2313 struct print_arg
*args
, *arg
, **next
;
2314 unsigned long long ip
, val
;
2319 field
= find_field(event
, "buf");
2321 die("can't find buffer field for binary printk");
2322 ip_field
= find_field(event
, "ip");
2324 die("can't find ip field for binary printk");
2327 ip
= read_size(data
+ ip_field
->offset
, ip_field
->size
);
2330 * The first arg is the IP pointer.
2332 args
= malloc_or_die(sizeof(*args
));
2337 arg
->type
= PRINT_ATOM
;
2338 arg
->atom
.atom
= malloc_or_die(32);
2339 sprintf(arg
->atom
.atom
, "%lld", ip
);
2341 /* skip the first "%pf : " */
2342 for (ptr
= fmt
+ 6, bptr
= data
+ field
->offset
;
2343 bptr
< data
+ size
&& *ptr
; ptr
++) {
2367 /* the pointers are always 4 bytes aligned */
2368 bptr
= (void *)(((unsigned long)bptr
+ 3) &
2380 val
= read_size(bptr
, ls
);
2382 arg
= malloc_or_die(sizeof(*arg
));
2384 arg
->type
= PRINT_ATOM
;
2385 arg
->atom
.atom
= malloc_or_die(32);
2386 sprintf(arg
->atom
.atom
, "%lld", val
);
2391 arg
= malloc_or_die(sizeof(*arg
));
2393 arg
->type
= PRINT_STRING
;
2394 arg
->string
.string
= strdup(bptr
);
2395 bptr
+= strlen(bptr
) + 1;
2407 static void free_args(struct print_arg
*args
)
2409 struct print_arg
*next
;
2414 if (args
->type
== PRINT_ATOM
)
2415 free(args
->atom
.atom
);
2417 free(args
->string
.string
);
2423 static char *get_bprint_format(void *data
, int size __unused
, struct event
*event
)
2425 unsigned long long addr
;
2426 static struct format_field
*field
;
2427 struct printk_map
*printk
;
2432 field
= find_field(event
, "fmt");
2434 die("can't find format field for binary printk");
2435 printf("field->offset = %d size=%d\n", field
->offset
, field
->size
);
2438 addr
= read_size(data
+ field
->offset
, field
->size
);
2440 printk
= find_printk(addr
);
2442 format
= malloc_or_die(45);
2443 sprintf(format
, "%%pf : (NO FORMAT FOUND at %llx)\n",
2449 /* Remove any quotes. */
2452 format
= malloc_or_die(strlen(p
) + 10);
2453 sprintf(format
, "%s : %s", "%pf", p
);
2454 /* remove ending quotes and new line since we will add one too */
2455 p
= format
+ strlen(format
) - 1;
2460 if (strcmp(p
, "\\n") == 0)
2466 static void pretty_print(void *data
, int size
, struct event
*event
)
2468 struct print_fmt
*print_fmt
= &event
->print_fmt
;
2469 struct print_arg
*arg
= print_fmt
->args
;
2470 struct print_arg
*args
= NULL
;
2471 const char *ptr
= print_fmt
->format
;
2472 unsigned long long val
;
2473 struct func_map
*func
;
2474 const char *saveptr
;
2475 char *bprint_fmt
= NULL
;
2481 if (event
->flags
& EVENT_FL_ISFUNC
)
2482 ptr
= " %pF <-- %pF";
2484 if (event
->flags
& EVENT_FL_ISBPRINT
) {
2485 bprint_fmt
= get_bprint_format(data
, size
, event
);
2486 args
= make_bprint_args(bprint_fmt
, data
, size
, event
);
2491 for (; *ptr
; ptr
++) {
2513 } else if (*ptr
== '%') {
2538 if (*(ptr
+1) == 'F' ||
2551 die("no argument match");
2553 len
= ((unsigned long)ptr
+ 1) -
2554 (unsigned long)saveptr
;
2556 /* should never happen */
2560 memcpy(format
, saveptr
, len
);
2563 val
= eval_num_arg(data
, size
, event
, arg
);
2567 func
= find_func(val
);
2569 printf("%s", func
->func
);
2570 if (show_func
== 'F')
2578 printf(format
, (int)val
);
2581 printf(format
, (long)val
);
2584 printf(format
, (long long)val
);
2587 die("bad count (%d)", ls
);
2592 die("no matching argument");
2594 print_str_arg(data
, size
, event
, arg
);
2598 printf(">%c<", *ptr
);
2611 static inline int log10_cpu(int nb
)
2620 static void print_lat_fmt(void *data
, int size __unused
)
2622 unsigned int lat_flags
;
2628 lat_flags
= parse_common_flags(data
);
2629 pc
= parse_common_pc(data
);
2630 lock_depth
= parse_common_lock_depth(data
);
2632 hardirq
= lat_flags
& TRACE_FLAG_HARDIRQ
;
2633 softirq
= lat_flags
& TRACE_FLAG_SOFTIRQ
;
2636 (lat_flags
& TRACE_FLAG_IRQS_OFF
) ? 'd' :
2637 (lat_flags
& TRACE_FLAG_IRQS_NOSUPPORT
) ?
2639 (lat_flags
& TRACE_FLAG_NEED_RESCHED
) ?
2641 (hardirq
&& softirq
) ? 'H' :
2642 hardirq
? 'h' : softirq
? 's' : '.');
2652 printf("%d ", lock_depth
);
2655 #define TRACE_GRAPH_INDENT 2
2657 static struct record
*
2658 get_return_for_leaf(int cpu
, int cur_pid
, unsigned long long cur_func
,
2659 struct record
*next
)
2661 struct format_field
*field
;
2662 struct event
*event
;
2667 type
= trace_parse_common_type(next
->data
);
2668 event
= trace_find_event(type
);
2672 if (!(event
->flags
& EVENT_FL_ISFUNCRET
))
2675 pid
= trace_parse_common_pid(next
->data
);
2676 field
= find_field(event
, "func");
2678 die("function return does not have field func");
2680 val
= read_size(next
->data
+ field
->offset
, field
->size
);
2682 if (cur_pid
!= pid
|| cur_func
!= val
)
2685 /* this is a leaf, now advance the iterator */
2686 return trace_read_data(cpu
);
2689 /* Signal a overhead of time execution to the output */
2690 static void print_graph_overhead(unsigned long long duration
)
2692 /* Non nested entry or return */
2693 if (duration
== ~0ULL)
2694 return (void)printf(" ");
2696 /* Duration exceeded 100 msecs */
2697 if (duration
> 100000ULL)
2698 return (void)printf("! ");
2700 /* Duration exceeded 10 msecs */
2701 if (duration
> 10000ULL)
2702 return (void)printf("+ ");
2707 static void print_graph_duration(unsigned long long duration
)
2709 unsigned long usecs
= duration
/ 1000;
2710 unsigned long nsecs_rem
= duration
% 1000;
2711 /* log10(ULONG_MAX) + '\0' */
2717 sprintf(msecs_str
, "%lu", usecs
);
2720 len
= printf("%lu", usecs
);
2722 /* Print nsecs (we don't want to exceed 7 numbers) */
2724 snprintf(nsecs_str
, 8 - len
, "%03lu", nsecs_rem
);
2725 len
+= printf(".%s", nsecs_str
);
2730 /* Print remaining spaces to fit the row's width */
2731 for (i
= len
; i
< 7; i
++)
2738 print_graph_entry_leaf(struct event
*event
, void *data
, struct record
*ret_rec
)
2740 unsigned long long rettime
, calltime
;
2741 unsigned long long duration
, depth
;
2742 unsigned long long val
;
2743 struct format_field
*field
;
2744 struct func_map
*func
;
2745 struct event
*ret_event
;
2749 type
= trace_parse_common_type(ret_rec
->data
);
2750 ret_event
= trace_find_event(type
);
2752 field
= find_field(ret_event
, "rettime");
2754 die("can't find rettime in return graph");
2755 rettime
= read_size(ret_rec
->data
+ field
->offset
, field
->size
);
2757 field
= find_field(ret_event
, "calltime");
2759 die("can't find rettime in return graph");
2760 calltime
= read_size(ret_rec
->data
+ field
->offset
, field
->size
);
2762 duration
= rettime
- calltime
;
2765 print_graph_overhead(duration
);
2768 print_graph_duration(duration
);
2770 field
= find_field(event
, "depth");
2772 die("can't find depth in entry graph");
2773 depth
= read_size(data
+ field
->offset
, field
->size
);
2776 for (i
= 0; i
< (int)(depth
* TRACE_GRAPH_INDENT
); i
++)
2779 field
= find_field(event
, "func");
2781 die("can't find func in entry graph");
2782 val
= read_size(data
+ field
->offset
, field
->size
);
2783 func
= find_func(val
);
2786 printf("%s();", func
->func
);
2788 printf("%llx();", val
);
2791 static void print_graph_nested(struct event
*event
, void *data
)
2793 struct format_field
*field
;
2794 unsigned long long depth
;
2795 unsigned long long val
;
2796 struct func_map
*func
;
2800 print_graph_overhead(-1);
2805 field
= find_field(event
, "depth");
2807 die("can't find depth in entry graph");
2808 depth
= read_size(data
+ field
->offset
, field
->size
);
2811 for (i
= 0; i
< (int)(depth
* TRACE_GRAPH_INDENT
); i
++)
2814 field
= find_field(event
, "func");
2816 die("can't find func in entry graph");
2817 val
= read_size(data
+ field
->offset
, field
->size
);
2818 func
= find_func(val
);
2821 printf("%s() {", func
->func
);
2823 printf("%llx() {", val
);
2827 pretty_print_func_ent(void *data
, int size
, struct event
*event
,
2830 struct format_field
*field
;
2835 if (latency_format
) {
2836 print_lat_fmt(data
, size
);
2840 field
= find_field(event
, "func");
2842 die("function entry does not have func field");
2844 val
= read_size(data
+ field
->offset
, field
->size
);
2847 * peek_data may unmap the data pointer. Copy it first.
2849 copy_data
= malloc_or_die(size
);
2850 memcpy(copy_data
, data
, size
);
2853 rec
= trace_peek_data(cpu
);
2855 rec
= get_return_for_leaf(cpu
, pid
, val
, rec
);
2857 print_graph_entry_leaf(event
, data
, rec
);
2861 print_graph_nested(event
, data
);
2867 pretty_print_func_ret(void *data
, int size __unused
, struct event
*event
)
2869 unsigned long long rettime
, calltime
;
2870 unsigned long long duration
, depth
;
2871 struct format_field
*field
;
2874 if (latency_format
) {
2875 print_lat_fmt(data
, size
);
2879 field
= find_field(event
, "rettime");
2881 die("can't find rettime in return graph");
2882 rettime
= read_size(data
+ field
->offset
, field
->size
);
2884 field
= find_field(event
, "calltime");
2886 die("can't find calltime in return graph");
2887 calltime
= read_size(data
+ field
->offset
, field
->size
);
2889 duration
= rettime
- calltime
;
2892 print_graph_overhead(duration
);
2895 print_graph_duration(duration
);
2897 field
= find_field(event
, "depth");
2899 die("can't find depth in entry graph");
2900 depth
= read_size(data
+ field
->offset
, field
->size
);
2903 for (i
= 0; i
< (int)(depth
* TRACE_GRAPH_INDENT
); i
++)
2910 pretty_print_func_graph(void *data
, int size
, struct event
*event
,
2913 if (event
->flags
& EVENT_FL_ISFUNCENT
)
2914 pretty_print_func_ent(data
, size
, event
, cpu
, pid
);
2915 else if (event
->flags
& EVENT_FL_ISFUNCRET
)
2916 pretty_print_func_ret(data
, size
, event
);
2920 void print_trace_event(int cpu
, void *data
, int size
)
2922 struct event
*event
;
2926 type
= trace_parse_common_type(data
);
2928 event
= trace_find_event(type
);
2930 warning("ug! no event found for type %d", type
);
2934 pid
= trace_parse_common_pid(data
);
2936 if (event
->flags
& (EVENT_FL_ISFUNCENT
| EVENT_FL_ISFUNCRET
))
2937 return pretty_print_func_graph(data
, size
, event
, cpu
, pid
);
2940 print_lat_fmt(data
, size
);
2942 if (event
->flags
& EVENT_FL_FAILED
) {
2943 printf("EVENT '%s' FAILED TO PARSE\n",
2948 pretty_print(data
, size
, event
);
2951 static void print_fields(struct print_flag_sym
*field
)
2953 printf("{ %s, %s }", field
->value
, field
->str
);
2956 print_fields(field
->next
);
2960 static void print_args(struct print_arg
*args
)
2962 int print_paren
= 1;
2964 switch (args
->type
) {
2969 printf("%s", args
->atom
.atom
);
2972 printf("REC->%s", args
->field
.name
);
2975 printf("__print_flags(");
2976 print_args(args
->flags
.field
);
2977 printf(", %s, ", args
->flags
.delim
);
2978 print_fields(args
->flags
.flags
);
2982 printf("__print_symbolic(");
2983 print_args(args
->symbol
.field
);
2985 print_fields(args
->symbol
.symbols
);
2989 printf("__get_str(%s)", args
->string
.string
);
2992 printf("(%s)", args
->typecast
.type
);
2993 print_args(args
->typecast
.item
);
2996 if (strcmp(args
->op
.op
, ":") == 0)
3000 print_args(args
->op
.left
);
3001 printf(" %s ", args
->op
.op
);
3002 print_args(args
->op
.right
);
3007 /* we should warn... */
3012 print_args(args
->next
);
3016 int parse_ftrace_file(char *buf
, unsigned long size
)
3018 struct format_field
*field
;
3019 struct print_arg
*arg
, **list
;
3020 struct event
*event
;
3023 init_input_buf(buf
, size
);
3025 event
= alloc_event();
3029 event
->flags
|= EVENT_FL_ISFTRACE
;
3031 event
->name
= event_read_name();
3033 die("failed to read ftrace event name");
3035 if (strcmp(event
->name
, "function") == 0)
3036 event
->flags
|= EVENT_FL_ISFUNC
;
3038 else if (strcmp(event
->name
, "funcgraph_entry") == 0)
3039 event
->flags
|= EVENT_FL_ISFUNCENT
;
3041 else if (strcmp(event
->name
, "funcgraph_exit") == 0)
3042 event
->flags
|= EVENT_FL_ISFUNCRET
;
3044 else if (strcmp(event
->name
, "bprint") == 0)
3045 event
->flags
|= EVENT_FL_ISBPRINT
;
3047 event
->id
= event_read_id();
3049 die("failed to read ftrace event id");
3053 ret
= event_read_format(event
);
3055 die("failed to read ftrace event format");
3057 ret
= event_read_print(event
);
3059 die("failed to read ftrace event print fmt");
3061 /* New ftrace handles args */
3065 * The arguments for ftrace files are parsed by the fields.
3066 * Set up the fields as their arguments.
3068 list
= &event
->print_fmt
.args
;
3069 for (field
= event
->format
.fields
; field
; field
= field
->next
) {
3070 arg
= malloc_or_die(sizeof(*arg
));
3071 memset(arg
, 0, sizeof(*arg
));
3074 arg
->type
= PRINT_FIELD
;
3075 arg
->field
.name
= field
->name
;
3076 arg
->field
.field
= field
;
3081 int parse_event_file(char *buf
, unsigned long size
, char *sys
)
3083 struct event
*event
;
3086 init_input_buf(buf
, size
);
3088 event
= alloc_event();
3092 event
->name
= event_read_name();
3094 die("failed to read event name");
3096 event
->id
= event_read_id();
3098 die("failed to read event id");
3100 ret
= event_read_format(event
);
3102 warning("failed to read event format for %s", event
->name
);
3106 ret
= event_read_print(event
);
3108 warning("failed to read event print fmt for %s", event
->name
);
3112 event
->system
= strdup(sys
);
3114 #define PRINT_ARGS 0
3115 if (PRINT_ARGS
&& event
->print_fmt
.args
)
3116 print_args(event
->print_fmt
.args
);
3122 event
->flags
|= EVENT_FL_FAILED
;
3123 /* still add it even if it failed */
3128 void parse_set_info(int nr_cpus
, int long_sz
)
3131 long_size
= long_sz
;
3134 int common_pc(struct scripting_context
*context
)
3136 return parse_common_pc(context
->event_data
);
3139 int common_flags(struct scripting_context
*context
)
3141 return parse_common_flags(context
->event_data
);
3144 int common_lock_depth(struct scripting_context
*context
)
3146 return parse_common_lock_depth(context
->event_data
);