1#include "builtin.h"
   2
   3#include "perf.h"
   4#include "util/cache.h"
   5#include "util/debug.h"
   6#include "util/exec_cmd.h"
 
   7#include "util/header.h"
   8#include "util/parse-options.h"
 
   9#include "util/session.h"
  10#include "util/tool.h"
 
 
  11#include "util/symbol.h"
  12#include "util/thread.h"
  13#include "util/trace-event.h"
  14#include "util/util.h"
  15#include "util/evlist.h"
  16#include "util/evsel.h"
 
 
  17#include "util/sort.h"
  18#include "util/data.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
  19#include <linux/bitmap.h>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  20
  21static char const		*script_name;
  22static char const		*generate_script_lang;
 
 
 
 
  23static bool			debug_mode;
  24static u64			last_timestamp;
  25static u64			nr_unordered;
  26extern const struct option	record_options[];
  27static bool			no_callchain;
  28static bool			latency_format;
  29static bool			system_wide;
 
  30static const char		*cpu_list;
  31static DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
 
 
 
 
 
 
 
 
  32
  33enum perf_output_field {
  34	PERF_OUTPUT_COMM            = 1U << 0,
  35	PERF_OUTPUT_TID             = 1U << 1,
  36	PERF_OUTPUT_PID             = 1U << 2,
  37	PERF_OUTPUT_TIME            = 1U << 3,
  38	PERF_OUTPUT_CPU             = 1U << 4,
  39	PERF_OUTPUT_EVNAME          = 1U << 5,
  40	PERF_OUTPUT_TRACE           = 1U << 6,
  41	PERF_OUTPUT_IP              = 1U << 7,
  42	PERF_OUTPUT_SYM             = 1U << 8,
  43	PERF_OUTPUT_DSO             = 1U << 9,
  44	PERF_OUTPUT_ADDR            = 1U << 10,
  45	PERF_OUTPUT_SYMOFFSET       = 1U << 11,
  46	PERF_OUTPUT_SRCLINE         = 1U << 12,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  47};
  48
  49struct output_option {
  50	const char *str;
  51	enum perf_output_field field;
  52} all_output_options[] = {
  53	{.str = "comm",  .field = PERF_OUTPUT_COMM},
  54	{.str = "tid",   .field = PERF_OUTPUT_TID},
  55	{.str = "pid",   .field = PERF_OUTPUT_PID},
  56	{.str = "time",  .field = PERF_OUTPUT_TIME},
  57	{.str = "cpu",   .field = PERF_OUTPUT_CPU},
  58	{.str = "event", .field = PERF_OUTPUT_EVNAME},
  59	{.str = "trace", .field = PERF_OUTPUT_TRACE},
  60	{.str = "ip",    .field = PERF_OUTPUT_IP},
  61	{.str = "sym",   .field = PERF_OUTPUT_SYM},
  62	{.str = "dso",   .field = PERF_OUTPUT_DSO},
  63	{.str = "addr",  .field = PERF_OUTPUT_ADDR},
  64	{.str = "symoff", .field = PERF_OUTPUT_SYMOFFSET},
  65	{.str = "srcline", .field = PERF_OUTPUT_SRCLINE},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  66};
  67
  68/* default set to maintain compatibility with current format */
  69static struct {
  70	bool user_set;
  71	bool wildcard_set;
  72	unsigned int print_ip_opts;
  73	u64 fields;
  74	u64 invalid_fields;
  75} output[PERF_TYPE_MAX] = {
 
 
  76
  77	[PERF_TYPE_HARDWARE] = {
  78		.user_set = false,
  79
  80		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  81			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  82			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
  83				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
  84
  85		.invalid_fields = PERF_OUTPUT_TRACE,
  86	},
  87
  88	[PERF_TYPE_SOFTWARE] = {
  89		.user_set = false,
  90
  91		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
  92			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
  93			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
  94				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
 
  95
  96		.invalid_fields = PERF_OUTPUT_TRACE,
  97	},
  98
  99	[PERF_TYPE_TRACEPOINT] = {
 100		.user_set = false,
 101
 102		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
 103				  PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
 104				  PERF_OUTPUT_EVNAME | PERF_OUTPUT_TRACE,
 
 
 
 
 
 
 
 
 
 
 
 
 105	},
 106
 107	[PERF_TYPE_RAW] = {
 108		.user_set = false,
 109
 110		.fields = PERF_OUTPUT_COMM | PERF_OUTPUT_TID |
 111			      PERF_OUTPUT_CPU | PERF_OUTPUT_TIME |
 112			      PERF_OUTPUT_EVNAME | PERF_OUTPUT_IP |
 113				  PERF_OUTPUT_SYM | PERF_OUTPUT_DSO,
 
 
 
 
 114
 115		.invalid_fields = PERF_OUTPUT_TRACE,
 
 
 
 
 
 
 
 
 
 
 
 
 116	},
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 117};
 118
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 119static bool output_set_by_user(void)
 120{
 121	int j;
 122	for (j = 0; j < PERF_TYPE_MAX; ++j) {
 123		if (output[j].user_set)
 124			return true;
 125	}
 126	return false;
 127}
 128
 129static const char *output_field2str(enum perf_output_field field)
 130{
 131	int i, imax = ARRAY_SIZE(all_output_options);
 132	const char *str = "";
 133
 134	for (i = 0; i < imax; ++i) {
 135		if (all_output_options[i].field == field) {
 136			str = all_output_options[i].str;
 137			break;
 138		}
 139	}
 140	return str;
 141}
 142
 143#define PRINT_FIELD(x)  (output[attr->type].fields & PERF_OUTPUT_##x)
 144
 145static int perf_evsel__check_stype(struct perf_evsel *evsel,
 146				   u64 sample_type, const char *sample_msg,
 147				   enum perf_output_field field)
 148{
 149	struct perf_event_attr *attr = &evsel->attr;
 150	int type = attr->type;
 151	const char *evname;
 152
 153	if (attr->sample_type & sample_type)
 154		return 0;
 155
 156	if (output[type].user_set) {
 157		evname = perf_evsel__name(evsel);
 
 
 158		pr_err("Samples for '%s' event do not have %s attribute set. "
 159		       "Cannot print '%s' field.\n",
 160		       evname, sample_msg, output_field2str(field));
 161		return -1;
 162	}
 163
 164	/* user did not ask for it explicitly so remove from the default list */
 165	output[type].fields &= ~field;
 166	evname = perf_evsel__name(evsel);
 167	pr_debug("Samples for '%s' event do not have %s attribute set. "
 168		 "Skipping '%s' field.\n",
 169		 evname, sample_msg, output_field2str(field));
 170
 171	return 0;
 172}
 173
 174static int perf_evsel__check_attr(struct perf_evsel *evsel,
 175				  struct perf_session *session)
 
 
 
 
 
 176{
 177	struct perf_event_attr *attr = &evsel->attr;
 
 
 
 
 
 
 
 178
 179	if (PRINT_FIELD(TRACE) &&
 180		!perf_session__has_traces(session, "record -R"))
 181		return -EINVAL;
 182
 183	if (PRINT_FIELD(IP)) {
 184		if (perf_evsel__check_stype(evsel, PERF_SAMPLE_IP, "IP",
 185					    PERF_OUTPUT_IP))
 186			return -EINVAL;
 187
 188		if (!no_callchain &&
 189		    !(attr->sample_type & PERF_SAMPLE_CALLCHAIN))
 190			symbol_conf.use_callchain = false;
 191	}
 192
 193	if (PRINT_FIELD(ADDR) &&
 194		perf_evsel__check_stype(evsel, PERF_SAMPLE_ADDR, "ADDR",
 195					PERF_OUTPUT_ADDR))
 196		return -EINVAL;
 197
 198	if (PRINT_FIELD(SYM) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
 
 
 
 
 
 
 
 
 
 199		pr_err("Display of symbols requested but neither sample IP nor "
 200			   "sample address\nis selected. Hence, no addresses to convert "
 201		       "to symbols.\n");
 202		return -EINVAL;
 203	}
 204	if (PRINT_FIELD(SYMOFFSET) && !PRINT_FIELD(SYM)) {
 205		pr_err("Display of offsets requested but symbol is not"
 206		       "selected.\n");
 207		return -EINVAL;
 208	}
 209	if (PRINT_FIELD(DSO) && !PRINT_FIELD(IP) && !PRINT_FIELD(ADDR)) {
 210		pr_err("Display of DSO requested but neither sample IP nor "
 211			   "sample address\nis selected. Hence, no addresses to convert "
 212		       "to DSO.\n");
 213		return -EINVAL;
 214	}
 215	if (PRINT_FIELD(SRCLINE) && !PRINT_FIELD(IP)) {
 216		pr_err("Display of source line number requested but sample IP is not\n"
 217		       "selected. Hence, no address to lookup the source line number.\n");
 218		return -EINVAL;
 219	}
 220
 
 
 
 
 
 221	if ((PRINT_FIELD(PID) || PRINT_FIELD(TID)) &&
 222		perf_evsel__check_stype(evsel, PERF_SAMPLE_TID, "TID",
 223					PERF_OUTPUT_TID|PERF_OUTPUT_PID))
 224		return -EINVAL;
 225
 226	if (PRINT_FIELD(TIME) &&
 227		perf_evsel__check_stype(evsel, PERF_SAMPLE_TIME, "TIME",
 228					PERF_OUTPUT_TIME))
 229		return -EINVAL;
 230
 231	if (PRINT_FIELD(CPU) &&
 232		perf_evsel__check_stype(evsel, PERF_SAMPLE_CPU, "CPU",
 233					PERF_OUTPUT_CPU))
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 234		return -EINVAL;
 235
 236	return 0;
 237}
 238
 239static void set_print_ip_opts(struct perf_event_attr *attr)
 240{
 241	unsigned int type = attr->type;
 242
 243	output[type].print_ip_opts = 0;
 244	if (PRINT_FIELD(IP))
 245		output[type].print_ip_opts |= PRINT_IP_OPT_IP;
 246
 247	if (PRINT_FIELD(SYM))
 248		output[type].print_ip_opts |= PRINT_IP_OPT_SYM;
 249
 250	if (PRINT_FIELD(DSO))
 251		output[type].print_ip_opts |= PRINT_IP_OPT_DSO;
 252
 253	if (PRINT_FIELD(SYMOFFSET))
 254		output[type].print_ip_opts |= PRINT_IP_OPT_SYMOFFSET;
 255
 256	if (PRINT_FIELD(SRCLINE))
 257		output[type].print_ip_opts |= PRINT_IP_OPT_SRCLINE;
 258}
 259
 260/*
 261 * verify all user requested events exist and the samples
 262 * have the expected data
 263 */
 264static int perf_session__check_output_opt(struct perf_session *session)
 265{
 266	int j;
 267	struct perf_evsel *evsel;
 
 268
 269	for (j = 0; j < PERF_TYPE_MAX; ++j) {
 270		evsel = perf_session__find_first_evtype(session, j);
 271
 272		/*
 273		 * even if fields is set to 0 (ie., show nothing) event must
 274		 * exist if user explicitly includes it on the command line
 275		 */
 276		if (!evsel && output[j].user_set && !output[j].wildcard_set) {
 
 277			pr_err("%s events do not exist. "
 278			       "Remove corresponding -f option to proceed.\n",
 279			       event_type(j));
 280			return -1;
 281		}
 282
 283		if (evsel && output[j].fields &&
 284			perf_evsel__check_attr(evsel, session))
 285			return -1;
 286
 287		if (evsel == NULL)
 288			continue;
 289
 290		set_print_ip_opts(&evsel->attr);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 291	}
 292
 293	/*
 294	 * set default for tracepoints to print symbols only
 295	 * if callchains are present
 296	 */
 297	if (symbol_conf.use_callchain &&
 298	    !output[PERF_TYPE_TRACEPOINT].user_set) {
 299		struct perf_event_attr *attr;
 300
 301		j = PERF_TYPE_TRACEPOINT;
 302		evsel = perf_session__find_first_evtype(session, j);
 303		if (evsel == NULL)
 304			goto out;
 305
 306		attr = &evsel->attr;
 
 
 307
 308		if (attr->sample_type & PERF_SAMPLE_CALLCHAIN) {
 309			output[j].fields |= PERF_OUTPUT_IP;
 310			output[j].fields |= PERF_OUTPUT_SYM;
 311			output[j].fields |= PERF_OUTPUT_DSO;
 312			set_print_ip_opts(attr);
 
 
 
 313		}
 314	}
 315
 
 
 
 
 
 316out:
 317	return 0;
 318}
 319
 320static void print_sample_start(struct perf_sample *sample,
 321			       struct thread *thread,
 322			       struct perf_evsel *evsel)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 323{
 324	struct perf_event_attr *attr = &evsel->attr;
 
 
 
 
 
 
 
 
 
 
 325	unsigned long secs;
 326	unsigned long usecs;
 327	unsigned long long nsecs;
 
 
 328
 329	if (PRINT_FIELD(COMM)) {
 
 
 330		if (latency_format)
 331			printf("%8.8s ", thread__comm_str(thread));
 332		else if (PRINT_FIELD(IP) && symbol_conf.use_callchain)
 333			printf("%s ", thread__comm_str(thread));
 334		else
 335			printf("%16s ", thread__comm_str(thread));
 336	}
 337
 338	if (PRINT_FIELD(PID) && PRINT_FIELD(TID))
 339		printf("%5d/%-5d ", sample->pid, sample->tid);
 340	else if (PRINT_FIELD(PID))
 341		printf("%5d ", sample->pid);
 342	else if (PRINT_FIELD(TID))
 343		printf("%5d ", sample->tid);
 344
 345	if (PRINT_FIELD(CPU)) {
 346		if (latency_format)
 347			printf("%3d ", sample->cpu);
 348		else
 349			printf("[%03d] ", sample->cpu);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 350	}
 351
 352	if (PRINT_FIELD(TIME)) {
 353		nsecs = sample->time;
 354		secs = nsecs / NSECS_PER_SEC;
 355		nsecs -= secs * NSECS_PER_SEC;
 356		usecs = nsecs / NSECS_PER_USEC;
 357		printf("%5lu.%06lu: ", secs, usecs);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 358	}
 
 
 359}
 360
 361static bool is_bts_event(struct perf_event_attr *attr)
 
 362{
 363	return ((attr->type == PERF_TYPE_HARDWARE) &&
 364		(attr->config & PERF_COUNT_HW_BRANCH_INSTRUCTIONS) &&
 365		(attr->sample_period == 1));
 
 366}
 367
 368static bool sample_addr_correlates_sym(struct perf_event_attr *attr)
 
 
 369{
 370	if ((attr->type == PERF_TYPE_SOFTWARE) &&
 371	    ((attr->config == PERF_COUNT_SW_PAGE_FAULTS) ||
 372	     (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MIN) ||
 373	     (attr->config == PERF_COUNT_SW_PAGE_FAULTS_MAJ)))
 374		return true;
 375
 376	if (is_bts_event(attr))
 377		return true;
 378
 379	return false;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 380}
 381
 382static void print_sample_addr(union perf_event *event,
 383			  struct perf_sample *sample,
 384			  struct machine *machine,
 385			  struct thread *thread,
 386			  struct perf_event_attr *attr)
 387{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 388	struct addr_location al;
 389	u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 390
 391	printf("%16" PRIx64, sample->addr);
 
 392
 393	if (!sample_addr_correlates_sym(attr))
 394		return;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 395
 396	thread__find_addr_map(thread, machine, cpumode, MAP__FUNCTION,
 397			      sample->addr, &al);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 398	if (!al.map)
 399		thread__find_addr_map(thread, machine, cpumode, MAP__VARIABLE,
 400				      sample->addr, &al);
 
 
 
 
 
 401
 402	al.cpu = sample->cpu;
 403	al.sym = NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 404
 
 
 
 
 
 
 
 405	if (al.map)
 406		al.sym = map__find_symbol(al.map, al.addr, NULL);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 407
 408	if (PRINT_FIELD(SYM)) {
 409		printf(" ");
 410		if (PRINT_FIELD(SYMOFFSET))
 411			symbol__fprintf_symname_offs(al.sym, &al, stdout);
 412		else
 413			symbol__fprintf_symname(al.sym, stdout);
 414	}
 415
 416	if (PRINT_FIELD(DSO)) {
 417		printf(" (");
 418		map__fprintf_dsoname(al.map, stdout);
 419		printf(")");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 420	}
 
 
 
 
 421}
 422
 423static void print_sample_bts(union perf_event *event,
 424			     struct perf_sample *sample,
 425			     struct perf_evsel *evsel,
 426			     struct thread *thread,
 427			     struct addr_location *al)
 428{
 429	struct perf_event_attr *attr = &evsel->attr;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 430
 431	/* print branch_from information */
 432	if (PRINT_FIELD(IP)) {
 433		if (!symbol_conf.use_callchain)
 434			printf(" ");
 435		else
 436			printf("\n");
 437		perf_evsel__print_ip(evsel, sample, al,
 438				     output[attr->type].print_ip_opts,
 439				     PERF_MAX_STACK_DEPTH);
 440	}
 441
 442	printf(" => ");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 443
 444	/* print branch_to information */
 445	if (PRINT_FIELD(ADDR) ||
 446	    ((evsel->attr.sample_type & PERF_SAMPLE_ADDR) &&
 447	     !output[attr->type].user_set))
 448		print_sample_addr(event, sample, al->machine, thread, attr);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 449
 450	printf("\n");
 
 
 
 
 
 451}
 452
 453static void process_event(union perf_event *event, struct perf_sample *sample,
 454			  struct perf_evsel *evsel, struct thread *thread,
 455			  struct addr_location *al)
 456{
 457	struct perf_event_attr *attr = &evsel->attr;
 
 
 
 
 458
 459	if (output[attr->type].fields == 0)
 460		return;
 
 461
 462	print_sample_start(sample, thread, evsel);
 
 
 
 
 463
 464	if (PRINT_FIELD(EVNAME)) {
 465		const char *evname = perf_evsel__name(evsel);
 466		printf("%s: ", evname ? evname : "[unknown]");
 
 467	}
 468
 469	if (is_bts_event(attr)) {
 470		print_sample_bts(event, sample, evsel, thread, al);
 471		return;
 472	}
 
 
 
 
 
 
 473
 474	if (PRINT_FIELD(TRACE))
 475		event_format__print(evsel->tp_format, sample->cpu,
 476				    sample->raw_data, sample->raw_size);
 477	if (PRINT_FIELD(ADDR))
 478		print_sample_addr(event, sample, al->machine, thread, attr);
 479
 480	if (PRINT_FIELD(IP)) {
 481		if (!symbol_conf.use_callchain)
 482			printf(" ");
 483		else
 484			printf("\n");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 485
 486		perf_evsel__print_ip(evsel, sample, al,
 487				     output[attr->type].print_ip_opts,
 488				     PERF_MAX_STACK_DEPTH);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 489	}
 490
 491	printf("\n");
 492}
 493
 494static int default_start_script(const char *script __maybe_unused,
 495				int argc __maybe_unused,
 496				const char **argv __maybe_unused)
 497{
 498	return 0;
 
 
 
 
 
 
 
 
 499}
 500
 501static int default_stop_script(void)
 502{
 
 
 
 503	return 0;
 504}
 505
 506static int default_generate_script(struct pevent *pevent __maybe_unused,
 507				   const char *outfile __maybe_unused)
 508{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 509	return 0;
 510}
 511
 512static struct scripting_ops default_scripting_ops = {
 513	.start_script		= default_start_script,
 514	.stop_script		= default_stop_script,
 515	.process_event		= process_event,
 516	.generate_script	= default_generate_script,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 517};
 518
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 519static struct scripting_ops	*scripting_ops;
 520
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 521static void setup_scripting(void)
 522{
 523	setup_perl_scripting();
 524	setup_python_scripting();
 
 525
 526	scripting_ops = &default_scripting_ops;
 
 
 527}
 528
 529static int cleanup_scripting(void)
 530{
 531	pr_debug("\nperf script stopped\n");
 532
 533	return scripting_ops->stop_script();
 534}
 535
 536static int process_sample_event(struct perf_tool *tool __maybe_unused,
 
 
 
 
 
 
 
 537				union perf_event *event,
 538				struct perf_sample *sample,
 539				struct perf_evsel *evsel,
 540				struct machine *machine)
 541{
 
 542	struct addr_location al;
 543	struct thread *thread = machine__findnew_thread(machine, sample->pid,
 544							sample->tid);
 545
 546	if (thread == NULL) {
 547		pr_debug("problem processing %d event, skipping it.\n",
 548			 event->header.type);
 549		return -1;
 
 
 
 
 
 
 
 
 
 
 550	}
 551
 552	if (debug_mode) {
 553		if (sample->time < last_timestamp) {
 554			pr_err("Samples misordered, previous: %" PRIu64
 555				" this: %" PRIu64 "\n", last_timestamp,
 556				sample->time);
 557			nr_unordered++;
 558		}
 559		last_timestamp = sample->time;
 560		return 0;
 561	}
 562
 563	if (perf_event__preprocess_sample(event, machine, &al, sample) < 0) {
 
 
 
 564		pr_err("problem processing %d event, skipping it.\n",
 565		       event->header.type);
 566		return -1;
 
 567	}
 568
 569	if (al.filtered)
 570		return 0;
 571
 572	if (cpu_list && !test_bit(sample->cpu, cpu_bitmap))
 573		return 0;
 574
 575	scripting_ops->process_event(event, sample, evsel, thread, &al);
 
 576
 577	evsel->hists.stats.total_period += sample->period;
 578	return 0;
 579}
 
 
 
 580
 581struct perf_script {
 582	struct perf_tool	tool;
 583	struct perf_session	*session;
 584	bool			show_task_events;
 585	bool			show_mmap_events;
 586};
 
 
 
 
 
 
 
 
 
 
 
 
 
 587
 588static int process_attr(struct perf_tool *tool, union perf_event *event,
 589			struct perf_evlist **pevlist)
 590{
 591	struct perf_script *scr = container_of(tool, struct perf_script, tool);
 592	struct perf_evlist *evlist;
 593	struct perf_evsel *evsel, *pos;
 
 594	int err;
 
 595
 596	err = perf_event__process_attr(tool, event, pevlist);
 597	if (err)
 598		return err;
 599
 600	evlist = *pevlist;
 601	evsel = perf_evlist__last(*pevlist);
 602
 603	if (evsel->attr.type >= PERF_TYPE_MAX)
 
 
 
 
 
 
 
 
 
 
 
 
 
 604		return 0;
 605
 606	evlist__for_each(evlist, pos) {
 607		if (pos->attr.type == evsel->attr.type && pos != evsel)
 608			return 0;
 609	}
 610
 611	set_print_ip_opts(&evsel->attr);
 
 
 
 
 
 
 
 
 
 
 
 612
 613	return perf_evsel__check_attr(evsel, scr->session);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 614}
 615
 616static int process_comm_event(struct perf_tool *tool,
 617			      union perf_event *event,
 618			      struct perf_sample *sample,
 619			      struct machine *machine)
 
 620{
 621	struct thread *thread;
 622	struct perf_script *script = container_of(tool, struct perf_script, tool);
 623	struct perf_session *session = script->session;
 624	struct perf_evsel *evsel = perf_evlist__first(session->evlist);
 625	int ret = -1;
 626
 627	thread = machine__findnew_thread(machine, event->comm.pid, event->comm.tid);
 628	if (thread == NULL) {
 629		pr_debug("problem processing COMM event, skipping it.\n");
 630		return -1;
 
 631	}
 632
 633	if (perf_event__process_comm(tool, event, sample, machine) < 0)
 634		goto out;
 635
 636	if (!evsel->attr.sample_id_all) {
 637		sample->cpu = 0;
 638		sample->time = 0;
 639		sample->tid = event->comm.tid;
 640		sample->pid = event->comm.pid;
 641	}
 642	print_sample_start(sample, thread, evsel);
 643	perf_event__fprintf(event, stdout);
 644	ret = 0;
 645
 646out:
 647	return ret;
 
 
 
 
 
 
 
 
 648}
 649
 650static int process_fork_event(struct perf_tool *tool,
 
 
 
 
 
 
 
 651			      union perf_event *event,
 652			      struct perf_sample *sample,
 653			      struct machine *machine)
 654{
 655	struct thread *thread;
 656	struct perf_script *script = container_of(tool, struct perf_script, tool);
 657	struct perf_session *session = script->session;
 658	struct perf_evsel *evsel = perf_evlist__first(session->evlist);
 659
 660	if (perf_event__process_fork(tool, event, sample, machine) < 0)
 
 
 
 
 
 
 
 
 
 661		return -1;
 662
 663	thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
 664	if (thread == NULL) {
 665		pr_debug("problem processing FORK event, skipping it.\n");
 
 
 
 
 
 
 
 666		return -1;
 667	}
 668
 669	if (!evsel->attr.sample_id_all) {
 670		sample->cpu = 0;
 671		sample->time = event->fork.time;
 672		sample->tid = event->fork.tid;
 673		sample->pid = event->fork.pid;
 674	}
 675	print_sample_start(sample, thread, evsel);
 676	perf_event__fprintf(event, stdout);
 677
 678	return 0;
 
 
 
 
 
 
 
 
 
 
 679}
 680static int process_exit_event(struct perf_tool *tool,
 681			      union perf_event *event,
 682			      struct perf_sample *sample,
 683			      struct machine *machine)
 684{
 685	struct thread *thread;
 686	struct perf_script *script = container_of(tool, struct perf_script, tool);
 687	struct perf_session *session = script->session;
 688	struct perf_evsel *evsel = perf_evlist__first(session->evlist);
 689
 690	thread = machine__findnew_thread(machine, event->fork.pid, event->fork.tid);
 691	if (thread == NULL) {
 692		pr_debug("problem processing EXIT event, skipping it.\n");
 693		return -1;
 694	}
 695
 696	if (!evsel->attr.sample_id_all) {
 697		sample->cpu = 0;
 698		sample->time = 0;
 699		sample->tid = event->comm.tid;
 700		sample->pid = event->comm.pid;
 701	}
 702	print_sample_start(sample, thread, evsel);
 703	perf_event__fprintf(event, stdout);
 704
 705	if (perf_event__process_exit(tool, event, sample, machine) < 0)
 
 
 
 
 
 706		return -1;
 707
 708	return 0;
 
 709}
 710
 711static int process_mmap_event(struct perf_tool *tool,
 712			      union perf_event *event,
 713			      struct perf_sample *sample,
 714			      struct machine *machine)
 715{
 716	struct thread *thread;
 
 
 
 
 
 
 
 
 
 
 
 717	struct perf_script *script = container_of(tool, struct perf_script, tool);
 718	struct perf_session *session = script->session;
 719	struct perf_evsel *evsel = perf_evlist__first(session->evlist);
 720
 721	if (perf_event__process_mmap(tool, event, sample, machine) < 0)
 722		return -1;
 723
 724	thread = machine__findnew_thread(machine, event->mmap.pid, event->mmap.tid);
 725	if (thread == NULL) {
 726		pr_debug("problem processing MMAP event, skipping it.\n");
 727		return -1;
 728	}
 729
 730	if (!evsel->attr.sample_id_all) {
 731		sample->cpu = 0;
 732		sample->time = 0;
 733		sample->tid = event->mmap.tid;
 734		sample->pid = event->mmap.pid;
 
 
 
 
 
 
 
 
 735	}
 736	print_sample_start(sample, thread, evsel);
 737	perf_event__fprintf(event, stdout);
 738
 739	return 0;
 740}
 741
 742static int process_mmap2_event(struct perf_tool *tool,
 743			      union perf_event *event,
 744			      struct perf_sample *sample,
 745			      struct machine *machine)
 
 746{
 747	struct thread *thread;
 748	struct perf_script *script = container_of(tool, struct perf_script, tool);
 749	struct perf_session *session = script->session;
 750	struct perf_evsel *evsel = perf_evlist__first(session->evlist);
 751
 752	if (perf_event__process_mmap2(tool, event, sample, machine) < 0)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 753		return -1;
 754
 755	thread = machine__findnew_thread(machine, event->mmap2.pid, event->mmap2.tid);
 756	if (thread == NULL) {
 757		pr_debug("problem processing MMAP2 event, skipping it.\n");
 
 
 
 
 
 
 
 758		return -1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 759	}
 
 760
 761	if (!evsel->attr.sample_id_all) {
 762		sample->cpu = 0;
 763		sample->time = 0;
 764		sample->tid = event->mmap2.tid;
 765		sample->pid = event->mmap2.pid;
 
 
 
 
 
 
 
 
 
 
 
 
 
 766	}
 767	print_sample_start(sample, thread, evsel);
 768	perf_event__fprintf(event, stdout);
 769
 770	return 0;
 
 
 
 
 771}
 772
 773static void sig_handler(int sig __maybe_unused)
 774{
 775	session_done = 1;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 776}
 777
 778static int __cmd_script(struct perf_script *script)
 779{
 780	int ret;
 781
 782	signal(SIGINT, sig_handler);
 783
 
 
 784	/* override event processing functions */
 785	if (script->show_task_events) {
 786		script->tool.comm = process_comm_event;
 787		script->tool.fork = process_fork_event;
 788		script->tool.exit = process_exit_event;
 789	}
 790	if (script->show_mmap_events) {
 791		script->tool.mmap = process_mmap_event;
 792		script->tool.mmap2 = process_mmap2_event;
 793	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 794
 795	ret = perf_session__process_events(script->session, &script->tool);
 
 
 
 
 
 
 
 
 796
 797	if (debug_mode)
 798		pr_err("Misordered timestamps: %" PRIu64 "\n", nr_unordered);
 799
 800	return ret;
 801}
 802
 803struct script_spec {
 804	struct list_head	node;
 805	struct scripting_ops	*ops;
 806	char			spec[0];
 807};
 808
 809static LIST_HEAD(script_specs);
 810
 811static struct script_spec *script_spec__new(const char *spec,
 812					    struct scripting_ops *ops)
 813{
 814	struct script_spec *s = malloc(sizeof(*s) + strlen(spec) + 1);
 815
 816	if (s != NULL) {
 817		strcpy(s->spec, spec);
 818		s->ops = ops;
 819	}
 820
 821	return s;
 822}
 823
 824static void script_spec__add(struct script_spec *s)
 825{
 826	list_add_tail(&s->node, &script_specs);
 827}
 828
 829static struct script_spec *script_spec__find(const char *spec)
 830{
 831	struct script_spec *s;
 832
 833	list_for_each_entry(s, &script_specs, node)
 834		if (strcasecmp(s->spec, spec) == 0)
 835			return s;
 836	return NULL;
 837}
 838
 839static struct script_spec *script_spec__findnew(const char *spec,
 840						struct scripting_ops *ops)
 841{
 842	struct script_spec *s = script_spec__find(spec);
 843
 844	if (s)
 845		return s;
 846
 847	s = script_spec__new(spec, ops);
 848	if (!s)
 849		return NULL;
 850
 851	script_spec__add(s);
 852
 853	return s;
 854}
 855
 856int script_spec_register(const char *spec, struct scripting_ops *ops)
 857{
 858	struct script_spec *s;
 859
 860	s = script_spec__find(spec);
 861	if (s)
 862		return -1;
 863
 864	s = script_spec__findnew(spec, ops);
 865	if (!s)
 866		return -1;
 
 
 867
 868	return 0;
 869}
 870
 871static struct scripting_ops *script_spec__lookup(const char *spec)
 872{
 873	struct script_spec *s = script_spec__find(spec);
 874	if (!s)
 875		return NULL;
 876
 877	return s->ops;
 878}
 879
 880static void list_available_languages(void)
 881{
 882	struct script_spec *s;
 883
 884	fprintf(stderr, "\n");
 885	fprintf(stderr, "Scripting language extensions (used in "
 886		"perf script -s [spec:]script.[spec]):\n\n");
 887
 888	list_for_each_entry(s, &script_specs, node)
 889		fprintf(stderr, "  %-42s [%s]\n", s->spec, s->ops->name);
 890
 891	fprintf(stderr, "\n");
 892}
 893
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 894static int parse_scriptname(const struct option *opt __maybe_unused,
 895			    const char *str, int unset __maybe_unused)
 896{
 897	char spec[PATH_MAX];
 898	const char *script, *ext;
 899	int len;
 900
 901	if (strcmp(str, "lang") == 0) {
 902		list_available_languages();
 903		exit(0);
 904	}
 905
 906	script = strchr(str, ':');
 907	if (script) {
 908		len = script - str;
 909		if (len >= PATH_MAX) {
 910			fprintf(stderr, "invalid language specifier");
 911			return -1;
 912		}
 913		strncpy(spec, str, len);
 914		spec[len] = '\0';
 915		scripting_ops = script_spec__lookup(spec);
 916		if (!scripting_ops) {
 917			fprintf(stderr, "invalid language specifier");
 918			return -1;
 919		}
 920		script++;
 921	} else {
 922		script = str;
 923		ext = strrchr(script, '.');
 924		if (!ext) {
 925			fprintf(stderr, "invalid script extension");
 926			return -1;
 927		}
 928		scripting_ops = script_spec__lookup(++ext);
 929		if (!scripting_ops) {
 930			fprintf(stderr, "invalid script extension");
 931			return -1;
 932		}
 933	}
 934
 935	script_name = strdup(script);
 
 
 936
 937	return 0;
 938}
 939
 940static int parse_output_fields(const struct option *opt __maybe_unused,
 941			    const char *arg, int unset __maybe_unused)
 942{
 943	char *tok;
 944	int i, imax = ARRAY_SIZE(all_output_options);
 945	int j;
 946	int rc = 0;
 947	char *str = strdup(arg);
 948	int type = -1;
 
 949
 950	if (!str)
 951		return -ENOMEM;
 952
 953	/* first word can state for which event type the user is specifying
 954	 * the fields. If no type exists, the specified fields apply to all
 955	 * event types found in the file minus the invalid fields for a type.
 956	 */
 957	tok = strchr(str, ':');
 958	if (tok) {
 959		*tok = '\0';
 960		tok++;
 961		if (!strcmp(str, "hw"))
 962			type = PERF_TYPE_HARDWARE;
 963		else if (!strcmp(str, "sw"))
 964			type = PERF_TYPE_SOFTWARE;
 965		else if (!strcmp(str, "trace"))
 966			type = PERF_TYPE_TRACEPOINT;
 967		else if (!strcmp(str, "raw"))
 968			type = PERF_TYPE_RAW;
 
 
 
 
 969		else {
 970			fprintf(stderr, "Invalid event type in field string.\n");
 971			rc = -EINVAL;
 972			goto out;
 973		}
 974
 975		if (output[type].user_set)
 976			pr_warning("Overriding previous field request for %s events.\n",
 977				   event_type(type));
 978
 
 
 
 
 979		output[type].fields = 0;
 980		output[type].user_set = true;
 981		output[type].wildcard_set = false;
 982
 983	} else {
 984		tok = str;
 985		if (strlen(str) == 0) {
 986			fprintf(stderr,
 987				"Cannot set fields to 'none' for all event types.\n");
 988			rc = -EINVAL;
 989			goto out;
 990		}
 991
 
 
 
 
 992		if (output_set_by_user())
 993			pr_warning("Overriding previous field request for all events.\n");
 994
 995		for (j = 0; j < PERF_TYPE_MAX; ++j) {
 996			output[j].fields = 0;
 997			output[j].user_set = true;
 998			output[j].wildcard_set = true;
 999		}
1000	}
1001
1002	tok = strtok(tok, ",");
1003	while (tok) {
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1004		for (i = 0; i < imax; ++i) {
1005			if (strcmp(tok, all_output_options[i].str) == 0)
1006				break;
1007		}
 
 
 
 
1008		if (i == imax) {
1009			fprintf(stderr, "Invalid field requested.\n");
1010			rc = -EINVAL;
1011			goto out;
1012		}
1013
1014		if (type == -1) {
1015			/* add user option to all events types for
1016			 * which it is valid
1017			 */
1018			for (j = 0; j < PERF_TYPE_MAX; ++j) {
1019				if (output[j].invalid_fields & all_output_options[i].field) {
1020					pr_warning("\'%s\' not valid for %s events. Ignoring.\n",
1021						   all_output_options[i].str, event_type(j));
1022				} else
1023					output[j].fields |= all_output_options[i].field;
 
 
 
 
 
 
 
 
 
 
 
1024			}
1025		} else {
1026			if (output[type].invalid_fields & all_output_options[i].field) {
1027				fprintf(stderr, "\'%s\' not valid for %s events.\n",
1028					 all_output_options[i].str, event_type(type));
1029
1030				rc = -EINVAL;
1031				goto out;
1032			}
1033			output[type].fields |= all_output_options[i].field;
 
 
 
 
 
1034		}
1035
1036		tok = strtok(NULL, ",");
1037	}
1038
1039	if (type >= 0) {
1040		if (output[type].fields == 0) {
1041			pr_debug("No fields requested for %s type. "
1042				 "Events will not be displayed.\n", event_type(type));
1043		}
1044	}
 
1045
 
 
 
1046out:
1047	free(str);
1048	return rc;
1049}
1050
1051/* Helper function for filesystems that return a dent->d_type DT_UNKNOWN */
1052static int is_directory(const char *base_path, const struct dirent *dent)
1053{
1054	char path[PATH_MAX];
1055	struct stat st;
1056
1057	sprintf(path, "%s/%s", base_path, dent->d_name);
1058	if (stat(path, &st))
1059		return 0;
1060
1061	return S_ISDIR(st.st_mode);
1062}
1063
1064#define for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next)\
1065	while (!readdir_r(scripts_dir, &lang_dirent, &lang_next) &&	\
1066	       lang_next)						\
1067		if ((lang_dirent.d_type == DT_DIR ||			\
1068		     (lang_dirent.d_type == DT_UNKNOWN &&		\
1069		      is_directory(scripts_path, &lang_dirent))) &&	\
1070		    (strcmp(lang_dirent.d_name, ".")) &&		\
1071		    (strcmp(lang_dirent.d_name, "..")))
1072
1073#define for_each_script(lang_path, lang_dir, script_dirent, script_next)\
1074	while (!readdir_r(lang_dir, &script_dirent, &script_next) &&	\
1075	       script_next)						\
1076		if (script_dirent.d_type != DT_DIR &&			\
1077		    (script_dirent.d_type != DT_UNKNOWN ||		\
1078		     !is_directory(lang_path, &script_dirent)))
1079
1080
1081#define RECORD_SUFFIX			"-record"
1082#define REPORT_SUFFIX			"-report"
1083
1084struct script_desc {
1085	struct list_head	node;
1086	char			*name;
1087	char			*half_liner;
1088	char			*args;
1089};
1090
1091static LIST_HEAD(script_descs);
1092
1093static struct script_desc *script_desc__new(const char *name)
1094{
1095	struct script_desc *s = zalloc(sizeof(*s));
1096
1097	if (s != NULL && name)
1098		s->name = strdup(name);
1099
1100	return s;
1101}
1102
1103static void script_desc__delete(struct script_desc *s)
1104{
1105	zfree(&s->name);
1106	zfree(&s->half_liner);
1107	zfree(&s->args);
1108	free(s);
1109}
1110
1111static void script_desc__add(struct script_desc *s)
1112{
1113	list_add_tail(&s->node, &script_descs);
1114}
1115
1116static struct script_desc *script_desc__find(const char *name)
1117{
1118	struct script_desc *s;
1119
1120	list_for_each_entry(s, &script_descs, node)
1121		if (strcasecmp(s->name, name) == 0)
1122			return s;
1123	return NULL;
1124}
1125
1126static struct script_desc *script_desc__findnew(const char *name)
1127{
1128	struct script_desc *s = script_desc__find(name);
1129
1130	if (s)
1131		return s;
1132
1133	s = script_desc__new(name);
1134	if (!s)
1135		goto out_delete_desc;
1136
1137	script_desc__add(s);
1138
1139	return s;
1140
1141out_delete_desc:
1142	script_desc__delete(s);
1143
1144	return NULL;
1145}
1146
1147static const char *ends_with(const char *str, const char *suffix)
1148{
1149	size_t suffix_len = strlen(suffix);
1150	const char *p = str;
1151
1152	if (strlen(str) > suffix_len) {
1153		p = str + strlen(str) - suffix_len;
1154		if (!strncmp(p, suffix, suffix_len))
1155			return p;
1156	}
1157
1158	return NULL;
1159}
1160
1161static int read_script_info(struct script_desc *desc, const char *filename)
1162{
1163	char line[BUFSIZ], *p;
1164	FILE *fp;
1165
1166	fp = fopen(filename, "r");
1167	if (!fp)
1168		return -1;
1169
1170	while (fgets(line, sizeof(line), fp)) {
1171		p = ltrim(line);
1172		if (strlen(p) == 0)
1173			continue;
1174		if (*p != '#')
1175			continue;
1176		p++;
1177		if (strlen(p) && *p == '!')
1178			continue;
1179
1180		p = ltrim(p);
1181		if (strlen(p) && p[strlen(p) - 1] == '\n')
1182			p[strlen(p) - 1] = '\0';
1183
1184		if (!strncmp(p, "description:", strlen("description:"))) {
1185			p += strlen("description:");
1186			desc->half_liner = strdup(ltrim(p));
1187			continue;
1188		}
1189
1190		if (!strncmp(p, "args:", strlen("args:"))) {
1191			p += strlen("args:");
1192			desc->args = strdup(ltrim(p));
1193			continue;
1194		}
1195	}
1196
1197	fclose(fp);
1198
1199	return 0;
1200}
1201
1202static char *get_script_root(struct dirent *script_dirent, const char *suffix)
1203{
1204	char *script_root, *str;
1205
1206	script_root = strdup(script_dirent->d_name);
1207	if (!script_root)
1208		return NULL;
1209
1210	str = (char *)ends_with(script_root, suffix);
1211	if (!str) {
1212		free(script_root);
1213		return NULL;
1214	}
1215
1216	*str = '\0';
1217	return script_root;
1218}
1219
1220static int list_available_scripts(const struct option *opt __maybe_unused,
1221				  const char *s __maybe_unused,
1222				  int unset __maybe_unused)
1223{
1224	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
1225	char scripts_path[MAXPATHLEN];
1226	DIR *scripts_dir, *lang_dir;
1227	char script_path[MAXPATHLEN];
1228	char lang_path[MAXPATHLEN];
1229	struct script_desc *desc;
1230	char first_half[BUFSIZ];
1231	char *script_root;
1232
1233	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
1234
1235	scripts_dir = opendir(scripts_path);
1236	if (!scripts_dir)
1237		return -1;
 
 
 
 
 
1238
1239	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
1240		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
1241			 lang_dirent.d_name);
1242		lang_dir = opendir(lang_path);
1243		if (!lang_dir)
1244			continue;
1245
1246		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
1247			script_root = get_script_root(&script_dirent, REPORT_SUFFIX);
1248			if (script_root) {
1249				desc = script_desc__findnew(script_root);
1250				snprintf(script_path, MAXPATHLEN, "%s/%s",
1251					 lang_path, script_dirent.d_name);
1252				read_script_info(desc, script_path);
1253				free(script_root);
1254			}
1255		}
1256	}
1257
1258	fprintf(stdout, "List of available trace scripts:\n");
1259	list_for_each_entry(desc, &script_descs, node) {
1260		sprintf(first_half, "%s %s", desc->name,
1261			desc->args ? desc->args : "");
1262		fprintf(stdout, "  %-36s %s\n", first_half,
1263			desc->half_liner ? desc->half_liner : "");
1264	}
1265
1266	exit(0);
1267}
1268
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1269/*
1270 * Some scripts specify the required events in their "xxx-record" file,
1271 * this function will check if the events in perf.data match those
1272 * mentioned in the "xxx-record".
1273 *
1274 * Fixme: All existing "xxx-record" are all in good formats "-e event ",
1275 * which is covered well now. And new parsing code should be added to
1276 * cover the future complexing formats like event groups etc.
1277 */
1278static int check_ev_match(char *dir_name, char *scriptname,
1279			struct perf_session *session)
1280{
1281	char filename[MAXPATHLEN], evname[128];
1282	char line[BUFSIZ], *p;
1283	struct perf_evsel *pos;
1284	int match, len;
1285	FILE *fp;
1286
1287	sprintf(filename, "%s/bin/%s-record", dir_name, scriptname);
1288
1289	fp = fopen(filename, "r");
1290	if (!fp)
1291		return -1;
1292
1293	while (fgets(line, sizeof(line), fp)) {
1294		p = ltrim(line);
1295		if (*p == '#')
1296			continue;
1297
1298		while (strlen(p)) {
1299			p = strstr(p, "-e");
1300			if (!p)
1301				break;
1302
1303			p += 2;
1304			p = ltrim(p);
1305			len = strcspn(p, " \t");
1306			if (!len)
1307				break;
1308
1309			snprintf(evname, len + 1, "%s", p);
1310
1311			match = 0;
1312			evlist__for_each(session->evlist, pos) {
1313				if (!strcmp(perf_evsel__name(pos), evname)) {
1314					match = 1;
1315					break;
1316				}
1317			}
1318
1319			if (!match) {
1320				fclose(fp);
1321				return -1;
1322			}
1323		}
1324	}
1325
1326	fclose(fp);
1327	return 0;
1328}
1329
1330/*
1331 * Return -1 if none is found, otherwise the actual scripts number.
1332 *
1333 * Currently the only user of this function is the script browser, which
1334 * will list all statically runnable scripts, select one, execute it and
1335 * show the output in a perf browser.
1336 */
1337int find_scripts(char **scripts_array, char **scripts_path_array)
 
1338{
1339	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
1340	char scripts_path[MAXPATHLEN], lang_path[MAXPATHLEN];
1341	DIR *scripts_dir, *lang_dir;
1342	struct perf_session *session;
1343	struct perf_data_file file = {
1344		.path = input_name,
1345		.mode = PERF_DATA_MODE_READ,
1346	};
1347	char *temp;
1348	int i = 0;
1349
1350	session = perf_session__new(&file, false, NULL);
1351	if (!session)
1352		return -1;
1353
1354	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
1355
1356	scripts_dir = opendir(scripts_path);
1357	if (!scripts_dir) {
1358		perf_session__delete(session);
1359		return -1;
1360	}
1361
1362	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
1363		snprintf(lang_path, MAXPATHLEN, "%s/%s", scripts_path,
1364			 lang_dirent.d_name);
1365#ifdef NO_LIBPERL
1366		if (strstr(lang_path, "perl"))
1367			continue;
1368#endif
1369#ifdef NO_LIBPYTHON
1370		if (strstr(lang_path, "python"))
1371			continue;
1372#endif
1373
1374		lang_dir = opendir(lang_path);
1375		if (!lang_dir)
1376			continue;
1377
1378		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
1379			/* Skip those real time scripts: xxxtop.p[yl] */
1380			if (strstr(script_dirent.d_name, "top."))
1381				continue;
1382			sprintf(scripts_path_array[i], "%s/%s", lang_path,
1383				script_dirent.d_name);
1384			temp = strchr(script_dirent.d_name, '.');
 
 
 
1385			snprintf(scripts_array[i],
1386				(temp - script_dirent.d_name) + 1,
1387				"%s", script_dirent.d_name);
1388
1389			if (check_ev_match(lang_path,
1390					scripts_array[i], session))
1391				continue;
1392
1393			i++;
1394		}
1395		closedir(lang_dir);
1396	}
1397
1398	closedir(scripts_dir);
1399	perf_session__delete(session);
1400	return i;
1401}
1402
1403static char *get_script_path(const char *script_root, const char *suffix)
1404{
1405	struct dirent *script_next, *lang_next, script_dirent, lang_dirent;
1406	char scripts_path[MAXPATHLEN];
1407	char script_path[MAXPATHLEN];
1408	DIR *scripts_dir, *lang_dir;
1409	char lang_path[MAXPATHLEN];
1410	char *__script_root;
1411
1412	snprintf(scripts_path, MAXPATHLEN, "%s/scripts", perf_exec_path());
1413
1414	scripts_dir = opendir(scripts_path);
1415	if (!scripts_dir)
1416		return NULL;
1417
1418	for_each_lang(scripts_path, scripts_dir, lang_dirent, lang_next) {
1419		snprintf(lang_path, MAXPATHLEN, "%s/%s/bin", scripts_path,
1420			 lang_dirent.d_name);
1421		lang_dir = opendir(lang_path);
1422		if (!lang_dir)
1423			continue;
1424
1425		for_each_script(lang_path, lang_dir, script_dirent, script_next) {
1426			__script_root = get_script_root(&script_dirent, suffix);
1427			if (__script_root && !strcmp(script_root, __script_root)) {
1428				free(__script_root);
1429				closedir(lang_dir);
1430				closedir(scripts_dir);
1431				snprintf(script_path, MAXPATHLEN, "%s/%s",
1432					 lang_path, script_dirent.d_name);
 
1433				return strdup(script_path);
1434			}
1435			free(__script_root);
1436		}
1437		closedir(lang_dir);
1438	}
1439	closedir(scripts_dir);
1440
1441	return NULL;
1442}
1443
1444static bool is_top_script(const char *script_path)
1445{
1446	return ends_with(script_path, "top") == NULL ? false : true;
1447}
1448
1449static int has_required_arg(char *script_path)
1450{
1451	struct script_desc *desc;
1452	int n_args = 0;
1453	char *p;
1454
1455	desc = script_desc__new(NULL);
1456
1457	if (read_script_info(desc, script_path))
1458		goto out;
1459
1460	if (!desc->args)
1461		goto out;
1462
1463	for (p = desc->args; *p; p++)
1464		if (*p == '<')
1465			n_args++;
1466out:
1467	script_desc__delete(desc);
1468
1469	return n_args;
1470}
1471
1472static int have_cmd(int argc, const char **argv)
1473{
1474	char **__argv = malloc(sizeof(const char *) * argc);
1475
1476	if (!__argv) {
1477		pr_err("malloc failed\n");
1478		return -1;
1479	}
1480
1481	memcpy(__argv, argv, sizeof(const char *) * argc);
1482	argc = parse_options(argc, (const char **)__argv, record_options,
1483			     NULL, PARSE_OPT_STOP_AT_NON_OPTION);
1484	free(__argv);
1485
1486	system_wide = (argc == 0);
1487
1488	return 0;
1489}
1490
1491int cmd_script(int argc, const char **argv, const char *prefix __maybe_unused)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1492{
1493	bool show_full_info = false;
1494	bool header = false;
1495	bool header_only = false;
 
1496	char *rec_script_path = NULL;
1497	char *rep_script_path = NULL;
1498	struct perf_session *session;
 
 
 
 
 
1499	char *script_path = NULL;
 
1500	const char **__argv;
1501	int i, j, err;
1502	struct perf_script script = {
1503		.tool = {
1504			.sample		 = process_sample_event,
1505			.mmap		 = perf_event__process_mmap,
1506			.mmap2		 = perf_event__process_mmap2,
1507			.comm		 = perf_event__process_comm,
 
 
1508			.exit		 = perf_event__process_exit,
1509			.fork		 = perf_event__process_fork,
1510			.attr		 = process_attr,
 
1511			.tracing_data	 = perf_event__process_tracing_data,
 
1512			.build_id	 = perf_event__process_build_id,
1513			.ordered_samples = true,
 
 
 
 
 
 
 
 
 
1514			.ordering_requires_timestamps = true,
1515		},
1516	};
 
 
 
1517	const struct option options[] = {
1518	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
1519		    "dump raw trace in ASCII"),
1520	OPT_INCR('v', "verbose", &verbose,
1521		 "be more verbose (show symbol address, etc)"),
1522	OPT_BOOLEAN('L', "Latency", &latency_format,
1523		    "show latency attributes (irqs/preemption disabled, etc)"),
1524	OPT_CALLBACK_NOOPT('l', "list", NULL, NULL, "list available scripts",
1525			   list_available_scripts),
 
 
1526	OPT_CALLBACK('s', "script", NULL, "name",
1527		     "script file name (lang:script name, script name, or *)",
1528		     parse_scriptname),
1529	OPT_STRING('g', "gen-script", &generate_script_lang, "lang",
1530		   "generate perf-script.xx script in specified language"),
 
 
 
1531	OPT_STRING('i', "input", &input_name, "file", "input file name"),
1532	OPT_BOOLEAN('d', "debug-mode", &debug_mode,
1533		   "do various checks like samples ordering and lost events"),
1534	OPT_BOOLEAN(0, "header", &header, "Show data header."),
1535	OPT_BOOLEAN(0, "header-only", &header_only, "Show only data header."),
1536	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
1537		   "file", "vmlinux pathname"),
1538	OPT_STRING(0, "kallsyms", &symbol_conf.kallsyms_name,
1539		   "file", "kallsyms pathname"),
1540	OPT_BOOLEAN('G', "hide-call-graph", &no_callchain,
1541		    "When printing symbols do not display call chain"),
1542	OPT_STRING(0, "symfs", &symbol_conf.symfs, "directory",
1543		    "Look for files with symbols relative to this directory"),
1544	OPT_CALLBACK('f', "fields", NULL, "str",
 
1545		     "comma separated output fields prepend with 'type:'. "
1546		     "Valid types: hw,sw,trace,raw. "
 
1547		     "Fields: comm,tid,pid,time,cpu,event,trace,ip,sym,dso,"
1548		     "addr,symoff", parse_output_fields),
 
 
 
 
1549	OPT_BOOLEAN('a', "all-cpus", &system_wide,
1550		    "system-wide collection from all CPUs"),
 
 
1551	OPT_STRING('S', "symbols", &symbol_conf.sym_list_str, "symbol[,symbol...]",
1552		   "only consider these symbols"),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1553	OPT_STRING('C', "cpu", &cpu_list, "cpu", "list of cpus to profile"),
1554	OPT_STRING('c', "comms", &symbol_conf.comm_list_str, "comm[,comm...]",
1555		   "only display events for these comms"),
 
 
 
 
 
 
 
 
 
 
1556	OPT_BOOLEAN('I', "show-info", &show_full_info,
1557		    "display extended information from perf.data file"),
1558	OPT_BOOLEAN('\0', "show-kernel-path", &symbol_conf.show_kernel_path,
1559		    "Show the path of [kernel.kallsyms]"),
1560	OPT_BOOLEAN('\0', "show-task-events", &script.show_task_events,
1561		    "Show the fork/comm/exit events"),
1562	OPT_BOOLEAN('\0', "show-mmap-events", &script.show_mmap_events,
1563		    "Show the mmap events"),
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1564	OPT_END()
1565	};
1566	const char * const script_usage[] = {
 
1567		"perf script [<options>]",
1568		"perf script [<options>] record <script> [<record-options>] <command>",
1569		"perf script [<options>] report <script> [script-args]",
1570		"perf script [<options>] <script> [<record-options>] <command>",
1571		"perf script [<options>] <top-script> [script-args]",
1572		NULL
1573	};
1574	struct perf_data_file file = {
1575		.mode = PERF_DATA_MODE_READ,
1576	};
1577
1578	setup_scripting();
1579
1580	argc = parse_options(argc, argv, options, script_usage,
1581			     PARSE_OPT_STOP_AT_NON_OPTION);
1582
1583	file.path = input_name;
 
 
 
 
 
 
 
 
 
 
 
1584
1585	if (argc > 1 && !strncmp(argv[0], "rec", strlen("rec"))) {
1586		rec_script_path = get_script_path(argv[1], RECORD_SUFFIX);
1587		if (!rec_script_path)
1588			return cmd_record(argc, argv, NULL);
1589	}
1590
1591	if (argc > 1 && !strncmp(argv[0], "rep", strlen("rep"))) {
1592		rep_script_path = get_script_path(argv[1], REPORT_SUFFIX);
1593		if (!rep_script_path) {
1594			fprintf(stderr,
1595				"Please specify a valid report script"
1596				"(see 'perf script -l' for listing)\n");
1597			return -1;
1598		}
1599	}
1600
 
 
 
 
 
 
 
 
 
 
 
1601	/* make sure PERF_EXEC_PATH is set for scripts */
1602	perf_set_argv_exec_path(perf_exec_path());
1603
1604	if (argc && !script_name && !rec_script_path && !rep_script_path) {
1605		int live_pipe[2];
1606		int rep_args;
1607		pid_t pid;
1608
1609		rec_script_path = get_script_path(argv[0], RECORD_SUFFIX);
1610		rep_script_path = get_script_path(argv[0], REPORT_SUFFIX);
1611
1612		if (!rec_script_path && !rep_script_path) {
1613			fprintf(stderr, " Couldn't find script %s\n\n See perf"
 
 
 
 
 
 
 
1614				" script -l for available scripts.\n", argv[0]);
1615			usage_with_options(script_usage, options);
1616		}
1617
1618		if (is_top_script(argv[0])) {
1619			rep_args = argc - 1;
1620		} else {
1621			int rec_args;
1622
1623			rep_args = has_required_arg(rep_script_path);
1624			rec_args = (argc - 1) - rep_args;
1625			if (rec_args < 0) {
1626				fprintf(stderr, " %s script requires options."
 
1627					"\n\n See perf script -l for available "
1628					"scripts and options.\n", argv[0]);
1629				usage_with_options(script_usage, options);
1630			}
1631		}
1632
1633		if (pipe(live_pipe) < 0) {
1634			perror("failed to create pipe");
1635			return -1;
1636		}
1637
1638		pid = fork();
1639		if (pid < 0) {
1640			perror("failed to fork");
1641			return -1;
1642		}
1643
1644		if (!pid) {
1645			j = 0;
1646
1647			dup2(live_pipe[1], 1);
1648			close(live_pipe[0]);
1649
1650			if (is_top_script(argv[0])) {
1651				system_wide = true;
1652			} else if (!system_wide) {
1653				if (have_cmd(argc - rep_args, &argv[rep_args]) != 0) {
1654					err = -1;
1655					goto out;
1656				}
1657			}
1658
1659			__argv = malloc((argc + 6) * sizeof(const char *));
1660			if (!__argv) {
1661				pr_err("malloc failed\n");
1662				err = -ENOMEM;
1663				goto out;
1664			}
1665
1666			__argv[j++] = "/bin/sh";
1667			__argv[j++] = rec_script_path;
1668			if (system_wide)
1669				__argv[j++] = "-a";
1670			__argv[j++] = "-q";
1671			__argv[j++] = "-o";
1672			__argv[j++] = "-";
1673			for (i = rep_args + 1; i < argc; i++)
1674				__argv[j++] = argv[i];
1675			__argv[j++] = NULL;
1676
1677			execvp("/bin/sh", (char **)__argv);
1678			free(__argv);
1679			exit(-1);
1680		}
1681
1682		dup2(live_pipe[0], 0);
1683		close(live_pipe[1]);
1684
1685		__argv = malloc((argc + 4) * sizeof(const char *));
1686		if (!__argv) {
1687			pr_err("malloc failed\n");
1688			err = -ENOMEM;
1689			goto out;
1690		}
1691
1692		j = 0;
1693		__argv[j++] = "/bin/sh";
1694		__argv[j++] = rep_script_path;
1695		for (i = 1; i < rep_args + 1; i++)
1696			__argv[j++] = argv[i];
1697		__argv[j++] = "-i";
1698		__argv[j++] = "-";
1699		__argv[j++] = NULL;
1700
1701		execvp("/bin/sh", (char **)__argv);
1702		free(__argv);
1703		exit(-1);
1704	}
1705
1706	if (rec_script_path)
1707		script_path = rec_script_path;
1708	if (rep_script_path)
1709		script_path = rep_script_path;
1710
1711	if (script_path) {
1712		j = 0;
1713
1714		if (!rec_script_path)
1715			system_wide = false;
1716		else if (!system_wide) {
1717			if (have_cmd(argc - 1, &argv[1]) != 0) {
1718				err = -1;
1719				goto out;
1720			}
1721		}
1722
1723		__argv = malloc((argc + 2) * sizeof(const char *));
1724		if (!__argv) {
1725			pr_err("malloc failed\n");
1726			err = -ENOMEM;
1727			goto out;
1728		}
1729
1730		__argv[j++] = "/bin/sh";
1731		__argv[j++] = script_path;
1732		if (system_wide)
1733			__argv[j++] = "-a";
1734		for (i = 2; i < argc; i++)
1735			__argv[j++] = argv[i];
1736		__argv[j++] = NULL;
1737
1738		execvp("/bin/sh", (char **)__argv);
1739		free(__argv);
1740		exit(-1);
1741	}
1742
1743	if (symbol__init() < 0)
1744		return -1;
1745	if (!script_name)
 
 
 
 
1746		setup_pager();
 
 
1747
1748	session = perf_session__new(&file, false, &script.tool);
1749	if (session == NULL)
1750		return -ENOMEM;
1751
1752	if (header || header_only) {
 
1753		perf_session__fprintf_info(session, stdout, show_full_info);
1754		if (header_only)
1755			return 0;
1756	}
 
 
 
 
 
 
 
 
 
 
 
 
1757
1758	script.session = session;
 
 
 
 
 
 
 
1759
1760	if (cpu_list) {
1761		if (perf_session__cpu_bitmap(session, cpu_list, cpu_bitmap))
1762			return -1;
 
 
1763	}
1764
1765	if (!no_callchain)
1766		symbol_conf.use_callchain = true;
1767	else
1768		symbol_conf.use_callchain = false;
1769
 
 
 
 
 
 
 
 
 
1770	if (generate_script_lang) {
1771		struct stat perf_stat;
1772		int input;
1773
1774		if (output_set_by_user()) {
1775			fprintf(stderr,
1776				"custom fields not supported for generated scripts");
1777			return -1;
 
1778		}
1779
1780		input = open(file.path, O_RDONLY);	/* input_name */
1781		if (input < 0) {
 
1782			perror("failed to open file");
1783			return -1;
1784		}
1785
1786		err = fstat(input, &perf_stat);
1787		if (err < 0) {
1788			perror("failed to stat file");
1789			return -1;
1790		}
1791
1792		if (!perf_stat.st_size) {
1793			fprintf(stderr, "zero-sized file, nothing to do!\n");
1794			return 0;
1795		}
1796
1797		scripting_ops = script_spec__lookup(generate_script_lang);
1798		if (!scripting_ops) {
1799			fprintf(stderr, "invalid language specifier");
1800			return -1;
 
1801		}
1802
1803		err = scripting_ops->generate_script(session->tevent.pevent,
1804						     "perf-script");
1805		goto out;
1806	}
1807
 
 
 
 
1808	if (script_name) {
1809		err = scripting_ops->start_script(script_name, argc, argv);
1810		if (err)
1811			goto out;
1812		pr_debug("perf script started with script %s\n\n", script_name);
 
1813	}
1814
1815
1816	err = perf_session__check_output_opt(session);
1817	if (err < 0)
1818		goto out;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1819
1820	err = __cmd_script(&script);
1821
 
 
 
 
 
 
 
 
 
 
1822	perf_session__delete(session);
1823	cleanup_scripting();
 
 
 
 
 
1824out:
1825	return err;
1826}