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