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