projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf hists: Introduce perf_hpp_list__for_each_format macro
[deliverable/linux.git] / tools / perf / util / sort.c
1 #include <sys/mman.h>
2 #include "sort.h"
3 #include "hist.h"
4 #include "comm.h"
5 #include "symbol.h"
6 #include "evsel.h"
7 #include "evlist.h"
8 #include <traceevent/event-parse.h>
9
10 regex_t parent_regex;
11 const char default_parent_pattern[] = "^sys_|^do_page_fault";
12 const char *parent_pattern = default_parent_pattern;
13 const char default_sort_order[] = "comm,dso,symbol";
14 const char default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
15 const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
16 const char default_top_sort_order[] = "dso,symbol";
17 const char default_diff_sort_order[] = "dso,symbol";
18 const char default_tracepoint_sort_order[] = "trace";
19 const char *sort_order;
20 const char *field_order;
21 regex_t ignore_callees_regex;
22 int have_ignore_callees = 0;
23 int sort__need_collapse = 0;
24 int sort__has_parent = 0;
25 int sort__has_sym = 0;
26 int sort__has_dso = 0;
27 int sort__has_socket = 0;
28 int sort__has_thread = 0;
29 enum sort_mode sort__mode = SORT_MODE__NORMAL;
30
31
32 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
33 {
34 int n;
35 va_list ap;
36
37 va_start(ap, fmt);
38 n = vsnprintf(bf, size, fmt, ap);
39 if (symbol_conf.field_sep && n > 0) {
40 char *sep = bf;
41
42 while (1) {
43 sep = strchr(sep, *symbol_conf.field_sep);
44 if (sep == NULL)
45 break;
46 *sep = '.';
47 }
48 }
49 va_end(ap);
50
51 if (n >= (int)size)
52 return size - 1;
53 return n;
54 }
55
56 static int64_t cmp_null(const void *l, const void *r)
57 {
58 if (!l && !r)
59 return 0;
60 else if (!l)
61 return -1;
62 else
63 return 1;
64 }
65
66 /* --sort pid */
67
68 static int64_t
69 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
70 {
71 return right->thread->tid - left->thread->tid;
72 }
73
74 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
75 size_t size, unsigned int width)
76 {
77 const char *comm = thread__comm_str(he->thread);
78
79 width = max(7U, width) - 6;
80 return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
81 width, width, comm ?: "");
82 }
83
84 struct sort_entry sort_thread = {
85 .se_header = " Pid:Command",
86 .se_cmp = sort__thread_cmp,
87 .se_snprintf = hist_entry__thread_snprintf,
88 .se_width_idx = HISTC_THREAD,
89 };
90
91 /* --sort comm */
92
93 static int64_t
94 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
95 {
96 /* Compare the addr that should be unique among comm */
97 return strcmp(comm__str(right->comm), comm__str(left->comm));
98 }
99
100 static int64_t
101 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
102 {
103 /* Compare the addr that should be unique among comm */
104 return strcmp(comm__str(right->comm), comm__str(left->comm));
105 }
106
107 static int64_t
108 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
109 {
110 return strcmp(comm__str(right->comm), comm__str(left->comm));
111 }
112
113 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
114 size_t size, unsigned int width)
115 {
116 return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
117 }
118
119 struct sort_entry sort_comm = {
120 .se_header = "Command",
121 .se_cmp = sort__comm_cmp,
122 .se_collapse = sort__comm_collapse,
123 .se_sort = sort__comm_sort,
124 .se_snprintf = hist_entry__comm_snprintf,
125 .se_width_idx = HISTC_COMM,
126 };
127
128 /* --sort dso */
129
130 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
131 {
132 struct dso *dso_l = map_l ? map_l->dso : NULL;
133 struct dso *dso_r = map_r ? map_r->dso : NULL;
134 const char *dso_name_l, *dso_name_r;
135
136 if (!dso_l || !dso_r)
137 return cmp_null(dso_r, dso_l);
138
139 if (verbose) {
140 dso_name_l = dso_l->long_name;
141 dso_name_r = dso_r->long_name;
142 } else {
143 dso_name_l = dso_l->short_name;
144 dso_name_r = dso_r->short_name;
145 }
146
147 return strcmp(dso_name_l, dso_name_r);
148 }
149
150 static int64_t
151 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
152 {
153 return _sort__dso_cmp(right->ms.map, left->ms.map);
154 }
155
156 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
157 size_t size, unsigned int width)
158 {
159 if (map && map->dso) {
160 const char *dso_name = !verbose ? map->dso->short_name :
161 map->dso->long_name;
162 return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
163 }
164
165 return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
166 }
167
168 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
169 size_t size, unsigned int width)
170 {
171 return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
172 }
173
174 struct sort_entry sort_dso = {
175 .se_header = "Shared Object",
176 .se_cmp = sort__dso_cmp,
177 .se_snprintf = hist_entry__dso_snprintf,
178 .se_width_idx = HISTC_DSO,
179 };
180
181 /* --sort symbol */
182
183 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
184 {
185 return (int64_t)(right_ip - left_ip);
186 }
187
188 static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
189 {
190 if (!sym_l || !sym_r)
191 return cmp_null(sym_l, sym_r);
192
193 if (sym_l == sym_r)
194 return 0;
195
196 if (sym_l->start != sym_r->start)
197 return (int64_t)(sym_r->start - sym_l->start);
198
199 return (int64_t)(sym_r->end - sym_l->end);
200 }
201
202 static int64_t
203 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
204 {
205 int64_t ret;
206
207 if (!left->ms.sym && !right->ms.sym)
208 return _sort__addr_cmp(left->ip, right->ip);
209
210 /*
211 * comparing symbol address alone is not enough since it's a
212 * relative address within a dso.
213 */
214 if (!sort__has_dso) {
215 ret = sort__dso_cmp(left, right);
216 if (ret != 0)
217 return ret;
218 }
219
220 return _sort__sym_cmp(left->ms.sym, right->ms.sym);
221 }
222
223 static int64_t
224 sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
225 {
226 if (!left->ms.sym || !right->ms.sym)
227 return cmp_null(left->ms.sym, right->ms.sym);
228
229 return strcmp(right->ms.sym->name, left->ms.sym->name);
230 }
231
232 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
233 u64 ip, char level, char *bf, size_t size,
234 unsigned int width)
235 {
236 size_t ret = 0;
237
238 if (verbose) {
239 char o = map ? dso__symtab_origin(map->dso) : '!';
240 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
241 BITS_PER_LONG / 4 + 2, ip, o);
242 }
243
244 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
245 if (sym && map) {
246 if (map->type == MAP__VARIABLE) {
247 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
248 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
249 ip - map->unmap_ip(map, sym->start));
250 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
251 width - ret, "");
252 } else {
253 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
254 width - ret,
255 sym->name);
256 }
257 } else {
258 size_t len = BITS_PER_LONG / 4;
259 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
260 len, ip);
261 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
262 width - ret, "");
263 }
264
265 if (ret > width)
266 bf[width] = '\0';
267
268 return width;
269 }
270
271 static int hist_entry__sym_snprintf(struct hist_entry *he, char *bf,
272 size_t size, unsigned int width)
273 {
274 return _hist_entry__sym_snprintf(he->ms.map, he->ms.sym, he->ip,
275 he->level, bf, size, width);
276 }
277
278 struct sort_entry sort_sym = {
279 .se_header = "Symbol",
280 .se_cmp = sort__sym_cmp,
281 .se_sort = sort__sym_sort,
282 .se_snprintf = hist_entry__sym_snprintf,
283 .se_width_idx = HISTC_SYMBOL,
284 };
285
286 /* --sort srcline */
287
288 static int64_t
289 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
290 {
291 if (!left->srcline) {
292 if (!left->ms.map)
293 left->srcline = SRCLINE_UNKNOWN;
294 else {
295 struct map *map = left->ms.map;
296 left->srcline = get_srcline(map->dso,
297 map__rip_2objdump(map, left->ip),
298 left->ms.sym, true);
299 }
300 }
301 if (!right->srcline) {
302 if (!right->ms.map)
303 right->srcline = SRCLINE_UNKNOWN;
304 else {
305 struct map *map = right->ms.map;
306 right->srcline = get_srcline(map->dso,
307 map__rip_2objdump(map, right->ip),
308 right->ms.sym, true);
309 }
310 }
311 return strcmp(right->srcline, left->srcline);
312 }
313
314 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
315 size_t size, unsigned int width)
316 {
317 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->srcline);
318 }
319
320 struct sort_entry sort_srcline = {
321 .se_header = "Source:Line",
322 .se_cmp = sort__srcline_cmp,
323 .se_snprintf = hist_entry__srcline_snprintf,
324 .se_width_idx = HISTC_SRCLINE,
325 };
326
327 /* --sort srcfile */
328
329 static char no_srcfile[1];
330
331 static char *get_srcfile(struct hist_entry *e)
332 {
333 char *sf, *p;
334 struct map *map = e->ms.map;
335
336 sf = __get_srcline(map->dso, map__rip_2objdump(map, e->ip),
337 e->ms.sym, false, true);
338 if (!strcmp(sf, SRCLINE_UNKNOWN))
339 return no_srcfile;
340 p = strchr(sf, ':');
341 if (p && *sf) {
342 *p = 0;
343 return sf;
344 }
345 free(sf);
346 return no_srcfile;
347 }
348
349 static int64_t
350 sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
351 {
352 if (!left->srcfile) {
353 if (!left->ms.map)
354 left->srcfile = no_srcfile;
355 else
356 left->srcfile = get_srcfile(left);
357 }
358 if (!right->srcfile) {
359 if (!right->ms.map)
360 right->srcfile = no_srcfile;
361 else
362 right->srcfile = get_srcfile(right);
363 }
364 return strcmp(right->srcfile, left->srcfile);
365 }
366
367 static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
368 size_t size, unsigned int width)
369 {
370 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->srcfile);
371 }
372
373 struct sort_entry sort_srcfile = {
374 .se_header = "Source File",
375 .se_cmp = sort__srcfile_cmp,
376 .se_snprintf = hist_entry__srcfile_snprintf,
377 .se_width_idx = HISTC_SRCFILE,
378 };
379
380 /* --sort parent */
381
382 static int64_t
383 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
384 {
385 struct symbol *sym_l = left->parent;
386 struct symbol *sym_r = right->parent;
387
388 if (!sym_l || !sym_r)
389 return cmp_null(sym_l, sym_r);
390
391 return strcmp(sym_r->name, sym_l->name);
392 }
393
394 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
395 size_t size, unsigned int width)
396 {
397 return repsep_snprintf(bf, size, "%-*.*s", width, width,
398 he->parent ? he->parent->name : "[other]");
399 }
400
401 struct sort_entry sort_parent = {
402 .se_header = "Parent symbol",
403 .se_cmp = sort__parent_cmp,
404 .se_snprintf = hist_entry__parent_snprintf,
405 .se_width_idx = HISTC_PARENT,
406 };
407
408 /* --sort cpu */
409
410 static int64_t
411 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
412 {
413 return right->cpu - left->cpu;
414 }
415
416 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
417 size_t size, unsigned int width)
418 {
419 return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
420 }
421
422 struct sort_entry sort_cpu = {
423 .se_header = "CPU",
424 .se_cmp = sort__cpu_cmp,
425 .se_snprintf = hist_entry__cpu_snprintf,
426 .se_width_idx = HISTC_CPU,
427 };
428
429 /* --sort socket */
430
431 static int64_t
432 sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
433 {
434 return right->socket - left->socket;
435 }
436
437 static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf,
438 size_t size, unsigned int width)
439 {
440 return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket);
441 }
442
443 struct sort_entry sort_socket = {
444 .se_header = "Socket",
445 .se_cmp = sort__socket_cmp,
446 .se_snprintf = hist_entry__socket_snprintf,
447 .se_width_idx = HISTC_SOCKET,
448 };
449
450 /* --sort trace */
451
452 static char *get_trace_output(struct hist_entry *he)
453 {
454 struct trace_seq seq;
455 struct perf_evsel *evsel;
456 struct pevent_record rec = {
457 .data = he->raw_data,
458 .size = he->raw_size,
459 };
460
461 evsel = hists_to_evsel(he->hists);
462
463 trace_seq_init(&seq);
464 if (symbol_conf.raw_trace) {
465 pevent_print_fields(&seq, he->raw_data, he->raw_size,
466 evsel->tp_format);
467 } else {
468 pevent_event_info(&seq, evsel->tp_format, &rec);
469 }
470 return seq.buffer;
471 }
472
473 static int64_t
474 sort__trace_cmp(struct hist_entry *left, struct hist_entry *right)
475 {
476 struct perf_evsel *evsel;
477
478 evsel = hists_to_evsel(left->hists);
479 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
480 return 0;
481
482 if (left->trace_output == NULL)
483 left->trace_output = get_trace_output(left);
484 if (right->trace_output == NULL)
485 right->trace_output = get_trace_output(right);
486
487 hists__new_col_len(left->hists, HISTC_TRACE, strlen(left->trace_output));
488 hists__new_col_len(right->hists, HISTC_TRACE, strlen(right->trace_output));
489
490 return strcmp(right->trace_output, left->trace_output);
491 }
492
493 static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf,
494 size_t size, unsigned int width)
495 {
496 struct perf_evsel *evsel;
497
498 evsel = hists_to_evsel(he->hists);
499 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
500 return scnprintf(bf, size, "%-*.*s", width, width, "N/A");
501
502 if (he->trace_output == NULL)
503 he->trace_output = get_trace_output(he);
504 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->trace_output);
505 }
506
507 struct sort_entry sort_trace = {
508 .se_header = "Trace output",
509 .se_cmp = sort__trace_cmp,
510 .se_snprintf = hist_entry__trace_snprintf,
511 .se_width_idx = HISTC_TRACE,
512 };
513
514 /* sort keys for branch stacks */
515
516 static int64_t
517 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
518 {
519 if (!left->branch_info || !right->branch_info)
520 return cmp_null(left->branch_info, right->branch_info);
521
522 return _sort__dso_cmp(left->branch_info->from.map,
523 right->branch_info->from.map);
524 }
525
526 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
527 size_t size, unsigned int width)
528 {
529 if (he->branch_info)
530 return _hist_entry__dso_snprintf(he->branch_info->from.map,
531 bf, size, width);
532 else
533 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
534 }
535
536 static int64_t
537 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
538 {
539 if (!left->branch_info || !right->branch_info)
540 return cmp_null(left->branch_info, right->branch_info);
541
542 return _sort__dso_cmp(left->branch_info->to.map,
543 right->branch_info->to.map);
544 }
545
546 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
547 size_t size, unsigned int width)
548 {
549 if (he->branch_info)
550 return _hist_entry__dso_snprintf(he->branch_info->to.map,
551 bf, size, width);
552 else
553 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
554 }
555
556 static int64_t
557 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
558 {
559 struct addr_map_symbol *from_l = &left->branch_info->from;
560 struct addr_map_symbol *from_r = &right->branch_info->from;
561
562 if (!left->branch_info || !right->branch_info)
563 return cmp_null(left->branch_info, right->branch_info);
564
565 from_l = &left->branch_info->from;
566 from_r = &right->branch_info->from;
567
568 if (!from_l->sym && !from_r->sym)
569 return _sort__addr_cmp(from_l->addr, from_r->addr);
570
571 return _sort__sym_cmp(from_l->sym, from_r->sym);
572 }
573
574 static int64_t
575 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
576 {
577 struct addr_map_symbol *to_l, *to_r;
578
579 if (!left->branch_info || !right->branch_info)
580 return cmp_null(left->branch_info, right->branch_info);
581
582 to_l = &left->branch_info->to;
583 to_r = &right->branch_info->to;
584
585 if (!to_l->sym && !to_r->sym)
586 return _sort__addr_cmp(to_l->addr, to_r->addr);
587
588 return _sort__sym_cmp(to_l->sym, to_r->sym);
589 }
590
591 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
592 size_t size, unsigned int width)
593 {
594 if (he->branch_info) {
595 struct addr_map_symbol *from = &he->branch_info->from;
596
597 return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
598 he->level, bf, size, width);
599 }
600
601 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
602 }
603
604 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
605 size_t size, unsigned int width)
606 {
607 if (he->branch_info) {
608 struct addr_map_symbol *to = &he->branch_info->to;
609
610 return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
611 he->level, bf, size, width);
612 }
613
614 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
615 }
616
617 struct sort_entry sort_dso_from = {
618 .se_header = "Source Shared Object",
619 .se_cmp = sort__dso_from_cmp,
620 .se_snprintf = hist_entry__dso_from_snprintf,
621 .se_width_idx = HISTC_DSO_FROM,
622 };
623
624 struct sort_entry sort_dso_to = {
625 .se_header = "Target Shared Object",
626 .se_cmp = sort__dso_to_cmp,
627 .se_snprintf = hist_entry__dso_to_snprintf,
628 .se_width_idx = HISTC_DSO_TO,
629 };
630
631 struct sort_entry sort_sym_from = {
632 .se_header = "Source Symbol",
633 .se_cmp = sort__sym_from_cmp,
634 .se_snprintf = hist_entry__sym_from_snprintf,
635 .se_width_idx = HISTC_SYMBOL_FROM,
636 };
637
638 struct sort_entry sort_sym_to = {
639 .se_header = "Target Symbol",
640 .se_cmp = sort__sym_to_cmp,
641 .se_snprintf = hist_entry__sym_to_snprintf,
642 .se_width_idx = HISTC_SYMBOL_TO,
643 };
644
645 static int64_t
646 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
647 {
648 unsigned char mp, p;
649
650 if (!left->branch_info || !right->branch_info)
651 return cmp_null(left->branch_info, right->branch_info);
652
653 mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
654 p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
655 return mp || p;
656 }
657
658 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
659 size_t size, unsigned int width){
660 static const char *out = "N/A";
661
662 if (he->branch_info) {
663 if (he->branch_info->flags.predicted)
664 out = "N";
665 else if (he->branch_info->flags.mispred)
666 out = "Y";
667 }
668
669 return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
670 }
671
672 static int64_t
673 sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
674 {
675 return left->branch_info->flags.cycles -
676 right->branch_info->flags.cycles;
677 }
678
679 static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
680 size_t size, unsigned int width)
681 {
682 if (he->branch_info->flags.cycles == 0)
683 return repsep_snprintf(bf, size, "%-*s", width, "-");
684 return repsep_snprintf(bf, size, "%-*hd", width,
685 he->branch_info->flags.cycles);
686 }
687
688 struct sort_entry sort_cycles = {
689 .se_header = "Basic Block Cycles",
690 .se_cmp = sort__cycles_cmp,
691 .se_snprintf = hist_entry__cycles_snprintf,
692 .se_width_idx = HISTC_CYCLES,
693 };
694
695 /* --sort daddr_sym */
696 static int64_t
697 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
698 {
699 uint64_t l = 0, r = 0;
700
701 if (left->mem_info)
702 l = left->mem_info->daddr.addr;
703 if (right->mem_info)
704 r = right->mem_info->daddr.addr;
705
706 return (int64_t)(r - l);
707 }
708
709 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
710 size_t size, unsigned int width)
711 {
712 uint64_t addr = 0;
713 struct map *map = NULL;
714 struct symbol *sym = NULL;
715
716 if (he->mem_info) {
717 addr = he->mem_info->daddr.addr;
718 map = he->mem_info->daddr.map;
719 sym = he->mem_info->daddr.sym;
720 }
721 return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
722 width);
723 }
724
725 static int64_t
726 sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
727 {
728 uint64_t l = 0, r = 0;
729
730 if (left->mem_info)
731 l = left->mem_info->iaddr.addr;
732 if (right->mem_info)
733 r = right->mem_info->iaddr.addr;
734
735 return (int64_t)(r - l);
736 }
737
738 static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
739 size_t size, unsigned int width)
740 {
741 uint64_t addr = 0;
742 struct map *map = NULL;
743 struct symbol *sym = NULL;
744
745 if (he->mem_info) {
746 addr = he->mem_info->iaddr.addr;
747 map = he->mem_info->iaddr.map;
748 sym = he->mem_info->iaddr.sym;
749 }
750 return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
751 width);
752 }
753
754 static int64_t
755 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
756 {
757 struct map *map_l = NULL;
758 struct map *map_r = NULL;
759
760 if (left->mem_info)
761 map_l = left->mem_info->daddr.map;
762 if (right->mem_info)
763 map_r = right->mem_info->daddr.map;
764
765 return _sort__dso_cmp(map_l, map_r);
766 }
767
768 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
769 size_t size, unsigned int width)
770 {
771 struct map *map = NULL;
772
773 if (he->mem_info)
774 map = he->mem_info->daddr.map;
775
776 return _hist_entry__dso_snprintf(map, bf, size, width);
777 }
778
779 static int64_t
780 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
781 {
782 union perf_mem_data_src data_src_l;
783 union perf_mem_data_src data_src_r;
784
785 if (left->mem_info)
786 data_src_l = left->mem_info->data_src;
787 else
788 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
789
790 if (right->mem_info)
791 data_src_r = right->mem_info->data_src;
792 else
793 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
794
795 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
796 }
797
798 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
799 size_t size, unsigned int width)
800 {
801 const char *out;
802 u64 mask = PERF_MEM_LOCK_NA;
803
804 if (he->mem_info)
805 mask = he->mem_info->data_src.mem_lock;
806
807 if (mask & PERF_MEM_LOCK_NA)
808 out = "N/A";
809 else if (mask & PERF_MEM_LOCK_LOCKED)
810 out = "Yes";
811 else
812 out = "No";
813
814 return repsep_snprintf(bf, size, "%-*s", width, out);
815 }
816
817 static int64_t
818 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
819 {
820 union perf_mem_data_src data_src_l;
821 union perf_mem_data_src data_src_r;
822
823 if (left->mem_info)
824 data_src_l = left->mem_info->data_src;
825 else
826 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
827
828 if (right->mem_info)
829 data_src_r = right->mem_info->data_src;
830 else
831 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
832
833 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
834 }
835
836 static const char * const tlb_access[] = {
837 "N/A",
838 "HIT",
839 "MISS",
840 "L1",
841 "L2",
842 "Walker",
843 "Fault",
844 };
845 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
846
847 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
848 size_t size, unsigned int width)
849 {
850 char out[64];
851 size_t sz = sizeof(out) - 1; /* -1 for null termination */
852 size_t l = 0, i;
853 u64 m = PERF_MEM_TLB_NA;
854 u64 hit, miss;
855
856 out[0] = '\0';
857
858 if (he->mem_info)
859 m = he->mem_info->data_src.mem_dtlb;
860
861 hit = m & PERF_MEM_TLB_HIT;
862 miss = m & PERF_MEM_TLB_MISS;
863
864 /* already taken care of */
865 m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
866
867 for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
868 if (!(m & 0x1))
869 continue;
870 if (l) {
871 strcat(out, " or ");
872 l += 4;
873 }
874 strncat(out, tlb_access[i], sz - l);
875 l += strlen(tlb_access[i]);
876 }
877 if (*out == '\0')
878 strcpy(out, "N/A");
879 if (hit)
880 strncat(out, " hit", sz - l);
881 if (miss)
882 strncat(out, " miss", sz - l);
883
884 return repsep_snprintf(bf, size, "%-*s", width, out);
885 }
886
887 static int64_t
888 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
889 {
890 union perf_mem_data_src data_src_l;
891 union perf_mem_data_src data_src_r;
892
893 if (left->mem_info)
894 data_src_l = left->mem_info->data_src;
895 else
896 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
897
898 if (right->mem_info)
899 data_src_r = right->mem_info->data_src;
900 else
901 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
902
903 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
904 }
905
906 static const char * const mem_lvl[] = {
907 "N/A",
908 "HIT",
909 "MISS",
910 "L1",
911 "LFB",
912 "L2",
913 "L3",
914 "Local RAM",
915 "Remote RAM (1 hop)",
916 "Remote RAM (2 hops)",
917 "Remote Cache (1 hop)",
918 "Remote Cache (2 hops)",
919 "I/O",
920 "Uncached",
921 };
922 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
923
924 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
925 size_t size, unsigned int width)
926 {
927 char out[64];
928 size_t sz = sizeof(out) - 1; /* -1 for null termination */
929 size_t i, l = 0;
930 u64 m = PERF_MEM_LVL_NA;
931 u64 hit, miss;
932
933 if (he->mem_info)
934 m = he->mem_info->data_src.mem_lvl;
935
936 out[0] = '\0';
937
938 hit = m & PERF_MEM_LVL_HIT;
939 miss = m & PERF_MEM_LVL_MISS;
940
941 /* already taken care of */
942 m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
943
944 for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
945 if (!(m & 0x1))
946 continue;
947 if (l) {
948 strcat(out, " or ");
949 l += 4;
950 }
951 strncat(out, mem_lvl[i], sz - l);
952 l += strlen(mem_lvl[i]);
953 }
954 if (*out == '\0')
955 strcpy(out, "N/A");
956 if (hit)
957 strncat(out, " hit", sz - l);
958 if (miss)
959 strncat(out, " miss", sz - l);
960
961 return repsep_snprintf(bf, size, "%-*s", width, out);
962 }
963
964 static int64_t
965 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
966 {
967 union perf_mem_data_src data_src_l;
968 union perf_mem_data_src data_src_r;
969
970 if (left->mem_info)
971 data_src_l = left->mem_info->data_src;
972 else
973 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
974
975 if (right->mem_info)
976 data_src_r = right->mem_info->data_src;
977 else
978 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
979
980 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
981 }
982
983 static const char * const snoop_access[] = {
984 "N/A",
985 "None",
986 "Miss",
987 "Hit",
988 "HitM",
989 };
990 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
991
992 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
993 size_t size, unsigned int width)
994 {
995 char out[64];
996 size_t sz = sizeof(out) - 1; /* -1 for null termination */
997 size_t i, l = 0;
998 u64 m = PERF_MEM_SNOOP_NA;
999
1000 out[0] = '\0';
1001
1002 if (he->mem_info)
1003 m = he->mem_info->data_src.mem_snoop;
1004
1005 for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
1006 if (!(m & 0x1))
1007 continue;
1008 if (l) {
1009 strcat(out, " or ");
1010 l += 4;
1011 }
1012 strncat(out, snoop_access[i], sz - l);
1013 l += strlen(snoop_access[i]);
1014 }
1015
1016 if (*out == '\0')
1017 strcpy(out, "N/A");
1018
1019 return repsep_snprintf(bf, size, "%-*s", width, out);
1020 }
1021
1022 static inline u64 cl_address(u64 address)
1023 {
1024 /* return the cacheline of the address */
1025 return (address & ~(cacheline_size - 1));
1026 }
1027
1028 static int64_t
1029 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
1030 {
1031 u64 l, r;
1032 struct map *l_map, *r_map;
1033
1034 if (!left->mem_info) return -1;
1035 if (!right->mem_info) return 1;
1036
1037 /* group event types together */
1038 if (left->cpumode > right->cpumode) return -1;
1039 if (left->cpumode < right->cpumode) return 1;
1040
1041 l_map = left->mem_info->daddr.map;
1042 r_map = right->mem_info->daddr.map;
1043
1044 /* if both are NULL, jump to sort on al_addr instead */
1045 if (!l_map && !r_map)
1046 goto addr;
1047
1048 if (!l_map) return -1;
1049 if (!r_map) return 1;
1050
1051 if (l_map->maj > r_map->maj) return -1;
1052 if (l_map->maj < r_map->maj) return 1;
1053
1054 if (l_map->min > r_map->min) return -1;
1055 if (l_map->min < r_map->min) return 1;
1056
1057 if (l_map->ino > r_map->ino) return -1;
1058 if (l_map->ino < r_map->ino) return 1;
1059
1060 if (l_map->ino_generation > r_map->ino_generation) return -1;
1061 if (l_map->ino_generation < r_map->ino_generation) return 1;
1062
1063 /*
1064 * Addresses with no major/minor numbers are assumed to be
1065 * anonymous in userspace. Sort those on pid then address.
1066 *
1067 * The kernel and non-zero major/minor mapped areas are
1068 * assumed to be unity mapped. Sort those on address.
1069 */
1070
1071 if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
1072 (!(l_map->flags & MAP_SHARED)) &&
1073 !l_map->maj && !l_map->min && !l_map->ino &&
1074 !l_map->ino_generation) {
1075 /* userspace anonymous */
1076
1077 if (left->thread->pid_ > right->thread->pid_) return -1;
1078 if (left->thread->pid_ < right->thread->pid_) return 1;
1079 }
1080
1081 addr:
1082 /* al_addr does all the right addr - start + offset calculations */
1083 l = cl_address(left->mem_info->daddr.al_addr);
1084 r = cl_address(right->mem_info->daddr.al_addr);
1085
1086 if (l > r) return -1;
1087 if (l < r) return 1;
1088
1089 return 0;
1090 }
1091
1092 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
1093 size_t size, unsigned int width)
1094 {
1095
1096 uint64_t addr = 0;
1097 struct map *map = NULL;
1098 struct symbol *sym = NULL;
1099 char level = he->level;
1100
1101 if (he->mem_info) {
1102 addr = cl_address(he->mem_info->daddr.al_addr);
1103 map = he->mem_info->daddr.map;
1104 sym = he->mem_info->daddr.sym;
1105
1106 /* print [s] for shared data mmaps */
1107 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
1108 map && (map->type == MAP__VARIABLE) &&
1109 (map->flags & MAP_SHARED) &&
1110 (map->maj || map->min || map->ino ||
1111 map->ino_generation))
1112 level = 's';
1113 else if (!map)
1114 level = 'X';
1115 }
1116 return _hist_entry__sym_snprintf(map, sym, addr, level, bf, size,
1117 width);
1118 }
1119
1120 struct sort_entry sort_mispredict = {
1121 .se_header = "Branch Mispredicted",
1122 .se_cmp = sort__mispredict_cmp,
1123 .se_snprintf = hist_entry__mispredict_snprintf,
1124 .se_width_idx = HISTC_MISPREDICT,
1125 };
1126
1127 static u64 he_weight(struct hist_entry *he)
1128 {
1129 return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
1130 }
1131
1132 static int64_t
1133 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1134 {
1135 return he_weight(left) - he_weight(right);
1136 }
1137
1138 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
1139 size_t size, unsigned int width)
1140 {
1141 return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
1142 }
1143
1144 struct sort_entry sort_local_weight = {
1145 .se_header = "Local Weight",
1146 .se_cmp = sort__local_weight_cmp,
1147 .se_snprintf = hist_entry__local_weight_snprintf,
1148 .se_width_idx = HISTC_LOCAL_WEIGHT,
1149 };
1150
1151 static int64_t
1152 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
1153 {
1154 return left->stat.weight - right->stat.weight;
1155 }
1156
1157 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
1158 size_t size, unsigned int width)
1159 {
1160 return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
1161 }
1162
1163 struct sort_entry sort_global_weight = {
1164 .se_header = "Weight",
1165 .se_cmp = sort__global_weight_cmp,
1166 .se_snprintf = hist_entry__global_weight_snprintf,
1167 .se_width_idx = HISTC_GLOBAL_WEIGHT,
1168 };
1169
1170 struct sort_entry sort_mem_daddr_sym = {
1171 .se_header = "Data Symbol",
1172 .se_cmp = sort__daddr_cmp,
1173 .se_snprintf = hist_entry__daddr_snprintf,
1174 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1175 };
1176
1177 struct sort_entry sort_mem_iaddr_sym = {
1178 .se_header = "Code Symbol",
1179 .se_cmp = sort__iaddr_cmp,
1180 .se_snprintf = hist_entry__iaddr_snprintf,
1181 .se_width_idx = HISTC_MEM_IADDR_SYMBOL,
1182 };
1183
1184 struct sort_entry sort_mem_daddr_dso = {
1185 .se_header = "Data Object",
1186 .se_cmp = sort__dso_daddr_cmp,
1187 .se_snprintf = hist_entry__dso_daddr_snprintf,
1188 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1189 };
1190
1191 struct sort_entry sort_mem_locked = {
1192 .se_header = "Locked",
1193 .se_cmp = sort__locked_cmp,
1194 .se_snprintf = hist_entry__locked_snprintf,
1195 .se_width_idx = HISTC_MEM_LOCKED,
1196 };
1197
1198 struct sort_entry sort_mem_tlb = {
1199 .se_header = "TLB access",
1200 .se_cmp = sort__tlb_cmp,
1201 .se_snprintf = hist_entry__tlb_snprintf,
1202 .se_width_idx = HISTC_MEM_TLB,
1203 };
1204
1205 struct sort_entry sort_mem_lvl = {
1206 .se_header = "Memory access",
1207 .se_cmp = sort__lvl_cmp,
1208 .se_snprintf = hist_entry__lvl_snprintf,
1209 .se_width_idx = HISTC_MEM_LVL,
1210 };
1211
1212 struct sort_entry sort_mem_snoop = {
1213 .se_header = "Snoop",
1214 .se_cmp = sort__snoop_cmp,
1215 .se_snprintf = hist_entry__snoop_snprintf,
1216 .se_width_idx = HISTC_MEM_SNOOP,
1217 };
1218
1219 struct sort_entry sort_mem_dcacheline = {
1220 .se_header = "Data Cacheline",
1221 .se_cmp = sort__dcacheline_cmp,
1222 .se_snprintf = hist_entry__dcacheline_snprintf,
1223 .se_width_idx = HISTC_MEM_DCACHELINE,
1224 };
1225
1226 static int64_t
1227 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1228 {
1229 if (!left->branch_info || !right->branch_info)
1230 return cmp_null(left->branch_info, right->branch_info);
1231
1232 return left->branch_info->flags.abort !=
1233 right->branch_info->flags.abort;
1234 }
1235
1236 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1237 size_t size, unsigned int width)
1238 {
1239 static const char *out = "N/A";
1240
1241 if (he->branch_info) {
1242 if (he->branch_info->flags.abort)
1243 out = "A";
1244 else
1245 out = ".";
1246 }
1247
1248 return repsep_snprintf(bf, size, "%-*s", width, out);
1249 }
1250
1251 struct sort_entry sort_abort = {
1252 .se_header = "Transaction abort",
1253 .se_cmp = sort__abort_cmp,
1254 .se_snprintf = hist_entry__abort_snprintf,
1255 .se_width_idx = HISTC_ABORT,
1256 };
1257
1258 static int64_t
1259 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1260 {
1261 if (!left->branch_info || !right->branch_info)
1262 return cmp_null(left->branch_info, right->branch_info);
1263
1264 return left->branch_info->flags.in_tx !=
1265 right->branch_info->flags.in_tx;
1266 }
1267
1268 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1269 size_t size, unsigned int width)
1270 {
1271 static const char *out = "N/A";
1272
1273 if (he->branch_info) {
1274 if (he->branch_info->flags.in_tx)
1275 out = "T";
1276 else
1277 out = ".";
1278 }
1279
1280 return repsep_snprintf(bf, size, "%-*s", width, out);
1281 }
1282
1283 struct sort_entry sort_in_tx = {
1284 .se_header = "Branch in transaction",
1285 .se_cmp = sort__in_tx_cmp,
1286 .se_snprintf = hist_entry__in_tx_snprintf,
1287 .se_width_idx = HISTC_IN_TX,
1288 };
1289
1290 static int64_t
1291 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1292 {
1293 return left->transaction - right->transaction;
1294 }
1295
1296 static inline char *add_str(char *p, const char *str)
1297 {
1298 strcpy(p, str);
1299 return p + strlen(str);
1300 }
1301
1302 static struct txbit {
1303 unsigned flag;
1304 const char *name;
1305 int skip_for_len;
1306 } txbits[] = {
1307 { PERF_TXN_ELISION, "EL ", 0 },
1308 { PERF_TXN_TRANSACTION, "TX ", 1 },
1309 { PERF_TXN_SYNC, "SYNC ", 1 },
1310 { PERF_TXN_ASYNC, "ASYNC ", 0 },
1311 { PERF_TXN_RETRY, "RETRY ", 0 },
1312 { PERF_TXN_CONFLICT, "CON ", 0 },
1313 { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1314 { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
1315 { 0, NULL, 0 }
1316 };
1317
1318 int hist_entry__transaction_len(void)
1319 {
1320 int i;
1321 int len = 0;
1322
1323 for (i = 0; txbits[i].name; i++) {
1324 if (!txbits[i].skip_for_len)
1325 len += strlen(txbits[i].name);
1326 }
1327 len += 4; /* :XX<space> */
1328 return len;
1329 }
1330
1331 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1332 size_t size, unsigned int width)
1333 {
1334 u64 t = he->transaction;
1335 char buf[128];
1336 char *p = buf;
1337 int i;
1338
1339 buf[0] = 0;
1340 for (i = 0; txbits[i].name; i++)
1341 if (txbits[i].flag & t)
1342 p = add_str(p, txbits[i].name);
1343 if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1344 p = add_str(p, "NEITHER ");
1345 if (t & PERF_TXN_ABORT_MASK) {
1346 sprintf(p, ":%" PRIx64,
1347 (t & PERF_TXN_ABORT_MASK) >>
1348 PERF_TXN_ABORT_SHIFT);
1349 p += strlen(p);
1350 }
1351
1352 return repsep_snprintf(bf, size, "%-*s", width, buf);
1353 }
1354
1355 struct sort_entry sort_transaction = {
1356 .se_header = "Transaction ",
1357 .se_cmp = sort__transaction_cmp,
1358 .se_snprintf = hist_entry__transaction_snprintf,
1359 .se_width_idx = HISTC_TRANSACTION,
1360 };
1361
1362 struct sort_dimension {
1363 const char *name;
1364 struct sort_entry *entry;
1365 int taken;
1366 };
1367
1368 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1369
1370 static struct sort_dimension common_sort_dimensions[] = {
1371 DIM(SORT_PID, "pid", sort_thread),
1372 DIM(SORT_COMM, "comm", sort_comm),
1373 DIM(SORT_DSO, "dso", sort_dso),
1374 DIM(SORT_SYM, "symbol", sort_sym),
1375 DIM(SORT_PARENT, "parent", sort_parent),
1376 DIM(SORT_CPU, "cpu", sort_cpu),
1377 DIM(SORT_SOCKET, "socket", sort_socket),
1378 DIM(SORT_SRCLINE, "srcline", sort_srcline),
1379 DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
1380 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1381 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1382 DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1383 DIM(SORT_TRACE, "trace", sort_trace),
1384 };
1385
1386 #undef DIM
1387
1388 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1389
1390 static struct sort_dimension bstack_sort_dimensions[] = {
1391 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
1392 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
1393 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
1394 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
1395 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
1396 DIM(SORT_IN_TX, "in_tx", sort_in_tx),
1397 DIM(SORT_ABORT, "abort", sort_abort),
1398 DIM(SORT_CYCLES, "cycles", sort_cycles),
1399 };
1400
1401 #undef DIM
1402
1403 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1404
1405 static struct sort_dimension memory_sort_dimensions[] = {
1406 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
1407 DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
1408 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
1409 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
1410 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
1411 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
1412 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
1413 DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
1414 };
1415
1416 #undef DIM
1417
1418 struct hpp_dimension {
1419 const char *name;
1420 struct perf_hpp_fmt *fmt;
1421 int taken;
1422 };
1423
1424 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1425
1426 static struct hpp_dimension hpp_sort_dimensions[] = {
1427 DIM(PERF_HPP__OVERHEAD, "overhead"),
1428 DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
1429 DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
1430 DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
1431 DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
1432 DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
1433 DIM(PERF_HPP__SAMPLES, "sample"),
1434 DIM(PERF_HPP__PERIOD, "period"),
1435 };
1436
1437 #undef DIM
1438
1439 struct hpp_sort_entry {
1440 struct perf_hpp_fmt hpp;
1441 struct sort_entry *se;
1442 };
1443
1444 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
1445 {
1446 struct hpp_sort_entry *hse;
1447
1448 if (!perf_hpp__is_sort_entry(fmt))
1449 return;
1450
1451 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1452 hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
1453 }
1454
1455 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1456 struct perf_evsel *evsel)
1457 {
1458 struct hpp_sort_entry *hse;
1459 size_t len = fmt->user_len;
1460
1461 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1462
1463 if (!len)
1464 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1465
1466 return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
1467 }
1468
1469 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
1470 struct perf_hpp *hpp __maybe_unused,
1471 struct perf_evsel *evsel)
1472 {
1473 struct hpp_sort_entry *hse;
1474 size_t len = fmt->user_len;
1475
1476 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1477
1478 if (!len)
1479 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1480
1481 return len;
1482 }
1483
1484 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1485 struct hist_entry *he)
1486 {
1487 struct hpp_sort_entry *hse;
1488 size_t len = fmt->user_len;
1489
1490 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1491
1492 if (!len)
1493 len = hists__col_len(he->hists, hse->se->se_width_idx);
1494
1495 return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
1496 }
1497
1498 static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
1499 struct hist_entry *a, struct hist_entry *b)
1500 {
1501 struct hpp_sort_entry *hse;
1502
1503 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1504 return hse->se->se_cmp(a, b);
1505 }
1506
1507 static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
1508 struct hist_entry *a, struct hist_entry *b)
1509 {
1510 struct hpp_sort_entry *hse;
1511 int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
1512
1513 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1514 collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
1515 return collapse_fn(a, b);
1516 }
1517
1518 static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
1519 struct hist_entry *a, struct hist_entry *b)
1520 {
1521 struct hpp_sort_entry *hse;
1522 int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
1523
1524 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1525 sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
1526 return sort_fn(a, b);
1527 }
1528
1529 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
1530 {
1531 return format->header == __sort__hpp_header;
1532 }
1533
1534 static bool __sort__hpp_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
1535 {
1536 struct hpp_sort_entry *hse_a;
1537 struct hpp_sort_entry *hse_b;
1538
1539 if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
1540 return false;
1541
1542 hse_a = container_of(a, struct hpp_sort_entry, hpp);
1543 hse_b = container_of(b, struct hpp_sort_entry, hpp);
1544
1545 return hse_a->se == hse_b->se;
1546 }
1547
1548 static void hse_free(struct perf_hpp_fmt *fmt)
1549 {
1550 struct hpp_sort_entry *hse;
1551
1552 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1553 free(hse);
1554 }
1555
1556 static struct hpp_sort_entry *
1557 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1558 {
1559 struct hpp_sort_entry *hse;
1560
1561 hse = malloc(sizeof(*hse));
1562 if (hse == NULL) {
1563 pr_err("Memory allocation failed\n");
1564 return NULL;
1565 }
1566
1567 hse->se = sd->entry;
1568 hse->hpp.name = sd->entry->se_header;
1569 hse->hpp.header = __sort__hpp_header;
1570 hse->hpp.width = __sort__hpp_width;
1571 hse->hpp.entry = __sort__hpp_entry;
1572 hse->hpp.color = NULL;
1573
1574 hse->hpp.cmp = __sort__hpp_cmp;
1575 hse->hpp.collapse = __sort__hpp_collapse;
1576 hse->hpp.sort = __sort__hpp_sort;
1577 hse->hpp.equal = __sort__hpp_equal;
1578 hse->hpp.free = hse_free;
1579
1580 INIT_LIST_HEAD(&hse->hpp.list);
1581 INIT_LIST_HEAD(&hse->hpp.sort_list);
1582 hse->hpp.elide = false;
1583 hse->hpp.len = 0;
1584 hse->hpp.user_len = 0;
1585
1586 return hse;
1587 }
1588
1589 static void hpp_free(struct perf_hpp_fmt *fmt)
1590 {
1591 free(fmt);
1592 }
1593
1594 static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd)
1595 {
1596 struct perf_hpp_fmt *fmt;
1597
1598 fmt = memdup(hd->fmt, sizeof(*fmt));
1599 if (fmt) {
1600 INIT_LIST_HEAD(&fmt->list);
1601 INIT_LIST_HEAD(&fmt->sort_list);
1602 fmt->free = hpp_free;
1603 }
1604
1605 return fmt;
1606 }
1607
1608 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1609 {
1610 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1611
1612 if (hse == NULL)
1613 return -1;
1614
1615 perf_hpp__register_sort_field(&hse->hpp);
1616 return 0;
1617 }
1618
1619 static int __sort_dimension__add_hpp_output(struct perf_hpp_list *list,
1620 struct sort_dimension *sd)
1621 {
1622 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1623
1624 if (hse == NULL)
1625 return -1;
1626
1627 perf_hpp_list__column_register(list, &hse->hpp);
1628 return 0;
1629 }
1630
1631 struct hpp_dynamic_entry {
1632 struct perf_hpp_fmt hpp;
1633 struct perf_evsel *evsel;
1634 struct format_field *field;
1635 unsigned dynamic_len;
1636 bool raw_trace;
1637 };
1638
1639 static int hde_width(struct hpp_dynamic_entry *hde)
1640 {
1641 if (!hde->hpp.len) {
1642 int len = hde->dynamic_len;
1643 int namelen = strlen(hde->field->name);
1644 int fieldlen = hde->field->size;
1645
1646 if (namelen > len)
1647 len = namelen;
1648
1649 if (!(hde->field->flags & FIELD_IS_STRING)) {
1650 /* length for print hex numbers */
1651 fieldlen = hde->field->size * 2 + 2;
1652 }
1653 if (fieldlen > len)
1654 len = fieldlen;
1655
1656 hde->hpp.len = len;
1657 }
1658 return hde->hpp.len;
1659 }
1660
1661 static void update_dynamic_len(struct hpp_dynamic_entry *hde,
1662 struct hist_entry *he)
1663 {
1664 char *str, *pos;
1665 struct format_field *field = hde->field;
1666 size_t namelen;
1667 bool last = false;
1668
1669 if (hde->raw_trace)
1670 return;
1671
1672 /* parse pretty print result and update max length */
1673 if (!he->trace_output)
1674 he->trace_output = get_trace_output(he);
1675
1676 namelen = strlen(field->name);
1677 str = he->trace_output;
1678
1679 while (str) {
1680 pos = strchr(str, ' ');
1681 if (pos == NULL) {
1682 last = true;
1683 pos = str + strlen(str);
1684 }
1685
1686 if (!strncmp(str, field->name, namelen)) {
1687 size_t len;
1688
1689 str += namelen + 1;
1690 len = pos - str;
1691
1692 if (len > hde->dynamic_len)
1693 hde->dynamic_len = len;
1694 break;
1695 }
1696
1697 if (last)
1698 str = NULL;
1699 else
1700 str = pos + 1;
1701 }
1702 }
1703
1704 static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1705 struct perf_evsel *evsel __maybe_unused)
1706 {
1707 struct hpp_dynamic_entry *hde;
1708 size_t len = fmt->user_len;
1709
1710 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1711
1712 if (!len)
1713 len = hde_width(hde);
1714
1715 return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, hde->field->name);
1716 }
1717
1718 static int __sort__hde_width(struct perf_hpp_fmt *fmt,
1719 struct perf_hpp *hpp __maybe_unused,
1720 struct perf_evsel *evsel __maybe_unused)
1721 {
1722 struct hpp_dynamic_entry *hde;
1723 size_t len = fmt->user_len;
1724
1725 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1726
1727 if (!len)
1728 len = hde_width(hde);
1729
1730 return len;
1731 }
1732
1733 bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt, struct hists *hists)
1734 {
1735 struct hpp_dynamic_entry *hde;
1736
1737 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1738
1739 return hists_to_evsel(hists) == hde->evsel;
1740 }
1741
1742 static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1743 struct hist_entry *he)
1744 {
1745 struct hpp_dynamic_entry *hde;
1746 size_t len = fmt->user_len;
1747 char *str, *pos;
1748 struct format_field *field;
1749 size_t namelen;
1750 bool last = false;
1751 int ret;
1752
1753 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1754
1755 if (!len)
1756 len = hde_width(hde);
1757
1758 if (hde->raw_trace)
1759 goto raw_field;
1760
1761 field = hde->field;
1762 namelen = strlen(field->name);
1763 str = he->trace_output;
1764
1765 while (str) {
1766 pos = strchr(str, ' ');
1767 if (pos == NULL) {
1768 last = true;
1769 pos = str + strlen(str);
1770 }
1771
1772 if (!strncmp(str, field->name, namelen)) {
1773 str += namelen + 1;
1774 str = strndup(str, pos - str);
1775
1776 if (str == NULL)
1777 return scnprintf(hpp->buf, hpp->size,
1778 "%*.*s", len, len, "ERROR");
1779 break;
1780 }
1781
1782 if (last)
1783 str = NULL;
1784 else
1785 str = pos + 1;
1786 }
1787
1788 if (str == NULL) {
1789 struct trace_seq seq;
1790 raw_field:
1791 trace_seq_init(&seq);
1792 pevent_print_field(&seq, he->raw_data, hde->field);
1793 str = seq.buffer;
1794 }
1795
1796 ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str);
1797 free(str);
1798 return ret;
1799 }
1800
1801 static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
1802 struct hist_entry *a, struct hist_entry *b)
1803 {
1804 struct hpp_dynamic_entry *hde;
1805 struct format_field *field;
1806 unsigned offset, size;
1807
1808 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1809
1810 field = hde->field;
1811 if (field->flags & FIELD_IS_DYNAMIC) {
1812 unsigned long long dyn;
1813
1814 pevent_read_number_field(field, a->raw_data, &dyn);
1815 offset = dyn & 0xffff;
1816 size = (dyn >> 16) & 0xffff;
1817
1818 /* record max width for output */
1819 if (size > hde->dynamic_len)
1820 hde->dynamic_len = size;
1821 } else {
1822 offset = field->offset;
1823 size = field->size;
1824
1825 update_dynamic_len(hde, a);
1826 update_dynamic_len(hde, b);
1827 }
1828
1829 return memcmp(a->raw_data + offset, b->raw_data + offset, size);
1830 }
1831
1832 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt)
1833 {
1834 return fmt->cmp == __sort__hde_cmp;
1835 }
1836
1837 static void hde_free(struct perf_hpp_fmt *fmt)
1838 {
1839 struct hpp_dynamic_entry *hde;
1840
1841 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1842 free(hde);
1843 }
1844
1845 static struct hpp_dynamic_entry *
1846 __alloc_dynamic_entry(struct perf_evsel *evsel, struct format_field *field)
1847 {
1848 struct hpp_dynamic_entry *hde;
1849
1850 hde = malloc(sizeof(*hde));
1851 if (hde == NULL) {
1852 pr_debug("Memory allocation failed\n");
1853 return NULL;
1854 }
1855
1856 hde->evsel = evsel;
1857 hde->field = field;
1858 hde->dynamic_len = 0;
1859
1860 hde->hpp.name = field->name;
1861 hde->hpp.header = __sort__hde_header;
1862 hde->hpp.width = __sort__hde_width;
1863 hde->hpp.entry = __sort__hde_entry;
1864 hde->hpp.color = NULL;
1865
1866 hde->hpp.cmp = __sort__hde_cmp;
1867 hde->hpp.collapse = __sort__hde_cmp;
1868 hde->hpp.sort = __sort__hde_cmp;
1869 hde->hpp.free = hde_free;
1870
1871 INIT_LIST_HEAD(&hde->hpp.list);
1872 INIT_LIST_HEAD(&hde->hpp.sort_list);
1873 hde->hpp.elide = false;
1874 hde->hpp.len = 0;
1875 hde->hpp.user_len = 0;
1876
1877 return hde;
1878 }
1879
1880 static int parse_field_name(char *str, char **event, char **field, char **opt)
1881 {
1882 char *event_name, *field_name, *opt_name;
1883
1884 event_name = str;
1885 field_name = strchr(str, '.');
1886
1887 if (field_name) {
1888 *field_name++ = '\0';
1889 } else {
1890 event_name = NULL;
1891 field_name = str;
1892 }
1893
1894 opt_name = strchr(field_name, '/');
1895 if (opt_name)
1896 *opt_name++ = '\0';
1897
1898 *event = event_name;
1899 *field = field_name;
1900 *opt = opt_name;
1901
1902 return 0;
1903 }
1904
1905 /* find match evsel using a given event name. The event name can be:
1906 * 1. '%' + event index (e.g. '%1' for first event)
1907 * 2. full event name (e.g. sched:sched_switch)
1908 * 3. partial event name (should not contain ':')
1909 */
1910 static struct perf_evsel *find_evsel(struct perf_evlist *evlist, char *event_name)
1911 {
1912 struct perf_evsel *evsel = NULL;
1913 struct perf_evsel *pos;
1914 bool full_name;
1915
1916 /* case 1 */
1917 if (event_name[0] == '%') {
1918 int nr = strtol(event_name+1, NULL, 0);
1919
1920 if (nr > evlist->nr_entries)
1921 return NULL;
1922
1923 evsel = perf_evlist__first(evlist);
1924 while (--nr > 0)
1925 evsel = perf_evsel__next(evsel);
1926
1927 return evsel;
1928 }
1929
1930 full_name = !!strchr(event_name, ':');
1931 evlist__for_each(evlist, pos) {
1932 /* case 2 */
1933 if (full_name && !strcmp(pos->name, event_name))
1934 return pos;
1935 /* case 3 */
1936 if (!full_name && strstr(pos->name, event_name)) {
1937 if (evsel) {
1938 pr_debug("'%s' event is ambiguous: it can be %s or %s\n",
1939 event_name, evsel->name, pos->name);
1940 return NULL;
1941 }
1942 evsel = pos;
1943 }
1944 }
1945
1946 return evsel;
1947 }
1948
1949 static int __dynamic_dimension__add(struct perf_evsel *evsel,
1950 struct format_field *field,
1951 bool raw_trace)
1952 {
1953 struct hpp_dynamic_entry *hde;
1954
1955 hde = __alloc_dynamic_entry(evsel, field);
1956 if (hde == NULL)
1957 return -ENOMEM;
1958
1959 hde->raw_trace = raw_trace;
1960
1961 perf_hpp__register_sort_field(&hde->hpp);
1962 return 0;
1963 }
1964
1965 static int add_evsel_fields(struct perf_evsel *evsel, bool raw_trace)
1966 {
1967 int ret;
1968 struct format_field *field;
1969
1970 field = evsel->tp_format->format.fields;
1971 while (field) {
1972 ret = __dynamic_dimension__add(evsel, field, raw_trace);
1973 if (ret < 0)
1974 return ret;
1975
1976 field = field->next;
1977 }
1978 return 0;
1979 }
1980
1981 static int add_all_dynamic_fields(struct perf_evlist *evlist, bool raw_trace)
1982 {
1983 int ret;
1984 struct perf_evsel *evsel;
1985
1986 evlist__for_each(evlist, evsel) {
1987 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
1988 continue;
1989
1990 ret = add_evsel_fields(evsel, raw_trace);
1991 if (ret < 0)
1992 return ret;
1993 }
1994 return 0;
1995 }
1996
1997 static int add_all_matching_fields(struct perf_evlist *evlist,
1998 char *field_name, bool raw_trace)
1999 {
2000 int ret = -ESRCH;
2001 struct perf_evsel *evsel;
2002 struct format_field *field;
2003
2004 evlist__for_each(evlist, evsel) {
2005 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
2006 continue;
2007
2008 field = pevent_find_any_field(evsel->tp_format, field_name);
2009 if (field == NULL)
2010 continue;
2011
2012 ret = __dynamic_dimension__add(evsel, field, raw_trace);
2013 if (ret < 0)
2014 break;
2015 }
2016 return ret;
2017 }
2018
2019 static int add_dynamic_entry(struct perf_evlist *evlist, const char *tok)
2020 {
2021 char *str, *event_name, *field_name, *opt_name;
2022 struct perf_evsel *evsel;
2023 struct format_field *field;
2024 bool raw_trace = symbol_conf.raw_trace;
2025 int ret = 0;
2026
2027 if (evlist == NULL)
2028 return -ENOENT;
2029
2030 str = strdup(tok);
2031 if (str == NULL)
2032 return -ENOMEM;
2033
2034 if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) {
2035 ret = -EINVAL;
2036 goto out;
2037 }
2038
2039 if (opt_name) {
2040 if (strcmp(opt_name, "raw")) {
2041 pr_debug("unsupported field option %s\n", opt_name);
2042 ret = -EINVAL;
2043 goto out;
2044 }
2045 raw_trace = true;
2046 }
2047
2048 if (!strcmp(field_name, "trace_fields")) {
2049 ret = add_all_dynamic_fields(evlist, raw_trace);
2050 goto out;
2051 }
2052
2053 if (event_name == NULL) {
2054 ret = add_all_matching_fields(evlist, field_name, raw_trace);
2055 goto out;
2056 }
2057
2058 evsel = find_evsel(evlist, event_name);
2059 if (evsel == NULL) {
2060 pr_debug("Cannot find event: %s\n", event_name);
2061 ret = -ENOENT;
2062 goto out;
2063 }
2064
2065 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
2066 pr_debug("%s is not a tracepoint event\n", event_name);
2067 ret = -EINVAL;
2068 goto out;
2069 }
2070
2071 if (!strcmp(field_name, "*")) {
2072 ret = add_evsel_fields(evsel, raw_trace);
2073 } else {
2074 field = pevent_find_any_field(evsel->tp_format, field_name);
2075 if (field == NULL) {
2076 pr_debug("Cannot find event field for %s.%s\n",
2077 event_name, field_name);
2078 return -ENOENT;
2079 }
2080
2081 ret = __dynamic_dimension__add(evsel, field, raw_trace);
2082 }
2083
2084 out:
2085 free(str);
2086 return ret;
2087 }
2088
2089 static int __sort_dimension__add(struct sort_dimension *sd)
2090 {
2091 if (sd->taken)
2092 return 0;
2093
2094 if (__sort_dimension__add_hpp_sort(sd) < 0)
2095 return -1;
2096
2097 if (sd->entry->se_collapse)
2098 sort__need_collapse = 1;
2099
2100 sd->taken = 1;
2101
2102 return 0;
2103 }
2104
2105 static int __hpp_dimension__add(struct hpp_dimension *hd)
2106 {
2107 struct perf_hpp_fmt *fmt;
2108
2109 if (hd->taken)
2110 return 0;
2111
2112 fmt = __hpp_dimension__alloc_hpp(hd);
2113 if (!fmt)
2114 return -1;
2115
2116 hd->taken = 1;
2117 perf_hpp__register_sort_field(fmt);
2118 return 0;
2119 }
2120
2121 static int __sort_dimension__add_output(struct perf_hpp_list *list,
2122 struct sort_dimension *sd)
2123 {
2124 if (sd->taken)
2125 return 0;
2126
2127 if (__sort_dimension__add_hpp_output(list, sd) < 0)
2128 return -1;
2129
2130 sd->taken = 1;
2131 return 0;
2132 }
2133
2134 static int __hpp_dimension__add_output(struct perf_hpp_list *list,
2135 struct hpp_dimension *hd)
2136 {
2137 struct perf_hpp_fmt *fmt;
2138
2139 if (hd->taken)
2140 return 0;
2141
2142 fmt = __hpp_dimension__alloc_hpp(hd);
2143 if (!fmt)
2144 return -1;
2145
2146 hd->taken = 1;
2147 perf_hpp_list__column_register(list, fmt);
2148 return 0;
2149 }
2150
2151 int hpp_dimension__add_output(unsigned col)
2152 {
2153 BUG_ON(col >= PERF_HPP__MAX_INDEX);
2154 return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]);
2155 }
2156
2157 static int sort_dimension__add(const char *tok,
2158 struct perf_evlist *evlist __maybe_unused)
2159 {
2160 unsigned int i;
2161
2162 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
2163 struct sort_dimension *sd = &common_sort_dimensions[i];
2164
2165 if (strncasecmp(tok, sd->name, strlen(tok)))
2166 continue;
2167
2168 if (sd->entry == &sort_parent) {
2169 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
2170 if (ret) {
2171 char err[BUFSIZ];
2172
2173 regerror(ret, &parent_regex, err, sizeof(err));
2174 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
2175 return -EINVAL;
2176 }
2177 sort__has_parent = 1;
2178 } else if (sd->entry == &sort_sym) {
2179 sort__has_sym = 1;
2180 /*
2181 * perf diff displays the performance difference amongst
2182 * two or more perf.data files. Those files could come
2183 * from different binaries. So we should not compare
2184 * their ips, but the name of symbol.
2185 */
2186 if (sort__mode == SORT_MODE__DIFF)
2187 sd->entry->se_collapse = sort__sym_sort;
2188
2189 } else if (sd->entry == &sort_dso) {
2190 sort__has_dso = 1;
2191 } else if (sd->entry == &sort_socket) {
2192 sort__has_socket = 1;
2193 } else if (sd->entry == &sort_thread) {
2194 sort__has_thread = 1;
2195 }
2196
2197 return __sort_dimension__add(sd);
2198 }
2199
2200 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
2201 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
2202
2203 if (strncasecmp(tok, hd->name, strlen(tok)))
2204 continue;
2205
2206 return __hpp_dimension__add(hd);
2207 }
2208
2209 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
2210 struct sort_dimension *sd = &bstack_sort_dimensions[i];
2211
2212 if (strncasecmp(tok, sd->name, strlen(tok)))
2213 continue;
2214
2215 if (sort__mode != SORT_MODE__BRANCH)
2216 return -EINVAL;
2217
2218 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
2219 sort__has_sym = 1;
2220
2221 __sort_dimension__add(sd);
2222 return 0;
2223 }
2224
2225 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
2226 struct sort_dimension *sd = &memory_sort_dimensions[i];
2227
2228 if (strncasecmp(tok, sd->name, strlen(tok)))
2229 continue;
2230
2231 if (sort__mode != SORT_MODE__MEMORY)
2232 return -EINVAL;
2233
2234 if (sd->entry == &sort_mem_daddr_sym)
2235 sort__has_sym = 1;
2236
2237 __sort_dimension__add(sd);
2238 return 0;
2239 }
2240
2241 if (!add_dynamic_entry(evlist, tok))
2242 return 0;
2243
2244 return -ESRCH;
2245 }
2246
2247 static int setup_sort_list(char *str, struct perf_evlist *evlist)
2248 {
2249 char *tmp, *tok;
2250 int ret = 0;
2251
2252 for (tok = strtok_r(str, ", ", &tmp);
2253 tok; tok = strtok_r(NULL, ", ", &tmp)) {
2254 ret = sort_dimension__add(tok, evlist);
2255 if (ret == -EINVAL) {
2256 error("Invalid --sort key: `%s'", tok);
2257 break;
2258 } else if (ret == -ESRCH) {
2259 error("Unknown --sort key: `%s'", tok);
2260 break;
2261 }
2262 }
2263
2264 return ret;
2265 }
2266
2267 static const char *get_default_sort_order(struct perf_evlist *evlist)
2268 {
2269 const char *default_sort_orders[] = {
2270 default_sort_order,
2271 default_branch_sort_order,
2272 default_mem_sort_order,
2273 default_top_sort_order,
2274 default_diff_sort_order,
2275 default_tracepoint_sort_order,
2276 };
2277 bool use_trace = true;
2278 struct perf_evsel *evsel;
2279
2280 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
2281
2282 if (evlist == NULL)
2283 goto out_no_evlist;
2284
2285 evlist__for_each(evlist, evsel) {
2286 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
2287 use_trace = false;
2288 break;
2289 }
2290 }
2291
2292 if (use_trace) {
2293 sort__mode = SORT_MODE__TRACEPOINT;
2294 if (symbol_conf.raw_trace)
2295 return "trace_fields";
2296 }
2297 out_no_evlist:
2298 return default_sort_orders[sort__mode];
2299 }
2300
2301 static int setup_sort_order(struct perf_evlist *evlist)
2302 {
2303 char *new_sort_order;
2304
2305 /*
2306 * Append '+'-prefixed sort order to the default sort
2307 * order string.
2308 */
2309 if (!sort_order || is_strict_order(sort_order))
2310 return 0;
2311
2312 if (sort_order[1] == '\0') {
2313 error("Invalid --sort key: `+'");
2314 return -EINVAL;
2315 }
2316
2317 /*
2318 * We allocate new sort_order string, but we never free it,
2319 * because it's checked over the rest of the code.
2320 */
2321 if (asprintf(&new_sort_order, "%s,%s",
2322 get_default_sort_order(evlist), sort_order + 1) < 0) {
2323 error("Not enough memory to set up --sort");
2324 return -ENOMEM;
2325 }
2326
2327 sort_order = new_sort_order;
2328 return 0;
2329 }
2330
2331 /*
2332 * Adds 'pre,' prefix into 'str' is 'pre' is
2333 * not already part of 'str'.
2334 */
2335 static char *prefix_if_not_in(const char *pre, char *str)
2336 {
2337 char *n;
2338
2339 if (!str || strstr(str, pre))
2340 return str;
2341
2342 if (asprintf(&n, "%s,%s", pre, str) < 0)
2343 return NULL;
2344
2345 free(str);
2346 return n;
2347 }
2348
2349 static char *setup_overhead(char *keys)
2350 {
2351 keys = prefix_if_not_in("overhead", keys);
2352
2353 if (symbol_conf.cumulate_callchain)
2354 keys = prefix_if_not_in("overhead_children", keys);
2355
2356 return keys;
2357 }
2358
2359 static int __setup_sorting(struct perf_evlist *evlist)
2360 {
2361 char *str;
2362 const char *sort_keys;
2363 int ret = 0;
2364
2365 ret = setup_sort_order(evlist);
2366 if (ret)
2367 return ret;
2368
2369 sort_keys = sort_order;
2370 if (sort_keys == NULL) {
2371 if (is_strict_order(field_order)) {
2372 /*
2373 * If user specified field order but no sort order,
2374 * we'll honor it and not add default sort orders.
2375 */
2376 return 0;
2377 }
2378
2379 sort_keys = get_default_sort_order(evlist);
2380 }
2381
2382 str = strdup(sort_keys);
2383 if (str == NULL) {
2384 error("Not enough memory to setup sort keys");
2385 return -ENOMEM;
2386 }
2387
2388 /*
2389 * Prepend overhead fields for backward compatibility.
2390 */
2391 if (!is_strict_order(field_order)) {
2392 str = setup_overhead(str);
2393 if (str == NULL) {
2394 error("Not enough memory to setup overhead keys");
2395 return -ENOMEM;
2396 }
2397 }
2398
2399 ret = setup_sort_list(str, evlist);
2400
2401 free(str);
2402 return ret;
2403 }
2404
2405 void perf_hpp__set_elide(int idx, bool elide)
2406 {
2407 struct perf_hpp_fmt *fmt;
2408 struct hpp_sort_entry *hse;
2409
2410 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
2411 if (!perf_hpp__is_sort_entry(fmt))
2412 continue;
2413
2414 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2415 if (hse->se->se_width_idx == idx) {
2416 fmt->elide = elide;
2417 break;
2418 }
2419 }
2420 }
2421
2422 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
2423 {
2424 if (list && strlist__nr_entries(list) == 1) {
2425 if (fp != NULL)
2426 fprintf(fp, "# %s: %s\n", list_name,
2427 strlist__entry(list, 0)->s);
2428 return true;
2429 }
2430 return false;
2431 }
2432
2433 static bool get_elide(int idx, FILE *output)
2434 {
2435 switch (idx) {
2436 case HISTC_SYMBOL:
2437 return __get_elide(symbol_conf.sym_list, "symbol", output);
2438 case HISTC_DSO:
2439 return __get_elide(symbol_conf.dso_list, "dso", output);
2440 case HISTC_COMM:
2441 return __get_elide(symbol_conf.comm_list, "comm", output);
2442 default:
2443 break;
2444 }
2445
2446 if (sort__mode != SORT_MODE__BRANCH)
2447 return false;
2448
2449 switch (idx) {
2450 case HISTC_SYMBOL_FROM:
2451 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
2452 case HISTC_SYMBOL_TO:
2453 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
2454 case HISTC_DSO_FROM:
2455 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
2456 case HISTC_DSO_TO:
2457 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
2458 default:
2459 break;
2460 }
2461
2462 return false;
2463 }
2464
2465 void sort__setup_elide(FILE *output)
2466 {
2467 struct perf_hpp_fmt *fmt;
2468 struct hpp_sort_entry *hse;
2469
2470 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
2471 if (!perf_hpp__is_sort_entry(fmt))
2472 continue;
2473
2474 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2475 fmt->elide = get_elide(hse->se->se_width_idx, output);
2476 }
2477
2478 /*
2479 * It makes no sense to elide all of sort entries.
2480 * Just revert them to show up again.
2481 */
2482 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
2483 if (!perf_hpp__is_sort_entry(fmt))
2484 continue;
2485
2486 if (!fmt->elide)
2487 return;
2488 }
2489
2490 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
2491 if (!perf_hpp__is_sort_entry(fmt))
2492 continue;
2493
2494 fmt->elide = false;
2495 }
2496 }
2497
2498 static int output_field_add(struct perf_hpp_list *list, char *tok)
2499 {
2500 unsigned int i;
2501
2502 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
2503 struct sort_dimension *sd = &common_sort_dimensions[i];
2504
2505 if (strncasecmp(tok, sd->name, strlen(tok)))
2506 continue;
2507
2508 return __sort_dimension__add_output(list, sd);
2509 }
2510
2511 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
2512 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
2513
2514 if (strncasecmp(tok, hd->name, strlen(tok)))
2515 continue;
2516
2517 return __hpp_dimension__add_output(list, hd);
2518 }
2519
2520 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
2521 struct sort_dimension *sd = &bstack_sort_dimensions[i];
2522
2523 if (strncasecmp(tok, sd->name, strlen(tok)))
2524 continue;
2525
2526 return __sort_dimension__add_output(list, sd);
2527 }
2528
2529 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
2530 struct sort_dimension *sd = &memory_sort_dimensions[i];
2531
2532 if (strncasecmp(tok, sd->name, strlen(tok)))
2533 continue;
2534
2535 return __sort_dimension__add_output(list, sd);
2536 }
2537
2538 return -ESRCH;
2539 }
2540
2541 static int setup_output_list(struct perf_hpp_list *list, char *str)
2542 {
2543 char *tmp, *tok;
2544 int ret = 0;
2545
2546 for (tok = strtok_r(str, ", ", &tmp);
2547 tok; tok = strtok_r(NULL, ", ", &tmp)) {
2548 ret = output_field_add(list, tok);
2549 if (ret == -EINVAL) {
2550 error("Invalid --fields key: `%s'", tok);
2551 break;
2552 } else if (ret == -ESRCH) {
2553 error("Unknown --fields key: `%s'", tok);
2554 break;
2555 }
2556 }
2557
2558 return ret;
2559 }
2560
2561 static void reset_dimensions(void)
2562 {
2563 unsigned int i;
2564
2565 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
2566 common_sort_dimensions[i].taken = 0;
2567
2568 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
2569 hpp_sort_dimensions[i].taken = 0;
2570
2571 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
2572 bstack_sort_dimensions[i].taken = 0;
2573
2574 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
2575 memory_sort_dimensions[i].taken = 0;
2576 }
2577
2578 bool is_strict_order(const char *order)
2579 {
2580 return order && (*order != '+');
2581 }
2582
2583 static int __setup_output_field(void)
2584 {
2585 char *str, *strp;
2586 int ret = -EINVAL;
2587
2588 if (field_order == NULL)
2589 return 0;
2590
2591 strp = str = strdup(field_order);
2592 if (str == NULL) {
2593 error("Not enough memory to setup output fields");
2594 return -ENOMEM;
2595 }
2596
2597 if (!is_strict_order(field_order))
2598 strp++;
2599
2600 if (!strlen(strp)) {
2601 error("Invalid --fields key: `+'");
2602 goto out;
2603 }
2604
2605 ret = setup_output_list(&perf_hpp_list, strp);
2606
2607 out:
2608 free(str);
2609 return ret;
2610 }
2611
2612 int setup_sorting(struct perf_evlist *evlist)
2613 {
2614 int err;
2615
2616 err = __setup_sorting(evlist);
2617 if (err < 0)
2618 return err;
2619
2620 if (parent_pattern != default_parent_pattern) {
2621 err = sort_dimension__add("parent", evlist);
2622 if (err < 0)
2623 return err;
2624 }
2625
2626 reset_dimensions();
2627
2628 /*
2629 * perf diff doesn't use default hpp output fields.
2630 */
2631 if (sort__mode != SORT_MODE__DIFF)
2632 perf_hpp__init();
2633
2634 err = __setup_output_field();
2635 if (err < 0)
2636 return err;
2637
2638 /* copy sort keys to output fields */
2639 perf_hpp__setup_output_field();
2640 /* and then copy output fields to sort keys */
2641 perf_hpp__append_sort_keys();
2642
2643 return 0;
2644 }
2645
2646 void reset_output_field(void)
2647 {
2648 sort__need_collapse = 0;
2649 sort__has_parent = 0;
2650 sort__has_sym = 0;
2651 sort__has_dso = 0;
2652
2653 field_order = NULL;
2654 sort_order = NULL;
2655
2656 reset_dimensions();
2657 perf_hpp__reset_output_field();
2658 }
Linux kernel - Deliverables
This page took 0.084863 seconds and 6 git commands to generate.