builtin-script.c 18.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 9
#include "util/debug.h"
#include "util/exec_cmd.h"
#include "util/header.h"
#include "util/parse-options.h"
#include "util/session.h"
F
Frederic Weisbecker 已提交
10 11
#include "util/symbol.h"
#include "util/thread.h"
I
Ingo Molnar 已提交
12
#include "util/trace-event.h"
13
#include "util/parse-options.h"
A
Andrea Gelmini 已提交
14
#include "util/util.h"
F
Frederic Weisbecker 已提交
15

T
Tom Zanussi 已提交
16 17
static char const		*script_name;
static char const		*generate_script_lang;
18
static bool			debug_mode;
19
static u64			last_timestamp;
20
static u64			nr_unordered;
21
extern const struct option	record_options[];
T
Tom Zanussi 已提交
22

23 24 25
static int default_start_script(const char *script __unused,
				int argc __unused,
				const char **argv __unused)
T
Tom Zanussi 已提交
26 27 28 29 30 31 32 33 34
{
	return 0;
}

static int default_stop_script(void)
{
	return 0;
}

35
static int default_generate_script(const char *outfile __unused)
T
Tom Zanussi 已提交
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
{
	return 0;
}

static struct scripting_ops default_scripting_ops = {
	.start_script		= default_start_script,
	.stop_script		= default_stop_script,
	.process_event		= print_event,
	.generate_script	= default_generate_script,
};

static struct scripting_ops	*scripting_ops;

static void setup_scripting(void)
{
51
	setup_perl_scripting();
52
	setup_python_scripting();
53

T
Tom Zanussi 已提交
54 55 56 57 58
	scripting_ops = &default_scripting_ops;
}

static int cleanup_scripting(void)
{
59
	pr_debug("\nperf script stopped\n");
60

T
Tom Zanussi 已提交
61 62 63 64
	return scripting_ops->stop_script();
}

static char const		*input_name = "perf.data";
F
Frederic Weisbecker 已提交
65

66 67
static int process_sample_event(event_t *event, struct sample_data *sample,
				struct perf_session *session)
F
Frederic Weisbecker 已提交
68
{
69
	struct thread *thread = perf_session__findnew(session, event->ip.pid);
70

F
Frederic Weisbecker 已提交
71
	if (thread == NULL) {
72 73
		pr_debug("problem processing %d event, skipping it.\n",
			 event->header.type);
F
Frederic Weisbecker 已提交
74 75 76
		return -1;
	}

77
	if (session->sample_type & PERF_SAMPLE_RAW) {
78
		if (debug_mode) {
79
			if (sample->time < last_timestamp) {
80 81
				pr_err("Samples misordered, previous: %llu "
					"this: %llu\n", last_timestamp,
82
					sample->time);
83
				nr_unordered++;
84
			}
85
			last_timestamp = sample->time;
86
			return 0;
87
		}
F
Frederic Weisbecker 已提交
88 89 90 91 92
		/*
		 * FIXME: better resolve from pid from the struct trace_entry
		 * field, although it should be the same than this perf
		 * event pid
		 */
93 94 95
		scripting_ops->process_event(sample->cpu, sample->raw_data,
					     sample->raw_size,
					     sample->time, thread->comm);
F
Frederic Weisbecker 已提交
96 97
	}

98
	session->hists.stats.total_period += sample->period;
F
Frederic Weisbecker 已提交
99 100 101
	return 0;
}

102 103
static u64 nr_lost;

104 105
static int process_lost_event(event_t *event, struct sample_data *sample __used,
			      struct perf_session *session __used)
106 107 108 109 110 111
{
	nr_lost += event->lost.lost;

	return 0;
}

112
static struct perf_event_ops event_ops = {
113 114
	.sample	= process_sample_event,
	.comm	= event__process_comm,
115
	.attr	= event__process_attr,
116
	.event_type = event__process_event_type,
117
	.tracing_data = event__process_tracing_data,
118
	.build_id = event__process_build_id,
119
	.lost = process_lost_event,
120
	.ordered_samples = true,
121 122
};

123 124 125 126 127 128 129
extern volatile int session_done;

static void sig_handler(int sig __unused)
{
	session_done = 1;
}

130
static int __cmd_script(struct perf_session *session)
F
Frederic Weisbecker 已提交
131
{
132 133
	int ret;

134 135
	signal(SIGINT, sig_handler);

136 137
	ret = perf_session__process_events(session, &event_ops);

138
	if (debug_mode) {
139
		pr_err("Misordered timestamps: %llu\n", nr_unordered);
140 141
		pr_err("Lost events: %llu\n", nr_lost);
	}
142 143

	return ret;
F
Frederic Weisbecker 已提交
144 145
}

T
Tom Zanussi 已提交
146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
struct script_spec {
	struct list_head	node;
	struct scripting_ops	*ops;
	char			spec[0];
};

LIST_HEAD(script_specs);

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__delete(struct script_spec *s)
{
	free(s->spec);
	free(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)
		goto out_delete_spec;

	script_spec__add(s);

	return s;

out_delete_spec:
	script_spec__delete(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;

	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 "
240
		"perf script -s [spec:]script.[spec]):\n\n");
T
Tom Zanussi 已提交
241 242 243 244 245 246 247 248 249 250 251 252 253 254

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

	fprintf(stderr, "\n");
}

static int parse_scriptname(const struct option *opt __used,
			    const char *str, int unset __used)
{
	char spec[PATH_MAX];
	const char *script, *ext;
	int len;

255
	if (strcmp(str, "lang") == 0) {
T
Tom Zanussi 已提交
256
		list_available_languages();
257
		exit(0);
T
Tom Zanussi 已提交
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	}

	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;
277
		ext = strrchr(script, '.');
T
Tom Zanussi 已提交
278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
		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;
}

294 295 296 297 298 299 300 301 302 303 304 305 306 307
/* 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)\
308 309
	while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&	\
	       lang_next)						\
310 311 312
		if ((lang_dirent.d_type == DT_DIR ||			\
		     (lang_dirent.d_type == DT_UNKNOWN &&		\
		      is_directory(scripts_path, &lang_dirent))) &&	\
313 314 315
		    (strcmp(lang_dirent.d_name, ".")) &&		\
		    (strcmp(lang_dirent.d_name, "..")))

316
#define for_each_script(lang_path, lang_dir, script_dirent, script_next)\
317 318
	while (!readdir_r(lang_dir, &script_dirent, &script_next) &&	\
	       script_next)						\
319 320 321
		if (script_dirent.d_type != DT_DIR &&			\
		    (script_dirent.d_type != DT_UNKNOWN ||		\
		     !is_directory(lang_path, &script_dirent)))
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339


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

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

LIST_HEAD(script_descs);

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

340
	if (s != NULL && name)
341 342 343 344 345 346 347 348
		s->name = strdup(name);

	return s;
}

static void script_desc__delete(struct script_desc *s)
{
	free(s->name);
349 350
	free(s->half_liner);
	free(s->args);
351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
	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;
}

static char *ends_with(char *str, const char *suffix)
{
	size_t suffix_len = strlen(suffix);
	char *p = str;

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

	return NULL;
}

static char *ltrim(char *str)
{
	int len = strlen(str);

	while (len && isspace(*str)) {
		len--;
		str++;
	}

	return str;
}

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

static int list_available_scripts(const struct option *opt __used,
				  const char *s __used, int unset __used)
{
	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;
	char *str;

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

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

476
	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
477 478 479 480 481 482
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

483
		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507
			script_root = strdup(script_dirent.d_name);
			str = ends_with(script_root, REPORT_SUFFIX);
			if (str) {
				*str = '\0';
				desc = script_desc__findnew(script_root);
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
				read_script_info(desc, script_path);
			}
			free(script_root);
		}
	}

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

508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
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];
	char *str, *__script_root;
	char *path = NULL;

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

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

524
	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
525 526 527 528 529 530
		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
			 lang_dirent.d_name);
		lang_dir = opendir(lang_path);
		if (!lang_dir)
			continue;

531
		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550
			__script_root = strdup(script_dirent.d_name);
			str = ends_with(__script_root, suffix);
			if (str) {
				*str = '\0';
				if (strcmp(__script_root, script_root))
					continue;
				snprintf(script_path, MAXPATHLEN, "%s/%s",
					 lang_path, script_dirent.d_name);
				path = strdup(script_path);
				free(__script_root);
				break;
			}
			free(__script_root);
		}
	}

	return path;
}

551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
static bool is_top_script(const char *script_path)
{
	return ends_with((char *)script_path, "top") == NULL ? false : true;
}

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

579 580 581 582 583 584
static const char * const script_usage[] = {
	"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]",
F
Frederic Weisbecker 已提交
585 586 587 588 589 590
	NULL
};

static const struct option options[] = {
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
591
	OPT_INCR('v', "verbose", &verbose,
F
Frederic Weisbecker 已提交
592
		    "be more verbose (show symbol address, etc)"),
593
	OPT_BOOLEAN('L', "Latency", &latency_format,
594
		    "show latency attributes (irqs/preemption disabled, etc)"),
595 596
	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
			   list_available_scripts),
T
Tom Zanussi 已提交
597 598 599 600
	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",
601
		   "generate perf-script.xx script in specified language"),
602 603
	OPT_STRING('i', "input", &input_name, "file",
		    "input file name"),
604 605
	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
		   "do various checks like samples ordering and lost events"),
T
Tom Zanussi 已提交
606

607
	OPT_END()
F
Frederic Weisbecker 已提交
608 609
};

610 611 612 613 614 615 616 617 618 619 620 621 622 623
static bool have_cmd(int argc, const char **argv)
{
	char **__argv = malloc(sizeof(const char *) * argc);

	if (!__argv)
		die("malloc");
	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);

	return argc != 0;
}

624
int cmd_script(int argc, const char **argv, const char *prefix __used)
F
Frederic Weisbecker 已提交
625
{
626 627
	char *rec_script_path = NULL;
	char *rep_script_path = NULL;
628
	struct perf_session *session;
629
	char *script_path = NULL;
630
	const char **__argv;
631 632
	bool system_wide;
	int i, j, err;
633

634 635
	setup_scripting();

636
	argc = parse_options(argc, argv, options, script_usage,
637 638 639 640 641 642
			     PARSE_OPT_STOP_AT_NON_OPTION);

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

645 646 647
	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
		if (!rep_script_path) {
648
			fprintf(stderr,
649
				"Please specify a valid report script"
650
				"(see 'perf script -l' for listing)\n");
651 652 653 654
			return -1;
		}
	}

655 656 657
	/* make sure PERF_EXEC_PATH is set for scripts */
	perf_set_argv_exec_path(perf_exec_path());

658
	if (argc && !script_name && !rec_script_path && !rep_script_path) {
659
		int live_pipe[2];
660
		int rep_args;
661 662
		pid_t pid;

663 664 665 666 667
		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"
668 669
				" script -l for available scripts.\n", argv[0]);
			usage_with_options(script_usage, options);
670 671
		}

672 673 674 675 676 677 678 679 680
		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."
681
					"\n\n See perf script -l for available "
682
					"scripts and options.\n", argv[0]);
683
				usage_with_options(script_usage, options);
684
			}
685 686 687 688 689 690 691 692 693 694 695 696 697 698
		}

		if (pipe(live_pipe) < 0) {
			perror("failed to create pipe");
			exit(-1);
		}

		pid = fork();
		if (pid < 0) {
			perror("failed to fork");
			exit(-1);
		}

		if (!pid) {
699 700 701
			system_wide = true;
			j = 0;

702 703 704
			dup2(live_pipe[1], 1);
			close(live_pipe[0]);

705 706 707 708 709
			if (!is_top_script(argv[0]))
				system_wide = !have_cmd(argc - rep_args,
							&argv[rep_args]);

			__argv = malloc((argc + 6) * sizeof(const char *));
710 711 712
			if (!__argv)
				die("malloc");

713 714 715 716 717 718 719 720 721 722
			__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;
723 724

			execvp("/bin/sh", (char **)__argv);
725
			free(__argv);
726 727 728 729 730 731
			exit(-1);
		}

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

732
		__argv = malloc((argc + 4) * sizeof(const char *));
733 734
		if (!__argv)
			die("malloc");
735 736 737 738 739 740 741 742
		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;
743 744

		execvp("/bin/sh", (char **)__argv);
745
		free(__argv);
746 747 748
		exit(-1);
	}

749 750 751 752
	if (rec_script_path)
		script_path = rec_script_path;
	if (rep_script_path)
		script_path = rep_script_path;
753

754 755 756
	if (script_path) {
		system_wide = false;
		j = 0;
757

758 759
		if (rec_script_path)
			system_wide = !have_cmd(argc - 1, &argv[1]);
760

761
		__argv = malloc((argc + 2) * sizeof(const char *));
762 763
		if (!__argv)
			die("malloc");
764 765 766 767
		__argv[j++] = "/bin/sh";
		__argv[j++] = script_path;
		if (system_wide)
			__argv[j++] = "-a";
768
		for (i = 2; i < argc; i++)
769 770
			__argv[j++] = argv[i];
		__argv[j++] = NULL;
771 772

		execvp("/bin/sh", (char **)__argv);
773
		free(__argv);
774 775
		exit(-1);
	}
T
Tom Zanussi 已提交
776

777 778
	if (symbol__init() < 0)
		return -1;
779 780
	if (!script_name)
		setup_pager();
F
Frederic Weisbecker 已提交
781

T
Tom Zanussi 已提交
782
	session = perf_session__new(input_name, O_RDONLY, 0, false);
783 784 785
	if (session == NULL)
		return -ENOMEM;

786 787
	if (strcmp(input_name, "-") &&
	    !perf_session__has_traces(session, "record -R"))
788 789
		return -EINVAL;

T
Tom Zanussi 已提交
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
	if (generate_script_lang) {
		struct stat perf_stat;

		int input = open(input_name, O_RDONLY);
		if (input < 0) {
			perror("failed to open file");
			exit(-1);
		}

		err = fstat(input, &perf_stat);
		if (err < 0) {
			perror("failed to stat file");
			exit(-1);
		}

		if (!perf_stat.st_size) {
			fprintf(stderr, "zero-sized file, nothing to do!\n");
			exit(0);
		}

		scripting_ops = script_spec__lookup(generate_script_lang);
		if (!scripting_ops) {
			fprintf(stderr, "invalid language specifier");
			return -1;
		}

816
		err = scripting_ops->generate_script("perf-script");
T
Tom Zanussi 已提交
817 818 819 820
		goto out;
	}

	if (script_name) {
821
		err = scripting_ops->start_script(script_name, argc, argv);
T
Tom Zanussi 已提交
822 823
		if (err)
			goto out;
824
		pr_debug("perf script started with script %s\n\n", script_name);
T
Tom Zanussi 已提交
825 826
	}

827
	err = __cmd_script(session);
T
Tom Zanussi 已提交
828

829
	perf_session__delete(session);
T
Tom Zanussi 已提交
830 831 832
	cleanup_scripting();
out:
	return err;
F
Frederic Weisbecker 已提交
833
}