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