• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // SPDX-License-Identifier: GPL-2.0
2 #include "builtin.h"
3 
4 #include "util/counts.h"
5 #include "util/debug.h"
6 #include "util/dso.h"
7 #include <subcmd/exec-cmd.h>
8 #include "util/header.h"
9 #include <subcmd/parse-options.h>
10 #include "util/perf_regs.h"
11 #include "util/session.h"
12 #include "util/tool.h"
13 #include "util/map.h"
14 #include "util/srcline.h"
15 #include "util/symbol.h"
16 #include "util/thread.h"
17 #include "util/trace-event.h"
18 #include "util/evlist.h"
19 #include "util/evsel.h"
20 #include "util/evsel_fprintf.h"
21 #include "util/evswitch.h"
22 #include "util/sort.h"
23 #include "util/data.h"
24 #include "util/auxtrace.h"
25 #include "util/cpumap.h"
26 #include "util/thread_map.h"
27 #include "util/stat.h"
28 #include "util/color.h"
29 #include "util/string2.h"
30 #include "util/thread-stack.h"
31 #include "util/time-utils.h"
32 #include "util/path.h"
33 #include "ui/ui.h"
34 #include "print_binary.h"
35 #include "archinsn.h"
36 #include <linux/bitmap.h>
37 #include <linux/kernel.h>
38 #include <linux/stringify.h>
39 #include <linux/time64.h>
40 #include <linux/zalloc.h>
41 #include <sys/utsname.h>
42 #include "asm/bug.h"
43 #include "util/mem-events.h"
44 #include "util/dump-insn.h"
45 #include <dirent.h>
46 #include <errno.h>
47 #include <inttypes.h>
48 #include <signal.h>
49 #include <sys/param.h>
50 #include <sys/types.h>
51 #include <sys/stat.h>
52 #include <fcntl.h>
53 #include <unistd.h>
54 #include <subcmd/pager.h>
55 #include <perf/evlist.h>
56 #include <linux/err.h>
57 #include "util/record.h"
58 #include "util/util.h"
59 #include "perf.h"
60 
61 #include <linux/ctype.h>
62 
63 static char const		*script_name;
64 static char const		*generate_script_lang;
65 static bool			reltime;
66 static bool			deltatime;
67 static u64			initial_time;
68 static u64			previous_time;
69 static bool			debug_mode;
70 static u64			last_timestamp;
71 static u64			nr_unordered;
72 static bool			no_callchain;
73 static bool			latency_format;
74 static bool			system_wide;
75 static bool			print_flags;
76 static const char		*cpu_list;
77 static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
78 static struct perf_stat_config	stat_config;
79 static int			max_blocks;
80 static bool			native_arch;
81 
82 unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;
83 
84 enum perf_output_field {
85 	PERF_OUTPUT_COMM            = 1ULL << 0,
86 	PERF_OUTPUT_TID             = 1ULL << 1,
87 	PERF_OUTPUT_PID             = 1ULL << 2,
88 	PERF_OUTPUT_TIME            = 1ULL << 3,
89 	PERF_OUTPUT_CPU             = 1ULL << 4,
90 	PERF_OUTPUT_EVNAME          = 1ULL << 5,
91 	PERF_OUTPUT_TRACE           = 1ULL << 6,
92 	PERF_OUTPUT_IP              = 1ULL << 7,
93 	PERF_OUTPUT_SYM             = 1ULL << 8,
94 	PERF_OUTPUT_DSO             = 1ULL << 9,
95 	PERF_OUTPUT_ADDR            = 1ULL << 10,
96 	PERF_OUTPUT_SYMOFFSET       = 1ULL << 11,
97 	PERF_OUTPUT_SRCLINE         = 1ULL << 12,
98 	PERF_OUTPUT_PERIOD          = 1ULL << 13,
99 	PERF_OUTPUT_IREGS	    = 1ULL << 14,
100 	PERF_OUTPUT_BRSTACK	    = 1ULL << 15,
101 	PERF_OUTPUT_BRSTACKSYM	    = 1ULL << 16,
102 	PERF_OUTPUT_DATA_SRC	    = 1ULL << 17,
103 	PERF_OUTPUT_WEIGHT	    = 1ULL << 18,
104 	PERF_OUTPUT_BPF_OUTPUT	    = 1ULL << 19,
105 	PERF_OUTPUT_CALLINDENT	    = 1ULL << 20,
106 	PERF_OUTPUT_INSN	    = 1ULL << 21,
107 	PERF_OUTPUT_INSNLEN	    = 1ULL << 22,
108 	PERF_OUTPUT_BRSTACKINSN	    = 1ULL << 23,
109 	PERF_OUTPUT_BRSTACKOFF	    = 1ULL << 24,
110 	PERF_OUTPUT_SYNTH           = 1ULL << 25,
111 	PERF_OUTPUT_PHYS_ADDR       = 1ULL << 26,
112 	PERF_OUTPUT_UREGS	    = 1ULL << 27,
113 	PERF_OUTPUT_METRIC	    = 1ULL << 28,
114 	PERF_OUTPUT_MISC            = 1ULL << 29,
115 	PERF_OUTPUT_SRCCODE	    = 1ULL << 30,
116 	PERF_OUTPUT_IPC             = 1ULL << 31,
117 	PERF_OUTPUT_TOD             = 1ULL << 32,
118 };
119 
120 struct perf_script {
121 	struct perf_tool	tool;
122 	struct perf_session	*session;
123 	bool			show_task_events;
124 	bool			show_mmap_events;
125 	bool			show_switch_events;
126 	bool			show_namespace_events;
127 	bool			show_lost_events;
128 	bool			show_round_events;
129 	bool			show_bpf_events;
130 	bool			show_cgroup_events;
131 	bool			show_text_poke_events;
132 	bool			allocated;
133 	bool			per_event_dump;
134 	bool			stitch_lbr;
135 	struct evswitch		evswitch;
136 	struct perf_cpu_map	*cpus;
137 	struct perf_thread_map *threads;
138 	int			name_width;
139 	const char              *time_str;
140 	struct perf_time_interval *ptime_range;
141 	int			range_size;
142 	int			range_num;
143 };
144 
145 struct output_option {
146 	const char *str;
147 	enum perf_output_field field;
148 } all_output_options[] = {
149 	{.str = "comm",  .field = PERF_OUTPUT_COMM},
150 	{.str = "tid",   .field = PERF_OUTPUT_TID},
151 	{.str = "pid",   .field = PERF_OUTPUT_PID},
152 	{.str = "time",  .field = PERF_OUTPUT_TIME},
153 	{.str = "cpu",   .field = PERF_OUTPUT_CPU},
154 	{.str = "event", .field = PERF_OUTPUT_EVNAME},
155 	{.str = "trace", .field = PERF_OUTPUT_TRACE},
156 	{.str = "ip",    .field = PERF_OUTPUT_IP},
157 	{.str = "sym",   .field = PERF_OUTPUT_SYM},
158 	{.str = "dso",   .field = PERF_OUTPUT_DSO},
159 	{.str = "addr",  .field = PERF_OUTPUT_ADDR},
160 	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
161 	{.str = "srcline", .field = PERF_OUTPUT_SRCLINE},
162 	{.str = "period", .field = PERF_OUTPUT_PERIOD},
163 	{.str = "iregs", .field = PERF_OUTPUT_IREGS},
164 	{.str = "uregs", .field = PERF_OUTPUT_UREGS},
165 	{.str = "brstack", .field = PERF_OUTPUT_BRSTACK},
166 	{.str = "brstacksym", .field = PERF_OUTPUT_BRSTACKSYM},
167 	{.str = "data_src", .field = PERF_OUTPUT_DATA_SRC},
168 	{.str = "weight",   .field = PERF_OUTPUT_WEIGHT},
169 	{.str = "bpf-output",   .field = PERF_OUTPUT_BPF_OUTPUT},
170 	{.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},
171 	{.str = "insn", .field = PERF_OUTPUT_INSN},
172 	{.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},
173 	{.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},
174 	{.str = "brstackoff", .field = PERF_OUTPUT_BRSTACKOFF},
175 	{.str = "synth", .field = PERF_OUTPUT_SYNTH},
176 	{.str = "phys_addr", .field = PERF_OUTPUT_PHYS_ADDR},
177 	{.str = "metric", .field = PERF_OUTPUT_METRIC},
178 	{.str = "misc", .field = PERF_OUTPUT_MISC},
179 	{.str = "srccode", .field = PERF_OUTPUT_SRCCODE},
180 	{.str = "ipc", .field = PERF_OUTPUT_IPC},
181 	{.str = "tod", .field = PERF_OUTPUT_TOD},
182 };
183 
184 enum {
185 	OUTPUT_TYPE_SYNTH = PERF_TYPE_MAX,
186 	OUTPUT_TYPE_MAX
187 };
188 
189 /* default set to maintain compatibility with current format */
190 static struct {
191 	bool user_set;
192 	bool wildcard_set;
193 	unsigned int print_ip_opts;
194 	u64 fields;
195 	u64 invalid_fields;
196 	u64 user_set_fields;
197 	u64 user_unset_fields;
198 } output[OUTPUT_TYPE_MAX] = {
199 
200 	[PERF_TYPE_HARDWARE] = {
201 		.user_set = false,
202 
203 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
204 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
205 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
206 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
207 			      PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
208 
209 		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
210 	},
211 
212 	[PERF_TYPE_SOFTWARE] = {
213 		.user_set = false,
214 
215 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
216 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
217 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
218 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
219 			      PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD |
220 			      PERF_OUTPUT_BPF_OUTPUT,
221 
222 		.invalid_fields = PERF_OUTPUT_TRACE,
223 	},
224 
225 	[PERF_TYPE_TRACEPOINT] = {
226 		.user_set = false,
227 
228 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
229 				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
230 				  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE
231 	},
232 
233 	[PERF_TYPE_HW_CACHE] = {
234 		.user_set = false,
235 
236 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
237 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
238 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
239 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
240 			      PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
241 
242 		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
243 	},
244 
245 	[PERF_TYPE_RAW] = {
246 		.user_set = false,
247 
248 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
249 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
250 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
251 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
252 			      PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD |
253 			      PERF_OUTPUT_ADDR | PERF_OUTPUT_DATA_SRC |
254 			      PERF_OUTPUT_WEIGHT | PERF_OUTPUT_PHYS_ADDR,
255 
256 		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
257 	},
258 
259 	[PERF_TYPE_BREAKPOINT] = {
260 		.user_set = false,
261 
262 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
263 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
264 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
265 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
266 			      PERF_OUTPUT_DSO | PERF_OUTPUT_PERIOD,
267 
268 		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
269 	},
270 
271 	[OUTPUT_TYPE_SYNTH] = {
272 		.user_set = false,
273 
274 		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
275 			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
276 			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
277 			      PERF_OUTPUT_SYM | PERF_OUTPUT_SYMOFFSET |
278 			      PERF_OUTPUT_DSO | PERF_OUTPUT_SYNTH,
279 
280 		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
281 	},
282 };
283 
284 struct evsel_script {
285        char *filename;
286        FILE *fp;
287        u64  samples;
288        /* For metric output */
289        u64  val;
290        int  gnum;
291 };
292 
evsel_script(struct evsel * evsel)293 static inline struct evsel_script *evsel_script(struct evsel *evsel)
294 {
295 	return (struct evsel_script *)evsel->priv;
296 }
297 
perf_evsel_script__new(struct evsel * evsel,struct perf_data * data)298 static struct evsel_script *perf_evsel_script__new(struct evsel *evsel,
299 							struct perf_data *data)
300 {
301 	struct evsel_script *es = zalloc(sizeof(*es));
302 
303 	if (es != NULL) {
304 		if (asprintf(&es->filename, "%s.%s.dump", data->file.path, evsel__name(evsel)) < 0)
305 			goto out_free;
306 		es->fp = fopen(es->filename, "w");
307 		if (es->fp == NULL)
308 			goto out_free_filename;
309 	}
310 
311 	return es;
312 out_free_filename:
313 	zfree(&es->filename);
314 out_free:
315 	free(es);
316 	return NULL;
317 }
318 
perf_evsel_script__delete(struct evsel_script * es)319 static void perf_evsel_script__delete(struct evsel_script *es)
320 {
321 	zfree(&es->filename);
322 	fclose(es->fp);
323 	es->fp = NULL;
324 	free(es);
325 }
326 
perf_evsel_script__fprintf(struct evsel_script * es,FILE * fp)327 static int perf_evsel_script__fprintf(struct evsel_script *es, FILE *fp)
328 {
329 	struct stat st;
330 
331 	fstat(fileno(es->fp), &st);
332 	return fprintf(fp, "[ perf script: Wrote %.3f MB %s (%" PRIu64 " samples) ]\n",
333 		       st.st_size / 1024.0 / 1024.0, es->filename, es->samples);
334 }
335 
output_type(unsigned int type)336 static inline int output_type(unsigned int type)
337 {
338 	switch (type) {
339 	case PERF_TYPE_SYNTH:
340 		return OUTPUT_TYPE_SYNTH;
341 	default:
342 		return type;
343 	}
344 }
345 
attr_type(unsigned int type)346 static inline unsigned int attr_type(unsigned int type)
347 {
348 	switch (type) {
349 	case OUTPUT_TYPE_SYNTH:
350 		return PERF_TYPE_SYNTH;
351 	default:
352 		return type;
353 	}
354 }
355 
output_set_by_user(void)356 static bool output_set_by_user(void)
357 {
358 	int j;
359 	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
360 		if (output[j].user_set)
361 			return true;
362 	}
363 	return false;
364 }
365 
output_field2str(enum perf_output_field field)366 static const char *output_field2str(enum perf_output_field field)
367 {
368 	int i, imax = ARRAY_SIZE(all_output_options);
369 	const char *str = "";
370 
371 	for (i = 0; i < imax; ++i) {
372 		if (all_output_options[i].field == field) {
373 			str = all_output_options[i].str;
374 			break;
375 		}
376 	}
377 	return str;
378 }
379 
380 #define PRINT_FIELD(x)  (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)
381 
evsel__do_check_stype(struct evsel * evsel,u64 sample_type,const char * sample_msg,enum perf_output_field field,bool allow_user_set)382 static int evsel__do_check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
383 				 enum perf_output_field field, bool allow_user_set)
384 {
385 	struct perf_event_attr *attr = &evsel->core.attr;
386 	int type = output_type(attr->type);
387 	const char *evname;
388 
389 	if (attr->sample_type & sample_type)
390 		return 0;
391 
392 	if (output[type].user_set_fields & field) {
393 		if (allow_user_set)
394 			return 0;
395 		evname = evsel__name(evsel);
396 		pr_err("Samples for '%s' event do not have %s attribute set. "
397 		       "Cannot print '%s' field.\n",
398 		       evname, sample_msg, output_field2str(field));
399 		return -1;
400 	}
401 
402 	/* user did not ask for it explicitly so remove from the default list */
403 	output[type].fields &= ~field;
404 	evname = evsel__name(evsel);
405 	pr_debug("Samples for '%s' event do not have %s attribute set. "
406 		 "Skipping '%s' field.\n",
407 		 evname, sample_msg, output_field2str(field));
408 
409 	return 0;
410 }
411 
evsel__check_stype(struct evsel * evsel,u64 sample_type,const char * sample_msg,enum perf_output_field field)412 static int evsel__check_stype(struct evsel *evsel, u64 sample_type, const char *sample_msg,
413 			      enum perf_output_field field)
414 {
415 	return evsel__do_check_stype(evsel, sample_type, sample_msg, field, false);
416 }
417 
evsel__check_attr(struct evsel * evsel,struct perf_session * session)418 static int evsel__check_attr(struct evsel *evsel, struct perf_session *session)
419 {
420 	struct perf_event_attr *attr = &evsel->core.attr;
421 	bool allow_user_set;
422 
423 	if (perf_header__has_feat(&session->header, HEADER_STAT))
424 		return 0;
425 
426 	allow_user_set = perf_header__has_feat(&session->header,
427 					       HEADER_AUXTRACE);
428 
429 	if (PRINT_FIELD(TRACE) &&
430 	    !perf_session__has_traces(session, "record -R"))
431 		return -EINVAL;
432 
433 	if (PRINT_FIELD(IP)) {
434 		if (evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP", PERF_OUTPUT_IP))
435 			return -EINVAL;
436 	}
437 
438 	if (PRINT_FIELD(ADDR) &&
439 	    evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR", PERF_OUTPUT_ADDR, allow_user_set))
440 		return -EINVAL;
441 
442 	if (PRINT_FIELD(DATA_SRC) &&
443 	    evsel__check_stype(evsel, PERF_SAMPLE_DATA_SRC, "DATA_SRC", PERF_OUTPUT_DATA_SRC))
444 		return -EINVAL;
445 
446 	if (PRINT_FIELD(WEIGHT) &&
447 	    evsel__check_stype(evsel, PERF_SAMPLE_WEIGHT, "WEIGHT", PERF_OUTPUT_WEIGHT))
448 		return -EINVAL;
449 
450 	if (PRINT_FIELD(SYM) &&
451 	    !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
452 		pr_err("Display of symbols requested but neither sample IP nor "
453 			   "sample address\navailable. Hence, no addresses to convert "
454 		       "to symbols.\n");
455 		return -EINVAL;
456 	}
457 	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
458 		pr_err("Display of offsets requested but symbol is not"
459 		       "selected.\n");
460 		return -EINVAL;
461 	}
462 	if (PRINT_FIELD(DSO) &&
463 	    !(evsel->core.attr.sample_type & (PERF_SAMPLE_IP|PERF_SAMPLE_ADDR))) {
464 		pr_err("Display of DSO requested but no address to convert.\n");
465 		return -EINVAL;
466 	}
467 	if ((PRINT_FIELD(SRCLINE) || PRINT_FIELD(SRCCODE)) && !PRINT_FIELD(IP)) {
468 		pr_err("Display of source line number requested but sample IP is not\n"
469 		       "selected. Hence, no address to lookup the source line number.\n");
470 		return -EINVAL;
471 	}
472 	if (PRINT_FIELD(BRSTACKINSN) && !allow_user_set &&
473 	    !(evlist__combined_branch_type(session->evlist) & PERF_SAMPLE_BRANCH_ANY)) {
474 		pr_err("Display of branch stack assembler requested, but non all-branch filter set\n"
475 		       "Hint: run 'perf record -b ...'\n");
476 		return -EINVAL;
477 	}
478 	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
479 	    evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID", PERF_OUTPUT_TID|PERF_OUTPUT_PID))
480 		return -EINVAL;
481 
482 	if (PRINT_FIELD(TIME) &&
483 	    evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME", PERF_OUTPUT_TIME))
484 		return -EINVAL;
485 
486 	if (PRINT_FIELD(CPU) &&
487 	    evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU", PERF_OUTPUT_CPU, allow_user_set))
488 		return -EINVAL;
489 
490 	if (PRINT_FIELD(IREGS) &&
491 	    evsel__do_check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS", PERF_OUTPUT_IREGS, allow_user_set))
492 		return -EINVAL;
493 
494 	if (PRINT_FIELD(UREGS) &&
495 	    evsel__check_stype(evsel, PERF_SAMPLE_REGS_USER, "UREGS", PERF_OUTPUT_UREGS))
496 		return -EINVAL;
497 
498 	if (PRINT_FIELD(PHYS_ADDR) &&
499 	    evsel__check_stype(evsel, PERF_SAMPLE_PHYS_ADDR, "PHYS_ADDR", PERF_OUTPUT_PHYS_ADDR))
500 		return -EINVAL;
501 
502 	return 0;
503 }
504 
set_print_ip_opts(struct perf_event_attr * attr)505 static void set_print_ip_opts(struct perf_event_attr *attr)
506 {
507 	unsigned int type = output_type(attr->type);
508 
509 	output[type].print_ip_opts = 0;
510 	if (PRINT_FIELD(IP))
511 		output[type].print_ip_opts |= EVSEL__PRINT_IP;
512 
513 	if (PRINT_FIELD(SYM))
514 		output[type].print_ip_opts |= EVSEL__PRINT_SYM;
515 
516 	if (PRINT_FIELD(DSO))
517 		output[type].print_ip_opts |= EVSEL__PRINT_DSO;
518 
519 	if (PRINT_FIELD(SYMOFFSET))
520 		output[type].print_ip_opts |= EVSEL__PRINT_SYMOFFSET;
521 
522 	if (PRINT_FIELD(SRCLINE))
523 		output[type].print_ip_opts |= EVSEL__PRINT_SRCLINE;
524 }
525 
526 /*
527  * verify all user requested events exist and the samples
528  * have the expected data
529  */
perf_session__check_output_opt(struct perf_session * session)530 static int perf_session__check_output_opt(struct perf_session *session)
531 {
532 	bool tod = false;
533 	unsigned int j;
534 	struct evsel *evsel;
535 
536 	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
537 		evsel = perf_session__find_first_evtype(session, attr_type(j));
538 
539 		/*
540 		 * even if fields is set to 0 (ie., show nothing) event must
541 		 * exist if user explicitly includes it on the command line
542 		 */
543 		if (!evsel && output[j].user_set && !output[j].wildcard_set &&
544 		    j != OUTPUT_TYPE_SYNTH) {
545 			pr_err("%s events do not exist. "
546 			       "Remove corresponding -F option to proceed.\n",
547 			       event_type(j));
548 			return -1;
549 		}
550 
551 		if (evsel && output[j].fields &&
552 			evsel__check_attr(evsel, session))
553 			return -1;
554 
555 		if (evsel == NULL)
556 			continue;
557 
558 		set_print_ip_opts(&evsel->core.attr);
559 		tod |= output[j].fields & PERF_OUTPUT_TOD;
560 	}
561 
562 	if (!no_callchain) {
563 		bool use_callchain = false;
564 		bool not_pipe = false;
565 
566 		evlist__for_each_entry(session->evlist, evsel) {
567 			not_pipe = true;
568 			if (evsel__has_callchain(evsel)) {
569 				use_callchain = true;
570 				break;
571 			}
572 		}
573 		if (not_pipe && !use_callchain)
574 			symbol_conf.use_callchain = false;
575 	}
576 
577 	/*
578 	 * set default for tracepoints to print symbols only
579 	 * if callchains are present
580 	 */
581 	if (symbol_conf.use_callchain &&
582 	    !output[PERF_TYPE_TRACEPOINT].user_set) {
583 		j = PERF_TYPE_TRACEPOINT;
584 
585 		evlist__for_each_entry(session->evlist, evsel) {
586 			if (evsel->core.attr.type != j)
587 				continue;
588 
589 			if (evsel__has_callchain(evsel)) {
590 				output[j].fields |= PERF_OUTPUT_IP;
591 				output[j].fields |= PERF_OUTPUT_SYM;
592 				output[j].fields |= PERF_OUTPUT_SYMOFFSET;
593 				output[j].fields |= PERF_OUTPUT_DSO;
594 				set_print_ip_opts(&evsel->core.attr);
595 				goto out;
596 			}
597 		}
598 	}
599 
600 	if (tod && !session->header.env.clock.enabled) {
601 		pr_err("Can't provide 'tod' time, missing clock data. "
602 		       "Please record with -k/--clockid option.\n");
603 		return -1;
604 	}
605 out:
606 	return 0;
607 }
608 
perf_sample__fprintf_regs(struct regs_dump * regs,uint64_t mask,FILE * fp)609 static int perf_sample__fprintf_regs(struct regs_dump *regs, uint64_t mask,
610 				     FILE *fp)
611 {
612 	unsigned i = 0, r;
613 	int printed = 0;
614 
615 	if (!regs || !regs->regs)
616 		return 0;
617 
618 	printed += fprintf(fp, " ABI:%" PRIu64 " ", regs->abi);
619 
620 	for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) {
621 		u64 val = regs->regs[i++];
622 		printed += fprintf(fp, "%5s:0x%"PRIx64" ", perf_reg_name(r), val);
623 	}
624 
625 	return printed;
626 }
627 
628 #define DEFAULT_TOD_FMT "%F %H:%M:%S"
629 
630 static char*
tod_scnprintf(struct perf_script * script,char * buf,int buflen,u64 timestamp)631 tod_scnprintf(struct perf_script *script, char *buf, int buflen,
632 	     u64 timestamp)
633 {
634 	u64 tod_ns, clockid_ns;
635 	struct perf_env *env;
636 	unsigned long nsec;
637 	struct tm ltime;
638 	char date[64];
639 	time_t sec;
640 
641 	buf[0] = '\0';
642 	if (buflen < 64 || !script)
643 		return buf;
644 
645 	env = &script->session->header.env;
646 	if (!env->clock.enabled) {
647 		scnprintf(buf, buflen, "disabled");
648 		return buf;
649 	}
650 
651 	clockid_ns = env->clock.clockid_ns;
652 	tod_ns     = env->clock.tod_ns;
653 
654 	if (timestamp > clockid_ns)
655 		tod_ns += timestamp - clockid_ns;
656 	else
657 		tod_ns -= clockid_ns - timestamp;
658 
659 	sec  = (time_t) (tod_ns / NSEC_PER_SEC);
660 	nsec = tod_ns - sec * NSEC_PER_SEC;
661 
662 	if (localtime_r(&sec, &ltime) == NULL) {
663 		scnprintf(buf, buflen, "failed");
664 	} else {
665 		strftime(date, sizeof(date), DEFAULT_TOD_FMT, &ltime);
666 
667 		if (symbol_conf.nanosecs) {
668 			snprintf(buf, buflen, "%s.%09lu", date, nsec);
669 		} else {
670 			snprintf(buf, buflen, "%s.%06lu",
671 				 date, nsec / NSEC_PER_USEC);
672 		}
673 	}
674 
675 	return buf;
676 }
677 
perf_sample__fprintf_iregs(struct perf_sample * sample,struct perf_event_attr * attr,FILE * fp)678 static int perf_sample__fprintf_iregs(struct perf_sample *sample,
679 				      struct perf_event_attr *attr, FILE *fp)
680 {
681 	return perf_sample__fprintf_regs(&sample->intr_regs,
682 					 attr->sample_regs_intr, fp);
683 }
684 
perf_sample__fprintf_uregs(struct perf_sample * sample,struct perf_event_attr * attr,FILE * fp)685 static int perf_sample__fprintf_uregs(struct perf_sample *sample,
686 				      struct perf_event_attr *attr, FILE *fp)
687 {
688 	return perf_sample__fprintf_regs(&sample->user_regs,
689 					 attr->sample_regs_user, fp);
690 }
691 
perf_sample__fprintf_start(struct perf_script * script,struct perf_sample * sample,struct thread * thread,struct evsel * evsel,u32 type,FILE * fp)692 static int perf_sample__fprintf_start(struct perf_script *script,
693 				      struct perf_sample *sample,
694 				      struct thread *thread,
695 				      struct evsel *evsel,
696 				      u32 type, FILE *fp)
697 {
698 	struct perf_event_attr *attr = &evsel->core.attr;
699 	unsigned long secs;
700 	unsigned long long nsecs;
701 	int printed = 0;
702 	char tstr[128];
703 
704 	if (PRINT_FIELD(COMM)) {
705 		const char *comm = thread ? thread__comm_str(thread) : ":-1";
706 
707 		if (latency_format)
708 			printed += fprintf(fp, "%8.8s ", comm);
709 		else if (PRINT_FIELD(IP) && evsel__has_callchain(evsel) && symbol_conf.use_callchain)
710 			printed += fprintf(fp, "%s ", comm);
711 		else
712 			printed += fprintf(fp, "%16s ", comm);
713 	}
714 
715 	if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
716 		printed += fprintf(fp, "%5d/%-5d ", sample->pid, sample->tid);
717 	else if (PRINT_FIELD(PID))
718 		printed += fprintf(fp, "%5d ", sample->pid);
719 	else if (PRINT_FIELD(TID))
720 		printed += fprintf(fp, "%5d ", sample->tid);
721 
722 	if (PRINT_FIELD(CPU)) {
723 		if (latency_format)
724 			printed += fprintf(fp, "%3d ", sample->cpu);
725 		else
726 			printed += fprintf(fp, "[%03d] ", sample->cpu);
727 	}
728 
729 	if (PRINT_FIELD(MISC)) {
730 		int ret = 0;
731 
732 		#define has(m) \
733 			(sample->misc & PERF_RECORD_MISC_##m) == PERF_RECORD_MISC_##m
734 
735 		if (has(KERNEL))
736 			ret += fprintf(fp, "K");
737 		if (has(USER))
738 			ret += fprintf(fp, "U");
739 		if (has(HYPERVISOR))
740 			ret += fprintf(fp, "H");
741 		if (has(GUEST_KERNEL))
742 			ret += fprintf(fp, "G");
743 		if (has(GUEST_USER))
744 			ret += fprintf(fp, "g");
745 
746 		switch (type) {
747 		case PERF_RECORD_MMAP:
748 		case PERF_RECORD_MMAP2:
749 			if (has(MMAP_DATA))
750 				ret += fprintf(fp, "M");
751 			break;
752 		case PERF_RECORD_COMM:
753 			if (has(COMM_EXEC))
754 				ret += fprintf(fp, "E");
755 			break;
756 		case PERF_RECORD_SWITCH:
757 		case PERF_RECORD_SWITCH_CPU_WIDE:
758 			if (has(SWITCH_OUT)) {
759 				ret += fprintf(fp, "S");
760 				if (sample->misc & PERF_RECORD_MISC_SWITCH_OUT_PREEMPT)
761 					ret += fprintf(fp, "p");
762 			}
763 		default:
764 			break;
765 		}
766 
767 		#undef has
768 
769 		ret += fprintf(fp, "%*s", 6 - ret, " ");
770 		printed += ret;
771 	}
772 
773 	if (PRINT_FIELD(TOD)) {
774 		tod_scnprintf(script, tstr, sizeof(tstr), sample->time);
775 		printed += fprintf(fp, "%s ", tstr);
776 	}
777 
778 	if (PRINT_FIELD(TIME)) {
779 		u64 t = sample->time;
780 		if (reltime) {
781 			if (!initial_time)
782 				initial_time = sample->time;
783 			t = sample->time - initial_time;
784 		} else if (deltatime) {
785 			if (previous_time)
786 				t = sample->time - previous_time;
787 			else {
788 				t = 0;
789 			}
790 			previous_time = sample->time;
791 		}
792 		nsecs = t;
793 		secs = nsecs / NSEC_PER_SEC;
794 		nsecs -= secs * NSEC_PER_SEC;
795 
796 		if (symbol_conf.nanosecs)
797 			printed += fprintf(fp, "%5lu.%09llu: ", secs, nsecs);
798 		else {
799 			char sample_time[32];
800 			timestamp__scnprintf_usec(t, sample_time, sizeof(sample_time));
801 			printed += fprintf(fp, "%12s: ", sample_time);
802 		}
803 	}
804 
805 	return printed;
806 }
807 
808 static inline char
mispred_str(struct branch_entry * br)809 mispred_str(struct branch_entry *br)
810 {
811 	if (!(br->flags.mispred  || br->flags.predicted))
812 		return '-';
813 
814 	return br->flags.predicted ? 'P' : 'M';
815 }
816 
perf_sample__fprintf_brstack(struct perf_sample * sample,struct thread * thread,struct perf_event_attr * attr,FILE * fp)817 static int perf_sample__fprintf_brstack(struct perf_sample *sample,
818 					struct thread *thread,
819 					struct perf_event_attr *attr, FILE *fp)
820 {
821 	struct branch_stack *br = sample->branch_stack;
822 	struct branch_entry *entries = perf_sample__branch_entries(sample);
823 	struct addr_location alf, alt;
824 	u64 i, from, to;
825 	int printed = 0;
826 
827 	if (!(br && br->nr))
828 		return 0;
829 
830 	for (i = 0; i < br->nr; i++) {
831 		from = entries[i].from;
832 		to   = entries[i].to;
833 
834 		if (PRINT_FIELD(DSO)) {
835 			memset(&alf, 0, sizeof(alf));
836 			memset(&alt, 0, sizeof(alt));
837 			thread__find_map_fb(thread, sample->cpumode, from, &alf);
838 			thread__find_map_fb(thread, sample->cpumode, to, &alt);
839 		}
840 
841 		printed += fprintf(fp, " 0x%"PRIx64, from);
842 		if (PRINT_FIELD(DSO)) {
843 			printed += fprintf(fp, "(");
844 			printed += map__fprintf_dsoname(alf.map, fp);
845 			printed += fprintf(fp, ")");
846 		}
847 
848 		printed += fprintf(fp, "/0x%"PRIx64, to);
849 		if (PRINT_FIELD(DSO)) {
850 			printed += fprintf(fp, "(");
851 			printed += map__fprintf_dsoname(alt.map, fp);
852 			printed += fprintf(fp, ")");
853 		}
854 
855 		printed += fprintf(fp, "/%c/%c/%c/%d ",
856 			mispred_str(entries + i),
857 			entries[i].flags.in_tx ? 'X' : '-',
858 			entries[i].flags.abort ? 'A' : '-',
859 			entries[i].flags.cycles);
860 	}
861 
862 	return printed;
863 }
864 
perf_sample__fprintf_brstacksym(struct perf_sample * sample,struct thread * thread,struct perf_event_attr * attr,FILE * fp)865 static int perf_sample__fprintf_brstacksym(struct perf_sample *sample,
866 					   struct thread *thread,
867 					   struct perf_event_attr *attr, FILE *fp)
868 {
869 	struct branch_stack *br = sample->branch_stack;
870 	struct branch_entry *entries = perf_sample__branch_entries(sample);
871 	struct addr_location alf, alt;
872 	u64 i, from, to;
873 	int printed = 0;
874 
875 	if (!(br && br->nr))
876 		return 0;
877 
878 	for (i = 0; i < br->nr; i++) {
879 
880 		memset(&alf, 0, sizeof(alf));
881 		memset(&alt, 0, sizeof(alt));
882 		from = entries[i].from;
883 		to   = entries[i].to;
884 
885 		thread__find_symbol_fb(thread, sample->cpumode, from, &alf);
886 		thread__find_symbol_fb(thread, sample->cpumode, to, &alt);
887 
888 		printed += symbol__fprintf_symname_offs(alf.sym, &alf, fp);
889 		if (PRINT_FIELD(DSO)) {
890 			printed += fprintf(fp, "(");
891 			printed += map__fprintf_dsoname(alf.map, fp);
892 			printed += fprintf(fp, ")");
893 		}
894 		printed += fprintf(fp, "%c", '/');
895 		printed += symbol__fprintf_symname_offs(alt.sym, &alt, fp);
896 		if (PRINT_FIELD(DSO)) {
897 			printed += fprintf(fp, "(");
898 			printed += map__fprintf_dsoname(alt.map, fp);
899 			printed += fprintf(fp, ")");
900 		}
901 		printed += fprintf(fp, "/%c/%c/%c/%d ",
902 			mispred_str(entries + i),
903 			entries[i].flags.in_tx ? 'X' : '-',
904 			entries[i].flags.abort ? 'A' : '-',
905 			entries[i].flags.cycles);
906 	}
907 
908 	return printed;
909 }
910 
perf_sample__fprintf_brstackoff(struct perf_sample * sample,struct thread * thread,struct perf_event_attr * attr,FILE * fp)911 static int perf_sample__fprintf_brstackoff(struct perf_sample *sample,
912 					   struct thread *thread,
913 					   struct perf_event_attr *attr, FILE *fp)
914 {
915 	struct branch_stack *br = sample->branch_stack;
916 	struct branch_entry *entries = perf_sample__branch_entries(sample);
917 	struct addr_location alf, alt;
918 	u64 i, from, to;
919 	int printed = 0;
920 
921 	if (!(br && br->nr))
922 		return 0;
923 
924 	for (i = 0; i < br->nr; i++) {
925 
926 		memset(&alf, 0, sizeof(alf));
927 		memset(&alt, 0, sizeof(alt));
928 		from = entries[i].from;
929 		to   = entries[i].to;
930 
931 		if (thread__find_map_fb(thread, sample->cpumode, from, &alf) &&
932 		    !alf.map->dso->adjust_symbols)
933 			from = map__map_ip(alf.map, from);
934 
935 		if (thread__find_map_fb(thread, sample->cpumode, to, &alt) &&
936 		    !alt.map->dso->adjust_symbols)
937 			to = map__map_ip(alt.map, to);
938 
939 		printed += fprintf(fp, " 0x%"PRIx64, from);
940 		if (PRINT_FIELD(DSO)) {
941 			printed += fprintf(fp, "(");
942 			printed += map__fprintf_dsoname(alf.map, fp);
943 			printed += fprintf(fp, ")");
944 		}
945 		printed += fprintf(fp, "/0x%"PRIx64, to);
946 		if (PRINT_FIELD(DSO)) {
947 			printed += fprintf(fp, "(");
948 			printed += map__fprintf_dsoname(alt.map, fp);
949 			printed += fprintf(fp, ")");
950 		}
951 		printed += fprintf(fp, "/%c/%c/%c/%d ",
952 			mispred_str(entries + i),
953 			entries[i].flags.in_tx ? 'X' : '-',
954 			entries[i].flags.abort ? 'A' : '-',
955 			entries[i].flags.cycles);
956 	}
957 
958 	return printed;
959 }
960 #define MAXBB 16384UL
961 
grab_bb(u8 * buffer,u64 start,u64 end,struct machine * machine,struct thread * thread,bool * is64bit,u8 * cpumode,bool last)962 static int grab_bb(u8 *buffer, u64 start, u64 end,
963 		    struct machine *machine, struct thread *thread,
964 		    bool *is64bit, u8 *cpumode, bool last)
965 {
966 	long offset, len;
967 	struct addr_location al;
968 	bool kernel;
969 
970 	if (!start || !end)
971 		return 0;
972 
973 	kernel = machine__kernel_ip(machine, start);
974 	if (kernel)
975 		*cpumode = PERF_RECORD_MISC_KERNEL;
976 	else
977 		*cpumode = PERF_RECORD_MISC_USER;
978 
979 	/*
980 	 * Block overlaps between kernel and user.
981 	 * This can happen due to ring filtering
982 	 * On Intel CPUs the entry into the kernel is filtered,
983 	 * but the exit is not. Let the caller patch it up.
984 	 */
985 	if (kernel != machine__kernel_ip(machine, end)) {
986 		pr_debug("\tblock %" PRIx64 "-%" PRIx64 " transfers between kernel and user\n", start, end);
987 		return -ENXIO;
988 	}
989 
990 	memset(&al, 0, sizeof(al));
991 	if (end - start > MAXBB - MAXINSN) {
992 		if (last)
993 			pr_debug("\tbrstack does not reach to final jump (%" PRIx64 "-%" PRIx64 ")\n", start, end);
994 		else
995 			pr_debug("\tblock %" PRIx64 "-%" PRIx64 " (%" PRIu64 ") too long to dump\n", start, end, end - start);
996 		return 0;
997 	}
998 
999 	if (!thread__find_map(thread, *cpumode, start, &al) || !al.map->dso) {
1000 		pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
1001 		return 0;
1002 	}
1003 	if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR) {
1004 		pr_debug("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
1005 		return 0;
1006 	}
1007 
1008 	/* Load maps to ensure dso->is_64_bit has been updated */
1009 	map__load(al.map);
1010 
1011 	offset = al.map->map_ip(al.map, start);
1012 	len = dso__data_read_offset(al.map->dso, machine, offset, (u8 *)buffer,
1013 				    end - start + MAXINSN);
1014 
1015 	*is64bit = al.map->dso->is_64_bit;
1016 	if (len <= 0)
1017 		pr_debug("\tcannot fetch code for block at %" PRIx64 "-%" PRIx64 "\n",
1018 			start, end);
1019 	return len;
1020 }
1021 
map__fprintf_srccode(struct map * map,u64 addr,FILE * fp,struct srccode_state * state)1022 static int map__fprintf_srccode(struct map *map, u64 addr, FILE *fp, struct srccode_state *state)
1023 {
1024 	char *srcfile;
1025 	int ret = 0;
1026 	unsigned line;
1027 	int len;
1028 	char *srccode;
1029 
1030 	if (!map || !map->dso)
1031 		return 0;
1032 	srcfile = get_srcline_split(map->dso,
1033 				    map__rip_2objdump(map, addr),
1034 				    &line);
1035 	if (!srcfile)
1036 		return 0;
1037 
1038 	/* Avoid redundant printing */
1039 	if (state &&
1040 	    state->srcfile &&
1041 	    !strcmp(state->srcfile, srcfile) &&
1042 	    state->line == line) {
1043 		free(srcfile);
1044 		return 0;
1045 	}
1046 
1047 	srccode = find_sourceline(srcfile, line, &len);
1048 	if (!srccode)
1049 		goto out_free_line;
1050 
1051 	ret = fprintf(fp, "|%-8d %.*s", line, len, srccode);
1052 
1053 	if (state) {
1054 		state->srcfile = srcfile;
1055 		state->line = line;
1056 	}
1057 	return ret;
1058 
1059 out_free_line:
1060 	free(srcfile);
1061 	return ret;
1062 }
1063 
print_srccode(struct thread * thread,u8 cpumode,uint64_t addr)1064 static int print_srccode(struct thread *thread, u8 cpumode, uint64_t addr)
1065 {
1066 	struct addr_location al;
1067 	int ret = 0;
1068 
1069 	memset(&al, 0, sizeof(al));
1070 	thread__find_map(thread, cpumode, addr, &al);
1071 	if (!al.map)
1072 		return 0;
1073 	ret = map__fprintf_srccode(al.map, al.addr, stdout,
1074 		    &thread->srccode_state);
1075 	if (ret)
1076 		ret += printf("\n");
1077 	return ret;
1078 }
1079 
ip__fprintf_jump(uint64_t ip,struct branch_entry * en,struct perf_insn * x,u8 * inbuf,int len,int insn,FILE * fp,int * total_cycles)1080 static int ip__fprintf_jump(uint64_t ip, struct branch_entry *en,
1081 			    struct perf_insn *x, u8 *inbuf, int len,
1082 			    int insn, FILE *fp, int *total_cycles)
1083 {
1084 	int printed = fprintf(fp, "\t%016" PRIx64 "\t%-30s\t#%s%s%s%s", ip,
1085 			      dump_insn(x, ip, inbuf, len, NULL),
1086 			      en->flags.predicted ? " PRED" : "",
1087 			      en->flags.mispred ? " MISPRED" : "",
1088 			      en->flags.in_tx ? " INTX" : "",
1089 			      en->flags.abort ? " ABORT" : "");
1090 	if (en->flags.cycles) {
1091 		*total_cycles += en->flags.cycles;
1092 		printed += fprintf(fp, " %d cycles [%d]", en->flags.cycles, *total_cycles);
1093 		if (insn)
1094 			printed += fprintf(fp, " %.2f IPC", (float)insn / en->flags.cycles);
1095 	}
1096 	return printed + fprintf(fp, "\n");
1097 }
1098 
ip__fprintf_sym(uint64_t addr,struct thread * thread,u8 cpumode,int cpu,struct symbol ** lastsym,struct perf_event_attr * attr,FILE * fp)1099 static int ip__fprintf_sym(uint64_t addr, struct thread *thread,
1100 			   u8 cpumode, int cpu, struct symbol **lastsym,
1101 			   struct perf_event_attr *attr, FILE *fp)
1102 {
1103 	struct addr_location al;
1104 	int off, printed = 0;
1105 
1106 	memset(&al, 0, sizeof(al));
1107 
1108 	thread__find_map(thread, cpumode, addr, &al);
1109 
1110 	if ((*lastsym) && al.addr >= (*lastsym)->start && al.addr < (*lastsym)->end)
1111 		return 0;
1112 
1113 	al.cpu = cpu;
1114 	al.sym = NULL;
1115 	if (al.map)
1116 		al.sym = map__find_symbol(al.map, al.addr);
1117 
1118 	if (!al.sym)
1119 		return 0;
1120 
1121 	if (al.addr < al.sym->end)
1122 		off = al.addr - al.sym->start;
1123 	else
1124 		off = al.addr - al.map->start - al.sym->start;
1125 	printed += fprintf(fp, "\t%s", al.sym->name);
1126 	if (off)
1127 		printed += fprintf(fp, "%+d", off);
1128 	printed += fprintf(fp, ":");
1129 	if (PRINT_FIELD(SRCLINE))
1130 		printed += map__fprintf_srcline(al.map, al.addr, "\t", fp);
1131 	printed += fprintf(fp, "\n");
1132 	*lastsym = al.sym;
1133 
1134 	return printed;
1135 }
1136 
perf_sample__fprintf_brstackinsn(struct perf_sample * sample,struct thread * thread,struct perf_event_attr * attr,struct machine * machine,FILE * fp)1137 static int perf_sample__fprintf_brstackinsn(struct perf_sample *sample,
1138 					    struct thread *thread,
1139 					    struct perf_event_attr *attr,
1140 					    struct machine *machine, FILE *fp)
1141 {
1142 	struct branch_stack *br = sample->branch_stack;
1143 	struct branch_entry *entries = perf_sample__branch_entries(sample);
1144 	u64 start, end;
1145 	int i, insn, len, nr, ilen, printed = 0;
1146 	struct perf_insn x;
1147 	u8 buffer[MAXBB];
1148 	unsigned off;
1149 	struct symbol *lastsym = NULL;
1150 	int total_cycles = 0;
1151 
1152 	if (!(br && br->nr))
1153 		return 0;
1154 	nr = br->nr;
1155 	if (max_blocks && nr > max_blocks + 1)
1156 		nr = max_blocks + 1;
1157 
1158 	x.thread = thread;
1159 	x.cpu = sample->cpu;
1160 
1161 	printed += fprintf(fp, "%c", '\n');
1162 
1163 	/* Handle first from jump, of which we don't know the entry. */
1164 	len = grab_bb(buffer, entries[nr-1].from,
1165 			entries[nr-1].from,
1166 			machine, thread, &x.is64bit, &x.cpumode, false);
1167 	if (len > 0) {
1168 		printed += ip__fprintf_sym(entries[nr - 1].from, thread,
1169 					   x.cpumode, x.cpu, &lastsym, attr, fp);
1170 		printed += ip__fprintf_jump(entries[nr - 1].from, &entries[nr - 1],
1171 					    &x, buffer, len, 0, fp, &total_cycles);
1172 		if (PRINT_FIELD(SRCCODE))
1173 			printed += print_srccode(thread, x.cpumode, entries[nr - 1].from);
1174 	}
1175 
1176 	/* Print all blocks */
1177 	for (i = nr - 2; i >= 0; i--) {
1178 		if (entries[i].from || entries[i].to)
1179 			pr_debug("%d: %" PRIx64 "-%" PRIx64 "\n", i,
1180 				 entries[i].from,
1181 				 entries[i].to);
1182 		start = entries[i + 1].to;
1183 		end   = entries[i].from;
1184 
1185 		len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
1186 		/* Patch up missing kernel transfers due to ring filters */
1187 		if (len == -ENXIO && i > 0) {
1188 			end = entries[--i].from;
1189 			pr_debug("\tpatching up to %" PRIx64 "-%" PRIx64 "\n", start, end);
1190 			len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
1191 		}
1192 		if (len <= 0)
1193 			continue;
1194 
1195 		insn = 0;
1196 		for (off = 0; off < (unsigned)len; off += ilen) {
1197 			uint64_t ip = start + off;
1198 
1199 			printed += ip__fprintf_sym(ip, thread, x.cpumode, x.cpu, &lastsym, attr, fp);
1200 			if (ip == end) {
1201 				printed += ip__fprintf_jump(ip, &entries[i], &x, buffer + off, len - off, ++insn, fp,
1202 							    &total_cycles);
1203 				if (PRINT_FIELD(SRCCODE))
1204 					printed += print_srccode(thread, x.cpumode, ip);
1205 				break;
1206 			} else {
1207 				ilen = 0;
1208 				printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", ip,
1209 						   dump_insn(&x, ip, buffer + off, len - off, &ilen));
1210 				if (ilen == 0)
1211 					break;
1212 				if (PRINT_FIELD(SRCCODE))
1213 					print_srccode(thread, x.cpumode, ip);
1214 				insn++;
1215 			}
1216 		}
1217 		if (off != end - start)
1218 			printed += fprintf(fp, "\tmismatch of LBR data and executable\n");
1219 	}
1220 
1221 	/*
1222 	 * Hit the branch? In this case we are already done, and the target
1223 	 * has not been executed yet.
1224 	 */
1225 	if (entries[0].from == sample->ip)
1226 		goto out;
1227 	if (entries[0].flags.abort)
1228 		goto out;
1229 
1230 	/*
1231 	 * Print final block upto sample
1232 	 *
1233 	 * Due to pipeline delays the LBRs might be missing a branch
1234 	 * or two, which can result in very large or negative blocks
1235 	 * between final branch and sample. When this happens just
1236 	 * continue walking after the last TO until we hit a branch.
1237 	 */
1238 	start = entries[0].to;
1239 	end = sample->ip;
1240 	if (end < start) {
1241 		/* Missing jump. Scan 128 bytes for the next branch */
1242 		end = start + 128;
1243 	}
1244 	len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, true);
1245 	printed += ip__fprintf_sym(start, thread, x.cpumode, x.cpu, &lastsym, attr, fp);
1246 	if (len <= 0) {
1247 		/* Print at least last IP if basic block did not work */
1248 		len = grab_bb(buffer, sample->ip, sample->ip,
1249 			      machine, thread, &x.is64bit, &x.cpumode, false);
1250 		if (len <= 0)
1251 			goto out;
1252 		printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", sample->ip,
1253 			dump_insn(&x, sample->ip, buffer, len, NULL));
1254 		if (PRINT_FIELD(SRCCODE))
1255 			print_srccode(thread, x.cpumode, sample->ip);
1256 		goto out;
1257 	}
1258 	for (off = 0; off <= end - start; off += ilen) {
1259 		ilen = 0;
1260 		printed += fprintf(fp, "\t%016" PRIx64 "\t%s\n", start + off,
1261 				   dump_insn(&x, start + off, buffer + off, len - off, &ilen));
1262 		if (ilen == 0)
1263 			break;
1264 		if (arch_is_branch(buffer + off, len - off, x.is64bit) && start + off != sample->ip) {
1265 			/*
1266 			 * Hit a missing branch. Just stop.
1267 			 */
1268 			printed += fprintf(fp, "\t... not reaching sample ...\n");
1269 			break;
1270 		}
1271 		if (PRINT_FIELD(SRCCODE))
1272 			print_srccode(thread, x.cpumode, start + off);
1273 	}
1274 out:
1275 	return printed;
1276 }
1277 
perf_sample__fprintf_addr(struct perf_sample * sample,struct thread * thread,struct perf_event_attr * attr,FILE * fp)1278 static int perf_sample__fprintf_addr(struct perf_sample *sample,
1279 				     struct thread *thread,
1280 				     struct perf_event_attr *attr, FILE *fp)
1281 {
1282 	struct addr_location al;
1283 	int printed = fprintf(fp, "%16" PRIx64, sample->addr);
1284 
1285 	if (!sample_addr_correlates_sym(attr))
1286 		goto out;
1287 
1288 	thread__resolve(thread, &al, sample);
1289 
1290 	if (PRINT_FIELD(SYM)) {
1291 		printed += fprintf(fp, " ");
1292 		if (PRINT_FIELD(SYMOFFSET))
1293 			printed += symbol__fprintf_symname_offs(al.sym, &al, fp);
1294 		else
1295 			printed += symbol__fprintf_symname(al.sym, fp);
1296 	}
1297 
1298 	if (PRINT_FIELD(DSO)) {
1299 		printed += fprintf(fp, " (");
1300 		printed += map__fprintf_dsoname(al.map, fp);
1301 		printed += fprintf(fp, ")");
1302 	}
1303 out:
1304 	return printed;
1305 }
1306 
resolve_branch_sym(struct perf_sample * sample,struct evsel * evsel,struct thread * thread,struct addr_location * al,u64 * ip)1307 static const char *resolve_branch_sym(struct perf_sample *sample,
1308 				      struct evsel *evsel,
1309 				      struct thread *thread,
1310 				      struct addr_location *al,
1311 				      u64 *ip)
1312 {
1313 	struct addr_location addr_al;
1314 	struct perf_event_attr *attr = &evsel->core.attr;
1315 	const char *name = NULL;
1316 
1317 	if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
1318 		if (sample_addr_correlates_sym(attr)) {
1319 			thread__resolve(thread, &addr_al, sample);
1320 			if (addr_al.sym)
1321 				name = addr_al.sym->name;
1322 			else
1323 				*ip = sample->addr;
1324 		} else {
1325 			*ip = sample->addr;
1326 		}
1327 	} else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
1328 		if (al->sym)
1329 			name = al->sym->name;
1330 		else
1331 			*ip = sample->ip;
1332 	}
1333 	return name;
1334 }
1335 
perf_sample__fprintf_callindent(struct perf_sample * sample,struct evsel * evsel,struct thread * thread,struct addr_location * al,FILE * fp)1336 static int perf_sample__fprintf_callindent(struct perf_sample *sample,
1337 					   struct evsel *evsel,
1338 					   struct thread *thread,
1339 					   struct addr_location *al, FILE *fp)
1340 {
1341 	struct perf_event_attr *attr = &evsel->core.attr;
1342 	size_t depth = thread_stack__depth(thread, sample->cpu);
1343 	const char *name = NULL;
1344 	static int spacing;
1345 	int len = 0;
1346 	int dlen = 0;
1347 	u64 ip = 0;
1348 
1349 	/*
1350 	 * The 'return' has already been popped off the stack so the depth has
1351 	 * to be adjusted to match the 'call'.
1352 	 */
1353 	if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
1354 		depth += 1;
1355 
1356 	name = resolve_branch_sym(sample, evsel, thread, al, &ip);
1357 
1358 	if (PRINT_FIELD(DSO) && !(PRINT_FIELD(IP) || PRINT_FIELD(ADDR))) {
1359 		dlen += fprintf(fp, "(");
1360 		dlen += map__fprintf_dsoname(al->map, fp);
1361 		dlen += fprintf(fp, ")\t");
1362 	}
1363 
1364 	if (name)
1365 		len = fprintf(fp, "%*s%s", (int)depth * 4, "", name);
1366 	else if (ip)
1367 		len = fprintf(fp, "%*s%16" PRIx64, (int)depth * 4, "", ip);
1368 
1369 	if (len < 0)
1370 		return len;
1371 
1372 	/*
1373 	 * Try to keep the output length from changing frequently so that the
1374 	 * output lines up more nicely.
1375 	 */
1376 	if (len > spacing || (len && len < spacing - 52))
1377 		spacing = round_up(len + 4, 32);
1378 
1379 	if (len < spacing)
1380 		len += fprintf(fp, "%*s", spacing - len, "");
1381 
1382 	return len + dlen;
1383 }
1384 
arch_fetch_insn(struct perf_sample * sample __maybe_unused,struct thread * thread __maybe_unused,struct machine * machine __maybe_unused)1385 __weak void arch_fetch_insn(struct perf_sample *sample __maybe_unused,
1386 			    struct thread *thread __maybe_unused,
1387 			    struct machine *machine __maybe_unused)
1388 {
1389 }
1390 
perf_sample__fprintf_insn(struct perf_sample * sample,struct perf_event_attr * attr,struct thread * thread,struct machine * machine,FILE * fp)1391 static int perf_sample__fprintf_insn(struct perf_sample *sample,
1392 				     struct perf_event_attr *attr,
1393 				     struct thread *thread,
1394 				     struct machine *machine, FILE *fp)
1395 {
1396 	int printed = 0;
1397 
1398 	if (sample->insn_len == 0 && native_arch)
1399 		arch_fetch_insn(sample, thread, machine);
1400 
1401 	if (PRINT_FIELD(INSNLEN))
1402 		printed += fprintf(fp, " ilen: %d", sample->insn_len);
1403 	if (PRINT_FIELD(INSN) && sample->insn_len) {
1404 		int i;
1405 
1406 		printed += fprintf(fp, " insn:");
1407 		for (i = 0; i < sample->insn_len; i++)
1408 			printed += fprintf(fp, " %02x", (unsigned char)sample->insn[i]);
1409 	}
1410 	if (PRINT_FIELD(BRSTACKINSN))
1411 		printed += perf_sample__fprintf_brstackinsn(sample, thread, attr, machine, fp);
1412 
1413 	return printed;
1414 }
1415 
perf_sample__fprintf_ipc(struct perf_sample * sample,struct perf_event_attr * attr,FILE * fp)1416 static int perf_sample__fprintf_ipc(struct perf_sample *sample,
1417 				    struct perf_event_attr *attr, FILE *fp)
1418 {
1419 	unsigned int ipc;
1420 
1421 	if (!PRINT_FIELD(IPC) || !sample->cyc_cnt || !sample->insn_cnt)
1422 		return 0;
1423 
1424 	ipc = (sample->insn_cnt * 100) / sample->cyc_cnt;
1425 
1426 	return fprintf(fp, " \t IPC: %u.%02u (%" PRIu64 "/%" PRIu64 ") ",
1427 		       ipc / 100, ipc % 100, sample->insn_cnt, sample->cyc_cnt);
1428 }
1429 
perf_sample__fprintf_bts(struct perf_sample * sample,struct evsel * evsel,struct thread * thread,struct addr_location * al,struct machine * machine,FILE * fp)1430 static int perf_sample__fprintf_bts(struct perf_sample *sample,
1431 				    struct evsel *evsel,
1432 				    struct thread *thread,
1433 				    struct addr_location *al,
1434 				    struct machine *machine, FILE *fp)
1435 {
1436 	struct perf_event_attr *attr = &evsel->core.attr;
1437 	unsigned int type = output_type(attr->type);
1438 	bool print_srcline_last = false;
1439 	int printed = 0;
1440 
1441 	if (PRINT_FIELD(CALLINDENT))
1442 		printed += perf_sample__fprintf_callindent(sample, evsel, thread, al, fp);
1443 
1444 	/* print branch_from information */
1445 	if (PRINT_FIELD(IP)) {
1446 		unsigned int print_opts = output[type].print_ip_opts;
1447 		struct callchain_cursor *cursor = NULL;
1448 
1449 		if (symbol_conf.use_callchain && sample->callchain &&
1450 		    thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
1451 					      sample, NULL, NULL, scripting_max_stack) == 0)
1452 			cursor = &callchain_cursor;
1453 
1454 		if (cursor == NULL) {
1455 			printed += fprintf(fp, " ");
1456 			if (print_opts & EVSEL__PRINT_SRCLINE) {
1457 				print_srcline_last = true;
1458 				print_opts &= ~EVSEL__PRINT_SRCLINE;
1459 			}
1460 		} else
1461 			printed += fprintf(fp, "\n");
1462 
1463 		printed += sample__fprintf_sym(sample, al, 0, print_opts, cursor,
1464 					       symbol_conf.bt_stop_list, fp);
1465 	}
1466 
1467 	/* print branch_to information */
1468 	if (PRINT_FIELD(ADDR) ||
1469 	    ((evsel->core.attr.sample_type & PERF_SAMPLE_ADDR) &&
1470 	     !output[type].user_set)) {
1471 		printed += fprintf(fp, " => ");
1472 		printed += perf_sample__fprintf_addr(sample, thread, attr, fp);
1473 	}
1474 
1475 	printed += perf_sample__fprintf_ipc(sample, attr, fp);
1476 
1477 	if (print_srcline_last)
1478 		printed += map__fprintf_srcline(al->map, al->addr, "\n  ", fp);
1479 
1480 	printed += perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
1481 	printed += fprintf(fp, "\n");
1482 	if (PRINT_FIELD(SRCCODE)) {
1483 		int ret = map__fprintf_srccode(al->map, al->addr, stdout,
1484 					 &thread->srccode_state);
1485 		if (ret) {
1486 			printed += ret;
1487 			printed += printf("\n");
1488 		}
1489 	}
1490 	return printed;
1491 }
1492 
1493 static struct {
1494 	u32 flags;
1495 	const char *name;
1496 } sample_flags[] = {
1497 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL, "call"},
1498 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN, "return"},
1499 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL, "jcc"},
1500 	{PERF_IP_FLAG_BRANCH, "jmp"},
1501 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_INTERRUPT, "int"},
1502 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_INTERRUPT, "iret"},
1503 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_SYSCALLRET, "syscall"},
1504 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_SYSCALLRET, "sysret"},
1505 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_ASYNC, "async"},
1506 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC |	PERF_IP_FLAG_INTERRUPT, "hw int"},
1507 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TX_ABORT, "tx abrt"},
1508 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_BEGIN, "tr strt"},
1509 	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_END, "tr end"},
1510 	{0, NULL}
1511 };
1512 
sample_flags_to_name(u32 flags)1513 static const char *sample_flags_to_name(u32 flags)
1514 {
1515 	int i;
1516 
1517 	for (i = 0; sample_flags[i].name ; i++) {
1518 		if (sample_flags[i].flags == flags)
1519 			return sample_flags[i].name;
1520 	}
1521 
1522 	return NULL;
1523 }
1524 
perf_sample__fprintf_flags(u32 flags,FILE * fp)1525 static int perf_sample__fprintf_flags(u32 flags, FILE *fp)
1526 {
1527 	const char *chars = PERF_IP_FLAG_CHARS;
1528 	const int n = strlen(PERF_IP_FLAG_CHARS);
1529 	bool in_tx = flags & PERF_IP_FLAG_IN_TX;
1530 	const char *name = NULL;
1531 	char str[33];
1532 	int i, pos = 0;
1533 
1534 	name = sample_flags_to_name(flags & ~PERF_IP_FLAG_IN_TX);
1535 	if (name)
1536 		return fprintf(fp, "  %-15s%4s ", name, in_tx ? "(x)" : "");
1537 
1538 	if (flags & PERF_IP_FLAG_TRACE_BEGIN) {
1539 		name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_BEGIN));
1540 		if (name)
1541 			return fprintf(fp, "  tr strt %-7s%4s ", name, in_tx ? "(x)" : "");
1542 	}
1543 
1544 	if (flags & PERF_IP_FLAG_TRACE_END) {
1545 		name = sample_flags_to_name(flags & ~(PERF_IP_FLAG_IN_TX | PERF_IP_FLAG_TRACE_END));
1546 		if (name)
1547 			return fprintf(fp, "  tr end  %-7s%4s ", name, in_tx ? "(x)" : "");
1548 	}
1549 
1550 	for (i = 0; i < n; i++, flags >>= 1) {
1551 		if (flags & 1)
1552 			str[pos++] = chars[i];
1553 	}
1554 	for (; i < 32; i++, flags >>= 1) {
1555 		if (flags & 1)
1556 			str[pos++] = '?';
1557 	}
1558 	str[pos] = 0;
1559 
1560 	return fprintf(fp, "  %-19s ", str);
1561 }
1562 
1563 struct printer_data {
1564 	int line_no;
1565 	bool hit_nul;
1566 	bool is_printable;
1567 };
1568 
sample__fprintf_bpf_output(enum binary_printer_ops op,unsigned int val,void * extra,FILE * fp)1569 static int sample__fprintf_bpf_output(enum binary_printer_ops op,
1570 				      unsigned int val,
1571 				      void *extra, FILE *fp)
1572 {
1573 	unsigned char ch = (unsigned char)val;
1574 	struct printer_data *printer_data = extra;
1575 	int printed = 0;
1576 
1577 	switch (op) {
1578 	case BINARY_PRINT_DATA_BEGIN:
1579 		printed += fprintf(fp, "\n");
1580 		break;
1581 	case BINARY_PRINT_LINE_BEGIN:
1582 		printed += fprintf(fp, "%17s", !printer_data->line_no ? "BPF output:" :
1583 						        "           ");
1584 		break;
1585 	case BINARY_PRINT_ADDR:
1586 		printed += fprintf(fp, " %04x:", val);
1587 		break;
1588 	case BINARY_PRINT_NUM_DATA:
1589 		printed += fprintf(fp, " %02x", val);
1590 		break;
1591 	case BINARY_PRINT_NUM_PAD:
1592 		printed += fprintf(fp, "   ");
1593 		break;
1594 	case BINARY_PRINT_SEP:
1595 		printed += fprintf(fp, "  ");
1596 		break;
1597 	case BINARY_PRINT_CHAR_DATA:
1598 		if (printer_data->hit_nul && ch)
1599 			printer_data->is_printable = false;
1600 
1601 		if (!isprint(ch)) {
1602 			printed += fprintf(fp, "%c", '.');
1603 
1604 			if (!printer_data->is_printable)
1605 				break;
1606 
1607 			if (ch == '\0')
1608 				printer_data->hit_nul = true;
1609 			else
1610 				printer_data->is_printable = false;
1611 		} else {
1612 			printed += fprintf(fp, "%c", ch);
1613 		}
1614 		break;
1615 	case BINARY_PRINT_CHAR_PAD:
1616 		printed += fprintf(fp, " ");
1617 		break;
1618 	case BINARY_PRINT_LINE_END:
1619 		printed += fprintf(fp, "\n");
1620 		printer_data->line_no++;
1621 		break;
1622 	case BINARY_PRINT_DATA_END:
1623 	default:
1624 		break;
1625 	}
1626 
1627 	return printed;
1628 }
1629 
perf_sample__fprintf_bpf_output(struct perf_sample * sample,FILE * fp)1630 static int perf_sample__fprintf_bpf_output(struct perf_sample *sample, FILE *fp)
1631 {
1632 	unsigned int nr_bytes = sample->raw_size;
1633 	struct printer_data printer_data = {0, false, true};
1634 	int printed = binary__fprintf(sample->raw_data, nr_bytes, 8,
1635 				      sample__fprintf_bpf_output, &printer_data, fp);
1636 
1637 	if (printer_data.is_printable && printer_data.hit_nul)
1638 		printed += fprintf(fp, "%17s \"%s\"\n", "BPF string:", (char *)(sample->raw_data));
1639 
1640 	return printed;
1641 }
1642 
perf_sample__fprintf_spacing(int len,int spacing,FILE * fp)1643 static int perf_sample__fprintf_spacing(int len, int spacing, FILE *fp)
1644 {
1645 	if (len > 0 && len < spacing)
1646 		return fprintf(fp, "%*s", spacing - len, "");
1647 
1648 	return 0;
1649 }
1650 
perf_sample__fprintf_pt_spacing(int len,FILE * fp)1651 static int perf_sample__fprintf_pt_spacing(int len, FILE *fp)
1652 {
1653 	return perf_sample__fprintf_spacing(len, 34, fp);
1654 }
1655 
perf_sample__fprintf_synth_ptwrite(struct perf_sample * sample,FILE * fp)1656 static int perf_sample__fprintf_synth_ptwrite(struct perf_sample *sample, FILE *fp)
1657 {
1658 	struct perf_synth_intel_ptwrite *data = perf_sample__synth_ptr(sample);
1659 	int len;
1660 
1661 	if (perf_sample__bad_synth_size(sample, *data))
1662 		return 0;
1663 
1664 	len = fprintf(fp, " IP: %u payload: %#" PRIx64 " ",
1665 		     data->ip, le64_to_cpu(data->payload));
1666 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1667 }
1668 
perf_sample__fprintf_synth_mwait(struct perf_sample * sample,FILE * fp)1669 static int perf_sample__fprintf_synth_mwait(struct perf_sample *sample, FILE *fp)
1670 {
1671 	struct perf_synth_intel_mwait *data = perf_sample__synth_ptr(sample);
1672 	int len;
1673 
1674 	if (perf_sample__bad_synth_size(sample, *data))
1675 		return 0;
1676 
1677 	len = fprintf(fp, " hints: %#x extensions: %#x ",
1678 		      data->hints, data->extensions);
1679 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1680 }
1681 
perf_sample__fprintf_synth_pwre(struct perf_sample * sample,FILE * fp)1682 static int perf_sample__fprintf_synth_pwre(struct perf_sample *sample, FILE *fp)
1683 {
1684 	struct perf_synth_intel_pwre *data = perf_sample__synth_ptr(sample);
1685 	int len;
1686 
1687 	if (perf_sample__bad_synth_size(sample, *data))
1688 		return 0;
1689 
1690 	len = fprintf(fp, " hw: %u cstate: %u sub-cstate: %u ",
1691 		      data->hw, data->cstate, data->subcstate);
1692 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1693 }
1694 
perf_sample__fprintf_synth_exstop(struct perf_sample * sample,FILE * fp)1695 static int perf_sample__fprintf_synth_exstop(struct perf_sample *sample, FILE *fp)
1696 {
1697 	struct perf_synth_intel_exstop *data = perf_sample__synth_ptr(sample);
1698 	int len;
1699 
1700 	if (perf_sample__bad_synth_size(sample, *data))
1701 		return 0;
1702 
1703 	len = fprintf(fp, " IP: %u ", data->ip);
1704 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1705 }
1706 
perf_sample__fprintf_synth_pwrx(struct perf_sample * sample,FILE * fp)1707 static int perf_sample__fprintf_synth_pwrx(struct perf_sample *sample, FILE *fp)
1708 {
1709 	struct perf_synth_intel_pwrx *data = perf_sample__synth_ptr(sample);
1710 	int len;
1711 
1712 	if (perf_sample__bad_synth_size(sample, *data))
1713 		return 0;
1714 
1715 	len = fprintf(fp, " deepest cstate: %u last cstate: %u wake reason: %#x ",
1716 		     data->deepest_cstate, data->last_cstate,
1717 		     data->wake_reason);
1718 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1719 }
1720 
perf_sample__fprintf_synth_cbr(struct perf_sample * sample,FILE * fp)1721 static int perf_sample__fprintf_synth_cbr(struct perf_sample *sample, FILE *fp)
1722 {
1723 	struct perf_synth_intel_cbr *data = perf_sample__synth_ptr(sample);
1724 	unsigned int percent, freq;
1725 	int len;
1726 
1727 	if (perf_sample__bad_synth_size(sample, *data))
1728 		return 0;
1729 
1730 	freq = (le32_to_cpu(data->freq) + 500) / 1000;
1731 	len = fprintf(fp, " cbr: %2u freq: %4u MHz ", data->cbr, freq);
1732 	if (data->max_nonturbo) {
1733 		percent = (5 + (1000 * data->cbr) / data->max_nonturbo) / 10;
1734 		len += fprintf(fp, "(%3u%%) ", percent);
1735 	}
1736 	return len + perf_sample__fprintf_pt_spacing(len, fp);
1737 }
1738 
perf_sample__fprintf_synth(struct perf_sample * sample,struct evsel * evsel,FILE * fp)1739 static int perf_sample__fprintf_synth(struct perf_sample *sample,
1740 				      struct evsel *evsel, FILE *fp)
1741 {
1742 	switch (evsel->core.attr.config) {
1743 	case PERF_SYNTH_INTEL_PTWRITE:
1744 		return perf_sample__fprintf_synth_ptwrite(sample, fp);
1745 	case PERF_SYNTH_INTEL_MWAIT:
1746 		return perf_sample__fprintf_synth_mwait(sample, fp);
1747 	case PERF_SYNTH_INTEL_PWRE:
1748 		return perf_sample__fprintf_synth_pwre(sample, fp);
1749 	case PERF_SYNTH_INTEL_EXSTOP:
1750 		return perf_sample__fprintf_synth_exstop(sample, fp);
1751 	case PERF_SYNTH_INTEL_PWRX:
1752 		return perf_sample__fprintf_synth_pwrx(sample, fp);
1753 	case PERF_SYNTH_INTEL_CBR:
1754 		return perf_sample__fprintf_synth_cbr(sample, fp);
1755 	default:
1756 		break;
1757 	}
1758 
1759 	return 0;
1760 }
1761 
evlist__max_name_len(struct evlist * evlist)1762 static int evlist__max_name_len(struct evlist *evlist)
1763 {
1764 	struct evsel *evsel;
1765 	int max = 0;
1766 
1767 	evlist__for_each_entry(evlist, evsel) {
1768 		int len = strlen(evsel__name(evsel));
1769 
1770 		max = MAX(len, max);
1771 	}
1772 
1773 	return max;
1774 }
1775 
data_src__fprintf(u64 data_src,FILE * fp)1776 static int data_src__fprintf(u64 data_src, FILE *fp)
1777 {
1778 	struct mem_info mi = { .data_src.val = data_src };
1779 	char decode[100];
1780 	char out[100];
1781 	static int maxlen;
1782 	int len;
1783 
1784 	perf_script__meminfo_scnprintf(decode, 100, &mi);
1785 
1786 	len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode);
1787 	if (maxlen < len)
1788 		maxlen = len;
1789 
1790 	return fprintf(fp, "%-*s", maxlen, out);
1791 }
1792 
1793 struct metric_ctx {
1794 	struct perf_sample	*sample;
1795 	struct thread		*thread;
1796 	struct evsel	*evsel;
1797 	FILE 			*fp;
1798 };
1799 
script_print_metric(struct perf_stat_config * config __maybe_unused,void * ctx,const char * color,const char * fmt,const char * unit,double val)1800 static void script_print_metric(struct perf_stat_config *config __maybe_unused,
1801 				void *ctx, const char *color,
1802 			        const char *fmt,
1803 			        const char *unit, double val)
1804 {
1805 	struct metric_ctx *mctx = ctx;
1806 
1807 	if (!fmt)
1808 		return;
1809 	perf_sample__fprintf_start(NULL, mctx->sample, mctx->thread, mctx->evsel,
1810 				   PERF_RECORD_SAMPLE, mctx->fp);
1811 	fputs("\tmetric: ", mctx->fp);
1812 	if (color)
1813 		color_fprintf(mctx->fp, color, fmt, val);
1814 	else
1815 		printf(fmt, val);
1816 	fprintf(mctx->fp, " %s\n", unit);
1817 }
1818 
script_new_line(struct perf_stat_config * config __maybe_unused,void * ctx)1819 static void script_new_line(struct perf_stat_config *config __maybe_unused,
1820 			    void *ctx)
1821 {
1822 	struct metric_ctx *mctx = ctx;
1823 
1824 	perf_sample__fprintf_start(NULL, mctx->sample, mctx->thread, mctx->evsel,
1825 				   PERF_RECORD_SAMPLE, mctx->fp);
1826 	fputs("\tmetric: ", mctx->fp);
1827 }
1828 
perf_sample__fprint_metric(struct perf_script * script,struct thread * thread,struct evsel * evsel,struct perf_sample * sample,FILE * fp)1829 static void perf_sample__fprint_metric(struct perf_script *script,
1830 				       struct thread *thread,
1831 				       struct evsel *evsel,
1832 				       struct perf_sample *sample,
1833 				       FILE *fp)
1834 {
1835 	struct perf_stat_output_ctx ctx = {
1836 		.print_metric = script_print_metric,
1837 		.new_line = script_new_line,
1838 		.ctx = &(struct metric_ctx) {
1839 				.sample = sample,
1840 				.thread = thread,
1841 				.evsel  = evsel,
1842 				.fp     = fp,
1843 			 },
1844 		.force_header = false,
1845 	};
1846 	struct evsel *ev2;
1847 	u64 val;
1848 
1849 	if (!evsel->stats)
1850 		perf_evlist__alloc_stats(script->session->evlist, false);
1851 	if (evsel_script(evsel->leader)->gnum++ == 0)
1852 		perf_stat__reset_shadow_stats();
1853 	val = sample->period * evsel->scale;
1854 	perf_stat__update_shadow_stats(evsel,
1855 				       val,
1856 				       sample->cpu,
1857 				       &rt_stat);
1858 	evsel_script(evsel)->val = val;
1859 	if (evsel_script(evsel->leader)->gnum == evsel->leader->core.nr_members) {
1860 		for_each_group_member (ev2, evsel->leader) {
1861 			perf_stat__print_shadow_stats(&stat_config, ev2,
1862 						      evsel_script(ev2)->val,
1863 						      sample->cpu,
1864 						      &ctx,
1865 						      NULL,
1866 						      &rt_stat);
1867 		}
1868 		evsel_script(evsel->leader)->gnum = 0;
1869 	}
1870 }
1871 
show_event(struct perf_sample * sample,struct evsel * evsel,struct thread * thread,struct addr_location * al)1872 static bool show_event(struct perf_sample *sample,
1873 		       struct evsel *evsel,
1874 		       struct thread *thread,
1875 		       struct addr_location *al)
1876 {
1877 	int depth = thread_stack__depth(thread, sample->cpu);
1878 
1879 	if (!symbol_conf.graph_function)
1880 		return true;
1881 
1882 	if (thread->filter) {
1883 		if (depth <= thread->filter_entry_depth) {
1884 			thread->filter = false;
1885 			return false;
1886 		}
1887 		return true;
1888 	} else {
1889 		const char *s = symbol_conf.graph_function;
1890 		u64 ip;
1891 		const char *name = resolve_branch_sym(sample, evsel, thread, al,
1892 				&ip);
1893 		unsigned nlen;
1894 
1895 		if (!name)
1896 			return false;
1897 		nlen = strlen(name);
1898 		while (*s) {
1899 			unsigned len = strcspn(s, ",");
1900 			if (nlen == len && !strncmp(name, s, len)) {
1901 				thread->filter = true;
1902 				thread->filter_entry_depth = depth;
1903 				return true;
1904 			}
1905 			s += len;
1906 			if (*s == ',')
1907 				s++;
1908 		}
1909 		return false;
1910 	}
1911 }
1912 
process_event(struct perf_script * script,struct perf_sample * sample,struct evsel * evsel,struct addr_location * al,struct machine * machine)1913 static void process_event(struct perf_script *script,
1914 			  struct perf_sample *sample, struct evsel *evsel,
1915 			  struct addr_location *al,
1916 			  struct machine *machine)
1917 {
1918 	struct thread *thread = al->thread;
1919 	struct perf_event_attr *attr = &evsel->core.attr;
1920 	unsigned int type = output_type(attr->type);
1921 	struct evsel_script *es = evsel->priv;
1922 	FILE *fp = es->fp;
1923 
1924 	if (output[type].fields == 0)
1925 		return;
1926 
1927 	if (!show_event(sample, evsel, thread, al))
1928 		return;
1929 
1930 	if (evswitch__discard(&script->evswitch, evsel))
1931 		return;
1932 
1933 	++es->samples;
1934 
1935 	perf_sample__fprintf_start(script, sample, thread, evsel,
1936 				   PERF_RECORD_SAMPLE, fp);
1937 
1938 	if (PRINT_FIELD(PERIOD))
1939 		fprintf(fp, "%10" PRIu64 " ", sample->period);
1940 
1941 	if (PRINT_FIELD(EVNAME)) {
1942 		const char *evname = evsel__name(evsel);
1943 
1944 		if (!script->name_width)
1945 			script->name_width = evlist__max_name_len(script->session->evlist);
1946 
1947 		fprintf(fp, "%*s: ", script->name_width, evname ?: "[unknown]");
1948 	}
1949 
1950 	if (print_flags)
1951 		perf_sample__fprintf_flags(sample->flags, fp);
1952 
1953 	if (is_bts_event(attr)) {
1954 		perf_sample__fprintf_bts(sample, evsel, thread, al, machine, fp);
1955 		return;
1956 	}
1957 
1958 	if (PRINT_FIELD(TRACE) && sample->raw_data) {
1959 		event_format__fprintf(evsel->tp_format, sample->cpu,
1960 				      sample->raw_data, sample->raw_size, fp);
1961 	}
1962 
1963 	if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
1964 		perf_sample__fprintf_synth(sample, evsel, fp);
1965 
1966 	if (PRINT_FIELD(ADDR))
1967 		perf_sample__fprintf_addr(sample, thread, attr, fp);
1968 
1969 	if (PRINT_FIELD(DATA_SRC))
1970 		data_src__fprintf(sample->data_src, fp);
1971 
1972 	if (PRINT_FIELD(WEIGHT))
1973 		fprintf(fp, "%16" PRIu64, sample->weight);
1974 
1975 	if (PRINT_FIELD(IP)) {
1976 		struct callchain_cursor *cursor = NULL;
1977 
1978 		if (script->stitch_lbr)
1979 			al->thread->lbr_stitch_enable = true;
1980 
1981 		if (symbol_conf.use_callchain && sample->callchain &&
1982 		    thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
1983 					      sample, NULL, NULL, scripting_max_stack) == 0)
1984 			cursor = &callchain_cursor;
1985 
1986 		fputc(cursor ? '\n' : ' ', fp);
1987 		sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor,
1988 				    symbol_conf.bt_stop_list, fp);
1989 	}
1990 
1991 	if (PRINT_FIELD(IREGS))
1992 		perf_sample__fprintf_iregs(sample, attr, fp);
1993 
1994 	if (PRINT_FIELD(UREGS))
1995 		perf_sample__fprintf_uregs(sample, attr, fp);
1996 
1997 	if (PRINT_FIELD(BRSTACK))
1998 		perf_sample__fprintf_brstack(sample, thread, attr, fp);
1999 	else if (PRINT_FIELD(BRSTACKSYM))
2000 		perf_sample__fprintf_brstacksym(sample, thread, attr, fp);
2001 	else if (PRINT_FIELD(BRSTACKOFF))
2002 		perf_sample__fprintf_brstackoff(sample, thread, attr, fp);
2003 
2004 	if (evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
2005 		perf_sample__fprintf_bpf_output(sample, fp);
2006 	perf_sample__fprintf_insn(sample, attr, thread, machine, fp);
2007 
2008 	if (PRINT_FIELD(PHYS_ADDR))
2009 		fprintf(fp, "%16" PRIx64, sample->phys_addr);
2010 
2011 	perf_sample__fprintf_ipc(sample, attr, fp);
2012 
2013 	fprintf(fp, "\n");
2014 
2015 	if (PRINT_FIELD(SRCCODE)) {
2016 		if (map__fprintf_srccode(al->map, al->addr, stdout,
2017 					 &thread->srccode_state))
2018 			printf("\n");
2019 	}
2020 
2021 	if (PRINT_FIELD(METRIC))
2022 		perf_sample__fprint_metric(script, thread, evsel, sample, fp);
2023 
2024 	if (verbose)
2025 		fflush(fp);
2026 }
2027 
2028 static struct scripting_ops	*scripting_ops;
2029 
__process_stat(struct evsel * counter,u64 tstamp)2030 static void __process_stat(struct evsel *counter, u64 tstamp)
2031 {
2032 	int nthreads = perf_thread_map__nr(counter->core.threads);
2033 	int ncpus = evsel__nr_cpus(counter);
2034 	int cpu, thread;
2035 	static int header_printed;
2036 
2037 	if (counter->core.system_wide)
2038 		nthreads = 1;
2039 
2040 	if (!header_printed) {
2041 		printf("%3s %8s %15s %15s %15s %15s %s\n",
2042 		       "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
2043 		header_printed = 1;
2044 	}
2045 
2046 	for (thread = 0; thread < nthreads; thread++) {
2047 		for (cpu = 0; cpu < ncpus; cpu++) {
2048 			struct perf_counts_values *counts;
2049 
2050 			counts = perf_counts(counter->counts, cpu, thread);
2051 
2052 			printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
2053 				counter->core.cpus->map[cpu],
2054 				perf_thread_map__pid(counter->core.threads, thread),
2055 				counts->val,
2056 				counts->ena,
2057 				counts->run,
2058 				tstamp,
2059 				evsel__name(counter));
2060 		}
2061 	}
2062 }
2063 
process_stat(struct evsel * counter,u64 tstamp)2064 static void process_stat(struct evsel *counter, u64 tstamp)
2065 {
2066 	if (scripting_ops && scripting_ops->process_stat)
2067 		scripting_ops->process_stat(&stat_config, counter, tstamp);
2068 	else
2069 		__process_stat(counter, tstamp);
2070 }
2071 
process_stat_interval(u64 tstamp)2072 static void process_stat_interval(u64 tstamp)
2073 {
2074 	if (scripting_ops && scripting_ops->process_stat_interval)
2075 		scripting_ops->process_stat_interval(tstamp);
2076 }
2077 
setup_scripting(void)2078 static void setup_scripting(void)
2079 {
2080 	setup_perl_scripting();
2081 	setup_python_scripting();
2082 }
2083 
flush_scripting(void)2084 static int flush_scripting(void)
2085 {
2086 	return scripting_ops ? scripting_ops->flush_script() : 0;
2087 }
2088 
cleanup_scripting(void)2089 static int cleanup_scripting(void)
2090 {
2091 	pr_debug("\nperf script stopped\n");
2092 
2093 	return scripting_ops ? scripting_ops->stop_script() : 0;
2094 }
2095 
filter_cpu(struct perf_sample * sample)2096 static bool filter_cpu(struct perf_sample *sample)
2097 {
2098 	if (cpu_list && sample->cpu != (u32)-1)
2099 		return !test_bit(sample->cpu, cpu_bitmap);
2100 	return false;
2101 }
2102 
process_sample_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct evsel * evsel,struct machine * machine)2103 static int process_sample_event(struct perf_tool *tool,
2104 				union perf_event *event,
2105 				struct perf_sample *sample,
2106 				struct evsel *evsel,
2107 				struct machine *machine)
2108 {
2109 	struct perf_script *scr = container_of(tool, struct perf_script, tool);
2110 	struct addr_location al;
2111 
2112 	if (perf_time__ranges_skip_sample(scr->ptime_range, scr->range_num,
2113 					  sample->time)) {
2114 		return 0;
2115 	}
2116 
2117 	if (debug_mode) {
2118 		if (sample->time < last_timestamp) {
2119 			pr_err("Samples misordered, previous: %" PRIu64
2120 				" this: %" PRIu64 "\n", last_timestamp,
2121 				sample->time);
2122 			nr_unordered++;
2123 		}
2124 		last_timestamp = sample->time;
2125 		return 0;
2126 	}
2127 
2128 	if (machine__resolve(machine, &al, sample) < 0) {
2129 		pr_err("problem processing %d event, skipping it.\n",
2130 		       event->header.type);
2131 		return -1;
2132 	}
2133 
2134 	if (al.filtered)
2135 		goto out_put;
2136 
2137 	if (filter_cpu(sample))
2138 		goto out_put;
2139 
2140 	if (scripting_ops)
2141 		scripting_ops->process_event(event, sample, evsel, &al);
2142 	else
2143 		process_event(scr, sample, evsel, &al, machine);
2144 
2145 out_put:
2146 	addr_location__put(&al);
2147 	return 0;
2148 }
2149 
process_attr(struct perf_tool * tool,union perf_event * event,struct evlist ** pevlist)2150 static int process_attr(struct perf_tool *tool, union perf_event *event,
2151 			struct evlist **pevlist)
2152 {
2153 	struct perf_script *scr = container_of(tool, struct perf_script, tool);
2154 	struct evlist *evlist;
2155 	struct evsel *evsel, *pos;
2156 	u64 sample_type;
2157 	int err;
2158 	static struct evsel_script *es;
2159 
2160 	err = perf_event__process_attr(tool, event, pevlist);
2161 	if (err)
2162 		return err;
2163 
2164 	evlist = *pevlist;
2165 	evsel = evlist__last(*pevlist);
2166 
2167 	if (!evsel->priv) {
2168 		if (scr->per_event_dump) {
2169 			evsel->priv = perf_evsel_script__new(evsel,
2170 						scr->session->data);
2171 		} else {
2172 			es = zalloc(sizeof(*es));
2173 			if (!es)
2174 				return -ENOMEM;
2175 			es->fp = stdout;
2176 			evsel->priv = es;
2177 		}
2178 	}
2179 
2180 	if (evsel->core.attr.type >= PERF_TYPE_MAX &&
2181 	    evsel->core.attr.type != PERF_TYPE_SYNTH)
2182 		return 0;
2183 
2184 	evlist__for_each_entry(evlist, pos) {
2185 		if (pos->core.attr.type == evsel->core.attr.type && pos != evsel)
2186 			return 0;
2187 	}
2188 
2189 	if (evsel->core.attr.sample_type) {
2190 		err = evsel__check_attr(evsel, scr->session);
2191 		if (err)
2192 			return err;
2193 	}
2194 
2195 	/*
2196 	 * Check if we need to enable callchains based
2197 	 * on events sample_type.
2198 	 */
2199 	sample_type = evlist__combined_sample_type(evlist);
2200 	callchain_param_setup(sample_type);
2201 
2202 	/* Enable fields for callchain entries */
2203 	if (symbol_conf.use_callchain &&
2204 	    (sample_type & PERF_SAMPLE_CALLCHAIN ||
2205 	     sample_type & PERF_SAMPLE_BRANCH_STACK ||
2206 	     (sample_type & PERF_SAMPLE_REGS_USER &&
2207 	      sample_type & PERF_SAMPLE_STACK_USER))) {
2208 		int type = output_type(evsel->core.attr.type);
2209 
2210 		if (!(output[type].user_unset_fields & PERF_OUTPUT_IP))
2211 			output[type].fields |= PERF_OUTPUT_IP;
2212 		if (!(output[type].user_unset_fields & PERF_OUTPUT_SYM))
2213 			output[type].fields |= PERF_OUTPUT_SYM;
2214 	}
2215 	set_print_ip_opts(&evsel->core.attr);
2216 	return 0;
2217 }
2218 
print_event_with_time(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine,pid_t pid,pid_t tid,u64 timestamp)2219 static int print_event_with_time(struct perf_tool *tool,
2220 				 union perf_event *event,
2221 				 struct perf_sample *sample,
2222 				 struct machine *machine,
2223 				 pid_t pid, pid_t tid, u64 timestamp)
2224 {
2225 	struct perf_script *script = container_of(tool, struct perf_script, tool);
2226 	struct perf_session *session = script->session;
2227 	struct evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
2228 	struct thread *thread = NULL;
2229 
2230 	if (evsel && !evsel->core.attr.sample_id_all) {
2231 		sample->cpu = 0;
2232 		sample->time = timestamp;
2233 		sample->pid = pid;
2234 		sample->tid = tid;
2235 	}
2236 
2237 	if (filter_cpu(sample))
2238 		return 0;
2239 
2240 	if (tid != -1)
2241 		thread = machine__findnew_thread(machine, pid, tid);
2242 
2243 	if (evsel) {
2244 		perf_sample__fprintf_start(script, sample, thread, evsel,
2245 					   event->header.type, stdout);
2246 	}
2247 
2248 	perf_event__fprintf(event, machine, stdout);
2249 
2250 	thread__put(thread);
2251 
2252 	return 0;
2253 }
2254 
print_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine,pid_t pid,pid_t tid)2255 static int print_event(struct perf_tool *tool, union perf_event *event,
2256 		       struct perf_sample *sample, struct machine *machine,
2257 		       pid_t pid, pid_t tid)
2258 {
2259 	return print_event_with_time(tool, event, sample, machine, pid, tid, 0);
2260 }
2261 
process_comm_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2262 static int process_comm_event(struct perf_tool *tool,
2263 			      union perf_event *event,
2264 			      struct perf_sample *sample,
2265 			      struct machine *machine)
2266 {
2267 	if (perf_event__process_comm(tool, event, sample, machine) < 0)
2268 		return -1;
2269 
2270 	return print_event(tool, event, sample, machine, event->comm.pid,
2271 			   event->comm.tid);
2272 }
2273 
process_namespaces_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2274 static int process_namespaces_event(struct perf_tool *tool,
2275 				    union perf_event *event,
2276 				    struct perf_sample *sample,
2277 				    struct machine *machine)
2278 {
2279 	if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
2280 		return -1;
2281 
2282 	return print_event(tool, event, sample, machine, event->namespaces.pid,
2283 			   event->namespaces.tid);
2284 }
2285 
process_cgroup_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2286 static int process_cgroup_event(struct perf_tool *tool,
2287 				union perf_event *event,
2288 				struct perf_sample *sample,
2289 				struct machine *machine)
2290 {
2291 	if (perf_event__process_cgroup(tool, event, sample, machine) < 0)
2292 		return -1;
2293 
2294 	return print_event(tool, event, sample, machine, sample->pid,
2295 			    sample->tid);
2296 }
2297 
process_fork_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2298 static int process_fork_event(struct perf_tool *tool,
2299 			      union perf_event *event,
2300 			      struct perf_sample *sample,
2301 			      struct machine *machine)
2302 {
2303 	if (perf_event__process_fork(tool, event, sample, machine) < 0)
2304 		return -1;
2305 
2306 	return print_event_with_time(tool, event, sample, machine,
2307 				     event->fork.pid, event->fork.tid,
2308 				     event->fork.time);
2309 }
process_exit_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2310 static int process_exit_event(struct perf_tool *tool,
2311 			      union perf_event *event,
2312 			      struct perf_sample *sample,
2313 			      struct machine *machine)
2314 {
2315 	/* Print before 'exit' deletes anything */
2316 	if (print_event_with_time(tool, event, sample, machine, event->fork.pid,
2317 				  event->fork.tid, event->fork.time))
2318 		return -1;
2319 
2320 	return perf_event__process_exit(tool, event, sample, machine);
2321 }
2322 
process_mmap_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2323 static int process_mmap_event(struct perf_tool *tool,
2324 			      union perf_event *event,
2325 			      struct perf_sample *sample,
2326 			      struct machine *machine)
2327 {
2328 	if (perf_event__process_mmap(tool, event, sample, machine) < 0)
2329 		return -1;
2330 
2331 	return print_event(tool, event, sample, machine, event->mmap.pid,
2332 			   event->mmap.tid);
2333 }
2334 
process_mmap2_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2335 static int process_mmap2_event(struct perf_tool *tool,
2336 			      union perf_event *event,
2337 			      struct perf_sample *sample,
2338 			      struct machine *machine)
2339 {
2340 	if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
2341 		return -1;
2342 
2343 	return print_event(tool, event, sample, machine, event->mmap2.pid,
2344 			   event->mmap2.tid);
2345 }
2346 
process_switch_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2347 static int process_switch_event(struct perf_tool *tool,
2348 				union perf_event *event,
2349 				struct perf_sample *sample,
2350 				struct machine *machine)
2351 {
2352 	struct perf_script *script = container_of(tool, struct perf_script, tool);
2353 
2354 	if (perf_event__process_switch(tool, event, sample, machine) < 0)
2355 		return -1;
2356 
2357 	if (scripting_ops && scripting_ops->process_switch && !filter_cpu(sample))
2358 		scripting_ops->process_switch(event, sample, machine);
2359 
2360 	if (!script->show_switch_events)
2361 		return 0;
2362 
2363 	return print_event(tool, event, sample, machine, sample->pid,
2364 			   sample->tid);
2365 }
2366 
2367 static int
process_lost_event(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2368 process_lost_event(struct perf_tool *tool,
2369 		   union perf_event *event,
2370 		   struct perf_sample *sample,
2371 		   struct machine *machine)
2372 {
2373 	return print_event(tool, event, sample, machine, sample->pid,
2374 			   sample->tid);
2375 }
2376 
2377 static int
process_finished_round_event(struct perf_tool * tool __maybe_unused,union perf_event * event,struct ordered_events * oe __maybe_unused)2378 process_finished_round_event(struct perf_tool *tool __maybe_unused,
2379 			     union perf_event *event,
2380 			     struct ordered_events *oe __maybe_unused)
2381 
2382 {
2383 	perf_event__fprintf(event, NULL, stdout);
2384 	return 0;
2385 }
2386 
2387 static int
process_bpf_events(struct perf_tool * tool __maybe_unused,union perf_event * event,struct perf_sample * sample,struct machine * machine)2388 process_bpf_events(struct perf_tool *tool __maybe_unused,
2389 		   union perf_event *event,
2390 		   struct perf_sample *sample,
2391 		   struct machine *machine)
2392 {
2393 	if (machine__process_ksymbol(machine, event, sample) < 0)
2394 		return -1;
2395 
2396 	return print_event(tool, event, sample, machine, sample->pid,
2397 			   sample->tid);
2398 }
2399 
process_text_poke_events(struct perf_tool * tool,union perf_event * event,struct perf_sample * sample,struct machine * machine)2400 static int process_text_poke_events(struct perf_tool *tool,
2401 				    union perf_event *event,
2402 				    struct perf_sample *sample,
2403 				    struct machine *machine)
2404 {
2405 	if (perf_event__process_text_poke(tool, event, sample, machine) < 0)
2406 		return -1;
2407 
2408 	return print_event(tool, event, sample, machine, sample->pid,
2409 			   sample->tid);
2410 }
2411 
sig_handler(int sig __maybe_unused)2412 static void sig_handler(int sig __maybe_unused)
2413 {
2414 	session_done = 1;
2415 }
2416 
perf_script__fclose_per_event_dump(struct perf_script * script)2417 static void perf_script__fclose_per_event_dump(struct perf_script *script)
2418 {
2419 	struct evlist *evlist = script->session->evlist;
2420 	struct evsel *evsel;
2421 
2422 	evlist__for_each_entry(evlist, evsel) {
2423 		if (!evsel->priv)
2424 			break;
2425 		perf_evsel_script__delete(evsel->priv);
2426 		evsel->priv = NULL;
2427 	}
2428 }
2429 
perf_script__fopen_per_event_dump(struct perf_script * script)2430 static int perf_script__fopen_per_event_dump(struct perf_script *script)
2431 {
2432 	struct evsel *evsel;
2433 
2434 	evlist__for_each_entry(script->session->evlist, evsel) {
2435 		/*
2436 		 * Already setup? I.e. we may be called twice in cases like
2437 		 * Intel PT, one for the intel_pt// and dummy events, then
2438 		 * for the evsels syntheized from the auxtrace info.
2439 		 *
2440 		 * Ses perf_script__process_auxtrace_info.
2441 		 */
2442 		if (evsel->priv != NULL)
2443 			continue;
2444 
2445 		evsel->priv = perf_evsel_script__new(evsel, script->session->data);
2446 		if (evsel->priv == NULL)
2447 			goto out_err_fclose;
2448 	}
2449 
2450 	return 0;
2451 
2452 out_err_fclose:
2453 	perf_script__fclose_per_event_dump(script);
2454 	return -1;
2455 }
2456 
perf_script__setup_per_event_dump(struct perf_script * script)2457 static int perf_script__setup_per_event_dump(struct perf_script *script)
2458 {
2459 	struct evsel *evsel;
2460 	static struct evsel_script es_stdout;
2461 
2462 	if (script->per_event_dump)
2463 		return perf_script__fopen_per_event_dump(script);
2464 
2465 	es_stdout.fp = stdout;
2466 
2467 	evlist__for_each_entry(script->session->evlist, evsel)
2468 		evsel->priv = &es_stdout;
2469 
2470 	return 0;
2471 }
2472 
perf_script__exit_per_event_dump_stats(struct perf_script * script)2473 static void perf_script__exit_per_event_dump_stats(struct perf_script *script)
2474 {
2475 	struct evsel *evsel;
2476 
2477 	evlist__for_each_entry(script->session->evlist, evsel) {
2478 		struct evsel_script *es = evsel->priv;
2479 
2480 		perf_evsel_script__fprintf(es, stdout);
2481 		perf_evsel_script__delete(es);
2482 		evsel->priv = NULL;
2483 	}
2484 }
2485 
perf_script__exit(struct perf_script * script)2486 static void perf_script__exit(struct perf_script *script)
2487 {
2488 	perf_thread_map__put(script->threads);
2489 	perf_cpu_map__put(script->cpus);
2490 }
2491 
__cmd_script(struct perf_script * script)2492 static int __cmd_script(struct perf_script *script)
2493 {
2494 	int ret;
2495 
2496 	signal(SIGINT, sig_handler);
2497 
2498 	perf_stat__init_shadow_stats();
2499 
2500 	/* override event processing functions */
2501 	if (script->show_task_events) {
2502 		script->tool.comm = process_comm_event;
2503 		script->tool.fork = process_fork_event;
2504 		script->tool.exit = process_exit_event;
2505 	}
2506 	if (script->show_mmap_events) {
2507 		script->tool.mmap = process_mmap_event;
2508 		script->tool.mmap2 = process_mmap2_event;
2509 	}
2510 	if (script->show_switch_events || (scripting_ops && scripting_ops->process_switch))
2511 		script->tool.context_switch = process_switch_event;
2512 	if (script->show_namespace_events)
2513 		script->tool.namespaces = process_namespaces_event;
2514 	if (script->show_cgroup_events)
2515 		script->tool.cgroup = process_cgroup_event;
2516 	if (script->show_lost_events)
2517 		script->tool.lost = process_lost_event;
2518 	if (script->show_round_events) {
2519 		script->tool.ordered_events = false;
2520 		script->tool.finished_round = process_finished_round_event;
2521 	}
2522 	if (script->show_bpf_events) {
2523 		script->tool.ksymbol = process_bpf_events;
2524 		script->tool.bpf     = process_bpf_events;
2525 	}
2526 	if (script->show_text_poke_events) {
2527 		script->tool.ksymbol   = process_bpf_events;
2528 		script->tool.text_poke = process_text_poke_events;
2529 	}
2530 
2531 	if (perf_script__setup_per_event_dump(script)) {
2532 		pr_err("Couldn't create the per event dump files\n");
2533 		return -1;
2534 	}
2535 
2536 	ret = perf_session__process_events(script->session);
2537 
2538 	if (script->per_event_dump)
2539 		perf_script__exit_per_event_dump_stats(script);
2540 
2541 	if (debug_mode)
2542 		pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
2543 
2544 	return ret;
2545 }
2546 
2547 struct script_spec {
2548 	struct list_head	node;
2549 	struct scripting_ops	*ops;
2550 	char			spec[];
2551 };
2552 
2553 static LIST_HEAD(script_specs);
2554 
script_spec__new(const char * spec,struct scripting_ops * ops)2555 static struct script_spec *script_spec__new(const char *spec,
2556 					    struct scripting_ops *ops)
2557 {
2558 	struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
2559 
2560 	if (s != NULL) {
2561 		strcpy(s->spec, spec);
2562 		s->ops = ops;
2563 	}
2564 
2565 	return s;
2566 }
2567 
script_spec__add(struct script_spec * s)2568 static void script_spec__add(struct script_spec *s)
2569 {
2570 	list_add_tail(&s->node, &script_specs);
2571 }
2572 
script_spec__find(const char * spec)2573 static struct script_spec *script_spec__find(const char *spec)
2574 {
2575 	struct script_spec *s;
2576 
2577 	list_for_each_entry(s, &script_specs, node)
2578 		if (strcasecmp(s->spec, spec) == 0)
2579 			return s;
2580 	return NULL;
2581 }
2582 
script_spec_register(const char * spec,struct scripting_ops * ops)2583 int script_spec_register(const char *spec, struct scripting_ops *ops)
2584 {
2585 	struct script_spec *s;
2586 
2587 	s = script_spec__find(spec);
2588 	if (s)
2589 		return -1;
2590 
2591 	s = script_spec__new(spec, ops);
2592 	if (!s)
2593 		return -1;
2594 	else
2595 		script_spec__add(s);
2596 
2597 	return 0;
2598 }
2599 
script_spec__lookup(const char * spec)2600 static struct scripting_ops *script_spec__lookup(const char *spec)
2601 {
2602 	struct script_spec *s = script_spec__find(spec);
2603 	if (!s)
2604 		return NULL;
2605 
2606 	return s->ops;
2607 }
2608 
list_available_languages(void)2609 static void list_available_languages(void)
2610 {
2611 	struct script_spec *s;
2612 
2613 	fprintf(stderr, "\n");
2614 	fprintf(stderr, "Scripting language extensions (used in "
2615 		"perf script -s [spec:]script.[spec]):\n\n");
2616 
2617 	list_for_each_entry(s, &script_specs, node)
2618 		fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
2619 
2620 	fprintf(stderr, "\n");
2621 }
2622 
parse_scriptname(const struct option * opt __maybe_unused,const char * str,int unset __maybe_unused)2623 static int parse_scriptname(const struct option *opt __maybe_unused,
2624 			    const char *str, int unset __maybe_unused)
2625 {
2626 	char spec[PATH_MAX];
2627 	const char *script, *ext;
2628 	int len;
2629 
2630 	if (strcmp(str, "lang") == 0) {
2631 		list_available_languages();
2632 		exit(0);
2633 	}
2634 
2635 	script = strchr(str, ':');
2636 	if (script) {
2637 		len = script - str;
2638 		if (len >= PATH_MAX) {
2639 			fprintf(stderr, "invalid language specifier");
2640 			return -1;
2641 		}
2642 		strncpy(spec, str, len);
2643 		spec[len] = '\0';
2644 		scripting_ops = script_spec__lookup(spec);
2645 		if (!scripting_ops) {
2646 			fprintf(stderr, "invalid language specifier");
2647 			return -1;
2648 		}
2649 		script++;
2650 	} else {
2651 		script = str;
2652 		ext = strrchr(script, '.');
2653 		if (!ext) {
2654 			fprintf(stderr, "invalid script extension");
2655 			return -1;
2656 		}
2657 		scripting_ops = script_spec__lookup(++ext);
2658 		if (!scripting_ops) {
2659 			fprintf(stderr, "invalid script extension");
2660 			return -1;
2661 		}
2662 	}
2663 
2664 	script_name = strdup(script);
2665 
2666 	return 0;
2667 }
2668 
parse_output_fields(const struct option * opt __maybe_unused,const char * arg,int unset __maybe_unused)2669 static int parse_output_fields(const struct option *opt __maybe_unused,
2670 			    const char *arg, int unset __maybe_unused)
2671 {
2672 	char *tok, *strtok_saveptr = NULL;
2673 	int i, imax = ARRAY_SIZE(all_output_options);
2674 	int j;
2675 	int rc = 0;
2676 	char *str = strdup(arg);
2677 	int type = -1;
2678 	enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
2679 
2680 	if (!str)
2681 		return -ENOMEM;
2682 
2683 	/* first word can state for which event type the user is specifying
2684 	 * the fields. If no type exists, the specified fields apply to all
2685 	 * event types found in the file minus the invalid fields for a type.
2686 	 */
2687 	tok = strchr(str, ':');
2688 	if (tok) {
2689 		*tok = '\0';
2690 		tok++;
2691 		if (!strcmp(str, "hw"))
2692 			type = PERF_TYPE_HARDWARE;
2693 		else if (!strcmp(str, "sw"))
2694 			type = PERF_TYPE_SOFTWARE;
2695 		else if (!strcmp(str, "trace"))
2696 			type = PERF_TYPE_TRACEPOINT;
2697 		else if (!strcmp(str, "raw"))
2698 			type = PERF_TYPE_RAW;
2699 		else if (!strcmp(str, "break"))
2700 			type = PERF_TYPE_BREAKPOINT;
2701 		else if (!strcmp(str, "synth"))
2702 			type = OUTPUT_TYPE_SYNTH;
2703 		else {
2704 			fprintf(stderr, "Invalid event type in field string.\n");
2705 			rc = -EINVAL;
2706 			goto out;
2707 		}
2708 
2709 		if (output[type].user_set)
2710 			pr_warning("Overriding previous field request for %s events.\n",
2711 				   event_type(type));
2712 
2713 		/* Don't override defaults for +- */
2714 		if (strchr(tok, '+') || strchr(tok, '-'))
2715 			goto parse;
2716 
2717 		output[type].fields = 0;
2718 		output[type].user_set = true;
2719 		output[type].wildcard_set = false;
2720 
2721 	} else {
2722 		tok = str;
2723 		if (strlen(str) == 0) {
2724 			fprintf(stderr,
2725 				"Cannot set fields to 'none' for all event types.\n");
2726 			rc = -EINVAL;
2727 			goto out;
2728 		}
2729 
2730 		/* Don't override defaults for +- */
2731 		if (strchr(str, '+') || strchr(str, '-'))
2732 			goto parse;
2733 
2734 		if (output_set_by_user())
2735 			pr_warning("Overriding previous field request for all events.\n");
2736 
2737 		for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2738 			output[j].fields = 0;
2739 			output[j].user_set = true;
2740 			output[j].wildcard_set = true;
2741 		}
2742 	}
2743 
2744 parse:
2745 	for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
2746 		if (*tok == '+') {
2747 			if (change == SET)
2748 				goto out_badmix;
2749 			change = ADD;
2750 			tok++;
2751 		} else if (*tok == '-') {
2752 			if (change == SET)
2753 				goto out_badmix;
2754 			change = REMOVE;
2755 			tok++;
2756 		} else {
2757 			if (change != SET && change != DEFAULT)
2758 				goto out_badmix;
2759 			change = SET;
2760 		}
2761 
2762 		for (i = 0; i < imax; ++i) {
2763 			if (strcmp(tok, all_output_options[i].str) == 0)
2764 				break;
2765 		}
2766 		if (i == imax && strcmp(tok, "flags") == 0) {
2767 			print_flags = change == REMOVE ? false : true;
2768 			continue;
2769 		}
2770 		if (i == imax) {
2771 			fprintf(stderr, "Invalid field requested.\n");
2772 			rc = -EINVAL;
2773 			goto out;
2774 		}
2775 
2776 		if (type == -1) {
2777 			/* add user option to all events types for
2778 			 * which it is valid
2779 			 */
2780 			for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2781 				if (output[j].invalid_fields & all_output_options[i].field) {
2782 					pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
2783 						   all_output_options[i].str, event_type(j));
2784 				} else {
2785 					if (change == REMOVE) {
2786 						output[j].fields &= ~all_output_options[i].field;
2787 						output[j].user_set_fields &= ~all_output_options[i].field;
2788 						output[j].user_unset_fields |= all_output_options[i].field;
2789 					} else {
2790 						output[j].fields |= all_output_options[i].field;
2791 						output[j].user_set_fields |= all_output_options[i].field;
2792 						output[j].user_unset_fields &= ~all_output_options[i].field;
2793 					}
2794 					output[j].user_set = true;
2795 					output[j].wildcard_set = true;
2796 				}
2797 			}
2798 		} else {
2799 			if (output[type].invalid_fields & all_output_options[i].field) {
2800 				fprintf(stderr, "\'%s\' not valid for %s events.\n",
2801 					 all_output_options[i].str, event_type(type));
2802 
2803 				rc = -EINVAL;
2804 				goto out;
2805 			}
2806 			if (change == REMOVE)
2807 				output[type].fields &= ~all_output_options[i].field;
2808 			else
2809 				output[type].fields |= all_output_options[i].field;
2810 			output[type].user_set = true;
2811 			output[type].wildcard_set = true;
2812 		}
2813 	}
2814 
2815 	if (type >= 0) {
2816 		if (output[type].fields == 0) {
2817 			pr_debug("No fields requested for %s type. "
2818 				 "Events will not be displayed.\n", event_type(type));
2819 		}
2820 	}
2821 	goto out;
2822 
2823 out_badmix:
2824 	fprintf(stderr, "Cannot mix +-field with overridden fields\n");
2825 	rc = -EINVAL;
2826 out:
2827 	free(str);
2828 	return rc;
2829 }
2830 
2831 #define for_each_lang(scripts_path, scripts_dir, lang_dirent)		\
2832 	while ((lang_dirent = readdir(scripts_dir)) != NULL)		\
2833 		if ((lang_dirent->d_type == DT_DIR ||			\
2834 		     (lang_dirent->d_type == DT_UNKNOWN &&		\
2835 		      is_directory(scripts_path, lang_dirent))) &&	\
2836 		    (strcmp(lang_dirent->d_name, ".")) &&		\
2837 		    (strcmp(lang_dirent->d_name, "..")))
2838 
2839 #define for_each_script(lang_path, lang_dir, script_dirent)		\
2840 	while ((script_dirent = readdir(lang_dir)) != NULL)		\
2841 		if (script_dirent->d_type != DT_DIR &&			\
2842 		    (script_dirent->d_type != DT_UNKNOWN ||		\
2843 		     !is_directory(lang_path, script_dirent)))
2844 
2845 
2846 #define RECORD_SUFFIX			"-record"
2847 #define REPORT_SUFFIX			"-report"
2848 
2849 struct script_desc {
2850 	struct list_head	node;
2851 	char			*name;
2852 	char			*half_liner;
2853 	char			*args;
2854 };
2855 
2856 static LIST_HEAD(script_descs);
2857 
script_desc__new(const char * name)2858 static struct script_desc *script_desc__new(const char *name)
2859 {
2860 	struct script_desc *s = zalloc(sizeof(*s));
2861 
2862 	if (s != NULL && name)
2863 		s->name = strdup(name);
2864 
2865 	return s;
2866 }
2867 
script_desc__delete(struct script_desc * s)2868 static void script_desc__delete(struct script_desc *s)
2869 {
2870 	zfree(&s->name);
2871 	zfree(&s->half_liner);
2872 	zfree(&s->args);
2873 	free(s);
2874 }
2875 
script_desc__add(struct script_desc * s)2876 static void script_desc__add(struct script_desc *s)
2877 {
2878 	list_add_tail(&s->node, &script_descs);
2879 }
2880 
script_desc__find(const char * name)2881 static struct script_desc *script_desc__find(const char *name)
2882 {
2883 	struct script_desc *s;
2884 
2885 	list_for_each_entry(s, &script_descs, node)
2886 		if (strcasecmp(s->name, name) == 0)
2887 			return s;
2888 	return NULL;
2889 }
2890 
script_desc__findnew(const char * name)2891 static struct script_desc *script_desc__findnew(const char *name)
2892 {
2893 	struct script_desc *s = script_desc__find(name);
2894 
2895 	if (s)
2896 		return s;
2897 
2898 	s = script_desc__new(name);
2899 	if (!s)
2900 		return NULL;
2901 
2902 	script_desc__add(s);
2903 
2904 	return s;
2905 }
2906 
ends_with(const char * str,const char * suffix)2907 static const char *ends_with(const char *str, const char *suffix)
2908 {
2909 	size_t suffix_len = strlen(suffix);
2910 	const char *p = str;
2911 
2912 	if (strlen(str) > suffix_len) {
2913 		p = str + strlen(str) - suffix_len;
2914 		if (!strncmp(p, suffix, suffix_len))
2915 			return p;
2916 	}
2917 
2918 	return NULL;
2919 }
2920 
read_script_info(struct script_desc * desc,const char * filename)2921 static int read_script_info(struct script_desc *desc, const char *filename)
2922 {
2923 	char line[BUFSIZ], *p;
2924 	FILE *fp;
2925 
2926 	fp = fopen(filename, "r");
2927 	if (!fp)
2928 		return -1;
2929 
2930 	while (fgets(line, sizeof(line), fp)) {
2931 		p = skip_spaces(line);
2932 		if (strlen(p) == 0)
2933 			continue;
2934 		if (*p != '#')
2935 			continue;
2936 		p++;
2937 		if (strlen(p) && *p == '!')
2938 			continue;
2939 
2940 		p = skip_spaces(p);
2941 		if (strlen(p) && p[strlen(p) - 1] == '\n')
2942 			p[strlen(p) - 1] = '\0';
2943 
2944 		if (!strncmp(p, "description:", strlen("description:"))) {
2945 			p += strlen("description:");
2946 			desc->half_liner = strdup(skip_spaces(p));
2947 			continue;
2948 		}
2949 
2950 		if (!strncmp(p, "args:", strlen("args:"))) {
2951 			p += strlen("args:");
2952 			desc->args = strdup(skip_spaces(p));
2953 			continue;
2954 		}
2955 	}
2956 
2957 	fclose(fp);
2958 
2959 	return 0;
2960 }
2961 
get_script_root(struct dirent * script_dirent,const char * suffix)2962 static char *get_script_root(struct dirent *script_dirent, const char *suffix)
2963 {
2964 	char *script_root, *str;
2965 
2966 	script_root = strdup(script_dirent->d_name);
2967 	if (!script_root)
2968 		return NULL;
2969 
2970 	str = (char *)ends_with(script_root, suffix);
2971 	if (!str) {
2972 		free(script_root);
2973 		return NULL;
2974 	}
2975 
2976 	*str = '\0';
2977 	return script_root;
2978 }
2979 
list_available_scripts(const struct option * opt __maybe_unused,const char * s __maybe_unused,int unset __maybe_unused)2980 static int list_available_scripts(const struct option *opt __maybe_unused,
2981 				  const char *s __maybe_unused,
2982 				  int unset __maybe_unused)
2983 {
2984 	struct dirent *script_dirent, *lang_dirent;
2985 	char scripts_path[MAXPATHLEN];
2986 	DIR *scripts_dir, *lang_dir;
2987 	char script_path[MAXPATHLEN];
2988 	char lang_path[MAXPATHLEN];
2989 	struct script_desc *desc;
2990 	char first_half[BUFSIZ];
2991 	char *script_root;
2992 
2993 	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2994 
2995 	scripts_dir = opendir(scripts_path);
2996 	if (!scripts_dir) {
2997 		fprintf(stdout,
2998 			"open(%s) failed.\n"
2999 			"Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
3000 			scripts_path);
3001 		exit(-1);
3002 	}
3003 
3004 	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3005 		scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
3006 			  lang_dirent->d_name);
3007 		lang_dir = opendir(lang_path);
3008 		if (!lang_dir)
3009 			continue;
3010 
3011 		for_each_script(lang_path, lang_dir, script_dirent) {
3012 			script_root = get_script_root(script_dirent, REPORT_SUFFIX);
3013 			if (script_root) {
3014 				desc = script_desc__findnew(script_root);
3015 				scnprintf(script_path, MAXPATHLEN, "%s/%s",
3016 					  lang_path, script_dirent->d_name);
3017 				read_script_info(desc, script_path);
3018 				free(script_root);
3019 			}
3020 		}
3021 	}
3022 
3023 	fprintf(stdout, "List of available trace scripts:\n");
3024 	list_for_each_entry(desc, &script_descs, node) {
3025 		sprintf(first_half, "%s %s", desc->name,
3026 			desc->args ? desc->args : "");
3027 		fprintf(stdout, "  %-36s %s\n", first_half,
3028 			desc->half_liner ? desc->half_liner : "");
3029 	}
3030 
3031 	exit(0);
3032 }
3033 
3034 /*
3035  * Some scripts specify the required events in their "xxx-record" file,
3036  * this function will check if the events in perf.data match those
3037  * mentioned in the "xxx-record".
3038  *
3039  * Fixme: All existing "xxx-record" are all in good formats "-e event ",
3040  * which is covered well now. And new parsing code should be added to
3041  * cover the future complexing formats like event groups etc.
3042  */
check_ev_match(char * dir_name,char * scriptname,struct perf_session * session)3043 static int check_ev_match(char *dir_name, char *scriptname,
3044 			struct perf_session *session)
3045 {
3046 	char filename[MAXPATHLEN], evname[128];
3047 	char line[BUFSIZ], *p;
3048 	struct evsel *pos;
3049 	int match, len;
3050 	FILE *fp;
3051 
3052 	scnprintf(filename, MAXPATHLEN, "%s/bin/%s-record", dir_name, scriptname);
3053 
3054 	fp = fopen(filename, "r");
3055 	if (!fp)
3056 		return -1;
3057 
3058 	while (fgets(line, sizeof(line), fp)) {
3059 		p = skip_spaces(line);
3060 		if (*p == '#')
3061 			continue;
3062 
3063 		while (strlen(p)) {
3064 			p = strstr(p, "-e");
3065 			if (!p)
3066 				break;
3067 
3068 			p += 2;
3069 			p = skip_spaces(p);
3070 			len = strcspn(p, " \t");
3071 			if (!len)
3072 				break;
3073 
3074 			snprintf(evname, len + 1, "%s", p);
3075 
3076 			match = 0;
3077 			evlist__for_each_entry(session->evlist, pos) {
3078 				if (!strcmp(evsel__name(pos), evname)) {
3079 					match = 1;
3080 					break;
3081 				}
3082 			}
3083 
3084 			if (!match) {
3085 				fclose(fp);
3086 				return -1;
3087 			}
3088 		}
3089 	}
3090 
3091 	fclose(fp);
3092 	return 0;
3093 }
3094 
3095 /*
3096  * Return -1 if none is found, otherwise the actual scripts number.
3097  *
3098  * Currently the only user of this function is the script browser, which
3099  * will list all statically runnable scripts, select one, execute it and
3100  * show the output in a perf browser.
3101  */
find_scripts(char ** scripts_array,char ** scripts_path_array,int num,int pathlen)3102 int find_scripts(char **scripts_array, char **scripts_path_array, int num,
3103 		 int pathlen)
3104 {
3105 	struct dirent *script_dirent, *lang_dirent;
3106 	char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
3107 	DIR *scripts_dir, *lang_dir;
3108 	struct perf_session *session;
3109 	struct perf_data data = {
3110 		.path = input_name,
3111 		.mode = PERF_DATA_MODE_READ,
3112 	};
3113 	char *temp;
3114 	int i = 0;
3115 
3116 	session = perf_session__new(&data, false, NULL);
3117 	if (IS_ERR(session))
3118 		return PTR_ERR(session);
3119 
3120 	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3121 
3122 	scripts_dir = opendir(scripts_path);
3123 	if (!scripts_dir) {
3124 		perf_session__delete(session);
3125 		return -1;
3126 	}
3127 
3128 	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3129 		scnprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
3130 			  lang_dirent->d_name);
3131 #ifndef HAVE_LIBPERL_SUPPORT
3132 		if (strstr(lang_path, "perl"))
3133 			continue;
3134 #endif
3135 #ifndef HAVE_LIBPYTHON_SUPPORT
3136 		if (strstr(lang_path, "python"))
3137 			continue;
3138 #endif
3139 
3140 		lang_dir = opendir(lang_path);
3141 		if (!lang_dir)
3142 			continue;
3143 
3144 		for_each_script(lang_path, lang_dir, script_dirent) {
3145 			/* Skip those real time scripts: xxxtop.p[yl] */
3146 			if (strstr(script_dirent->d_name, "top."))
3147 				continue;
3148 			if (i >= num)
3149 				break;
3150 			snprintf(scripts_path_array[i], pathlen, "%s/%s",
3151 				lang_path,
3152 				script_dirent->d_name);
3153 			temp = strchr(script_dirent->d_name, '.');
3154 			snprintf(scripts_array[i],
3155 				(temp - script_dirent->d_name) + 1,
3156 				"%s", script_dirent->d_name);
3157 
3158 			if (check_ev_match(lang_path,
3159 					scripts_array[i], session))
3160 				continue;
3161 
3162 			i++;
3163 		}
3164 		closedir(lang_dir);
3165 	}
3166 
3167 	closedir(scripts_dir);
3168 	perf_session__delete(session);
3169 	return i;
3170 }
3171 
get_script_path(const char * script_root,const char * suffix)3172 static char *get_script_path(const char *script_root, const char *suffix)
3173 {
3174 	struct dirent *script_dirent, *lang_dirent;
3175 	char scripts_path[MAXPATHLEN];
3176 	char script_path[MAXPATHLEN];
3177 	DIR *scripts_dir, *lang_dir;
3178 	char lang_path[MAXPATHLEN];
3179 	char *__script_root;
3180 
3181 	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
3182 
3183 	scripts_dir = opendir(scripts_path);
3184 	if (!scripts_dir)
3185 		return NULL;
3186 
3187 	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
3188 		scnprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
3189 			  lang_dirent->d_name);
3190 		lang_dir = opendir(lang_path);
3191 		if (!lang_dir)
3192 			continue;
3193 
3194 		for_each_script(lang_path, lang_dir, script_dirent) {
3195 			__script_root = get_script_root(script_dirent, suffix);
3196 			if (__script_root && !strcmp(script_root, __script_root)) {
3197 				free(__script_root);
3198 				closedir(scripts_dir);
3199 				scnprintf(script_path, MAXPATHLEN, "%s/%s",
3200 					  lang_path, script_dirent->d_name);
3201 				closedir(lang_dir);
3202 				return strdup(script_path);
3203 			}
3204 			free(__script_root);
3205 		}
3206 		closedir(lang_dir);
3207 	}
3208 	closedir(scripts_dir);
3209 
3210 	return NULL;
3211 }
3212 
is_top_script(const char * script_path)3213 static bool is_top_script(const char *script_path)
3214 {
3215 	return ends_with(script_path, "top") == NULL ? false : true;
3216 }
3217 
has_required_arg(char * script_path)3218 static int has_required_arg(char *script_path)
3219 {
3220 	struct script_desc *desc;
3221 	int n_args = 0;
3222 	char *p;
3223 
3224 	desc = script_desc__new(NULL);
3225 
3226 	if (read_script_info(desc, script_path))
3227 		goto out;
3228 
3229 	if (!desc->args)
3230 		goto out;
3231 
3232 	for (p = desc->args; *p; p++)
3233 		if (*p == '<')
3234 			n_args++;
3235 out:
3236 	script_desc__delete(desc);
3237 
3238 	return n_args;
3239 }
3240 
have_cmd(int argc,const char ** argv)3241 static int have_cmd(int argc, const char **argv)
3242 {
3243 	char **__argv = malloc(sizeof(const char *) * argc);
3244 
3245 	if (!__argv) {
3246 		pr_err("malloc failed\n");
3247 		return -1;
3248 	}
3249 
3250 	memcpy(__argv, argv, sizeof(const char *) * argc);
3251 	argc = parse_options(argc, (const char **)__argv, record_options,
3252 			     NULL, PARSE_OPT_STOP_AT_NON_OPTION);
3253 	free(__argv);
3254 
3255 	system_wide = (argc == 0);
3256 
3257 	return 0;
3258 }
3259 
script__setup_sample_type(struct perf_script * script)3260 static void script__setup_sample_type(struct perf_script *script)
3261 {
3262 	struct perf_session *session = script->session;
3263 	u64 sample_type = evlist__combined_sample_type(session->evlist);
3264 
3265 	if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
3266 		if ((sample_type & PERF_SAMPLE_REGS_USER) &&
3267 		    (sample_type & PERF_SAMPLE_STACK_USER)) {
3268 			callchain_param.record_mode = CALLCHAIN_DWARF;
3269 			dwarf_callchain_users = true;
3270 		} else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
3271 			callchain_param.record_mode = CALLCHAIN_LBR;
3272 		else
3273 			callchain_param.record_mode = CALLCHAIN_FP;
3274 	}
3275 
3276 	if (script->stitch_lbr && (callchain_param.record_mode != CALLCHAIN_LBR)) {
3277 		pr_warning("Can't find LBR callchain. Switch off --stitch-lbr.\n"
3278 			   "Please apply --call-graph lbr when recording.\n");
3279 		script->stitch_lbr = false;
3280 	}
3281 }
3282 
process_stat_round_event(struct perf_session * session,union perf_event * event)3283 static int process_stat_round_event(struct perf_session *session,
3284 				    union perf_event *event)
3285 {
3286 	struct perf_record_stat_round *round = &event->stat_round;
3287 	struct evsel *counter;
3288 
3289 	evlist__for_each_entry(session->evlist, counter) {
3290 		perf_stat_process_counter(&stat_config, counter);
3291 		process_stat(counter, round->time);
3292 	}
3293 
3294 	process_stat_interval(round->time);
3295 	return 0;
3296 }
3297 
process_stat_config_event(struct perf_session * session __maybe_unused,union perf_event * event)3298 static int process_stat_config_event(struct perf_session *session __maybe_unused,
3299 				     union perf_event *event)
3300 {
3301 	perf_event__read_stat_config(&stat_config, &event->stat_config);
3302 	return 0;
3303 }
3304 
set_maps(struct perf_script * script)3305 static int set_maps(struct perf_script *script)
3306 {
3307 	struct evlist *evlist = script->session->evlist;
3308 
3309 	if (!script->cpus || !script->threads)
3310 		return 0;
3311 
3312 	if (WARN_ONCE(script->allocated, "stats double allocation\n"))
3313 		return -EINVAL;
3314 
3315 	perf_evlist__set_maps(&evlist->core, script->cpus, script->threads);
3316 
3317 	if (perf_evlist__alloc_stats(evlist, true))
3318 		return -ENOMEM;
3319 
3320 	script->allocated = true;
3321 	return 0;
3322 }
3323 
3324 static
process_thread_map_event(struct perf_session * session,union perf_event * event)3325 int process_thread_map_event(struct perf_session *session,
3326 			     union perf_event *event)
3327 {
3328 	struct perf_tool *tool = session->tool;
3329 	struct perf_script *script = container_of(tool, struct perf_script, tool);
3330 
3331 	if (script->threads) {
3332 		pr_warning("Extra thread map event, ignoring.\n");
3333 		return 0;
3334 	}
3335 
3336 	script->threads = thread_map__new_event(&event->thread_map);
3337 	if (!script->threads)
3338 		return -ENOMEM;
3339 
3340 	return set_maps(script);
3341 }
3342 
3343 static
process_cpu_map_event(struct perf_session * session,union perf_event * event)3344 int process_cpu_map_event(struct perf_session *session,
3345 			  union perf_event *event)
3346 {
3347 	struct perf_tool *tool = session->tool;
3348 	struct perf_script *script = container_of(tool, struct perf_script, tool);
3349 
3350 	if (script->cpus) {
3351 		pr_warning("Extra cpu map event, ignoring.\n");
3352 		return 0;
3353 	}
3354 
3355 	script->cpus = cpu_map__new_data(&event->cpu_map.data);
3356 	if (!script->cpus)
3357 		return -ENOMEM;
3358 
3359 	return set_maps(script);
3360 }
3361 
process_feature_event(struct perf_session * session,union perf_event * event)3362 static int process_feature_event(struct perf_session *session,
3363 				 union perf_event *event)
3364 {
3365 	if (event->feat.feat_id < HEADER_LAST_FEATURE)
3366 		return perf_event__process_feature(session, event);
3367 	return 0;
3368 }
3369 
3370 #ifdef HAVE_AUXTRACE_SUPPORT
perf_script__process_auxtrace_info(struct perf_session * session,union perf_event * event)3371 static int perf_script__process_auxtrace_info(struct perf_session *session,
3372 					      union perf_event *event)
3373 {
3374 	struct perf_tool *tool = session->tool;
3375 
3376 	int ret = perf_event__process_auxtrace_info(session, event);
3377 
3378 	if (ret == 0) {
3379 		struct perf_script *script = container_of(tool, struct perf_script, tool);
3380 
3381 		ret = perf_script__setup_per_event_dump(script);
3382 	}
3383 
3384 	return ret;
3385 }
3386 #else
3387 #define perf_script__process_auxtrace_info 0
3388 #endif
3389 
parse_insn_trace(const struct option * opt __maybe_unused,const char * str __maybe_unused,int unset __maybe_unused)3390 static int parse_insn_trace(const struct option *opt __maybe_unused,
3391 			    const char *str __maybe_unused,
3392 			    int unset __maybe_unused)
3393 {
3394 	parse_output_fields(NULL, "+insn,-event,-period", 0);
3395 	itrace_parse_synth_opts(opt, "i0ns", 0);
3396 	symbol_conf.nanosecs = true;
3397 	return 0;
3398 }
3399 
parse_xed(const struct option * opt __maybe_unused,const char * str __maybe_unused,int unset __maybe_unused)3400 static int parse_xed(const struct option *opt __maybe_unused,
3401 		     const char *str __maybe_unused,
3402 		     int unset __maybe_unused)
3403 {
3404 	if (isatty(1))
3405 		force_pager("xed -F insn: -A -64 | less");
3406 	else
3407 		force_pager("xed -F insn: -A -64");
3408 	return 0;
3409 }
3410 
parse_call_trace(const struct option * opt __maybe_unused,const char * str __maybe_unused,int unset __maybe_unused)3411 static int parse_call_trace(const struct option *opt __maybe_unused,
3412 			    const char *str __maybe_unused,
3413 			    int unset __maybe_unused)
3414 {
3415 	parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent", 0);
3416 	itrace_parse_synth_opts(opt, "cewp", 0);
3417 	symbol_conf.nanosecs = true;
3418 	symbol_conf.pad_output_len_dso = 50;
3419 	return 0;
3420 }
3421 
parse_callret_trace(const struct option * opt __maybe_unused,const char * str __maybe_unused,int unset __maybe_unused)3422 static int parse_callret_trace(const struct option *opt __maybe_unused,
3423 			    const char *str __maybe_unused,
3424 			    int unset __maybe_unused)
3425 {
3426 	parse_output_fields(NULL, "-ip,-addr,-event,-period,+callindent,+flags", 0);
3427 	itrace_parse_synth_opts(opt, "crewp", 0);
3428 	symbol_conf.nanosecs = true;
3429 	return 0;
3430 }
3431 
cmd_script(int argc,const char ** argv)3432 int cmd_script(int argc, const char **argv)
3433 {
3434 	bool show_full_info = false;
3435 	bool header = false;
3436 	bool header_only = false;
3437 	bool script_started = false;
3438 	char *rec_script_path = NULL;
3439 	char *rep_script_path = NULL;
3440 	struct perf_session *session;
3441 	struct itrace_synth_opts itrace_synth_opts = {
3442 		.set = false,
3443 		.default_no_sample = true,
3444 	};
3445 	struct utsname uts;
3446 	char *script_path = NULL;
3447 	const char **__argv;
3448 	int i, j, err = 0;
3449 	struct perf_script script = {
3450 		.tool = {
3451 			.sample		 = process_sample_event,
3452 			.mmap		 = perf_event__process_mmap,
3453 			.mmap2		 = perf_event__process_mmap2,
3454 			.comm		 = perf_event__process_comm,
3455 			.namespaces	 = perf_event__process_namespaces,
3456 			.cgroup		 = perf_event__process_cgroup,
3457 			.exit		 = perf_event__process_exit,
3458 			.fork		 = perf_event__process_fork,
3459 			.attr		 = process_attr,
3460 			.event_update   = perf_event__process_event_update,
3461 			.tracing_data	 = perf_event__process_tracing_data,
3462 			.feature	 = process_feature_event,
3463 			.build_id	 = perf_event__process_build_id,
3464 			.id_index	 = perf_event__process_id_index,
3465 			.auxtrace_info	 = perf_script__process_auxtrace_info,
3466 			.auxtrace	 = perf_event__process_auxtrace,
3467 			.auxtrace_error	 = perf_event__process_auxtrace_error,
3468 			.stat		 = perf_event__process_stat_event,
3469 			.stat_round	 = process_stat_round_event,
3470 			.stat_config	 = process_stat_config_event,
3471 			.thread_map	 = process_thread_map_event,
3472 			.cpu_map	 = process_cpu_map_event,
3473 			.ordered_events	 = true,
3474 			.ordering_requires_timestamps = true,
3475 		},
3476 	};
3477 	struct perf_data data = {
3478 		.mode = PERF_DATA_MODE_READ,
3479 	};
3480 	const struct option options[] = {
3481 	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
3482 		    "dump raw trace in ASCII"),
3483 	OPT_INCR('v', "verbose", &verbose,
3484 		 "be more verbose (show symbol address, etc)"),
3485 	OPT_BOOLEAN('L', "Latency", &latency_format,
3486 		    "show latency attributes (irqs/preemption disabled, etc)"),
3487 	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
3488 			   list_available_scripts),
3489 	OPT_CALLBACK('s', "script", NULL, "name",
3490 		     "script file name (lang:script name, script name, or *)",
3491 		     parse_scriptname),
3492 	OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
3493 		   "generate perf-script.xx script in specified language"),
3494 	OPT_STRING('i', "input", &input_name, "file", "input file name"),
3495 	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
3496 		   "do various checks like samples ordering and lost events"),
3497 	OPT_BOOLEAN(0, "header", &header, "Show data header."),
3498 	OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
3499 	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
3500 		   "file", "vmlinux pathname"),
3501 	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
3502 		   "file", "kallsyms pathname"),
3503 	OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
3504 		    "When printing symbols do not display call chain"),
3505 	OPT_CALLBACK(0, "symfs", NULL, "directory",
3506 		     "Look for files with symbols relative to this directory",
3507 		     symbol__config_symfs),
3508 	OPT_CALLBACK('F', "fields", NULL, "str",
3509 		     "comma separated output fields prepend with 'type:'. "
3510 		     "+field to add and -field to remove."
3511 		     "Valid types: hw,sw,trace,raw,synth. "
3512 		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
3513 		     "addr,symoff,srcline,period,iregs,uregs,brstack,"
3514 		     "brstacksym,flags,bpf-output,brstackinsn,brstackoff,"
3515 		     "callindent,insn,insnlen,synth,phys_addr,metric,misc,ipc,tod",
3516 		     parse_output_fields),
3517 	OPT_BOOLEAN('a', "all-cpus", &system_wide,
3518 		    "system-wide collection from all CPUs"),
3519 	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
3520 		   "only consider these symbols"),
3521 	OPT_CALLBACK_OPTARG(0, "insn-trace", &itrace_synth_opts, NULL, NULL,
3522 			"Decode instructions from itrace", parse_insn_trace),
3523 	OPT_CALLBACK_OPTARG(0, "xed", NULL, NULL, NULL,
3524 			"Run xed disassembler on output", parse_xed),
3525 	OPT_CALLBACK_OPTARG(0, "call-trace", &itrace_synth_opts, NULL, NULL,
3526 			"Decode calls from from itrace", parse_call_trace),
3527 	OPT_CALLBACK_OPTARG(0, "call-ret-trace", &itrace_synth_opts, NULL, NULL,
3528 			"Decode calls and returns from itrace", parse_callret_trace),
3529 	OPT_STRING(0, "graph-function", &symbol_conf.graph_function, "symbol[,symbol...]",
3530 			"Only print symbols and callees with --call-trace/--call-ret-trace"),
3531 	OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
3532 		   "Stop display of callgraph at these symbols"),
3533 	OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
3534 	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
3535 		   "only display events for these comms"),
3536 	OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
3537 		   "only consider symbols in these pids"),
3538 	OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
3539 		   "only consider symbols in these tids"),
3540 	OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
3541 		     "Set the maximum stack depth when parsing the callchain, "
3542 		     "anything beyond the specified depth will be ignored. "
3543 		     "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
3544 	OPT_BOOLEAN(0, "reltime", &reltime, "Show time stamps relative to start"),
3545 	OPT_BOOLEAN(0, "deltatime", &deltatime, "Show time stamps relative to previous event"),
3546 	OPT_BOOLEAN('I', "show-info", &show_full_info,
3547 		    "display extended information from perf.data file"),
3548 	OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
3549 		    "Show the path of [kernel.kallsyms]"),
3550 	OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
3551 		    "Show the fork/comm/exit events"),
3552 	OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
3553 		    "Show the mmap events"),
3554 	OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
3555 		    "Show context switch events (if recorded)"),
3556 	OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
3557 		    "Show namespace events (if recorded)"),
3558 	OPT_BOOLEAN('\0', "show-cgroup-events", &script.show_cgroup_events,
3559 		    "Show cgroup events (if recorded)"),
3560 	OPT_BOOLEAN('\0', "show-lost-events", &script.show_lost_events,
3561 		    "Show lost events (if recorded)"),
3562 	OPT_BOOLEAN('\0', "show-round-events", &script.show_round_events,
3563 		    "Show round events (if recorded)"),
3564 	OPT_BOOLEAN('\0', "show-bpf-events", &script.show_bpf_events,
3565 		    "Show bpf related events (if recorded)"),
3566 	OPT_BOOLEAN('\0', "show-text-poke-events", &script.show_text_poke_events,
3567 		    "Show text poke related events (if recorded)"),
3568 	OPT_BOOLEAN('\0', "per-event-dump", &script.per_event_dump,
3569 		    "Dump trace output to files named by the monitored events"),
3570 	OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
3571 	OPT_INTEGER(0, "max-blocks", &max_blocks,
3572 		    "Maximum number of code blocks to dump with brstackinsn"),
3573 	OPT_BOOLEAN(0, "ns", &symbol_conf.nanosecs,
3574 		    "Use 9 decimal places when displaying time"),
3575 	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
3576 			    "Instruction Tracing options\n" ITRACE_HELP,
3577 			    itrace_parse_synth_opts),
3578 	OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
3579 			"Show full source file name path for source lines"),
3580 	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
3581 			"Enable symbol demangling"),
3582 	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
3583 			"Enable kernel symbol demangling"),
3584 	OPT_STRING(0, "time", &script.time_str, "str",
3585 		   "Time span of interest (start,stop)"),
3586 	OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
3587 		    "Show inline function"),
3588 	OPT_STRING(0, "guestmount", &symbol_conf.guestmount, "directory",
3589 		   "guest mount directory under which every guest os"
3590 		   " instance has a subdir"),
3591 	OPT_STRING(0, "guestvmlinux", &symbol_conf.default_guest_vmlinux_name,
3592 		   "file", "file saving guest os vmlinux"),
3593 	OPT_STRING(0, "guestkallsyms", &symbol_conf.default_guest_kallsyms,
3594 		   "file", "file saving guest os /proc/kallsyms"),
3595 	OPT_STRING(0, "guestmodules", &symbol_conf.default_guest_modules,
3596 		   "file", "file saving guest os /proc/modules"),
3597 	OPT_BOOLEAN('\0', "stitch-lbr", &script.stitch_lbr,
3598 		    "Enable LBR callgraph stitching approach"),
3599 	OPTS_EVSWITCH(&script.evswitch),
3600 	OPT_END()
3601 	};
3602 	const char * const script_subcommands[] = { "record", "report", NULL };
3603 	const char *script_usage[] = {
3604 		"perf script [<options>]",
3605 		"perf script [<options>] record <script> [<record-options>] <command>",
3606 		"perf script [<options>] report <script> [script-args]",
3607 		"perf script [<options>] <script> [<record-options>] <command>",
3608 		"perf script [<options>] <top-script> [script-args]",
3609 		NULL
3610 	};
3611 
3612 	perf_set_singlethreaded();
3613 
3614 	setup_scripting();
3615 
3616 	argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
3617 			     PARSE_OPT_STOP_AT_NON_OPTION);
3618 
3619 	if (symbol_conf.guestmount ||
3620 	    symbol_conf.default_guest_vmlinux_name ||
3621 	    symbol_conf.default_guest_kallsyms ||
3622 	    symbol_conf.default_guest_modules) {
3623 		/*
3624 		 * Enable guest sample processing.
3625 		 */
3626 		perf_guest = true;
3627 	}
3628 
3629 	data.path  = input_name;
3630 	data.force = symbol_conf.force;
3631 
3632 	if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
3633 		rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
3634 		if (!rec_script_path)
3635 			return cmd_record(argc, argv);
3636 	}
3637 
3638 	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
3639 		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
3640 		if (!rep_script_path) {
3641 			fprintf(stderr,
3642 				"Please specify a valid report script"
3643 				"(see 'perf script -l' for listing)\n");
3644 			return -1;
3645 		}
3646 	}
3647 
3648 	if (reltime && deltatime) {
3649 		fprintf(stderr,
3650 			"reltime and deltatime - the two don't get along well. "
3651 			"Please limit to --reltime or --deltatime.\n");
3652 		return -1;
3653 	}
3654 
3655 	if ((itrace_synth_opts.callchain || itrace_synth_opts.add_callchain) &&
3656 	    itrace_synth_opts.callchain_sz > scripting_max_stack)
3657 		scripting_max_stack = itrace_synth_opts.callchain_sz;
3658 
3659 	/* make sure PERF_EXEC_PATH is set for scripts */
3660 	set_argv_exec_path(get_argv_exec_path());
3661 
3662 	if (argc && !script_name && !rec_script_path && !rep_script_path) {
3663 		int live_pipe[2];
3664 		int rep_args;
3665 		pid_t pid;
3666 
3667 		rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
3668 		rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
3669 
3670 		if (!rec_script_path && !rep_script_path) {
3671 			usage_with_options_msg(script_usage, options,
3672 				"Couldn't find script `%s'\n\n See perf"
3673 				" script -l for available scripts.\n", argv[0]);
3674 		}
3675 
3676 		if (is_top_script(argv[0])) {
3677 			rep_args = argc - 1;
3678 		} else {
3679 			int rec_args;
3680 
3681 			rep_args = has_required_arg(rep_script_path);
3682 			rec_args = (argc - 1) - rep_args;
3683 			if (rec_args < 0) {
3684 				usage_with_options_msg(script_usage, options,
3685 					"`%s' script requires options."
3686 					"\n\n See perf script -l for available "
3687 					"scripts and options.\n", argv[0]);
3688 			}
3689 		}
3690 
3691 		if (pipe(live_pipe) < 0) {
3692 			perror("failed to create pipe");
3693 			return -1;
3694 		}
3695 
3696 		pid = fork();
3697 		if (pid < 0) {
3698 			perror("failed to fork");
3699 			return -1;
3700 		}
3701 
3702 		if (!pid) {
3703 			j = 0;
3704 
3705 			dup2(live_pipe[1], 1);
3706 			close(live_pipe[0]);
3707 
3708 			if (is_top_script(argv[0])) {
3709 				system_wide = true;
3710 			} else if (!system_wide) {
3711 				if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
3712 					err = -1;
3713 					goto out;
3714 				}
3715 			}
3716 
3717 			__argv = malloc((argc + 6) * sizeof(const char *));
3718 			if (!__argv) {
3719 				pr_err("malloc failed\n");
3720 				err = -ENOMEM;
3721 				goto out;
3722 			}
3723 
3724 			__argv[j++] = "/bin/sh";
3725 			__argv[j++] = rec_script_path;
3726 			if (system_wide)
3727 				__argv[j++] = "-a";
3728 			__argv[j++] = "-q";
3729 			__argv[j++] = "-o";
3730 			__argv[j++] = "-";
3731 			for (i = rep_args + 1; i < argc; i++)
3732 				__argv[j++] = argv[i];
3733 			__argv[j++] = NULL;
3734 
3735 			execvp("/bin/sh", (char **)__argv);
3736 			free(__argv);
3737 			exit(-1);
3738 		}
3739 
3740 		dup2(live_pipe[0], 0);
3741 		close(live_pipe[1]);
3742 
3743 		__argv = malloc((argc + 4) * sizeof(const char *));
3744 		if (!__argv) {
3745 			pr_err("malloc failed\n");
3746 			err = -ENOMEM;
3747 			goto out;
3748 		}
3749 
3750 		j = 0;
3751 		__argv[j++] = "/bin/sh";
3752 		__argv[j++] = rep_script_path;
3753 		for (i = 1; i < rep_args + 1; i++)
3754 			__argv[j++] = argv[i];
3755 		__argv[j++] = "-i";
3756 		__argv[j++] = "-";
3757 		__argv[j++] = NULL;
3758 
3759 		execvp("/bin/sh", (char **)__argv);
3760 		free(__argv);
3761 		exit(-1);
3762 	}
3763 
3764 	if (rec_script_path)
3765 		script_path = rec_script_path;
3766 	if (rep_script_path)
3767 		script_path = rep_script_path;
3768 
3769 	if (script_path) {
3770 		j = 0;
3771 
3772 		if (!rec_script_path)
3773 			system_wide = false;
3774 		else if (!system_wide) {
3775 			if (have_cmd(argc - 1, &argv[1]) != 0) {
3776 				err = -1;
3777 				goto out;
3778 			}
3779 		}
3780 
3781 		__argv = malloc((argc + 2) * sizeof(const char *));
3782 		if (!__argv) {
3783 			pr_err("malloc failed\n");
3784 			err = -ENOMEM;
3785 			goto out;
3786 		}
3787 
3788 		__argv[j++] = "/bin/sh";
3789 		__argv[j++] = script_path;
3790 		if (system_wide)
3791 			__argv[j++] = "-a";
3792 		for (i = 2; i < argc; i++)
3793 			__argv[j++] = argv[i];
3794 		__argv[j++] = NULL;
3795 
3796 		execvp("/bin/sh", (char **)__argv);
3797 		free(__argv);
3798 		exit(-1);
3799 	}
3800 
3801 	if (!script_name) {
3802 		setup_pager();
3803 		use_browser = 0;
3804 	}
3805 
3806 	session = perf_session__new(&data, false, &script.tool);
3807 	if (IS_ERR(session))
3808 		return PTR_ERR(session);
3809 
3810 	if (header || header_only) {
3811 		script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
3812 		perf_session__fprintf_info(session, stdout, show_full_info);
3813 		if (header_only)
3814 			goto out_delete;
3815 	}
3816 	if (show_full_info)
3817 		script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
3818 
3819 	if (symbol__init(&session->header.env) < 0)
3820 		goto out_delete;
3821 
3822 	uname(&uts);
3823 	if (data.is_pipe) { /* Assume pipe_mode indicates native_arch */
3824 		native_arch = true;
3825 	} else if (session->header.env.arch) {
3826 		if (!strcmp(uts.machine, session->header.env.arch))
3827 			native_arch = true;
3828 		else if (!strcmp(uts.machine, "x86_64") &&
3829 			 !strcmp(session->header.env.arch, "i386"))
3830 			native_arch = true;
3831 	}
3832 
3833 	script.session = session;
3834 	script__setup_sample_type(&script);
3835 
3836 	if ((output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT) ||
3837 	    symbol_conf.graph_function)
3838 		itrace_synth_opts.thread_stack = true;
3839 
3840 	session->itrace_synth_opts = &itrace_synth_opts;
3841 
3842 	if (cpu_list) {
3843 		err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
3844 		if (err < 0)
3845 			goto out_delete;
3846 		itrace_synth_opts.cpu_bitmap = cpu_bitmap;
3847 	}
3848 
3849 	if (!no_callchain)
3850 		symbol_conf.use_callchain = true;
3851 	else
3852 		symbol_conf.use_callchain = false;
3853 
3854 	if (session->tevent.pevent &&
3855 	    tep_set_function_resolver(session->tevent.pevent,
3856 				      machine__resolve_kernel_addr,
3857 				      &session->machines.host) < 0) {
3858 		pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
3859 		err = -1;
3860 		goto out_delete;
3861 	}
3862 
3863 	if (generate_script_lang) {
3864 		struct stat perf_stat;
3865 		int input;
3866 
3867 		if (output_set_by_user()) {
3868 			fprintf(stderr,
3869 				"custom fields not supported for generated scripts");
3870 			err = -EINVAL;
3871 			goto out_delete;
3872 		}
3873 
3874 		input = open(data.path, O_RDONLY);	/* input_name */
3875 		if (input < 0) {
3876 			err = -errno;
3877 			perror("failed to open file");
3878 			goto out_delete;
3879 		}
3880 
3881 		err = fstat(input, &perf_stat);
3882 		if (err < 0) {
3883 			perror("failed to stat file");
3884 			goto out_delete;
3885 		}
3886 
3887 		if (!perf_stat.st_size) {
3888 			fprintf(stderr, "zero-sized file, nothing to do!\n");
3889 			goto out_delete;
3890 		}
3891 
3892 		scripting_ops = script_spec__lookup(generate_script_lang);
3893 		if (!scripting_ops) {
3894 			fprintf(stderr, "invalid language specifier");
3895 			err = -ENOENT;
3896 			goto out_delete;
3897 		}
3898 
3899 		err = scripting_ops->generate_script(session->tevent.pevent,
3900 						     "perf-script");
3901 		goto out_delete;
3902 	}
3903 
3904 	if (script_name) {
3905 		err = scripting_ops->start_script(script_name, argc, argv);
3906 		if (err)
3907 			goto out_delete;
3908 		pr_debug("perf script started with script %s\n\n", script_name);
3909 		script_started = true;
3910 	}
3911 
3912 
3913 	err = perf_session__check_output_opt(session);
3914 	if (err < 0)
3915 		goto out_delete;
3916 
3917 	if (script.time_str) {
3918 		err = perf_time__parse_for_ranges_reltime(script.time_str, session,
3919 						  &script.ptime_range,
3920 						  &script.range_size,
3921 						  &script.range_num,
3922 						  reltime);
3923 		if (err < 0)
3924 			goto out_delete;
3925 
3926 		itrace_synth_opts__set_time_range(&itrace_synth_opts,
3927 						  script.ptime_range,
3928 						  script.range_num);
3929 	}
3930 
3931 	err = evswitch__init(&script.evswitch, session->evlist, stderr);
3932 	if (err)
3933 		goto out_delete;
3934 
3935 	if (zstd_init(&(session->zstd_data), 0) < 0)
3936 		pr_warning("Decompression initialization failed. Reported data may be incomplete.\n");
3937 
3938 	err = __cmd_script(&script);
3939 
3940 	flush_scripting();
3941 
3942 out_delete:
3943 	if (script.ptime_range) {
3944 		itrace_synth_opts__clear_time_range(&itrace_synth_opts);
3945 		zfree(&script.ptime_range);
3946 	}
3947 
3948 	perf_evlist__free_stats(session->evlist);
3949 	perf_session__delete(session);
3950 	perf_script__exit(&script);
3951 
3952 	if (script_started)
3953 		cleanup_scripting();
3954 out:
3955 	return err;
3956 }
3957