builtin-script.c 49.0 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 6 7 8
#include "util/debug.h"
#include "util/exec_cmd.h"
#include "util/header.h"
#include "util/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
#include <linux/bitmap.h>
F
Frederic Weisbecker 已提交
22

T
Tom Zanussi 已提交
23 24
static char const		*script_name;
static char const		*generate_script_lang;
25
static bool			debug_mode;
26
static u64			last_timestamp;
27
static u64			nr_unordered;
28
static bool			no_callchain;
29
static bool			latency_format;
30
static bool			system_wide;
31
static bool			print_flags;
32
static bool			nanosecs;
33 34
static const char		*cpu_list;
static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
T
Tom Zanussi 已提交
35

36
unsigned int scripting_max_stack = PERF_MAX_STACK_DEPTH;
37

38 39 40 41 42 43 44 45
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,
46 47
	PERF_OUTPUT_IP              = 1U << 7,
	PERF_OUTPUT_SYM             = 1U << 8,
48
	PERF_OUTPUT_DSO             = 1U << 9,
49
	PERF_OUTPUT_ADDR            = 1U << 10,
50
	PERF_OUTPUT_SYMOFFSET       = 1U << 11,
51
	PERF_OUTPUT_SRCLINE         = 1U << 12,
J
Jiri Olsa 已提交
52
	PERF_OUTPUT_PERIOD          = 1U << 13,
53
	PERF_OUTPUT_IREGS	    = 1U << 14,
54 55 56 57 58 59 60 61 62 63 64 65 66
};

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},
67
	{.str = "ip",    .field = PERF_OUTPUT_IP},
68
	{.str = "sym",   .field = PERF_OUTPUT_SYM},
69
	{.str = "dso",   .field = PERF_OUTPUT_DSO},
70
	{.str = "addr",  .field = PERF_OUTPUT_ADDR},
71
	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
72
	{.str = "srcline", .field = PERF_OUTPUT_SRCLINE},
J
Jiri Olsa 已提交
73
	{.str = "period", .field = PERF_OUTPUT_PERIOD},
74
	{.str = "iregs", .field = PERF_OUTPUT_IREGS},
75 76 77
};

/* default set to maintain compatibility with current format */
78 79
static struct {
	bool user_set;
80
	bool wildcard_set;
81
	unsigned int print_ip_opts;
82 83 84 85 86 87 88 89 90
	u64 fields;
	u64 invalid_fields;
} output[PERF_TYPE_MAX] = {

	[PERF_TYPE_HARDWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
91
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
92 93
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_PERIOD,
94 95 96 97 98 99 100 101 102

		.invalid_fields = PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_SOFTWARE] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
103
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
104 105
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_PERIOD,
106 107 108 109 110 111 112 113 114 115 116

		.invalid_fields = PERF_OUTPUT_TRACE,
	},

	[PERF_TYPE_TRACEPOINT] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
				  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE,
	},
117 118 119 120 121 122

	[PERF_TYPE_RAW] = {
		.user_set = false,

		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
123
			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
124 125
			      PERF_OUTPUT_SYM | PERF_OUTPUT_DSO |
			      PERF_OUTPUT_PERIOD,
126 127 128

		.invalid_fields = PERF_OUTPUT_TRACE,
	},
129
};
130

131 132 133 134 135 136 137 138 139
static bool output_set_by_user(void)
{
	int j;
	for (j = 0; j < PERF_TYPE_MAX; ++j) {
		if (output[j].user_set)
			return true;
	}
	return false;
}
140

141 142 143 144 145 146 147 148 149 150 151 152 153 154
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;
}

155
#define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
156

157 158 159 160
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)
161
{
162
	struct perf_event_attr *attr = &evsel->attr;
163 164 165 166 167 168 169
	int type = attr->type;
	const char *evname;

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

	if (output[type].user_set) {
170 171
		if (allow_user_set)
			return 0;
172
		evname = perf_evsel__name(evsel);
173 174 175 176 177 178 179 180
		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;
181
	evname = perf_evsel__name(evsel);
182 183 184 185 186 187 188
	pr_debug("Samples for '%s' event do not have %s attribute set. "
		 "Skipping '%s' field.\n",
		 evname, sample_msg, output_field2str(field));

	return 0;
}

189 190 191 192 193 194 195 196
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);
}

197 198 199 200
static int perf_evsel__check_attr(struct perf_evsel *evsel,
				  struct perf_session *session)
{
	struct perf_event_attr *attr = &evsel->attr;
201 202 203 204
	bool allow_user_set;

	allow_user_set = perf_header__has_feat(&session->header,
					       HEADER_AUXTRACE);
205

206 207 208 209
	if (PRINT_FIELD(TRACE) &&
		!perf_session__has_traces(session, "record -R"))
		return -EINVAL;

210
	if (PRINT_FIELD(IP)) {
211 212
		if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
					    PERF_OUTPUT_IP))
213 214
			return -EINVAL;
	}
215 216

	if (PRINT_FIELD(ADDR) &&
217 218
		perf_evsel__do_check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR",
					   PERF_OUTPUT_ADDR, allow_user_set))
219 220 221 222 223 224
		return -EINVAL;

	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");
225 226
		return -EINVAL;
	}
227 228 229 230 231
	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
		pr_err("Display of offsets requested but symbol is not"
		       "selected.\n");
		return -EINVAL;
	}
232 233 234 235
	if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
		pr_err("Display of DSO requested but neither sample IP nor "
			   "sample address\nis selected. Hence, no addresses to convert "
		       "to DSO.\n");
236 237
		return -EINVAL;
	}
238 239 240 241 242
	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;
	}
243 244

	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
245 246
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
					PERF_OUTPUT_TID|PERF_OUTPUT_PID))
247 248 249
		return -EINVAL;

	if (PRINT_FIELD(TIME) &&
250 251
		perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME",
					PERF_OUTPUT_TIME))
252 253 254
		return -EINVAL;

	if (PRINT_FIELD(CPU) &&
255 256
		perf_evsel__do_check_stype(evsel, PERF_SAMPLE_CPU, "CPU",
					   PERF_OUTPUT_CPU, allow_user_set))
257
		return -EINVAL;
258

J
Jiri Olsa 已提交
259 260 261 262 263
	if (PRINT_FIELD(PERIOD) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_PERIOD, "PERIOD",
					PERF_OUTPUT_PERIOD))
		return -EINVAL;

264 265 266 267 268
	if (PRINT_FIELD(IREGS) &&
		perf_evsel__check_stype(evsel, PERF_SAMPLE_REGS_INTR, "IREGS",
					PERF_OUTPUT_IREGS))
		return -EINVAL;

269 270 271
	return 0;
}

272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
static void set_print_ip_opts(struct perf_event_attr *attr)
{
	unsigned int type = attr->type;

	output[type].print_ip_opts = 0;
	if (PRINT_FIELD(IP))
		output[type].print_ip_opts |= PRINT_IP_OPT_IP;

	if (PRINT_FIELD(SYM))
		output[type].print_ip_opts |= PRINT_IP_OPT_SYM;

	if (PRINT_FIELD(DSO))
		output[type].print_ip_opts |= PRINT_IP_OPT_DSO;

	if (PRINT_FIELD(SYMOFFSET))
		output[type].print_ip_opts |= PRINT_IP_OPT_SYMOFFSET;
288 289 290

	if (PRINT_FIELD(SRCLINE))
		output[type].print_ip_opts |= PRINT_IP_OPT_SRCLINE;
291 292
}

293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
/*
 * verify all user requested events exist and the samples
 * have the expected data
 */
static int perf_session__check_output_opt(struct perf_session *session)
{
	int j;
	struct perf_evsel *evsel;

	for (j = 0; j < PERF_TYPE_MAX; ++j) {
		evsel = perf_session__find_first_evtype(session, j);

		/*
		 * even if fields is set to 0 (ie., show nothing) event must
		 * exist if user explicitly includes it on the command line
		 */
		if (!evsel && output[j].user_set && !output[j].wildcard_set) {
			pr_err("%s events do not exist. "
			       "Remove corresponding -f option to proceed.\n",
			       event_type(j));
			return -1;
		}

		if (evsel && output[j].fields &&
			perf_evsel__check_attr(evsel, session))
			return -1;
319 320 321 322

		if (evsel == NULL)
			continue;

323
		set_print_ip_opts(&evsel->attr);
324 325
	}

326 327 328 329 330 331 332 333 334 335 336 337 338
	if (!no_callchain) {
		bool use_callchain = false;

		evlist__for_each(session->evlist, evsel) {
			if (evsel->attr.sample_type & PERF_SAMPLE_CALLCHAIN) {
				use_callchain = true;
				break;
			}
		}
		if (!use_callchain)
			symbol_conf.use_callchain = false;
	}

339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
	/*
	 * 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;
		evsel = perf_session__find_first_evtype(session, j);
		if (evsel == NULL)
			goto out;

		attr = &evsel->attr;

		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);
		}
	}

out:
363 364
	return 0;
}
365

366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
static void print_sample_iregs(union perf_event *event __maybe_unused,
			  struct perf_sample *sample,
			  struct thread *thread __maybe_unused,
			  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);
	}
}

384
static void print_sample_start(struct perf_sample *sample,
385
			       struct thread *thread,
386
			       struct perf_evsel *evsel)
387
{
388
	struct perf_event_attr *attr = &evsel->attr;
389 390
	unsigned long secs;
	unsigned long usecs;
391 392 393 394
	unsigned long long nsecs;

	if (PRINT_FIELD(COMM)) {
		if (latency_format)
395
			printf("%8.8s ", thread__comm_str(thread));
396
		else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
397
			printf("%s ", thread__comm_str(thread));
398
		else
399
			printf("%16s ", thread__comm_str(thread));
400
	}
401

402 403 404 405 406 407 408 409 410 411 412 413 414
	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);
	}
415

416 417 418 419 420
	if (PRINT_FIELD(TIME)) {
		nsecs = sample->time;
		secs = nsecs / NSECS_PER_SEC;
		nsecs -= secs * NSECS_PER_SEC;
		usecs = nsecs / NSECS_PER_USEC;
421 422 423 424
		if (nanosecs)
			printf("%5lu.%09llu: ", secs, nsecs);
		else
			printf("%5lu.%06lu: ", secs, usecs);
425
	}
426 427
}

428 429 430 431 432 433 434 435 436 437 438 439
static void print_sample_addr(union perf_event *event,
			  struct perf_sample *sample,
			  struct thread *thread,
			  struct perf_event_attr *attr)
{
	struct addr_location al;

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

	if (!sample_addr_correlates_sym(attr))
		return;

440
	perf_event__preprocess_sample_addr(event, sample, thread, &al);
441 442

	if (PRINT_FIELD(SYM)) {
443
		printf(" ");
444 445 446 447
		if (PRINT_FIELD(SYMOFFSET))
			symbol__fprintf_symname_offs(al.sym, &al, stdout);
		else
			symbol__fprintf_symname(al.sym, stdout);
448 449 450
	}

	if (PRINT_FIELD(DSO)) {
451 452 453
		printf(" (");
		map__fprintf_dsoname(al.map, stdout);
		printf(")");
454 455 456
	}
}

457 458 459
static void print_sample_bts(union perf_event *event,
			     struct perf_sample *sample,
			     struct perf_evsel *evsel,
460 461
			     struct thread *thread,
			     struct addr_location *al)
462 463
{
	struct perf_event_attr *attr = &evsel->attr;
464
	bool print_srcline_last = false;
465 466 467

	/* print branch_from information */
	if (PRINT_FIELD(IP)) {
468 469 470
		unsigned int print_opts = output[attr->type].print_ip_opts;

		if (symbol_conf.use_callchain && sample->callchain) {
471
			printf("\n");
472 473 474 475 476 477 478 479
		} else {
			printf(" ");
			if (print_opts & PRINT_IP_OPT_SRCLINE) {
				print_srcline_last = true;
				print_opts &= ~PRINT_IP_OPT_SRCLINE;
			}
		}
		perf_evsel__print_ip(evsel, sample, al, print_opts,
480
				     scripting_max_stack);
481 482 483
	}

	/* print branch_to information */
484 485
	if (PRINT_FIELD(ADDR) ||
	    ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
486 487
	     !output[attr->type].user_set)) {
		printf(" => ");
488
		print_sample_addr(event, sample, thread, attr);
489
	}
490

491 492 493
	if (print_srcline_last)
		map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);

494 495 496
	printf("\n");
}

497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515
static void print_sample_flags(u32 flags)
{
	const char *chars = PERF_IP_FLAG_CHARS;
	const int n = strlen(PERF_IP_FLAG_CHARS);
	char str[33];
	int i, pos = 0;

	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;
	printf("  %-4s ", str);
}

516
static void process_event(union perf_event *event, struct perf_sample *sample,
517
			  struct perf_evsel *evsel, struct addr_location *al)
518
{
519
	struct thread *thread = al->thread;
520
	struct perf_event_attr *attr = &evsel->attr;
521

522
	if (output[attr->type].fields == 0)
523 524
		return;

525
	print_sample_start(sample, thread, evsel);
526

J
Jiri Olsa 已提交
527 528 529
	if (PRINT_FIELD(PERIOD))
		printf("%10" PRIu64 " ", sample->period);

530 531 532 533 534
	if (PRINT_FIELD(EVNAME)) {
		const char *evname = perf_evsel__name(evsel);
		printf("%s: ", evname ? evname : "[unknown]");
	}

535 536 537
	if (print_flags)
		print_sample_flags(sample->flags);

538
	if (is_bts_event(attr)) {
539
		print_sample_bts(event, sample, evsel, thread, al);
540 541 542
		return;
	}

543
	if (PRINT_FIELD(TRACE))
544 545
		event_format__print(evsel->tp_format, sample->cpu,
				    sample->raw_data, sample->raw_size);
546
	if (PRINT_FIELD(ADDR))
547
		print_sample_addr(event, sample, thread, attr);
548

549
	if (PRINT_FIELD(IP)) {
550 551 552 553
		if (!symbol_conf.use_callchain)
			printf(" ");
		else
			printf("\n");
554

555
		perf_evsel__print_ip(evsel, sample, al,
556
				     output[attr->type].print_ip_opts,
557
				     scripting_max_stack);
558 559
	}

560 561 562
	if (PRINT_FIELD(IREGS))
		print_sample_iregs(event, sample, thread, attr);

563
	printf("\n");
564 565
}

566 567 568
static int default_start_script(const char *script __maybe_unused,
				int argc __maybe_unused,
				const char **argv __maybe_unused)
T
Tom Zanussi 已提交
569 570 571 572
{
	return 0;
}

573 574 575 576 577
static int default_flush_script(void)
{
	return 0;
}

T
Tom Zanussi 已提交
578 579 580 581 582
static int default_stop_script(void)
{
	return 0;
}

583 584
static int default_generate_script(struct pevent *pevent __maybe_unused,
				   const char *outfile __maybe_unused)
T
Tom Zanussi 已提交
585 586 587 588 589 590
{
	return 0;
}

static struct scripting_ops default_scripting_ops = {
	.start_script		= default_start_script,
591
	.flush_script		= default_flush_script,
T
Tom Zanussi 已提交
592
	.stop_script		= default_stop_script,
593
	.process_event		= process_event,
T
Tom Zanussi 已提交
594 595 596 597 598 599 600
	.generate_script	= default_generate_script,
};

static struct scripting_ops	*scripting_ops;

static void setup_scripting(void)
{
601
	setup_perl_scripting();
602
	setup_python_scripting();
603

T
Tom Zanussi 已提交
604 605 606
	scripting_ops = &default_scripting_ops;
}

607 608 609 610 611
static int flush_scripting(void)
{
	return scripting_ops->flush_script();
}

T
Tom Zanussi 已提交
612 613
static int cleanup_scripting(void)
{
614
	pr_debug("\nperf script stopped\n");
615

T
Tom Zanussi 已提交
616 617 618
	return scripting_ops->stop_script();
}

619
static int process_sample_event(struct perf_tool *tool __maybe_unused,
620
				union perf_event *event,
621
				struct perf_sample *sample,
622
				struct perf_evsel *evsel,
623
				struct machine *machine)
F
Frederic Weisbecker 已提交
624
{
625
	struct addr_location al;
F
Frederic Weisbecker 已提交
626

627 628 629 630 631 632
	if (debug_mode) {
		if (sample->time < last_timestamp) {
			pr_err("Samples misordered, previous: %" PRIu64
				" this: %" PRIu64 "\n", last_timestamp,
				sample->time);
			nr_unordered++;
633
		}
634 635
		last_timestamp = sample->time;
		return 0;
F
Frederic Weisbecker 已提交
636
	}
637

638
	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
639 640 641 642 643 644
		pr_err("problem processing %d event, skipping it.\n",
		       event->header.type);
		return -1;
	}

	if (al.filtered)
645
		goto out_put;
646

647
	if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
648
		goto out_put;
649

650
	scripting_ops->process_event(event, sample, evsel, &al);
651 652
out_put:
	addr_location__put(&al);
F
Frederic Weisbecker 已提交
653 654 655
	return 0;
}

656 657 658
struct perf_script {
	struct perf_tool	tool;
	struct perf_session	*session;
659
	bool			show_task_events;
660
	bool			show_mmap_events;
661
	bool			show_switch_events;
662 663
};

664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
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);

	if (evsel->attr.type >= PERF_TYPE_MAX)
		return 0;

682
	evlist__for_each(evlist, pos) {
683 684 685 686 687 688
		if (pos->attr.type == evsel->attr.type && pos != evsel)
			return 0;
	}

	set_print_ip_opts(&evsel->attr);

689 690 691 692
	if (evsel->attr.sample_type)
		err = perf_evsel__check_attr(evsel, scr->session);

	return err;
693 694
}

695 696 697 698 699 700 701 702
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;
703
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724
	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:
725
	thread__put(thread);
726 727 728 729 730 731 732 733 734 735 736
	return ret;
}

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;
737
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755

	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);
756
	thread__put(thread);
757 758 759 760 761 762 763 764

	return 0;
}
static int process_exit_event(struct perf_tool *tool,
			      union perf_event *event,
			      struct perf_sample *sample,
			      struct machine *machine)
{
765
	int err = 0;
766 767 768
	struct thread *thread;
	struct perf_script *script = container_of(tool, struct perf_script, tool);
	struct perf_session *session = script->session;
769
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
770 771 772 773 774 775 776 777 778 779

	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;
780 781
		sample->tid = event->fork.tid;
		sample->pid = event->fork.pid;
782 783 784 785 786
	}
	print_sample_start(sample, thread, evsel);
	perf_event__fprintf(event, stdout);

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

789 790
	thread__put(thread);
	return err;
791 792
}

793 794 795 796 797 798 799 800
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;
801
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819

	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);
820
	thread__put(thread);
821 822 823 824 825 826 827 828 829 830 831
	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;
832
	struct perf_evsel *evsel = perf_evlist__id2evsel(session->evlist, sample->id);
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850

	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);
851
	thread__put(thread);
852 853 854
	return 0;
}

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
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;
}

881
static void sig_handler(int sig __maybe_unused)
882 883 884 885
{
	session_done = 1;
}

886
static int __cmd_script(struct perf_script *script)
F
Frederic Weisbecker 已提交
887
{
888 889
	int ret;

890 891
	signal(SIGINT, sig_handler);

892 893 894 895 896 897
	/* 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;
	}
898 899 900 901
	if (script->show_mmap_events) {
		script->tool.mmap = process_mmap_event;
		script->tool.mmap2 = process_mmap2_event;
	}
902 903
	if (script->show_switch_events)
		script->tool.context_switch = process_switch_event;
904

905
	ret = perf_session__process_events(script->session);
906

907
	if (debug_mode)
908
		pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
909 910

	return ret;
F
Frederic Weisbecker 已提交
911 912
}

T
Tom Zanussi 已提交
913 914 915 916 917 918
struct script_spec {
	struct list_head	node;
	struct scripting_ops	*ops;
	char			spec[0];
};

919
static LIST_HEAD(script_specs);
T
Tom Zanussi 已提交
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958

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;
}

static struct script_spec *script_spec__findnew(const char *spec,
						struct scripting_ops *ops)
{
	struct script_spec *s = script_spec__find(spec);

	if (s)
		return s;

	s = script_spec__new(spec, ops);
	if (!s)
959
		return NULL;
T
Tom Zanussi 已提交
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

	script_spec__add(s);

	return s;
}

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

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

	s = script_spec__findnew(spec, ops);
	if (!s)
		return -1;

	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 "
996
		"perf script -s [spec:]script.[spec]):\n\n");
T
Tom Zanussi 已提交
997 998 999 1000 1001 1002 1003

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

	fprintf(stderr, "\n");
}

1004 1005
static int parse_scriptname(const struct option *opt __maybe_unused,
			    const char *str, int unset __maybe_unused)
T
Tom Zanussi 已提交
1006 1007 1008 1009 1010
{
	char spec[PATH_MAX];
	const char *script, *ext;
	int len;

1011
	if (strcmp(str, "lang") == 0) {
T
Tom Zanussi 已提交
1012
		list_available_languages();
1013
		exit(0);
T
Tom Zanussi 已提交
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032
	}

	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;
1033
		ext = strrchr(script, '.');
T
Tom Zanussi 已提交
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
		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;
}

1050 1051
static int parse_output_fields(const struct option *opt __maybe_unused,
			    const char *arg, int unset __maybe_unused)
1052 1053
{
	char *tok;
1054
	int i, imax = ARRAY_SIZE(all_output_options);
1055
	int j;
1056 1057
	int rc = 0;
	char *str = strdup(arg);
1058
	int type = -1;
1059 1060 1061 1062

	if (!str)
		return -ENOMEM;

1063 1064 1065
	/* 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.
1066
	 */
1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
	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;
1077 1078
		else if (!strcmp(str, "raw"))
			type = PERF_TYPE_RAW;
1079 1080
		else {
			fprintf(stderr, "Invalid event type in field string.\n");
1081 1082
			rc = -EINVAL;
			goto out;
1083 1084 1085 1086 1087 1088 1089 1090
		}

		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;
1091
		output[type].wildcard_set = false;
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107

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

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

		for (j = 0; j < PERF_TYPE_MAX; ++j) {
			output[j].fields = 0;
			output[j].user_set = true;
1108
			output[j].wildcard_set = true;
1109
		}
1110 1111
	}

1112
	for (tok = strtok(tok, ","); tok; tok = strtok(NULL, ",")) {
1113
		for (i = 0; i < imax; ++i) {
1114
			if (strcmp(tok, all_output_options[i].str) == 0)
1115 1116
				break;
		}
1117 1118 1119 1120
		if (i == imax && strcmp(tok, "flags") == 0) {
			print_flags = true;
			continue;
		}
1121
		if (i == imax) {
1122
			fprintf(stderr, "Invalid field requested.\n");
1123
			rc = -EINVAL;
1124
			goto out;
1125 1126
		}

1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
		if (type == -1) {
			/* add user option to all events types for
			 * which it is valid
			 */
			for (j = 0; j < PERF_TYPE_MAX; ++j) {
				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));
				} else
					output[j].fields |= all_output_options[i].field;
			}
		} 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;
		}
1148 1149
	}

1150 1151 1152 1153 1154 1155
	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));
		}
	}
1156

1157
out:
1158 1159 1160 1161
	free(str);
	return rc;
}

1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175
/* 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);
}

#define for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next)\
1176 1177
	while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&	\
	       lang_next)						\
1178 1179 1180
		if ((lang_dirent.d_type == DT_DIR ||			\
		     (lang_dirent.d_type == DT_UNKNOWN &&		\
		      is_directory(scripts_path, &lang_dirent))) &&	\
1181 1182 1183
		    (strcmp(lang_dirent.d_name, ".")) &&		\
		    (strcmp(lang_dirent.d_name, "..")))

1184
#define for_each_script(lang_path, lang_dir, script_dirent, script_next)\
1185 1186
	while (!readdir_r(lang_dir, &script_dirent, &script_next) &&	\
	       script_next)						\
1187 1188 1189
		if (script_dirent.d_type != DT_DIR &&			\
		    (script_dirent.d_type != DT_UNKNOWN ||		\
		     !is_directory(lang_path, &script_dirent)))
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201


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

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

1202
static LIST_HEAD(script_descs);
1203 1204 1205 1206 1207

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

1208
	if (s != NULL && name)
1209 1210 1211 1212 1213 1214 1215
		s->name = strdup(name);

	return s;
}

static void script_desc__delete(struct script_desc *s)
{
1216 1217 1218
	zfree(&s->name);
	zfree(&s->half_liner);
	zfree(&s->args);
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
	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)
		goto out_delete_desc;

	script_desc__add(s);

	return s;

out_delete_desc:
	script_desc__delete(s);

	return NULL;
}

1258
static const char *ends_with(const char *str, const char *suffix)
1259 1260
{
	size_t suffix_len = strlen(suffix);
1261
	const char *p = str;
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 1309 1310 1311 1312

	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;
}

1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330
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;
}

1331 1332 1333
static int list_available_scripts(const struct option *opt __maybe_unused,
				  const char *s __maybe_unused,
				  int unset __maybe_unused)
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
	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;

	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

	scripts_dir = opendir(scripts_path);
	if (!scripts_dir)
		return -1;

1350
	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
1351 1352 1353 1354 1355 1356
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

1357
		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
1358 1359
			script_root = get_script_root(&script_dirent, REPORT_SUFFIX);
			if (script_root) {
1360 1361 1362 1363
				desc = script_desc__findnew(script_root);
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
				read_script_info(desc, script_path);
1364
				free(script_root);
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379
			}
		}
	}

	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);
}

1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422
/*
 * 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;
1423
			evlist__for_each(session->evlist, pos) {
1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
				if (!strcmp(perf_evsel__name(pos), evname)) {
					match = 1;
					break;
				}
			}

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

	fclose(fp);
	return 0;
}

1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
/*
 * 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)
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
1451
	char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
1452
	DIR *scripts_dir, *lang_dir;
1453
	struct perf_session *session;
1454 1455 1456 1457
	struct perf_data_file file = {
		.path = input_name,
		.mode = PERF_DATA_MODE_READ,
	};
1458 1459 1460
	char *temp;
	int i = 0;

1461
	session = perf_session__new(&file, false, NULL);
1462 1463 1464
	if (!session)
		return -1;

1465 1466 1467
	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

	scripts_dir = opendir(scripts_path);
1468 1469
	if (!scripts_dir) {
		perf_session__delete(session);
1470
		return -1;
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

	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
		snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
			 lang_dirent.d_name);
#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;

		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
			/* Skip those real time scripts: xxxtop.p[yl] */
			if (strstr(script_dirent.d_name, "top."))
				continue;
			sprintf(scripts_path_array[i], "%s/%s", lang_path,
				script_dirent.d_name);
			temp = strchr(script_dirent.d_name, '.');
			snprintf(scripts_array[i],
				(temp - script_dirent.d_name) + 1,
				"%s", script_dirent.d_name);
1499 1500 1501 1502 1503

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

1504 1505
			i++;
		}
1506
		closedir(lang_dir);
1507 1508
	}

1509 1510
	closedir(scripts_dir);
	perf_session__delete(session);
1511 1512 1513
	return i;
}

1514 1515 1516 1517 1518 1519 1520
static char *get_script_path(const char *script_root, const char *suffix)
{
	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
	char scripts_path[MAXPATHLEN];
	char script_path[MAXPATHLEN];
	DIR *scripts_dir, *lang_dir;
	char lang_path[MAXPATHLEN];
1521
	char *__script_root;
1522 1523 1524 1525 1526 1527 1528

	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());

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

1529
	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
1530 1531 1532 1533 1534 1535
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

1536
		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
1537 1538 1539
			__script_root = get_script_root(&script_dirent, suffix);
			if (__script_root && !strcmp(script_root, __script_root)) {
				free(__script_root);
1540 1541
				closedir(lang_dir);
				closedir(scripts_dir);
1542 1543
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
1544
				return strdup(script_path);
1545 1546 1547
			}
			free(__script_root);
		}
1548
		closedir(lang_dir);
1549
	}
1550
	closedir(scripts_dir);
1551

1552
	return NULL;
1553 1554
}

1555 1556
static bool is_top_script(const char *script_path)
{
1557
	return ends_with(script_path, "top") == NULL ? false : true;
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
}

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;
}

1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
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 已提交
1596

1597 1598 1599 1600 1601
	system_wide = (argc == 0);

	return 0;
}

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617
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;
	}
}

1618 1619 1620
int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
{
	bool show_full_info = false;
1621 1622
	bool header = false;
	bool header_only = false;
1623
	bool script_started = false;
1624 1625 1626
	char *rec_script_path = NULL;
	char *rep_script_path = NULL;
	struct perf_session *session;
1627
	struct itrace_synth_opts itrace_synth_opts = { .set = false, };
1628 1629
	char *script_path = NULL;
	const char **__argv;
1630
	int i, j, err = 0;
1631 1632 1633 1634 1635 1636 1637 1638
	struct perf_script script = {
		.tool = {
			.sample		 = process_sample_event,
			.mmap		 = perf_event__process_mmap,
			.mmap2		 = perf_event__process_mmap2,
			.comm		 = perf_event__process_comm,
			.exit		 = perf_event__process_exit,
			.fork		 = perf_event__process_fork,
1639
			.attr		 = process_attr,
1640 1641
			.tracing_data	 = perf_event__process_tracing_data,
			.build_id	 = perf_event__process_build_id,
1642 1643 1644 1645
			.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,
1646
			.ordered_events	 = true,
1647 1648 1649
			.ordering_requires_timestamps = true,
		},
	};
1650 1651 1652
	struct perf_data_file file = {
		.mode = PERF_DATA_MODE_READ,
	};
1653
	const struct option options[] = {
F
Frederic Weisbecker 已提交
1654 1655
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
1656
	OPT_INCR('v', "verbose", &verbose,
1657
		 "be more verbose (show symbol address, etc)"),
1658
	OPT_BOOLEAN('L', "Latency", &latency_format,
1659
		    "show latency attributes (irqs/preemption disabled, etc)"),
1660 1661
	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
			   list_available_scripts),
T
Tom Zanussi 已提交
1662 1663 1664 1665
	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",
1666
		   "generate perf-script.xx script in specified language"),
1667
	OPT_STRING('i', "input", &input_name, "file", "input file name"),
1668 1669
	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
		   "do various checks like samples ordering and lost events"),
1670 1671
	OPT_BOOLEAN(0, "header", &header, "Show data header."),
	OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
1672 1673 1674 1675 1676 1677 1678 1679
	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"),
	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
		    "Look for files with symbols relative to this directory"),
1680
	OPT_CALLBACK('F', "fields", NULL, "str",
1681 1682 1683
		     "comma separated output fields prepend with 'type:'. "
		     "Valid types: hw,sw,trace,raw. "
		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
1684
		     "addr,symoff,period,iregs,flags", parse_output_fields),
1685
	OPT_BOOLEAN('a', "all-cpus", &system_wide,
1686
		    "system-wide collection from all CPUs"),
1687 1688
	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
		   "only consider these symbols"),
1689
	OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
1690 1691
	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
		   "only display events for these comms"),
1692 1693 1694 1695
	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"),
1696 1697
	OPT_BOOLEAN('I', "show-info", &show_full_info,
		    "display extended information from perf.data file"),
1698 1699
	OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
		    "Show the path of [kernel.kallsyms]"),
1700 1701
	OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
		    "Show the fork/comm/exit events"),
1702 1703
	OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
		    "Show the mmap events"),
1704 1705
	OPT_BOOLEAN('\0', "show-switch-events", &script.show_switch_events,
		    "Show context switch events (if recorded)"),
1706
	OPT_BOOLEAN('f', "force", &file.force, "don't complain, do it"),
1707 1708
	OPT_BOOLEAN(0, "ns", &nanosecs,
		    "Use 9 decimal places when displaying time"),
1709 1710 1711
	OPT_CALLBACK_OPTARG(0, "itrace", &itrace_synth_opts, NULL, "opts",
			    "Instruction Tracing options",
			    itrace_parse_synth_opts),
1712 1713
	OPT_BOOLEAN(0, "full-source-path", &srcline_full_filename,
			"Show full source file name path for source lines"),
1714 1715 1716 1717 1718
	OPT_BOOLEAN(0, "demangle", &symbol_conf.demangle,
			"Enable symbol demangling"),
	OPT_BOOLEAN(0, "demangle-kernel", &symbol_conf.demangle_kernel,
			"Enable kernel symbol demangling"),

1719
	OPT_END()
1720
	};
1721 1722
	const char * const script_subcommands[] = { "record", "report", NULL };
	const char *script_usage[] = {
1723 1724 1725 1726 1727 1728 1729
		"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
	};
1730

1731 1732
	setup_scripting();

1733
	argc = parse_options_subcommand(argc, argv, options, script_subcommands, script_usage,
1734 1735
			     PARSE_OPT_STOP_AT_NON_OPTION);

1736 1737
	file.path = input_name;

1738 1739 1740 1741
	if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
		rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
		if (!rec_script_path)
			return cmd_record(argc, argv, NULL);
1742 1743
	}

1744 1745 1746
	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
		if (!rep_script_path) {
1747
			fprintf(stderr,
1748
				"Please specify a valid report script"
1749
				"(see 'perf script -l' for listing)\n");
1750 1751 1752 1753
			return -1;
		}
	}

1754 1755 1756 1757
	if (itrace_synth_opts.callchain &&
	    itrace_synth_opts.callchain_sz > scripting_max_stack)
		scripting_max_stack = itrace_synth_opts.callchain_sz;

1758 1759 1760
	/* make sure PERF_EXEC_PATH is set for scripts */
	perf_set_argv_exec_path(perf_exec_path());

1761
	if (argc && !script_name && !rec_script_path && !rep_script_path) {
1762
		int live_pipe[2];
1763
		int rep_args;
1764 1765
		pid_t pid;

1766 1767 1768 1769 1770
		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) {
			fprintf(stderr, " Couldn't find script %s\n\n See perf"
1771 1772
				" script -l for available scripts.\n", argv[0]);
			usage_with_options(script_usage, options);
1773 1774
		}

1775 1776 1777 1778 1779 1780 1781 1782 1783
		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) {
				fprintf(stderr, " %s script requires options."
1784
					"\n\n See perf script -l for available "
1785
					"scripts and options.\n", argv[0]);
1786
				usage_with_options(script_usage, options);
1787
			}
1788 1789 1790 1791
		}

		if (pipe(live_pipe) < 0) {
			perror("failed to create pipe");
1792
			return -1;
1793 1794 1795 1796 1797
		}

		pid = fork();
		if (pid < 0) {
			perror("failed to fork");
1798
			return -1;
1799 1800 1801
		}

		if (!pid) {
1802 1803
			j = 0;

1804 1805 1806
			dup2(live_pipe[1], 1);
			close(live_pipe[0]);

1807 1808 1809
			if (is_top_script(argv[0])) {
				system_wide = true;
			} else if (!system_wide) {
1810 1811 1812 1813
				if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
					err = -1;
					goto out;
				}
1814
			}
1815 1816

			__argv = malloc((argc + 6) * sizeof(const char *));
1817 1818 1819 1820 1821
			if (!__argv) {
				pr_err("malloc failed\n");
				err = -ENOMEM;
				goto out;
			}
1822

1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
			__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;
1833 1834

			execvp("/bin/sh", (char **)__argv);
1835
			free(__argv);
1836 1837 1838 1839 1840 1841
			exit(-1);
		}

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

1842
		__argv = malloc((argc + 4) * sizeof(const char *));
1843 1844 1845 1846 1847 1848
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

1849 1850 1851 1852 1853 1854 1855 1856
		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;
1857 1858

		execvp("/bin/sh", (char **)__argv);
1859
		free(__argv);
1860 1861 1862
		exit(-1);
	}

1863 1864 1865 1866
	if (rec_script_path)
		script_path = rec_script_path;
	if (rep_script_path)
		script_path = rep_script_path;
1867

1868 1869
	if (script_path) {
		j = 0;
1870

1871 1872
		if (!rec_script_path)
			system_wide = false;
1873 1874 1875 1876 1877 1878
		else if (!system_wide) {
			if (have_cmd(argc - 1, &argv[1]) != 0) {
				err = -1;
				goto out;
			}
		}
1879

1880
		__argv = malloc((argc + 2) * sizeof(const char *));
1881 1882 1883 1884 1885 1886
		if (!__argv) {
			pr_err("malloc failed\n");
			err = -ENOMEM;
			goto out;
		}

1887 1888 1889 1890
		__argv[j++] = "/bin/sh";
		__argv[j++] = script_path;
		if (system_wide)
			__argv[j++] = "-a";
1891
		for (i = 2; i < argc; i++)
1892 1893
			__argv[j++] = argv[i];
		__argv[j++] = NULL;
1894 1895

		execvp("/bin/sh", (char **)__argv);
1896
		free(__argv);
1897 1898
		exit(-1);
	}
T
Tom Zanussi 已提交
1899

1900 1901
	if (!script_name)
		setup_pager();
F
Frederic Weisbecker 已提交
1902

1903
	session = perf_session__new(&file, false, &script.tool);
1904
	if (session == NULL)
1905
		return -1;
1906

1907 1908 1909
	if (header || header_only) {
		perf_session__fprintf_info(session, stdout, show_full_info);
		if (header_only)
1910
			goto out_delete;
1911 1912
	}

1913
	if (symbol__init(&session->header.env) < 0)
1914 1915
		goto out_delete;

1916
	script.session = session;
1917
	script__setup_sample_type(&script);
1918

1919 1920
	session->itrace_synth_opts = &itrace_synth_opts;

1921
	if (cpu_list) {
1922 1923 1924
		err = perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap);
		if (err < 0)
			goto out_delete;
1925 1926
	}

1927
	if (!no_callchain)
1928 1929 1930 1931
		symbol_conf.use_callchain = true;
	else
		symbol_conf.use_callchain = false;

1932 1933
	if (session->tevent.pevent &&
	    pevent_set_function_resolver(session->tevent.pevent,
1934 1935 1936 1937 1938 1939
					 machine__resolve_kernel_addr,
					 &session->machines.host) < 0) {
		pr_err("%s: failed to set libtraceevent function resolver\n", __func__);
		return -1;
	}

T
Tom Zanussi 已提交
1940 1941
	if (generate_script_lang) {
		struct stat perf_stat;
1942 1943
		int input;

1944
		if (output_set_by_user()) {
1945 1946
			fprintf(stderr,
				"custom fields not supported for generated scripts");
1947 1948
			err = -EINVAL;
			goto out_delete;
1949
		}
T
Tom Zanussi 已提交
1950

1951
		input = open(file.path, O_RDONLY);	/* input_name */
T
Tom Zanussi 已提交
1952
		if (input < 0) {
1953
			err = -errno;
T
Tom Zanussi 已提交
1954
			perror("failed to open file");
1955
			goto out_delete;
T
Tom Zanussi 已提交
1956 1957 1958 1959 1960
		}

		err = fstat(input, &perf_stat);
		if (err < 0) {
			perror("failed to stat file");
1961
			goto out_delete;
T
Tom Zanussi 已提交
1962 1963 1964 1965
		}

		if (!perf_stat.st_size) {
			fprintf(stderr, "zero-sized file, nothing to do!\n");
1966
			goto out_delete;
T
Tom Zanussi 已提交
1967 1968 1969 1970 1971
		}

		scripting_ops = script_spec__lookup(generate_script_lang);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
1972 1973
			err = -ENOENT;
			goto out_delete;
T
Tom Zanussi 已提交
1974 1975
		}

J
Jiri Olsa 已提交
1976
		err = scripting_ops->generate_script(session->tevent.pevent,
1977
						     "perf-script");
1978
		goto out_delete;
T
Tom Zanussi 已提交
1979 1980 1981
	}

	if (script_name) {
1982
		err = scripting_ops->start_script(script_name, argc, argv);
T
Tom Zanussi 已提交
1983
		if (err)
1984
			goto out_delete;
1985
		pr_debug("perf script started with script %s\n\n", script_name);
1986
		script_started = true;
T
Tom Zanussi 已提交
1987 1988
	}

1989 1990 1991

	err = perf_session__check_output_opt(session);
	if (err < 0)
1992
		goto out_delete;
1993

1994
	err = __cmd_script(&script);
T
Tom Zanussi 已提交
1995

1996 1997
	flush_scripting();

1998
out_delete:
1999
	perf_session__delete(session);
2000 2001 2002

	if (script_started)
		cleanup_scripting();
T
Tom Zanussi 已提交
2003 2004
out:
	return err;
F
Frederic Weisbecker 已提交
2005
}