projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf hists: Add 'equal' method to perf_hpp_fmt struct
[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 struct hpp_sort_entry *
1549 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1550 {
1551 struct hpp_sort_entry *hse;
1552
1553 hse = malloc(sizeof(*hse));
1554 if (hse == NULL) {
1555 pr_err("Memory allocation failed\n");
1556 return NULL;
1557 }
1558
1559 hse->se = sd->entry;
1560 hse->hpp.name = sd->entry->se_header;
1561 hse->hpp.header = __sort__hpp_header;
1562 hse->hpp.width = __sort__hpp_width;
1563 hse->hpp.entry = __sort__hpp_entry;
1564 hse->hpp.color = NULL;
1565
1566 hse->hpp.cmp = __sort__hpp_cmp;
1567 hse->hpp.collapse = __sort__hpp_collapse;
1568 hse->hpp.sort = __sort__hpp_sort;
1569 hse->hpp.equal = __sort__hpp_equal;
1570
1571 INIT_LIST_HEAD(&hse->hpp.list);
1572 INIT_LIST_HEAD(&hse->hpp.sort_list);
1573 hse->hpp.elide = false;
1574 hse->hpp.len = 0;
1575 hse->hpp.user_len = 0;
1576
1577 return hse;
1578 }
1579
1580 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1581 {
1582 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1583
1584 if (hse == NULL)
1585 return -1;
1586
1587 perf_hpp__register_sort_field(&hse->hpp);
1588 return 0;
1589 }
1590
1591 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)
1592 {
1593 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1594
1595 if (hse == NULL)
1596 return -1;
1597
1598 perf_hpp__column_register(&hse->hpp);
1599 return 0;
1600 }
1601
1602 struct hpp_dynamic_entry {
1603 struct perf_hpp_fmt hpp;
1604 struct perf_evsel *evsel;
1605 struct format_field *field;
1606 unsigned dynamic_len;
1607 bool raw_trace;
1608 };
1609
1610 static int hde_width(struct hpp_dynamic_entry *hde)
1611 {
1612 if (!hde->hpp.len) {
1613 int len = hde->dynamic_len;
1614 int namelen = strlen(hde->field->name);
1615 int fieldlen = hde->field->size;
1616
1617 if (namelen > len)
1618 len = namelen;
1619
1620 if (!(hde->field->flags & FIELD_IS_STRING)) {
1621 /* length for print hex numbers */
1622 fieldlen = hde->field->size * 2 + 2;
1623 }
1624 if (fieldlen > len)
1625 len = fieldlen;
1626
1627 hde->hpp.len = len;
1628 }
1629 return hde->hpp.len;
1630 }
1631
1632 static void update_dynamic_len(struct hpp_dynamic_entry *hde,
1633 struct hist_entry *he)
1634 {
1635 char *str, *pos;
1636 struct format_field *field = hde->field;
1637 size_t namelen;
1638 bool last = false;
1639
1640 if (hde->raw_trace)
1641 return;
1642
1643 /* parse pretty print result and update max length */
1644 if (!he->trace_output)
1645 he->trace_output = get_trace_output(he);
1646
1647 namelen = strlen(field->name);
1648 str = he->trace_output;
1649
1650 while (str) {
1651 pos = strchr(str, ' ');
1652 if (pos == NULL) {
1653 last = true;
1654 pos = str + strlen(str);
1655 }
1656
1657 if (!strncmp(str, field->name, namelen)) {
1658 size_t len;
1659
1660 str += namelen + 1;
1661 len = pos - str;
1662
1663 if (len > hde->dynamic_len)
1664 hde->dynamic_len = len;
1665 break;
1666 }
1667
1668 if (last)
1669 str = NULL;
1670 else
1671 str = pos + 1;
1672 }
1673 }
1674
1675 static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1676 struct perf_evsel *evsel __maybe_unused)
1677 {
1678 struct hpp_dynamic_entry *hde;
1679 size_t len = fmt->user_len;
1680
1681 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1682
1683 if (!len)
1684 len = hde_width(hde);
1685
1686 return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, hde->field->name);
1687 }
1688
1689 static int __sort__hde_width(struct perf_hpp_fmt *fmt,
1690 struct perf_hpp *hpp __maybe_unused,
1691 struct perf_evsel *evsel __maybe_unused)
1692 {
1693 struct hpp_dynamic_entry *hde;
1694 size_t len = fmt->user_len;
1695
1696 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1697
1698 if (!len)
1699 len = hde_width(hde);
1700
1701 return len;
1702 }
1703
1704 bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt, struct hists *hists)
1705 {
1706 struct hpp_dynamic_entry *hde;
1707
1708 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1709
1710 return hists_to_evsel(hists) == hde->evsel;
1711 }
1712
1713 static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1714 struct hist_entry *he)
1715 {
1716 struct hpp_dynamic_entry *hde;
1717 size_t len = fmt->user_len;
1718 char *str, *pos;
1719 struct format_field *field;
1720 size_t namelen;
1721 bool last = false;
1722 int ret;
1723
1724 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1725
1726 if (!len)
1727 len = hde_width(hde);
1728
1729 if (hde->raw_trace)
1730 goto raw_field;
1731
1732 field = hde->field;
1733 namelen = strlen(field->name);
1734 str = he->trace_output;
1735
1736 while (str) {
1737 pos = strchr(str, ' ');
1738 if (pos == NULL) {
1739 last = true;
1740 pos = str + strlen(str);
1741 }
1742
1743 if (!strncmp(str, field->name, namelen)) {
1744 str += namelen + 1;
1745 str = strndup(str, pos - str);
1746
1747 if (str == NULL)
1748 return scnprintf(hpp->buf, hpp->size,
1749 "%*.*s", len, len, "ERROR");
1750 break;
1751 }
1752
1753 if (last)
1754 str = NULL;
1755 else
1756 str = pos + 1;
1757 }
1758
1759 if (str == NULL) {
1760 struct trace_seq seq;
1761 raw_field:
1762 trace_seq_init(&seq);
1763 pevent_print_field(&seq, he->raw_data, hde->field);
1764 str = seq.buffer;
1765 }
1766
1767 ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str);
1768 free(str);
1769 return ret;
1770 }
1771
1772 static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
1773 struct hist_entry *a, struct hist_entry *b)
1774 {
1775 struct hpp_dynamic_entry *hde;
1776 struct format_field *field;
1777 unsigned offset, size;
1778
1779 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
1780
1781 field = hde->field;
1782 if (field->flags & FIELD_IS_DYNAMIC) {
1783 unsigned long long dyn;
1784
1785 pevent_read_number_field(field, a->raw_data, &dyn);
1786 offset = dyn & 0xffff;
1787 size = (dyn >> 16) & 0xffff;
1788
1789 /* record max width for output */
1790 if (size > hde->dynamic_len)
1791 hde->dynamic_len = size;
1792 } else {
1793 offset = field->offset;
1794 size = field->size;
1795
1796 update_dynamic_len(hde, a);
1797 update_dynamic_len(hde, b);
1798 }
1799
1800 return memcmp(a->raw_data + offset, b->raw_data + offset, size);
1801 }
1802
1803 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt)
1804 {
1805 return fmt->cmp == __sort__hde_cmp;
1806 }
1807
1808 static struct hpp_dynamic_entry *
1809 __alloc_dynamic_entry(struct perf_evsel *evsel, struct format_field *field)
1810 {
1811 struct hpp_dynamic_entry *hde;
1812
1813 hde = malloc(sizeof(*hde));
1814 if (hde == NULL) {
1815 pr_debug("Memory allocation failed\n");
1816 return NULL;
1817 }
1818
1819 hde->evsel = evsel;
1820 hde->field = field;
1821 hde->dynamic_len = 0;
1822
1823 hde->hpp.name = field->name;
1824 hde->hpp.header = __sort__hde_header;
1825 hde->hpp.width = __sort__hde_width;
1826 hde->hpp.entry = __sort__hde_entry;
1827 hde->hpp.color = NULL;
1828
1829 hde->hpp.cmp = __sort__hde_cmp;
1830 hde->hpp.collapse = __sort__hde_cmp;
1831 hde->hpp.sort = __sort__hde_cmp;
1832
1833 INIT_LIST_HEAD(&hde->hpp.list);
1834 INIT_LIST_HEAD(&hde->hpp.sort_list);
1835 hde->hpp.elide = false;
1836 hde->hpp.len = 0;
1837 hde->hpp.user_len = 0;
1838
1839 return hde;
1840 }
1841
1842 static int parse_field_name(char *str, char **event, char **field, char **opt)
1843 {
1844 char *event_name, *field_name, *opt_name;
1845
1846 event_name = str;
1847 field_name = strchr(str, '.');
1848
1849 if (field_name) {
1850 *field_name++ = '\0';
1851 } else {
1852 event_name = NULL;
1853 field_name = str;
1854 }
1855
1856 opt_name = strchr(field_name, '/');
1857 if (opt_name)
1858 *opt_name++ = '\0';
1859
1860 *event = event_name;
1861 *field = field_name;
1862 *opt = opt_name;
1863
1864 return 0;
1865 }
1866
1867 /* find match evsel using a given event name. The event name can be:
1868 * 1. '%' + event index (e.g. '%1' for first event)
1869 * 2. full event name (e.g. sched:sched_switch)
1870 * 3. partial event name (should not contain ':')
1871 */
1872 static struct perf_evsel *find_evsel(struct perf_evlist *evlist, char *event_name)
1873 {
1874 struct perf_evsel *evsel = NULL;
1875 struct perf_evsel *pos;
1876 bool full_name;
1877
1878 /* case 1 */
1879 if (event_name[0] == '%') {
1880 int nr = strtol(event_name+1, NULL, 0);
1881
1882 if (nr > evlist->nr_entries)
1883 return NULL;
1884
1885 evsel = perf_evlist__first(evlist);
1886 while (--nr > 0)
1887 evsel = perf_evsel__next(evsel);
1888
1889 return evsel;
1890 }
1891
1892 full_name = !!strchr(event_name, ':');
1893 evlist__for_each(evlist, pos) {
1894 /* case 2 */
1895 if (full_name && !strcmp(pos->name, event_name))
1896 return pos;
1897 /* case 3 */
1898 if (!full_name && strstr(pos->name, event_name)) {
1899 if (evsel) {
1900 pr_debug("'%s' event is ambiguous: it can be %s or %s\n",
1901 event_name, evsel->name, pos->name);
1902 return NULL;
1903 }
1904 evsel = pos;
1905 }
1906 }
1907
1908 return evsel;
1909 }
1910
1911 static int __dynamic_dimension__add(struct perf_evsel *evsel,
1912 struct format_field *field,
1913 bool raw_trace)
1914 {
1915 struct hpp_dynamic_entry *hde;
1916
1917 hde = __alloc_dynamic_entry(evsel, field);
1918 if (hde == NULL)
1919 return -ENOMEM;
1920
1921 hde->raw_trace = raw_trace;
1922
1923 perf_hpp__register_sort_field(&hde->hpp);
1924 return 0;
1925 }
1926
1927 static int add_evsel_fields(struct perf_evsel *evsel, bool raw_trace)
1928 {
1929 int ret;
1930 struct format_field *field;
1931
1932 field = evsel->tp_format->format.fields;
1933 while (field) {
1934 ret = __dynamic_dimension__add(evsel, field, raw_trace);
1935 if (ret < 0)
1936 return ret;
1937
1938 field = field->next;
1939 }
1940 return 0;
1941 }
1942
1943 static int add_all_dynamic_fields(struct perf_evlist *evlist, bool raw_trace)
1944 {
1945 int ret;
1946 struct perf_evsel *evsel;
1947
1948 evlist__for_each(evlist, evsel) {
1949 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
1950 continue;
1951
1952 ret = add_evsel_fields(evsel, raw_trace);
1953 if (ret < 0)
1954 return ret;
1955 }
1956 return 0;
1957 }
1958
1959 static int add_all_matching_fields(struct perf_evlist *evlist,
1960 char *field_name, bool raw_trace)
1961 {
1962 int ret = -ESRCH;
1963 struct perf_evsel *evsel;
1964 struct format_field *field;
1965
1966 evlist__for_each(evlist, evsel) {
1967 if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
1968 continue;
1969
1970 field = pevent_find_any_field(evsel->tp_format, field_name);
1971 if (field == NULL)
1972 continue;
1973
1974 ret = __dynamic_dimension__add(evsel, field, raw_trace);
1975 if (ret < 0)
1976 break;
1977 }
1978 return ret;
1979 }
1980
1981 static int add_dynamic_entry(struct perf_evlist *evlist, const char *tok)
1982 {
1983 char *str, *event_name, *field_name, *opt_name;
1984 struct perf_evsel *evsel;
1985 struct format_field *field;
1986 bool raw_trace = symbol_conf.raw_trace;
1987 int ret = 0;
1988
1989 if (evlist == NULL)
1990 return -ENOENT;
1991
1992 str = strdup(tok);
1993 if (str == NULL)
1994 return -ENOMEM;
1995
1996 if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) {
1997 ret = -EINVAL;
1998 goto out;
1999 }
2000
2001 if (opt_name) {
2002 if (strcmp(opt_name, "raw")) {
2003 pr_debug("unsupported field option %s\n", opt_name);
2004 ret = -EINVAL;
2005 goto out;
2006 }
2007 raw_trace = true;
2008 }
2009
2010 if (!strcmp(field_name, "trace_fields")) {
2011 ret = add_all_dynamic_fields(evlist, raw_trace);
2012 goto out;
2013 }
2014
2015 if (event_name == NULL) {
2016 ret = add_all_matching_fields(evlist, field_name, raw_trace);
2017 goto out;
2018 }
2019
2020 evsel = find_evsel(evlist, event_name);
2021 if (evsel == NULL) {
2022 pr_debug("Cannot find event: %s\n", event_name);
2023 ret = -ENOENT;
2024 goto out;
2025 }
2026
2027 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
2028 pr_debug("%s is not a tracepoint event\n", event_name);
2029 ret = -EINVAL;
2030 goto out;
2031 }
2032
2033 if (!strcmp(field_name, "*")) {
2034 ret = add_evsel_fields(evsel, raw_trace);
2035 } else {
2036 field = pevent_find_any_field(evsel->tp_format, field_name);
2037 if (field == NULL) {
2038 pr_debug("Cannot find event field for %s.%s\n",
2039 event_name, field_name);
2040 return -ENOENT;
2041 }
2042
2043 ret = __dynamic_dimension__add(evsel, field, raw_trace);
2044 }
2045
2046 out:
2047 free(str);
2048 return ret;
2049 }
2050
2051 static int __sort_dimension__add(struct sort_dimension *sd)
2052 {
2053 if (sd->taken)
2054 return 0;
2055
2056 if (__sort_dimension__add_hpp_sort(sd) < 0)
2057 return -1;
2058
2059 if (sd->entry->se_collapse)
2060 sort__need_collapse = 1;
2061
2062 sd->taken = 1;
2063
2064 return 0;
2065 }
2066
2067 static int __hpp_dimension__add(struct hpp_dimension *hd)
2068 {
2069 if (!hd->taken) {
2070 hd->taken = 1;
2071
2072 perf_hpp__register_sort_field(hd->fmt);
2073 }
2074 return 0;
2075 }
2076
2077 static int __sort_dimension__add_output(struct sort_dimension *sd)
2078 {
2079 if (sd->taken)
2080 return 0;
2081
2082 if (__sort_dimension__add_hpp_output(sd) < 0)
2083 return -1;
2084
2085 sd->taken = 1;
2086 return 0;
2087 }
2088
2089 static int __hpp_dimension__add_output(struct hpp_dimension *hd)
2090 {
2091 if (!hd->taken) {
2092 hd->taken = 1;
2093
2094 perf_hpp__column_register(hd->fmt);
2095 }
2096 return 0;
2097 }
2098
2099 int hpp_dimension__add_output(unsigned col)
2100 {
2101 BUG_ON(col >= PERF_HPP__MAX_INDEX);
2102 return __hpp_dimension__add_output(&hpp_sort_dimensions[col]);
2103 }
2104
2105 static int sort_dimension__add(const char *tok,
2106 struct perf_evlist *evlist __maybe_unused)
2107 {
2108 unsigned int i;
2109
2110 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
2111 struct sort_dimension *sd = &common_sort_dimensions[i];
2112
2113 if (strncasecmp(tok, sd->name, strlen(tok)))
2114 continue;
2115
2116 if (sd->entry == &sort_parent) {
2117 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
2118 if (ret) {
2119 char err[BUFSIZ];
2120
2121 regerror(ret, &parent_regex, err, sizeof(err));
2122 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
2123 return -EINVAL;
2124 }
2125 sort__has_parent = 1;
2126 } else if (sd->entry == &sort_sym) {
2127 sort__has_sym = 1;
2128 /*
2129 * perf diff displays the performance difference amongst
2130 * two or more perf.data files. Those files could come
2131 * from different binaries. So we should not compare
2132 * their ips, but the name of symbol.
2133 */
2134 if (sort__mode == SORT_MODE__DIFF)
2135 sd->entry->se_collapse = sort__sym_sort;
2136
2137 } else if (sd->entry == &sort_dso) {
2138 sort__has_dso = 1;
2139 } else if (sd->entry == &sort_socket) {
2140 sort__has_socket = 1;
2141 } else if (sd->entry == &sort_thread) {
2142 sort__has_thread = 1;
2143 }
2144
2145 return __sort_dimension__add(sd);
2146 }
2147
2148 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
2149 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
2150
2151 if (strncasecmp(tok, hd->name, strlen(tok)))
2152 continue;
2153
2154 return __hpp_dimension__add(hd);
2155 }
2156
2157 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
2158 struct sort_dimension *sd = &bstack_sort_dimensions[i];
2159
2160 if (strncasecmp(tok, sd->name, strlen(tok)))
2161 continue;
2162
2163 if (sort__mode != SORT_MODE__BRANCH)
2164 return -EINVAL;
2165
2166 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
2167 sort__has_sym = 1;
2168
2169 __sort_dimension__add(sd);
2170 return 0;
2171 }
2172
2173 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
2174 struct sort_dimension *sd = &memory_sort_dimensions[i];
2175
2176 if (strncasecmp(tok, sd->name, strlen(tok)))
2177 continue;
2178
2179 if (sort__mode != SORT_MODE__MEMORY)
2180 return -EINVAL;
2181
2182 if (sd->entry == &sort_mem_daddr_sym)
2183 sort__has_sym = 1;
2184
2185 __sort_dimension__add(sd);
2186 return 0;
2187 }
2188
2189 if (!add_dynamic_entry(evlist, tok))
2190 return 0;
2191
2192 return -ESRCH;
2193 }
2194
2195 static const char *get_default_sort_order(struct perf_evlist *evlist)
2196 {
2197 const char *default_sort_orders[] = {
2198 default_sort_order,
2199 default_branch_sort_order,
2200 default_mem_sort_order,
2201 default_top_sort_order,
2202 default_diff_sort_order,
2203 default_tracepoint_sort_order,
2204 };
2205 bool use_trace = true;
2206 struct perf_evsel *evsel;
2207
2208 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
2209
2210 if (evlist == NULL)
2211 goto out_no_evlist;
2212
2213 evlist__for_each(evlist, evsel) {
2214 if (evsel->attr.type != PERF_TYPE_TRACEPOINT) {
2215 use_trace = false;
2216 break;
2217 }
2218 }
2219
2220 if (use_trace) {
2221 sort__mode = SORT_MODE__TRACEPOINT;
2222 if (symbol_conf.raw_trace)
2223 return "trace_fields";
2224 }
2225 out_no_evlist:
2226 return default_sort_orders[sort__mode];
2227 }
2228
2229 static int setup_sort_order(struct perf_evlist *evlist)
2230 {
2231 char *new_sort_order;
2232
2233 /*
2234 * Append '+'-prefixed sort order to the default sort
2235 * order string.
2236 */
2237 if (!sort_order || is_strict_order(sort_order))
2238 return 0;
2239
2240 if (sort_order[1] == '\0') {
2241 error("Invalid --sort key: `+'");
2242 return -EINVAL;
2243 }
2244
2245 /*
2246 * We allocate new sort_order string, but we never free it,
2247 * because it's checked over the rest of the code.
2248 */
2249 if (asprintf(&new_sort_order, "%s,%s",
2250 get_default_sort_order(evlist), sort_order + 1) < 0) {
2251 error("Not enough memory to set up --sort");
2252 return -ENOMEM;
2253 }
2254
2255 sort_order = new_sort_order;
2256 return 0;
2257 }
2258
2259 /*
2260 * Adds 'pre,' prefix into 'str' is 'pre' is
2261 * not already part of 'str'.
2262 */
2263 static char *prefix_if_not_in(const char *pre, char *str)
2264 {
2265 char *n;
2266
2267 if (!str || strstr(str, pre))
2268 return str;
2269
2270 if (asprintf(&n, "%s,%s", pre, str) < 0)
2271 return NULL;
2272
2273 free(str);
2274 return n;
2275 }
2276
2277 static char *setup_overhead(char *keys)
2278 {
2279 keys = prefix_if_not_in("overhead", keys);
2280
2281 if (symbol_conf.cumulate_callchain)
2282 keys = prefix_if_not_in("overhead_children", keys);
2283
2284 return keys;
2285 }
2286
2287 static int __setup_sorting(struct perf_evlist *evlist)
2288 {
2289 char *tmp, *tok, *str;
2290 const char *sort_keys;
2291 int ret = 0;
2292
2293 ret = setup_sort_order(evlist);
2294 if (ret)
2295 return ret;
2296
2297 sort_keys = sort_order;
2298 if (sort_keys == NULL) {
2299 if (is_strict_order(field_order)) {
2300 /*
2301 * If user specified field order but no sort order,
2302 * we'll honor it and not add default sort orders.
2303 */
2304 return 0;
2305 }
2306
2307 sort_keys = get_default_sort_order(evlist);
2308 }
2309
2310 str = strdup(sort_keys);
2311 if (str == NULL) {
2312 error("Not enough memory to setup sort keys");
2313 return -ENOMEM;
2314 }
2315
2316 /*
2317 * Prepend overhead fields for backward compatibility.
2318 */
2319 if (!is_strict_order(field_order)) {
2320 str = setup_overhead(str);
2321 if (str == NULL) {
2322 error("Not enough memory to setup overhead keys");
2323 return -ENOMEM;
2324 }
2325 }
2326
2327 for (tok = strtok_r(str, ", ", &tmp);
2328 tok; tok = strtok_r(NULL, ", ", &tmp)) {
2329 ret = sort_dimension__add(tok, evlist);
2330 if (ret == -EINVAL) {
2331 error("Invalid --sort key: `%s'", tok);
2332 break;
2333 } else if (ret == -ESRCH) {
2334 error("Unknown --sort key: `%s'", tok);
2335 break;
2336 }
2337 }
2338
2339 free(str);
2340 return ret;
2341 }
2342
2343 void perf_hpp__set_elide(int idx, bool elide)
2344 {
2345 struct perf_hpp_fmt *fmt;
2346 struct hpp_sort_entry *hse;
2347
2348 perf_hpp__for_each_format(fmt) {
2349 if (!perf_hpp__is_sort_entry(fmt))
2350 continue;
2351
2352 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2353 if (hse->se->se_width_idx == idx) {
2354 fmt->elide = elide;
2355 break;
2356 }
2357 }
2358 }
2359
2360 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
2361 {
2362 if (list && strlist__nr_entries(list) == 1) {
2363 if (fp != NULL)
2364 fprintf(fp, "# %s: %s\n", list_name,
2365 strlist__entry(list, 0)->s);
2366 return true;
2367 }
2368 return false;
2369 }
2370
2371 static bool get_elide(int idx, FILE *output)
2372 {
2373 switch (idx) {
2374 case HISTC_SYMBOL:
2375 return __get_elide(symbol_conf.sym_list, "symbol", output);
2376 case HISTC_DSO:
2377 return __get_elide(symbol_conf.dso_list, "dso", output);
2378 case HISTC_COMM:
2379 return __get_elide(symbol_conf.comm_list, "comm", output);
2380 default:
2381 break;
2382 }
2383
2384 if (sort__mode != SORT_MODE__BRANCH)
2385 return false;
2386
2387 switch (idx) {
2388 case HISTC_SYMBOL_FROM:
2389 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
2390 case HISTC_SYMBOL_TO:
2391 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
2392 case HISTC_DSO_FROM:
2393 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
2394 case HISTC_DSO_TO:
2395 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
2396 default:
2397 break;
2398 }
2399
2400 return false;
2401 }
2402
2403 void sort__setup_elide(FILE *output)
2404 {
2405 struct perf_hpp_fmt *fmt;
2406 struct hpp_sort_entry *hse;
2407
2408 perf_hpp__for_each_format(fmt) {
2409 if (!perf_hpp__is_sort_entry(fmt))
2410 continue;
2411
2412 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2413 fmt->elide = get_elide(hse->se->se_width_idx, output);
2414 }
2415
2416 /*
2417 * It makes no sense to elide all of sort entries.
2418 * Just revert them to show up again.
2419 */
2420 perf_hpp__for_each_format(fmt) {
2421 if (!perf_hpp__is_sort_entry(fmt))
2422 continue;
2423
2424 if (!fmt->elide)
2425 return;
2426 }
2427
2428 perf_hpp__for_each_format(fmt) {
2429 if (!perf_hpp__is_sort_entry(fmt))
2430 continue;
2431
2432 fmt->elide = false;
2433 }
2434 }
2435
2436 static int output_field_add(char *tok)
2437 {
2438 unsigned int i;
2439
2440 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
2441 struct sort_dimension *sd = &common_sort_dimensions[i];
2442
2443 if (strncasecmp(tok, sd->name, strlen(tok)))
2444 continue;
2445
2446 return __sort_dimension__add_output(sd);
2447 }
2448
2449 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
2450 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
2451
2452 if (strncasecmp(tok, hd->name, strlen(tok)))
2453 continue;
2454
2455 return __hpp_dimension__add_output(hd);
2456 }
2457
2458 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
2459 struct sort_dimension *sd = &bstack_sort_dimensions[i];
2460
2461 if (strncasecmp(tok, sd->name, strlen(tok)))
2462 continue;
2463
2464 return __sort_dimension__add_output(sd);
2465 }
2466
2467 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
2468 struct sort_dimension *sd = &memory_sort_dimensions[i];
2469
2470 if (strncasecmp(tok, sd->name, strlen(tok)))
2471 continue;
2472
2473 return __sort_dimension__add_output(sd);
2474 }
2475
2476 return -ESRCH;
2477 }
2478
2479 static void reset_dimensions(void)
2480 {
2481 unsigned int i;
2482
2483 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
2484 common_sort_dimensions[i].taken = 0;
2485
2486 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
2487 hpp_sort_dimensions[i].taken = 0;
2488
2489 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
2490 bstack_sort_dimensions[i].taken = 0;
2491
2492 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
2493 memory_sort_dimensions[i].taken = 0;
2494 }
2495
2496 bool is_strict_order(const char *order)
2497 {
2498 return order && (*order != '+');
2499 }
2500
2501 static int __setup_output_field(void)
2502 {
2503 char *tmp, *tok, *str, *strp;
2504 int ret = -EINVAL;
2505
2506 if (field_order == NULL)
2507 return 0;
2508
2509 strp = str = strdup(field_order);
2510 if (str == NULL) {
2511 error("Not enough memory to setup output fields");
2512 return -ENOMEM;
2513 }
2514
2515 if (!is_strict_order(field_order))
2516 strp++;
2517
2518 if (!strlen(strp)) {
2519 error("Invalid --fields key: `+'");
2520 goto out;
2521 }
2522
2523 for (tok = strtok_r(strp, ", ", &tmp);
2524 tok; tok = strtok_r(NULL, ", ", &tmp)) {
2525 ret = output_field_add(tok);
2526 if (ret == -EINVAL) {
2527 error("Invalid --fields key: `%s'", tok);
2528 break;
2529 } else if (ret == -ESRCH) {
2530 error("Unknown --fields key: `%s'", tok);
2531 break;
2532 }
2533 }
2534
2535 out:
2536 free(str);
2537 return ret;
2538 }
2539
2540 int setup_sorting(struct perf_evlist *evlist)
2541 {
2542 int err;
2543
2544 err = __setup_sorting(evlist);
2545 if (err < 0)
2546 return err;
2547
2548 if (parent_pattern != default_parent_pattern) {
2549 err = sort_dimension__add("parent", evlist);
2550 if (err < 0)
2551 return err;
2552 }
2553
2554 reset_dimensions();
2555
2556 /*
2557 * perf diff doesn't use default hpp output fields.
2558 */
2559 if (sort__mode != SORT_MODE__DIFF)
2560 perf_hpp__init();
2561
2562 err = __setup_output_field();
2563 if (err < 0)
2564 return err;
2565
2566 /* copy sort keys to output fields */
2567 perf_hpp__setup_output_field();
2568 /* and then copy output fields to sort keys */
2569 perf_hpp__append_sort_keys();
2570
2571 return 0;
2572 }
2573
2574 void reset_output_field(void)
2575 {
2576 sort__need_collapse = 0;
2577 sort__has_parent = 0;
2578 sort__has_sym = 0;
2579 sort__has_dso = 0;
2580
2581 field_order = NULL;
2582 sort_order = NULL;
2583
2584 reset_dimensions();
2585 perf_hpp__reset_output_field();
2586 }
Linux kernel - Deliverables
This page took 0.138696 seconds and 6 git commands to generate.