1 // SPDX-License-Identifier: GPL-2.0
2 #include <errno.h>
3 #include <inttypes.h>
4 #include <regex.h>
5 #include <stdlib.h>
6 #include <linux/mman.h>
7 #include <linux/time64.h>
8 #include "debug.h"
9 #include "dso.h"
10 #include "sort.h"
11 #include "hist.h"
12 #include "cacheline.h"
13 #include "comm.h"
14 #include "map.h"
15 #include "maps.h"
16 #include "symbol.h"
17 #include "map_symbol.h"
18 #include "branch.h"
19 #include "thread.h"
20 #include "evsel.h"
21 #include "evlist.h"
22 #include "srcline.h"
23 #include "strlist.h"
24 #include "strbuf.h"
25 #include <traceevent/event-parse.h>
26 #include "mem-events.h"
27 #include "annotate.h"
28 #include "event.h"
29 #include "time-utils.h"
30 #include "cgroup.h"
31 #include "machine.h"
32 #include <linux/kernel.h>
33 #include <linux/string.h>
34 
35 regex_t		parent_regex;
36 const char	default_parent_pattern[] = "^sys_|^do_page_fault";
37 const char	*parent_pattern = default_parent_pattern;
38 const char	*default_sort_order = "comm,dso,symbol";
39 const char	default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
40 const char	default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked,blocked,local_ins_lat,local_p_stage_cyc";
41 const char	default_top_sort_order[] = "dso,symbol";
42 const char	default_diff_sort_order[] = "dso,symbol";
43 const char	default_tracepoint_sort_order[] = "trace";
44 const char	*sort_order;
45 const char	*field_order;
46 regex_t		ignore_callees_regex;
47 int		have_ignore_callees = 0;
48 enum sort_mode	sort__mode = SORT_MODE__NORMAL;
49 static const char *const dynamic_headers[] = {"local_ins_lat", "ins_lat", "local_p_stage_cyc", "p_stage_cyc"};
50 static const char *const arch_specific_sort_keys[] = {"local_p_stage_cyc", "p_stage_cyc"};
51 
52 /*
53  * Replaces all occurrences of a char used with the:
54  *
55  * -t, --field-separator
56  *
57  * option, that uses a special separator character and don't pad with spaces,
58  * replacing all occurrences of this separator in symbol names (and other
59  * output) with a '.' character, that thus it's the only non valid separator.
60 */
repsep_snprintf(char * bf,size_t size,const char * fmt,...)61 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
62 {
63 	int n;
64 	va_list ap;
65 
66 	va_start(ap, fmt);
67 	n = vsnprintf(bf, size, fmt, ap);
68 	if (symbol_conf.field_sep && n > 0) {
69 		char *sep = bf;
70 
71 		while (1) {
72 			sep = strchr(sep, *symbol_conf.field_sep);
73 			if (sep == NULL)
74 				break;
75 			*sep = '.';
76 		}
77 	}
78 	va_end(ap);
79 
80 	if (n >= (int)size)
81 		return size - 1;
82 	return n;
83 }
84 
cmp_null(const void * l,const void * r)85 static int64_t cmp_null(const void *l, const void *r)
86 {
87 	if (!l && !r)
88 		return 0;
89 	else if (!l)
90 		return -1;
91 	else
92 		return 1;
93 }
94 
95 /* --sort pid */
96 
97 static int64_t
sort__thread_cmp(struct hist_entry * left,struct hist_entry * right)98 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
99 {
100 	return right->thread->tid - left->thread->tid;
101 }
102 
hist_entry__thread_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)103 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
104 				       size_t size, unsigned int width)
105 {
106 	const char *comm = thread__comm_str(he->thread);
107 
108 	width = max(7U, width) - 8;
109 	return repsep_snprintf(bf, size, "%7d:%-*.*s", he->thread->tid,
110 			       width, width, comm ?: "");
111 }
112 
hist_entry__thread_filter(struct hist_entry * he,int type,const void * arg)113 static int hist_entry__thread_filter(struct hist_entry *he, int type, const void *arg)
114 {
115 	const struct thread *th = arg;
116 
117 	if (type != HIST_FILTER__THREAD)
118 		return -1;
119 
120 	return th && he->thread != th;
121 }
122 
123 struct sort_entry sort_thread = {
124 	.se_header	= "    Pid:Command",
125 	.se_cmp		= sort__thread_cmp,
126 	.se_snprintf	= hist_entry__thread_snprintf,
127 	.se_filter	= hist_entry__thread_filter,
128 	.se_width_idx	= HISTC_THREAD,
129 };
130 
131 /* --sort comm */
132 
133 /*
134  * We can't use pointer comparison in functions below,
135  * because it gives different results based on pointer
136  * values, which could break some sorting assumptions.
137  */
138 static int64_t
sort__comm_cmp(struct hist_entry * left,struct hist_entry * right)139 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
140 {
141 	return strcmp(comm__str(right->comm), comm__str(left->comm));
142 }
143 
144 static int64_t
sort__comm_collapse(struct hist_entry * left,struct hist_entry * right)145 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
146 {
147 	return strcmp(comm__str(right->comm), comm__str(left->comm));
148 }
149 
150 static int64_t
sort__comm_sort(struct hist_entry * left,struct hist_entry * right)151 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
152 {
153 	return strcmp(comm__str(right->comm), comm__str(left->comm));
154 }
155 
hist_entry__comm_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)156 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
157 				     size_t size, unsigned int width)
158 {
159 	return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
160 }
161 
162 struct sort_entry sort_comm = {
163 	.se_header	= "Command",
164 	.se_cmp		= sort__comm_cmp,
165 	.se_collapse	= sort__comm_collapse,
166 	.se_sort	= sort__comm_sort,
167 	.se_snprintf	= hist_entry__comm_snprintf,
168 	.se_filter	= hist_entry__thread_filter,
169 	.se_width_idx	= HISTC_COMM,
170 };
171 
172 /* --sort dso */
173 
_sort__dso_cmp(struct map * map_l,struct map * map_r)174 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
175 {
176 	struct dso *dso_l = map_l ? map_l->dso : NULL;
177 	struct dso *dso_r = map_r ? map_r->dso : NULL;
178 	const char *dso_name_l, *dso_name_r;
179 
180 	if (!dso_l || !dso_r)
181 		return cmp_null(dso_r, dso_l);
182 
183 	if (verbose > 0) {
184 		dso_name_l = dso_l->long_name;
185 		dso_name_r = dso_r->long_name;
186 	} else {
187 		dso_name_l = dso_l->short_name;
188 		dso_name_r = dso_r->short_name;
189 	}
190 
191 	return strcmp(dso_name_l, dso_name_r);
192 }
193 
194 static int64_t
sort__dso_cmp(struct hist_entry * left,struct hist_entry * right)195 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
196 {
197 	return _sort__dso_cmp(right->ms.map, left->ms.map);
198 }
199 
_hist_entry__dso_snprintf(struct map * map,char * bf,size_t size,unsigned int width)200 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
201 				     size_t size, unsigned int width)
202 {
203 	if (map && map->dso) {
204 		const char *dso_name = verbose > 0 ? map->dso->long_name :
205 			map->dso->short_name;
206 		return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
207 	}
208 
209 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "[unknown]");
210 }
211 
hist_entry__dso_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)212 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
213 				    size_t size, unsigned int width)
214 {
215 	return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
216 }
217 
hist_entry__dso_filter(struct hist_entry * he,int type,const void * arg)218 static int hist_entry__dso_filter(struct hist_entry *he, int type, const void *arg)
219 {
220 	const struct dso *dso = arg;
221 
222 	if (type != HIST_FILTER__DSO)
223 		return -1;
224 
225 	return dso && (!he->ms.map || he->ms.map->dso != dso);
226 }
227 
228 struct sort_entry sort_dso = {
229 	.se_header	= "Shared Object",
230 	.se_cmp		= sort__dso_cmp,
231 	.se_snprintf	= hist_entry__dso_snprintf,
232 	.se_filter	= hist_entry__dso_filter,
233 	.se_width_idx	= HISTC_DSO,
234 };
235 
236 /* --sort symbol */
237 
_sort__addr_cmp(u64 left_ip,u64 right_ip)238 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
239 {
240 	return (int64_t)(right_ip - left_ip);
241 }
242 
_sort__sym_cmp(struct symbol * sym_l,struct symbol * sym_r)243 int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
244 {
245 	if (!sym_l || !sym_r)
246 		return cmp_null(sym_l, sym_r);
247 
248 	if (sym_l == sym_r)
249 		return 0;
250 
251 	if (sym_l->inlined || sym_r->inlined) {
252 		int ret = strcmp(sym_l->name, sym_r->name);
253 
254 		if (ret)
255 			return ret;
256 		if ((sym_l->start <= sym_r->end) && (sym_l->end >= sym_r->start))
257 			return 0;
258 	}
259 
260 	if (sym_l->start != sym_r->start)
261 		return (int64_t)(sym_r->start - sym_l->start);
262 
263 	return (int64_t)(sym_r->end - sym_l->end);
264 }
265 
266 static int64_t
sort__sym_cmp(struct hist_entry * left,struct hist_entry * right)267 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
268 {
269 	int64_t ret;
270 
271 	if (!left->ms.sym && !right->ms.sym)
272 		return _sort__addr_cmp(left->ip, right->ip);
273 
274 	/*
275 	 * comparing symbol address alone is not enough since it's a
276 	 * relative address within a dso.
277 	 */
278 	if (!hists__has(left->hists, dso) || hists__has(right->hists, dso)) {
279 		ret = sort__dso_cmp(left, right);
280 		if (ret != 0)
281 			return ret;
282 	}
283 
284 	return _sort__sym_cmp(left->ms.sym, right->ms.sym);
285 }
286 
287 static int64_t
sort__sym_sort(struct hist_entry * left,struct hist_entry * right)288 sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
289 {
290 	if (!left->ms.sym || !right->ms.sym)
291 		return cmp_null(left->ms.sym, right->ms.sym);
292 
293 	return strcmp(right->ms.sym->name, left->ms.sym->name);
294 }
295 
_hist_entry__sym_snprintf(struct map_symbol * ms,u64 ip,char level,char * bf,size_t size,unsigned int width)296 static int _hist_entry__sym_snprintf(struct map_symbol *ms,
297 				     u64 ip, char level, char *bf, size_t size,
298 				     unsigned int width)
299 {
300 	struct symbol *sym = ms->sym;
301 	struct map *map = ms->map;
302 	size_t ret = 0;
303 
304 	if (verbose > 0) {
305 		char o = map ? dso__symtab_origin(map->dso) : '!';
306 		u64 rip = ip;
307 
308 		if (map && map->dso && map->dso->kernel
309 		    && map->dso->adjust_symbols)
310 			rip = map->unmap_ip(map, ip);
311 
312 		ret += repsep_snprintf(bf, size, "%-#*llx %c ",
313 				       BITS_PER_LONG / 4 + 2, rip, o);
314 	}
315 
316 	ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
317 	if (sym && map) {
318 		if (sym->type == STT_OBJECT) {
319 			ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
320 			ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
321 					ip - map->unmap_ip(map, sym->start));
322 		} else {
323 			ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
324 					       width - ret,
325 					       sym->name);
326 			if (sym->inlined)
327 				ret += repsep_snprintf(bf + ret, size - ret,
328 						       " (inlined)");
329 		}
330 	} else {
331 		size_t len = BITS_PER_LONG / 4;
332 		ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
333 				       len, ip);
334 	}
335 
336 	return ret;
337 }
338 
hist_entry__sym_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)339 int hist_entry__sym_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width)
340 {
341 	return _hist_entry__sym_snprintf(&he->ms, he->ip,
342 					 he->level, bf, size, width);
343 }
344 
hist_entry__sym_filter(struct hist_entry * he,int type,const void * arg)345 static int hist_entry__sym_filter(struct hist_entry *he, int type, const void *arg)
346 {
347 	const char *sym = arg;
348 
349 	if (type != HIST_FILTER__SYMBOL)
350 		return -1;
351 
352 	return sym && (!he->ms.sym || !strstr(he->ms.sym->name, sym));
353 }
354 
355 struct sort_entry sort_sym = {
356 	.se_header	= "Symbol",
357 	.se_cmp		= sort__sym_cmp,
358 	.se_sort	= sort__sym_sort,
359 	.se_snprintf	= hist_entry__sym_snprintf,
360 	.se_filter	= hist_entry__sym_filter,
361 	.se_width_idx	= HISTC_SYMBOL,
362 };
363 
364 /* --sort srcline */
365 
hist_entry__srcline(struct hist_entry * he)366 char *hist_entry__srcline(struct hist_entry *he)
367 {
368 	return map__srcline(he->ms.map, he->ip, he->ms.sym);
369 }
370 
371 static int64_t
sort__srcline_cmp(struct hist_entry * left,struct hist_entry * right)372 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
373 {
374 	if (!left->srcline)
375 		left->srcline = hist_entry__srcline(left);
376 	if (!right->srcline)
377 		right->srcline = hist_entry__srcline(right);
378 
379 	return strcmp(right->srcline, left->srcline);
380 }
381 
hist_entry__srcline_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)382 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
383 					size_t size, unsigned int width)
384 {
385 	if (!he->srcline)
386 		he->srcline = hist_entry__srcline(he);
387 
388 	return repsep_snprintf(bf, size, "%-.*s", width, he->srcline);
389 }
390 
391 struct sort_entry sort_srcline = {
392 	.se_header	= "Source:Line",
393 	.se_cmp		= sort__srcline_cmp,
394 	.se_snprintf	= hist_entry__srcline_snprintf,
395 	.se_width_idx	= HISTC_SRCLINE,
396 };
397 
398 /* --sort srcline_from */
399 
addr_map_symbol__srcline(struct addr_map_symbol * ams)400 static char *addr_map_symbol__srcline(struct addr_map_symbol *ams)
401 {
402 	return map__srcline(ams->ms.map, ams->al_addr, ams->ms.sym);
403 }
404 
405 static int64_t
sort__srcline_from_cmp(struct hist_entry * left,struct hist_entry * right)406 sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
407 {
408 	if (!left->branch_info->srcline_from)
409 		left->branch_info->srcline_from = addr_map_symbol__srcline(&left->branch_info->from);
410 
411 	if (!right->branch_info->srcline_from)
412 		right->branch_info->srcline_from = addr_map_symbol__srcline(&right->branch_info->from);
413 
414 	return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from);
415 }
416 
hist_entry__srcline_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)417 static int hist_entry__srcline_from_snprintf(struct hist_entry *he, char *bf,
418 					size_t size, unsigned int width)
419 {
420 	return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_from);
421 }
422 
423 struct sort_entry sort_srcline_from = {
424 	.se_header	= "From Source:Line",
425 	.se_cmp		= sort__srcline_from_cmp,
426 	.se_snprintf	= hist_entry__srcline_from_snprintf,
427 	.se_width_idx	= HISTC_SRCLINE_FROM,
428 };
429 
430 /* --sort srcline_to */
431 
432 static int64_t
sort__srcline_to_cmp(struct hist_entry * left,struct hist_entry * right)433 sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
434 {
435 	if (!left->branch_info->srcline_to)
436 		left->branch_info->srcline_to = addr_map_symbol__srcline(&left->branch_info->to);
437 
438 	if (!right->branch_info->srcline_to)
439 		right->branch_info->srcline_to = addr_map_symbol__srcline(&right->branch_info->to);
440 
441 	return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to);
442 }
443 
hist_entry__srcline_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)444 static int hist_entry__srcline_to_snprintf(struct hist_entry *he, char *bf,
445 					size_t size, unsigned int width)
446 {
447 	return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_to);
448 }
449 
450 struct sort_entry sort_srcline_to = {
451 	.se_header	= "To Source:Line",
452 	.se_cmp		= sort__srcline_to_cmp,
453 	.se_snprintf	= hist_entry__srcline_to_snprintf,
454 	.se_width_idx	= HISTC_SRCLINE_TO,
455 };
456 
hist_entry__sym_ipc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)457 static int hist_entry__sym_ipc_snprintf(struct hist_entry *he, char *bf,
458 					size_t size, unsigned int width)
459 {
460 
461 	struct symbol *sym = he->ms.sym;
462 	struct annotation *notes;
463 	double ipc = 0.0, coverage = 0.0;
464 	char tmp[64];
465 
466 	if (!sym)
467 		return repsep_snprintf(bf, size, "%-*s", width, "-");
468 
469 	notes = symbol__annotation(sym);
470 
471 	if (notes->hit_cycles)
472 		ipc = notes->hit_insn / ((double)notes->hit_cycles);
473 
474 	if (notes->total_insn) {
475 		coverage = notes->cover_insn * 100.0 /
476 			((double)notes->total_insn);
477 	}
478 
479 	snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);
480 	return repsep_snprintf(bf, size, "%-*s", width, tmp);
481 }
482 
483 struct sort_entry sort_sym_ipc = {
484 	.se_header	= "IPC   [IPC Coverage]",
485 	.se_cmp		= sort__sym_cmp,
486 	.se_snprintf	= hist_entry__sym_ipc_snprintf,
487 	.se_width_idx	= HISTC_SYMBOL_IPC,
488 };
489 
hist_entry__sym_ipc_null_snprintf(struct hist_entry * he __maybe_unused,char * bf,size_t size,unsigned int width)490 static int hist_entry__sym_ipc_null_snprintf(struct hist_entry *he
491 					     __maybe_unused,
492 					     char *bf, size_t size,
493 					     unsigned int width)
494 {
495 	char tmp[64];
496 
497 	snprintf(tmp, sizeof(tmp), "%-5s %2s", "-", "-");
498 	return repsep_snprintf(bf, size, "%-*s", width, tmp);
499 }
500 
501 struct sort_entry sort_sym_ipc_null = {
502 	.se_header	= "IPC   [IPC Coverage]",
503 	.se_cmp		= sort__sym_cmp,
504 	.se_snprintf	= hist_entry__sym_ipc_null_snprintf,
505 	.se_width_idx	= HISTC_SYMBOL_IPC,
506 };
507 
508 /* --sort srcfile */
509 
510 static char no_srcfile[1];
511 
hist_entry__get_srcfile(struct hist_entry * e)512 static char *hist_entry__get_srcfile(struct hist_entry *e)
513 {
514 	char *sf, *p;
515 	struct map *map = e->ms.map;
516 
517 	if (!map)
518 		return no_srcfile;
519 
520 	sf = __get_srcline(map->dso, map__rip_2objdump(map, e->ip),
521 			 e->ms.sym, false, true, true, e->ip);
522 	if (!strcmp(sf, SRCLINE_UNKNOWN))
523 		return no_srcfile;
524 	p = strchr(sf, ':');
525 	if (p && *sf) {
526 		*p = 0;
527 		return sf;
528 	}
529 	free(sf);
530 	return no_srcfile;
531 }
532 
533 static int64_t
sort__srcfile_cmp(struct hist_entry * left,struct hist_entry * right)534 sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
535 {
536 	if (!left->srcfile)
537 		left->srcfile = hist_entry__get_srcfile(left);
538 	if (!right->srcfile)
539 		right->srcfile = hist_entry__get_srcfile(right);
540 
541 	return strcmp(right->srcfile, left->srcfile);
542 }
543 
hist_entry__srcfile_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)544 static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
545 					size_t size, unsigned int width)
546 {
547 	if (!he->srcfile)
548 		he->srcfile = hist_entry__get_srcfile(he);
549 
550 	return repsep_snprintf(bf, size, "%-.*s", width, he->srcfile);
551 }
552 
553 struct sort_entry sort_srcfile = {
554 	.se_header	= "Source File",
555 	.se_cmp		= sort__srcfile_cmp,
556 	.se_snprintf	= hist_entry__srcfile_snprintf,
557 	.se_width_idx	= HISTC_SRCFILE,
558 };
559 
560 /* --sort parent */
561 
562 static int64_t
sort__parent_cmp(struct hist_entry * left,struct hist_entry * right)563 sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
564 {
565 	struct symbol *sym_l = left->parent;
566 	struct symbol *sym_r = right->parent;
567 
568 	if (!sym_l || !sym_r)
569 		return cmp_null(sym_l, sym_r);
570 
571 	return strcmp(sym_r->name, sym_l->name);
572 }
573 
hist_entry__parent_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)574 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
575 				       size_t size, unsigned int width)
576 {
577 	return repsep_snprintf(bf, size, "%-*.*s", width, width,
578 			      he->parent ? he->parent->name : "[other]");
579 }
580 
581 struct sort_entry sort_parent = {
582 	.se_header	= "Parent symbol",
583 	.se_cmp		= sort__parent_cmp,
584 	.se_snprintf	= hist_entry__parent_snprintf,
585 	.se_width_idx	= HISTC_PARENT,
586 };
587 
588 /* --sort cpu */
589 
590 static int64_t
sort__cpu_cmp(struct hist_entry * left,struct hist_entry * right)591 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
592 {
593 	return right->cpu - left->cpu;
594 }
595 
hist_entry__cpu_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)596 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
597 				    size_t size, unsigned int width)
598 {
599 	return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
600 }
601 
602 struct sort_entry sort_cpu = {
603 	.se_header      = "CPU",
604 	.se_cmp	        = sort__cpu_cmp,
605 	.se_snprintf    = hist_entry__cpu_snprintf,
606 	.se_width_idx	= HISTC_CPU,
607 };
608 
609 /* --sort cgroup_id */
610 
_sort__cgroup_dev_cmp(u64 left_dev,u64 right_dev)611 static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev)
612 {
613 	return (int64_t)(right_dev - left_dev);
614 }
615 
_sort__cgroup_inode_cmp(u64 left_ino,u64 right_ino)616 static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino)
617 {
618 	return (int64_t)(right_ino - left_ino);
619 }
620 
621 static int64_t
sort__cgroup_id_cmp(struct hist_entry * left,struct hist_entry * right)622 sort__cgroup_id_cmp(struct hist_entry *left, struct hist_entry *right)
623 {
624 	int64_t ret;
625 
626 	ret = _sort__cgroup_dev_cmp(right->cgroup_id.dev, left->cgroup_id.dev);
627 	if (ret != 0)
628 		return ret;
629 
630 	return _sort__cgroup_inode_cmp(right->cgroup_id.ino,
631 				       left->cgroup_id.ino);
632 }
633 
hist_entry__cgroup_id_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)634 static int hist_entry__cgroup_id_snprintf(struct hist_entry *he,
635 					  char *bf, size_t size,
636 					  unsigned int width __maybe_unused)
637 {
638 	return repsep_snprintf(bf, size, "%lu/0x%lx", he->cgroup_id.dev,
639 			       he->cgroup_id.ino);
640 }
641 
642 struct sort_entry sort_cgroup_id = {
643 	.se_header      = "cgroup id (dev/inode)",
644 	.se_cmp	        = sort__cgroup_id_cmp,
645 	.se_snprintf    = hist_entry__cgroup_id_snprintf,
646 	.se_width_idx	= HISTC_CGROUP_ID,
647 };
648 
649 /* --sort cgroup */
650 
651 static int64_t
sort__cgroup_cmp(struct hist_entry * left,struct hist_entry * right)652 sort__cgroup_cmp(struct hist_entry *left, struct hist_entry *right)
653 {
654 	return right->cgroup - left->cgroup;
655 }
656 
hist_entry__cgroup_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)657 static int hist_entry__cgroup_snprintf(struct hist_entry *he,
658 				       char *bf, size_t size,
659 				       unsigned int width __maybe_unused)
660 {
661 	const char *cgrp_name = "N/A";
662 
663 	if (he->cgroup) {
664 		struct cgroup *cgrp = cgroup__find(he->ms.maps->machine->env,
665 						   he->cgroup);
666 		if (cgrp != NULL)
667 			cgrp_name = cgrp->name;
668 		else
669 			cgrp_name = "unknown";
670 	}
671 
672 	return repsep_snprintf(bf, size, "%s", cgrp_name);
673 }
674 
675 struct sort_entry sort_cgroup = {
676 	.se_header      = "Cgroup",
677 	.se_cmp	        = sort__cgroup_cmp,
678 	.se_snprintf    = hist_entry__cgroup_snprintf,
679 	.se_width_idx	= HISTC_CGROUP,
680 };
681 
682 /* --sort socket */
683 
684 static int64_t
sort__socket_cmp(struct hist_entry * left,struct hist_entry * right)685 sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
686 {
687 	return right->socket - left->socket;
688 }
689 
hist_entry__socket_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)690 static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf,
691 				    size_t size, unsigned int width)
692 {
693 	return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket);
694 }
695 
hist_entry__socket_filter(struct hist_entry * he,int type,const void * arg)696 static int hist_entry__socket_filter(struct hist_entry *he, int type, const void *arg)
697 {
698 	int sk = *(const int *)arg;
699 
700 	if (type != HIST_FILTER__SOCKET)
701 		return -1;
702 
703 	return sk >= 0 && he->socket != sk;
704 }
705 
706 struct sort_entry sort_socket = {
707 	.se_header      = "Socket",
708 	.se_cmp	        = sort__socket_cmp,
709 	.se_snprintf    = hist_entry__socket_snprintf,
710 	.se_filter      = hist_entry__socket_filter,
711 	.se_width_idx	= HISTC_SOCKET,
712 };
713 
714 /* --sort time */
715 
716 static int64_t
sort__time_cmp(struct hist_entry * left,struct hist_entry * right)717 sort__time_cmp(struct hist_entry *left, struct hist_entry *right)
718 {
719 	return right->time - left->time;
720 }
721 
hist_entry__time_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)722 static int hist_entry__time_snprintf(struct hist_entry *he, char *bf,
723 				    size_t size, unsigned int width)
724 {
725 	char he_time[32];
726 
727 	if (symbol_conf.nanosecs)
728 		timestamp__scnprintf_nsec(he->time, he_time,
729 					  sizeof(he_time));
730 	else
731 		timestamp__scnprintf_usec(he->time, he_time,
732 					  sizeof(he_time));
733 
734 	return repsep_snprintf(bf, size, "%-.*s", width, he_time);
735 }
736 
737 struct sort_entry sort_time = {
738 	.se_header      = "Time",
739 	.se_cmp	        = sort__time_cmp,
740 	.se_snprintf    = hist_entry__time_snprintf,
741 	.se_width_idx	= HISTC_TIME,
742 };
743 
744 /* --sort trace */
745 
get_trace_output(struct hist_entry * he)746 static char *get_trace_output(struct hist_entry *he)
747 {
748 	struct trace_seq seq;
749 	struct evsel *evsel;
750 	struct tep_record rec = {
751 		.data = he->raw_data,
752 		.size = he->raw_size,
753 	};
754 
755 	evsel = hists_to_evsel(he->hists);
756 
757 	trace_seq_init(&seq);
758 	if (symbol_conf.raw_trace) {
759 		tep_print_fields(&seq, he->raw_data, he->raw_size,
760 				 evsel->tp_format);
761 	} else {
762 		tep_print_event(evsel->tp_format->tep,
763 				&seq, &rec, "%s", TEP_PRINT_INFO);
764 	}
765 	/*
766 	 * Trim the buffer, it starts at 4KB and we're not going to
767 	 * add anything more to this buffer.
768 	 */
769 	return realloc(seq.buffer, seq.len + 1);
770 }
771 
772 static int64_t
sort__trace_cmp(struct hist_entry * left,struct hist_entry * right)773 sort__trace_cmp(struct hist_entry *left, struct hist_entry *right)
774 {
775 	struct evsel *evsel;
776 
777 	evsel = hists_to_evsel(left->hists);
778 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
779 		return 0;
780 
781 	if (left->trace_output == NULL)
782 		left->trace_output = get_trace_output(left);
783 	if (right->trace_output == NULL)
784 		right->trace_output = get_trace_output(right);
785 
786 	return strcmp(right->trace_output, left->trace_output);
787 }
788 
hist_entry__trace_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)789 static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf,
790 				    size_t size, unsigned int width)
791 {
792 	struct evsel *evsel;
793 
794 	evsel = hists_to_evsel(he->hists);
795 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
796 		return scnprintf(bf, size, "%-.*s", width, "N/A");
797 
798 	if (he->trace_output == NULL)
799 		he->trace_output = get_trace_output(he);
800 	return repsep_snprintf(bf, size, "%-.*s", width, he->trace_output);
801 }
802 
803 struct sort_entry sort_trace = {
804 	.se_header      = "Trace output",
805 	.se_cmp	        = sort__trace_cmp,
806 	.se_snprintf    = hist_entry__trace_snprintf,
807 	.se_width_idx	= HISTC_TRACE,
808 };
809 
810 /* sort keys for branch stacks */
811 
812 static int64_t
sort__dso_from_cmp(struct hist_entry * left,struct hist_entry * right)813 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
814 {
815 	if (!left->branch_info || !right->branch_info)
816 		return cmp_null(left->branch_info, right->branch_info);
817 
818 	return _sort__dso_cmp(left->branch_info->from.ms.map,
819 			      right->branch_info->from.ms.map);
820 }
821 
hist_entry__dso_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)822 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
823 				    size_t size, unsigned int width)
824 {
825 	if (he->branch_info)
826 		return _hist_entry__dso_snprintf(he->branch_info->from.ms.map,
827 						 bf, size, width);
828 	else
829 		return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
830 }
831 
hist_entry__dso_from_filter(struct hist_entry * he,int type,const void * arg)832 static int hist_entry__dso_from_filter(struct hist_entry *he, int type,
833 				       const void *arg)
834 {
835 	const struct dso *dso = arg;
836 
837 	if (type != HIST_FILTER__DSO)
838 		return -1;
839 
840 	return dso && (!he->branch_info || !he->branch_info->from.ms.map ||
841 		       he->branch_info->from.ms.map->dso != dso);
842 }
843 
844 static int64_t
sort__dso_to_cmp(struct hist_entry * left,struct hist_entry * right)845 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
846 {
847 	if (!left->branch_info || !right->branch_info)
848 		return cmp_null(left->branch_info, right->branch_info);
849 
850 	return _sort__dso_cmp(left->branch_info->to.ms.map,
851 			      right->branch_info->to.ms.map);
852 }
853 
hist_entry__dso_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)854 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
855 				       size_t size, unsigned int width)
856 {
857 	if (he->branch_info)
858 		return _hist_entry__dso_snprintf(he->branch_info->to.ms.map,
859 						 bf, size, width);
860 	else
861 		return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
862 }
863 
hist_entry__dso_to_filter(struct hist_entry * he,int type,const void * arg)864 static int hist_entry__dso_to_filter(struct hist_entry *he, int type,
865 				     const void *arg)
866 {
867 	const struct dso *dso = arg;
868 
869 	if (type != HIST_FILTER__DSO)
870 		return -1;
871 
872 	return dso && (!he->branch_info || !he->branch_info->to.ms.map ||
873 		       he->branch_info->to.ms.map->dso != dso);
874 }
875 
876 static int64_t
sort__sym_from_cmp(struct hist_entry * left,struct hist_entry * right)877 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
878 {
879 	struct addr_map_symbol *from_l = &left->branch_info->from;
880 	struct addr_map_symbol *from_r = &right->branch_info->from;
881 
882 	if (!left->branch_info || !right->branch_info)
883 		return cmp_null(left->branch_info, right->branch_info);
884 
885 	from_l = &left->branch_info->from;
886 	from_r = &right->branch_info->from;
887 
888 	if (!from_l->ms.sym && !from_r->ms.sym)
889 		return _sort__addr_cmp(from_l->addr, from_r->addr);
890 
891 	return _sort__sym_cmp(from_l->ms.sym, from_r->ms.sym);
892 }
893 
894 static int64_t
sort__sym_to_cmp(struct hist_entry * left,struct hist_entry * right)895 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
896 {
897 	struct addr_map_symbol *to_l, *to_r;
898 
899 	if (!left->branch_info || !right->branch_info)
900 		return cmp_null(left->branch_info, right->branch_info);
901 
902 	to_l = &left->branch_info->to;
903 	to_r = &right->branch_info->to;
904 
905 	if (!to_l->ms.sym && !to_r->ms.sym)
906 		return _sort__addr_cmp(to_l->addr, to_r->addr);
907 
908 	return _sort__sym_cmp(to_l->ms.sym, to_r->ms.sym);
909 }
910 
hist_entry__sym_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)911 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
912 					 size_t size, unsigned int width)
913 {
914 	if (he->branch_info) {
915 		struct addr_map_symbol *from = &he->branch_info->from;
916 
917 		return _hist_entry__sym_snprintf(&from->ms, from->al_addr,
918 						 from->al_level, bf, size, width);
919 	}
920 
921 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
922 }
923 
hist_entry__sym_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)924 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
925 				       size_t size, unsigned int width)
926 {
927 	if (he->branch_info) {
928 		struct addr_map_symbol *to = &he->branch_info->to;
929 
930 		return _hist_entry__sym_snprintf(&to->ms, to->al_addr,
931 						 to->al_level, bf, size, width);
932 	}
933 
934 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
935 }
936 
hist_entry__sym_from_filter(struct hist_entry * he,int type,const void * arg)937 static int hist_entry__sym_from_filter(struct hist_entry *he, int type,
938 				       const void *arg)
939 {
940 	const char *sym = arg;
941 
942 	if (type != HIST_FILTER__SYMBOL)
943 		return -1;
944 
945 	return sym && !(he->branch_info && he->branch_info->from.ms.sym &&
946 			strstr(he->branch_info->from.ms.sym->name, sym));
947 }
948 
hist_entry__sym_to_filter(struct hist_entry * he,int type,const void * arg)949 static int hist_entry__sym_to_filter(struct hist_entry *he, int type,
950 				       const void *arg)
951 {
952 	const char *sym = arg;
953 
954 	if (type != HIST_FILTER__SYMBOL)
955 		return -1;
956 
957 	return sym && !(he->branch_info && he->branch_info->to.ms.sym &&
958 		        strstr(he->branch_info->to.ms.sym->name, sym));
959 }
960 
961 struct sort_entry sort_dso_from = {
962 	.se_header	= "Source Shared Object",
963 	.se_cmp		= sort__dso_from_cmp,
964 	.se_snprintf	= hist_entry__dso_from_snprintf,
965 	.se_filter	= hist_entry__dso_from_filter,
966 	.se_width_idx	= HISTC_DSO_FROM,
967 };
968 
969 struct sort_entry sort_dso_to = {
970 	.se_header	= "Target Shared Object",
971 	.se_cmp		= sort__dso_to_cmp,
972 	.se_snprintf	= hist_entry__dso_to_snprintf,
973 	.se_filter	= hist_entry__dso_to_filter,
974 	.se_width_idx	= HISTC_DSO_TO,
975 };
976 
977 struct sort_entry sort_sym_from = {
978 	.se_header	= "Source Symbol",
979 	.se_cmp		= sort__sym_from_cmp,
980 	.se_snprintf	= hist_entry__sym_from_snprintf,
981 	.se_filter	= hist_entry__sym_from_filter,
982 	.se_width_idx	= HISTC_SYMBOL_FROM,
983 };
984 
985 struct sort_entry sort_sym_to = {
986 	.se_header	= "Target Symbol",
987 	.se_cmp		= sort__sym_to_cmp,
988 	.se_snprintf	= hist_entry__sym_to_snprintf,
989 	.se_filter	= hist_entry__sym_to_filter,
990 	.se_width_idx	= HISTC_SYMBOL_TO,
991 };
992 
_hist_entry__addr_snprintf(struct map_symbol * ms,u64 ip,char level,char * bf,size_t size,unsigned int width)993 static int _hist_entry__addr_snprintf(struct map_symbol *ms,
994 				     u64 ip, char level, char *bf, size_t size,
995 				     unsigned int width)
996 {
997 	struct symbol *sym = ms->sym;
998 	struct map *map = ms->map;
999 	size_t ret = 0, offs;
1000 
1001 	ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
1002 	if (sym && map) {
1003 		if (sym->type == STT_OBJECT) {
1004 			ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
1005 			ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
1006 					ip - map->unmap_ip(map, sym->start));
1007 		} else {
1008 			ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
1009 					       width - ret,
1010 					       sym->name);
1011 			offs = ip - sym->start;
1012 			if (offs)
1013 				ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx", offs);
1014 		}
1015 	} else {
1016 		size_t len = BITS_PER_LONG / 4;
1017 		ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
1018 				       len, ip);
1019 	}
1020 
1021 	return ret;
1022 }
1023 
hist_entry__addr_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1024 static int hist_entry__addr_from_snprintf(struct hist_entry *he, char *bf,
1025 					 size_t size, unsigned int width)
1026 {
1027 	if (he->branch_info) {
1028 		struct addr_map_symbol *from = &he->branch_info->from;
1029 
1030 		return _hist_entry__addr_snprintf(&from->ms, from->al_addr,
1031 						 he->level, bf, size, width);
1032 	}
1033 
1034 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1035 }
1036 
hist_entry__addr_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1037 static int hist_entry__addr_to_snprintf(struct hist_entry *he, char *bf,
1038 				       size_t size, unsigned int width)
1039 {
1040 	if (he->branch_info) {
1041 		struct addr_map_symbol *to = &he->branch_info->to;
1042 
1043 		return _hist_entry__addr_snprintf(&to->ms, to->al_addr,
1044 						 he->level, bf, size, width);
1045 	}
1046 
1047 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1048 }
1049 
1050 static int64_t
sort__addr_from_cmp(struct hist_entry * left,struct hist_entry * right)1051 sort__addr_from_cmp(struct hist_entry *left, struct hist_entry *right)
1052 {
1053 	struct addr_map_symbol *from_l;
1054 	struct addr_map_symbol *from_r;
1055 	int64_t ret;
1056 
1057 	if (!left->branch_info || !right->branch_info)
1058 		return cmp_null(left->branch_info, right->branch_info);
1059 
1060 	from_l = &left->branch_info->from;
1061 	from_r = &right->branch_info->from;
1062 
1063 	/*
1064 	 * comparing symbol address alone is not enough since it's a
1065 	 * relative address within a dso.
1066 	 */
1067 	ret = _sort__dso_cmp(from_l->ms.map, from_r->ms.map);
1068 	if (ret != 0)
1069 		return ret;
1070 
1071 	return _sort__addr_cmp(from_l->addr, from_r->addr);
1072 }
1073 
1074 static int64_t
sort__addr_to_cmp(struct hist_entry * left,struct hist_entry * right)1075 sort__addr_to_cmp(struct hist_entry *left, struct hist_entry *right)
1076 {
1077 	struct addr_map_symbol *to_l;
1078 	struct addr_map_symbol *to_r;
1079 	int64_t ret;
1080 
1081 	if (!left->branch_info || !right->branch_info)
1082 		return cmp_null(left->branch_info, right->branch_info);
1083 
1084 	to_l = &left->branch_info->to;
1085 	to_r = &right->branch_info->to;
1086 
1087 	/*
1088 	 * comparing symbol address alone is not enough since it's a
1089 	 * relative address within a dso.
1090 	 */
1091 	ret = _sort__dso_cmp(to_l->ms.map, to_r->ms.map);
1092 	if (ret != 0)
1093 		return ret;
1094 
1095 	return _sort__addr_cmp(to_l->addr, to_r->addr);
1096 }
1097 
1098 struct sort_entry sort_addr_from = {
1099 	.se_header	= "Source Address",
1100 	.se_cmp		= sort__addr_from_cmp,
1101 	.se_snprintf	= hist_entry__addr_from_snprintf,
1102 	.se_filter	= hist_entry__sym_from_filter, /* shared with sym_from */
1103 	.se_width_idx	= HISTC_ADDR_FROM,
1104 };
1105 
1106 struct sort_entry sort_addr_to = {
1107 	.se_header	= "Target Address",
1108 	.se_cmp		= sort__addr_to_cmp,
1109 	.se_snprintf	= hist_entry__addr_to_snprintf,
1110 	.se_filter	= hist_entry__sym_to_filter, /* shared with sym_to */
1111 	.se_width_idx	= HISTC_ADDR_TO,
1112 };
1113 
1114 
1115 static int64_t
sort__mispredict_cmp(struct hist_entry * left,struct hist_entry * right)1116 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
1117 {
1118 	unsigned char mp, p;
1119 
1120 	if (!left->branch_info || !right->branch_info)
1121 		return cmp_null(left->branch_info, right->branch_info);
1122 
1123 	mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
1124 	p  = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
1125 	return mp || p;
1126 }
1127 
hist_entry__mispredict_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1128 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
1129 				    size_t size, unsigned int width){
1130 	static const char *out = "N/A";
1131 
1132 	if (he->branch_info) {
1133 		if (he->branch_info->flags.predicted)
1134 			out = "N";
1135 		else if (he->branch_info->flags.mispred)
1136 			out = "Y";
1137 	}
1138 
1139 	return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
1140 }
1141 
1142 static int64_t
sort__cycles_cmp(struct hist_entry * left,struct hist_entry * right)1143 sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
1144 {
1145 	if (!left->branch_info || !right->branch_info)
1146 		return cmp_null(left->branch_info, right->branch_info);
1147 
1148 	return left->branch_info->flags.cycles -
1149 		right->branch_info->flags.cycles;
1150 }
1151 
hist_entry__cycles_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1152 static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
1153 				    size_t size, unsigned int width)
1154 {
1155 	if (!he->branch_info)
1156 		return scnprintf(bf, size, "%-.*s", width, "N/A");
1157 	if (he->branch_info->flags.cycles == 0)
1158 		return repsep_snprintf(bf, size, "%-*s", width, "-");
1159 	return repsep_snprintf(bf, size, "%-*hd", width,
1160 			       he->branch_info->flags.cycles);
1161 }
1162 
1163 struct sort_entry sort_cycles = {
1164 	.se_header	= "Basic Block Cycles",
1165 	.se_cmp		= sort__cycles_cmp,
1166 	.se_snprintf	= hist_entry__cycles_snprintf,
1167 	.se_width_idx	= HISTC_CYCLES,
1168 };
1169 
1170 /* --sort daddr_sym */
1171 int64_t
sort__daddr_cmp(struct hist_entry * left,struct hist_entry * right)1172 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1173 {
1174 	uint64_t l = 0, r = 0;
1175 
1176 	if (left->mem_info)
1177 		l = left->mem_info->daddr.addr;
1178 	if (right->mem_info)
1179 		r = right->mem_info->daddr.addr;
1180 
1181 	return (int64_t)(r - l);
1182 }
1183 
hist_entry__daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1184 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
1185 				    size_t size, unsigned int width)
1186 {
1187 	uint64_t addr = 0;
1188 	struct map_symbol *ms = NULL;
1189 
1190 	if (he->mem_info) {
1191 		addr = he->mem_info->daddr.addr;
1192 		ms = &he->mem_info->daddr.ms;
1193 	}
1194 	return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
1195 }
1196 
1197 int64_t
sort__iaddr_cmp(struct hist_entry * left,struct hist_entry * right)1198 sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
1199 {
1200 	uint64_t l = 0, r = 0;
1201 
1202 	if (left->mem_info)
1203 		l = left->mem_info->iaddr.addr;
1204 	if (right->mem_info)
1205 		r = right->mem_info->iaddr.addr;
1206 
1207 	return (int64_t)(r - l);
1208 }
1209 
hist_entry__iaddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1210 static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
1211 				    size_t size, unsigned int width)
1212 {
1213 	uint64_t addr = 0;
1214 	struct map_symbol *ms = NULL;
1215 
1216 	if (he->mem_info) {
1217 		addr = he->mem_info->iaddr.addr;
1218 		ms   = &he->mem_info->iaddr.ms;
1219 	}
1220 	return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
1221 }
1222 
1223 static int64_t
sort__dso_daddr_cmp(struct hist_entry * left,struct hist_entry * right)1224 sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1225 {
1226 	struct map *map_l = NULL;
1227 	struct map *map_r = NULL;
1228 
1229 	if (left->mem_info)
1230 		map_l = left->mem_info->daddr.ms.map;
1231 	if (right->mem_info)
1232 		map_r = right->mem_info->daddr.ms.map;
1233 
1234 	return _sort__dso_cmp(map_l, map_r);
1235 }
1236 
hist_entry__dso_daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1237 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
1238 				    size_t size, unsigned int width)
1239 {
1240 	struct map *map = NULL;
1241 
1242 	if (he->mem_info)
1243 		map = he->mem_info->daddr.ms.map;
1244 
1245 	return _hist_entry__dso_snprintf(map, bf, size, width);
1246 }
1247 
1248 static int64_t
sort__locked_cmp(struct hist_entry * left,struct hist_entry * right)1249 sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
1250 {
1251 	union perf_mem_data_src data_src_l;
1252 	union perf_mem_data_src data_src_r;
1253 
1254 	if (left->mem_info)
1255 		data_src_l = left->mem_info->data_src;
1256 	else
1257 		data_src_l.mem_lock = PERF_MEM_LOCK_NA;
1258 
1259 	if (right->mem_info)
1260 		data_src_r = right->mem_info->data_src;
1261 	else
1262 		data_src_r.mem_lock = PERF_MEM_LOCK_NA;
1263 
1264 	return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
1265 }
1266 
hist_entry__locked_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1267 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
1268 				    size_t size, unsigned int width)
1269 {
1270 	char out[10];
1271 
1272 	perf_mem__lck_scnprintf(out, sizeof(out), he->mem_info);
1273 	return repsep_snprintf(bf, size, "%.*s", width, out);
1274 }
1275 
1276 static int64_t
sort__tlb_cmp(struct hist_entry * left,struct hist_entry * right)1277 sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
1278 {
1279 	union perf_mem_data_src data_src_l;
1280 	union perf_mem_data_src data_src_r;
1281 
1282 	if (left->mem_info)
1283 		data_src_l = left->mem_info->data_src;
1284 	else
1285 		data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
1286 
1287 	if (right->mem_info)
1288 		data_src_r = right->mem_info->data_src;
1289 	else
1290 		data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
1291 
1292 	return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
1293 }
1294 
hist_entry__tlb_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1295 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
1296 				    size_t size, unsigned int width)
1297 {
1298 	char out[64];
1299 
1300 	perf_mem__tlb_scnprintf(out, sizeof(out), he->mem_info);
1301 	return repsep_snprintf(bf, size, "%-*s", width, out);
1302 }
1303 
1304 static int64_t
sort__lvl_cmp(struct hist_entry * left,struct hist_entry * right)1305 sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
1306 {
1307 	union perf_mem_data_src data_src_l;
1308 	union perf_mem_data_src data_src_r;
1309 
1310 	if (left->mem_info)
1311 		data_src_l = left->mem_info->data_src;
1312 	else
1313 		data_src_l.mem_lvl = PERF_MEM_LVL_NA;
1314 
1315 	if (right->mem_info)
1316 		data_src_r = right->mem_info->data_src;
1317 	else
1318 		data_src_r.mem_lvl = PERF_MEM_LVL_NA;
1319 
1320 	return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
1321 }
1322 
hist_entry__lvl_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1323 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
1324 				    size_t size, unsigned int width)
1325 {
1326 	char out[64];
1327 
1328 	perf_mem__lvl_scnprintf(out, sizeof(out), he->mem_info);
1329 	return repsep_snprintf(bf, size, "%-*s", width, out);
1330 }
1331 
1332 static int64_t
sort__snoop_cmp(struct hist_entry * left,struct hist_entry * right)1333 sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
1334 {
1335 	union perf_mem_data_src data_src_l;
1336 	union perf_mem_data_src data_src_r;
1337 
1338 	if (left->mem_info)
1339 		data_src_l = left->mem_info->data_src;
1340 	else
1341 		data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
1342 
1343 	if (right->mem_info)
1344 		data_src_r = right->mem_info->data_src;
1345 	else
1346 		data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
1347 
1348 	return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
1349 }
1350 
hist_entry__snoop_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1351 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
1352 				    size_t size, unsigned int width)
1353 {
1354 	char out[64];
1355 
1356 	perf_mem__snp_scnprintf(out, sizeof(out), he->mem_info);
1357 	return repsep_snprintf(bf, size, "%-*s", width, out);
1358 }
1359 
1360 int64_t
sort__dcacheline_cmp(struct hist_entry * left,struct hist_entry * right)1361 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
1362 {
1363 	u64 l, r;
1364 	struct map *l_map, *r_map;
1365 	int rc;
1366 
1367 	if (!left->mem_info)  return -1;
1368 	if (!right->mem_info) return 1;
1369 
1370 	/* group event types together */
1371 	if (left->cpumode > right->cpumode) return -1;
1372 	if (left->cpumode < right->cpumode) return 1;
1373 
1374 	l_map = left->mem_info->daddr.ms.map;
1375 	r_map = right->mem_info->daddr.ms.map;
1376 
1377 	/* if both are NULL, jump to sort on al_addr instead */
1378 	if (!l_map && !r_map)
1379 		goto addr;
1380 
1381 	if (!l_map) return -1;
1382 	if (!r_map) return 1;
1383 
1384 	rc = dso__cmp_id(l_map->dso, r_map->dso);
1385 	if (rc)
1386 		return rc;
1387 	/*
1388 	 * Addresses with no major/minor numbers are assumed to be
1389 	 * anonymous in userspace.  Sort those on pid then address.
1390 	 *
1391 	 * The kernel and non-zero major/minor mapped areas are
1392 	 * assumed to be unity mapped.  Sort those on address.
1393 	 */
1394 
1395 	if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
1396 	    (!(l_map->flags & MAP_SHARED)) &&
1397 	    !l_map->dso->id.maj && !l_map->dso->id.min &&
1398 	    !l_map->dso->id.ino && !l_map->dso->id.ino_generation) {
1399 		/* userspace anonymous */
1400 
1401 		if (left->thread->pid_ > right->thread->pid_) return -1;
1402 		if (left->thread->pid_ < right->thread->pid_) return 1;
1403 	}
1404 
1405 addr:
1406 	/* al_addr does all the right addr - start + offset calculations */
1407 	l = cl_address(left->mem_info->daddr.al_addr);
1408 	r = cl_address(right->mem_info->daddr.al_addr);
1409 
1410 	if (l > r) return -1;
1411 	if (l < r) return 1;
1412 
1413 	return 0;
1414 }
1415 
hist_entry__dcacheline_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1416 static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
1417 					  size_t size, unsigned int width)
1418 {
1419 
1420 	uint64_t addr = 0;
1421 	struct map_symbol *ms = NULL;
1422 	char level = he->level;
1423 
1424 	if (he->mem_info) {
1425 		struct map *map = he->mem_info->daddr.ms.map;
1426 
1427 		addr = cl_address(he->mem_info->daddr.al_addr);
1428 		ms = &he->mem_info->daddr.ms;
1429 
1430 		/* print [s] for shared data mmaps */
1431 		if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
1432 		     map && !(map->prot & PROT_EXEC) &&
1433 		    (map->flags & MAP_SHARED) &&
1434 		    (map->dso->id.maj || map->dso->id.min ||
1435 		     map->dso->id.ino || map->dso->id.ino_generation))
1436 			level = 's';
1437 		else if (!map)
1438 			level = 'X';
1439 	}
1440 	return _hist_entry__sym_snprintf(ms, addr, level, bf, size, width);
1441 }
1442 
1443 struct sort_entry sort_mispredict = {
1444 	.se_header	= "Branch Mispredicted",
1445 	.se_cmp		= sort__mispredict_cmp,
1446 	.se_snprintf	= hist_entry__mispredict_snprintf,
1447 	.se_width_idx	= HISTC_MISPREDICT,
1448 };
1449 
1450 static int64_t
sort__weight_cmp(struct hist_entry * left,struct hist_entry * right)1451 sort__weight_cmp(struct hist_entry *left, struct hist_entry *right)
1452 {
1453 	return left->weight - right->weight;
1454 }
1455 
hist_entry__local_weight_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1456 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
1457 				    size_t size, unsigned int width)
1458 {
1459 	return repsep_snprintf(bf, size, "%-*llu", width, he->weight);
1460 }
1461 
1462 struct sort_entry sort_local_weight = {
1463 	.se_header	= "Local Weight",
1464 	.se_cmp		= sort__weight_cmp,
1465 	.se_snprintf	= hist_entry__local_weight_snprintf,
1466 	.se_width_idx	= HISTC_LOCAL_WEIGHT,
1467 };
1468 
hist_entry__global_weight_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1469 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
1470 					      size_t size, unsigned int width)
1471 {
1472 	return repsep_snprintf(bf, size, "%-*llu", width,
1473 			       he->weight * he->stat.nr_events);
1474 }
1475 
1476 struct sort_entry sort_global_weight = {
1477 	.se_header	= "Weight",
1478 	.se_cmp		= sort__weight_cmp,
1479 	.se_snprintf	= hist_entry__global_weight_snprintf,
1480 	.se_width_idx	= HISTC_GLOBAL_WEIGHT,
1481 };
1482 
1483 static int64_t
sort__ins_lat_cmp(struct hist_entry * left,struct hist_entry * right)1484 sort__ins_lat_cmp(struct hist_entry *left, struct hist_entry *right)
1485 {
1486 	return left->ins_lat - right->ins_lat;
1487 }
1488 
hist_entry__local_ins_lat_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1489 static int hist_entry__local_ins_lat_snprintf(struct hist_entry *he, char *bf,
1490 					      size_t size, unsigned int width)
1491 {
1492 	return repsep_snprintf(bf, size, "%-*u", width, he->ins_lat);
1493 }
1494 
1495 struct sort_entry sort_local_ins_lat = {
1496 	.se_header	= "Local INSTR Latency",
1497 	.se_cmp		= sort__ins_lat_cmp,
1498 	.se_snprintf	= hist_entry__local_ins_lat_snprintf,
1499 	.se_width_idx	= HISTC_LOCAL_INS_LAT,
1500 };
1501 
hist_entry__global_ins_lat_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1502 static int hist_entry__global_ins_lat_snprintf(struct hist_entry *he, char *bf,
1503 					       size_t size, unsigned int width)
1504 {
1505 	return repsep_snprintf(bf, size, "%-*u", width,
1506 			       he->ins_lat * he->stat.nr_events);
1507 }
1508 
1509 struct sort_entry sort_global_ins_lat = {
1510 	.se_header	= "INSTR Latency",
1511 	.se_cmp		= sort__ins_lat_cmp,
1512 	.se_snprintf	= hist_entry__global_ins_lat_snprintf,
1513 	.se_width_idx	= HISTC_GLOBAL_INS_LAT,
1514 };
1515 
1516 static int64_t
sort__p_stage_cyc_cmp(struct hist_entry * left,struct hist_entry * right)1517 sort__p_stage_cyc_cmp(struct hist_entry *left, struct hist_entry *right)
1518 {
1519 	return left->p_stage_cyc - right->p_stage_cyc;
1520 }
1521 
hist_entry__global_p_stage_cyc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1522 static int hist_entry__global_p_stage_cyc_snprintf(struct hist_entry *he, char *bf,
1523 					size_t size, unsigned int width)
1524 {
1525 	return repsep_snprintf(bf, size, "%-*u", width,
1526 			he->p_stage_cyc * he->stat.nr_events);
1527 }
1528 
1529 
hist_entry__p_stage_cyc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1530 static int hist_entry__p_stage_cyc_snprintf(struct hist_entry *he, char *bf,
1531 					size_t size, unsigned int width)
1532 {
1533 	return repsep_snprintf(bf, size, "%-*u", width, he->p_stage_cyc);
1534 }
1535 
1536 struct sort_entry sort_local_p_stage_cyc = {
1537 	.se_header      = "Local Pipeline Stage Cycle",
1538 	.se_cmp         = sort__p_stage_cyc_cmp,
1539 	.se_snprintf	= hist_entry__p_stage_cyc_snprintf,
1540 	.se_width_idx	= HISTC_LOCAL_P_STAGE_CYC,
1541 };
1542 
1543 struct sort_entry sort_global_p_stage_cyc = {
1544 	.se_header      = "Pipeline Stage Cycle",
1545 	.se_cmp         = sort__p_stage_cyc_cmp,
1546 	.se_snprintf    = hist_entry__global_p_stage_cyc_snprintf,
1547 	.se_width_idx   = HISTC_GLOBAL_P_STAGE_CYC,
1548 };
1549 
1550 struct sort_entry sort_mem_daddr_sym = {
1551 	.se_header	= "Data Symbol",
1552 	.se_cmp		= sort__daddr_cmp,
1553 	.se_snprintf	= hist_entry__daddr_snprintf,
1554 	.se_width_idx	= HISTC_MEM_DADDR_SYMBOL,
1555 };
1556 
1557 struct sort_entry sort_mem_iaddr_sym = {
1558 	.se_header	= "Code Symbol",
1559 	.se_cmp		= sort__iaddr_cmp,
1560 	.se_snprintf	= hist_entry__iaddr_snprintf,
1561 	.se_width_idx	= HISTC_MEM_IADDR_SYMBOL,
1562 };
1563 
1564 struct sort_entry sort_mem_daddr_dso = {
1565 	.se_header	= "Data Object",
1566 	.se_cmp		= sort__dso_daddr_cmp,
1567 	.se_snprintf	= hist_entry__dso_daddr_snprintf,
1568 	.se_width_idx	= HISTC_MEM_DADDR_DSO,
1569 };
1570 
1571 struct sort_entry sort_mem_locked = {
1572 	.se_header	= "Locked",
1573 	.se_cmp		= sort__locked_cmp,
1574 	.se_snprintf	= hist_entry__locked_snprintf,
1575 	.se_width_idx	= HISTC_MEM_LOCKED,
1576 };
1577 
1578 struct sort_entry sort_mem_tlb = {
1579 	.se_header	= "TLB access",
1580 	.se_cmp		= sort__tlb_cmp,
1581 	.se_snprintf	= hist_entry__tlb_snprintf,
1582 	.se_width_idx	= HISTC_MEM_TLB,
1583 };
1584 
1585 struct sort_entry sort_mem_lvl = {
1586 	.se_header	= "Memory access",
1587 	.se_cmp		= sort__lvl_cmp,
1588 	.se_snprintf	= hist_entry__lvl_snprintf,
1589 	.se_width_idx	= HISTC_MEM_LVL,
1590 };
1591 
1592 struct sort_entry sort_mem_snoop = {
1593 	.se_header	= "Snoop",
1594 	.se_cmp		= sort__snoop_cmp,
1595 	.se_snprintf	= hist_entry__snoop_snprintf,
1596 	.se_width_idx	= HISTC_MEM_SNOOP,
1597 };
1598 
1599 struct sort_entry sort_mem_dcacheline = {
1600 	.se_header	= "Data Cacheline",
1601 	.se_cmp		= sort__dcacheline_cmp,
1602 	.se_snprintf	= hist_entry__dcacheline_snprintf,
1603 	.se_width_idx	= HISTC_MEM_DCACHELINE,
1604 };
1605 
1606 static int64_t
sort__blocked_cmp(struct hist_entry * left,struct hist_entry * right)1607 sort__blocked_cmp(struct hist_entry *left, struct hist_entry *right)
1608 {
1609 	union perf_mem_data_src data_src_l;
1610 	union perf_mem_data_src data_src_r;
1611 
1612 	if (left->mem_info)
1613 		data_src_l = left->mem_info->data_src;
1614 	else
1615 		data_src_l.mem_blk = PERF_MEM_BLK_NA;
1616 
1617 	if (right->mem_info)
1618 		data_src_r = right->mem_info->data_src;
1619 	else
1620 		data_src_r.mem_blk = PERF_MEM_BLK_NA;
1621 
1622 	return (int64_t)(data_src_r.mem_blk - data_src_l.mem_blk);
1623 }
1624 
hist_entry__blocked_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1625 static int hist_entry__blocked_snprintf(struct hist_entry *he, char *bf,
1626 					size_t size, unsigned int width)
1627 {
1628 	char out[16];
1629 
1630 	perf_mem__blk_scnprintf(out, sizeof(out), he->mem_info);
1631 	return repsep_snprintf(bf, size, "%.*s", width, out);
1632 }
1633 
1634 struct sort_entry sort_mem_blocked = {
1635 	.se_header	= "Blocked",
1636 	.se_cmp		= sort__blocked_cmp,
1637 	.se_snprintf	= hist_entry__blocked_snprintf,
1638 	.se_width_idx	= HISTC_MEM_BLOCKED,
1639 };
1640 
1641 static int64_t
sort__phys_daddr_cmp(struct hist_entry * left,struct hist_entry * right)1642 sort__phys_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1643 {
1644 	uint64_t l = 0, r = 0;
1645 
1646 	if (left->mem_info)
1647 		l = left->mem_info->daddr.phys_addr;
1648 	if (right->mem_info)
1649 		r = right->mem_info->daddr.phys_addr;
1650 
1651 	return (int64_t)(r - l);
1652 }
1653 
hist_entry__phys_daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1654 static int hist_entry__phys_daddr_snprintf(struct hist_entry *he, char *bf,
1655 					   size_t size, unsigned int width)
1656 {
1657 	uint64_t addr = 0;
1658 	size_t ret = 0;
1659 	size_t len = BITS_PER_LONG / 4;
1660 
1661 	addr = he->mem_info->daddr.phys_addr;
1662 
1663 	ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", he->level);
1664 
1665 	ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, addr);
1666 
1667 	ret += repsep_snprintf(bf + ret, size - ret, "%-*s", width - ret, "");
1668 
1669 	if (ret > width)
1670 		bf[width] = '\0';
1671 
1672 	return width;
1673 }
1674 
1675 struct sort_entry sort_mem_phys_daddr = {
1676 	.se_header	= "Data Physical Address",
1677 	.se_cmp		= sort__phys_daddr_cmp,
1678 	.se_snprintf	= hist_entry__phys_daddr_snprintf,
1679 	.se_width_idx	= HISTC_MEM_PHYS_DADDR,
1680 };
1681 
1682 static int64_t
sort__data_page_size_cmp(struct hist_entry * left,struct hist_entry * right)1683 sort__data_page_size_cmp(struct hist_entry *left, struct hist_entry *right)
1684 {
1685 	uint64_t l = 0, r = 0;
1686 
1687 	if (left->mem_info)
1688 		l = left->mem_info->daddr.data_page_size;
1689 	if (right->mem_info)
1690 		r = right->mem_info->daddr.data_page_size;
1691 
1692 	return (int64_t)(r - l);
1693 }
1694 
hist_entry__data_page_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1695 static int hist_entry__data_page_size_snprintf(struct hist_entry *he, char *bf,
1696 					  size_t size, unsigned int width)
1697 {
1698 	char str[PAGE_SIZE_NAME_LEN];
1699 
1700 	return repsep_snprintf(bf, size, "%-*s", width,
1701 			       get_page_size_name(he->mem_info->daddr.data_page_size, str));
1702 }
1703 
1704 struct sort_entry sort_mem_data_page_size = {
1705 	.se_header	= "Data Page Size",
1706 	.se_cmp		= sort__data_page_size_cmp,
1707 	.se_snprintf	= hist_entry__data_page_size_snprintf,
1708 	.se_width_idx	= HISTC_MEM_DATA_PAGE_SIZE,
1709 };
1710 
1711 static int64_t
sort__code_page_size_cmp(struct hist_entry * left,struct hist_entry * right)1712 sort__code_page_size_cmp(struct hist_entry *left, struct hist_entry *right)
1713 {
1714 	uint64_t l = left->code_page_size;
1715 	uint64_t r = right->code_page_size;
1716 
1717 	return (int64_t)(r - l);
1718 }
1719 
hist_entry__code_page_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1720 static int hist_entry__code_page_size_snprintf(struct hist_entry *he, char *bf,
1721 					  size_t size, unsigned int width)
1722 {
1723 	char str[PAGE_SIZE_NAME_LEN];
1724 
1725 	return repsep_snprintf(bf, size, "%-*s", width,
1726 			       get_page_size_name(he->code_page_size, str));
1727 }
1728 
1729 struct sort_entry sort_code_page_size = {
1730 	.se_header	= "Code Page Size",
1731 	.se_cmp		= sort__code_page_size_cmp,
1732 	.se_snprintf	= hist_entry__code_page_size_snprintf,
1733 	.se_width_idx	= HISTC_CODE_PAGE_SIZE,
1734 };
1735 
1736 static int64_t
sort__abort_cmp(struct hist_entry * left,struct hist_entry * right)1737 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1738 {
1739 	if (!left->branch_info || !right->branch_info)
1740 		return cmp_null(left->branch_info, right->branch_info);
1741 
1742 	return left->branch_info->flags.abort !=
1743 		right->branch_info->flags.abort;
1744 }
1745 
hist_entry__abort_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1746 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1747 				    size_t size, unsigned int width)
1748 {
1749 	static const char *out = "N/A";
1750 
1751 	if (he->branch_info) {
1752 		if (he->branch_info->flags.abort)
1753 			out = "A";
1754 		else
1755 			out = ".";
1756 	}
1757 
1758 	return repsep_snprintf(bf, size, "%-*s", width, out);
1759 }
1760 
1761 struct sort_entry sort_abort = {
1762 	.se_header	= "Transaction abort",
1763 	.se_cmp		= sort__abort_cmp,
1764 	.se_snprintf	= hist_entry__abort_snprintf,
1765 	.se_width_idx	= HISTC_ABORT,
1766 };
1767 
1768 static int64_t
sort__in_tx_cmp(struct hist_entry * left,struct hist_entry * right)1769 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1770 {
1771 	if (!left->branch_info || !right->branch_info)
1772 		return cmp_null(left->branch_info, right->branch_info);
1773 
1774 	return left->branch_info->flags.in_tx !=
1775 		right->branch_info->flags.in_tx;
1776 }
1777 
hist_entry__in_tx_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1778 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1779 				    size_t size, unsigned int width)
1780 {
1781 	static const char *out = "N/A";
1782 
1783 	if (he->branch_info) {
1784 		if (he->branch_info->flags.in_tx)
1785 			out = "T";
1786 		else
1787 			out = ".";
1788 	}
1789 
1790 	return repsep_snprintf(bf, size, "%-*s", width, out);
1791 }
1792 
1793 struct sort_entry sort_in_tx = {
1794 	.se_header	= "Branch in transaction",
1795 	.se_cmp		= sort__in_tx_cmp,
1796 	.se_snprintf	= hist_entry__in_tx_snprintf,
1797 	.se_width_idx	= HISTC_IN_TX,
1798 };
1799 
1800 static int64_t
sort__transaction_cmp(struct hist_entry * left,struct hist_entry * right)1801 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1802 {
1803 	return left->transaction - right->transaction;
1804 }
1805 
add_str(char * p,const char * str)1806 static inline char *add_str(char *p, const char *str)
1807 {
1808 	strcpy(p, str);
1809 	return p + strlen(str);
1810 }
1811 
1812 static struct txbit {
1813 	unsigned flag;
1814 	const char *name;
1815 	int skip_for_len;
1816 } txbits[] = {
1817 	{ PERF_TXN_ELISION,        "EL ",        0 },
1818 	{ PERF_TXN_TRANSACTION,    "TX ",        1 },
1819 	{ PERF_TXN_SYNC,           "SYNC ",      1 },
1820 	{ PERF_TXN_ASYNC,          "ASYNC ",     0 },
1821 	{ PERF_TXN_RETRY,          "RETRY ",     0 },
1822 	{ PERF_TXN_CONFLICT,       "CON ",       0 },
1823 	{ PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
1824 	{ PERF_TXN_CAPACITY_READ,  "CAP-READ ",  0 },
1825 	{ 0, NULL, 0 }
1826 };
1827 
hist_entry__transaction_len(void)1828 int hist_entry__transaction_len(void)
1829 {
1830 	int i;
1831 	int len = 0;
1832 
1833 	for (i = 0; txbits[i].name; i++) {
1834 		if (!txbits[i].skip_for_len)
1835 			len += strlen(txbits[i].name);
1836 	}
1837 	len += 4; /* :XX<space> */
1838 	return len;
1839 }
1840 
hist_entry__transaction_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1841 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
1842 					    size_t size, unsigned int width)
1843 {
1844 	u64 t = he->transaction;
1845 	char buf[128];
1846 	char *p = buf;
1847 	int i;
1848 
1849 	buf[0] = 0;
1850 	for (i = 0; txbits[i].name; i++)
1851 		if (txbits[i].flag & t)
1852 			p = add_str(p, txbits[i].name);
1853 	if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
1854 		p = add_str(p, "NEITHER ");
1855 	if (t & PERF_TXN_ABORT_MASK) {
1856 		sprintf(p, ":%" PRIx64,
1857 			(t & PERF_TXN_ABORT_MASK) >>
1858 			PERF_TXN_ABORT_SHIFT);
1859 		p += strlen(p);
1860 	}
1861 
1862 	return repsep_snprintf(bf, size, "%-*s", width, buf);
1863 }
1864 
1865 struct sort_entry sort_transaction = {
1866 	.se_header	= "Transaction                ",
1867 	.se_cmp		= sort__transaction_cmp,
1868 	.se_snprintf	= hist_entry__transaction_snprintf,
1869 	.se_width_idx	= HISTC_TRANSACTION,
1870 };
1871 
1872 /* --sort symbol_size */
1873 
_sort__sym_size_cmp(struct symbol * sym_l,struct symbol * sym_r)1874 static int64_t _sort__sym_size_cmp(struct symbol *sym_l, struct symbol *sym_r)
1875 {
1876 	int64_t size_l = sym_l != NULL ? symbol__size(sym_l) : 0;
1877 	int64_t size_r = sym_r != NULL ? symbol__size(sym_r) : 0;
1878 
1879 	return size_l < size_r ? -1 :
1880 		size_l == size_r ? 0 : 1;
1881 }
1882 
1883 static int64_t
sort__sym_size_cmp(struct hist_entry * left,struct hist_entry * right)1884 sort__sym_size_cmp(struct hist_entry *left, struct hist_entry *right)
1885 {
1886 	return _sort__sym_size_cmp(right->ms.sym, left->ms.sym);
1887 }
1888 
_hist_entry__sym_size_snprintf(struct symbol * sym,char * bf,size_t bf_size,unsigned int width)1889 static int _hist_entry__sym_size_snprintf(struct symbol *sym, char *bf,
1890 					  size_t bf_size, unsigned int width)
1891 {
1892 	if (sym)
1893 		return repsep_snprintf(bf, bf_size, "%*d", width, symbol__size(sym));
1894 
1895 	return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
1896 }
1897 
hist_entry__sym_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1898 static int hist_entry__sym_size_snprintf(struct hist_entry *he, char *bf,
1899 					 size_t size, unsigned int width)
1900 {
1901 	return _hist_entry__sym_size_snprintf(he->ms.sym, bf, size, width);
1902 }
1903 
1904 struct sort_entry sort_sym_size = {
1905 	.se_header	= "Symbol size",
1906 	.se_cmp		= sort__sym_size_cmp,
1907 	.se_snprintf	= hist_entry__sym_size_snprintf,
1908 	.se_width_idx	= HISTC_SYM_SIZE,
1909 };
1910 
1911 /* --sort dso_size */
1912 
_sort__dso_size_cmp(struct map * map_l,struct map * map_r)1913 static int64_t _sort__dso_size_cmp(struct map *map_l, struct map *map_r)
1914 {
1915 	int64_t size_l = map_l != NULL ? map__size(map_l) : 0;
1916 	int64_t size_r = map_r != NULL ? map__size(map_r) : 0;
1917 
1918 	return size_l < size_r ? -1 :
1919 		size_l == size_r ? 0 : 1;
1920 }
1921 
1922 static int64_t
sort__dso_size_cmp(struct hist_entry * left,struct hist_entry * right)1923 sort__dso_size_cmp(struct hist_entry *left, struct hist_entry *right)
1924 {
1925 	return _sort__dso_size_cmp(right->ms.map, left->ms.map);
1926 }
1927 
_hist_entry__dso_size_snprintf(struct map * map,char * bf,size_t bf_size,unsigned int width)1928 static int _hist_entry__dso_size_snprintf(struct map *map, char *bf,
1929 					  size_t bf_size, unsigned int width)
1930 {
1931 	if (map && map->dso)
1932 		return repsep_snprintf(bf, bf_size, "%*d", width,
1933 				       map__size(map));
1934 
1935 	return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
1936 }
1937 
hist_entry__dso_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1938 static int hist_entry__dso_size_snprintf(struct hist_entry *he, char *bf,
1939 					 size_t size, unsigned int width)
1940 {
1941 	return _hist_entry__dso_size_snprintf(he->ms.map, bf, size, width);
1942 }
1943 
1944 struct sort_entry sort_dso_size = {
1945 	.se_header	= "DSO size",
1946 	.se_cmp		= sort__dso_size_cmp,
1947 	.se_snprintf	= hist_entry__dso_size_snprintf,
1948 	.se_width_idx	= HISTC_DSO_SIZE,
1949 };
1950 
1951 
1952 struct sort_dimension {
1953 	const char		*name;
1954 	struct sort_entry	*entry;
1955 	int			taken;
1956 };
1957 
arch_support_sort_key(const char * sort_key __maybe_unused)1958 int __weak arch_support_sort_key(const char *sort_key __maybe_unused)
1959 {
1960 	return 0;
1961 }
1962 
arch_perf_header_entry(const char * se_header)1963 const char * __weak arch_perf_header_entry(const char *se_header)
1964 {
1965 	return se_header;
1966 }
1967 
sort_dimension_add_dynamic_header(struct sort_dimension * sd)1968 static void sort_dimension_add_dynamic_header(struct sort_dimension *sd)
1969 {
1970 	sd->entry->se_header = arch_perf_header_entry(sd->entry->se_header);
1971 }
1972 
1973 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
1974 
1975 static struct sort_dimension common_sort_dimensions[] = {
1976 	DIM(SORT_PID, "pid", sort_thread),
1977 	DIM(SORT_COMM, "comm", sort_comm),
1978 	DIM(SORT_DSO, "dso", sort_dso),
1979 	DIM(SORT_SYM, "symbol", sort_sym),
1980 	DIM(SORT_PARENT, "parent", sort_parent),
1981 	DIM(SORT_CPU, "cpu", sort_cpu),
1982 	DIM(SORT_SOCKET, "socket", sort_socket),
1983 	DIM(SORT_SRCLINE, "srcline", sort_srcline),
1984 	DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
1985 	DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
1986 	DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
1987 	DIM(SORT_TRANSACTION, "transaction", sort_transaction),
1988 	DIM(SORT_TRACE, "trace", sort_trace),
1989 	DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size),
1990 	DIM(SORT_DSO_SIZE, "dso_size", sort_dso_size),
1991 	DIM(SORT_CGROUP, "cgroup", sort_cgroup),
1992 	DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id),
1993 	DIM(SORT_SYM_IPC_NULL, "ipc_null", sort_sym_ipc_null),
1994 	DIM(SORT_TIME, "time", sort_time),
1995 	DIM(SORT_CODE_PAGE_SIZE, "code_page_size", sort_code_page_size),
1996 	DIM(SORT_LOCAL_INS_LAT, "local_ins_lat", sort_local_ins_lat),
1997 	DIM(SORT_GLOBAL_INS_LAT, "ins_lat", sort_global_ins_lat),
1998 	DIM(SORT_LOCAL_PIPELINE_STAGE_CYC, "local_p_stage_cyc", sort_local_p_stage_cyc),
1999 	DIM(SORT_GLOBAL_PIPELINE_STAGE_CYC, "p_stage_cyc", sort_global_p_stage_cyc),
2000 };
2001 
2002 #undef DIM
2003 
2004 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
2005 
2006 static struct sort_dimension bstack_sort_dimensions[] = {
2007 	DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
2008 	DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
2009 	DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
2010 	DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
2011 	DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
2012 	DIM(SORT_IN_TX, "in_tx", sort_in_tx),
2013 	DIM(SORT_ABORT, "abort", sort_abort),
2014 	DIM(SORT_CYCLES, "cycles", sort_cycles),
2015 	DIM(SORT_SRCLINE_FROM, "srcline_from", sort_srcline_from),
2016 	DIM(SORT_SRCLINE_TO, "srcline_to", sort_srcline_to),
2017 	DIM(SORT_SYM_IPC, "ipc_lbr", sort_sym_ipc),
2018 	DIM(SORT_ADDR_FROM, "addr_from", sort_addr_from),
2019 	DIM(SORT_ADDR_TO, "addr_to", sort_addr_to),
2020 };
2021 
2022 #undef DIM
2023 
2024 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
2025 
2026 static struct sort_dimension memory_sort_dimensions[] = {
2027 	DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
2028 	DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
2029 	DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
2030 	DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
2031 	DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
2032 	DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
2033 	DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
2034 	DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
2035 	DIM(SORT_MEM_PHYS_DADDR, "phys_daddr", sort_mem_phys_daddr),
2036 	DIM(SORT_MEM_DATA_PAGE_SIZE, "data_page_size", sort_mem_data_page_size),
2037 	DIM(SORT_MEM_BLOCKED, "blocked", sort_mem_blocked),
2038 };
2039 
2040 #undef DIM
2041 
2042 struct hpp_dimension {
2043 	const char		*name;
2044 	struct perf_hpp_fmt	*fmt;
2045 	int			taken;
2046 };
2047 
2048 #define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
2049 
2050 static struct hpp_dimension hpp_sort_dimensions[] = {
2051 	DIM(PERF_HPP__OVERHEAD, "overhead"),
2052 	DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
2053 	DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
2054 	DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
2055 	DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
2056 	DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
2057 	DIM(PERF_HPP__SAMPLES, "sample"),
2058 	DIM(PERF_HPP__PERIOD, "period"),
2059 };
2060 
2061 #undef DIM
2062 
2063 struct hpp_sort_entry {
2064 	struct perf_hpp_fmt hpp;
2065 	struct sort_entry *se;
2066 };
2067 
perf_hpp__reset_sort_width(struct perf_hpp_fmt * fmt,struct hists * hists)2068 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
2069 {
2070 	struct hpp_sort_entry *hse;
2071 
2072 	if (!perf_hpp__is_sort_entry(fmt))
2073 		return;
2074 
2075 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2076 	hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
2077 }
2078 
__sort__hpp_header(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hists * hists,int line __maybe_unused,int * span __maybe_unused)2079 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2080 			      struct hists *hists, int line __maybe_unused,
2081 			      int *span __maybe_unused)
2082 {
2083 	struct hpp_sort_entry *hse;
2084 	size_t len = fmt->user_len;
2085 
2086 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2087 
2088 	if (!len)
2089 		len = hists__col_len(hists, hse->se->se_width_idx);
2090 
2091 	return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
2092 }
2093 
__sort__hpp_width(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp __maybe_unused,struct hists * hists)2094 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
2095 			     struct perf_hpp *hpp __maybe_unused,
2096 			     struct hists *hists)
2097 {
2098 	struct hpp_sort_entry *hse;
2099 	size_t len = fmt->user_len;
2100 
2101 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2102 
2103 	if (!len)
2104 		len = hists__col_len(hists, hse->se->se_width_idx);
2105 
2106 	return len;
2107 }
2108 
__sort__hpp_entry(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hist_entry * he)2109 static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2110 			     struct hist_entry *he)
2111 {
2112 	struct hpp_sort_entry *hse;
2113 	size_t len = fmt->user_len;
2114 
2115 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2116 
2117 	if (!len)
2118 		len = hists__col_len(he->hists, hse->se->se_width_idx);
2119 
2120 	return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
2121 }
2122 
__sort__hpp_cmp(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2123 static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
2124 			       struct hist_entry *a, struct hist_entry *b)
2125 {
2126 	struct hpp_sort_entry *hse;
2127 
2128 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2129 	return hse->se->se_cmp(a, b);
2130 }
2131 
__sort__hpp_collapse(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2132 static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
2133 				    struct hist_entry *a, struct hist_entry *b)
2134 {
2135 	struct hpp_sort_entry *hse;
2136 	int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
2137 
2138 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2139 	collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
2140 	return collapse_fn(a, b);
2141 }
2142 
__sort__hpp_sort(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2143 static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
2144 				struct hist_entry *a, struct hist_entry *b)
2145 {
2146 	struct hpp_sort_entry *hse;
2147 	int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
2148 
2149 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2150 	sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
2151 	return sort_fn(a, b);
2152 }
2153 
perf_hpp__is_sort_entry(struct perf_hpp_fmt * format)2154 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
2155 {
2156 	return format->header == __sort__hpp_header;
2157 }
2158 
2159 #define MK_SORT_ENTRY_CHK(key)					\
2160 bool perf_hpp__is_ ## key ## _entry(struct perf_hpp_fmt *fmt)	\
2161 {								\
2162 	struct hpp_sort_entry *hse;				\
2163 								\
2164 	if (!perf_hpp__is_sort_entry(fmt))			\
2165 		return false;					\
2166 								\
2167 	hse = container_of(fmt, struct hpp_sort_entry, hpp);	\
2168 	return hse->se == &sort_ ## key ;			\
2169 }
2170 
2171 MK_SORT_ENTRY_CHK(trace)
MK_SORT_ENTRY_CHK(srcline)2172 MK_SORT_ENTRY_CHK(srcline)
2173 MK_SORT_ENTRY_CHK(srcfile)
2174 MK_SORT_ENTRY_CHK(thread)
2175 MK_SORT_ENTRY_CHK(comm)
2176 MK_SORT_ENTRY_CHK(dso)
2177 MK_SORT_ENTRY_CHK(sym)
2178 
2179 
2180 static bool __sort__hpp_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
2181 {
2182 	struct hpp_sort_entry *hse_a;
2183 	struct hpp_sort_entry *hse_b;
2184 
2185 	if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
2186 		return false;
2187 
2188 	hse_a = container_of(a, struct hpp_sort_entry, hpp);
2189 	hse_b = container_of(b, struct hpp_sort_entry, hpp);
2190 
2191 	return hse_a->se == hse_b->se;
2192 }
2193 
hse_free(struct perf_hpp_fmt * fmt)2194 static void hse_free(struct perf_hpp_fmt *fmt)
2195 {
2196 	struct hpp_sort_entry *hse;
2197 
2198 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2199 	free(hse);
2200 }
2201 
2202 static struct hpp_sort_entry *
__sort_dimension__alloc_hpp(struct sort_dimension * sd,int level)2203 __sort_dimension__alloc_hpp(struct sort_dimension *sd, int level)
2204 {
2205 	struct hpp_sort_entry *hse;
2206 
2207 	hse = malloc(sizeof(*hse));
2208 	if (hse == NULL) {
2209 		pr_err("Memory allocation failed\n");
2210 		return NULL;
2211 	}
2212 
2213 	hse->se = sd->entry;
2214 	hse->hpp.name = sd->entry->se_header;
2215 	hse->hpp.header = __sort__hpp_header;
2216 	hse->hpp.width = __sort__hpp_width;
2217 	hse->hpp.entry = __sort__hpp_entry;
2218 	hse->hpp.color = NULL;
2219 
2220 	hse->hpp.cmp = __sort__hpp_cmp;
2221 	hse->hpp.collapse = __sort__hpp_collapse;
2222 	hse->hpp.sort = __sort__hpp_sort;
2223 	hse->hpp.equal = __sort__hpp_equal;
2224 	hse->hpp.free = hse_free;
2225 
2226 	INIT_LIST_HEAD(&hse->hpp.list);
2227 	INIT_LIST_HEAD(&hse->hpp.sort_list);
2228 	hse->hpp.elide = false;
2229 	hse->hpp.len = 0;
2230 	hse->hpp.user_len = 0;
2231 	hse->hpp.level = level;
2232 
2233 	return hse;
2234 }
2235 
hpp_free(struct perf_hpp_fmt * fmt)2236 static void hpp_free(struct perf_hpp_fmt *fmt)
2237 {
2238 	free(fmt);
2239 }
2240 
__hpp_dimension__alloc_hpp(struct hpp_dimension * hd,int level)2241 static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd,
2242 						       int level)
2243 {
2244 	struct perf_hpp_fmt *fmt;
2245 
2246 	fmt = memdup(hd->fmt, sizeof(*fmt));
2247 	if (fmt) {
2248 		INIT_LIST_HEAD(&fmt->list);
2249 		INIT_LIST_HEAD(&fmt->sort_list);
2250 		fmt->free = hpp_free;
2251 		fmt->level = level;
2252 	}
2253 
2254 	return fmt;
2255 }
2256 
hist_entry__filter(struct hist_entry * he,int type,const void * arg)2257 int hist_entry__filter(struct hist_entry *he, int type, const void *arg)
2258 {
2259 	struct perf_hpp_fmt *fmt;
2260 	struct hpp_sort_entry *hse;
2261 	int ret = -1;
2262 	int r;
2263 
2264 	perf_hpp_list__for_each_format(he->hpp_list, fmt) {
2265 		if (!perf_hpp__is_sort_entry(fmt))
2266 			continue;
2267 
2268 		hse = container_of(fmt, struct hpp_sort_entry, hpp);
2269 		if (hse->se->se_filter == NULL)
2270 			continue;
2271 
2272 		/*
2273 		 * hist entry is filtered if any of sort key in the hpp list
2274 		 * is applied.  But it should skip non-matched filter types.
2275 		 */
2276 		r = hse->se->se_filter(he, type, arg);
2277 		if (r >= 0) {
2278 			if (ret < 0)
2279 				ret = 0;
2280 			ret |= r;
2281 		}
2282 	}
2283 
2284 	return ret;
2285 }
2286 
__sort_dimension__add_hpp_sort(struct sort_dimension * sd,struct perf_hpp_list * list,int level)2287 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd,
2288 					  struct perf_hpp_list *list,
2289 					  int level)
2290 {
2291 	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, level);
2292 
2293 	if (hse == NULL)
2294 		return -1;
2295 
2296 	perf_hpp_list__register_sort_field(list, &hse->hpp);
2297 	return 0;
2298 }
2299 
__sort_dimension__add_hpp_output(struct sort_dimension * sd,struct perf_hpp_list * list)2300 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd,
2301 					    struct perf_hpp_list *list)
2302 {
2303 	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, 0);
2304 
2305 	if (hse == NULL)
2306 		return -1;
2307 
2308 	perf_hpp_list__column_register(list, &hse->hpp);
2309 	return 0;
2310 }
2311 
2312 struct hpp_dynamic_entry {
2313 	struct perf_hpp_fmt hpp;
2314 	struct evsel *evsel;
2315 	struct tep_format_field *field;
2316 	unsigned dynamic_len;
2317 	bool raw_trace;
2318 };
2319 
hde_width(struct hpp_dynamic_entry * hde)2320 static int hde_width(struct hpp_dynamic_entry *hde)
2321 {
2322 	if (!hde->hpp.len) {
2323 		int len = hde->dynamic_len;
2324 		int namelen = strlen(hde->field->name);
2325 		int fieldlen = hde->field->size;
2326 
2327 		if (namelen > len)
2328 			len = namelen;
2329 
2330 		if (!(hde->field->flags & TEP_FIELD_IS_STRING)) {
2331 			/* length for print hex numbers */
2332 			fieldlen = hde->field->size * 2 + 2;
2333 		}
2334 		if (fieldlen > len)
2335 			len = fieldlen;
2336 
2337 		hde->hpp.len = len;
2338 	}
2339 	return hde->hpp.len;
2340 }
2341 
update_dynamic_len(struct hpp_dynamic_entry * hde,struct hist_entry * he)2342 static void update_dynamic_len(struct hpp_dynamic_entry *hde,
2343 			       struct hist_entry *he)
2344 {
2345 	char *str, *pos;
2346 	struct tep_format_field *field = hde->field;
2347 	size_t namelen;
2348 	bool last = false;
2349 
2350 	if (hde->raw_trace)
2351 		return;
2352 
2353 	/* parse pretty print result and update max length */
2354 	if (!he->trace_output)
2355 		he->trace_output = get_trace_output(he);
2356 
2357 	namelen = strlen(field->name);
2358 	str = he->trace_output;
2359 
2360 	while (str) {
2361 		pos = strchr(str, ' ');
2362 		if (pos == NULL) {
2363 			last = true;
2364 			pos = str + strlen(str);
2365 		}
2366 
2367 		if (!strncmp(str, field->name, namelen)) {
2368 			size_t len;
2369 
2370 			str += namelen + 1;
2371 			len = pos - str;
2372 
2373 			if (len > hde->dynamic_len)
2374 				hde->dynamic_len = len;
2375 			break;
2376 		}
2377 
2378 		if (last)
2379 			str = NULL;
2380 		else
2381 			str = pos + 1;
2382 	}
2383 }
2384 
__sort__hde_header(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hists * hists __maybe_unused,int line __maybe_unused,int * span __maybe_unused)2385 static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2386 			      struct hists *hists __maybe_unused,
2387 			      int line __maybe_unused,
2388 			      int *span __maybe_unused)
2389 {
2390 	struct hpp_dynamic_entry *hde;
2391 	size_t len = fmt->user_len;
2392 
2393 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2394 
2395 	if (!len)
2396 		len = hde_width(hde);
2397 
2398 	return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, hde->field->name);
2399 }
2400 
__sort__hde_width(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp __maybe_unused,struct hists * hists __maybe_unused)2401 static int __sort__hde_width(struct perf_hpp_fmt *fmt,
2402 			     struct perf_hpp *hpp __maybe_unused,
2403 			     struct hists *hists __maybe_unused)
2404 {
2405 	struct hpp_dynamic_entry *hde;
2406 	size_t len = fmt->user_len;
2407 
2408 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2409 
2410 	if (!len)
2411 		len = hde_width(hde);
2412 
2413 	return len;
2414 }
2415 
perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt * fmt,struct hists * hists)2416 bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt, struct hists *hists)
2417 {
2418 	struct hpp_dynamic_entry *hde;
2419 
2420 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2421 
2422 	return hists_to_evsel(hists) == hde->evsel;
2423 }
2424 
__sort__hde_entry(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hist_entry * he)2425 static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2426 			     struct hist_entry *he)
2427 {
2428 	struct hpp_dynamic_entry *hde;
2429 	size_t len = fmt->user_len;
2430 	char *str, *pos;
2431 	struct tep_format_field *field;
2432 	size_t namelen;
2433 	bool last = false;
2434 	int ret;
2435 
2436 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2437 
2438 	if (!len)
2439 		len = hde_width(hde);
2440 
2441 	if (hde->raw_trace)
2442 		goto raw_field;
2443 
2444 	if (!he->trace_output)
2445 		he->trace_output = get_trace_output(he);
2446 
2447 	field = hde->field;
2448 	namelen = strlen(field->name);
2449 	str = he->trace_output;
2450 
2451 	while (str) {
2452 		pos = strchr(str, ' ');
2453 		if (pos == NULL) {
2454 			last = true;
2455 			pos = str + strlen(str);
2456 		}
2457 
2458 		if (!strncmp(str, field->name, namelen)) {
2459 			str += namelen + 1;
2460 			str = strndup(str, pos - str);
2461 
2462 			if (str == NULL)
2463 				return scnprintf(hpp->buf, hpp->size,
2464 						 "%*.*s", len, len, "ERROR");
2465 			break;
2466 		}
2467 
2468 		if (last)
2469 			str = NULL;
2470 		else
2471 			str = pos + 1;
2472 	}
2473 
2474 	if (str == NULL) {
2475 		struct trace_seq seq;
2476 raw_field:
2477 		trace_seq_init(&seq);
2478 		tep_print_field(&seq, he->raw_data, hde->field);
2479 		str = seq.buffer;
2480 	}
2481 
2482 	ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str);
2483 	free(str);
2484 	return ret;
2485 }
2486 
__sort__hde_cmp(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2487 static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
2488 			       struct hist_entry *a, struct hist_entry *b)
2489 {
2490 	struct hpp_dynamic_entry *hde;
2491 	struct tep_format_field *field;
2492 	unsigned offset, size;
2493 
2494 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2495 
2496 	if (b == NULL) {
2497 		update_dynamic_len(hde, a);
2498 		return 0;
2499 	}
2500 
2501 	field = hde->field;
2502 	if (field->flags & TEP_FIELD_IS_DYNAMIC) {
2503 		unsigned long long dyn;
2504 
2505 		tep_read_number_field(field, a->raw_data, &dyn);
2506 		offset = dyn & 0xffff;
2507 		size = (dyn >> 16) & 0xffff;
2508 		if (field->flags & TEP_FIELD_IS_RELATIVE)
2509 			offset += field->offset + field->size;
2510 
2511 		/* record max width for output */
2512 		if (size > hde->dynamic_len)
2513 			hde->dynamic_len = size;
2514 	} else {
2515 		offset = field->offset;
2516 		size = field->size;
2517 	}
2518 
2519 	return memcmp(a->raw_data + offset, b->raw_data + offset, size);
2520 }
2521 
perf_hpp__is_dynamic_entry(struct perf_hpp_fmt * fmt)2522 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt)
2523 {
2524 	return fmt->cmp == __sort__hde_cmp;
2525 }
2526 
__sort__hde_equal(struct perf_hpp_fmt * a,struct perf_hpp_fmt * b)2527 static bool __sort__hde_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
2528 {
2529 	struct hpp_dynamic_entry *hde_a;
2530 	struct hpp_dynamic_entry *hde_b;
2531 
2532 	if (!perf_hpp__is_dynamic_entry(a) || !perf_hpp__is_dynamic_entry(b))
2533 		return false;
2534 
2535 	hde_a = container_of(a, struct hpp_dynamic_entry, hpp);
2536 	hde_b = container_of(b, struct hpp_dynamic_entry, hpp);
2537 
2538 	return hde_a->field == hde_b->field;
2539 }
2540 
hde_free(struct perf_hpp_fmt * fmt)2541 static void hde_free(struct perf_hpp_fmt *fmt)
2542 {
2543 	struct hpp_dynamic_entry *hde;
2544 
2545 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2546 	free(hde);
2547 }
2548 
2549 static struct hpp_dynamic_entry *
__alloc_dynamic_entry(struct evsel * evsel,struct tep_format_field * field,int level)2550 __alloc_dynamic_entry(struct evsel *evsel, struct tep_format_field *field,
2551 		      int level)
2552 {
2553 	struct hpp_dynamic_entry *hde;
2554 
2555 	hde = malloc(sizeof(*hde));
2556 	if (hde == NULL) {
2557 		pr_debug("Memory allocation failed\n");
2558 		return NULL;
2559 	}
2560 
2561 	hde->evsel = evsel;
2562 	hde->field = field;
2563 	hde->dynamic_len = 0;
2564 
2565 	hde->hpp.name = field->name;
2566 	hde->hpp.header = __sort__hde_header;
2567 	hde->hpp.width  = __sort__hde_width;
2568 	hde->hpp.entry  = __sort__hde_entry;
2569 	hde->hpp.color  = NULL;
2570 
2571 	hde->hpp.cmp = __sort__hde_cmp;
2572 	hde->hpp.collapse = __sort__hde_cmp;
2573 	hde->hpp.sort = __sort__hde_cmp;
2574 	hde->hpp.equal = __sort__hde_equal;
2575 	hde->hpp.free = hde_free;
2576 
2577 	INIT_LIST_HEAD(&hde->hpp.list);
2578 	INIT_LIST_HEAD(&hde->hpp.sort_list);
2579 	hde->hpp.elide = false;
2580 	hde->hpp.len = 0;
2581 	hde->hpp.user_len = 0;
2582 	hde->hpp.level = level;
2583 
2584 	return hde;
2585 }
2586 
perf_hpp_fmt__dup(struct perf_hpp_fmt * fmt)2587 struct perf_hpp_fmt *perf_hpp_fmt__dup(struct perf_hpp_fmt *fmt)
2588 {
2589 	struct perf_hpp_fmt *new_fmt = NULL;
2590 
2591 	if (perf_hpp__is_sort_entry(fmt)) {
2592 		struct hpp_sort_entry *hse, *new_hse;
2593 
2594 		hse = container_of(fmt, struct hpp_sort_entry, hpp);
2595 		new_hse = memdup(hse, sizeof(*hse));
2596 		if (new_hse)
2597 			new_fmt = &new_hse->hpp;
2598 	} else if (perf_hpp__is_dynamic_entry(fmt)) {
2599 		struct hpp_dynamic_entry *hde, *new_hde;
2600 
2601 		hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2602 		new_hde = memdup(hde, sizeof(*hde));
2603 		if (new_hde)
2604 			new_fmt = &new_hde->hpp;
2605 	} else {
2606 		new_fmt = memdup(fmt, sizeof(*fmt));
2607 	}
2608 
2609 	INIT_LIST_HEAD(&new_fmt->list);
2610 	INIT_LIST_HEAD(&new_fmt->sort_list);
2611 
2612 	return new_fmt;
2613 }
2614 
parse_field_name(char * str,char ** event,char ** field,char ** opt)2615 static int parse_field_name(char *str, char **event, char **field, char **opt)
2616 {
2617 	char *event_name, *field_name, *opt_name;
2618 
2619 	event_name = str;
2620 	field_name = strchr(str, '.');
2621 
2622 	if (field_name) {
2623 		*field_name++ = '\0';
2624 	} else {
2625 		event_name = NULL;
2626 		field_name = str;
2627 	}
2628 
2629 	opt_name = strchr(field_name, '/');
2630 	if (opt_name)
2631 		*opt_name++ = '\0';
2632 
2633 	*event = event_name;
2634 	*field = field_name;
2635 	*opt   = opt_name;
2636 
2637 	return 0;
2638 }
2639 
2640 /* find match evsel using a given event name.  The event name can be:
2641  *   1. '%' + event index (e.g. '%1' for first event)
2642  *   2. full event name (e.g. sched:sched_switch)
2643  *   3. partial event name (should not contain ':')
2644  */
find_evsel(struct evlist * evlist,char * event_name)2645 static struct evsel *find_evsel(struct evlist *evlist, char *event_name)
2646 {
2647 	struct evsel *evsel = NULL;
2648 	struct evsel *pos;
2649 	bool full_name;
2650 
2651 	/* case 1 */
2652 	if (event_name[0] == '%') {
2653 		int nr = strtol(event_name+1, NULL, 0);
2654 
2655 		if (nr > evlist->core.nr_entries)
2656 			return NULL;
2657 
2658 		evsel = evlist__first(evlist);
2659 		while (--nr > 0)
2660 			evsel = evsel__next(evsel);
2661 
2662 		return evsel;
2663 	}
2664 
2665 	full_name = !!strchr(event_name, ':');
2666 	evlist__for_each_entry(evlist, pos) {
2667 		/* case 2 */
2668 		if (full_name && !strcmp(pos->name, event_name))
2669 			return pos;
2670 		/* case 3 */
2671 		if (!full_name && strstr(pos->name, event_name)) {
2672 			if (evsel) {
2673 				pr_debug("'%s' event is ambiguous: it can be %s or %s\n",
2674 					 event_name, evsel->name, pos->name);
2675 				return NULL;
2676 			}
2677 			evsel = pos;
2678 		}
2679 	}
2680 
2681 	return evsel;
2682 }
2683 
__dynamic_dimension__add(struct evsel * evsel,struct tep_format_field * field,bool raw_trace,int level)2684 static int __dynamic_dimension__add(struct evsel *evsel,
2685 				    struct tep_format_field *field,
2686 				    bool raw_trace, int level)
2687 {
2688 	struct hpp_dynamic_entry *hde;
2689 
2690 	hde = __alloc_dynamic_entry(evsel, field, level);
2691 	if (hde == NULL)
2692 		return -ENOMEM;
2693 
2694 	hde->raw_trace = raw_trace;
2695 
2696 	perf_hpp__register_sort_field(&hde->hpp);
2697 	return 0;
2698 }
2699 
add_evsel_fields(struct evsel * evsel,bool raw_trace,int level)2700 static int add_evsel_fields(struct evsel *evsel, bool raw_trace, int level)
2701 {
2702 	int ret;
2703 	struct tep_format_field *field;
2704 
2705 	field = evsel->tp_format->format.fields;
2706 	while (field) {
2707 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
2708 		if (ret < 0)
2709 			return ret;
2710 
2711 		field = field->next;
2712 	}
2713 	return 0;
2714 }
2715 
add_all_dynamic_fields(struct evlist * evlist,bool raw_trace,int level)2716 static int add_all_dynamic_fields(struct evlist *evlist, bool raw_trace,
2717 				  int level)
2718 {
2719 	int ret;
2720 	struct evsel *evsel;
2721 
2722 	evlist__for_each_entry(evlist, evsel) {
2723 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
2724 			continue;
2725 
2726 		ret = add_evsel_fields(evsel, raw_trace, level);
2727 		if (ret < 0)
2728 			return ret;
2729 	}
2730 	return 0;
2731 }
2732 
add_all_matching_fields(struct evlist * evlist,char * field_name,bool raw_trace,int level)2733 static int add_all_matching_fields(struct evlist *evlist,
2734 				   char *field_name, bool raw_trace, int level)
2735 {
2736 	int ret = -ESRCH;
2737 	struct evsel *evsel;
2738 	struct tep_format_field *field;
2739 
2740 	evlist__for_each_entry(evlist, evsel) {
2741 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
2742 			continue;
2743 
2744 		field = tep_find_any_field(evsel->tp_format, field_name);
2745 		if (field == NULL)
2746 			continue;
2747 
2748 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
2749 		if (ret < 0)
2750 			break;
2751 	}
2752 	return ret;
2753 }
2754 
add_dynamic_entry(struct evlist * evlist,const char * tok,int level)2755 static int add_dynamic_entry(struct evlist *evlist, const char *tok,
2756 			     int level)
2757 {
2758 	char *str, *event_name, *field_name, *opt_name;
2759 	struct evsel *evsel;
2760 	struct tep_format_field *field;
2761 	bool raw_trace = symbol_conf.raw_trace;
2762 	int ret = 0;
2763 
2764 	if (evlist == NULL)
2765 		return -ENOENT;
2766 
2767 	str = strdup(tok);
2768 	if (str == NULL)
2769 		return -ENOMEM;
2770 
2771 	if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) {
2772 		ret = -EINVAL;
2773 		goto out;
2774 	}
2775 
2776 	if (opt_name) {
2777 		if (strcmp(opt_name, "raw")) {
2778 			pr_debug("unsupported field option %s\n", opt_name);
2779 			ret = -EINVAL;
2780 			goto out;
2781 		}
2782 		raw_trace = true;
2783 	}
2784 
2785 	if (!strcmp(field_name, "trace_fields")) {
2786 		ret = add_all_dynamic_fields(evlist, raw_trace, level);
2787 		goto out;
2788 	}
2789 
2790 	if (event_name == NULL) {
2791 		ret = add_all_matching_fields(evlist, field_name, raw_trace, level);
2792 		goto out;
2793 	}
2794 
2795 	evsel = find_evsel(evlist, event_name);
2796 	if (evsel == NULL) {
2797 		pr_debug("Cannot find event: %s\n", event_name);
2798 		ret = -ENOENT;
2799 		goto out;
2800 	}
2801 
2802 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
2803 		pr_debug("%s is not a tracepoint event\n", event_name);
2804 		ret = -EINVAL;
2805 		goto out;
2806 	}
2807 
2808 	if (!strcmp(field_name, "*")) {
2809 		ret = add_evsel_fields(evsel, raw_trace, level);
2810 	} else {
2811 		field = tep_find_any_field(evsel->tp_format, field_name);
2812 		if (field == NULL) {
2813 			pr_debug("Cannot find event field for %s.%s\n",
2814 				 event_name, field_name);
2815 			return -ENOENT;
2816 		}
2817 
2818 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
2819 	}
2820 
2821 out:
2822 	free(str);
2823 	return ret;
2824 }
2825 
__sort_dimension__add(struct sort_dimension * sd,struct perf_hpp_list * list,int level)2826 static int __sort_dimension__add(struct sort_dimension *sd,
2827 				 struct perf_hpp_list *list,
2828 				 int level)
2829 {
2830 	if (sd->taken)
2831 		return 0;
2832 
2833 	if (__sort_dimension__add_hpp_sort(sd, list, level) < 0)
2834 		return -1;
2835 
2836 	if (sd->entry->se_collapse)
2837 		list->need_collapse = 1;
2838 
2839 	sd->taken = 1;
2840 
2841 	return 0;
2842 }
2843 
__hpp_dimension__add(struct hpp_dimension * hd,struct perf_hpp_list * list,int level)2844 static int __hpp_dimension__add(struct hpp_dimension *hd,
2845 				struct perf_hpp_list *list,
2846 				int level)
2847 {
2848 	struct perf_hpp_fmt *fmt;
2849 
2850 	if (hd->taken)
2851 		return 0;
2852 
2853 	fmt = __hpp_dimension__alloc_hpp(hd, level);
2854 	if (!fmt)
2855 		return -1;
2856 
2857 	hd->taken = 1;
2858 	perf_hpp_list__register_sort_field(list, fmt);
2859 	return 0;
2860 }
2861 
__sort_dimension__add_output(struct perf_hpp_list * list,struct sort_dimension * sd)2862 static int __sort_dimension__add_output(struct perf_hpp_list *list,
2863 					struct sort_dimension *sd)
2864 {
2865 	if (sd->taken)
2866 		return 0;
2867 
2868 	if (__sort_dimension__add_hpp_output(sd, list) < 0)
2869 		return -1;
2870 
2871 	sd->taken = 1;
2872 	return 0;
2873 }
2874 
__hpp_dimension__add_output(struct perf_hpp_list * list,struct hpp_dimension * hd)2875 static int __hpp_dimension__add_output(struct perf_hpp_list *list,
2876 				       struct hpp_dimension *hd)
2877 {
2878 	struct perf_hpp_fmt *fmt;
2879 
2880 	if (hd->taken)
2881 		return 0;
2882 
2883 	fmt = __hpp_dimension__alloc_hpp(hd, 0);
2884 	if (!fmt)
2885 		return -1;
2886 
2887 	hd->taken = 1;
2888 	perf_hpp_list__column_register(list, fmt);
2889 	return 0;
2890 }
2891 
hpp_dimension__add_output(unsigned col)2892 int hpp_dimension__add_output(unsigned col)
2893 {
2894 	BUG_ON(col >= PERF_HPP__MAX_INDEX);
2895 	return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]);
2896 }
2897 
sort_dimension__add(struct perf_hpp_list * list,const char * tok,struct evlist * evlist,int level)2898 int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
2899 			struct evlist *evlist,
2900 			int level)
2901 {
2902 	unsigned int i, j;
2903 
2904 	/*
2905 	 * Check to see if there are any arch specific
2906 	 * sort dimensions not applicable for the current
2907 	 * architecture. If so, Skip that sort key since
2908 	 * we don't want to display it in the output fields.
2909 	 */
2910 	for (j = 0; j < ARRAY_SIZE(arch_specific_sort_keys); j++) {
2911 		if (!strcmp(arch_specific_sort_keys[j], tok) &&
2912 				!arch_support_sort_key(tok)) {
2913 			return 0;
2914 		}
2915 	}
2916 
2917 	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
2918 		struct sort_dimension *sd = &common_sort_dimensions[i];
2919 
2920 		if (strncasecmp(tok, sd->name, strlen(tok)))
2921 			continue;
2922 
2923 		for (j = 0; j < ARRAY_SIZE(dynamic_headers); j++) {
2924 			if (!strcmp(dynamic_headers[j], sd->name))
2925 				sort_dimension_add_dynamic_header(sd);
2926 		}
2927 
2928 		if (sd->entry == &sort_parent) {
2929 			int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
2930 			if (ret) {
2931 				char err[BUFSIZ];
2932 
2933 				regerror(ret, &parent_regex, err, sizeof(err));
2934 				pr_err("Invalid regex: %s\n%s", parent_pattern, err);
2935 				return -EINVAL;
2936 			}
2937 			list->parent = 1;
2938 		} else if (sd->entry == &sort_sym) {
2939 			list->sym = 1;
2940 			/*
2941 			 * perf diff displays the performance difference amongst
2942 			 * two or more perf.data files. Those files could come
2943 			 * from different binaries. So we should not compare
2944 			 * their ips, but the name of symbol.
2945 			 */
2946 			if (sort__mode == SORT_MODE__DIFF)
2947 				sd->entry->se_collapse = sort__sym_sort;
2948 
2949 		} else if (sd->entry == &sort_dso) {
2950 			list->dso = 1;
2951 		} else if (sd->entry == &sort_socket) {
2952 			list->socket = 1;
2953 		} else if (sd->entry == &sort_thread) {
2954 			list->thread = 1;
2955 		} else if (sd->entry == &sort_comm) {
2956 			list->comm = 1;
2957 		}
2958 
2959 		return __sort_dimension__add(sd, list, level);
2960 	}
2961 
2962 	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
2963 		struct hpp_dimension *hd = &hpp_sort_dimensions[i];
2964 
2965 		if (strncasecmp(tok, hd->name, strlen(tok)))
2966 			continue;
2967 
2968 		return __hpp_dimension__add(hd, list, level);
2969 	}
2970 
2971 	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
2972 		struct sort_dimension *sd = &bstack_sort_dimensions[i];
2973 
2974 		if (strncasecmp(tok, sd->name, strlen(tok)))
2975 			continue;
2976 
2977 		if (sort__mode != SORT_MODE__BRANCH)
2978 			return -EINVAL;
2979 
2980 		if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
2981 			list->sym = 1;
2982 
2983 		__sort_dimension__add(sd, list, level);
2984 		return 0;
2985 	}
2986 
2987 	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
2988 		struct sort_dimension *sd = &memory_sort_dimensions[i];
2989 
2990 		if (strncasecmp(tok, sd->name, strlen(tok)))
2991 			continue;
2992 
2993 		if (sort__mode != SORT_MODE__MEMORY)
2994 			return -EINVAL;
2995 
2996 		if (sd->entry == &sort_mem_dcacheline && cacheline_size() == 0)
2997 			return -EINVAL;
2998 
2999 		if (sd->entry == &sort_mem_daddr_sym)
3000 			list->sym = 1;
3001 
3002 		__sort_dimension__add(sd, list, level);
3003 		return 0;
3004 	}
3005 
3006 	if (!add_dynamic_entry(evlist, tok, level))
3007 		return 0;
3008 
3009 	return -ESRCH;
3010 }
3011 
setup_sort_list(struct perf_hpp_list * list,char * str,struct evlist * evlist)3012 static int setup_sort_list(struct perf_hpp_list *list, char *str,
3013 			   struct evlist *evlist)
3014 {
3015 	char *tmp, *tok;
3016 	int ret = 0;
3017 	int level = 0;
3018 	int next_level = 1;
3019 	bool in_group = false;
3020 
3021 	do {
3022 		tok = str;
3023 		tmp = strpbrk(str, "{}, ");
3024 		if (tmp) {
3025 			if (in_group)
3026 				next_level = level;
3027 			else
3028 				next_level = level + 1;
3029 
3030 			if (*tmp == '{')
3031 				in_group = true;
3032 			else if (*tmp == '}')
3033 				in_group = false;
3034 
3035 			*tmp = '\0';
3036 			str = tmp + 1;
3037 		}
3038 
3039 		if (*tok) {
3040 			ret = sort_dimension__add(list, tok, evlist, level);
3041 			if (ret == -EINVAL) {
3042 				if (!cacheline_size() && !strncasecmp(tok, "dcacheline", strlen(tok)))
3043 					ui__error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
3044 				else
3045 					ui__error("Invalid --sort key: `%s'", tok);
3046 				break;
3047 			} else if (ret == -ESRCH) {
3048 				ui__error("Unknown --sort key: `%s'", tok);
3049 				break;
3050 			}
3051 		}
3052 
3053 		level = next_level;
3054 	} while (tmp);
3055 
3056 	return ret;
3057 }
3058 
get_default_sort_order(struct evlist * evlist)3059 static const char *get_default_sort_order(struct evlist *evlist)
3060 {
3061 	const char *default_sort_orders[] = {
3062 		default_sort_order,
3063 		default_branch_sort_order,
3064 		default_mem_sort_order,
3065 		default_top_sort_order,
3066 		default_diff_sort_order,
3067 		default_tracepoint_sort_order,
3068 	};
3069 	bool use_trace = true;
3070 	struct evsel *evsel;
3071 
3072 	BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
3073 
3074 	if (evlist == NULL || evlist__empty(evlist))
3075 		goto out_no_evlist;
3076 
3077 	evlist__for_each_entry(evlist, evsel) {
3078 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
3079 			use_trace = false;
3080 			break;
3081 		}
3082 	}
3083 
3084 	if (use_trace) {
3085 		sort__mode = SORT_MODE__TRACEPOINT;
3086 		if (symbol_conf.raw_trace)
3087 			return "trace_fields";
3088 	}
3089 out_no_evlist:
3090 	return default_sort_orders[sort__mode];
3091 }
3092 
setup_sort_order(struct evlist * evlist)3093 static int setup_sort_order(struct evlist *evlist)
3094 {
3095 	char *new_sort_order;
3096 
3097 	/*
3098 	 * Append '+'-prefixed sort order to the default sort
3099 	 * order string.
3100 	 */
3101 	if (!sort_order || is_strict_order(sort_order))
3102 		return 0;
3103 
3104 	if (sort_order[1] == '\0') {
3105 		ui__error("Invalid --sort key: `+'");
3106 		return -EINVAL;
3107 	}
3108 
3109 	/*
3110 	 * We allocate new sort_order string, but we never free it,
3111 	 * because it's checked over the rest of the code.
3112 	 */
3113 	if (asprintf(&new_sort_order, "%s,%s",
3114 		     get_default_sort_order(evlist), sort_order + 1) < 0) {
3115 		pr_err("Not enough memory to set up --sort");
3116 		return -ENOMEM;
3117 	}
3118 
3119 	sort_order = new_sort_order;
3120 	return 0;
3121 }
3122 
3123 /*
3124  * Adds 'pre,' prefix into 'str' is 'pre' is
3125  * not already part of 'str'.
3126  */
prefix_if_not_in(const char * pre,char * str)3127 static char *prefix_if_not_in(const char *pre, char *str)
3128 {
3129 	char *n;
3130 
3131 	if (!str || strstr(str, pre))
3132 		return str;
3133 
3134 	if (asprintf(&n, "%s,%s", pre, str) < 0)
3135 		n = NULL;
3136 
3137 	free(str);
3138 	return n;
3139 }
3140 
setup_overhead(char * keys)3141 static char *setup_overhead(char *keys)
3142 {
3143 	if (sort__mode == SORT_MODE__DIFF)
3144 		return keys;
3145 
3146 	keys = prefix_if_not_in("overhead", keys);
3147 
3148 	if (symbol_conf.cumulate_callchain)
3149 		keys = prefix_if_not_in("overhead_children", keys);
3150 
3151 	return keys;
3152 }
3153 
__setup_sorting(struct evlist * evlist)3154 static int __setup_sorting(struct evlist *evlist)
3155 {
3156 	char *str;
3157 	const char *sort_keys;
3158 	int ret = 0;
3159 
3160 	ret = setup_sort_order(evlist);
3161 	if (ret)
3162 		return ret;
3163 
3164 	sort_keys = sort_order;
3165 	if (sort_keys == NULL) {
3166 		if (is_strict_order(field_order)) {
3167 			/*
3168 			 * If user specified field order but no sort order,
3169 			 * we'll honor it and not add default sort orders.
3170 			 */
3171 			return 0;
3172 		}
3173 
3174 		sort_keys = get_default_sort_order(evlist);
3175 	}
3176 
3177 	str = strdup(sort_keys);
3178 	if (str == NULL) {
3179 		pr_err("Not enough memory to setup sort keys");
3180 		return -ENOMEM;
3181 	}
3182 
3183 	/*
3184 	 * Prepend overhead fields for backward compatibility.
3185 	 */
3186 	if (!is_strict_order(field_order)) {
3187 		str = setup_overhead(str);
3188 		if (str == NULL) {
3189 			pr_err("Not enough memory to setup overhead keys");
3190 			return -ENOMEM;
3191 		}
3192 	}
3193 
3194 	ret = setup_sort_list(&perf_hpp_list, str, evlist);
3195 
3196 	free(str);
3197 	return ret;
3198 }
3199 
perf_hpp__set_elide(int idx,bool elide)3200 void perf_hpp__set_elide(int idx, bool elide)
3201 {
3202 	struct perf_hpp_fmt *fmt;
3203 	struct hpp_sort_entry *hse;
3204 
3205 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3206 		if (!perf_hpp__is_sort_entry(fmt))
3207 			continue;
3208 
3209 		hse = container_of(fmt, struct hpp_sort_entry, hpp);
3210 		if (hse->se->se_width_idx == idx) {
3211 			fmt->elide = elide;
3212 			break;
3213 		}
3214 	}
3215 }
3216 
__get_elide(struct strlist * list,const char * list_name,FILE * fp)3217 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
3218 {
3219 	if (list && strlist__nr_entries(list) == 1) {
3220 		if (fp != NULL)
3221 			fprintf(fp, "# %s: %s\n", list_name,
3222 				strlist__entry(list, 0)->s);
3223 		return true;
3224 	}
3225 	return false;
3226 }
3227 
get_elide(int idx,FILE * output)3228 static bool get_elide(int idx, FILE *output)
3229 {
3230 	switch (idx) {
3231 	case HISTC_SYMBOL:
3232 		return __get_elide(symbol_conf.sym_list, "symbol", output);
3233 	case HISTC_DSO:
3234 		return __get_elide(symbol_conf.dso_list, "dso", output);
3235 	case HISTC_COMM:
3236 		return __get_elide(symbol_conf.comm_list, "comm", output);
3237 	default:
3238 		break;
3239 	}
3240 
3241 	if (sort__mode != SORT_MODE__BRANCH)
3242 		return false;
3243 
3244 	switch (idx) {
3245 	case HISTC_SYMBOL_FROM:
3246 		return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
3247 	case HISTC_SYMBOL_TO:
3248 		return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
3249 	case HISTC_DSO_FROM:
3250 		return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
3251 	case HISTC_DSO_TO:
3252 		return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
3253 	case HISTC_ADDR_FROM:
3254 		return __get_elide(symbol_conf.sym_from_list, "addr_from", output);
3255 	case HISTC_ADDR_TO:
3256 		return __get_elide(symbol_conf.sym_to_list, "addr_to", output);
3257 	default:
3258 		break;
3259 	}
3260 
3261 	return false;
3262 }
3263 
sort__setup_elide(FILE * output)3264 void sort__setup_elide(FILE *output)
3265 {
3266 	struct perf_hpp_fmt *fmt;
3267 	struct hpp_sort_entry *hse;
3268 
3269 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3270 		if (!perf_hpp__is_sort_entry(fmt))
3271 			continue;
3272 
3273 		hse = container_of(fmt, struct hpp_sort_entry, hpp);
3274 		fmt->elide = get_elide(hse->se->se_width_idx, output);
3275 	}
3276 
3277 	/*
3278 	 * It makes no sense to elide all of sort entries.
3279 	 * Just revert them to show up again.
3280 	 */
3281 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3282 		if (!perf_hpp__is_sort_entry(fmt))
3283 			continue;
3284 
3285 		if (!fmt->elide)
3286 			return;
3287 	}
3288 
3289 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3290 		if (!perf_hpp__is_sort_entry(fmt))
3291 			continue;
3292 
3293 		fmt->elide = false;
3294 	}
3295 }
3296 
output_field_add(struct perf_hpp_list * list,char * tok)3297 int output_field_add(struct perf_hpp_list *list, char *tok)
3298 {
3299 	unsigned int i;
3300 
3301 	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
3302 		struct sort_dimension *sd = &common_sort_dimensions[i];
3303 
3304 		if (strncasecmp(tok, sd->name, strlen(tok)))
3305 			continue;
3306 
3307 		return __sort_dimension__add_output(list, sd);
3308 	}
3309 
3310 	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
3311 		struct hpp_dimension *hd = &hpp_sort_dimensions[i];
3312 
3313 		if (strncasecmp(tok, hd->name, strlen(tok)))
3314 			continue;
3315 
3316 		return __hpp_dimension__add_output(list, hd);
3317 	}
3318 
3319 	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
3320 		struct sort_dimension *sd = &bstack_sort_dimensions[i];
3321 
3322 		if (strncasecmp(tok, sd->name, strlen(tok)))
3323 			continue;
3324 
3325 		if (sort__mode != SORT_MODE__BRANCH)
3326 			return -EINVAL;
3327 
3328 		return __sort_dimension__add_output(list, sd);
3329 	}
3330 
3331 	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
3332 		struct sort_dimension *sd = &memory_sort_dimensions[i];
3333 
3334 		if (strncasecmp(tok, sd->name, strlen(tok)))
3335 			continue;
3336 
3337 		if (sort__mode != SORT_MODE__MEMORY)
3338 			return -EINVAL;
3339 
3340 		return __sort_dimension__add_output(list, sd);
3341 	}
3342 
3343 	return -ESRCH;
3344 }
3345 
setup_output_list(struct perf_hpp_list * list,char * str)3346 static int setup_output_list(struct perf_hpp_list *list, char *str)
3347 {
3348 	char *tmp, *tok;
3349 	int ret = 0;
3350 
3351 	for (tok = strtok_r(str, ", ", &tmp);
3352 			tok; tok = strtok_r(NULL, ", ", &tmp)) {
3353 		ret = output_field_add(list, tok);
3354 		if (ret == -EINVAL) {
3355 			ui__error("Invalid --fields key: `%s'", tok);
3356 			break;
3357 		} else if (ret == -ESRCH) {
3358 			ui__error("Unknown --fields key: `%s'", tok);
3359 			break;
3360 		}
3361 	}
3362 
3363 	return ret;
3364 }
3365 
reset_dimensions(void)3366 void reset_dimensions(void)
3367 {
3368 	unsigned int i;
3369 
3370 	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
3371 		common_sort_dimensions[i].taken = 0;
3372 
3373 	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
3374 		hpp_sort_dimensions[i].taken = 0;
3375 
3376 	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
3377 		bstack_sort_dimensions[i].taken = 0;
3378 
3379 	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
3380 		memory_sort_dimensions[i].taken = 0;
3381 }
3382 
is_strict_order(const char * order)3383 bool is_strict_order(const char *order)
3384 {
3385 	return order && (*order != '+');
3386 }
3387 
__setup_output_field(void)3388 static int __setup_output_field(void)
3389 {
3390 	char *str, *strp;
3391 	int ret = -EINVAL;
3392 
3393 	if (field_order == NULL)
3394 		return 0;
3395 
3396 	strp = str = strdup(field_order);
3397 	if (str == NULL) {
3398 		pr_err("Not enough memory to setup output fields");
3399 		return -ENOMEM;
3400 	}
3401 
3402 	if (!is_strict_order(field_order))
3403 		strp++;
3404 
3405 	if (!strlen(strp)) {
3406 		ui__error("Invalid --fields key: `+'");
3407 		goto out;
3408 	}
3409 
3410 	ret = setup_output_list(&perf_hpp_list, strp);
3411 
3412 out:
3413 	free(str);
3414 	return ret;
3415 }
3416 
setup_sorting(struct evlist * evlist)3417 int setup_sorting(struct evlist *evlist)
3418 {
3419 	int err;
3420 
3421 	err = __setup_sorting(evlist);
3422 	if (err < 0)
3423 		return err;
3424 
3425 	if (parent_pattern != default_parent_pattern) {
3426 		err = sort_dimension__add(&perf_hpp_list, "parent", evlist, -1);
3427 		if (err < 0)
3428 			return err;
3429 	}
3430 
3431 	reset_dimensions();
3432 
3433 	/*
3434 	 * perf diff doesn't use default hpp output fields.
3435 	 */
3436 	if (sort__mode != SORT_MODE__DIFF)
3437 		perf_hpp__init();
3438 
3439 	err = __setup_output_field();
3440 	if (err < 0)
3441 		return err;
3442 
3443 	/* copy sort keys to output fields */
3444 	perf_hpp__setup_output_field(&perf_hpp_list);
3445 	/* and then copy output fields to sort keys */
3446 	perf_hpp__append_sort_keys(&perf_hpp_list);
3447 
3448 	/* setup hists-specific output fields */
3449 	if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0)
3450 		return -1;
3451 
3452 	return 0;
3453 }
3454 
reset_output_field(void)3455 void reset_output_field(void)
3456 {
3457 	perf_hpp_list.need_collapse = 0;
3458 	perf_hpp_list.parent = 0;
3459 	perf_hpp_list.sym = 0;
3460 	perf_hpp_list.dso = 0;
3461 
3462 	field_order = NULL;
3463 	sort_order = NULL;
3464 
3465 	reset_dimensions();
3466 	perf_hpp__reset_output_field(&perf_hpp_list);
3467 }
3468 
3469 #define INDENT (3*8 + 1)
3470 
add_key(struct strbuf * sb,const char * str,int * llen)3471 static void add_key(struct strbuf *sb, const char *str, int *llen)
3472 {
3473 	if (*llen >= 75) {
3474 		strbuf_addstr(sb, "\n\t\t\t ");
3475 		*llen = INDENT;
3476 	}
3477 	strbuf_addf(sb, " %s", str);
3478 	*llen += strlen(str) + 1;
3479 }
3480 
add_sort_string(struct strbuf * sb,struct sort_dimension * s,int n,int * llen)3481 static void add_sort_string(struct strbuf *sb, struct sort_dimension *s, int n,
3482 			    int *llen)
3483 {
3484 	int i;
3485 
3486 	for (i = 0; i < n; i++)
3487 		add_key(sb, s[i].name, llen);
3488 }
3489 
add_hpp_sort_string(struct strbuf * sb,struct hpp_dimension * s,int n,int * llen)3490 static void add_hpp_sort_string(struct strbuf *sb, struct hpp_dimension *s, int n,
3491 				int *llen)
3492 {
3493 	int i;
3494 
3495 	for (i = 0; i < n; i++)
3496 		add_key(sb, s[i].name, llen);
3497 }
3498 
sort_help(const char * prefix)3499 char *sort_help(const char *prefix)
3500 {
3501 	struct strbuf sb;
3502 	char *s;
3503 	int len = strlen(prefix) + INDENT;
3504 
3505 	strbuf_init(&sb, 300);
3506 	strbuf_addstr(&sb, prefix);
3507 	add_hpp_sort_string(&sb, hpp_sort_dimensions,
3508 			    ARRAY_SIZE(hpp_sort_dimensions), &len);
3509 	add_sort_string(&sb, common_sort_dimensions,
3510 			    ARRAY_SIZE(common_sort_dimensions), &len);
3511 	add_sort_string(&sb, bstack_sort_dimensions,
3512 			    ARRAY_SIZE(bstack_sort_dimensions), &len);
3513 	add_sort_string(&sb, memory_sort_dimensions,
3514 			    ARRAY_SIZE(memory_sort_dimensions), &len);
3515 	s = strbuf_detach(&sb, NULL);
3516 	strbuf_release(&sb);
3517 	return s;
3518 }
3519