projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
perf tools: Fix report -F dso_from for data without branch info
[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
8 regex_t parent_regex;
9 const char default_parent_pattern[] = "^sys_|^do_page_fault";
10 const char *parent_pattern = default_parent_pattern;
11 const char default_sort_order[] = "comm,dso,symbol";
12 const char default_branch_sort_order[] = "comm,dso_from,symbol_from,dso_to,symbol_to";
13 const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked";
14 const char default_top_sort_order[] = "dso,symbol";
15 const char default_diff_sort_order[] = "dso,symbol";
16 const char *sort_order;
17 const char *field_order;
18 regex_t ignore_callees_regex;
19 int have_ignore_callees = 0;
20 int sort__need_collapse = 0;
21 int sort__has_parent = 0;
22 int sort__has_sym = 0;
23 int sort__has_dso = 0;
24 enum sort_mode sort__mode = SORT_MODE__NORMAL;
25
26
27 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
28 {
29 int n;
30 va_list ap;
31
32 va_start(ap, fmt);
33 n = vsnprintf(bf, size, fmt, ap);
34 if (symbol_conf.field_sep && n > 0) {
35 char *sep = bf;
36
37 while (1) {
38 sep = strchr(sep, *symbol_conf.field_sep);
39 if (sep == NULL)
40 break;
41 *sep = '.';
42 }
43 }
44 va_end(ap);
45
46 if (n >= (int)size)
47 return size - 1;
48 return n;
49 }
50
51 static int64_t cmp_null(const void *l, const void *r)
52 {
53 if (!l && !r)
54 return 0;
55 else if (!l)
56 return -1;
57 else
58 return 1;
59 }
60
61 /* --sort pid */
62
63 static int64_t
64 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
65 {
66 return right->thread->tid - left->thread->tid;
67 }
68
69 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
70 size_t size, unsigned int width)
71 {
72 const char *comm = thread__comm_str(he->thread);
73
74 width = max(7U, width) - 6;
75 return repsep_snprintf(bf, size, "%5d:%-*.*s", he->thread->tid,
76 width, width, comm ?: "");
77 }
78
79 struct sort_entry sort_thread = {
80 .se_header = " Pid:Command",
81 .se_cmp = sort__thread_cmp,
82 .se_snprintf = hist_entry__thread_snprintf,
83 .se_width_idx = HISTC_THREAD,
84 };
85
86 /* --sort comm */
87
88 static int64_t
89 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
90 {
91 /* Compare the addr that should be unique among comm */
92 return comm__str(right->comm) - comm__str(left->comm);
93 }
94
95 static int64_t
96 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
97 {
98 /* Compare the addr that should be unique among comm */
99 return comm__str(right->comm) - comm__str(left->comm);
100 }
101
102 static int64_t
103 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
104 {
105 return strcmp(comm__str(right->comm), comm__str(left->comm));
106 }
107
108 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
109 size_t size, unsigned int width)
110 {
111 return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
112 }
113
114 struct sort_entry sort_comm = {
115 .se_header = "Command",
116 .se_cmp = sort__comm_cmp,
117 .se_collapse = sort__comm_collapse,
118 .se_sort = sort__comm_sort,
119 .se_snprintf = hist_entry__comm_snprintf,
120 .se_width_idx = HISTC_COMM,
121 };
122
123 /* --sort dso */
124
125 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
126 {
127 struct dso *dso_l = map_l ? map_l->dso : NULL;
128 struct dso *dso_r = map_r ? map_r->dso : NULL;
129 const char *dso_name_l, *dso_name_r;
130
131 if (!dso_l || !dso_r)
132 return cmp_null(dso_r, dso_l);
133
134 if (verbose) {
135 dso_name_l = dso_l->long_name;
136 dso_name_r = dso_r->long_name;
137 } else {
138 dso_name_l = dso_l->short_name;
139 dso_name_r = dso_r->short_name;
140 }
141
142 return strcmp(dso_name_l, dso_name_r);
143 }
144
145 static int64_t
146 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
147 {
148 return _sort__dso_cmp(right->ms.map, left->ms.map);
149 }
150
151 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
152 size_t size, unsigned int width)
153 {
154 if (map && map->dso) {
155 const char *dso_name = !verbose ? map->dso->short_name :
156 map->dso->long_name;
157 return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
158 }
159
160 return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
161 }
162
163 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
164 size_t size, unsigned int width)
165 {
166 return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
167 }
168
169 struct sort_entry sort_dso = {
170 .se_header = "Shared Object",
171 .se_cmp = sort__dso_cmp,
172 .se_snprintf = hist_entry__dso_snprintf,
173 .se_width_idx = HISTC_DSO,
174 };
175
176 /* --sort symbol */
177
178 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
179 {
180 return (int64_t)(right_ip - left_ip);
181 }
182
183 static int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
184 {
185 u64 ip_l, ip_r;
186
187 if (!sym_l || !sym_r)
188 return cmp_null(sym_l, sym_r);
189
190 if (sym_l == sym_r)
191 return 0;
192
193 ip_l = sym_l->start;
194 ip_r = sym_r->start;
195
196 return (int64_t)(ip_r - ip_l);
197 }
198
199 static int64_t
200 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
201 {
202 int64_t ret;
203
204 if (!left->ms.sym && !right->ms.sym)
205 return _sort__addr_cmp(left->ip, right->ip);
206
207 /*
208 * comparing symbol address alone is not enough since it's a
209 * relative address within a dso.
210 */
211 if (!sort__has_dso) {
212 ret = sort__dso_cmp(left, right);
213 if (ret != 0)
214 return ret;
215 }
216
217 return _sort__sym_cmp(left->ms.sym, right->ms.sym);
218 }
219
220 static int64_t
221 sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
222 {
223 if (!left->ms.sym || !right->ms.sym)
224 return cmp_null(left->ms.sym, right->ms.sym);
225
226 return strcmp(right->ms.sym->name, left->ms.sym->name);
227 }
228
229 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
230 u64 ip, char level, char *bf, size_t size,
231 unsigned int width)
232 {
233 size_t ret = 0;
234
235 if (verbose) {
236 char o = map ? dso__symtab_origin(map->dso) : '!';
237 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
238 BITS_PER_LONG / 4 + 2, ip, o);
239 }
240
241 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
242 if (sym && map) {
243 if (map->type == MAP__VARIABLE) {
244 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
245 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
246 ip - map->unmap_ip(map, sym->start));
247 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
248 width - ret, "");
249 } else {
250 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
251 width - ret,
252 sym->name);
253 }
254 } else {
255 size_t len = BITS_PER_LONG / 4;
256 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
257 len, ip);
258 ret += repsep_snprintf(bf + ret, size - ret, "%-*s",
259 width - ret, "");
260 }
261
262 if (ret > width)
263 bf[width] = '\0';
264
265 return width;
266 }
267
268 static int hist_entry__sym_snprintf(struct hist_entry *he, char *bf,
269 size_t size, unsigned int width)
270 {
271 return _hist_entry__sym_snprintf(he->ms.map, he->ms.sym, he->ip,
272 he->level, bf, size, width);
273 }
274
275 struct sort_entry sort_sym = {
276 .se_header = "Symbol",
277 .se_cmp = sort__sym_cmp,
278 .se_sort = sort__sym_sort,
279 .se_snprintf = hist_entry__sym_snprintf,
280 .se_width_idx = HISTC_SYMBOL,
281 };
282
283 /* --sort srcline */
284
285 static int64_t
286 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
287 {
288 if (!left->srcline) {
289 if (!left->ms.map)
290 left->srcline = SRCLINE_UNKNOWN;
291 else {
292 struct map *map = left->ms.map;
293 left->srcline = get_srcline(map->dso,
294 map__rip_2objdump(map, left->ip));
295 }
296 }
297 if (!right->srcline) {
298 if (!right->ms.map)
299 right->srcline = SRCLINE_UNKNOWN;
300 else {
301 struct map *map = right->ms.map;
302 right->srcline = get_srcline(map->dso,
303 map__rip_2objdump(map, right->ip));
304 }
305 }
306 return strcmp(right->srcline, left->srcline);
307 }
308
309 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
310 size_t size, unsigned int width)
311 {
312 return repsep_snprintf(bf, size, "%*.*-s", width, width, he->srcline);
313 }
314
315 struct sort_entry sort_srcline = {
316 .se_header = "Source:Line",
317 .se_cmp = sort__srcline_cmp,
318 .se_snprintf = hist_entry__srcline_snprintf,
319 .se_width_idx = HISTC_SRCLINE,
320 };
321
322 /* --sort parent */
323
324 static int64_t
325 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
326 {
327 struct symbol *sym_l = left->parent;
328 struct symbol *sym_r = right->parent;
329
330 if (!sym_l || !sym_r)
331 return cmp_null(sym_l, sym_r);
332
333 return strcmp(sym_r->name, sym_l->name);
334 }
335
336 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
337 size_t size, unsigned int width)
338 {
339 return repsep_snprintf(bf, size, "%-*.*s", width, width,
340 he->parent ? he->parent->name : "[other]");
341 }
342
343 struct sort_entry sort_parent = {
344 .se_header = "Parent symbol",
345 .se_cmp = sort__parent_cmp,
346 .se_snprintf = hist_entry__parent_snprintf,
347 .se_width_idx = HISTC_PARENT,
348 };
349
350 /* --sort cpu */
351
352 static int64_t
353 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
354 {
355 return right->cpu - left->cpu;
356 }
357
358 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
359 size_t size, unsigned int width)
360 {
361 return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
362 }
363
364 struct sort_entry sort_cpu = {
365 .se_header = "CPU",
366 .se_cmp = sort__cpu_cmp,
367 .se_snprintf = hist_entry__cpu_snprintf,
368 .se_width_idx = HISTC_CPU,
369 };
370
371 /* sort keys for branch stacks */
372
373 static int64_t
374 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
375 {
376 if (!left->branch_info || !right->branch_info)
377 return cmp_null(left->branch_info, right->branch_info);
378
379 return _sort__dso_cmp(left->branch_info->from.map,
380 right->branch_info->from.map);
381 }
382
383 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
384 size_t size, unsigned int width)
385 {
386 if (he->branch_info)
387 return _hist_entry__dso_snprintf(he->branch_info->from.map,
388 bf, size, width);
389 else
390 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
391 }
392
393 static int64_t
394 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
395 {
396 if (!left->branch_info || !right->branch_info)
397 return cmp_null(left->branch_info, right->branch_info);
398
399 return _sort__dso_cmp(left->branch_info->to.map,
400 right->branch_info->to.map);
401 }
402
403 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
404 size_t size, unsigned int width)
405 {
406 if (he->branch_info)
407 return _hist_entry__dso_snprintf(he->branch_info->to.map,
408 bf, size, width);
409 else
410 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
411 }
412
413 static int64_t
414 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
415 {
416 struct addr_map_symbol *from_l = &left->branch_info->from;
417 struct addr_map_symbol *from_r = &right->branch_info->from;
418
419 if (!left->branch_info || !right->branch_info)
420 return cmp_null(left->branch_info, right->branch_info);
421
422 from_l = &left->branch_info->from;
423 from_r = &right->branch_info->from;
424
425 if (!from_l->sym && !from_r->sym)
426 return _sort__addr_cmp(from_l->addr, from_r->addr);
427
428 return _sort__sym_cmp(from_l->sym, from_r->sym);
429 }
430
431 static int64_t
432 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
433 {
434 struct addr_map_symbol *to_l, *to_r;
435
436 if (!left->branch_info || !right->branch_info)
437 return cmp_null(left->branch_info, right->branch_info);
438
439 to_l = &left->branch_info->to;
440 to_r = &right->branch_info->to;
441
442 if (!to_l->sym && !to_r->sym)
443 return _sort__addr_cmp(to_l->addr, to_r->addr);
444
445 return _sort__sym_cmp(to_l->sym, to_r->sym);
446 }
447
448 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
449 size_t size, unsigned int width)
450 {
451 if (he->branch_info) {
452 struct addr_map_symbol *from = &he->branch_info->from;
453
454 return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
455 he->level, bf, size, width);
456 }
457
458 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
459 }
460
461 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
462 size_t size, unsigned int width)
463 {
464 if (he->branch_info) {
465 struct addr_map_symbol *to = &he->branch_info->to;
466
467 return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
468 he->level, bf, size, width);
469 }
470
471 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
472 }
473
474 struct sort_entry sort_dso_from = {
475 .se_header = "Source Shared Object",
476 .se_cmp = sort__dso_from_cmp,
477 .se_snprintf = hist_entry__dso_from_snprintf,
478 .se_width_idx = HISTC_DSO_FROM,
479 };
480
481 struct sort_entry sort_dso_to = {
482 .se_header = "Target Shared Object",
483 .se_cmp = sort__dso_to_cmp,
484 .se_snprintf = hist_entry__dso_to_snprintf,
485 .se_width_idx = HISTC_DSO_TO,
486 };
487
488 struct sort_entry sort_sym_from = {
489 .se_header = "Source Symbol",
490 .se_cmp = sort__sym_from_cmp,
491 .se_snprintf = hist_entry__sym_from_snprintf,
492 .se_width_idx = HISTC_SYMBOL_FROM,
493 };
494
495 struct sort_entry sort_sym_to = {
496 .se_header = "Target Symbol",
497 .se_cmp = sort__sym_to_cmp,
498 .se_snprintf = hist_entry__sym_to_snprintf,
499 .se_width_idx = HISTC_SYMBOL_TO,
500 };
501
502 static int64_t
503 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
504 {
505 unsigned char mp, p;
506
507 if (!left->branch_info || !right->branch_info)
508 return cmp_null(left->branch_info, right->branch_info);
509
510 mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
511 p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
512 return mp || p;
513 }
514
515 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
516 size_t size, unsigned int width){
517 static const char *out = "N/A";
518
519 if (he->branch_info) {
520 if (he->branch_info->flags.predicted)
521 out = "N";
522 else if (he->branch_info->flags.mispred)
523 out = "Y";
524 }
525
526 return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
527 }
528
529 /* --sort daddr_sym */
530 static int64_t
531 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
532 {
533 uint64_t l = 0, r = 0;
534
535 if (left->mem_info)
536 l = left->mem_info->daddr.addr;
537 if (right->mem_info)
538 r = right->mem_info->daddr.addr;
539
540 return (int64_t)(r - l);
541 }
542
543 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
544 size_t size, unsigned int width)
545 {
546 uint64_t addr = 0;
547 struct map *map = NULL;
548 struct symbol *sym = NULL;
549
550 if (he->mem_info) {
551 addr = he->mem_info->daddr.addr;
552 map = he->mem_info->daddr.map;
553 sym = he->mem_info->daddr.sym;
554 }
555 return _hist_entry__sym_snprintf(map, sym, addr, he->level, bf, size,
556 width);
557 }
558
559 static int64_t
560 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
561 {
562 struct map *map_l = NULL;
563 struct map *map_r = NULL;
564
565 if (left->mem_info)
566 map_l = left->mem_info->daddr.map;
567 if (right->mem_info)
568 map_r = right->mem_info->daddr.map;
569
570 return _sort__dso_cmp(map_l, map_r);
571 }
572
573 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
574 size_t size, unsigned int width)
575 {
576 struct map *map = NULL;
577
578 if (he->mem_info)
579 map = he->mem_info->daddr.map;
580
581 return _hist_entry__dso_snprintf(map, bf, size, width);
582 }
583
584 static int64_t
585 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
586 {
587 union perf_mem_data_src data_src_l;
588 union perf_mem_data_src data_src_r;
589
590 if (left->mem_info)
591 data_src_l = left->mem_info->data_src;
592 else
593 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
594
595 if (right->mem_info)
596 data_src_r = right->mem_info->data_src;
597 else
598 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
599
600 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
601 }
602
603 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
604 size_t size, unsigned int width)
605 {
606 const char *out;
607 u64 mask = PERF_MEM_LOCK_NA;
608
609 if (he->mem_info)
610 mask = he->mem_info->data_src.mem_lock;
611
612 if (mask & PERF_MEM_LOCK_NA)
613 out = "N/A";
614 else if (mask & PERF_MEM_LOCK_LOCKED)
615 out = "Yes";
616 else
617 out = "No";
618
619 return repsep_snprintf(bf, size, "%-*s", width, out);
620 }
621
622 static int64_t
623 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
624 {
625 union perf_mem_data_src data_src_l;
626 union perf_mem_data_src data_src_r;
627
628 if (left->mem_info)
629 data_src_l = left->mem_info->data_src;
630 else
631 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
632
633 if (right->mem_info)
634 data_src_r = right->mem_info->data_src;
635 else
636 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
637
638 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
639 }
640
641 static const char * const tlb_access[] = {
642 "N/A",
643 "HIT",
644 "MISS",
645 "L1",
646 "L2",
647 "Walker",
648 "Fault",
649 };
650 #define NUM_TLB_ACCESS (sizeof(tlb_access)/sizeof(const char *))
651
652 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
653 size_t size, unsigned int width)
654 {
655 char out[64];
656 size_t sz = sizeof(out) - 1; /* -1 for null termination */
657 size_t l = 0, i;
658 u64 m = PERF_MEM_TLB_NA;
659 u64 hit, miss;
660
661 out[0] = '\0';
662
663 if (he->mem_info)
664 m = he->mem_info->data_src.mem_dtlb;
665
666 hit = m & PERF_MEM_TLB_HIT;
667 miss = m & PERF_MEM_TLB_MISS;
668
669 /* already taken care of */
670 m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
671
672 for (i = 0; m && i < NUM_TLB_ACCESS; i++, m >>= 1) {
673 if (!(m & 0x1))
674 continue;
675 if (l) {
676 strcat(out, " or ");
677 l += 4;
678 }
679 strncat(out, tlb_access[i], sz - l);
680 l += strlen(tlb_access[i]);
681 }
682 if (*out == '\0')
683 strcpy(out, "N/A");
684 if (hit)
685 strncat(out, " hit", sz - l);
686 if (miss)
687 strncat(out, " miss", sz - l);
688
689 return repsep_snprintf(bf, size, "%-*s", width, out);
690 }
691
692 static int64_t
693 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
694 {
695 union perf_mem_data_src data_src_l;
696 union perf_mem_data_src data_src_r;
697
698 if (left->mem_info)
699 data_src_l = left->mem_info->data_src;
700 else
701 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
702
703 if (right->mem_info)
704 data_src_r = right->mem_info->data_src;
705 else
706 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
707
708 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
709 }
710
711 static const char * const mem_lvl[] = {
712 "N/A",
713 "HIT",
714 "MISS",
715 "L1",
716 "LFB",
717 "L2",
718 "L3",
719 "Local RAM",
720 "Remote RAM (1 hop)",
721 "Remote RAM (2 hops)",
722 "Remote Cache (1 hop)",
723 "Remote Cache (2 hops)",
724 "I/O",
725 "Uncached",
726 };
727 #define NUM_MEM_LVL (sizeof(mem_lvl)/sizeof(const char *))
728
729 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
730 size_t size, unsigned int width)
731 {
732 char out[64];
733 size_t sz = sizeof(out) - 1; /* -1 for null termination */
734 size_t i, l = 0;
735 u64 m = PERF_MEM_LVL_NA;
736 u64 hit, miss;
737
738 if (he->mem_info)
739 m = he->mem_info->data_src.mem_lvl;
740
741 out[0] = '\0';
742
743 hit = m & PERF_MEM_LVL_HIT;
744 miss = m & PERF_MEM_LVL_MISS;
745
746 /* already taken care of */
747 m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
748
749 for (i = 0; m && i < NUM_MEM_LVL; i++, m >>= 1) {
750 if (!(m & 0x1))
751 continue;
752 if (l) {
753 strcat(out, " or ");
754 l += 4;
755 }
756 strncat(out, mem_lvl[i], sz - l);
757 l += strlen(mem_lvl[i]);
758 }
759 if (*out == '\0')
760 strcpy(out, "N/A");
761 if (hit)
762 strncat(out, " hit", sz - l);
763 if (miss)
764 strncat(out, " miss", sz - l);
765
766 return repsep_snprintf(bf, size, "%-*s", width, out);
767 }
768
769 static int64_t
770 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
771 {
772 union perf_mem_data_src data_src_l;
773 union perf_mem_data_src data_src_r;
774
775 if (left->mem_info)
776 data_src_l = left->mem_info->data_src;
777 else
778 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
779
780 if (right->mem_info)
781 data_src_r = right->mem_info->data_src;
782 else
783 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
784
785 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
786 }
787
788 static const char * const snoop_access[] = {
789 "N/A",
790 "None",
791 "Miss",
792 "Hit",
793 "HitM",
794 };
795 #define NUM_SNOOP_ACCESS (sizeof(snoop_access)/sizeof(const char *))
796
797 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
798 size_t size, unsigned int width)
799 {
800 char out[64];
801 size_t sz = sizeof(out) - 1; /* -1 for null termination */
802 size_t i, l = 0;
803 u64 m = PERF_MEM_SNOOP_NA;
804
805 out[0] = '\0';
806
807 if (he->mem_info)
808 m = he->mem_info->data_src.mem_snoop;
809
810 for (i = 0; m && i < NUM_SNOOP_ACCESS; i++, m >>= 1) {
811 if (!(m & 0x1))
812 continue;
813 if (l) {
814 strcat(out, " or ");
815 l += 4;
816 }
817 strncat(out, snoop_access[i], sz - l);
818 l += strlen(snoop_access[i]);
819 }
820
821 if (*out == '\0')
822 strcpy(out, "N/A");
823
824 return repsep_snprintf(bf, size, "%-*s", width, out);
825 }
826
827 static inline u64 cl_address(u64 address)
828 {
829 /* return the cacheline of the address */
830 return (address & ~(cacheline_size - 1));
831 }
832
833 static int64_t
834 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
835 {
836 u64 l, r;
837 struct map *l_map, *r_map;
838
839 if (!left->mem_info) return -1;
840 if (!right->mem_info) return 1;
841
842 /* group event types together */
843 if (left->cpumode > right->cpumode) return -1;
844 if (left->cpumode < right->cpumode) return 1;
845
846 l_map = left->mem_info->daddr.map;
847 r_map = right->mem_info->daddr.map;
848
849 /* if both are NULL, jump to sort on al_addr instead */
850 if (!l_map && !r_map)
851 goto addr;
852
853 if (!l_map) return -1;
854 if (!r_map) return 1;
855
856 if (l_map->maj > r_map->maj) return -1;
857 if (l_map->maj < r_map->maj) return 1;
858
859 if (l_map->min > r_map->min) return -1;
860 if (l_map->min < r_map->min) return 1;
861
862 if (l_map->ino > r_map->ino) return -1;
863 if (l_map->ino < r_map->ino) return 1;
864
865 if (l_map->ino_generation > r_map->ino_generation) return -1;
866 if (l_map->ino_generation < r_map->ino_generation) return 1;
867
868 /*
869 * Addresses with no major/minor numbers are assumed to be
870 * anonymous in userspace. Sort those on pid then address.
871 *
872 * The kernel and non-zero major/minor mapped areas are
873 * assumed to be unity mapped. Sort those on address.
874 */
875
876 if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
877 (!(l_map->flags & MAP_SHARED)) &&
878 !l_map->maj && !l_map->min && !l_map->ino &&
879 !l_map->ino_generation) {
880 /* userspace anonymous */
881
882 if (left->thread->pid_ > right->thread->pid_) return -1;
883 if (left->thread->pid_ < right->thread->pid_) return 1;
884 }
885
886 addr:
887 /* al_addr does all the right addr - start + offset calculations */
888 l = cl_address(left->mem_info->daddr.al_addr);
889 r = cl_address(right->mem_info->daddr.al_addr);
890
891 if (l > r) return -1;
892 if (l < r) return 1;
893
894 return 0;
895 }
896
897 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
898 size_t size, unsigned int width)
899 {
900
901 uint64_t addr = 0;
902 struct map *map = NULL;
903 struct symbol *sym = NULL;
904 char level = he->level;
905
906 if (he->mem_info) {
907 addr = cl_address(he->mem_info->daddr.al_addr);
908 map = he->mem_info->daddr.map;
909 sym = he->mem_info->daddr.sym;
910
911 /* print [s] for shared data mmaps */
912 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
913 map && (map->type == MAP__VARIABLE) &&
914 (map->flags & MAP_SHARED) &&
915 (map->maj || map->min || map->ino ||
916 map->ino_generation))
917 level = 's';
918 else if (!map)
919 level = 'X';
920 }
921 return _hist_entry__sym_snprintf(map, sym, addr, level, bf, size,
922 width);
923 }
924
925 struct sort_entry sort_mispredict = {
926 .se_header = "Branch Mispredicted",
927 .se_cmp = sort__mispredict_cmp,
928 .se_snprintf = hist_entry__mispredict_snprintf,
929 .se_width_idx = HISTC_MISPREDICT,
930 };
931
932 static u64 he_weight(struct hist_entry *he)
933 {
934 return he->stat.nr_events ? he->stat.weight / he->stat.nr_events : 0;
935 }
936
937 static int64_t
938 sort__local_weight_cmp(struct hist_entry *left, struct hist_entry *right)
939 {
940 return he_weight(left) - he_weight(right);
941 }
942
943 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
944 size_t size, unsigned int width)
945 {
946 return repsep_snprintf(bf, size, "%-*llu", width, he_weight(he));
947 }
948
949 struct sort_entry sort_local_weight = {
950 .se_header = "Local Weight",
951 .se_cmp = sort__local_weight_cmp,
952 .se_snprintf = hist_entry__local_weight_snprintf,
953 .se_width_idx = HISTC_LOCAL_WEIGHT,
954 };
955
956 static int64_t
957 sort__global_weight_cmp(struct hist_entry *left, struct hist_entry *right)
958 {
959 return left->stat.weight - right->stat.weight;
960 }
961
962 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
963 size_t size, unsigned int width)
964 {
965 return repsep_snprintf(bf, size, "%-*llu", width, he->stat.weight);
966 }
967
968 struct sort_entry sort_global_weight = {
969 .se_header = "Weight",
970 .se_cmp = sort__global_weight_cmp,
971 .se_snprintf = hist_entry__global_weight_snprintf,
972 .se_width_idx = HISTC_GLOBAL_WEIGHT,
973 };
974
975 struct sort_entry sort_mem_daddr_sym = {
976 .se_header = "Data Symbol",
977 .se_cmp = sort__daddr_cmp,
978 .se_snprintf = hist_entry__daddr_snprintf,
979 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
980 };
981
982 struct sort_entry sort_mem_daddr_dso = {
983 .se_header = "Data Object",
984 .se_cmp = sort__dso_daddr_cmp,
985 .se_snprintf = hist_entry__dso_daddr_snprintf,
986 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
987 };
988
989 struct sort_entry sort_mem_locked = {
990 .se_header = "Locked",
991 .se_cmp = sort__locked_cmp,
992 .se_snprintf = hist_entry__locked_snprintf,
993 .se_width_idx = HISTC_MEM_LOCKED,
994 };
995
996 struct sort_entry sort_mem_tlb = {
997 .se_header = "TLB access",
998 .se_cmp = sort__tlb_cmp,
999 .se_snprintf = hist_entry__tlb_snprintf,
1000 .se_width_idx = HISTC_MEM_TLB,
1001 };
1002
1003 struct sort_entry sort_mem_lvl = {
1004 .se_header = "Memory access",
1005 .se_cmp = sort__lvl_cmp,
1006 .se_snprintf = hist_entry__lvl_snprintf,
1007 .se_width_idx = HISTC_MEM_LVL,
1008 };
1009
1010 struct sort_entry sort_mem_snoop = {
1011 .se_header = "Snoop",
1012 .se_cmp = sort__snoop_cmp,
1013 .se_snprintf = hist_entry__snoop_snprintf,
1014 .se_width_idx = HISTC_MEM_SNOOP,
1015 };
1016
1017 struct sort_entry sort_mem_dcacheline = {
1018 .se_header = "Data Cacheline",
1019 .se_cmp = sort__dcacheline_cmp,
1020 .se_snprintf = hist_entry__dcacheline_snprintf,
1021 .se_width_idx = HISTC_MEM_DCACHELINE,
1022 };
1023
1024 static int64_t
1025 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1026 {
1027 if (!left->branch_info || !right->branch_info)
1028 return cmp_null(left->branch_info, right->branch_info);
1029
1030 return left->branch_info->flags.abort !=
1031 right->branch_info->flags.abort;
1032 }
1033
1034 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1035 size_t size, unsigned int width)
1036 {
1037 static const char *out = "N/A";
1038
1039 if (he->branch_info) {
1040 if (he->branch_info->flags.abort)
1041 out = "A";
1042 else
1043 out = ".";
1044 }
1045
1046 return repsep_snprintf(bf, size, "%-*s", width, out);
1047 }
1048
1049 struct sort_entry sort_abort = {
1050 .se_header = "Transaction abort",
1051 .se_cmp = sort__abort_cmp,
1052 .se_snprintf = hist_entry__abort_snprintf,
1053 .se_width_idx = HISTC_ABORT,
1054 };
1055
1056 static int64_t
1057 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1058 {
1059 if (!left->branch_info || !right->branch_info)
1060 return cmp_null(left->branch_info, right->branch_info);
1061
1062 return left->branch_info->flags.in_tx !=
1063 right->branch_info->flags.in_tx;
1064 }
1065
1066 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1067 size_t size, unsigned int width)
1068 {
1069 static const char *out = "N/A";
1070
1071 if (he->branch_info) {
1072 if (he->branch_info->flags.in_tx)
1073 out = "T";
1074 else
1075 out = ".";
1076 }
1077
1078 return repsep_snprintf(bf, size, "%-*s", width, out);
1079 }
1080
1081 struct sort_entry sort_in_tx = {
1082 .se_header = "Branch in transaction",
1083 .se_cmp = sort__in_tx_cmp,
1084 .se_snprintf = hist_entry__in_tx_snprintf,
1085 .se_width_idx = HISTC_IN_TX,
1086 };
1087
1088 static int64_t
1089 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1090 {
1091 return left->transaction - right->transaction;
1092 }
1093
1094 static inline char *add_str(char *p, const char *str)
1095 {
1096 strcpy(p, str);
1097 return p + strlen(str);
1098 }
1099
1100 static struct txbit {
1101 unsigned flag;
1102 const char *name;
1103 int skip_for_len;
1104 } txbits[] = {
1105 { PERF_TXN_ELISION, "EL ", 0 },
1106 { PERF_TXN_TRANSACTION, "TX ", 1 },
1107 { PERF_TXN_SYNC, "SYNC ", 1 },
1108 { PERF_TXN_ASYNC, "ASYNC ", 0 },
1109 { PERF_TXN_RETRY, "RETRY ", 0 },
1110 { PERF_TXN_CONFLICT, "CON ", 0 },
1111 { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1112 { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
1113 { 0, NULL, 0 }
1114 };
1115
1116 int hist_entry__transaction_len(void)
1117 {
1118 int i;
1119 int len = 0;
1120
1121 for (i = 0; txbits[i].name; i++) {
1122 if (!txbits[i].skip_for_len)
1123 len += strlen(txbits[i].name);
1124 }
1125 len += 4; /* :XX<space> */
1126 return len;
1127 }
1128
1129 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1130 size_t size, unsigned int width)
1131 {
1132 u64 t = he->transaction;
1133 char buf[128];
1134 char *p = buf;
1135 int i;
1136
1137 buf[0] = 0;
1138 for (i = 0; txbits[i].name; i++)
1139 if (txbits[i].flag & t)
1140 p = add_str(p, txbits[i].name);
1141 if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1142 p = add_str(p, "NEITHER ");
1143 if (t & PERF_TXN_ABORT_MASK) {
1144 sprintf(p, ":%" PRIx64,
1145 (t & PERF_TXN_ABORT_MASK) >>
1146 PERF_TXN_ABORT_SHIFT);
1147 p += strlen(p);
1148 }
1149
1150 return repsep_snprintf(bf, size, "%-*s", width, buf);
1151 }
1152
1153 struct sort_entry sort_transaction = {
1154 .se_header = "Transaction ",
1155 .se_cmp = sort__transaction_cmp,
1156 .se_snprintf = hist_entry__transaction_snprintf,
1157 .se_width_idx = HISTC_TRANSACTION,
1158 };
1159
1160 struct sort_dimension {
1161 const char *name;
1162 struct sort_entry *entry;
1163 int taken;
1164 };
1165
1166 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1167
1168 static struct sort_dimension common_sort_dimensions[] = {
1169 DIM(SORT_PID, "pid", sort_thread),
1170 DIM(SORT_COMM, "comm", sort_comm),
1171 DIM(SORT_DSO, "dso", sort_dso),
1172 DIM(SORT_SYM, "symbol", sort_sym),
1173 DIM(SORT_PARENT, "parent", sort_parent),
1174 DIM(SORT_CPU, "cpu", sort_cpu),
1175 DIM(SORT_SRCLINE, "srcline", sort_srcline),
1176 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1177 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1178 DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1179 };
1180
1181 #undef DIM
1182
1183 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
1184
1185 static struct sort_dimension bstack_sort_dimensions[] = {
1186 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
1187 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
1188 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
1189 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
1190 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
1191 DIM(SORT_IN_TX, "in_tx", sort_in_tx),
1192 DIM(SORT_ABORT, "abort", sort_abort),
1193 };
1194
1195 #undef DIM
1196
1197 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
1198
1199 static struct sort_dimension memory_sort_dimensions[] = {
1200 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
1201 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
1202 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
1203 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
1204 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
1205 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
1206 DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
1207 };
1208
1209 #undef DIM
1210
1211 struct hpp_dimension {
1212 const char *name;
1213 struct perf_hpp_fmt *fmt;
1214 int taken;
1215 };
1216
1217 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
1218
1219 static struct hpp_dimension hpp_sort_dimensions[] = {
1220 DIM(PERF_HPP__OVERHEAD, "overhead"),
1221 DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
1222 DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
1223 DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
1224 DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
1225 DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
1226 DIM(PERF_HPP__SAMPLES, "sample"),
1227 DIM(PERF_HPP__PERIOD, "period"),
1228 };
1229
1230 #undef DIM
1231
1232 struct hpp_sort_entry {
1233 struct perf_hpp_fmt hpp;
1234 struct sort_entry *se;
1235 };
1236
1237 bool perf_hpp__same_sort_entry(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
1238 {
1239 struct hpp_sort_entry *hse_a;
1240 struct hpp_sort_entry *hse_b;
1241
1242 if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
1243 return false;
1244
1245 hse_a = container_of(a, struct hpp_sort_entry, hpp);
1246 hse_b = container_of(b, struct hpp_sort_entry, hpp);
1247
1248 return hse_a->se == hse_b->se;
1249 }
1250
1251 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
1252 {
1253 struct hpp_sort_entry *hse;
1254
1255 if (!perf_hpp__is_sort_entry(fmt))
1256 return;
1257
1258 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1259 hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
1260 }
1261
1262 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1263 struct perf_evsel *evsel)
1264 {
1265 struct hpp_sort_entry *hse;
1266 size_t len = fmt->user_len;
1267
1268 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1269
1270 if (!len)
1271 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1272
1273 return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
1274 }
1275
1276 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
1277 struct perf_hpp *hpp __maybe_unused,
1278 struct perf_evsel *evsel)
1279 {
1280 struct hpp_sort_entry *hse;
1281 size_t len = fmt->user_len;
1282
1283 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1284
1285 if (!len)
1286 len = hists__col_len(evsel__hists(evsel), hse->se->se_width_idx);
1287
1288 return len;
1289 }
1290
1291 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
1292 struct hist_entry *he)
1293 {
1294 struct hpp_sort_entry *hse;
1295 size_t len = fmt->user_len;
1296
1297 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1298
1299 if (!len)
1300 len = hists__col_len(he->hists, hse->se->se_width_idx);
1301
1302 return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
1303 }
1304
1305 static struct hpp_sort_entry *
1306 __sort_dimension__alloc_hpp(struct sort_dimension *sd)
1307 {
1308 struct hpp_sort_entry *hse;
1309
1310 hse = malloc(sizeof(*hse));
1311 if (hse == NULL) {
1312 pr_err("Memory allocation failed\n");
1313 return NULL;
1314 }
1315
1316 hse->se = sd->entry;
1317 hse->hpp.name = sd->entry->se_header;
1318 hse->hpp.header = __sort__hpp_header;
1319 hse->hpp.width = __sort__hpp_width;
1320 hse->hpp.entry = __sort__hpp_entry;
1321 hse->hpp.color = NULL;
1322
1323 hse->hpp.cmp = sd->entry->se_cmp;
1324 hse->hpp.collapse = sd->entry->se_collapse ? : sd->entry->se_cmp;
1325 hse->hpp.sort = sd->entry->se_sort ? : hse->hpp.collapse;
1326
1327 INIT_LIST_HEAD(&hse->hpp.list);
1328 INIT_LIST_HEAD(&hse->hpp.sort_list);
1329 hse->hpp.elide = false;
1330 hse->hpp.len = 0;
1331 hse->hpp.user_len = 0;
1332
1333 return hse;
1334 }
1335
1336 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
1337 {
1338 return format->header == __sort__hpp_header;
1339 }
1340
1341 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd)
1342 {
1343 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1344
1345 if (hse == NULL)
1346 return -1;
1347
1348 perf_hpp__register_sort_field(&hse->hpp);
1349 return 0;
1350 }
1351
1352 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd)
1353 {
1354 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd);
1355
1356 if (hse == NULL)
1357 return -1;
1358
1359 perf_hpp__column_register(&hse->hpp);
1360 return 0;
1361 }
1362
1363 static int __sort_dimension__add(struct sort_dimension *sd)
1364 {
1365 if (sd->taken)
1366 return 0;
1367
1368 if (__sort_dimension__add_hpp_sort(sd) < 0)
1369 return -1;
1370
1371 if (sd->entry->se_collapse)
1372 sort__need_collapse = 1;
1373
1374 sd->taken = 1;
1375
1376 return 0;
1377 }
1378
1379 static int __hpp_dimension__add(struct hpp_dimension *hd)
1380 {
1381 if (!hd->taken) {
1382 hd->taken = 1;
1383
1384 perf_hpp__register_sort_field(hd->fmt);
1385 }
1386 return 0;
1387 }
1388
1389 static int __sort_dimension__add_output(struct sort_dimension *sd)
1390 {
1391 if (sd->taken)
1392 return 0;
1393
1394 if (__sort_dimension__add_hpp_output(sd) < 0)
1395 return -1;
1396
1397 sd->taken = 1;
1398 return 0;
1399 }
1400
1401 static int __hpp_dimension__add_output(struct hpp_dimension *hd)
1402 {
1403 if (!hd->taken) {
1404 hd->taken = 1;
1405
1406 perf_hpp__column_register(hd->fmt);
1407 }
1408 return 0;
1409 }
1410
1411 int sort_dimension__add(const char *tok)
1412 {
1413 unsigned int i;
1414
1415 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1416 struct sort_dimension *sd = &common_sort_dimensions[i];
1417
1418 if (strncasecmp(tok, sd->name, strlen(tok)))
1419 continue;
1420
1421 if (sd->entry == &sort_parent) {
1422 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
1423 if (ret) {
1424 char err[BUFSIZ];
1425
1426 regerror(ret, &parent_regex, err, sizeof(err));
1427 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
1428 return -EINVAL;
1429 }
1430 sort__has_parent = 1;
1431 } else if (sd->entry == &sort_sym) {
1432 sort__has_sym = 1;
1433 } else if (sd->entry == &sort_dso) {
1434 sort__has_dso = 1;
1435 }
1436
1437 return __sort_dimension__add(sd);
1438 }
1439
1440 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1441 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1442
1443 if (strncasecmp(tok, hd->name, strlen(tok)))
1444 continue;
1445
1446 return __hpp_dimension__add(hd);
1447 }
1448
1449 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1450 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1451
1452 if (strncasecmp(tok, sd->name, strlen(tok)))
1453 continue;
1454
1455 if (sort__mode != SORT_MODE__BRANCH)
1456 return -EINVAL;
1457
1458 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
1459 sort__has_sym = 1;
1460
1461 __sort_dimension__add(sd);
1462 return 0;
1463 }
1464
1465 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1466 struct sort_dimension *sd = &memory_sort_dimensions[i];
1467
1468 if (strncasecmp(tok, sd->name, strlen(tok)))
1469 continue;
1470
1471 if (sort__mode != SORT_MODE__MEMORY)
1472 return -EINVAL;
1473
1474 if (sd->entry == &sort_mem_daddr_sym)
1475 sort__has_sym = 1;
1476
1477 __sort_dimension__add(sd);
1478 return 0;
1479 }
1480
1481 return -ESRCH;
1482 }
1483
1484 static const char *get_default_sort_order(void)
1485 {
1486 const char *default_sort_orders[] = {
1487 default_sort_order,
1488 default_branch_sort_order,
1489 default_mem_sort_order,
1490 default_top_sort_order,
1491 default_diff_sort_order,
1492 };
1493
1494 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
1495
1496 return default_sort_orders[sort__mode];
1497 }
1498
1499 static int setup_sort_order(void)
1500 {
1501 char *new_sort_order;
1502
1503 /*
1504 * Append '+'-prefixed sort order to the default sort
1505 * order string.
1506 */
1507 if (!sort_order || is_strict_order(sort_order))
1508 return 0;
1509
1510 if (sort_order[1] == '\0') {
1511 error("Invalid --sort key: `+'");
1512 return -EINVAL;
1513 }
1514
1515 /*
1516 * We allocate new sort_order string, but we never free it,
1517 * because it's checked over the rest of the code.
1518 */
1519 if (asprintf(&new_sort_order, "%s,%s",
1520 get_default_sort_order(), sort_order + 1) < 0) {
1521 error("Not enough memory to set up --sort");
1522 return -ENOMEM;
1523 }
1524
1525 sort_order = new_sort_order;
1526 return 0;
1527 }
1528
1529 static int __setup_sorting(void)
1530 {
1531 char *tmp, *tok, *str;
1532 const char *sort_keys;
1533 int ret = 0;
1534
1535 ret = setup_sort_order();
1536 if (ret)
1537 return ret;
1538
1539 sort_keys = sort_order;
1540 if (sort_keys == NULL) {
1541 if (is_strict_order(field_order)) {
1542 /*
1543 * If user specified field order but no sort order,
1544 * we'll honor it and not add default sort orders.
1545 */
1546 return 0;
1547 }
1548
1549 sort_keys = get_default_sort_order();
1550 }
1551
1552 str = strdup(sort_keys);
1553 if (str == NULL) {
1554 error("Not enough memory to setup sort keys");
1555 return -ENOMEM;
1556 }
1557
1558 for (tok = strtok_r(str, ", ", &tmp);
1559 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1560 ret = sort_dimension__add(tok);
1561 if (ret == -EINVAL) {
1562 error("Invalid --sort key: `%s'", tok);
1563 break;
1564 } else if (ret == -ESRCH) {
1565 error("Unknown --sort key: `%s'", tok);
1566 break;
1567 }
1568 }
1569
1570 free(str);
1571 return ret;
1572 }
1573
1574 void perf_hpp__set_elide(int idx, bool elide)
1575 {
1576 struct perf_hpp_fmt *fmt;
1577 struct hpp_sort_entry *hse;
1578
1579 perf_hpp__for_each_format(fmt) {
1580 if (!perf_hpp__is_sort_entry(fmt))
1581 continue;
1582
1583 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1584 if (hse->se->se_width_idx == idx) {
1585 fmt->elide = elide;
1586 break;
1587 }
1588 }
1589 }
1590
1591 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
1592 {
1593 if (list && strlist__nr_entries(list) == 1) {
1594 if (fp != NULL)
1595 fprintf(fp, "# %s: %s\n", list_name,
1596 strlist__entry(list, 0)->s);
1597 return true;
1598 }
1599 return false;
1600 }
1601
1602 static bool get_elide(int idx, FILE *output)
1603 {
1604 switch (idx) {
1605 case HISTC_SYMBOL:
1606 return __get_elide(symbol_conf.sym_list, "symbol", output);
1607 case HISTC_DSO:
1608 return __get_elide(symbol_conf.dso_list, "dso", output);
1609 case HISTC_COMM:
1610 return __get_elide(symbol_conf.comm_list, "comm", output);
1611 default:
1612 break;
1613 }
1614
1615 if (sort__mode != SORT_MODE__BRANCH)
1616 return false;
1617
1618 switch (idx) {
1619 case HISTC_SYMBOL_FROM:
1620 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
1621 case HISTC_SYMBOL_TO:
1622 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
1623 case HISTC_DSO_FROM:
1624 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
1625 case HISTC_DSO_TO:
1626 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
1627 default:
1628 break;
1629 }
1630
1631 return false;
1632 }
1633
1634 void sort__setup_elide(FILE *output)
1635 {
1636 struct perf_hpp_fmt *fmt;
1637 struct hpp_sort_entry *hse;
1638
1639 perf_hpp__for_each_format(fmt) {
1640 if (!perf_hpp__is_sort_entry(fmt))
1641 continue;
1642
1643 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1644 fmt->elide = get_elide(hse->se->se_width_idx, output);
1645 }
1646
1647 /*
1648 * It makes no sense to elide all of sort entries.
1649 * Just revert them to show up again.
1650 */
1651 perf_hpp__for_each_format(fmt) {
1652 if (!perf_hpp__is_sort_entry(fmt))
1653 continue;
1654
1655 if (!fmt->elide)
1656 return;
1657 }
1658
1659 perf_hpp__for_each_format(fmt) {
1660 if (!perf_hpp__is_sort_entry(fmt))
1661 continue;
1662
1663 fmt->elide = false;
1664 }
1665 }
1666
1667 static int output_field_add(char *tok)
1668 {
1669 unsigned int i;
1670
1671 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
1672 struct sort_dimension *sd = &common_sort_dimensions[i];
1673
1674 if (strncasecmp(tok, sd->name, strlen(tok)))
1675 continue;
1676
1677 return __sort_dimension__add_output(sd);
1678 }
1679
1680 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
1681 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
1682
1683 if (strncasecmp(tok, hd->name, strlen(tok)))
1684 continue;
1685
1686 return __hpp_dimension__add_output(hd);
1687 }
1688
1689 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
1690 struct sort_dimension *sd = &bstack_sort_dimensions[i];
1691
1692 if (strncasecmp(tok, sd->name, strlen(tok)))
1693 continue;
1694
1695 return __sort_dimension__add_output(sd);
1696 }
1697
1698 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
1699 struct sort_dimension *sd = &memory_sort_dimensions[i];
1700
1701 if (strncasecmp(tok, sd->name, strlen(tok)))
1702 continue;
1703
1704 return __sort_dimension__add_output(sd);
1705 }
1706
1707 return -ESRCH;
1708 }
1709
1710 static void reset_dimensions(void)
1711 {
1712 unsigned int i;
1713
1714 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
1715 common_sort_dimensions[i].taken = 0;
1716
1717 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
1718 hpp_sort_dimensions[i].taken = 0;
1719
1720 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
1721 bstack_sort_dimensions[i].taken = 0;
1722
1723 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
1724 memory_sort_dimensions[i].taken = 0;
1725 }
1726
1727 bool is_strict_order(const char *order)
1728 {
1729 return order && (*order != '+');
1730 }
1731
1732 static int __setup_output_field(void)
1733 {
1734 char *tmp, *tok, *str, *strp;
1735 int ret = -EINVAL;
1736
1737 if (field_order == NULL)
1738 return 0;
1739
1740 reset_dimensions();
1741
1742 strp = str = strdup(field_order);
1743 if (str == NULL) {
1744 error("Not enough memory to setup output fields");
1745 return -ENOMEM;
1746 }
1747
1748 if (!is_strict_order(field_order))
1749 strp++;
1750
1751 if (!strlen(strp)) {
1752 error("Invalid --fields key: `+'");
1753 goto out;
1754 }
1755
1756 for (tok = strtok_r(strp, ", ", &tmp);
1757 tok; tok = strtok_r(NULL, ", ", &tmp)) {
1758 ret = output_field_add(tok);
1759 if (ret == -EINVAL) {
1760 error("Invalid --fields key: `%s'", tok);
1761 break;
1762 } else if (ret == -ESRCH) {
1763 error("Unknown --fields key: `%s'", tok);
1764 break;
1765 }
1766 }
1767
1768 out:
1769 free(str);
1770 return ret;
1771 }
1772
1773 int setup_sorting(void)
1774 {
1775 int err;
1776
1777 err = __setup_sorting();
1778 if (err < 0)
1779 return err;
1780
1781 if (parent_pattern != default_parent_pattern) {
1782 err = sort_dimension__add("parent");
1783 if (err < 0)
1784 return err;
1785 }
1786
1787 reset_dimensions();
1788
1789 /*
1790 * perf diff doesn't use default hpp output fields.
1791 */
1792 if (sort__mode != SORT_MODE__DIFF)
1793 perf_hpp__init();
1794
1795 err = __setup_output_field();
1796 if (err < 0)
1797 return err;
1798
1799 /* copy sort keys to output fields */
1800 perf_hpp__setup_output_field();
1801 /* and then copy output fields to sort keys */
1802 perf_hpp__append_sort_keys();
1803
1804 return 0;
1805 }
1806
1807 void reset_output_field(void)
1808 {
1809 sort__need_collapse = 0;
1810 sort__has_parent = 0;
1811 sort__has_sym = 0;
1812 sort__has_dso = 0;
1813
1814 field_order = NULL;
1815 sort_order = NULL;
1816
1817 reset_dimensions();
1818 perf_hpp__reset_output_field();
1819 }
Linux kernel - Deliverables
This page took 0.133345 seconds and 5 git commands to generate.