builtin-script.c 78.2 KB
Newer Older
F
Frederic Weisbecker 已提交
1 2
#include "builtin.h"

A
Andrea Gelmini 已提交
3
#include "perf.h"
F
Frederic Weisbecker 已提交
4
#include "util/cache.h"
A
Andrea Gelmini 已提交
5
#include "util/debug.h"
6
#include <subcmd/exec-cmd.h>
A
Andrea Gelmini 已提交
7
#include "util/header.h"
8
#include <subcmd/parse-options.h>
9
#include "util/perf_regs.h"
A
Andrea Gelmini 已提交
10
#include "util/session.h"
11
#include "util/tool.h"
F
Frederic Weisbecker 已提交
12 13
#include "util/symbol.h"
#include "util/thread.h"
I
Ingo Molnar 已提交
14
#include "util/trace-event.h"
A
Andrea Gelmini 已提交
15
#include "util/util.h"
16 17
#include "util/evlist.h"
#include "util/evsel.h"
18
#include "util/sort.h"
19
#include "util/data.h"
20
#include "util/auxtrace.h"
21 22 23
#include "util/cpumap.h"
#include "util/thread_map.h"
#include "util/stat.h"
24
#include "util/string2.h"
25
#include "util/thread-stack.h"
26
#include "util/time-utils.h"
27
#include "print_binary.h"
28
#include <linux/bitmap.h>
29
#include <linux/kernel.h>
30
#include <linux/stringify.h>
31
#include <linux/time64.h>
32
#include "asm/bug.h"
J
Jiri Olsa 已提交
33
#include "util/mem-events.h"
34
#include "util/dump-insn.h"
35
#include <dirent.h>
36
#include <errno.h>
37
#include <inttypes.h>
38
#include <signal.h>
39
#include <sys/param.h>
40 41 42
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
F
Frederic Weisbecker 已提交
43

44 45
#include "sane_ctype.h"

T
Tom Zanussi 已提交
46 47
static char const		*script_name;
static char const		*generate_script_lang;
48
static bool			debug_mode;
49
static u64			last_timestamp;
50
static u64			nr_unordered;
51
static bool			no_callchain;
52
static bool			latency_format;
53
static bool			system_wide;
54
static bool			print_flags;
55
static bool			nanosecs;
56 57
static const char		*cpu_list;
static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
58
static struct perf_stat_config	stat_config;
59
static int			max_blocks;
T
Tom Zanussi 已提交
60

61
unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;
62

63 64 65 66 67 68 69 70
enum perf_output_field {
	PERF_OUTPUT_COMM            = 1U << 0,
	PERF_OUTPUT_TID             = 1U << 1,
	PERF_OUTPUT_PID             = 1U << 2,
	PERF_OUTPUT_TIME            = 1U << 3,
	PERF_OUTPUT_CPU             = 1U << 4,
	PERF_OUTPUT_EVNAME          = 1U << 5,
	PERF_OUTPUT_TRACE           = 1U << 6,
71 72
	PERF_OUTPUT_IP              = 1U << 7,
	PERF_OUTPUT_SYM             = 1U << 8,
73
	PERF_OUTPUT_DSO             = 1U << 9,
74
	PERF_OUTPUT_ADDR            = 1U << 10,
75
	PERF_OUTPUT_SYMOFFSET       = 1U << 11,
76
	PERF_OUTPUT_SRCLINE         = 1U << 12,
J
Jiri Olsa 已提交
77
	PERF_OUTPUT_PERIOD          = 1U << 13,
78
	PERF_OUTPUT_IREGS	    = 1U << 14,
79 80
	PERF_OUTPUT_BRSTACK	    = 1U << 15,
	PERF_OUTPUT_BRSTACKSYM	    = 1U << 16,
81 82
	PERF_OUTPUT_DATA_SRC	    = 1U << 17,
	PERF_OUTPUT_WEIGHT	    = 1U << 18,
83
	PERF_OUTPUT_BPF_OUTPUT	    = 1U << 19,
84
	PERF_OUTPUT_CALLINDENT	    = 1U << 20,
A
Andi Kleen 已提交
85 86
	PERF_OUTPUT_INSN	    = 1U << 21,
	PERF_OUTPUT_INSNLEN	    = 1U << 22,
87
	PERF_OUTPUT_BRSTACKINSN	    = 1U << 23,
88
	PERF_OUTPUT_BRSTACKOFF	    = 1U << 24,
89
	PERF_OUTPUT_SYNTH           = 1U << 25,
90
	PERF_OUTPUT_PHYS_ADDR       = 1U << 26,
91 92 93 94 95 96 97 98 99 100 101 102 103
};

struct output_option {
	const char *str;
	enum perf_output_field field;
} all_output_options[] = {
	{.str = "comm",  .field = PERF_OUTPUT_COMM},
	{.str = "tid",   .field = PERF_OUTPUT_TID},
	{.str = "pid",   .field = PERF_OUTPUT_PID},
	{.str = "time",  .field = PERF_OUTPUT_TIME},
	{.str = "cpu",   .field = PERF_OUTPUT_CPU},
	{.str = "event", .field = PERF_OUTPUT_EVNAME},
	{.str = "trace", .field = PERF_OUTPUT_TRACE},
104
	{.str = "ip",    .field = PERF_OUTPUT_IP},
105
	{.str = "sym",   .field = PERF_OUTPUT_SYM},
106
	{.str = "dso",   .field = PERF_OUTPUT_DSO},
107
	{.str = "addr",  .field = PERF_OUTPUT_ADDR},
108
	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
109
	{.str = "srcline", .field = PERF_OUTPUT_SRCLINE},
J
Jiri Olsa 已提交
110
	{.str = "period", .field = PERF_OUTPUT_PERIOD},
111
	{.str = "iregs", .field = PERF_OUTPUT_IREGS},
112 113
	{.str = "brstack", .field = PERF_OUTPUT_BRSTACK},
	{.str = "brstacksym", .field = PERF_OUTPUT_BRSTACKSYM},
114 115
	{.str = "data_src", .field = PERF_OUTPUT_DATA_SRC},
	{.str = "weight",   .field = PERF_OUTPUT_WEIGHT},
116
	{.str = "bpf-output",   .field = PERF_OUTPUT_BPF_OUTPUT},
117
	{.str = "callindent", .field = PERF_OUTPUT_CALLINDENT},
A
Andi Kleen 已提交
118 119
	{.str = "insn", .field = PERF_OUTPUT_INSN},
	{.str = "insnlen", .field = PERF_OUTPUT_INSNLEN},
120
	{.str = "brstackinsn", .field = PERF_OUTPUT_BRSTACKINSN},
121
	{.str = "brstackoff", .field = PERF_OUTPUT_BRSTACKOFF},
122
	{.str = "synth", .field = PERF_OUTPUT_SYNTH},
123
	{.str = "phys_addr", .field = PERF_OUTPUT_PHYS_ADDR},
124 125
};

126 127 128 129 130
enum {
	OUTPUT_TYPE_SYNTH = PERF_TYPE_MAX,
	OUTPUT_TYPE_MAX
};

131
/* default set to maintain compatibility with current format */
132 133
static struct {
	bool user_set;
134
	bool wildcard_set;
135
	unsigned int print_ip_opts;
136 137
	u64 fields;
	u64 invalid_fields;
138
} output[OUTPUT_TYPE_MAX] = {
139 140 141 142 143 144

	[PERF_TYPE_HARDWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
145
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
146 147
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_PERIOD,
148

149
		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
150 151 152 153 154 155 156
	},

	[PERF_TYPE_SOFTWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
157
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
158
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
159
			      PERF_OUTPUT_PERIOD | PERF_OUTPUT_BPF_OUTPUT,
160 161 162 163 164 165 166 167 168

		.invalid_fields = PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_TRACEPOINT] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
169
				  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE
170
	},
171 172 173 174 175 176

	[PERF_TYPE_RAW] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
177
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
178
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
179
			      PERF_OUTPUT_PERIOD |  PERF_OUTPUT_ADDR |
180 181
			      PERF_OUTPUT_DATA_SRC | PERF_OUTPUT_WEIGHT |
			      PERF_OUTPUT_PHYS_ADDR,
182

183
		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
184
	},
185 186 187 188 189 190 191 192 193 194

	[PERF_TYPE_BREAKPOINT] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_PERIOD,

195
		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
196
	},
197 198 199 200 201 202 203

	[OUTPUT_TYPE_SYNTH] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
204 205
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_SYNTH,
206 207 208

		.invalid_fields = PERF_OUTPUT_TRACE | PERF_OUTPUT_BPF_OUTPUT,
	},
209
};
210

211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
static inline int output_type(unsigned int type)
{
	switch (type) {
	case PERF_TYPE_SYNTH:
		return OUTPUT_TYPE_SYNTH;
	default:
		return type;
	}
}

static inline unsigned int attr_type(unsigned int type)
{
	switch (type) {
	case OUTPUT_TYPE_SYNTH:
		return PERF_TYPE_SYNTH;
	default:
		return type;
	}
}

231 232 233
static bool output_set_by_user(void)
{
	int j;
234
	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
235 236 237 238 239
		if (output[j].user_set)
			return true;
	}
	return false;
}
240

241 242 243 244 245 246 247 248 249 250 251 252 253 254
static const char *output_field2str(enum perf_output_field field)
{
	int i, imax = ARRAY_SIZE(all_output_options);
	const char *str = "";

	for (i = 0; i < imax; ++i) {
		if (all_output_options[i].field == field) {
			str = all_output_options[i].str;
			break;
		}
	}
	return str;
}

255
#define PRINT_FIELD(x)  (output[output_type(attr->type)].fields & PERF_OUTPUT_##x)
256

257 258 259 260
static int perf_evsel__do_check_stype(struct perf_evsel *evsel,
				      u64 sample_type, const char *sample_msg,
				      enum perf_output_field field,
				      bool allow_user_set)
261
{
262
	struct perf_event_attr *attr = &evsel->attr;
263
	int type = output_type(attr->type);
264 265 266 267 268 269
	const char *evname;

	if (attr->sample_type & sample_type)
		return 0;

	if (output[type].user_set) {
270 271
		if (allow_user_set)
			return 0;
272
		evname = perf_evsel__name(evsel);
273 274 275 276 277 278 279 280
		pr_err("Samples for '%s' event do not have %s attribute set. "
		       "Cannot print '%s' field.\n",
		       evname, sample_msg, output_field2str(field));
		return -1;
	}

	/* user did not ask for it explicitly so remove from the default list */
	output[type].fields &= ~field;
281
	evname = perf_evsel__name(evsel);
282 283 284 285 286 287 288
	pr_debug("Samples for '%s' event do not have %s attribute set. "
		 "Skipping '%s' field.\n",
		 evname, sample_msg, output_field2str(field));

	return 0;
}

289 290 291 292 293 294 295 296
static int perf_evsel__check_stype(struct perf_evsel *evsel,
				   u64 sample_type, const char *sample_msg,
				   enum perf_output_field field)
{
	return perf_evsel__do_check_stype(evsel, sample_type, sample_msg, field,
					  false);
}

297 298 299 300
static int perf_evsel__check_attr(struct perf_evsel *evsel,
				  struct perf_session *session)
{
	struct perf_event_attr *attr = &evsel->attr;
301 302
	bool allow_user_set;

303 304 305
	if (perf_header__has_feat(&session->header, HEADER_STAT))
		return 0;

306 307
	allow_user_set = perf_header__has_feat(&session->header,
					       HEADER_AUXTRACE);
308

309 310 311 312
	if (PRINT_FIELD(TRACE) &&
		!perf_session__has_traces(session, "record -R"))
		return -EINVAL;

313
	if (PRINT_FIELD(IP)) {
314 315
		if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
					    PERF_OUTPUT_IP))
316 317
			return -EINVAL;
	}
318 319

	if (PRINT_FIELD(ADDR) &&
320 321
		perf_evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR",
					   PERF_OUTPUT_ADDR, allow_user_set))
322 323
		return -EINVAL;

324 325 326 327 328 329 330 331 332 333
	if (PRINT_FIELD(DATA_SRC) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_DATA_SRC, "DATA_SRC",
					PERF_OUTPUT_DATA_SRC))
		return -EINVAL;

	if (PRINT_FIELD(WEIGHT) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_WEIGHT, "WEIGHT",
					PERF_OUTPUT_WEIGHT))
		return -EINVAL;

334 335 336 337
	if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
		pr_err("Display of symbols requested but neither sample IP nor "
			   "sample address\nis selected. Hence, no addresses to convert "
		       "to symbols.\n");
338 339
		return -EINVAL;
	}
340 341 342 343 344
	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
		pr_err("Display of offsets requested but symbol is not"
		       "selected.\n");
		return -EINVAL;
	}
345
	if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR) &&
346 347 348
	    !PRINT_FIELD(BRSTACK) && !PRINT_FIELD(BRSTACKSYM) && !PRINT_FIELD(BRSTACKOFF)) {
		pr_err("Display of DSO requested but no address to convert.  Select\n"
		       "sample IP, sample address, brstack, brstacksym, or brstackoff.\n");
349 350
		return -EINVAL;
	}
351 352 353 354 355
	if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) {
		pr_err("Display of source line number requested but sample IP is not\n"
		       "selected. Hence, no address to lookup the source line number.\n");
		return -EINVAL;
	}
356 357 358 359 360 361 362
	if (PRINT_FIELD(BRSTACKINSN) &&
	    !(perf_evlist__combined_branch_type(session->evlist) &
	      PERF_SAMPLE_BRANCH_ANY)) {
		pr_err("Display of branch stack assembler requested, but non all-branch filter set\n"
		       "Hint: run 'perf record -b ...'\n");
		return -EINVAL;
	}
363
	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
364 365
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
					PERF_OUTPUT_TID|PERF_OUTPUT_PID))
366 367 368
		return -EINVAL;

	if (PRINT_FIELD(TIME) &&
369 370
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME",
					PERF_OUTPUT_TIME))
371 372 373
		return -EINVAL;

	if (PRINT_FIELD(CPU) &&
374 375
		perf_evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU",
					   PERF_OUTPUT_CPU, allow_user_set))
376
		return -EINVAL;
377

J
Jiri Olsa 已提交
378 379 380 381 382
	if (PRINT_FIELD(PERIOD) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_PERIOD, "PERIOD",
					PERF_OUTPUT_PERIOD))
		return -EINVAL;

383 384 385 386 387
	if (PRINT_FIELD(IREGS) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS",
					PERF_OUTPUT_IREGS))
		return -EINVAL;

388 389 390 391 392
	if (PRINT_FIELD(PHYS_ADDR) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_PHYS_ADDR, "PHYS_ADDR",
					PERF_OUTPUT_PHYS_ADDR))
		return -EINVAL;

393 394 395
	return 0;
}

396 397
static void set_print_ip_opts(struct perf_event_attr *attr)
{
398
	unsigned int type = output_type(attr->type);
399 400 401

	output[type].print_ip_opts = 0;
	if (PRINT_FIELD(IP))
402
		output[type].print_ip_opts |= EVSEL__PRINT_IP;
403 404

	if (PRINT_FIELD(SYM))
405
		output[type].print_ip_opts |= EVSEL__PRINT_SYM;
406 407

	if (PRINT_FIELD(DSO))
408
		output[type].print_ip_opts |= EVSEL__PRINT_DSO;
409 410

	if (PRINT_FIELD(SYMOFFSET))
411
		output[type].print_ip_opts |= EVSEL__PRINT_SYMOFFSET;
412 413

	if (PRINT_FIELD(SRCLINE))
414
		output[type].print_ip_opts |= EVSEL__PRINT_SRCLINE;
415 416
}

417 418 419 420 421 422
/*
 * verify all user requested events exist and the samples
 * have the expected data
 */
static int perf_session__check_output_opt(struct perf_session *session)
{
423
	unsigned int j;
424 425
	struct perf_evsel *evsel;

426 427
	for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
		evsel = perf_session__find_first_evtype(session, attr_type(j));
428 429 430 431 432

		/*
		 * even if fields is set to 0 (ie., show nothing) event must
		 * exist if user explicitly includes it on the command line
		 */
433 434
		if (!evsel && output[j].user_set && !output[j].wildcard_set &&
		    j != OUTPUT_TYPE_SYNTH) {
435
			pr_err("%s events do not exist. "
436
			       "Remove corresponding -F option to proceed.\n",
437 438 439 440 441 442 443
			       event_type(j));
			return -1;
		}

		if (evsel && output[j].fields &&
			perf_evsel__check_attr(evsel, session))
			return -1;
444 445 446 447

		if (evsel == NULL)
			continue;

448
		set_print_ip_opts(&evsel->attr);
449 450
	}

451 452
	if (!no_callchain) {
		bool use_callchain = false;
453
		bool not_pipe = false;
454

455
		evlist__for_each_entry(session->evlist, evsel) {
456
			not_pipe = true;
457 458 459 460 461
			if (evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
				use_callchain = true;
				break;
			}
		}
462
		if (not_pipe && !use_callchain)
463 464 465
			symbol_conf.use_callchain = false;
	}

466 467 468 469 470 471 472 473 474 475
	/*
	 * set default for tracepoints to print symbols only
	 * if callchains are present
	 */
	if (symbol_conf.use_callchain &&
	    !output[PERF_TYPE_TRACEPOINT].user_set) {
		struct perf_event_attr *attr;

		j = PERF_TYPE_TRACEPOINT;

476
		evlist__for_each_entry(session->evlist, evsel) {
477 478 479 480
			if (evsel->attr.type != j)
				continue;

			attr = &evsel->attr;
481

482 483 484 485 486 487 488
			if (attr->sample_type & PERF_SAMPLE_CALLCHAIN) {
				output[j].fields |= PERF_OUTPUT_IP;
				output[j].fields |= PERF_OUTPUT_SYM;
				output[j].fields |= PERF_OUTPUT_DSO;
				set_print_ip_opts(attr);
				goto out;
			}
489 490 491 492
		}
	}

out:
493 494
	return 0;
}
495

496
static void print_sample_iregs(struct perf_sample *sample,
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
			  struct perf_event_attr *attr)
{
	struct regs_dump *regs = &sample->intr_regs;
	uint64_t mask = attr->sample_regs_intr;
	unsigned i = 0, r;

	if (!regs)
		return;

	for_each_set_bit(r, (unsigned long *) &mask, sizeof(mask) * 8) {
		u64 val = regs->regs[i++];
		printf("%5s:0x%"PRIx64" ", perf_reg_name(r), val);
	}
}

512
static void print_sample_start(struct perf_sample *sample,
513
			       struct thread *thread,
514
			       struct perf_evsel *evsel)
515
{
516
	struct perf_event_attr *attr = &evsel->attr;
517
	unsigned long secs;
518 519 520 521
	unsigned long long nsecs;

	if (PRINT_FIELD(COMM)) {
		if (latency_format)
522
			printf("%8.8s ", thread__comm_str(thread));
523
		else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
524
			printf("%s ", thread__comm_str(thread));
525
		else
526
			printf("%16s ", thread__comm_str(thread));
527
	}
528

529 530 531 532 533 534 535 536 537 538 539 540 541
	if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
		printf("%5d/%-5d ", sample->pid, sample->tid);
	else if (PRINT_FIELD(PID))
		printf("%5d ", sample->pid);
	else if (PRINT_FIELD(TID))
		printf("%5d ", sample->tid);

	if (PRINT_FIELD(CPU)) {
		if (latency_format)
			printf("%3d ", sample->cpu);
		else
			printf("[%03d] ", sample->cpu);
	}
542

543 544
	if (PRINT_FIELD(TIME)) {
		nsecs = sample->time;
545 546
		secs = nsecs / NSEC_PER_SEC;
		nsecs -= secs * NSEC_PER_SEC;
547

548 549
		if (nanosecs)
			printf("%5lu.%09llu: ", secs, nsecs);
550 551 552 553 554
		else {
			char sample_time[32];
			timestamp__scnprintf_usec(sample->time, sample_time, sizeof(sample_time));
			printf("%12s: ", sample_time);
		}
555
	}
556 557
}

558 559 560 561 562 563 564 565 566
static inline char
mispred_str(struct branch_entry *br)
{
	if (!(br->flags.mispred  || br->flags.predicted))
		return '-';

	return br->flags.predicted ? 'P' : 'M';
}

567 568 569
static void print_sample_brstack(struct perf_sample *sample,
				 struct thread *thread,
				 struct perf_event_attr *attr)
570 571
{
	struct branch_stack *br = sample->branch_stack;
572 573
	struct addr_location alf, alt;
	u64 i, from, to;
574 575 576 577 578

	if (!(br && br->nr))
		return;

	for (i = 0; i < br->nr; i++) {
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
		from = br->entries[i].from;
		to   = br->entries[i].to;

		if (PRINT_FIELD(DSO)) {
			memset(&alf, 0, sizeof(alf));
			memset(&alt, 0, sizeof(alt));
			thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
			thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
		}

		printf("0x%"PRIx64, from);
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alf.map, stdout);
			printf(")");
		}

		printf("/0x%"PRIx64, to);
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alt.map, stdout);
			printf(")");
		}

		printf("/%c/%c/%c/%d ",
604 605 606 607 608 609 610
			mispred_str( br->entries + i),
			br->entries[i].flags.in_tx? 'X' : '-',
			br->entries[i].flags.abort? 'A' : '-',
			br->entries[i].flags.cycles);
	}
}

611
static void print_sample_brstacksym(struct perf_sample *sample,
612 613
				    struct thread *thread,
				    struct perf_event_attr *attr)
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
{
	struct branch_stack *br = sample->branch_stack;
	struct addr_location alf, alt;
	u64 i, from, to;

	if (!(br && br->nr))
		return;

	for (i = 0; i < br->nr; i++) {

		memset(&alf, 0, sizeof(alf));
		memset(&alt, 0, sizeof(alt));
		from = br->entries[i].from;
		to   = br->entries[i].to;

629
		thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
630
		if (alf.map)
631
			alf.sym = map__find_symbol(alf.map, alf.addr);
632

633
		thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
634
		if (alt.map)
635
			alt.sym = map__find_symbol(alt.map, alt.addr);
636 637

		symbol__fprintf_symname_offs(alf.sym, &alf, stdout);
638 639 640 641 642
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alf.map, stdout);
			printf(")");
		}
643 644
		putchar('/');
		symbol__fprintf_symname_offs(alt.sym, &alt, stdout);
645 646 647 648 649
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alt.map, stdout);
			printf(")");
		}
650 651 652 653 654 655 656 657
		printf("/%c/%c/%c/%d ",
			mispred_str( br->entries + i),
			br->entries[i].flags.in_tx? 'X' : '-',
			br->entries[i].flags.abort? 'A' : '-',
			br->entries[i].flags.cycles);
	}
}

658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
static void print_sample_brstackoff(struct perf_sample *sample,
				    struct thread *thread,
				    struct perf_event_attr *attr)
{
	struct branch_stack *br = sample->branch_stack;
	struct addr_location alf, alt;
	u64 i, from, to;

	if (!(br && br->nr))
		return;

	for (i = 0; i < br->nr; i++) {

		memset(&alf, 0, sizeof(alf));
		memset(&alt, 0, sizeof(alt));
		from = br->entries[i].from;
		to   = br->entries[i].to;

		thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, from, &alf);
		if (alf.map && !alf.map->dso->adjust_symbols)
			from = map__map_ip(alf.map, from);

		thread__find_addr_map(thread, sample->cpumode, MAP__FUNCTION, to, &alt);
		if (alt.map && !alt.map->dso->adjust_symbols)
			to = map__map_ip(alt.map, to);

		printf("0x%"PRIx64, from);
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alf.map, stdout);
			printf(")");
		}
		printf("/0x%"PRIx64, to);
		if (PRINT_FIELD(DSO)) {
			printf("(");
			map__fprintf_dsoname(alt.map, stdout);
			printf(")");
		}
		printf("/%c/%c/%c/%d ",
			mispred_str(br->entries + i),
			br->entries[i].flags.in_tx ? 'X' : '-',
			br->entries[i].flags.abort ? 'A' : '-',
			br->entries[i].flags.cycles);
	}
}
703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
#define MAXBB 16384UL

static int grab_bb(u8 *buffer, u64 start, u64 end,
		    struct machine *machine, struct thread *thread,
		    bool *is64bit, u8 *cpumode, bool last)
{
	long offset, len;
	struct addr_location al;
	bool kernel;

	if (!start || !end)
		return 0;

	kernel = machine__kernel_ip(machine, start);
	if (kernel)
		*cpumode = PERF_RECORD_MISC_KERNEL;
	else
		*cpumode = PERF_RECORD_MISC_USER;

	/*
	 * Block overlaps between kernel and user.
	 * This can happen due to ring filtering
	 * On Intel CPUs the entry into the kernel is filtered,
	 * but the exit is not. Let the caller patch it up.
	 */
	if (kernel != machine__kernel_ip(machine, end)) {
		printf("\tblock %" PRIx64 "-%" PRIx64 " transfers between kernel and user\n",
				start, end);
		return -ENXIO;
	}

	memset(&al, 0, sizeof(al));
	if (end - start > MAXBB - MAXINSN) {
		if (last)
			printf("\tbrstack does not reach to final jump (%" PRIx64 "-%" PRIx64 ")\n", start, end);
		else
			printf("\tblock %" PRIx64 "-%" PRIx64 " (%" PRIu64 ") too long to dump\n", start, end, end - start);
		return 0;
	}

	thread__find_addr_map(thread, *cpumode, MAP__FUNCTION, start, &al);
	if (!al.map || !al.map->dso) {
		printf("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
		return 0;
	}
	if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR) {
		printf("\tcannot resolve %" PRIx64 "-%" PRIx64 "\n", start, end);
		return 0;
	}

	/* Load maps to ensure dso->is_64_bit has been updated */
	map__load(al.map);

	offset = al.map->map_ip(al.map, start);
	len = dso__data_read_offset(al.map->dso, machine, offset, (u8 *)buffer,
				    end - start + MAXINSN);

	*is64bit = al.map->dso->is_64_bit;
	if (len <= 0)
		printf("\tcannot fetch code for block at %" PRIx64 "-%" PRIx64 "\n",
			start, end);
	return len;
}

static void print_jump(uint64_t ip, struct branch_entry *en,
		       struct perf_insn *x, u8 *inbuf, int len,
		       int insn)
{
	printf("\t%016" PRIx64 "\t%-30s\t#%s%s%s%s",
	       ip,
	       dump_insn(x, ip, inbuf, len, NULL),
	       en->flags.predicted ? " PRED" : "",
	       en->flags.mispred ? " MISPRED" : "",
	       en->flags.in_tx ? " INTX" : "",
	       en->flags.abort ? " ABORT" : "");
	if (en->flags.cycles) {
		printf(" %d cycles", en->flags.cycles);
		if (insn)
			printf(" %.2f IPC", (float)insn / en->flags.cycles);
	}
	putchar('\n');
}

static void print_ip_sym(struct thread *thread, u8 cpumode, int cpu,
			 uint64_t addr, struct symbol **lastsym,
			 struct perf_event_attr *attr)
{
	struct addr_location al;
	int off;

	memset(&al, 0, sizeof(al));

	thread__find_addr_map(thread, cpumode, MAP__FUNCTION, addr, &al);
	if (!al.map)
		thread__find_addr_map(thread, cpumode, MAP__VARIABLE,
				      addr, &al);
	if ((*lastsym) && al.addr >= (*lastsym)->start && al.addr < (*lastsym)->end)
		return;

	al.cpu = cpu;
	al.sym = NULL;
	if (al.map)
		al.sym = map__find_symbol(al.map, al.addr);

	if (!al.sym)
		return;

	if (al.addr < al.sym->end)
		off = al.addr - al.sym->start;
	else
		off = al.addr - al.map->start - al.sym->start;
	printf("\t%s", al.sym->name);
	if (off)
		printf("%+d", off);
	putchar(':');
	if (PRINT_FIELD(SRCLINE))
		map__fprintf_srcline(al.map, al.addr, "\t", stdout);
	putchar('\n');
	*lastsym = al.sym;
}

static void print_sample_brstackinsn(struct perf_sample *sample,
				     struct thread *thread,
				     struct perf_event_attr *attr,
				     struct machine *machine)
{
	struct branch_stack *br = sample->branch_stack;
	u64 start, end;
	int i, insn, len, nr, ilen;
	struct perf_insn x;
	u8 buffer[MAXBB];
	unsigned off;
	struct symbol *lastsym = NULL;

	if (!(br && br->nr))
		return;
	nr = br->nr;
	if (max_blocks && nr > max_blocks + 1)
		nr = max_blocks + 1;

	x.thread = thread;
	x.cpu = sample->cpu;

	putchar('\n');

	/* Handle first from jump, of which we don't know the entry. */
	len = grab_bb(buffer, br->entries[nr-1].from,
			br->entries[nr-1].from,
			machine, thread, &x.is64bit, &x.cpumode, false);
	if (len > 0) {
		print_ip_sym(thread, x.cpumode, x.cpu,
			     br->entries[nr - 1].from, &lastsym, attr);
		print_jump(br->entries[nr - 1].from, &br->entries[nr - 1],
			    &x, buffer, len, 0);
	}

	/* Print all blocks */
	for (i = nr - 2; i >= 0; i--) {
		if (br->entries[i].from || br->entries[i].to)
			pr_debug("%d: %" PRIx64 "-%" PRIx64 "\n", i,
				 br->entries[i].from,
				 br->entries[i].to);
		start = br->entries[i + 1].to;
		end   = br->entries[i].from;

		len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
		/* Patch up missing kernel transfers due to ring filters */
		if (len == -ENXIO && i > 0) {
			end = br->entries[--i].from;
			pr_debug("\tpatching up to %" PRIx64 "-%" PRIx64 "\n", start, end);
			len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, false);
		}
		if (len <= 0)
			continue;

		insn = 0;
		for (off = 0;; off += ilen) {
			uint64_t ip = start + off;

			print_ip_sym(thread, x.cpumode, x.cpu, ip, &lastsym, attr);
			if (ip == end) {
				print_jump(ip, &br->entries[i], &x, buffer + off, len - off, insn);
				break;
			} else {
				printf("\t%016" PRIx64 "\t%s\n", ip,
					dump_insn(&x, ip, buffer + off, len - off, &ilen));
				if (ilen == 0)
					break;
				insn++;
			}
		}
	}

	/*
	 * Hit the branch? In this case we are already done, and the target
	 * has not been executed yet.
	 */
	if (br->entries[0].from == sample->ip)
		return;
	if (br->entries[0].flags.abort)
		return;

	/*
	 * Print final block upto sample
	 */
	start = br->entries[0].to;
	end = sample->ip;
	len = grab_bb(buffer, start, end, machine, thread, &x.is64bit, &x.cpumode, true);
	print_ip_sym(thread, x.cpumode, x.cpu, start, &lastsym, attr);
	if (len <= 0) {
		/* Print at least last IP if basic block did not work */
		len = grab_bb(buffer, sample->ip, sample->ip,
			      machine, thread, &x.is64bit, &x.cpumode, false);
		if (len <= 0)
			return;

		printf("\t%016" PRIx64 "\t%s\n", sample->ip,
			dump_insn(&x, sample->ip, buffer, len, NULL));
		return;
	}
	for (off = 0; off <= end - start; off += ilen) {
		printf("\t%016" PRIx64 "\t%s\n", start + off,
			dump_insn(&x, start + off, buffer + off, len - off, &ilen));
		if (ilen == 0)
			break;
	}
}
930

931
static void print_sample_addr(struct perf_sample *sample,
932 933 934 935 936 937 938 939 940 941
			  struct thread *thread,
			  struct perf_event_attr *attr)
{
	struct addr_location al;

	printf("%16" PRIx64, sample->addr);

	if (!sample_addr_correlates_sym(attr))
		return;

942
	thread__resolve(thread, &al, sample);
943 944

	if (PRINT_FIELD(SYM)) {
945
		printf(" ");
946 947 948 949
		if (PRINT_FIELD(SYMOFFSET))
			symbol__fprintf_symname_offs(al.sym, &al, stdout);
		else
			symbol__fprintf_symname(al.sym, stdout);
950 951 952
	}

	if (PRINT_FIELD(DSO)) {
953 954 955
		printf(" (");
		map__fprintf_dsoname(al.map, stdout);
		printf(")");
956 957 958
	}
}

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
static void print_sample_callindent(struct perf_sample *sample,
				    struct perf_evsel *evsel,
				    struct thread *thread,
				    struct addr_location *al)
{
	struct perf_event_attr *attr = &evsel->attr;
	size_t depth = thread_stack__depth(thread);
	struct addr_location addr_al;
	const char *name = NULL;
	static int spacing;
	int len = 0;
	u64 ip = 0;

	/*
	 * The 'return' has already been popped off the stack so the depth has
	 * to be adjusted to match the 'call'.
	 */
	if (thread->ts && sample->flags & PERF_IP_FLAG_RETURN)
		depth += 1;

	if (sample->flags & (PERF_IP_FLAG_CALL | PERF_IP_FLAG_TRACE_BEGIN)) {
		if (sample_addr_correlates_sym(attr)) {
			thread__resolve(thread, &addr_al, sample);
			if (addr_al.sym)
				name = addr_al.sym->name;
			else
				ip = sample->addr;
		} else {
			ip = sample->addr;
		}
	} else if (sample->flags & (PERF_IP_FLAG_RETURN | PERF_IP_FLAG_TRACE_END)) {
		if (al->sym)
			name = al->sym->name;
		else
			ip = sample->ip;
	}

	if (name)
		len = printf("%*s%s", (int)depth * 4, "", name);
	else if (ip)
		len = printf("%*s%16" PRIx64, (int)depth * 4, "", ip);

	if (len < 0)
		return;

	/*
	 * Try to keep the output length from changing frequently so that the
	 * output lines up more nicely.
	 */
	if (len > spacing || (len && len < spacing - 52))
		spacing = round_up(len + 4, 32);

	if (len < spacing)
		printf("%*s", spacing - len, "");
}

A
Andi Kleen 已提交
1015
static void print_insn(struct perf_sample *sample,
1016 1017 1018
		       struct perf_event_attr *attr,
		       struct thread *thread,
		       struct machine *machine)
A
Andi Kleen 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
{
	if (PRINT_FIELD(INSNLEN))
		printf(" ilen: %d", sample->insn_len);
	if (PRINT_FIELD(INSN)) {
		int i;

		printf(" insn:");
		for (i = 0; i < sample->insn_len; i++)
			printf(" %02x", (unsigned char)sample->insn[i]);
	}
1029 1030
	if (PRINT_FIELD(BRSTACKINSN))
		print_sample_brstackinsn(sample, thread, attr, machine);
A
Andi Kleen 已提交
1031 1032
}

1033
static void print_sample_bts(struct perf_sample *sample,
1034
			     struct perf_evsel *evsel,
1035
			     struct thread *thread,
1036 1037
			     struct addr_location *al,
			     struct machine *machine)
1038 1039
{
	struct perf_event_attr *attr = &evsel->attr;
1040
	unsigned int type = output_type(attr->type);
1041
	bool print_srcline_last = false;
1042

1043 1044 1045
	if (PRINT_FIELD(CALLINDENT))
		print_sample_callindent(sample, evsel, thread, al);

1046 1047
	/* print branch_from information */
	if (PRINT_FIELD(IP)) {
1048
		unsigned int print_opts = output[type].print_ip_opts;
1049
		struct callchain_cursor *cursor = NULL;
1050

1051
		if (symbol_conf.use_callchain && sample->callchain &&
1052
		    thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
1053
					      sample, NULL, NULL, scripting_max_stack) == 0)
1054
			cursor = &callchain_cursor;
1055 1056 1057

		if (cursor == NULL) {
			putchar(' ');
1058
			if (print_opts & EVSEL__PRINT_SRCLINE) {
1059
				print_srcline_last = true;
1060
				print_opts &= ~EVSEL__PRINT_SRCLINE;
1061
			}
1062 1063 1064 1065
		} else
			putchar('\n');

		sample__fprintf_sym(sample, al, 0, print_opts, cursor, stdout);
1066 1067 1068
	}

	/* print branch_to information */
1069 1070
	if (PRINT_FIELD(ADDR) ||
	    ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
1071
	     !output[type].user_set)) {
1072
		printf(" => ");
1073
		print_sample_addr(sample, thread, attr);
1074
	}
1075

1076 1077 1078
	if (print_srcline_last)
		map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);

1079
	print_insn(sample, attr, thread, machine);
A
Andi Kleen 已提交
1080

1081 1082 1083
	printf("\n");
}

1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
static struct {
	u32 flags;
	const char *name;
} sample_flags[] = {
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL, "call"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN, "return"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL, "jcc"},
	{PERF_IP_FLAG_BRANCH, "jmp"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_INTERRUPT, "int"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_INTERRUPT, "iret"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_SYSCALLRET, "syscall"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | PERF_IP_FLAG_SYSCALLRET, "sysret"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_ASYNC, "async"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | PERF_IP_FLAG_ASYNC |	PERF_IP_FLAG_INTERRUPT, "hw int"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TX_ABORT, "tx abrt"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_BEGIN, "tr strt"},
	{PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_TRACE_END, "tr end"},
	{0, NULL}
};

1104 1105 1106 1107
static void print_sample_flags(u32 flags)
{
	const char *chars = PERF_IP_FLAG_CHARS;
	const int n = strlen(PERF_IP_FLAG_CHARS);
1108 1109
	bool in_tx = flags & PERF_IP_FLAG_IN_TX;
	const char *name = NULL;
1110 1111 1112
	char str[33];
	int i, pos = 0;

1113 1114 1115 1116 1117 1118 1119
	for (i = 0; sample_flags[i].name ; i++) {
		if (sample_flags[i].flags == (flags & ~PERF_IP_FLAG_IN_TX)) {
			name = sample_flags[i].name;
			break;
		}
	}

1120 1121 1122 1123 1124 1125 1126 1127 1128
	for (i = 0; i < n; i++, flags >>= 1) {
		if (flags & 1)
			str[pos++] = chars[i];
	}
	for (; i < 32; i++, flags >>= 1) {
		if (flags & 1)
			str[pos++] = '?';
	}
	str[pos] = 0;
1129 1130 1131 1132 1133

	if (name)
		printf("  %-7s%4s ", name, in_tx ? "(x)" : "");
	else
		printf("  %-11s ", str);
1134 1135
}

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
struct printer_data {
	int line_no;
	bool hit_nul;
	bool is_printable;
};

static void
print_sample_bpf_output_printer(enum binary_printer_ops op,
				unsigned int val,
				void *extra)
{
	unsigned char ch = (unsigned char)val;
	struct printer_data *printer_data = extra;

	switch (op) {
	case BINARY_PRINT_DATA_BEGIN:
		printf("\n");
		break;
	case BINARY_PRINT_LINE_BEGIN:
		printf("%17s", !printer_data->line_no ? "BPF output:" :
						        "           ");
		break;
	case BINARY_PRINT_ADDR:
		printf(" %04x:", val);
		break;
	case BINARY_PRINT_NUM_DATA:
		printf(" %02x", val);
		break;
	case BINARY_PRINT_NUM_PAD:
		printf("   ");
		break;
	case BINARY_PRINT_SEP:
		printf("  ");
		break;
	case BINARY_PRINT_CHAR_DATA:
		if (printer_data->hit_nul && ch)
			printer_data->is_printable = false;

		if (!isprint(ch)) {
			printf("%c", '.');

			if (!printer_data->is_printable)
				break;

			if (ch == '\0')
				printer_data->hit_nul = true;
			else
				printer_data->is_printable = false;
		} else {
			printf("%c", ch);
		}
		break;
	case BINARY_PRINT_CHAR_PAD:
		printf(" ");
		break;
	case BINARY_PRINT_LINE_END:
		printf("\n");
		printer_data->line_no++;
		break;
	case BINARY_PRINT_DATA_END:
	default:
		break;
	}
}

static void print_sample_bpf_output(struct perf_sample *sample)
{
	unsigned int nr_bytes = sample->raw_size;
	struct printer_data printer_data = {0, false, true};

	print_binary(sample->raw_data, nr_bytes, 8,
		     print_sample_bpf_output_printer, &printer_data);

	if (printer_data.is_printable && printer_data.hit_nul)
		printf("%17s \"%s\"\n", "BPF string:",
		       (char *)(sample->raw_data));
}

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
static void print_sample_spacing(int len, int spacing)
{
	if (len > 0 && len < spacing)
		printf("%*s", spacing - len, "");
}

static void print_sample_pt_spacing(int len)
{
	print_sample_spacing(len, 34);
}

static void print_sample_synth_ptwrite(struct perf_sample *sample)
{
	struct perf_synth_intel_ptwrite *data = perf_sample__synth_ptr(sample);
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	len = printf(" IP: %u payload: %#" PRIx64 " ",
		     data->ip, le64_to_cpu(data->payload));
	print_sample_pt_spacing(len);
}

static void print_sample_synth_mwait(struct perf_sample *sample)
{
	struct perf_synth_intel_mwait *data = perf_sample__synth_ptr(sample);
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	len = printf(" hints: %#x extensions: %#x ",
		     data->hints, data->extensions);
	print_sample_pt_spacing(len);
}

static void print_sample_synth_pwre(struct perf_sample *sample)
{
	struct perf_synth_intel_pwre *data = perf_sample__synth_ptr(sample);
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	len = printf(" hw: %u cstate: %u sub-cstate: %u ",
		     data->hw, data->cstate, data->subcstate);
	print_sample_pt_spacing(len);
}

static void print_sample_synth_exstop(struct perf_sample *sample)
{
	struct perf_synth_intel_exstop *data = perf_sample__synth_ptr(sample);
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	len = printf(" IP: %u ", data->ip);
	print_sample_pt_spacing(len);
}

static void print_sample_synth_pwrx(struct perf_sample *sample)
{
	struct perf_synth_intel_pwrx *data = perf_sample__synth_ptr(sample);
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	len = printf(" deepest cstate: %u last cstate: %u wake reason: %#x ",
		     data->deepest_cstate, data->last_cstate,
		     data->wake_reason);
	print_sample_pt_spacing(len);
}

static void print_sample_synth_cbr(struct perf_sample *sample)
{
	struct perf_synth_intel_cbr *data = perf_sample__synth_ptr(sample);
	unsigned int percent, freq;
	int len;

	if (perf_sample__bad_synth_size(sample, *data))
		return;

	freq = (le32_to_cpu(data->freq) + 500) / 1000;
	len = printf(" cbr: %2u freq: %4u MHz ", data->cbr, freq);
	if (data->max_nonturbo) {
		percent = (5 + (1000 * data->cbr) / data->max_nonturbo) / 10;
		len += printf("(%3u%%) ", percent);
	}
	print_sample_pt_spacing(len);
}

static void print_sample_synth(struct perf_sample *sample,
1309 1310 1311
			       struct perf_evsel *evsel)
{
	switch (evsel->attr.config) {
1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
	case PERF_SYNTH_INTEL_PTWRITE:
		print_sample_synth_ptwrite(sample);
		break;
	case PERF_SYNTH_INTEL_MWAIT:
		print_sample_synth_mwait(sample);
		break;
	case PERF_SYNTH_INTEL_PWRE:
		print_sample_synth_pwre(sample);
		break;
	case PERF_SYNTH_INTEL_EXSTOP:
		print_sample_synth_exstop(sample);
		break;
	case PERF_SYNTH_INTEL_PWRX:
		print_sample_synth_pwrx(sample);
		break;
	case PERF_SYNTH_INTEL_CBR:
		print_sample_synth_cbr(sample);
		break;
1330 1331 1332 1333 1334
	default:
		break;
	}
}

1335 1336 1337 1338 1339 1340
struct perf_script {
	struct perf_tool	tool;
	struct perf_session	*session;
	bool			show_task_events;
	bool			show_mmap_events;
	bool			show_switch_events;
1341
	bool			show_namespace_events;
1342 1343 1344
	bool			allocated;
	struct cpu_map		*cpus;
	struct thread_map	*threads;
1345
	int			name_width;
1346 1347
	const char              *time_str;
	struct perf_time_interval ptime;
1348 1349
};

1350 1351 1352 1353 1354
static int perf_evlist__max_name_len(struct perf_evlist *evlist)
{
	struct perf_evsel *evsel;
	int max = 0;

1355
	evlist__for_each_entry(evlist, evsel) {
1356 1357 1358 1359 1360 1361 1362 1363
		int len = strlen(perf_evsel__name(evsel));

		max = MAX(len, max);
	}

	return max;
}

J
Jiri Olsa 已提交
1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
static size_t data_src__printf(u64 data_src)
{
	struct mem_info mi = { .data_src.val = data_src };
	char decode[100];
	char out[100];
	static int maxlen;
	int len;

	perf_script__meminfo_scnprintf(decode, 100, &mi);

	len = scnprintf(out, 100, "%16" PRIx64 " %s", data_src, decode);
	if (maxlen < len)
		maxlen = len;

	return printf("%-*s", maxlen, out);
}

1381
static void process_event(struct perf_script *script,
1382
			  struct perf_sample *sample, struct perf_evsel *evsel,
1383 1384
			  struct addr_location *al,
			  struct machine *machine)
1385
{
1386
	struct thread *thread = al->thread;
1387
	struct perf_event_attr *attr = &evsel->attr;
1388
	unsigned int type = output_type(attr->type);
1389

1390
	if (output[type].fields == 0)
1391 1392
		return;

1393
	print_sample_start(sample, thread, evsel);
1394

J
Jiri Olsa 已提交
1395 1396 1397
	if (PRINT_FIELD(PERIOD))
		printf("%10" PRIu64 " ", sample->period);

1398 1399
	if (PRINT_FIELD(EVNAME)) {
		const char *evname = perf_evsel__name(evsel);
1400 1401 1402 1403 1404 1405

		if (!script->name_width)
			script->name_width = perf_evlist__max_name_len(script->session->evlist);

		printf("%*s: ", script->name_width,
		       evname ? evname : "[unknown]");
1406 1407
	}

1408 1409 1410
	if (print_flags)
		print_sample_flags(sample->flags);

1411
	if (is_bts_event(attr)) {
1412
		print_sample_bts(sample, evsel, thread, al, machine);
1413 1414 1415
		return;
	}

1416
	if (PRINT_FIELD(TRACE))
1417 1418
		event_format__print(evsel->tp_format, sample->cpu,
				    sample->raw_data, sample->raw_size);
1419 1420 1421 1422

	if (attr->type == PERF_TYPE_SYNTH && PRINT_FIELD(SYNTH))
		print_sample_synth(sample, evsel);

1423
	if (PRINT_FIELD(ADDR))
1424
		print_sample_addr(sample, thread, attr);
1425

1426
	if (PRINT_FIELD(DATA_SRC))
J
Jiri Olsa 已提交
1427
		data_src__printf(sample->data_src);
1428 1429 1430 1431

	if (PRINT_FIELD(WEIGHT))
		printf("%16" PRIu64, sample->weight);

1432
	if (PRINT_FIELD(IP)) {
1433
		struct callchain_cursor *cursor = NULL;
1434

1435
		if (symbol_conf.use_callchain && sample->callchain &&
1436
		    thread__resolve_callchain(al->thread, &callchain_cursor, evsel,
1437
					      sample, NULL, NULL, scripting_max_stack) == 0)
1438
			cursor = &callchain_cursor;
1439

1440
		putchar(cursor ? '\n' : ' ');
1441
		sample__fprintf_sym(sample, al, 0, output[type].print_ip_opts, cursor, stdout);
1442 1443
	}

1444
	if (PRINT_FIELD(IREGS))
1445
		print_sample_iregs(sample, attr);
1446

1447
	if (PRINT_FIELD(BRSTACK))
1448
		print_sample_brstack(sample, thread, attr);
1449
	else if (PRINT_FIELD(BRSTACKSYM))
1450
		print_sample_brstacksym(sample, thread, attr);
1451 1452
	else if (PRINT_FIELD(BRSTACKOFF))
		print_sample_brstackoff(sample, thread, attr);
1453

1454 1455
	if (perf_evsel__is_bpf_output(evsel) && PRINT_FIELD(BPF_OUTPUT))
		print_sample_bpf_output(sample);
1456
	print_insn(sample, attr, thread, machine);
1457 1458 1459

	if (PRINT_FIELD(PHYS_ADDR))
		printf("%16" PRIx64, sample->phys_addr);
1460
	printf("\n");
1461 1462
}

T
Tom Zanussi 已提交
1463 1464
static struct scripting_ops	*scripting_ops;

1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
static void __process_stat(struct perf_evsel *counter, u64 tstamp)
{
	int nthreads = thread_map__nr(counter->threads);
	int ncpus = perf_evsel__nr_cpus(counter);
	int cpu, thread;
	static int header_printed;

	if (counter->system_wide)
		nthreads = 1;

	if (!header_printed) {
		printf("%3s %8s %15s %15s %15s %15s %s\n",
		       "CPU", "THREAD", "VAL", "ENA", "RUN", "TIME", "EVENT");
		header_printed = 1;
	}

	for (thread = 0; thread < nthreads; thread++) {
		for (cpu = 0; cpu < ncpus; cpu++) {
			struct perf_counts_values *counts;

			counts = perf_counts(counter->counts, cpu, thread);

			printf("%3d %8d %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %15" PRIu64 " %s\n",
				counter->cpus->map[cpu],
				thread_map__pid(counter->threads, thread),
				counts->val,
				counts->ena,
				counts->run,
				tstamp,
				perf_evsel__name(counter));
		}
	}
}

1499 1500 1501 1502
static void process_stat(struct perf_evsel *counter, u64 tstamp)
{
	if (scripting_ops && scripting_ops->process_stat)
		scripting_ops->process_stat(&stat_config, counter, tstamp);
1503 1504
	else
		__process_stat(counter, tstamp);
1505 1506 1507 1508 1509 1510 1511 1512
}

static void process_stat_interval(u64 tstamp)
{
	if (scripting_ops && scripting_ops->process_stat_interval)
		scripting_ops->process_stat_interval(tstamp);
}

T
Tom Zanussi 已提交
1513 1514
static void setup_scripting(void)
{
1515
	setup_perl_scripting();
1516
	setup_python_scripting();
T
Tom Zanussi 已提交
1517 1518
}

1519 1520
static int flush_scripting(void)
{
1521
	return scripting_ops ? scripting_ops->flush_script() : 0;
1522 1523
}

T
Tom Zanussi 已提交
1524 1525
static int cleanup_scripting(void)
{
1526
	pr_debug("\nperf script stopped\n");
1527

1528
	return scripting_ops ? scripting_ops->stop_script() : 0;
T
Tom Zanussi 已提交
1529 1530
}

1531
static int process_sample_event(struct perf_tool *tool,
1532
				union perf_event *event,
1533
				struct perf_sample *sample,
1534
				struct perf_evsel *evsel,
1535
				struct machine *machine)
F
Frederic Weisbecker 已提交
1536
{
1537
	struct perf_script *scr = container_of(tool, struct perf_script, tool);
1538
	struct addr_location al;
F
Frederic Weisbecker 已提交
1539

1540 1541 1542
	if (perf_time__skip_sample(&scr->ptime, sample->time))
		return 0;

1543 1544 1545 1546 1547 1548
	if (debug_mode) {
		if (sample->time < last_timestamp) {
			pr_err("Samples misordered, previous: %" PRIu64
				" this: %" PRIu64 "\n", last_timestamp,
				sample->time);
			nr_unordered++;
1549
		}
1550 1551
		last_timestamp = sample->time;
		return 0;
F
Frederic Weisbecker 已提交
1552
	}
1553

1554
	if (machine__resolve(machine, &al, sample) < 0) {
1555 1556 1557 1558 1559 1560
		pr_err("problem processing %d event, skipping it.\n",
		       event->header.type);
		return -1;
	}

	if (al.filtered)
1561
		goto out_put;
1562

1563
	if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
1564
		goto out_put;
1565

1566 1567 1568
	if (scripting_ops)
		scripting_ops->process_event(event, sample, evsel, &al);
	else
1569
		process_event(scr, sample, evsel, &al, machine);
1570

1571 1572
out_put:
	addr_location__put(&al);
F
Frederic Weisbecker 已提交
1573 1574 1575
	return 0;
}

1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590
static int process_attr(struct perf_tool *tool, union perf_event *event,
			struct perf_evlist **pevlist)
{
	struct perf_script *scr = container_of(tool, struct perf_script, tool);
	struct perf_evlist *evlist;
	struct perf_evsel *evsel, *pos;
	int err;

	err = perf_event__process_attr(tool, event, pevlist);
	if (err)
		return err;

	evlist = *pevlist;
	evsel = perf_evlist__last(*pevlist);

1591 1592
	if (evsel->attr.type >= PERF_TYPE_MAX &&
	    evsel->attr.type != PERF_TYPE_SYNTH)
1593 1594
		return 0;

1595
	evlist__for_each_entry(evlist, pos) {
1596 1597 1598 1599 1600 1601
		if (pos->attr.type == evsel->attr.type && pos != evsel)
			return 0;
	}

	set_print_ip_opts(&evsel->attr);

1602 1603 1604 1605
	if (evsel->attr.sample_type)
		err = perf_evsel__check_attr(evsel, scr->session);

	return err;
1606 1607
}

1608 1609 1610 1611 1612 1613 1614 1615
static int process_comm_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
1616
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
	int ret = -1;

	thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid);
	if (thread == NULL) {
		pr_debug("problem processing COMM event, skipping it.\n");
		return -1;
	}

	if (perf_event__process_comm(tool, event, sample, machine) < 0)
		goto out;

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = 0;
		sample->tid = event->comm.tid;
		sample->pid = event->comm.pid;
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
	ret = 0;
out:
1638
	thread__put(thread);
1639 1640 1641
	return ret;
}

1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
static int process_namespaces_event(struct perf_tool *tool,
				    union perf_event *event,
				    struct perf_sample *sample,
				    struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
	int ret = -1;

	thread = machine__findnew_thread(machine, event->namespaces.pid,
					 event->namespaces.tid);
	if (thread == NULL) {
		pr_debug("problem processing NAMESPACES event, skipping it.\n");
		return -1;
	}

	if (perf_event__process_namespaces(tool, event, sample, machine) < 0)
		goto out;

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = 0;
		sample->tid = event->namespaces.tid;
		sample->pid = event->namespaces.pid;
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
	ret = 0;
out:
	thread__put(thread);
	return ret;
}

1677 1678 1679 1680 1681 1682 1683 1684
static int process_fork_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
1685
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703

	if (perf_event__process_fork(tool, event, sample, machine) < 0)
		return -1;

	thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
	if (thread == NULL) {
		pr_debug("problem processing FORK event, skipping it.\n");
		return -1;
	}

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = event->fork.time;
		sample->tid = event->fork.tid;
		sample->pid = event->fork.pid;
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
1704
	thread__put(thread);
1705 1706 1707 1708 1709 1710 1711 1712

	return 0;
}
static int process_exit_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
1713
	int err = 0;
1714 1715 1716
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
1717
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727

	thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
	if (thread == NULL) {
		pr_debug("problem processing EXIT event, skipping it.\n");
		return -1;
	}

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = 0;
1728 1729
		sample->tid = event->fork.tid;
		sample->pid = event->fork.pid;
1730 1731 1732 1733 1734
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);

	if (perf_event__process_exit(tool, event, sample, machine) < 0)
1735
		err = -1;
1736

1737 1738
	thread__put(thread);
	return err;
1739 1740
}

1741 1742 1743 1744 1745 1746 1747 1748
static int process_mmap_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
1749
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767

	if (perf_event__process_mmap(tool, event, sample, machine) < 0)
		return -1;

	thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid);
	if (thread == NULL) {
		pr_debug("problem processing MMAP event, skipping it.\n");
		return -1;
	}

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = 0;
		sample->tid = event->mmap.tid;
		sample->pid = event->mmap.pid;
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
1768
	thread__put(thread);
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
	return 0;
}

static int process_mmap2_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
1780
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798

	if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
		return -1;

	thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid);
	if (thread == NULL) {
		pr_debug("problem processing MMAP2 event, skipping it.\n");
		return -1;
	}

	if (!evsel->attr.sample_id_all) {
		sample->cpu = 0;
		sample->time = 0;
		sample->tid = event->mmap2.tid;
		sample->pid = event->mmap2.pid;
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
1799
	thread__put(thread);
1800 1801 1802
	return 0;
}

1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828
static int process_switch_event(struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct machine *machine)
{
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);

	if (perf_event__process_switch(tool, event, sample, machine) < 0)
		return -1;

	thread = machine__findnew_thread(machine, sample->pid,
					 sample->tid);
	if (thread == NULL) {
		pr_debug("problem processing SWITCH event, skipping it.\n");
		return -1;
	}

	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);
	thread__put(thread);
	return 0;
}

1829
static void sig_handler(int sig __maybe_unused)
1830 1831 1832 1833
{
	session_done = 1;
}

1834
static int __cmd_script(struct perf_script *script)
F
Frederic Weisbecker 已提交
1835
{
1836 1837
	int ret;

1838 1839
	signal(SIGINT, sig_handler);

1840 1841 1842 1843 1844 1845
	/* override event processing functions */
	if (script->show_task_events) {
		script->tool.comm = process_comm_event;
		script->tool.fork = process_fork_event;
		script->tool.exit = process_exit_event;
	}
1846 1847 1848 1849
	if (script->show_mmap_events) {
		script->tool.mmap = process_mmap_event;
		script->tool.mmap2 = process_mmap2_event;
	}
1850 1851
	if (script->show_switch_events)
		script->tool.context_switch = process_switch_event;
1852 1853
	if (script->show_namespace_events)
		script->tool.namespaces = process_namespaces_event;
1854

1855
	ret = perf_session__process_events(script->session);
1856

1857
	if (debug_mode)
1858
		pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
1859 1860

	return ret;
F
Frederic Weisbecker 已提交
1861 1862
}

T
Tom Zanussi 已提交
1863 1864 1865 1866 1867 1868
struct script_spec {
	struct list_head	node;
	struct scripting_ops	*ops;
	char			spec[0];
};

1869
static LIST_HEAD(script_specs);
T
Tom Zanussi 已提交
1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906

static struct script_spec *script_spec__new(const char *spec,
					    struct scripting_ops *ops)
{
	struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);

	if (s != NULL) {
		strcpy(s->spec, spec);
		s->ops = ops;
	}

	return s;
}

static void script_spec__add(struct script_spec *s)
{
	list_add_tail(&s->node, &script_specs);
}

static struct script_spec *script_spec__find(const char *spec)
{
	struct script_spec *s;

	list_for_each_entry(s, &script_specs, node)
		if (strcasecmp(s->spec, spec) == 0)
			return s;
	return NULL;
}

int script_spec_register(const char *spec, struct scripting_ops *ops)
{
	struct script_spec *s;

	s = script_spec__find(spec);
	if (s)
		return -1;

1907
	s = script_spec__new(spec, ops);
T
Tom Zanussi 已提交
1908 1909
	if (!s)
		return -1;
1910 1911
	else
		script_spec__add(s);
T
Tom Zanussi 已提交
1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930

	return 0;
}

static struct scripting_ops *script_spec__lookup(const char *spec)
{
	struct script_spec *s = script_spec__find(spec);
	if (!s)
		return NULL;

	return s->ops;
}

static void list_available_languages(void)
{
	struct script_spec *s;

	fprintf(stderr, "\n");
	fprintf(stderr, "Scripting language extensions (used in "
1931
		"perf script -s [spec:]script.[spec]):\n\n");
T
Tom Zanussi 已提交
1932 1933 1934 1935 1936 1937 1938

	list_for_each_entry(s, &script_specs, node)
		fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);

	fprintf(stderr, "\n");
}

1939 1940
static int parse_scriptname(const struct option *opt __maybe_unused,
			    const char *str, int unset __maybe_unused)
T
Tom Zanussi 已提交
1941 1942 1943 1944 1945
{
	char spec[PATH_MAX];
	const char *script, *ext;
	int len;

1946
	if (strcmp(str, "lang") == 0) {
T
Tom Zanussi 已提交
1947
		list_available_languages();
1948
		exit(0);
T
Tom Zanussi 已提交
1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
	}

	script = strchr(str, ':');
	if (script) {
		len = script - str;
		if (len >= PATH_MAX) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}
		strncpy(spec, str, len);
		spec[len] = '\0';
		scripting_ops = script_spec__lookup(spec);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}
		script++;
	} else {
		script = str;
1968
		ext = strrchr(script, '.');
T
Tom Zanussi 已提交
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
		if (!ext) {
			fprintf(stderr, "invalid script extension");
			return -1;
		}
		scripting_ops = script_spec__lookup(++ext);
		if (!scripting_ops) {
			fprintf(stderr, "invalid script extension");
			return -1;
		}
	}

	script_name = strdup(script);

	return 0;
}

1985 1986
static int parse_output_fields(const struct option *opt __maybe_unused,
			    const char *arg, int unset __maybe_unused)
1987
{
1988
	char *tok, *strtok_saveptr = NULL;
1989
	int i, imax = ARRAY_SIZE(all_output_options);
1990
	int j;
1991 1992
	int rc = 0;
	char *str = strdup(arg);
1993
	int type = -1;
1994
	enum { DEFAULT, SET, ADD, REMOVE } change = DEFAULT;
1995 1996 1997 1998

	if (!str)
		return -ENOMEM;

1999 2000 2001
	/* first word can state for which event type the user is specifying
	 * the fields. If no type exists, the specified fields apply to all
	 * event types found in the file minus the invalid fields for a type.
2002
	 */
2003 2004 2005 2006 2007 2008 2009 2010 2011 2012
	tok = strchr(str, ':');
	if (tok) {
		*tok = '\0';
		tok++;
		if (!strcmp(str, "hw"))
			type = PERF_TYPE_HARDWARE;
		else if (!strcmp(str, "sw"))
			type = PERF_TYPE_SOFTWARE;
		else if (!strcmp(str, "trace"))
			type = PERF_TYPE_TRACEPOINT;
2013 2014
		else if (!strcmp(str, "raw"))
			type = PERF_TYPE_RAW;
2015 2016
		else if (!strcmp(str, "break"))
			type = PERF_TYPE_BREAKPOINT;
2017 2018
		else if (!strcmp(str, "synth"))
			type = OUTPUT_TYPE_SYNTH;
2019 2020
		else {
			fprintf(stderr, "Invalid event type in field string.\n");
2021 2022
			rc = -EINVAL;
			goto out;
2023 2024 2025 2026 2027 2028 2029 2030
		}

		if (output[type].user_set)
			pr_warning("Overriding previous field request for %s events.\n",
				   event_type(type));

		output[type].fields = 0;
		output[type].user_set = true;
2031
		output[type].wildcard_set = false;
2032 2033 2034 2035 2036 2037 2038 2039 2040 2041

	} else {
		tok = str;
		if (strlen(str) == 0) {
			fprintf(stderr,
				"Cannot set fields to 'none' for all event types.\n");
			rc = -EINVAL;
			goto out;
		}

2042 2043 2044 2045
		/* Don't override defaults for +- */
		if (strchr(str, '+') || strchr(str, '-'))
			goto parse;

2046 2047 2048
		if (output_set_by_user())
			pr_warning("Overriding previous field request for all events.\n");

2049
		for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2050 2051
			output[j].fields = 0;
			output[j].user_set = true;
2052
			output[j].wildcard_set = true;
2053
		}
2054 2055
	}

2056
parse:
2057
	for (tok = strtok_r(tok, ",", &strtok_saveptr); tok; tok = strtok_r(NULL, ",", &strtok_saveptr)) {
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
		if (*tok == '+') {
			if (change == SET)
				goto out_badmix;
			change = ADD;
			tok++;
		} else if (*tok == '-') {
			if (change == SET)
				goto out_badmix;
			change = REMOVE;
			tok++;
		} else {
			if (change != SET && change != DEFAULT)
				goto out_badmix;
			change = SET;
		}

2074
		for (i = 0; i < imax; ++i) {
2075
			if (strcmp(tok, all_output_options[i].str) == 0)
2076 2077
				break;
		}
2078
		if (i == imax && strcmp(tok, "flags") == 0) {
2079
			print_flags = change == REMOVE ? false : true;
2080 2081
			continue;
		}
2082
		if (i == imax) {
2083
			fprintf(stderr, "Invalid field requested.\n");
2084
			rc = -EINVAL;
2085
			goto out;
2086 2087
		}

2088 2089 2090 2091
		if (type == -1) {
			/* add user option to all events types for
			 * which it is valid
			 */
2092
			for (j = 0; j < OUTPUT_TYPE_MAX; ++j) {
2093 2094 2095
				if (output[j].invalid_fields & all_output_options[i].field) {
					pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
						   all_output_options[i].str, event_type(j));
2096 2097 2098 2099 2100 2101
				} else {
					if (change == REMOVE)
						output[j].fields &= ~all_output_options[i].field;
					else
						output[j].fields |= all_output_options[i].field;
				}
2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112
			}
		} else {
			if (output[type].invalid_fields & all_output_options[i].field) {
				fprintf(stderr, "\'%s\' not valid for %s events.\n",
					 all_output_options[i].str, event_type(type));

				rc = -EINVAL;
				goto out;
			}
			output[type].fields |= all_output_options[i].field;
		}
2113 2114
	}

2115 2116 2117 2118 2119 2120
	if (type >= 0) {
		if (output[type].fields == 0) {
			pr_debug("No fields requested for %s type. "
				 "Events will not be displayed.\n", event_type(type));
		}
	}
2121
	goto out;
2122

2123 2124 2125
out_badmix:
	fprintf(stderr, "Cannot mix +-field with overridden fields\n");
	rc = -EINVAL;
2126
out:
2127 2128 2129 2130
	free(str);
	return rc;
}

2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143
/* Helper function for filesystems that return a dent->d_type DT_UNKNOWN */
static int is_directory(const char *base_path, const struct dirent *dent)
{
	char path[PATH_MAX];
	struct stat st;

	sprintf(path, "%s/%s", base_path, dent->d_name);
	if (stat(path, &st))
		return 0;

	return S_ISDIR(st.st_mode);
}

2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156
#define for_each_lang(scripts_path, scripts_dir, lang_dirent)		\
	while ((lang_dirent = readdir(scripts_dir)) != NULL)		\
		if ((lang_dirent->d_type == DT_DIR ||			\
		     (lang_dirent->d_type == DT_UNKNOWN &&		\
		      is_directory(scripts_path, lang_dirent))) &&	\
		    (strcmp(lang_dirent->d_name, ".")) &&		\
		    (strcmp(lang_dirent->d_name, "..")))

#define for_each_script(lang_path, lang_dir, script_dirent)		\
	while ((script_dirent = readdir(lang_dir)) != NULL)		\
		if (script_dirent->d_type != DT_DIR &&			\
		    (script_dirent->d_type != DT_UNKNOWN ||		\
		     !is_directory(lang_path, script_dirent)))
2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168


#define RECORD_SUFFIX			"-record"
#define REPORT_SUFFIX			"-report"

struct script_desc {
	struct list_head	node;
	char			*name;
	char			*half_liner;
	char			*args;
};

2169
static LIST_HEAD(script_descs);
2170 2171 2172 2173 2174

static struct script_desc *script_desc__new(const char *name)
{
	struct script_desc *s = zalloc(sizeof(*s));

2175
	if (s != NULL && name)
2176 2177 2178 2179 2180 2181 2182
		s->name = strdup(name);

	return s;
}

static void script_desc__delete(struct script_desc *s)
{
2183 2184 2185
	zfree(&s->name);
	zfree(&s->half_liner);
	zfree(&s->args);
2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
	free(s);
}

static void script_desc__add(struct script_desc *s)
{
	list_add_tail(&s->node, &script_descs);
}

static struct script_desc *script_desc__find(const char *name)
{
	struct script_desc *s;

	list_for_each_entry(s, &script_descs, node)
		if (strcasecmp(s->name, name) == 0)
			return s;
	return NULL;
}

static struct script_desc *script_desc__findnew(const char *name)
{
	struct script_desc *s = script_desc__find(name);

	if (s)
		return s;

	s = script_desc__new(name);
	if (!s)
2213
		return NULL;
2214 2215 2216 2217 2218 2219

	script_desc__add(s);

	return s;
}

2220
static const char *ends_with(const char *str, const char *suffix)
2221 2222
{
	size_t suffix_len = strlen(suffix);
2223
	const char *p = str;
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274

	if (strlen(str) > suffix_len) {
		p = str + strlen(str) - suffix_len;
		if (!strncmp(p, suffix, suffix_len))
			return p;
	}

	return NULL;
}

static int read_script_info(struct script_desc *desc, const char *filename)
{
	char line[BUFSIZ], *p;
	FILE *fp;

	fp = fopen(filename, "r");
	if (!fp)
		return -1;

	while (fgets(line, sizeof(line), fp)) {
		p = ltrim(line);
		if (strlen(p) == 0)
			continue;
		if (*p != '#')
			continue;
		p++;
		if (strlen(p) && *p == '!')
			continue;

		p = ltrim(p);
		if (strlen(p) && p[strlen(p) - 1] == '\n')
			p[strlen(p) - 1] = '\0';

		if (!strncmp(p, "description:", strlen("description:"))) {
			p += strlen("description:");
			desc->half_liner = strdup(ltrim(p));
			continue;
		}

		if (!strncmp(p, "args:", strlen("args:"))) {
			p += strlen("args:");
			desc->args = strdup(ltrim(p));
			continue;
		}
	}

	fclose(fp);

	return 0;
}

2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
static char *get_script_root(struct dirent *script_dirent, const char *suffix)
{
	char *script_root, *str;

	script_root = strdup(script_dirent->d_name);
	if (!script_root)
		return NULL;

	str = (char *)ends_with(script_root, suffix);
	if (!str) {
		free(script_root);
		return NULL;
	}

	*str = '\0';
	return script_root;
}

2293 2294 2295
static int list_available_scripts(const struct option *opt __maybe_unused,
				  const char *s __maybe_unused,
				  int unset __maybe_unused)
2296
{
2297
	struct dirent *script_dirent, *lang_dirent;
2298 2299 2300 2301 2302 2303 2304 2305
	char scripts_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	char script_path[MAXPATHLEN];
	char lang_path[MAXPATHLEN];
	struct script_desc *desc;
	char first_half[BUFSIZ];
	char *script_root;

2306
	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2307 2308

	scripts_dir = opendir(scripts_path);
2309 2310 2311 2312 2313 2314 2315
	if (!scripts_dir) {
		fprintf(stdout,
			"open(%s) failed.\n"
			"Check \"PERF_EXEC_PATH\" env to set scripts dir.\n",
			scripts_path);
		exit(-1);
	}
2316

2317
	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2318
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
2319
			 lang_dirent->d_name);
2320 2321 2322 2323
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

2324 2325
		for_each_script(lang_path, lang_dir, script_dirent) {
			script_root = get_script_root(script_dirent, REPORT_SUFFIX);
2326
			if (script_root) {
2327 2328
				desc = script_desc__findnew(script_root);
				snprintf(script_path, MAXPATHLEN, "%s/%s",
2329
					 lang_path, script_dirent->d_name);
2330
				read_script_info(desc, script_path);
2331
				free(script_root);
2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346
			}
		}
	}

	fprintf(stdout, "List of available trace scripts:\n");
	list_for_each_entry(desc, &script_descs, node) {
		sprintf(first_half, "%s %s", desc->name,
			desc->args ? desc->args : "");
		fprintf(stdout, "  %-36s %s\n", first_half,
			desc->half_liner ? desc->half_liner : "");
	}

	exit(0);
}

2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389
/*
 * Some scripts specify the required events in their "xxx-record" file,
 * this function will check if the events in perf.data match those
 * mentioned in the "xxx-record".
 *
 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
 * which is covered well now. And new parsing code should be added to
 * cover the future complexing formats like event groups etc.
 */
static int check_ev_match(char *dir_name, char *scriptname,
			struct perf_session *session)
{
	char filename[MAXPATHLEN], evname[128];
	char line[BUFSIZ], *p;
	struct perf_evsel *pos;
	int match, len;
	FILE *fp;

	sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);

	fp = fopen(filename, "r");
	if (!fp)
		return -1;

	while (fgets(line, sizeof(line), fp)) {
		p = ltrim(line);
		if (*p == '#')
			continue;

		while (strlen(p)) {
			p = strstr(p, "-e");
			if (!p)
				break;

			p += 2;
			p = ltrim(p);
			len = strcspn(p, " \t");
			if (!len)
				break;

			snprintf(evname, len + 1, "%s", p);

			match = 0;
2390
			evlist__for_each_entry(session->evlist, pos) {
2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407
				if (!strcmp(perf_evsel__name(pos), evname)) {
					match = 1;
					break;
				}
			}

			if (!match) {
				fclose(fp);
				return -1;
			}
		}
	}

	fclose(fp);
	return 0;
}

2408 2409 2410 2411 2412 2413 2414 2415 2416
/*
 * Return -1 if none is found, otherwise the actual scripts number.
 *
 * Currently the only user of this function is the script browser, which
 * will list all statically runnable scripts, select one, execute it and
 * show the output in a perf browser.
 */
int find_scripts(char **scripts_array, char **scripts_path_array)
{
2417
	struct dirent *script_dirent, *lang_dirent;
2418
	char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
2419
	DIR *scripts_dir, *lang_dir;
2420
	struct perf_session *session;
2421 2422 2423 2424
	struct perf_data_file file = {
		.path = input_name,
		.mode = PERF_DATA_MODE_READ,
	};
2425 2426 2427
	char *temp;
	int i = 0;

2428
	session = perf_session__new(&file, false, NULL);
2429 2430 2431
	if (!session)
		return -1;

2432
	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2433 2434

	scripts_dir = opendir(scripts_path);
2435 2436
	if (!scripts_dir) {
		perf_session__delete(session);
2437
		return -1;
2438
	}
2439

2440
	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2441
		snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
2442
			 lang_dirent->d_name);
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455
#ifdef NO_LIBPERL
		if (strstr(lang_path, "perl"))
			continue;
#endif
#ifdef NO_LIBPYTHON
		if (strstr(lang_path, "python"))
			continue;
#endif

		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

2456
		for_each_script(lang_path, lang_dir, script_dirent) {
2457
			/* Skip those real time scripts: xxxtop.p[yl] */
2458
			if (strstr(script_dirent->d_name, "top."))
2459 2460
				continue;
			sprintf(scripts_path_array[i], "%s/%s", lang_path,
2461 2462
				script_dirent->d_name);
			temp = strchr(script_dirent->d_name, '.');
2463
			snprintf(scripts_array[i],
2464 2465
				(temp - script_dirent->d_name) + 1,
				"%s", script_dirent->d_name);
2466 2467 2468 2469 2470

			if (check_ev_match(lang_path,
					scripts_array[i], session))
				continue;

2471 2472
			i++;
		}
2473
		closedir(lang_dir);
2474 2475
	}

2476 2477
	closedir(scripts_dir);
	perf_session__delete(session);
2478 2479 2480
	return i;
}

2481 2482
static char *get_script_path(const char *script_root, const char *suffix)
{
2483
	struct dirent *script_dirent, *lang_dirent;
2484 2485 2486 2487
	char scripts_path[MAXPATHLEN];
	char script_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	char lang_path[MAXPATHLEN];
2488
	char *__script_root;
2489

2490
	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", get_argv_exec_path());
2491 2492 2493 2494 2495

	scripts_dir = opendir(scripts_path);
	if (!scripts_dir)
		return NULL;

2496
	for_each_lang(scripts_path, scripts_dir, lang_dirent) {
2497
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
2498
			 lang_dirent->d_name);
2499 2500 2501 2502
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

2503 2504
		for_each_script(lang_path, lang_dir, script_dirent) {
			__script_root = get_script_root(script_dirent, suffix);
2505 2506
			if (__script_root && !strcmp(script_root, __script_root)) {
				free(__script_root);
2507 2508
				closedir(lang_dir);
				closedir(scripts_dir);
2509
				snprintf(script_path, MAXPATHLEN, "%s/%s",
2510
					 lang_path, script_dirent->d_name);
2511
				return strdup(script_path);
2512 2513 2514
			}
			free(__script_root);
		}
2515
		closedir(lang_dir);
2516
	}
2517
	closedir(scripts_dir);
2518

2519
	return NULL;
2520 2521
}

2522 2523
static bool is_top_script(const char *script_path)
{
2524
	return ends_with(script_path, "top") == NULL ? false : true;
2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549
}

static int has_required_arg(char *script_path)
{
	struct script_desc *desc;
	int n_args = 0;
	char *p;

	desc = script_desc__new(NULL);

	if (read_script_info(desc, script_path))
		goto out;

	if (!desc->args)
		goto out;

	for (p = desc->args; *p; p++)
		if (*p == '<')
			n_args++;
out:
	script_desc__delete(desc);

	return n_args;
}

2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
static int have_cmd(int argc, const char **argv)
{
	char **__argv = malloc(sizeof(const char *) * argc);

	if (!__argv) {
		pr_err("malloc failed\n");
		return -1;
	}

	memcpy(__argv, argv, sizeof(const char *) * argc);
	argc = parse_options(argc, (const char **)__argv, record_options,
			     NULL, PARSE_OPT_STOP_AT_NON_OPTION);
	free(__argv);
F
Frederic Weisbecker 已提交
2563

2564 2565 2566 2567 2568
	system_wide = (argc == 0);

	return 0;
}

2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
static void script__setup_sample_type(struct perf_script *script)
{
	struct perf_session *session = script->session;
	u64 sample_type = perf_evlist__combined_sample_type(session->evlist);

	if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain) {
		if ((sample_type & PERF_SAMPLE_REGS_USER) &&
		    (sample_type & PERF_SAMPLE_STACK_USER))
			callchain_param.record_mode = CALLCHAIN_DWARF;
		else if (sample_type & PERF_SAMPLE_BRANCH_STACK)
			callchain_param.record_mode = CALLCHAIN_LBR;
		else
			callchain_param.record_mode = CALLCHAIN_FP;
	}
}

2585 2586 2587 2588 2589 2590 2591
static int process_stat_round_event(struct perf_tool *tool __maybe_unused,
				    union perf_event *event,
				    struct perf_session *session)
{
	struct stat_round_event *round = &event->stat_round;
	struct perf_evsel *counter;

2592
	evlist__for_each_entry(session->evlist, counter) {
2593 2594 2595 2596 2597 2598 2599 2600
		perf_stat_process_counter(&stat_config, counter);
		process_stat(counter, round->time);
	}

	process_stat_interval(round->time);
	return 0;
}

2601 2602 2603 2604 2605 2606 2607 2608
static int process_stat_config_event(struct perf_tool *tool __maybe_unused,
				     union perf_event *event,
				     struct perf_session *session __maybe_unused)
{
	perf_event__read_stat_config(&stat_config, &event->stat_config);
	return 0;
}

2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665
static int set_maps(struct perf_script *script)
{
	struct perf_evlist *evlist = script->session->evlist;

	if (!script->cpus || !script->threads)
		return 0;

	if (WARN_ONCE(script->allocated, "stats double allocation\n"))
		return -EINVAL;

	perf_evlist__set_maps(evlist, script->cpus, script->threads);

	if (perf_evlist__alloc_stats(evlist, true))
		return -ENOMEM;

	script->allocated = true;
	return 0;
}

static
int process_thread_map_event(struct perf_tool *tool,
			     union perf_event *event,
			     struct perf_session *session __maybe_unused)
{
	struct perf_script *script = container_of(tool, struct perf_script, tool);

	if (script->threads) {
		pr_warning("Extra thread map event, ignoring.\n");
		return 0;
	}

	script->threads = thread_map__new_event(&event->thread_map);
	if (!script->threads)
		return -ENOMEM;

	return set_maps(script);
}

static
int process_cpu_map_event(struct perf_tool *tool __maybe_unused,
			  union perf_event *event,
			  struct perf_session *session __maybe_unused)
{
	struct perf_script *script = container_of(tool, struct perf_script, tool);

	if (script->cpus) {
		pr_warning("Extra cpu map event, ignoring.\n");
		return 0;
	}

	script->cpus = cpu_map__new_data(&event->cpu_map.data);
	if (!script->cpus)
		return -ENOMEM;

	return set_maps(script);
}

2666
int cmd_script(int argc, const char **argv)
2667 2668
{
	bool show_full_info = false;
2669 2670
	bool header = false;
	bool header_only = false;
2671
	bool script_started = false;
2672 2673 2674
	char *rec_script_path = NULL;
	char *rep_script_path = NULL;
	struct perf_session *session;
2675
	struct itrace_synth_opts itrace_synth_opts = { .set = false, };
2676 2677
	char *script_path = NULL;
	const char **__argv;
2678
	int i, j, err = 0;
2679 2680 2681 2682 2683 2684
	struct perf_script script = {
		.tool = {
			.sample		 = process_sample_event,
			.mmap		 = perf_event__process_mmap,
			.mmap2		 = perf_event__process_mmap2,
			.comm		 = perf_event__process_comm,
2685
			.namespaces	 = perf_event__process_namespaces,
2686 2687
			.exit		 = perf_event__process_exit,
			.fork		 = perf_event__process_fork,
2688
			.attr		 = process_attr,
2689
			.event_update   = perf_event__process_event_update,
2690
			.tracing_data	 = perf_event__process_tracing_data,
2691
			.feature	 = perf_event__process_feature,
2692
			.build_id	 = perf_event__process_build_id,
2693 2694 2695 2696
			.id_index	 = perf_event__process_id_index,
			.auxtrace_info	 = perf_event__process_auxtrace_info,
			.auxtrace	 = perf_event__process_auxtrace,
			.auxtrace_error	 = perf_event__process_auxtrace_error,
2697 2698
			.stat		 = perf_event__process_stat_event,
			.stat_round	 = process_stat_round_event,
2699
			.stat_config	 = process_stat_config_event,
2700 2701
			.thread_map	 = process_thread_map_event,
			.cpu_map	 = process_cpu_map_event,
2702
			.ordered_events	 = true,
2703 2704 2705
			.ordering_requires_timestamps = true,
		},
	};
2706 2707 2708
	struct perf_data_file file = {
		.mode = PERF_DATA_MODE_READ,
	};
2709
	const struct option options[] = {
F
Frederic Weisbecker 已提交
2710 2711
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
2712
	OPT_INCR('v', "verbose", &verbose,
2713
		 "be more verbose (show symbol address, etc)"),
2714
	OPT_BOOLEAN('L', "Latency", &latency_format,
2715
		    "show latency attributes (irqs/preemption disabled, etc)"),
2716 2717
	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
			   list_available_scripts),
T
Tom Zanussi 已提交
2718 2719 2720 2721
	OPT_CALLBACK('s', "script", NULL, "name",
		     "script file name (lang:script name, script name, or *)",
		     parse_scriptname),
	OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
2722
		   "generate perf-script.xx script in specified language"),
2723
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
2724 2725
	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
		   "do various checks like samples ordering and lost events"),
2726 2727
	OPT_BOOLEAN(0, "header", &header, "Show data header."),
	OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
2728 2729 2730 2731 2732 2733
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
		   "file", "kallsyms pathname"),
	OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
		    "When printing symbols do not display call chain"),
2734 2735 2736
	OPT_CALLBACK(0, "symfs", NULL, "directory",
		     "Look for files with symbols relative to this directory",
		     symbol__config_symfs),
2737
	OPT_CALLBACK('F', "fields", NULL, "str",
2738
		     "comma separated output fields prepend with 'type:'. "
2739
		     "+field to add and -field to remove."
2740
		     "Valid types: hw,sw,trace,raw,synth. "
2741
		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
2742
		     "addr,symoff,period,iregs,brstack,brstacksym,flags,"
2743
		     "bpf-output,callindent,insn,insnlen,brstackinsn,synth,phys_addr",
2744
		     parse_output_fields),
2745
	OPT_BOOLEAN('a', "all-cpus", &system_wide,
2746
		    "system-wide collection from all CPUs"),
2747 2748
	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
		   "only consider these symbols"),
2749 2750
	OPT_STRING(0, "stop-bt", &symbol_conf.bt_stop_list_str, "symbol[,symbol...]",
		   "Stop display of callgraph at these symbols"),
2751
	OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
2752 2753
	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
		   "only display events for these comms"),
2754 2755 2756 2757
	OPT_STRING(0, "pid", &symbol_conf.pid_list_str, "pid[,pid...]",
		   "only consider symbols in these pids"),
	OPT_STRING(0, "tid", &symbol_conf.tid_list_str, "tid[,tid...]",
		   "only consider symbols in these tids"),
2758 2759 2760
	OPT_UINTEGER(0, "max-stack", &scripting_max_stack,
		     "Set the maximum stack depth when parsing the callchain, "
		     "anything beyond the specified depth will be ignored. "
2761
		     "Default: kernel.perf_event_max_stack or " __stringify(PERF_MAX_STACK_DEPTH)),
2762 2763
	OPT_BOOLEAN('I', "show-info", &show_full_info,
		    "display extended information from perf.data file"),
2764 2765
	OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
		    "Show the path of [kernel.kallsyms]"),
2766 2767
	OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
		    "Show the fork/comm/exit events"),
2768 2769
	OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
		    "Show the mmap events"),
2770 2771
	OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
		    "Show context switch events (if recorded)"),
2772 2773
	OPT_BOOLEAN('\0', "show-namespace-events", &script.show_namespace_events,
		    "Show namespace events (if recorded)"),
2774
	OPT_BOOLEAN('f', "force", &symbol_conf.force, "don't complain, do it"),
2775 2776
	OPT_INTEGER(0, "max-blocks", &max_blocks,
		    "Maximum number of code blocks to dump with brstackinsn"),
2777 2778
	OPT_BOOLEAN(0, "ns", &nanosecs,
		    "Use 9 decimal places when displaying time"),
2779 2780 2781
	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
			    "Instruction Tracing options",
			    itrace_parse_synth_opts),
2782 2783
	OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
			"Show full source file name path for source lines"),
2784 2785 2786 2787
	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
			"Enable symbol demangling"),
	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
			"Enable kernel symbol demangling"),
2788 2789
	OPT_STRING(0, "time", &script.time_str, "str",
		   "Time span of interest (start,stop)"),
2790 2791
	OPT_BOOLEAN(0, "inline", &symbol_conf.inline_name,
		    "Show inline function"),
2792
	OPT_END()
2793
	};
2794 2795
	const char * const script_subcommands[] = { "record", "report", NULL };
	const char *script_usage[] = {
2796 2797 2798 2799 2800 2801 2802
		"perf script [<options>]",
		"perf script [<options>] record <script> [<record-options>] <command>",
		"perf script [<options>] report <script> [script-args]",
		"perf script [<options>] <script> [<record-options>] <command>",
		"perf script [<options>] <top-script> [script-args]",
		NULL
	};
2803

2804 2805
	setup_scripting();

2806
	argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
2807 2808
			     PARSE_OPT_STOP_AT_NON_OPTION);

2809
	file.path = input_name;
2810
	file.force = symbol_conf.force;
2811

2812 2813 2814
	if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
		rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
		if (!rec_script_path)
2815
			return cmd_record(argc, argv);
2816 2817
	}

2818 2819 2820
	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
		if (!rep_script_path) {
2821
			fprintf(stderr,
2822
				"Please specify a valid report script"
2823
				"(see 'perf script -l' for listing)\n");
2824 2825 2826 2827
			return -1;
		}
	}

2828 2829 2830 2831
	if (itrace_synth_opts.callchain &&
	    itrace_synth_opts.callchain_sz > scripting_max_stack)
		scripting_max_stack = itrace_synth_opts.callchain_sz;

2832
	/* make sure PERF_EXEC_PATH is set for scripts */
2833
	set_argv_exec_path(get_argv_exec_path());
2834

2835
	if (argc && !script_name && !rec_script_path && !rep_script_path) {
2836
		int live_pipe[2];
2837
		int rep_args;
2838 2839
		pid_t pid;

2840 2841 2842 2843
		rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
		rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);

		if (!rec_script_path && !rep_script_path) {
2844 2845
			usage_with_options_msg(script_usage, options,
				"Couldn't find script `%s'\n\n See perf"
2846
				" script -l for available scripts.\n", argv[0]);
2847 2848
		}

2849 2850 2851 2852 2853 2854 2855 2856
		if (is_top_script(argv[0])) {
			rep_args = argc - 1;
		} else {
			int rec_args;

			rep_args = has_required_arg(rep_script_path);
			rec_args = (argc - 1) - rep_args;
			if (rec_args < 0) {
2857 2858
				usage_with_options_msg(script_usage, options,
					"`%s' script requires options."
2859
					"\n\n See perf script -l for available "
2860 2861
					"scripts and options.\n", argv[0]);
			}
2862 2863 2864 2865
		}

		if (pipe(live_pipe) < 0) {
			perror("failed to create pipe");
2866
			return -1;
2867 2868 2869 2870 2871
		}

		pid = fork();
		if (pid < 0) {
			perror("failed to fork");
2872
			return -1;
2873 2874 2875
		}

		if (!pid) {
2876 2877
			j = 0;

2878 2879 2880
			dup2(live_pipe[1], 1);
			close(live_pipe[0]);

2881 2882 2883
			if (is_top_script(argv[0])) {
				system_wide = true;
			} else if (!system_wide) {
2884 2885 2886 2887
				if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
					err = -1;
					goto out;
				}
2888
			}
2889 2890

			__argv = malloc((argc + 6) * sizeof(const char *));
2891 2892 2893 2894 2895
			if (!__argv) {
				pr_err("malloc failed\n");
				err = -ENOMEM;
				goto out;
			}
2896

2897 2898 2899 2900 2901 2902 2903 2904 2905 2906
			__argv[j++] = "/bin/sh";
			__argv[j++] = rec_script_path;
			if (system_wide)
				__argv[j++] = "-a";
			__argv[j++] = "-q";
			__argv[j++] = "-o";
			__argv[j++] = "-";
			for (i = rep_args + 1; i < argc; i++)
				__argv[j++] = argv[i];
			__argv[j++] = NULL;
2907 2908

			execvp("/bin/sh", (char **)__argv);
2909
			free(__argv);
2910 2911 2912 2913 2914 2915
			exit(-1);
		}

		dup2(live_pipe[0], 0);
		close(live_pipe[1]);

2916
		__argv = malloc((argc + 4) * sizeof(const char *));
2917 2918 2919 2920 2921 2922
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

2923 2924 2925 2926 2927 2928 2929 2930
		j = 0;
		__argv[j++] = "/bin/sh";
		__argv[j++] = rep_script_path;
		for (i = 1; i < rep_args + 1; i++)
			__argv[j++] = argv[i];
		__argv[j++] = "-i";
		__argv[j++] = "-";
		__argv[j++] = NULL;
2931 2932

		execvp("/bin/sh", (char **)__argv);
2933
		free(__argv);
2934 2935 2936
		exit(-1);
	}

2937 2938 2939 2940
	if (rec_script_path)
		script_path = rec_script_path;
	if (rep_script_path)
		script_path = rep_script_path;
2941

2942 2943
	if (script_path) {
		j = 0;
2944

2945 2946
		if (!rec_script_path)
			system_wide = false;
2947 2948 2949 2950 2951 2952
		else if (!system_wide) {
			if (have_cmd(argc - 1, &argv[1]) != 0) {
				err = -1;
				goto out;
			}
		}
2953

2954
		__argv = malloc((argc + 2) * sizeof(const char *));
2955 2956 2957 2958 2959 2960
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

2961 2962 2963 2964
		__argv[j++] = "/bin/sh";
		__argv[j++] = script_path;
		if (system_wide)
			__argv[j++] = "-a";
2965
		for (i = 2; i < argc; i++)
2966 2967
			__argv[j++] = argv[i];
		__argv[j++] = NULL;
2968 2969

		execvp("/bin/sh", (char **)__argv);
2970
		free(__argv);
2971 2972
		exit(-1);
	}
T
Tom Zanussi 已提交
2973

2974 2975
	if (!script_name)
		setup_pager();
F
Frederic Weisbecker 已提交
2976

2977
	session = perf_session__new(&file, false, &script.tool);
2978
	if (session == NULL)
2979
		return -1;
2980

2981
	if (header || header_only) {
2982
		script.tool.show_feat_hdr = SHOW_FEAT_HEADER;
2983 2984
		perf_session__fprintf_info(session, stdout, show_full_info);
		if (header_only)
2985
			goto out_delete;
2986
	}
2987 2988
	if (show_full_info)
		script.tool.show_feat_hdr = SHOW_FEAT_HEADER_FULL_INFO;
2989

2990
	if (symbol__init(&session->header.env) < 0)
2991 2992
		goto out_delete;

2993
	script.session = session;
2994
	script__setup_sample_type(&script);
2995

2996 2997 2998
	if (output[PERF_TYPE_HARDWARE].fields & PERF_OUTPUT_CALLINDENT)
		itrace_synth_opts.thread_stack = true;

2999 3000
	session->itrace_synth_opts = &itrace_synth_opts;

3001
	if (cpu_list) {
3002 3003 3004
		err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
		if (err < 0)
			goto out_delete;
3005
		itrace_synth_opts.cpu_bitmap = cpu_bitmap;
3006 3007
	}

3008
	if (!no_callchain)
3009 3010 3011 3012
		symbol_conf.use_callchain = true;
	else
		symbol_conf.use_callchain = false;

3013 3014
	if (session->tevent.pevent &&
	    pevent_set_function_resolver(session->tevent.pevent,
3015 3016 3017 3018 3019 3020
					 machine__resolve_kernel_addr,
					 &session->machines.host) < 0) {
		pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
		return -1;
	}

T
Tom Zanussi 已提交
3021 3022
	if (generate_script_lang) {
		struct stat perf_stat;
3023 3024
		int input;

3025
		if (output_set_by_user()) {
3026 3027
			fprintf(stderr,
				"custom fields not supported for generated scripts");
3028 3029
			err = -EINVAL;
			goto out_delete;
3030
		}
T
Tom Zanussi 已提交
3031

3032
		input = open(file.path, O_RDONLY);	/* input_name */
T
Tom Zanussi 已提交
3033
		if (input < 0) {
3034
			err = -errno;
T
Tom Zanussi 已提交
3035
			perror("failed to open file");
3036
			goto out_delete;
T
Tom Zanussi 已提交
3037 3038 3039 3040 3041
		}

		err = fstat(input, &perf_stat);
		if (err < 0) {
			perror("failed to stat file");
3042
			goto out_delete;
T
Tom Zanussi 已提交
3043 3044 3045 3046
		}

		if (!perf_stat.st_size) {
			fprintf(stderr, "zero-sized file, nothing to do!\n");
3047
			goto out_delete;
T
Tom Zanussi 已提交
3048 3049 3050 3051 3052
		}

		scripting_ops = script_spec__lookup(generate_script_lang);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
3053 3054
			err = -ENOENT;
			goto out_delete;
T
Tom Zanussi 已提交
3055 3056
		}

J
Jiri Olsa 已提交
3057
		err = scripting_ops->generate_script(session->tevent.pevent,
3058
						     "perf-script");
3059
		goto out_delete;
T
Tom Zanussi 已提交
3060 3061 3062
	}

	if (script_name) {
3063
		err = scripting_ops->start_script(script_name, argc, argv);
T
Tom Zanussi 已提交
3064
		if (err)
3065
			goto out_delete;
3066
		pr_debug("perf script started with script %s\n\n", script_name);
3067
		script_started = true;
T
Tom Zanussi 已提交
3068 3069
	}

3070 3071 3072

	err = perf_session__check_output_opt(session);
	if (err < 0)
3073
		goto out_delete;
3074

3075 3076 3077 3078 3079 3080
	/* needs to be parsed after looking up reference time */
	if (perf_time__parse_str(&script.ptime, script.time_str) != 0) {
		pr_err("Invalid time string\n");
		return -EINVAL;
	}

3081
	err = __cmd_script(&script);
T
Tom Zanussi 已提交
3082

3083 3084
	flush_scripting();

3085
out_delete:
3086
	perf_evlist__free_stats(session->evlist);
3087
	perf_session__delete(session);
3088 3089 3090

	if (script_started)
		cleanup_scripting();
T
Tom Zanussi 已提交
3091 3092
out:
	return err;
F
Frederic Weisbecker 已提交
3093
}