session.c 54.5 KB
Newer Older
1
#include <linux/kernel.h>
2
#include <traceevent/event-parse.h>
3

4
#include <byteswap.h>
5 6
#include <unistd.h>
#include <sys/types.h>
7
#include <sys/mman.h>
8

9 10
#include "evlist.h"
#include "evsel.h"
11
#include "session.h"
12
#include "tool.h"
13
#include "sort.h"
14
#include "util.h"
15
#include "cpumap.h"
16
#include "perf_regs.h"
17
#include "asm/bug.h"
18
#include "auxtrace.h"
19
#include "thread-stack.h"
20

21 22 23 24 25
static int perf_session__deliver_event(struct perf_session *session,
				       union perf_event *event,
				       struct perf_sample *sample,
				       struct perf_tool *tool,
				       u64 file_offset);
26

27
static int perf_session__open(struct perf_session *session)
28
{
29
	struct perf_data_file *file = session->file;
30

31
	if (perf_session__read_header(session) < 0) {
32
		pr_err("incompatible file format (rerun with -v to learn more)");
33
		return -1;
34 35
	}

36 37 38
	if (perf_data_file__is_pipe(file))
		return 0;

39
	if (!perf_evlist__valid_sample_type(session->evlist)) {
40
		pr_err("non matching sample_type");
41
		return -1;
42 43
	}

44
	if (!perf_evlist__valid_sample_id_all(session->evlist)) {
45
		pr_err("non matching sample_id_all");
46
		return -1;
47 48
	}

49
	if (!perf_evlist__valid_read_format(session->evlist)) {
50
		pr_err("non matching read_format");
51
		return -1;
52 53
	}

54 55 56
	return 0;
}

57
void perf_session__set_id_hdr_size(struct perf_session *session)
58
{
59 60 61
	u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);

	machines__set_id_hdr_size(&session->machines, id_hdr_size);
62 63
}

64
int perf_session__create_kernel_maps(struct perf_session *session)
65
{
66
	int ret = machine__create_kernel_maps(&session->machines.host);
67 68

	if (ret >= 0)
69
		ret = machines__create_guest_kernel_maps(&session->machines);
70 71 72
	return ret;
}

73
static void perf_session__destroy_kernel_maps(struct perf_session *session)
74
{
75
	machines__destroy_kernel_maps(&session->machines);
76 77
}

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
static bool perf_session__has_comm_exec(struct perf_session *session)
{
	struct perf_evsel *evsel;

	evlist__for_each(session->evlist, evsel) {
		if (evsel->attr.comm_exec)
			return true;
	}

	return false;
}

static void perf_session__set_comm_exec(struct perf_session *session)
{
	bool comm_exec = perf_session__has_comm_exec(session);

	machines__set_comm_exec(&session->machines, comm_exec);
}

97
static int ordered_events__deliver_event(struct ordered_events *oe,
98
					 struct ordered_event *event)
99
{
100 101 102 103 104 105 106 107 108 109
	struct perf_sample sample;
	struct perf_session *session = container_of(oe, struct perf_session,
						    ordered_events);
	int ret = perf_evlist__parse_sample(session->evlist, event->event, &sample);

	if (ret) {
		pr_err("Can't parse sample, err = %d\n", ret);
		return ret;
	}

110 111
	return perf_session__deliver_event(session, event->event, &sample,
					   session->tool, event->file_offset);
112 113
}

114 115
struct perf_session *perf_session__new(struct perf_data_file *file,
				       bool repipe, struct perf_tool *tool)
116
{
117
	struct perf_session *session = zalloc(sizeof(*session));
118

119
	if (!session)
120 121
		goto out;

122
	session->repipe = repipe;
123
	session->tool   = tool;
124
	INIT_LIST_HEAD(&session->auxtrace_index);
125
	machines__init(&session->machines);
126
	ordered_events__init(&session->ordered_events, ordered_events__deliver_event);
127

128 129
	if (file) {
		if (perf_data_file__open(file))
130
			goto out_delete;
131

132
		session->file = file;
133 134

		if (perf_data_file__is_read(file)) {
135
			if (perf_session__open(session) < 0)
136 137
				goto out_close;

138
			perf_session__set_id_hdr_size(session);
139
			perf_session__set_comm_exec(session);
140
		}
141 142
	} else  {
		session->machines.host.env = &perf_env;
143 144 145
	}

	if (!file || perf_data_file__is_write(file)) {
146 147
		/*
		 * In O_RDONLY mode this will be performed when reading the
148
		 * kernel MMAP event, in perf_event__process_mmap().
149
		 */
150
		if (perf_session__create_kernel_maps(session) < 0)
151
			pr_warning("Cannot read kernel map\n");
152
	}
153

154
	if (tool && tool->ordering_requires_timestamps &&
155
	    tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
156
		dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
157
		tool->ordered_events = false;
158
	}
159

160
	return session;
161 162 163 164

 out_close:
	perf_data_file__close(file);
 out_delete:
165
	perf_session__delete(session);
166
 out:
167
	return NULL;
168 169
}

170 171
static void perf_session__delete_threads(struct perf_session *session)
{
172
	machine__delete_threads(&session->machines.host);
173 174
}

175
void perf_session__delete(struct perf_session *session)
176
{
177
	auxtrace__free(session);
178
	auxtrace_index__free(&session->auxtrace_index);
179 180
	perf_session__destroy_kernel_maps(session);
	perf_session__delete_threads(session);
181
	perf_env__exit(&session->header.env);
182 183 184 185
	machines__exit(&session->machines);
	if (session->file)
		perf_data_file__close(session->file);
	free(session);
186
}
187

188 189 190
static int process_event_synth_tracing_data_stub(struct perf_tool *tool
						 __maybe_unused,
						 union perf_event *event
191 192 193
						 __maybe_unused,
						 struct perf_session *session
						__maybe_unused)
194 195 196 197 198
{
	dump_printf(": unhandled!\n");
	return 0;
}

199 200
static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
					 union perf_event *event __maybe_unused,
201 202
					 struct perf_evlist **pevlist
					 __maybe_unused)
203 204 205 206 207
{
	dump_printf(": unhandled!\n");
	return 0;
}

208 209 210 211 212
static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
				     union perf_event *event __maybe_unused,
				     struct perf_sample *sample __maybe_unused,
				     struct perf_evsel *evsel __maybe_unused,
				     struct machine *machine __maybe_unused)
213 214 215 216 217
{
	dump_printf(": unhandled!\n");
	return 0;
}

218 219 220 221
static int process_event_stub(struct perf_tool *tool __maybe_unused,
			      union perf_event *event __maybe_unused,
			      struct perf_sample *sample __maybe_unused,
			      struct machine *machine __maybe_unused)
222 223 224 225 226
{
	dump_printf(": unhandled!\n");
	return 0;
}

227 228 229 230 231 232 233 234
static int process_build_id_stub(struct perf_tool *tool __maybe_unused,
				 union perf_event *event __maybe_unused,
				 struct perf_session *session __maybe_unused)
{
	dump_printf(": unhandled!\n");
	return 0;
}

235 236
static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
				       union perf_event *event __maybe_unused,
237
				       struct ordered_events *oe __maybe_unused)
238 239 240 241 242
{
	dump_printf(": unhandled!\n");
	return 0;
}

243
static int process_finished_round(struct perf_tool *tool,
244
				  union perf_event *event,
245
				  struct ordered_events *oe);
246

A
Adrian Hunter 已提交
247 248 249 250 251 252 253 254 255
static int process_id_index_stub(struct perf_tool *tool __maybe_unused,
				 union perf_event *event __maybe_unused,
				 struct perf_session *perf_session
				 __maybe_unused)
{
	dump_printf(": unhandled!\n");
	return 0;
}

256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
static int process_event_auxtrace_info_stub(struct perf_tool *tool __maybe_unused,
				union perf_event *event __maybe_unused,
				struct perf_session *session __maybe_unused)
{
	dump_printf(": unhandled!\n");
	return 0;
}

static int skipn(int fd, off_t n)
{
	char buf[4096];
	ssize_t ret;

	while (n > 0) {
		ret = read(fd, buf, min(n, (off_t)sizeof(buf)));
		if (ret <= 0)
			return ret;
		n -= ret;
	}

	return 0;
}

static s64 process_event_auxtrace_stub(struct perf_tool *tool __maybe_unused,
				       union perf_event *event,
				       struct perf_session *session
				       __maybe_unused)
{
	dump_printf(": unhandled!\n");
	if (perf_data_file__is_pipe(session->file))
		skipn(perf_data_file__fd(session->file), event->auxtrace.size);
	return event->auxtrace.size;
}

290 291 292 293 294 295 296 297 298
static
int process_event_auxtrace_error_stub(struct perf_tool *tool __maybe_unused,
				      union perf_event *event __maybe_unused,
				      struct perf_session *session __maybe_unused)
{
	dump_printf(": unhandled!\n");
	return 0;
}

299
void perf_tool__fill_defaults(struct perf_tool *tool)
300
{
301 302 303 304
	if (tool->sample == NULL)
		tool->sample = process_event_sample_stub;
	if (tool->mmap == NULL)
		tool->mmap = process_event_stub;
305 306
	if (tool->mmap2 == NULL)
		tool->mmap2 = process_event_stub;
307 308 309 310 311 312 313 314
	if (tool->comm == NULL)
		tool->comm = process_event_stub;
	if (tool->fork == NULL)
		tool->fork = process_event_stub;
	if (tool->exit == NULL)
		tool->exit = process_event_stub;
	if (tool->lost == NULL)
		tool->lost = perf_event__process_lost;
315 316
	if (tool->lost_samples == NULL)
		tool->lost_samples = perf_event__process_lost_samples;
317 318
	if (tool->aux == NULL)
		tool->aux = perf_event__process_aux;
319 320
	if (tool->itrace_start == NULL)
		tool->itrace_start = perf_event__process_itrace_start;
321 322
	if (tool->context_switch == NULL)
		tool->context_switch = perf_event__process_switch;
323 324 325 326 327 328 329 330 331 332 333
	if (tool->read == NULL)
		tool->read = process_event_sample_stub;
	if (tool->throttle == NULL)
		tool->throttle = process_event_stub;
	if (tool->unthrottle == NULL)
		tool->unthrottle = process_event_stub;
	if (tool->attr == NULL)
		tool->attr = process_event_synth_attr_stub;
	if (tool->tracing_data == NULL)
		tool->tracing_data = process_event_synth_tracing_data_stub;
	if (tool->build_id == NULL)
334
		tool->build_id = process_build_id_stub;
335
	if (tool->finished_round == NULL) {
336
		if (tool->ordered_events)
337
			tool->finished_round = process_finished_round;
338
		else
339
			tool->finished_round = process_finished_round_stub;
340
	}
A
Adrian Hunter 已提交
341 342
	if (tool->id_index == NULL)
		tool->id_index = process_id_index_stub;
343 344 345 346
	if (tool->auxtrace_info == NULL)
		tool->auxtrace_info = process_event_auxtrace_info_stub;
	if (tool->auxtrace == NULL)
		tool->auxtrace = process_event_auxtrace_stub;
347 348
	if (tool->auxtrace_error == NULL)
		tool->auxtrace_error = process_event_auxtrace_error_stub;
349
}
350

351 352 353 354 355 356 357 358 359 360
static void swap_sample_id_all(union perf_event *event, void *data)
{
	void *end = (void *) event + event->header.size;
	int size = end - data;

	BUG_ON(size % sizeof(u64));
	mem_bswap_64(data, size);
}

static void perf_event__all64_swap(union perf_event *event,
361
				   bool sample_id_all __maybe_unused)
362
{
363 364
	struct perf_event_header *hdr = &event->header;
	mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
365 366
}

367
static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
368
{
369 370
	event->comm.pid = bswap_32(event->comm.pid);
	event->comm.tid = bswap_32(event->comm.tid);
371 372 373 374

	if (sample_id_all) {
		void *data = &event->comm.comm;

375
		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
376 377
		swap_sample_id_all(event, data);
	}
378 379
}

380 381
static void perf_event__mmap_swap(union perf_event *event,
				  bool sample_id_all)
382
{
383 384 385 386 387
	event->mmap.pid	  = bswap_32(event->mmap.pid);
	event->mmap.tid	  = bswap_32(event->mmap.tid);
	event->mmap.start = bswap_64(event->mmap.start);
	event->mmap.len	  = bswap_64(event->mmap.len);
	event->mmap.pgoff = bswap_64(event->mmap.pgoff);
388 389 390 391

	if (sample_id_all) {
		void *data = &event->mmap.filename;

392
		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
393 394
		swap_sample_id_all(event, data);
	}
395 396
}

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
static void perf_event__mmap2_swap(union perf_event *event,
				  bool sample_id_all)
{
	event->mmap2.pid   = bswap_32(event->mmap2.pid);
	event->mmap2.tid   = bswap_32(event->mmap2.tid);
	event->mmap2.start = bswap_64(event->mmap2.start);
	event->mmap2.len   = bswap_64(event->mmap2.len);
	event->mmap2.pgoff = bswap_64(event->mmap2.pgoff);
	event->mmap2.maj   = bswap_32(event->mmap2.maj);
	event->mmap2.min   = bswap_32(event->mmap2.min);
	event->mmap2.ino   = bswap_64(event->mmap2.ino);

	if (sample_id_all) {
		void *data = &event->mmap2.filename;

		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
		swap_sample_id_all(event, data);
	}
}
416
static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
417
{
418 419 420 421 422
	event->fork.pid	 = bswap_32(event->fork.pid);
	event->fork.tid	 = bswap_32(event->fork.tid);
	event->fork.ppid = bswap_32(event->fork.ppid);
	event->fork.ptid = bswap_32(event->fork.ptid);
	event->fork.time = bswap_64(event->fork.time);
423 424 425

	if (sample_id_all)
		swap_sample_id_all(event, &event->fork + 1);
426 427
}

428
static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
429
{
430 431 432 433 434 435
	event->read.pid		 = bswap_32(event->read.pid);
	event->read.tid		 = bswap_32(event->read.tid);
	event->read.value	 = bswap_64(event->read.value);
	event->read.time_enabled = bswap_64(event->read.time_enabled);
	event->read.time_running = bswap_64(event->read.time_running);
	event->read.id		 = bswap_64(event->read.id);
436 437 438

	if (sample_id_all)
		swap_sample_id_all(event, &event->read + 1);
439 440
}

441 442 443 444 445 446 447 448 449 450
static void perf_event__aux_swap(union perf_event *event, bool sample_id_all)
{
	event->aux.aux_offset = bswap_64(event->aux.aux_offset);
	event->aux.aux_size   = bswap_64(event->aux.aux_size);
	event->aux.flags      = bswap_64(event->aux.flags);

	if (sample_id_all)
		swap_sample_id_all(event, &event->aux + 1);
}

451 452 453 454 455 456 457 458 459 460
static void perf_event__itrace_start_swap(union perf_event *event,
					  bool sample_id_all)
{
	event->itrace_start.pid	 = bswap_32(event->itrace_start.pid);
	event->itrace_start.tid	 = bswap_32(event->itrace_start.tid);

	if (sample_id_all)
		swap_sample_id_all(event, &event->itrace_start + 1);
}

461 462 463 464 465 466 467 468 469 470 471 472 473
static void perf_event__switch_swap(union perf_event *event, bool sample_id_all)
{
	if (event->header.type == PERF_RECORD_SWITCH_CPU_WIDE) {
		event->context_switch.next_prev_pid =
				bswap_32(event->context_switch.next_prev_pid);
		event->context_switch.next_prev_tid =
				bswap_32(event->context_switch.next_prev_tid);
	}

	if (sample_id_all)
		swap_sample_id_all(event, &event->context_switch + 1);
}

474 475 476 477 478 479 480 481 482 483 484
static void perf_event__throttle_swap(union perf_event *event,
				      bool sample_id_all)
{
	event->throttle.time	  = bswap_64(event->throttle.time);
	event->throttle.id	  = bswap_64(event->throttle.id);
	event->throttle.stream_id = bswap_64(event->throttle.stream_id);

	if (sample_id_all)
		swap_sample_id_all(event, &event->throttle + 1);
}

485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516
static u8 revbyte(u8 b)
{
	int rev = (b >> 4) | ((b & 0xf) << 4);
	rev = ((rev & 0xcc) >> 2) | ((rev & 0x33) << 2);
	rev = ((rev & 0xaa) >> 1) | ((rev & 0x55) << 1);
	return (u8) rev;
}

/*
 * XXX this is hack in attempt to carry flags bitfield
 * throught endian village. ABI says:
 *
 * Bit-fields are allocated from right to left (least to most significant)
 * on little-endian implementations and from left to right (most to least
 * significant) on big-endian implementations.
 *
 * The above seems to be byte specific, so we need to reverse each
 * byte of the bitfield. 'Internet' also says this might be implementation
 * specific and we probably need proper fix and carry perf_event_attr
 * bitfield flags in separate data file FEAT_ section. Thought this seems
 * to work for now.
 */
static void swap_bitfield(u8 *p, unsigned len)
{
	unsigned i;

	for (i = 0; i < len; i++) {
		*p = revbyte(*p);
		p++;
	}
}

517 518 519 520 521
/* exported for swapping attributes in file header */
void perf_event__attr_swap(struct perf_event_attr *attr)
{
	attr->type		= bswap_32(attr->type);
	attr->size		= bswap_32(attr->size);
522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557

#define bswap_safe(f, n) 					\
	(attr->size > (offsetof(struct perf_event_attr, f) + 	\
		       sizeof(attr->f) * (n)))
#define bswap_field(f, sz) 			\
do { 						\
	if (bswap_safe(f, 0))			\
		attr->f = bswap_##sz(attr->f);	\
} while(0)
#define bswap_field_32(f) bswap_field(f, 32)
#define bswap_field_64(f) bswap_field(f, 64)

	bswap_field_64(config);
	bswap_field_64(sample_period);
	bswap_field_64(sample_type);
	bswap_field_64(read_format);
	bswap_field_32(wakeup_events);
	bswap_field_32(bp_type);
	bswap_field_64(bp_addr);
	bswap_field_64(bp_len);
	bswap_field_64(branch_sample_type);
	bswap_field_64(sample_regs_user);
	bswap_field_32(sample_stack_user);
	bswap_field_32(aux_watermark);

	/*
	 * After read_format are bitfields. Check read_format because
	 * we are unable to use offsetof on bitfield.
	 */
	if (bswap_safe(read_format, 1))
		swap_bitfield((u8 *) (&attr->read_format + 1),
			      sizeof(u64));
#undef bswap_field_64
#undef bswap_field_32
#undef bswap_field
#undef bswap_safe
558 559
}

560
static void perf_event__hdr_attr_swap(union perf_event *event,
561
				      bool sample_id_all __maybe_unused)
562 563 564
{
	size_t size;

565
	perf_event__attr_swap(&event->attr.attr);
566

567 568 569
	size = event->header.size;
	size -= (void *)&event->attr.id - (void *)event;
	mem_bswap_64(event->attr.id, size);
570 571
}

572
static void perf_event__event_type_swap(union perf_event *event,
573
					bool sample_id_all __maybe_unused)
574
{
575 576
	event->event_type.event_type.event_id =
		bswap_64(event->event_type.event_type.event_id);
577 578
}

579
static void perf_event__tracing_data_swap(union perf_event *event,
580
					  bool sample_id_all __maybe_unused)
581
{
582
	event->tracing_data.size = bswap_32(event->tracing_data.size);
583 584
}

585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
static void perf_event__auxtrace_info_swap(union perf_event *event,
					   bool sample_id_all __maybe_unused)
{
	size_t size;

	event->auxtrace_info.type = bswap_32(event->auxtrace_info.type);

	size = event->header.size;
	size -= (void *)&event->auxtrace_info.priv - (void *)event;
	mem_bswap_64(event->auxtrace_info.priv, size);
}

static void perf_event__auxtrace_swap(union perf_event *event,
				      bool sample_id_all __maybe_unused)
{
	event->auxtrace.size      = bswap_64(event->auxtrace.size);
	event->auxtrace.offset    = bswap_64(event->auxtrace.offset);
	event->auxtrace.reference = bswap_64(event->auxtrace.reference);
	event->auxtrace.idx       = bswap_32(event->auxtrace.idx);
	event->auxtrace.tid       = bswap_32(event->auxtrace.tid);
	event->auxtrace.cpu       = bswap_32(event->auxtrace.cpu);
}

608 609 610 611 612 613 614 615 616 617 618
static void perf_event__auxtrace_error_swap(union perf_event *event,
					    bool sample_id_all __maybe_unused)
{
	event->auxtrace_error.type = bswap_32(event->auxtrace_error.type);
	event->auxtrace_error.code = bswap_32(event->auxtrace_error.code);
	event->auxtrace_error.cpu  = bswap_32(event->auxtrace_error.cpu);
	event->auxtrace_error.pid  = bswap_32(event->auxtrace_error.pid);
	event->auxtrace_error.tid  = bswap_32(event->auxtrace_error.tid);
	event->auxtrace_error.ip   = bswap_64(event->auxtrace_error.ip);
}

619 620
typedef void (*perf_event__swap_op)(union perf_event *event,
				    bool sample_id_all);
621

622 623
static perf_event__swap_op perf_event__swap_ops[] = {
	[PERF_RECORD_MMAP]		  = perf_event__mmap_swap,
624
	[PERF_RECORD_MMAP2]		  = perf_event__mmap2_swap,
625 626 627 628 629
	[PERF_RECORD_COMM]		  = perf_event__comm_swap,
	[PERF_RECORD_FORK]		  = perf_event__task_swap,
	[PERF_RECORD_EXIT]		  = perf_event__task_swap,
	[PERF_RECORD_LOST]		  = perf_event__all64_swap,
	[PERF_RECORD_READ]		  = perf_event__read_swap,
630 631
	[PERF_RECORD_THROTTLE]		  = perf_event__throttle_swap,
	[PERF_RECORD_UNTHROTTLE]	  = perf_event__throttle_swap,
632
	[PERF_RECORD_SAMPLE]		  = perf_event__all64_swap,
633
	[PERF_RECORD_AUX]		  = perf_event__aux_swap,
634
	[PERF_RECORD_ITRACE_START]	  = perf_event__itrace_start_swap,
635
	[PERF_RECORD_LOST_SAMPLES]	  = perf_event__all64_swap,
636 637
	[PERF_RECORD_SWITCH]		  = perf_event__switch_swap,
	[PERF_RECORD_SWITCH_CPU_WIDE]	  = perf_event__switch_swap,
638
	[PERF_RECORD_HEADER_ATTR]	  = perf_event__hdr_attr_swap,
639 640 641
	[PERF_RECORD_HEADER_EVENT_TYPE]	  = perf_event__event_type_swap,
	[PERF_RECORD_HEADER_TRACING_DATA] = perf_event__tracing_data_swap,
	[PERF_RECORD_HEADER_BUILD_ID]	  = NULL,
A
Adrian Hunter 已提交
642
	[PERF_RECORD_ID_INDEX]		  = perf_event__all64_swap,
643 644
	[PERF_RECORD_AUXTRACE_INFO]	  = perf_event__auxtrace_info_swap,
	[PERF_RECORD_AUXTRACE]		  = perf_event__auxtrace_swap,
645
	[PERF_RECORD_AUXTRACE_ERROR]	  = perf_event__auxtrace_error_swap,
646
	[PERF_RECORD_HEADER_MAX]	  = NULL,
647 648
};

649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
/*
 * When perf record finishes a pass on every buffers, it records this pseudo
 * event.
 * We record the max timestamp t found in the pass n.
 * Assuming these timestamps are monotonic across cpus, we know that if
 * a buffer still has events with timestamps below t, they will be all
 * available and then read in the pass n + 1.
 * Hence when we start to read the pass n + 2, we can safely flush every
 * events with timestamps below t.
 *
 *    ============ PASS n =================
 *       CPU 0         |   CPU 1
 *                     |
 *    cnt1 timestamps  |   cnt2 timestamps
 *          1          |         2
 *          2          |         3
 *          -          |         4  <--- max recorded
 *
 *    ============ PASS n + 1 ==============
 *       CPU 0         |   CPU 1
 *                     |
 *    cnt1 timestamps  |   cnt2 timestamps
 *          3          |         5
 *          4          |         6
 *          5          |         7 <---- max recorded
 *
 *      Flush every events below timestamp 4
 *
 *    ============ PASS n + 2 ==============
 *       CPU 0         |   CPU 1
 *                     |
 *    cnt1 timestamps  |   cnt2 timestamps
 *          6          |         8
 *          7          |         9
 *          -          |         10
 *
 *      Flush every events below timestamp 7
 *      etc...
 */
688
static int process_finished_round(struct perf_tool *tool __maybe_unused,
689
				  union perf_event *event __maybe_unused,
690
				  struct ordered_events *oe)
691
{
692 693
	if (dump_trace)
		fprintf(stdout, "\n");
694
	return ordered_events__flush(oe, OE_FLUSH__ROUND);
695 696
}

697 698
int perf_session__queue_event(struct perf_session *s, union perf_event *event,
			      struct perf_sample *sample, u64 file_offset)
699
{
700
	return ordered_events__queue(&s->ordered_events, event, sample, file_offset);
701
}
702

K
Kan Liang 已提交
703
static void callchain__lbr_callstack_printf(struct perf_sample *sample)
704
{
K
Kan Liang 已提交
705 706 707
	struct ip_callchain *callchain = sample->callchain;
	struct branch_stack *lbr_stack = sample->branch_stack;
	u64 kernel_callchain_nr = callchain->nr;
708
	unsigned int i;
709

K
Kan Liang 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
	for (i = 0; i < kernel_callchain_nr; i++) {
		if (callchain->ips[i] == PERF_CONTEXT_USER)
			break;
	}

	if ((i != kernel_callchain_nr) && lbr_stack->nr) {
		u64 total_nr;
		/*
		 * LBR callstack can only get user call chain,
		 * i is kernel call chain number,
		 * 1 is PERF_CONTEXT_USER.
		 *
		 * The user call chain is stored in LBR registers.
		 * LBR are pair registers. The caller is stored
		 * in "from" register, while the callee is stored
		 * in "to" register.
		 * For example, there is a call stack
		 * "A"->"B"->"C"->"D".
		 * The LBR registers will recorde like
		 * "C"->"D", "B"->"C", "A"->"B".
		 * So only the first "to" register and all "from"
		 * registers are needed to construct the whole stack.
		 */
		total_nr = i + 1 + lbr_stack->nr + 1;
		kernel_callchain_nr = i + 1;

		printf("... LBR call chain: nr:%" PRIu64 "\n", total_nr);

		for (i = 0; i < kernel_callchain_nr; i++)
			printf("..... %2d: %016" PRIx64 "\n",
			       i, callchain->ips[i]);

		printf("..... %2d: %016" PRIx64 "\n",
		       (int)(kernel_callchain_nr), lbr_stack->entries[0].to);
		for (i = 0; i < lbr_stack->nr; i++)
			printf("..... %2d: %016" PRIx64 "\n",
			       (int)(i + kernel_callchain_nr + 1), lbr_stack->entries[i].from);
	}
}

static void callchain__printf(struct perf_evsel *evsel,
			      struct perf_sample *sample)
{
	unsigned int i;
	struct ip_callchain *callchain = sample->callchain;

	if (has_branch_callstack(evsel))
		callchain__lbr_callstack_printf(sample);

	printf("... FP chain: nr:%" PRIu64 "\n", callchain->nr);
760

K
Kan Liang 已提交
761
	for (i = 0; i < callchain->nr; i++)
762
		printf("..... %2d: %016" PRIx64 "\n",
K
Kan Liang 已提交
763
		       i, callchain->ips[i]);
764 765
}

766 767 768 769 770 771
static void branch_stack__printf(struct perf_sample *sample)
{
	uint64_t i;

	printf("... branch stack: nr:%" PRIu64 "\n", sample->branch_stack->nr);

772 773 774 775 776 777 778 779 780 781 782 783
	for (i = 0; i < sample->branch_stack->nr; i++) {
		struct branch_entry *e = &sample->branch_stack->entries[i];

		printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 " %hu cycles %s%s%s%s %x\n",
			i, e->from, e->to,
			e->flags.cycles,
			e->flags.mispred ? "M" : " ",
			e->flags.predicted ? "P" : " ",
			e->flags.abort ? "A" : " ",
			e->flags.in_tx ? "T" : " ",
			(unsigned)e->flags.reserved);
	}
784 785
}

786 787 788 789 790 791 792 793 794 795 796 797
static void regs_dump__printf(u64 mask, u64 *regs)
{
	unsigned rid, i = 0;

	for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
		u64 val = regs[i++];

		printf(".... %-5s 0x%" PRIx64 "\n",
		       perf_reg_name(rid), val);
	}
}

798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823
static const char *regs_abi[] = {
	[PERF_SAMPLE_REGS_ABI_NONE] = "none",
	[PERF_SAMPLE_REGS_ABI_32] = "32-bit",
	[PERF_SAMPLE_REGS_ABI_64] = "64-bit",
};

static inline const char *regs_dump_abi(struct regs_dump *d)
{
	if (d->abi > PERF_SAMPLE_REGS_ABI_64)
		return "unknown";

	return regs_abi[d->abi];
}

static void regs__printf(const char *type, struct regs_dump *regs)
{
	u64 mask = regs->mask;

	printf("... %s regs: mask 0x%" PRIx64 " ABI %s\n",
	       type,
	       mask,
	       regs_dump_abi(regs));

	regs_dump__printf(mask, regs->regs);
}

824
static void regs_user__printf(struct perf_sample *sample)
825 826 827
{
	struct regs_dump *user_regs = &sample->user_regs;

828 829 830 831 832 833 834 835 836 837
	if (user_regs->regs)
		regs__printf("user", user_regs);
}

static void regs_intr__printf(struct perf_sample *sample)
{
	struct regs_dump *intr_regs = &sample->intr_regs;

	if (intr_regs->regs)
		regs__printf("intr", intr_regs);
838 839 840 841 842 843 844 845
}

static void stack_user__printf(struct stack_dump *dump)
{
	printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
	       dump->size, dump->offset);
}

846
static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
847
				       union perf_event *event,
848
				       struct perf_sample *sample)
849
{
850
	u64 sample_type = __perf_evlist__combined_sample_type(evlist);
851

852
	if (event->header.type != PERF_RECORD_SAMPLE &&
853
	    !perf_evlist__sample_id_all(evlist)) {
854 855 856 857
		fputs("-1 -1 ", stdout);
		return;
	}

858
	if ((sample_type & PERF_SAMPLE_CPU))
859 860
		printf("%u ", sample->cpu);

861
	if (sample_type & PERF_SAMPLE_TIME)
862
		printf("%" PRIu64 " ", sample->time);
863 864
}

865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894
static void sample_read__printf(struct perf_sample *sample, u64 read_format)
{
	printf("... sample_read:\n");

	if (read_format & PERF_FORMAT_TOTAL_TIME_ENABLED)
		printf("...... time enabled %016" PRIx64 "\n",
		       sample->read.time_enabled);

	if (read_format & PERF_FORMAT_TOTAL_TIME_RUNNING)
		printf("...... time running %016" PRIx64 "\n",
		       sample->read.time_running);

	if (read_format & PERF_FORMAT_GROUP) {
		u64 i;

		printf(".... group nr %" PRIu64 "\n", sample->read.group.nr);

		for (i = 0; i < sample->read.group.nr; i++) {
			struct sample_read_value *value;

			value = &sample->read.group.values[i];
			printf("..... id %016" PRIx64
			       ", value %016" PRIx64 "\n",
			       value->id, value->value);
		}
	} else
		printf("..... id %016" PRIx64 ", value %016" PRIx64 "\n",
			sample->read.one.id, sample->read.one.value);
}

895
static void dump_event(struct perf_evlist *evlist, union perf_event *event,
896
		       u64 file_offset, struct perf_sample *sample)
897 898 899 900
{
	if (!dump_trace)
		return;

901 902
	printf("\n%#" PRIx64 " [%#x]: event: %d\n",
	       file_offset, event->header.size, event->header.type);
903 904 905 906

	trace_event(event);

	if (sample)
907
		perf_evlist__print_tstamp(evlist, event, sample);
908

909
	printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
910
	       event->header.size, perf_event__name(event->header.type));
911 912
}

913
static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
914
			struct perf_sample *sample)
915
{
916 917
	u64 sample_type;

918 919 920
	if (!dump_trace)
		return;

921
	printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
922
	       event->header.misc, sample->pid, sample->tid, sample->ip,
923
	       sample->period, sample->addr);
924

925
	sample_type = evsel->attr.sample_type;
926 927

	if (sample_type & PERF_SAMPLE_CALLCHAIN)
K
Kan Liang 已提交
928
		callchain__printf(evsel, sample);
929

K
Kan Liang 已提交
930
	if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel))
931
		branch_stack__printf(sample);
932 933

	if (sample_type & PERF_SAMPLE_REGS_USER)
934
		regs_user__printf(sample);
935

936 937 938
	if (sample_type & PERF_SAMPLE_REGS_INTR)
		regs_intr__printf(sample);

939 940
	if (sample_type & PERF_SAMPLE_STACK_USER)
		stack_user__printf(&sample->user_stack);
941 942 943

	if (sample_type & PERF_SAMPLE_WEIGHT)
		printf("... weight: %" PRIu64 "\n", sample->weight);
944 945 946

	if (sample_type & PERF_SAMPLE_DATA_SRC)
		printf(" . data_src: 0x%"PRIx64"\n", sample->data_src);
947

948 949 950
	if (sample_type & PERF_SAMPLE_TRANSACTION)
		printf("... transaction: %" PRIx64 "\n", sample->transaction);

951 952
	if (sample_type & PERF_SAMPLE_READ)
		sample_read__printf(sample, evsel->attr.read_format);
953 954
}

955
static struct machine *machines__find_for_cpumode(struct machines *machines,
956 957
					       union perf_event *event,
					       struct perf_sample *sample)
958 959
{
	const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
960
	struct machine *machine;
961

962 963 964
	if (perf_guest &&
	    ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
	     (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
965 966
		u32 pid;

967 968
		if (event->header.type == PERF_RECORD_MMAP
		    || event->header.type == PERF_RECORD_MMAP2)
969 970
			pid = event->mmap.pid;
		else
971
			pid = sample->pid;
972

973
		machine = machines__find(machines, pid);
974
		if (!machine)
975
			machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID);
976
		return machine;
977
	}
978

979
	return &machines->host;
980 981
}

982
static int deliver_sample_value(struct perf_evlist *evlist,
983 984 985 986 987 988
				struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct sample_read_value *v,
				struct machine *machine)
{
989
	struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
990 991 992 993 994 995 996 997

	if (sid) {
		sample->id     = v->id;
		sample->period = v->value - sid->period;
		sid->period    = v->value;
	}

	if (!sid || sid->evsel == NULL) {
998
		++evlist->stats.nr_unknown_id;
999 1000 1001 1002 1003 1004
		return 0;
	}

	return tool->sample(tool, event, sample, sid->evsel, machine);
}

1005
static int deliver_sample_group(struct perf_evlist *evlist,
1006 1007 1008 1009 1010 1011 1012 1013 1014
				struct perf_tool *tool,
				union  perf_event *event,
				struct perf_sample *sample,
				struct machine *machine)
{
	int ret = -EINVAL;
	u64 i;

	for (i = 0; i < sample->read.group.nr; i++) {
1015
		ret = deliver_sample_value(evlist, tool, event, sample,
1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
					   &sample->read.group.values[i],
					   machine);
		if (ret)
			break;
	}

	return ret;
}

static int
1026
 perf_evlist__deliver_sample(struct perf_evlist *evlist,
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
			     struct perf_tool *tool,
			     union  perf_event *event,
			     struct perf_sample *sample,
			     struct perf_evsel *evsel,
			     struct machine *machine)
{
	/* We know evsel != NULL. */
	u64 sample_type = evsel->attr.sample_type;
	u64 read_format = evsel->attr.read_format;

	/* Standard sample delievery. */
	if (!(sample_type & PERF_SAMPLE_READ))
		return tool->sample(tool, event, sample, evsel, machine);

	/* For PERF_SAMPLE_READ we have either single or group mode. */
	if (read_format & PERF_FORMAT_GROUP)
1043
		return deliver_sample_group(evlist, tool, event, sample,
1044 1045
					    machine);
	else
1046
		return deliver_sample_value(evlist, tool, event, sample,
1047 1048 1049
					    &sample->read.one, machine);
}

1050 1051 1052 1053 1054
static int machines__deliver_event(struct machines *machines,
				   struct perf_evlist *evlist,
				   union perf_event *event,
				   struct perf_sample *sample,
				   struct perf_tool *tool, u64 file_offset)
1055
{
1056
	struct perf_evsel *evsel;
1057
	struct machine *machine;
1058

1059
	dump_event(evlist, event, file_offset, sample);
1060

1061
	evsel = perf_evlist__id2evsel(evlist, sample->id);
1062

1063
	machine = machines__find_for_cpumode(machines, event, sample);
1064

1065 1066
	switch (event->header.type) {
	case PERF_RECORD_SAMPLE:
1067
		if (evsel == NULL) {
1068
			++evlist->stats.nr_unknown_id;
1069
			return 0;
1070
		}
1071
		dump_sample(evsel, event, sample);
1072
		if (machine == NULL) {
1073
			++evlist->stats.nr_unprocessable_samples;
1074
			return 0;
1075
		}
1076
		return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
1077
	case PERF_RECORD_MMAP:
1078
		return tool->mmap(tool, event, sample, machine);
1079
	case PERF_RECORD_MMAP2:
1080 1081
		if (event->header.misc & PERF_RECORD_MISC_PROC_MAP_PARSE_TIMEOUT)
			++evlist->stats.nr_proc_map_timeout;
1082
		return tool->mmap2(tool, event, sample, machine);
1083
	case PERF_RECORD_COMM:
1084
		return tool->comm(tool, event, sample, machine);
1085
	case PERF_RECORD_FORK:
1086
		return tool->fork(tool, event, sample, machine);
1087
	case PERF_RECORD_EXIT:
1088
		return tool->exit(tool, event, sample, machine);
1089
	case PERF_RECORD_LOST:
1090
		if (tool->lost == perf_event__process_lost)
1091
			evlist->stats.total_lost += event->lost.lost;
1092
		return tool->lost(tool, event, sample, machine);
1093 1094 1095 1096
	case PERF_RECORD_LOST_SAMPLES:
		if (tool->lost_samples == perf_event__process_lost_samples)
			evlist->stats.total_lost_samples += event->lost_samples.lost;
		return tool->lost_samples(tool, event, sample, machine);
1097
	case PERF_RECORD_READ:
1098
		return tool->read(tool, event, sample, evsel, machine);
1099
	case PERF_RECORD_THROTTLE:
1100
		return tool->throttle(tool, event, sample, machine);
1101
	case PERF_RECORD_UNTHROTTLE:
1102
		return tool->unthrottle(tool, event, sample, machine);
1103 1104
	case PERF_RECORD_AUX:
		return tool->aux(tool, event, sample, machine);
1105 1106
	case PERF_RECORD_ITRACE_START:
		return tool->itrace_start(tool, event, sample, machine);
1107 1108 1109
	case PERF_RECORD_SWITCH:
	case PERF_RECORD_SWITCH_CPU_WIDE:
		return tool->context_switch(tool, event, sample, machine);
1110
	default:
1111
		++evlist->stats.nr_unknown_events;
1112 1113 1114 1115
		return -1;
	}
}

1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
static int perf_session__deliver_event(struct perf_session *session,
				       union perf_event *event,
				       struct perf_sample *sample,
				       struct perf_tool *tool,
				       u64 file_offset)
{
	int ret;

	ret = auxtrace__process_event(session, event, sample, tool);
	if (ret < 0)
		return ret;
	if (ret > 0)
		return 0;

	return machines__deliver_event(&session->machines, session->evlist,
				       event, sample, tool, file_offset);
}

1134 1135 1136
static s64 perf_session__process_user_event(struct perf_session *session,
					    union perf_event *event,
					    u64 file_offset)
1137
{
1138
	struct ordered_events *oe = &session->ordered_events;
1139
	struct perf_tool *tool = session->tool;
1140
	int fd = perf_data_file__fd(session->file);
1141 1142
	int err;

1143
	dump_event(session->evlist, event, file_offset, NULL);
1144

1145
	/* These events are processed right away */
1146
	switch (event->header.type) {
1147
	case PERF_RECORD_HEADER_ATTR:
1148
		err = tool->attr(tool, event, &session->evlist);
1149
		if (err == 0) {
1150
			perf_session__set_id_hdr_size(session);
1151 1152
			perf_session__set_comm_exec(session);
		}
1153
		return err;
1154 1155 1156 1157 1158 1159
	case PERF_RECORD_HEADER_EVENT_TYPE:
		/*
		 * Depreceated, but we need to handle it for sake
		 * of old data files create in pipe mode.
		 */
		return 0;
1160 1161
	case PERF_RECORD_HEADER_TRACING_DATA:
		/* setup for reading amidst mmap */
1162
		lseek(fd, file_offset, SEEK_SET);
1163
		return tool->tracing_data(tool, event, session);
1164
	case PERF_RECORD_HEADER_BUILD_ID:
1165
		return tool->build_id(tool, event, session);
1166
	case PERF_RECORD_FINISHED_ROUND:
1167
		return tool->finished_round(tool, event, oe);
A
Adrian Hunter 已提交
1168 1169
	case PERF_RECORD_ID_INDEX:
		return tool->id_index(tool, event, session);
1170 1171 1172 1173 1174 1175
	case PERF_RECORD_AUXTRACE_INFO:
		return tool->auxtrace_info(tool, event, session);
	case PERF_RECORD_AUXTRACE:
		/* setup for reading amidst mmap */
		lseek(fd, file_offset + event->header.size, SEEK_SET);
		return tool->auxtrace(tool, event, session);
1176
	case PERF_RECORD_AUXTRACE_ERROR:
1177
		perf_session__auxtrace_error_inc(session, event);
1178
		return tool->auxtrace_error(tool, event, session);
1179
	default:
1180
		return -EINVAL;
1181
	}
1182 1183
}

1184 1185
int perf_session__deliver_synth_event(struct perf_session *session,
				      union perf_event *event,
1186
				      struct perf_sample *sample)
1187
{
1188
	struct perf_evlist *evlist = session->evlist;
1189
	struct perf_tool *tool = session->tool;
1190 1191

	events_stats__inc(&evlist->stats, event->header.type);
1192 1193

	if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1194
		return perf_session__process_user_event(session, event, 0);
1195

1196
	return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
1197 1198
}

1199 1200 1201 1202 1203 1204 1205 1206 1207
static void event_swap(union perf_event *event, bool sample_id_all)
{
	perf_event__swap_op swap;

	swap = perf_event__swap_ops[event->header.type];
	if (swap)
		swap(event, sample_id_all);
}

1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
int perf_session__peek_event(struct perf_session *session, off_t file_offset,
			     void *buf, size_t buf_sz,
			     union perf_event **event_ptr,
			     struct perf_sample *sample)
{
	union perf_event *event;
	size_t hdr_sz, rest;
	int fd;

	if (session->one_mmap && !session->header.needs_swap) {
		event = file_offset - session->one_mmap_offset +
			session->one_mmap_addr;
		goto out_parse_sample;
	}

	if (perf_data_file__is_pipe(session->file))
		return -1;

	fd = perf_data_file__fd(session->file);
	hdr_sz = sizeof(struct perf_event_header);

	if (buf_sz < hdr_sz)
		return -1;

	if (lseek(fd, file_offset, SEEK_SET) == (off_t)-1 ||
1233
	    readn(fd, buf, hdr_sz) != (ssize_t)hdr_sz)
1234 1235 1236 1237 1238 1239 1240
		return -1;

	event = (union perf_event *)buf;

	if (session->header.needs_swap)
		perf_event_header__bswap(&event->header);

1241
	if (event->header.size < hdr_sz || event->header.size > buf_sz)
1242 1243 1244 1245
		return -1;

	rest = event->header.size - hdr_sz;

1246
	if (readn(fd, buf, rest) != (ssize_t)rest)
1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262
		return -1;

	if (session->header.needs_swap)
		event_swap(event, perf_evlist__sample_id_all(session->evlist));

out_parse_sample:

	if (sample && event->header.type < PERF_RECORD_USER_TYPE_START &&
	    perf_evlist__parse_sample(session->evlist, event, sample))
		return -1;

	*event_ptr = event;

	return 0;
}

1263
static s64 perf_session__process_event(struct perf_session *session,
1264
				       union perf_event *event, u64 file_offset)
1265
{
1266
	struct perf_evlist *evlist = session->evlist;
1267
	struct perf_tool *tool = session->tool;
1268
	struct perf_sample sample;
1269 1270
	int ret;

1271
	if (session->header.needs_swap)
1272
		event_swap(event, perf_evlist__sample_id_all(evlist));
1273 1274 1275 1276

	if (event->header.type >= PERF_RECORD_HEADER_MAX)
		return -EINVAL;

1277
	events_stats__inc(&evlist->stats, event->header.type);
1278 1279

	if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1280
		return perf_session__process_user_event(session, event, file_offset);
1281

1282 1283 1284
	/*
	 * For all kernel events we get the sample data
	 */
1285
	ret = perf_evlist__parse_sample(evlist, event, &sample);
1286 1287
	if (ret)
		return ret;
1288

1289
	if (tool->ordered_events) {
1290
		ret = perf_session__queue_event(session, event, &sample, file_offset);
1291 1292 1293 1294
		if (ret != -ETIME)
			return ret;
	}

1295 1296
	return perf_session__deliver_event(session, event, &sample, tool,
					   file_offset);
1297 1298
}

1299
void perf_event_header__bswap(struct perf_event_header *hdr)
1300
{
1301 1302 1303
	hdr->type = bswap_32(hdr->type);
	hdr->misc = bswap_16(hdr->misc);
	hdr->size = bswap_16(hdr->size);
1304 1305
}

1306 1307
struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
{
1308
	return machine__findnew_thread(&session->machines.host, -1, pid);
1309 1310
}

1311
static struct thread *perf_session__register_idle_thread(struct perf_session *session)
1312
{
1313
	struct thread *thread;
1314

1315
	thread = machine__findnew_thread(&session->machines.host, 0, 0);
1316
	if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
1317 1318 1319 1320 1321 1322 1323
		pr_err("problem inserting idle task.\n");
		thread = NULL;
	}

	return thread;
}

1324
static void perf_session__warn_about_errors(const struct perf_session *session)
1325
{
1326 1327 1328 1329
	const struct events_stats *stats = &session->evlist->stats;
	const struct ordered_events *oe = &session->ordered_events;

	if (session->tool->lost == perf_event__process_lost &&
1330
	    stats->nr_events[PERF_RECORD_LOST] != 0) {
1331 1332
		ui__warning("Processed %d events and lost %d chunks!\n\n"
			    "Check IO/CPU overload!\n\n",
1333 1334
			    stats->nr_events[0],
			    stats->nr_events[PERF_RECORD_LOST]);
1335 1336
	}

1337 1338 1339 1340 1341 1342
	if (session->tool->lost_samples == perf_event__process_lost_samples) {
		double drop_rate;

		drop_rate = (double)stats->total_lost_samples /
			    (double) (stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples);
		if (drop_rate > 0.05) {
1343
			ui__warning("Processed %" PRIu64 " samples and lost %3.2f%% samples!\n\n",
1344 1345 1346 1347 1348
				    stats->nr_events[PERF_RECORD_SAMPLE] + stats->total_lost_samples,
				    drop_rate * 100.0);
		}
	}

1349
	if (stats->nr_unknown_events != 0) {
1350 1351 1352 1353 1354
		ui__warning("Found %u unknown events!\n\n"
			    "Is this an older tool processing a perf.data "
			    "file generated by a more recent tool?\n\n"
			    "If that is not the case, consider "
			    "reporting to linux-kernel@vger.kernel.org.\n\n",
1355
			    stats->nr_unknown_events);
1356 1357
	}

1358
	if (stats->nr_unknown_id != 0) {
1359
		ui__warning("%u samples with id not present in the header\n",
1360
			    stats->nr_unknown_id);
1361 1362
	}

1363
	if (stats->nr_invalid_chains != 0) {
1364 1365 1366
		ui__warning("Found invalid callchains!\n\n"
			    "%u out of %u events were discarded for this reason.\n\n"
			    "Consider reporting to linux-kernel@vger.kernel.org.\n\n",
1367 1368
			    stats->nr_invalid_chains,
			    stats->nr_events[PERF_RECORD_SAMPLE]);
1369
	}
1370

1371
	if (stats->nr_unprocessable_samples != 0) {
1372 1373
		ui__warning("%u unprocessable samples recorded.\n"
			    "Do you have a KVM guest running and not using 'perf kvm'?\n",
1374
			    stats->nr_unprocessable_samples);
1375
	}
1376

1377 1378
	if (oe->nr_unordered_events != 0)
		ui__warning("%u out of order events recorded.\n", oe->nr_unordered_events);
1379 1380

	events_stats__auxtrace_error_warn(stats);
1381 1382 1383 1384 1385 1386

	if (stats->nr_proc_map_timeout != 0) {
		ui__warning("%d map information files for pre-existing threads were\n"
			    "not processed, if there are samples for addresses they\n"
			    "will not be resolved, you may find out which are these\n"
			    "threads by running with -v and redirecting the output\n"
1387 1388 1389
			    "to a file.\n"
			    "The time limit to process proc map is too short?\n"
			    "Increase it by --proc-map-timeout\n",
1390 1391
			    stats->nr_proc_map_timeout);
	}
1392 1393
}

1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
static int perf_session__flush_thread_stack(struct thread *thread,
					    void *p __maybe_unused)
{
	return thread_stack__flush(thread);
}

static int perf_session__flush_thread_stacks(struct perf_session *session)
{
	return machines__for_each_thread(&session->machines,
					 perf_session__flush_thread_stack,
					 NULL);
}

1407 1408
volatile int session_done;

1409
static int __perf_session__process_pipe_events(struct perf_session *session)
1410
{
1411
	struct ordered_events *oe = &session->ordered_events;
1412
	struct perf_tool *tool = session->tool;
1413
	int fd = perf_data_file__fd(session->file);
1414 1415 1416
	union perf_event *event;
	uint32_t size, cur_size = 0;
	void *buf = NULL;
1417
	s64 skip = 0;
1418
	u64 head;
1419
	ssize_t err;
1420 1421
	void *p;

1422
	perf_tool__fill_defaults(tool);
1423 1424

	head = 0;
1425 1426 1427 1428 1429
	cur_size = sizeof(union perf_event);

	buf = malloc(cur_size);
	if (!buf)
		return -errno;
1430
more:
1431
	event = buf;
1432
	err = readn(fd, event, sizeof(struct perf_event_header));
1433 1434 1435 1436 1437 1438 1439 1440
	if (err <= 0) {
		if (err == 0)
			goto done;

		pr_err("failed to read event header\n");
		goto out_err;
	}

1441
	if (session->header.needs_swap)
1442
		perf_event_header__bswap(&event->header);
1443

1444
	size = event->header.size;
1445 1446 1447 1448
	if (size < sizeof(struct perf_event_header)) {
		pr_err("bad event header size\n");
		goto out_err;
	}
1449

1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
	if (size > cur_size) {
		void *new = realloc(buf, size);
		if (!new) {
			pr_err("failed to allocate memory to read event\n");
			goto out_err;
		}
		buf = new;
		cur_size = size;
		event = buf;
	}
	p = event;
1461 1462
	p += sizeof(struct perf_event_header);

1463
	if (size - sizeof(struct perf_event_header)) {
1464
		err = readn(fd, p, size - sizeof(struct perf_event_header));
1465 1466 1467 1468 1469
		if (err <= 0) {
			if (err == 0) {
				pr_err("unexpected end of event stream\n");
				goto done;
			}
1470

1471 1472 1473
			pr_err("failed to read event data\n");
			goto out_err;
		}
1474 1475
	}

1476
	if ((skip = perf_session__process_event(session, event, head)) < 0) {
1477
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1478
		       head, event->header.size, event->header.type);
1479 1480
		err = -EINVAL;
		goto out_err;
1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
	}

	head += size;

	if (skip > 0)
		head += skip;

	if (!session_done())
		goto more;
done:
1491
	/* do the final flush for ordered samples */
1492
	err = ordered_events__flush(oe, OE_FLUSH__FINAL);
1493 1494 1495
	if (err)
		goto out_err;
	err = auxtrace__flush_events(session, tool);
1496 1497 1498
	if (err)
		goto out_err;
	err = perf_session__flush_thread_stacks(session);
1499
out_err:
1500
	free(buf);
1501
	perf_session__warn_about_errors(session);
1502
	ordered_events__free(&session->ordered_events);
1503
	auxtrace__free_events(session);
1504 1505 1506
	return err;
}

1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
static union perf_event *
fetch_mmaped_event(struct perf_session *session,
		   u64 head, size_t mmap_size, char *buf)
{
	union perf_event *event;

	/*
	 * Ensure we have enough space remaining to read
	 * the size of the event in the headers.
	 */
	if (head + sizeof(event->header) > mmap_size)
		return NULL;

	event = (union perf_event *)(buf + head);

	if (session->header.needs_swap)
		perf_event_header__bswap(&event->header);

1525 1526 1527 1528
	if (head + event->header.size > mmap_size) {
		/* We're not fetching the event so swap back again */
		if (session->header.needs_swap)
			perf_event_header__bswap(&event->header);
1529
		return NULL;
1530
	}
1531 1532 1533 1534

	return event;
}

1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546
/*
 * On 64bit we can mmap the data file in one go. No need for tiny mmap
 * slices. On 32bit we use 32MB.
 */
#if BITS_PER_LONG == 64
#define MMAP_SIZE ULLONG_MAX
#define NUM_MMAPS 1
#else
#define MMAP_SIZE (32 * 1024 * 1024ULL)
#define NUM_MMAPS 128
#endif

1547 1548
static int __perf_session__process_events(struct perf_session *session,
					  u64 data_offset, u64 data_size,
1549
					  u64 file_size)
1550
{
1551
	struct ordered_events *oe = &session->ordered_events;
1552
	struct perf_tool *tool = session->tool;
1553
	int fd = perf_data_file__fd(session->file);
1554
	u64 head, page_offset, file_offset, file_pos, size;
1555
	int err, mmap_prot, mmap_flags, map_idx = 0;
1556
	size_t	mmap_size;
1557
	char *buf, *mmaps[NUM_MMAPS];
1558
	union perf_event *event;
1559
	struct ui_progress prog;
1560
	s64 skip;
1561

1562
	perf_tool__fill_defaults(tool);
1563

1564 1565 1566
	page_offset = page_size * (data_offset / page_size);
	file_offset = page_offset;
	head = data_offset - page_offset;
1567

1568 1569 1570 1571
	if (data_size == 0)
		goto out;

	if (data_offset + data_size < file_size)
1572 1573
		file_size = data_offset + data_size;

1574
	ui_progress__init(&prog, file_size, "Processing events...");
1575

1576
	mmap_size = MMAP_SIZE;
1577
	if (mmap_size > file_size) {
1578
		mmap_size = file_size;
1579 1580
		session->one_mmap = true;
	}
1581

1582 1583
	memset(mmaps, 0, sizeof(mmaps));

1584 1585 1586
	mmap_prot  = PROT_READ;
	mmap_flags = MAP_SHARED;

1587
	if (session->header.needs_swap) {
1588 1589 1590
		mmap_prot  |= PROT_WRITE;
		mmap_flags = MAP_PRIVATE;
	}
1591
remap:
1592
	buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
1593
		   file_offset);
1594 1595 1596 1597 1598
	if (buf == MAP_FAILED) {
		pr_err("failed to mmap file\n");
		err = -errno;
		goto out_err;
	}
1599 1600
	mmaps[map_idx] = buf;
	map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
1601
	file_pos = file_offset + head;
1602 1603 1604 1605
	if (session->one_mmap) {
		session->one_mmap_addr = buf;
		session->one_mmap_offset = file_offset;
	}
1606 1607

more:
1608 1609
	event = fetch_mmaped_event(session, head, mmap_size, buf);
	if (!event) {
1610 1611 1612 1613
		if (mmaps[map_idx]) {
			munmap(mmaps[map_idx], mmap_size);
			mmaps[map_idx] = NULL;
		}
1614

1615 1616 1617
		page_offset = page_size * (head / page_size);
		file_offset += page_offset;
		head -= page_offset;
1618 1619 1620 1621 1622
		goto remap;
	}

	size = event->header.size;

1623
	if (size < sizeof(struct perf_event_header) ||
1624
	    (skip = perf_session__process_event(session, event, file_pos)) < 0) {
1625 1626 1627 1628 1629
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
		       file_offset + head, event->header.size,
		       event->header.type);
		err = -EINVAL;
		goto out_err;
1630 1631
	}

1632 1633 1634
	if (skip)
		size += skip;

1635
	head += size;
1636
	file_pos += size;
1637

1638
	ui_progress__update(&prog, size);
1639

1640
	if (session_done())
1641
		goto out;
1642

1643
	if (file_pos < file_size)
1644
		goto more;
1645

1646
out:
1647
	/* do the final flush for ordered samples */
1648
	err = ordered_events__flush(oe, OE_FLUSH__FINAL);
1649 1650 1651
	if (err)
		goto out_err;
	err = auxtrace__flush_events(session, tool);
1652 1653 1654
	if (err)
		goto out_err;
	err = perf_session__flush_thread_stacks(session);
1655
out_err:
N
Namhyung Kim 已提交
1656
	ui_progress__finish();
1657
	perf_session__warn_about_errors(session);
1658
	ordered_events__free(&session->ordered_events);
1659
	auxtrace__free_events(session);
1660
	session->one_mmap = false;
1661 1662
	return err;
}
1663

1664
int perf_session__process_events(struct perf_session *session)
1665
{
1666
	u64 size = perf_data_file__size(session->file);
1667 1668
	int err;

1669
	if (perf_session__register_idle_thread(session) == NULL)
1670 1671
		return -ENOMEM;

1672 1673 1674
	if (!perf_data_file__is_pipe(session->file))
		err = __perf_session__process_events(session,
						     session->header.data_offset,
1675
						     session->header.data_size, size);
1676
	else
1677
		err = __perf_session__process_pipe_events(session);
1678

1679 1680 1681
	return err;
}

1682
bool perf_session__has_traces(struct perf_session *session, const char *msg)
1683
{
1684 1685
	struct perf_evsel *evsel;

1686
	evlist__for_each(session->evlist, evsel) {
1687 1688
		if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
			return true;
1689 1690
	}

1691 1692
	pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
	return false;
1693
}
1694

1695 1696
int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
				     const char *symbol_name, u64 addr)
1697 1698
{
	char *bracket;
1699
	enum map_type i;
1700 1701 1702 1703 1704
	struct ref_reloc_sym *ref;

	ref = zalloc(sizeof(struct ref_reloc_sym));
	if (ref == NULL)
		return -ENOMEM;
1705

1706 1707 1708
	ref->name = strdup(symbol_name);
	if (ref->name == NULL) {
		free(ref);
1709
		return -ENOMEM;
1710
	}
1711

1712
	bracket = strchr(ref->name, ']');
1713 1714 1715
	if (bracket)
		*bracket = '\0';

1716
	ref->addr = addr;
1717 1718

	for (i = 0; i < MAP__NR_TYPES; ++i) {
1719
		struct kmap *kmap = map__kmap(maps[i]);
1720 1721 1722

		if (!kmap)
			continue;
1723
		kmap->ref_reloc_sym = ref;
1724 1725
	}

1726 1727
	return 0;
}
1728

1729
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
1730
{
1731
	return machines__fprintf_dsos(&session->machines, fp);
1732
}
1733

1734
size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
1735
					  bool (skip)(struct dso *dso, int parm), int parm)
1736
{
1737
	return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
1738
}
1739 1740 1741

size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
{
1742 1743 1744 1745 1746 1747
	size_t ret;
	const char *msg = "";

	if (perf_header__has_feat(&session->header, HEADER_AUXTRACE))
		msg = " (excludes AUX area (e.g. instruction trace) decoded / synthesized events)";

1748
	ret = fprintf(fp, "\nAggregated stats:%s\n", msg);
1749

1750
	ret += events_stats__fprintf(&session->evlist->stats, fp);
1751 1752
	return ret;
}
1753

1754 1755 1756 1757 1758 1759
size_t perf_session__fprintf(struct perf_session *session, FILE *fp)
{
	/*
	 * FIXME: Here we have to actually print all the machines in this
	 * session, not just the host...
	 */
1760
	return machine__fprintf(&session->machines.host, fp);
1761 1762
}

1763 1764 1765 1766 1767
struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
					      unsigned int type)
{
	struct perf_evsel *pos;

1768
	evlist__for_each(session->evlist, pos) {
1769 1770 1771 1772 1773 1774
		if (pos->attr.type == type)
			return pos;
	}
	return NULL;
}

1775
void perf_evsel__print_ip(struct perf_evsel *evsel, struct perf_sample *sample,
1776
			  struct addr_location *al,
1777
			  unsigned int print_opts, unsigned int stack_depth)
1778 1779
{
	struct callchain_cursor_node *node;
1780 1781 1782 1783
	int print_ip = print_opts & PRINT_IP_OPT_IP;
	int print_sym = print_opts & PRINT_IP_OPT_SYM;
	int print_dso = print_opts & PRINT_IP_OPT_DSO;
	int print_symoffset = print_opts & PRINT_IP_OPT_SYMOFFSET;
1784
	int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
1785
	int print_srcline = print_opts & PRINT_IP_OPT_SRCLINE;
1786
	char s = print_oneline ? ' ' : '\t';
1787 1788

	if (symbol_conf.use_callchain && sample->callchain) {
1789
		struct addr_location node_al;
1790

1791 1792 1793
		if (thread__resolve_callchain(al->thread, evsel,
					      sample, NULL, NULL,
					      PERF_MAX_STACK_DEPTH) != 0) {
1794 1795 1796 1797
			if (verbose)
				error("Failed to resolve callchain. Skipping\n");
			return;
		}
1798
		callchain_cursor_commit(&callchain_cursor);
1799

1800 1801 1802
		if (print_symoffset)
			node_al = *al;

1803
		while (stack_depth) {
1804 1805
			u64 addr = 0;

1806
			node = callchain_cursor_current(&callchain_cursor);
1807 1808 1809
			if (!node)
				break;

1810 1811 1812
			if (node->sym && node->sym->ignore)
				goto next;

1813
			if (print_ip)
1814
				printf("%c%16" PRIx64, s, node->ip);
1815

1816 1817 1818
			if (node->map)
				addr = node->map->map_ip(node->map, node->ip);

1819
			if (print_sym) {
1820
				printf(" ");
1821
				if (print_symoffset) {
1822
					node_al.addr = addr;
1823 1824
					node_al.map  = node->map;
					symbol__fprintf_symname_offs(node->sym, &node_al, stdout);
1825 1826
				} else
					symbol__fprintf_symname(node->sym, stdout);
1827
			}
1828

1829
			if (print_dso) {
1830
				printf(" (");
1831
				map__fprintf_dsoname(node->map, stdout);
1832
				printf(")");
1833
			}
1834

1835 1836 1837 1838
			if (print_srcline)
				map__fprintf_srcline(node->map, addr, "\n  ",
						     stdout);

1839 1840
			if (!print_oneline)
				printf("\n");
1841

1842
			stack_depth--;
1843 1844
next:
			callchain_cursor_advance(&callchain_cursor);
1845 1846 1847
		}

	} else {
1848
		if (al->sym && al->sym->ignore)
1849 1850
			return;

1851 1852 1853
		if (print_ip)
			printf("%16" PRIx64, sample->ip);

1854
		if (print_sym) {
1855
			printf(" ");
1856
			if (print_symoffset)
1857
				symbol__fprintf_symname_offs(al->sym, al,
1858 1859
							     stdout);
			else
1860
				symbol__fprintf_symname(al->sym, stdout);
1861 1862 1863
		}

		if (print_dso) {
1864
			printf(" (");
1865
			map__fprintf_dsoname(al->map, stdout);
1866
			printf(")");
1867
		}
1868 1869 1870

		if (print_srcline)
			map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);
1871 1872
	}
}
1873 1874 1875 1876

int perf_session__cpu_bitmap(struct perf_session *session,
			     const char *cpu_list, unsigned long *cpu_bitmap)
{
1877
	int i, err = -1;
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894
	struct cpu_map *map;

	for (i = 0; i < PERF_TYPE_MAX; ++i) {
		struct perf_evsel *evsel;

		evsel = perf_session__find_first_evtype(session, i);
		if (!evsel)
			continue;

		if (!(evsel->attr.sample_type & PERF_SAMPLE_CPU)) {
			pr_err("File does not contain CPU events. "
			       "Remove -c option to proceed.\n");
			return -1;
		}
	}

	map = cpu_map__new(cpu_list);
1895 1896 1897 1898
	if (map == NULL) {
		pr_err("Invalid cpu_list\n");
		return -1;
	}
1899 1900 1901 1902 1903 1904 1905

	for (i = 0; i < map->nr; i++) {
		int cpu = map->map[i];

		if (cpu >= MAX_NR_CPUS) {
			pr_err("Requested CPU %d too large. "
			       "Consider raising MAX_NR_CPUS\n", cpu);
1906
			goto out_delete_map;
1907 1908 1909 1910 1911
		}

		set_bit(cpu, cpu_bitmap);
	}

1912 1913 1914
	err = 0;

out_delete_map:
1915
	cpu_map__put(map);
1916
	return err;
1917
}
1918 1919 1920 1921 1922

void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
				bool full)
{
	struct stat st;
1923
	int fd, ret;
1924 1925 1926 1927

	if (session == NULL || fp == NULL)
		return;

1928 1929
	fd = perf_data_file__fd(session->file);

1930
	ret = fstat(fd, &st);
1931 1932 1933 1934 1935 1936 1937 1938
	if (ret == -1)
		return;

	fprintf(fp, "# ========\n");
	fprintf(fp, "# captured on: %s", ctime(&st.st_ctime));
	perf_header__fprintf_info(session, fp, full);
	fprintf(fp, "# ========\n#\n");
}
1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949


int __perf_session__set_tracepoints_handlers(struct perf_session *session,
					     const struct perf_evsel_str_handler *assocs,
					     size_t nr_assocs)
{
	struct perf_evsel *evsel;
	size_t i;
	int err;

	for (i = 0; i < nr_assocs; i++) {
1950 1951 1952 1953 1954
		/*
		 * Adding a handler for an event not in the session,
		 * just ignore it.
		 */
		evsel = perf_evlist__find_tracepoint_by_name(session->evlist, assocs[i].name);
1955
		if (evsel == NULL)
1956
			continue;
1957 1958

		err = -EEXIST;
1959
		if (evsel->handler != NULL)
1960
			goto out;
1961
		evsel->handler = assocs[i].handler;
1962 1963 1964 1965 1966 1967
	}

	err = 0;
out:
	return err;
}
A
Adrian Hunter 已提交
1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021

int perf_event__process_id_index(struct perf_tool *tool __maybe_unused,
				 union perf_event *event,
				 struct perf_session *session)
{
	struct perf_evlist *evlist = session->evlist;
	struct id_index_event *ie = &event->id_index;
	size_t i, nr, max_nr;

	max_nr = (ie->header.size - sizeof(struct id_index_event)) /
		 sizeof(struct id_index_entry);
	nr = ie->nr;
	if (nr > max_nr)
		return -EINVAL;

	if (dump_trace)
		fprintf(stdout, " nr: %zu\n", nr);

	for (i = 0; i < nr; i++) {
		struct id_index_entry *e = &ie->entries[i];
		struct perf_sample_id *sid;

		if (dump_trace) {
			fprintf(stdout,	" ... id: %"PRIu64, e->id);
			fprintf(stdout,	"  idx: %"PRIu64, e->idx);
			fprintf(stdout,	"  cpu: %"PRId64, e->cpu);
			fprintf(stdout,	"  tid: %"PRId64"\n", e->tid);
		}

		sid = perf_evlist__id2sid(evlist, e->id);
		if (!sid)
			return -ENOENT;
		sid->idx = e->idx;
		sid->cpu = e->cpu;
		sid->tid = e->tid;
	}
	return 0;
}

int perf_event__synthesize_id_index(struct perf_tool *tool,
				    perf_event__handler_t process,
				    struct perf_evlist *evlist,
				    struct machine *machine)
{
	union perf_event *ev;
	struct perf_evsel *evsel;
	size_t nr = 0, i = 0, sz, max_nr, n;
	int err;

	pr_debug2("Synthesizing id index\n");

	max_nr = (UINT16_MAX - sizeof(struct id_index_event)) /
		 sizeof(struct id_index_entry);

2022
	evlist__for_each(evlist, evsel)
A
Adrian Hunter 已提交
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
		nr += evsel->ids;

	n = nr > max_nr ? max_nr : nr;
	sz = sizeof(struct id_index_event) + n * sizeof(struct id_index_entry);
	ev = zalloc(sz);
	if (!ev)
		return -ENOMEM;

	ev->id_index.header.type = PERF_RECORD_ID_INDEX;
	ev->id_index.header.size = sz;
	ev->id_index.nr = n;

2035
	evlist__for_each(evlist, evsel) {
A
Adrian Hunter 已提交
2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
		u32 j;

		for (j = 0; j < evsel->ids; j++) {
			struct id_index_entry *e;
			struct perf_sample_id *sid;

			if (i >= n) {
				err = process(tool, ev, NULL, machine);
				if (err)
					goto out_err;
				nr -= n;
				i = 0;
			}

			e = &ev->id_index.entries[i++];

			e->id = evsel->id[j];

			sid = perf_evlist__id2sid(evlist, e->id);
			if (!sid) {
				free(ev);
				return -ENOENT;
			}

			e->idx = sid->idx;
			e->cpu = sid->cpu;
			e->tid = sid->tid;
		}
	}

	sz = sizeof(struct id_index_event) + nr * sizeof(struct id_index_entry);
	ev->id_index.header.size = sz;
	ev->id_index.nr = nr;

	err = process(tool, ev, NULL, machine);
out_err:
	free(ev);

	return err;
}