5 const char default_parent_pattern
[] = "^sys_|^do_page_fault";
6 const char *parent_pattern
= default_parent_pattern
;
7 const char default_sort_order
[] = "comm,dso,symbol";
8 const char *sort_order
= default_sort_order
;
9 int sort__need_collapse
= 0;
10 int sort__has_parent
= 0;
11 int sort__has_sym
= 0;
12 int sort__branch_mode
= -1; /* -1 = means not set */
14 enum sort_type sort__first_dimension
;
16 LIST_HEAD(hist_entry__sort_list
);
18 static int repsep_snprintf(char *bf
, size_t size
, const char *fmt
, ...)
24 n
= vsnprintf(bf
, size
, fmt
, ap
);
25 if (symbol_conf
.field_sep
&& n
> 0) {
29 sep
= strchr(sep
, *symbol_conf
.field_sep
);
42 static int64_t cmp_null(void *l
, void *r
)
55 sort__thread_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
57 return right
->thread
->pid
- left
->thread
->pid
;
60 static int hist_entry__thread_snprintf(struct hist_entry
*self
, char *bf
,
61 size_t size
, unsigned int width
)
63 return repsep_snprintf(bf
, size
, "%*s:%5d", width
,
64 self
->thread
->comm
?: "", self
->thread
->pid
);
67 struct sort_entry sort_thread
= {
68 .se_header
= "Command: Pid",
69 .se_cmp
= sort__thread_cmp
,
70 .se_snprintf
= hist_entry__thread_snprintf
,
71 .se_width_idx
= HISTC_THREAD
,
77 sort__comm_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
79 return right
->thread
->pid
- left
->thread
->pid
;
83 sort__comm_collapse(struct hist_entry
*left
, struct hist_entry
*right
)
85 char *comm_l
= left
->thread
->comm
;
86 char *comm_r
= right
->thread
->comm
;
88 if (!comm_l
|| !comm_r
)
89 return cmp_null(comm_l
, comm_r
);
91 return strcmp(comm_l
, comm_r
);
94 static int hist_entry__comm_snprintf(struct hist_entry
*self
, char *bf
,
95 size_t size
, unsigned int width
)
97 return repsep_snprintf(bf
, size
, "%*s", width
, self
->thread
->comm
);
100 static int64_t _sort__dso_cmp(struct map
*map_l
, struct map
*map_r
)
102 struct dso
*dso_l
= map_l
? map_l
->dso
: NULL
;
103 struct dso
*dso_r
= map_r
? map_r
->dso
: NULL
;
104 const char *dso_name_l
, *dso_name_r
;
106 if (!dso_l
|| !dso_r
)
107 return cmp_null(dso_l
, dso_r
);
110 dso_name_l
= dso_l
->long_name
;
111 dso_name_r
= dso_r
->long_name
;
113 dso_name_l
= dso_l
->short_name
;
114 dso_name_r
= dso_r
->short_name
;
117 return strcmp(dso_name_l
, dso_name_r
);
120 struct sort_entry sort_comm
= {
121 .se_header
= "Command",
122 .se_cmp
= sort__comm_cmp
,
123 .se_collapse
= sort__comm_collapse
,
124 .se_snprintf
= hist_entry__comm_snprintf
,
125 .se_width_idx
= HISTC_COMM
,
131 sort__dso_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
133 return _sort__dso_cmp(left
->ms
.map
, right
->ms
.map
);
137 static int64_t _sort__sym_cmp(struct symbol
*sym_l
, struct symbol
*sym_r
,
140 if (!sym_l
|| !sym_r
)
141 return cmp_null(sym_l
, sym_r
);
151 return (int64_t)(ip_r
- ip_l
);
154 static int _hist_entry__dso_snprintf(struct map
*map
, char *bf
,
155 size_t size
, unsigned int width
)
157 if (map
&& map
->dso
) {
158 const char *dso_name
= !verbose
? map
->dso
->short_name
:
160 return repsep_snprintf(bf
, size
, "%-*s", width
, dso_name
);
163 return repsep_snprintf(bf
, size
, "%-*s", width
, "[unknown]");
166 static int hist_entry__dso_snprintf(struct hist_entry
*self
, char *bf
,
167 size_t size
, unsigned int width
)
169 return _hist_entry__dso_snprintf(self
->ms
.map
, bf
, size
, width
);
172 static int _hist_entry__sym_snprintf(struct map
*map
, struct symbol
*sym
,
173 u64 ip
, char level
, char *bf
, size_t size
,
174 unsigned int width __maybe_unused
)
179 char o
= map
? dso__symtab_origin(map
->dso
) : '!';
180 ret
+= repsep_snprintf(bf
, size
, "%-#*llx %c ",
181 BITS_PER_LONG
/ 4, ip
, o
);
184 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "[%c] ", level
);
186 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-*s",
190 size_t len
= BITS_PER_LONG
/ 4;
191 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-#.*llx",
193 ret
+= repsep_snprintf(bf
+ ret
, size
- ret
, "%-*s",
201 struct sort_entry sort_dso
= {
202 .se_header
= "Shared Object",
203 .se_cmp
= sort__dso_cmp
,
204 .se_snprintf
= hist_entry__dso_snprintf
,
205 .se_width_idx
= HISTC_DSO
,
208 static int hist_entry__sym_snprintf(struct hist_entry
*self
, char *bf
,
210 unsigned int width __maybe_unused
)
212 return _hist_entry__sym_snprintf(self
->ms
.map
, self
->ms
.sym
, self
->ip
,
213 self
->level
, bf
, size
, width
);
218 sort__sym_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
222 if (!left
->ms
.sym
&& !right
->ms
.sym
)
223 return right
->level
- left
->level
;
225 if (!left
->ms
.sym
|| !right
->ms
.sym
)
226 return cmp_null(left
->ms
.sym
, right
->ms
.sym
);
228 if (left
->ms
.sym
== right
->ms
.sym
)
231 ip_l
= left
->ms
.sym
->start
;
232 ip_r
= right
->ms
.sym
->start
;
234 return _sort__sym_cmp(left
->ms
.sym
, right
->ms
.sym
, ip_l
, ip_r
);
237 struct sort_entry sort_sym
= {
238 .se_header
= "Symbol",
239 .se_cmp
= sort__sym_cmp
,
240 .se_snprintf
= hist_entry__sym_snprintf
,
241 .se_width_idx
= HISTC_SYMBOL
,
247 sort__srcline_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
249 return (int64_t)(right
->ip
- left
->ip
);
252 static int hist_entry__srcline_snprintf(struct hist_entry
*self
, char *bf
,
254 unsigned int width __maybe_unused
)
257 char cmd
[PATH_MAX
+ 2], *path
= self
->srcline
, *nl
;
266 if (!strncmp(self
->ms
.map
->dso
->long_name
, "/tmp/perf-", 10))
269 snprintf(cmd
, sizeof(cmd
), "addr2line -e %s %016" PRIx64
,
270 self
->ms
.map
->dso
->long_name
, self
->ip
);
271 fp
= popen(cmd
, "r");
275 if (getline(&path
, &line_len
, fp
) < 0 || !line_len
)
278 self
->srcline
= strdup(path
);
279 if (self
->srcline
== NULL
)
282 nl
= strchr(self
->srcline
, '\n');
285 path
= self
->srcline
;
287 return repsep_snprintf(bf
, size
, "%s", path
);
289 return repsep_snprintf(bf
, size
, "%-#*llx", BITS_PER_LONG
/ 4, self
->ip
);
292 struct sort_entry sort_srcline
= {
293 .se_header
= "Source:Line",
294 .se_cmp
= sort__srcline_cmp
,
295 .se_snprintf
= hist_entry__srcline_snprintf
,
296 .se_width_idx
= HISTC_SRCLINE
,
302 sort__parent_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
304 struct symbol
*sym_l
= left
->parent
;
305 struct symbol
*sym_r
= right
->parent
;
307 if (!sym_l
|| !sym_r
)
308 return cmp_null(sym_l
, sym_r
);
310 return strcmp(sym_l
->name
, sym_r
->name
);
313 static int hist_entry__parent_snprintf(struct hist_entry
*self
, char *bf
,
314 size_t size
, unsigned int width
)
316 return repsep_snprintf(bf
, size
, "%-*s", width
,
317 self
->parent
? self
->parent
->name
: "[other]");
320 struct sort_entry sort_parent
= {
321 .se_header
= "Parent symbol",
322 .se_cmp
= sort__parent_cmp
,
323 .se_snprintf
= hist_entry__parent_snprintf
,
324 .se_width_idx
= HISTC_PARENT
,
330 sort__cpu_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
332 return right
->cpu
- left
->cpu
;
335 static int hist_entry__cpu_snprintf(struct hist_entry
*self
, char *bf
,
336 size_t size
, unsigned int width
)
338 return repsep_snprintf(bf
, size
, "%-*d", width
, self
->cpu
);
341 struct sort_entry sort_cpu
= {
343 .se_cmp
= sort__cpu_cmp
,
344 .se_snprintf
= hist_entry__cpu_snprintf
,
345 .se_width_idx
= HISTC_CPU
,
349 sort__dso_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
351 return _sort__dso_cmp(left
->branch_info
->from
.map
,
352 right
->branch_info
->from
.map
);
355 static int hist_entry__dso_from_snprintf(struct hist_entry
*self
, char *bf
,
356 size_t size
, unsigned int width
)
358 return _hist_entry__dso_snprintf(self
->branch_info
->from
.map
,
362 struct sort_entry sort_dso_from
= {
363 .se_header
= "Source Shared Object",
364 .se_cmp
= sort__dso_from_cmp
,
365 .se_snprintf
= hist_entry__dso_from_snprintf
,
366 .se_width_idx
= HISTC_DSO_FROM
,
370 sort__dso_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
372 return _sort__dso_cmp(left
->branch_info
->to
.map
,
373 right
->branch_info
->to
.map
);
376 static int hist_entry__dso_to_snprintf(struct hist_entry
*self
, char *bf
,
377 size_t size
, unsigned int width
)
379 return _hist_entry__dso_snprintf(self
->branch_info
->to
.map
,
384 sort__sym_from_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
386 struct addr_map_symbol
*from_l
= &left
->branch_info
->from
;
387 struct addr_map_symbol
*from_r
= &right
->branch_info
->from
;
389 if (!from_l
->sym
&& !from_r
->sym
)
390 return right
->level
- left
->level
;
392 return _sort__sym_cmp(from_l
->sym
, from_r
->sym
, from_l
->addr
,
397 sort__sym_to_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
399 struct addr_map_symbol
*to_l
= &left
->branch_info
->to
;
400 struct addr_map_symbol
*to_r
= &right
->branch_info
->to
;
402 if (!to_l
->sym
&& !to_r
->sym
)
403 return right
->level
- left
->level
;
405 return _sort__sym_cmp(to_l
->sym
, to_r
->sym
, to_l
->addr
, to_r
->addr
);
408 static int hist_entry__sym_from_snprintf(struct hist_entry
*self
, char *bf
,
410 unsigned int width __maybe_unused
)
412 struct addr_map_symbol
*from
= &self
->branch_info
->from
;
413 return _hist_entry__sym_snprintf(from
->map
, from
->sym
, from
->addr
,
414 self
->level
, bf
, size
, width
);
418 static int hist_entry__sym_to_snprintf(struct hist_entry
*self
, char *bf
,
420 unsigned int width __maybe_unused
)
422 struct addr_map_symbol
*to
= &self
->branch_info
->to
;
423 return _hist_entry__sym_snprintf(to
->map
, to
->sym
, to
->addr
,
424 self
->level
, bf
, size
, width
);
428 struct sort_entry sort_dso_to
= {
429 .se_header
= "Target Shared Object",
430 .se_cmp
= sort__dso_to_cmp
,
431 .se_snprintf
= hist_entry__dso_to_snprintf
,
432 .se_width_idx
= HISTC_DSO_TO
,
435 struct sort_entry sort_sym_from
= {
436 .se_header
= "Source Symbol",
437 .se_cmp
= sort__sym_from_cmp
,
438 .se_snprintf
= hist_entry__sym_from_snprintf
,
439 .se_width_idx
= HISTC_SYMBOL_FROM
,
442 struct sort_entry sort_sym_to
= {
443 .se_header
= "Target Symbol",
444 .se_cmp
= sort__sym_to_cmp
,
445 .se_snprintf
= hist_entry__sym_to_snprintf
,
446 .se_width_idx
= HISTC_SYMBOL_TO
,
450 sort__mispredict_cmp(struct hist_entry
*left
, struct hist_entry
*right
)
452 const unsigned char mp
= left
->branch_info
->flags
.mispred
!=
453 right
->branch_info
->flags
.mispred
;
454 const unsigned char p
= left
->branch_info
->flags
.predicted
!=
455 right
->branch_info
->flags
.predicted
;
460 static int hist_entry__mispredict_snprintf(struct hist_entry
*self
, char *bf
,
461 size_t size
, unsigned int width
){
462 static const char *out
= "N/A";
464 if (self
->branch_info
->flags
.predicted
)
466 else if (self
->branch_info
->flags
.mispred
)
469 return repsep_snprintf(bf
, size
, "%-*s", width
, out
);
472 struct sort_entry sort_mispredict
= {
473 .se_header
= "Branch Mispredicted",
474 .se_cmp
= sort__mispredict_cmp
,
475 .se_snprintf
= hist_entry__mispredict_snprintf
,
476 .se_width_idx
= HISTC_MISPREDICT
,
479 struct sort_dimension
{
481 struct sort_entry
*entry
;
485 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
487 static struct sort_dimension sort_dimensions
[] = {
488 DIM(SORT_PID
, "pid", sort_thread
),
489 DIM(SORT_COMM
, "comm", sort_comm
),
490 DIM(SORT_DSO
, "dso", sort_dso
),
491 DIM(SORT_DSO_FROM
, "dso_from", sort_dso_from
),
492 DIM(SORT_DSO_TO
, "dso_to", sort_dso_to
),
493 DIM(SORT_SYM
, "symbol", sort_sym
),
494 DIM(SORT_SYM_TO
, "symbol_from", sort_sym_from
),
495 DIM(SORT_SYM_FROM
, "symbol_to", sort_sym_to
),
496 DIM(SORT_PARENT
, "parent", sort_parent
),
497 DIM(SORT_CPU
, "cpu", sort_cpu
),
498 DIM(SORT_MISPREDICT
, "mispredict", sort_mispredict
),
499 DIM(SORT_SRCLINE
, "srcline", sort_srcline
),
502 int sort_dimension__add(const char *tok
)
506 for (i
= 0; i
< ARRAY_SIZE(sort_dimensions
); i
++) {
507 struct sort_dimension
*sd
= &sort_dimensions
[i
];
509 if (strncasecmp(tok
, sd
->name
, strlen(tok
)))
511 if (sd
->entry
== &sort_parent
) {
512 int ret
= regcomp(&parent_regex
, parent_pattern
, REG_EXTENDED
);
516 regerror(ret
, &parent_regex
, err
, sizeof(err
));
517 pr_err("Invalid regex: %s\n%s", parent_pattern
, err
);
520 sort__has_parent
= 1;
521 } else if (sd
->entry
== &sort_sym
||
522 sd
->entry
== &sort_sym_from
||
523 sd
->entry
== &sort_sym_to
) {
530 if (sd
->entry
->se_collapse
)
531 sort__need_collapse
= 1;
533 if (list_empty(&hist_entry__sort_list
)) {
534 if (!strcmp(sd
->name
, "pid"))
535 sort__first_dimension
= SORT_PID
;
536 else if (!strcmp(sd
->name
, "comm"))
537 sort__first_dimension
= SORT_COMM
;
538 else if (!strcmp(sd
->name
, "dso"))
539 sort__first_dimension
= SORT_DSO
;
540 else if (!strcmp(sd
->name
, "symbol"))
541 sort__first_dimension
= SORT_SYM
;
542 else if (!strcmp(sd
->name
, "parent"))
543 sort__first_dimension
= SORT_PARENT
;
544 else if (!strcmp(sd
->name
, "cpu"))
545 sort__first_dimension
= SORT_CPU
;
546 else if (!strcmp(sd
->name
, "symbol_from"))
547 sort__first_dimension
= SORT_SYM_FROM
;
548 else if (!strcmp(sd
->name
, "symbol_to"))
549 sort__first_dimension
= SORT_SYM_TO
;
550 else if (!strcmp(sd
->name
, "dso_from"))
551 sort__first_dimension
= SORT_DSO_FROM
;
552 else if (!strcmp(sd
->name
, "dso_to"))
553 sort__first_dimension
= SORT_DSO_TO
;
554 else if (!strcmp(sd
->name
, "mispredict"))
555 sort__first_dimension
= SORT_MISPREDICT
;
558 list_add_tail(&sd
->entry
->list
, &hist_entry__sort_list
);
566 void setup_sorting(const char * const usagestr
[], const struct option
*opts
)
568 char *tmp
, *tok
, *str
= strdup(sort_order
);
570 for (tok
= strtok_r(str
, ", ", &tmp
);
571 tok
; tok
= strtok_r(NULL
, ", ", &tmp
)) {
572 if (sort_dimension__add(tok
) < 0) {
573 error("Unknown --sort key: `%s'", tok
);
574 usage_with_options(usagestr
, opts
);
581 void sort_entry__setup_elide(struct sort_entry
*self
, struct strlist
*list
,
582 const char *list_name
, FILE *fp
)
584 if (list
&& strlist__nr_entries(list
) == 1) {
586 fprintf(fp
, "# %s: %s\n", list_name
,
587 strlist__entry(list
, 0)->s
);