session.c 45.8 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

19
static int perf_session__open(struct perf_session *session)
20
{
21
	struct perf_data_file *file = session->file;
22

23
	if (perf_session__read_header(session) < 0) {
24
		pr_err("incompatible file format (rerun with -v to learn more)");
25
		return -1;
26 27
	}

28 29 30
	if (perf_data_file__is_pipe(file))
		return 0;

31
	if (!perf_evlist__valid_sample_type(session->evlist)) {
32
		pr_err("non matching sample_type");
33
		return -1;
34 35
	}

36
	if (!perf_evlist__valid_sample_id_all(session->evlist)) {
37
		pr_err("non matching sample_id_all");
38
		return -1;
39 40
	}

41
	if (!perf_evlist__valid_read_format(session->evlist)) {
42
		pr_err("non matching read_format");
43
		return -1;
44 45
	}

46 47 48
	return 0;
}

49
void perf_session__set_id_hdr_size(struct perf_session *session)
50
{
51 52 53
	u16 id_hdr_size = perf_evlist__id_hdr_size(session->evlist);

	machines__set_id_hdr_size(&session->machines, id_hdr_size);
54 55
}

56
int perf_session__create_kernel_maps(struct perf_session *session)
57
{
58
	int ret = machine__create_kernel_maps(&session->machines.host);
59 60

	if (ret >= 0)
61
		ret = machines__create_guest_kernel_maps(&session->machines);
62 63 64
	return ret;
}

65
static void perf_session__destroy_kernel_maps(struct perf_session *session)
66
{
67
	machines__destroy_kernel_maps(&session->machines);
68 69
}

70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
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);
}

89 90
struct perf_session *perf_session__new(struct perf_data_file *file,
				       bool repipe, struct perf_tool *tool)
91
{
92
	struct perf_session *session = zalloc(sizeof(*session));
93

94
	if (!session)
95 96
		goto out;

97
	session->repipe = repipe;
98
	ordered_events__init(&session->ordered_events);
99
	machines__init(&session->machines);
100

101 102
	if (file) {
		if (perf_data_file__open(file))
103
			goto out_delete;
104

105
		session->file = file;
106 107

		if (perf_data_file__is_read(file)) {
108
			if (perf_session__open(session) < 0)
109 110
				goto out_close;

111
			perf_session__set_id_hdr_size(session);
112
			perf_session__set_comm_exec(session);
113 114 115 116
		}
	}

	if (!file || perf_data_file__is_write(file)) {
117 118
		/*
		 * In O_RDONLY mode this will be performed when reading the
119
		 * kernel MMAP event, in perf_event__process_mmap().
120
		 */
121
		if (perf_session__create_kernel_maps(session) < 0)
122
			pr_warning("Cannot read kernel map\n");
123
	}
124

125
	if (tool && tool->ordering_requires_timestamps &&
126
	    tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
127
		dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
128
		tool->ordered_events = false;
129 130
	}

131
	return session;
132 133 134 135

 out_close:
	perf_data_file__close(file);
 out_delete:
136
	perf_session__delete(session);
137
 out:
138
	return NULL;
139 140
}

141 142
static void perf_session__delete_threads(struct perf_session *session)
{
143
	machine__delete_threads(&session->machines.host);
144 145
}

146 147
static void perf_session_env__delete(struct perf_session_env *env)
{
148 149 150 151 152 153 154 155 156 157 158 159
	zfree(&env->hostname);
	zfree(&env->os_release);
	zfree(&env->version);
	zfree(&env->arch);
	zfree(&env->cpu_desc);
	zfree(&env->cpuid);

	zfree(&env->cmdline);
	zfree(&env->sibling_cores);
	zfree(&env->sibling_threads);
	zfree(&env->numa_nodes);
	zfree(&env->pmu_mappings);
160 161
}

162
void perf_session__delete(struct perf_session *session)
163
{
164 165 166 167 168 169 170
	perf_session__destroy_kernel_maps(session);
	perf_session__delete_threads(session);
	perf_session_env__delete(&session->header.env);
	machines__exit(&session->machines);
	if (session->file)
		perf_data_file__close(session->file);
	free(session);
171
}
172

173 174 175
static int process_event_synth_tracing_data_stub(struct perf_tool *tool
						 __maybe_unused,
						 union perf_event *event
176 177 178
						 __maybe_unused,
						 struct perf_session *session
						__maybe_unused)
179 180 181 182 183
{
	dump_printf(": unhandled!\n");
	return 0;
}

184 185
static int process_event_synth_attr_stub(struct perf_tool *tool __maybe_unused,
					 union perf_event *event __maybe_unused,
186 187
					 struct perf_evlist **pevlist
					 __maybe_unused)
188 189 190 191 192
{
	dump_printf(": unhandled!\n");
	return 0;
}

193 194 195 196 197
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)
198 199 200 201 202
{
	dump_printf(": unhandled!\n");
	return 0;
}

203 204 205 206
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)
207 208 209 210 211
{
	dump_printf(": unhandled!\n");
	return 0;
}

212 213 214 215
static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
				       union perf_event *event __maybe_unused,
				       struct perf_session *perf_session
				       __maybe_unused)
216 217 218 219 220
{
	dump_printf(": unhandled!\n");
	return 0;
}

221
static int process_finished_round(struct perf_tool *tool,
222 223
				  union perf_event *event,
				  struct perf_session *session);
224

A
Adrian Hunter 已提交
225 226 227 228 229 230 231 232 233
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;
}

234
void perf_tool__fill_defaults(struct perf_tool *tool)
235
{
236 237 238 239
	if (tool->sample == NULL)
		tool->sample = process_event_sample_stub;
	if (tool->mmap == NULL)
		tool->mmap = process_event_stub;
240 241
	if (tool->mmap2 == NULL)
		tool->mmap2 = process_event_stub;
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
	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;
	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)
		tool->build_id = process_finished_round_stub;
	if (tool->finished_round == NULL) {
263
		if (tool->ordered_events)
264
			tool->finished_round = process_finished_round;
265
		else
266
			tool->finished_round = process_finished_round_stub;
267
	}
A
Adrian Hunter 已提交
268 269
	if (tool->id_index == NULL)
		tool->id_index = process_id_index_stub;
270
}
271

272 273 274 275 276 277 278 279 280 281
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,
282
				   bool sample_id_all __maybe_unused)
283
{
284 285
	struct perf_event_header *hdr = &event->header;
	mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
286 287
}

288
static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
289
{
290 291
	event->comm.pid = bswap_32(event->comm.pid);
	event->comm.tid = bswap_32(event->comm.tid);
292 293 294 295

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

296
		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
297 298
		swap_sample_id_all(event, data);
	}
299 300
}

301 302
static void perf_event__mmap_swap(union perf_event *event,
				  bool sample_id_all)
303
{
304 305 306 307 308
	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);
309 310 311 312

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

313
		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
314 315
		swap_sample_id_all(event, data);
	}
316 317
}

318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
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);
	}
}
337
static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
338
{
339 340 341 342 343
	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);
344 345 346

	if (sample_id_all)
		swap_sample_id_all(event, &event->fork + 1);
347 348
}

349
static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
350
{
351 352 353 354 355 356
	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);
357 358 359

	if (sample_id_all)
		swap_sample_id_all(event, &event->read + 1);
360 361
}

362 363 364 365 366 367 368 369 370 371 372
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);
}

373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
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++;
	}
}

405 406 407 408 409 410 411 412 413 414 415 416 417
/* 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);
	attr->config		= bswap_64(attr->config);
	attr->sample_period	= bswap_64(attr->sample_period);
	attr->sample_type	= bswap_64(attr->sample_type);
	attr->read_format	= bswap_64(attr->read_format);
	attr->wakeup_events	= bswap_32(attr->wakeup_events);
	attr->bp_type		= bswap_32(attr->bp_type);
	attr->bp_addr		= bswap_64(attr->bp_addr);
	attr->bp_len		= bswap_64(attr->bp_len);
418 419 420
	attr->branch_sample_type = bswap_64(attr->branch_sample_type);
	attr->sample_regs_user	 = bswap_64(attr->sample_regs_user);
	attr->sample_stack_user  = bswap_32(attr->sample_stack_user);
421 422

	swap_bitfield((u8 *) (&attr->read_format + 1), sizeof(u64));
423 424
}

425
static void perf_event__hdr_attr_swap(union perf_event *event,
426
				      bool sample_id_all __maybe_unused)
427 428 429
{
	size_t size;

430
	perf_event__attr_swap(&event->attr.attr);
431

432 433 434
	size = event->header.size;
	size -= (void *)&event->attr.id - (void *)event;
	mem_bswap_64(event->attr.id, size);
435 436
}

437
static void perf_event__event_type_swap(union perf_event *event,
438
					bool sample_id_all __maybe_unused)
439
{
440 441
	event->event_type.event_type.event_id =
		bswap_64(event->event_type.event_type.event_id);
442 443
}

444
static void perf_event__tracing_data_swap(union perf_event *event,
445
					  bool sample_id_all __maybe_unused)
446
{
447
	event->tracing_data.size = bswap_32(event->tracing_data.size);
448 449
}

450 451
typedef void (*perf_event__swap_op)(union perf_event *event,
				    bool sample_id_all);
452

453 454
static perf_event__swap_op perf_event__swap_ops[] = {
	[PERF_RECORD_MMAP]		  = perf_event__mmap_swap,
455
	[PERF_RECORD_MMAP2]		  = perf_event__mmap2_swap,
456 457 458 459 460
	[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,
461 462
	[PERF_RECORD_THROTTLE]		  = perf_event__throttle_swap,
	[PERF_RECORD_UNTHROTTLE]	  = perf_event__throttle_swap,
463
	[PERF_RECORD_SAMPLE]		  = perf_event__all64_swap,
464
	[PERF_RECORD_HEADER_ATTR]	  = perf_event__hdr_attr_swap,
465 466 467
	[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 已提交
468
	[PERF_RECORD_ID_INDEX]		  = perf_event__all64_swap,
469
	[PERF_RECORD_HEADER_MAX]	  = NULL,
470 471
};

472 473 474 475 476 477 478 479 480 481 482 483 484 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
/*
 * 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...
 */
511
static int process_finished_round(struct perf_tool *tool,
512
				  union perf_event *event __maybe_unused,
513
				  struct perf_session *session)
514
{
515
	return ordered_events__flush(session, tool, OE_FLUSH__ROUND);
516 517
}

518
int perf_session_queue_event(struct perf_session *s, union perf_event *event,
519 520
			     struct perf_tool *tool, struct perf_sample *sample,
			     u64 file_offset)
521
{
522
	struct ordered_events *oe = &s->ordered_events;
523
	u64 timestamp = sample->time;
524
	struct ordered_event *new;
525

526
	if (!timestamp || timestamp == ~0ULL)
527 528
		return -ETIME;

529
	if (timestamp < oe->last_flush) {
530
		pr_oe_time(timestamp,      "out of order event\n");
531 532 533
		pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
			   oe->last_flush_type);

534
		s->evlist->stats.nr_unordered_events++;
535 536
	}

537
	new = ordered_events__new(oe, timestamp, event);
538 539
	if (!new) {
		ordered_events__flush(s, tool, OE_FLUSH__HALF);
540
		new = ordered_events__new(oe, timestamp, event);
541 542
	}

543 544
	if (!new)
		return -ENOMEM;
545

546
	new->file_offset = file_offset;
547 548
	return 0;
}
549

K
Kan Liang 已提交
550
static void callchain__lbr_callstack_printf(struct perf_sample *sample)
551
{
K
Kan Liang 已提交
552 553 554
	struct ip_callchain *callchain = sample->callchain;
	struct branch_stack *lbr_stack = sample->branch_stack;
	u64 kernel_callchain_nr = callchain->nr;
555
	unsigned int i;
556

K
Kan Liang 已提交
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606
	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);
607

K
Kan Liang 已提交
608
	for (i = 0; i < callchain->nr; i++)
609
		printf("..... %2d: %016" PRIx64 "\n",
K
Kan Liang 已提交
610
		       i, callchain->ips[i]);
611 612
}

613 614 615 616 617 618 619 620 621 622 623 624
static void branch_stack__printf(struct perf_sample *sample)
{
	uint64_t i;

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

	for (i = 0; i < sample->branch_stack->nr; i++)
		printf("..... %2"PRIu64": %016" PRIx64 " -> %016" PRIx64 "\n",
			i, sample->branch_stack->entries[i].from,
			sample->branch_stack->entries[i].to);
}

625 626 627 628 629 630 631 632 633 634 635 636
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);
	}
}

637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
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);
}

663
static void regs_user__printf(struct perf_sample *sample)
664 665 666
{
	struct regs_dump *user_regs = &sample->user_regs;

667 668 669 670 671 672 673 674 675 676
	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);
677 678 679 680 681 682 683 684
}

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

685
static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
686
				       union perf_event *event,
687
				       struct perf_sample *sample)
688
{
689
	u64 sample_type = __perf_evlist__combined_sample_type(evlist);
690

691
	if (event->header.type != PERF_RECORD_SAMPLE &&
692
	    !perf_evlist__sample_id_all(evlist)) {
693 694 695 696
		fputs("-1 -1 ", stdout);
		return;
	}

697
	if ((sample_type & PERF_SAMPLE_CPU))
698 699
		printf("%u ", sample->cpu);

700
	if (sample_type & PERF_SAMPLE_TIME)
701
		printf("%" PRIu64 " ", sample->time);
702 703
}

704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733
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);
}

734
static void dump_event(struct perf_evlist *evlist, union perf_event *event,
735
		       u64 file_offset, struct perf_sample *sample)
736 737 738 739
{
	if (!dump_trace)
		return;

740 741
	printf("\n%#" PRIx64 " [%#x]: event: %d\n",
	       file_offset, event->header.size, event->header.type);
742 743 744 745

	trace_event(event);

	if (sample)
746
		perf_evlist__print_tstamp(evlist, event, sample);
747

748
	printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
749
	       event->header.size, perf_event__name(event->header.type));
750 751
}

752
static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
753
			struct perf_sample *sample)
754
{
755 756
	u64 sample_type;

757 758 759
	if (!dump_trace)
		return;

760
	printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
761
	       event->header.misc, sample->pid, sample->tid, sample->ip,
762
	       sample->period, sample->addr);
763

764
	sample_type = evsel->attr.sample_type;
765 766

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

K
Kan Liang 已提交
769
	if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel))
770
		branch_stack__printf(sample);
771 772

	if (sample_type & PERF_SAMPLE_REGS_USER)
773
		regs_user__printf(sample);
774

775 776 777
	if (sample_type & PERF_SAMPLE_REGS_INTR)
		regs_intr__printf(sample);

778 779
	if (sample_type & PERF_SAMPLE_STACK_USER)
		stack_user__printf(&sample->user_stack);
780 781 782

	if (sample_type & PERF_SAMPLE_WEIGHT)
		printf("... weight: %" PRIu64 "\n", sample->weight);
783 784 785

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

787 788 789
	if (sample_type & PERF_SAMPLE_TRANSACTION)
		printf("... transaction: %" PRIx64 "\n", sample->transaction);

790 791
	if (sample_type & PERF_SAMPLE_READ)
		sample_read__printf(sample, evsel->attr.read_format);
792 793
}

794
static struct machine *machines__find_for_cpumode(struct machines *machines,
795 796
					       union perf_event *event,
					       struct perf_sample *sample)
797 798
{
	const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
799
	struct machine *machine;
800

801 802 803
	if (perf_guest &&
	    ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
	     (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
804 805
		u32 pid;

806 807
		if (event->header.type == PERF_RECORD_MMAP
		    || event->header.type == PERF_RECORD_MMAP2)
808 809
			pid = event->mmap.pid;
		else
810
			pid = sample->pid;
811

812
		machine = machines__find(machines, pid);
813
		if (!machine)
814
			machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID);
815
		return machine;
816
	}
817

818
	return &machines->host;
819 820
}

821
static int deliver_sample_value(struct perf_evlist *evlist,
822 823 824 825 826 827
				struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct sample_read_value *v,
				struct machine *machine)
{
828
	struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
829 830 831 832 833 834 835 836

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

	if (!sid || sid->evsel == NULL) {
837
		++evlist->stats.nr_unknown_id;
838 839 840 841 842 843
		return 0;
	}

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

844
static int deliver_sample_group(struct perf_evlist *evlist,
845 846 847 848 849 850 851 852 853
				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++) {
854
		ret = deliver_sample_value(evlist, tool, event, sample,
855 856 857 858 859 860 861 862 863 864
					   &sample->read.group.values[i],
					   machine);
		if (ret)
			break;
	}

	return ret;
}

static int
865
 perf_evlist__deliver_sample(struct perf_evlist *evlist,
866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881
			     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)
882
		return deliver_sample_group(evlist, tool, event, sample,
883 884
					    machine);
	else
885
		return deliver_sample_value(evlist, tool, event, sample,
886 887 888
					    &sample->read.one, machine);
}

889 890 891 892
int perf_session__deliver_event(struct perf_session *session,
				union perf_event *event,
				struct perf_sample *sample,
				struct perf_tool *tool, u64 file_offset)
893
{
894
	struct perf_evlist *evlist = session->evlist;
895
	struct perf_evsel *evsel;
896
	struct machine *machine;
897

898
	dump_event(evlist, event, file_offset, sample);
899

900
	evsel = perf_evlist__id2evsel(evlist, sample->id);
901

902
	machine = machines__find_for_cpumode(&session->machines, event, sample);
903

904 905
	switch (event->header.type) {
	case PERF_RECORD_SAMPLE:
906
		dump_sample(evsel, event, sample);
907
		if (evsel == NULL) {
908
			++evlist->stats.nr_unknown_id;
909
			return 0;
910
		}
911
		if (machine == NULL) {
912
			++evlist->stats.nr_unprocessable_samples;
913
			return 0;
914
		}
915
		return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
916
	case PERF_RECORD_MMAP:
917
		return tool->mmap(tool, event, sample, machine);
918 919
	case PERF_RECORD_MMAP2:
		return tool->mmap2(tool, event, sample, machine);
920
	case PERF_RECORD_COMM:
921
		return tool->comm(tool, event, sample, machine);
922
	case PERF_RECORD_FORK:
923
		return tool->fork(tool, event, sample, machine);
924
	case PERF_RECORD_EXIT:
925
		return tool->exit(tool, event, sample, machine);
926
	case PERF_RECORD_LOST:
927
		if (tool->lost == perf_event__process_lost)
928
			evlist->stats.total_lost += event->lost.lost;
929
		return tool->lost(tool, event, sample, machine);
930
	case PERF_RECORD_READ:
931
		return tool->read(tool, event, sample, evsel, machine);
932
	case PERF_RECORD_THROTTLE:
933
		return tool->throttle(tool, event, sample, machine);
934
	case PERF_RECORD_UNTHROTTLE:
935
		return tool->unthrottle(tool, event, sample, machine);
936
	default:
937
		++evlist->stats.nr_unknown_events;
938 939 940 941
		return -1;
	}
}

942 943 944 945
static s64 perf_session__process_user_event(struct perf_session *session,
					    union perf_event *event,
					    struct perf_tool *tool,
					    u64 file_offset)
946
{
947
	int fd = perf_data_file__fd(session->file);
948 949
	int err;

950
	dump_event(session->evlist, event, file_offset, NULL);
951

952
	/* These events are processed right away */
953
	switch (event->header.type) {
954
	case PERF_RECORD_HEADER_ATTR:
955
		err = tool->attr(tool, event, &session->evlist);
956
		if (err == 0) {
957
			perf_session__set_id_hdr_size(session);
958 959
			perf_session__set_comm_exec(session);
		}
960
		return err;
961 962 963 964 965 966
	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;
967 968
	case PERF_RECORD_HEADER_TRACING_DATA:
		/* setup for reading amidst mmap */
969
		lseek(fd, file_offset, SEEK_SET);
970
		return tool->tracing_data(tool, event, session);
971
	case PERF_RECORD_HEADER_BUILD_ID:
972
		return tool->build_id(tool, event, session);
973
	case PERF_RECORD_FINISHED_ROUND:
974
		return tool->finished_round(tool, event, session);
A
Adrian Hunter 已提交
975 976
	case PERF_RECORD_ID_INDEX:
		return tool->id_index(tool, event, session);
977
	default:
978
		return -EINVAL;
979
	}
980 981
}

982 983 984 985 986
int perf_session__deliver_synth_event(struct perf_session *session,
				      union perf_event *event,
				      struct perf_sample *sample,
				      struct perf_tool *tool)
{
987
	events_stats__inc(&session->evlist->stats, event->header.type);
988 989 990 991 992 993 994

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

	return perf_session__deliver_event(session, event, sample, tool, 0);
}

995 996 997 998 999 1000 1001 1002 1003
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);
}

1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
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 ||
	    readn(fd, &buf, hdr_sz) != (ssize_t)hdr_sz)
		return -1;

	event = (union perf_event *)buf;

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

	if (event->header.size < hdr_sz)
		return -1;

	rest = event->header.size - hdr_sz;

	if (readn(fd, &buf, rest) != (ssize_t)rest)
		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;
}

1059
static s64 perf_session__process_event(struct perf_session *session,
1060 1061 1062
				       union perf_event *event,
				       struct perf_tool *tool,
				       u64 file_offset)
1063
{
1064
	struct perf_evlist *evlist = session->evlist;
1065
	struct perf_sample sample;
1066 1067
	int ret;

1068
	if (session->header.needs_swap)
1069
		event_swap(event, perf_evlist__sample_id_all(evlist));
1070 1071 1072 1073

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

1074
	events_stats__inc(&evlist->stats, event->header.type);
1075 1076

	if (event->header.type >= PERF_RECORD_USER_TYPE_START)
1077
		return perf_session__process_user_event(session, event, tool, file_offset);
1078

1079 1080 1081
	/*
	 * For all kernel events we get the sample data
	 */
1082
	ret = perf_evlist__parse_sample(evlist, event, &sample);
1083 1084
	if (ret)
		return ret;
1085

1086
	if (tool->ordered_events) {
1087
		ret = perf_session_queue_event(session, event, tool, &sample,
1088
					       file_offset);
1089 1090 1091 1092
		if (ret != -ETIME)
			return ret;
	}

1093 1094
	return perf_session__deliver_event(session, event, &sample, tool,
					   file_offset);
1095 1096
}

1097
void perf_event_header__bswap(struct perf_event_header *hdr)
1098
{
1099 1100 1101
	hdr->type = bswap_32(hdr->type);
	hdr->misc = bswap_16(hdr->misc);
	hdr->size = bswap_16(hdr->size);
1102 1103
}

1104 1105
struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
{
1106
	return machine__findnew_thread(&session->machines.host, -1, pid);
1107 1108
}

1109
static struct thread *perf_session__register_idle_thread(struct perf_session *session)
1110
{
1111
	struct thread *thread;
1112

1113
	thread = machine__findnew_thread(&session->machines.host, 0, 0);
1114
	if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
1115 1116 1117 1118 1119 1120 1121
		pr_err("problem inserting idle task.\n");
		thread = NULL;
	}

	return thread;
}

1122 1123
static void perf_tool__warn_about_errors(const struct perf_tool *tool,
					 const struct events_stats *stats)
1124
{
1125
	if (tool->lost == perf_event__process_lost &&
1126
	    stats->nr_events[PERF_RECORD_LOST] != 0) {
1127 1128
		ui__warning("Processed %d events and lost %d chunks!\n\n"
			    "Check IO/CPU overload!\n\n",
1129 1130
			    stats->nr_events[0],
			    stats->nr_events[PERF_RECORD_LOST]);
1131 1132
	}

1133
	if (stats->nr_unknown_events != 0) {
1134 1135 1136 1137 1138
		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",
1139
			    stats->nr_unknown_events);
1140 1141
	}

1142
	if (stats->nr_unknown_id != 0) {
1143
		ui__warning("%u samples with id not present in the header\n",
1144
			    stats->nr_unknown_id);
1145 1146
	}

1147
	if (stats->nr_invalid_chains != 0) {
1148 1149 1150
		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",
1151 1152
			    stats->nr_invalid_chains,
			    stats->nr_events[PERF_RECORD_SAMPLE]);
1153
	}
1154

1155
	if (stats->nr_unprocessable_samples != 0) {
1156 1157
		ui__warning("%u unprocessable samples recorded.\n"
			    "Do you have a KVM guest running and not using 'perf kvm'?\n",
1158
			    stats->nr_unprocessable_samples);
1159
	}
1160

1161 1162
	if (stats->nr_unordered_events != 0)
		ui__warning("%u out of order events recorded.\n", stats->nr_unordered_events);
1163 1164
}

1165 1166
volatile int session_done;

1167
static int __perf_session__process_pipe_events(struct perf_session *session,
1168
					       struct perf_tool *tool)
1169
{
1170
	int fd = perf_data_file__fd(session->file);
1171 1172 1173
	union perf_event *event;
	uint32_t size, cur_size = 0;
	void *buf = NULL;
1174
	s64 skip = 0;
1175
	u64 head;
1176
	ssize_t err;
1177 1178
	void *p;

1179
	perf_tool__fill_defaults(tool);
1180 1181

	head = 0;
1182 1183 1184 1185 1186
	cur_size = sizeof(union perf_event);

	buf = malloc(cur_size);
	if (!buf)
		return -errno;
1187
more:
1188
	event = buf;
1189
	err = readn(fd, event, sizeof(struct perf_event_header));
1190 1191 1192 1193 1194 1195 1196 1197
	if (err <= 0) {
		if (err == 0)
			goto done;

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

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

1201
	size = event->header.size;
1202 1203 1204 1205
	if (size < sizeof(struct perf_event_header)) {
		pr_err("bad event header size\n");
		goto out_err;
	}
1206

1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
	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;
1218 1219
	p += sizeof(struct perf_event_header);

1220
	if (size - sizeof(struct perf_event_header)) {
1221
		err = readn(fd, p, size - sizeof(struct perf_event_header));
1222 1223 1224 1225 1226
		if (err <= 0) {
			if (err == 0) {
				pr_err("unexpected end of event stream\n");
				goto done;
			}
1227

1228 1229 1230
			pr_err("failed to read event data\n");
			goto out_err;
		}
1231 1232
	}

1233
	if ((skip = perf_session__process_event(session, event, tool, head)) < 0) {
1234
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1235
		       head, event->header.size, event->header.type);
1236 1237
		err = -EINVAL;
		goto out_err;
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247
	}

	head += size;

	if (skip > 0)
		head += skip;

	if (!session_done())
		goto more;
done:
1248
	/* do the final flush for ordered samples */
1249
	err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
1250
out_err:
1251
	free(buf);
1252
	perf_tool__warn_about_errors(tool, &session->evlist->stats);
1253
	ordered_events__free(&session->ordered_events);
1254 1255 1256
	return err;
}

1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274
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);

1275 1276 1277 1278
	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);
1279
		return NULL;
1280
	}
1281 1282 1283 1284

	return event;
}

1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296
/*
 * 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

1297 1298 1299
static int __perf_session__process_events(struct perf_session *session,
					  u64 data_offset, u64 data_size,
					  u64 file_size, struct perf_tool *tool)
1300
{
1301
	int fd = perf_data_file__fd(session->file);
1302
	u64 head, page_offset, file_offset, file_pos, size;
1303
	int err, mmap_prot, mmap_flags, map_idx = 0;
1304
	size_t	mmap_size;
1305
	char *buf, *mmaps[NUM_MMAPS];
1306
	union perf_event *event;
1307
	struct ui_progress prog;
1308
	s64 skip;
1309

1310
	perf_tool__fill_defaults(tool);
1311

1312 1313 1314
	page_offset = page_size * (data_offset / page_size);
	file_offset = page_offset;
	head = data_offset - page_offset;
1315

1316
	if (data_size && (data_offset + data_size < file_size))
1317 1318
		file_size = data_offset + data_size;

1319
	ui_progress__init(&prog, file_size, "Processing events...");
1320

1321
	mmap_size = MMAP_SIZE;
1322
	if (mmap_size > file_size) {
1323
		mmap_size = file_size;
1324 1325
		session->one_mmap = true;
	}
1326

1327 1328
	memset(mmaps, 0, sizeof(mmaps));

1329 1330 1331
	mmap_prot  = PROT_READ;
	mmap_flags = MAP_SHARED;

1332
	if (session->header.needs_swap) {
1333 1334 1335
		mmap_prot  |= PROT_WRITE;
		mmap_flags = MAP_PRIVATE;
	}
1336
remap:
1337
	buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
1338
		   file_offset);
1339 1340 1341 1342 1343
	if (buf == MAP_FAILED) {
		pr_err("failed to mmap file\n");
		err = -errno;
		goto out_err;
	}
1344 1345
	mmaps[map_idx] = buf;
	map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
1346
	file_pos = file_offset + head;
1347 1348 1349 1350
	if (session->one_mmap) {
		session->one_mmap_addr = buf;
		session->one_mmap_offset = file_offset;
	}
1351 1352

more:
1353 1354
	event = fetch_mmaped_event(session, head, mmap_size, buf);
	if (!event) {
1355 1356 1357 1358
		if (mmaps[map_idx]) {
			munmap(mmaps[map_idx], mmap_size);
			mmaps[map_idx] = NULL;
		}
1359

1360 1361 1362
		page_offset = page_size * (head / page_size);
		file_offset += page_offset;
		head -= page_offset;
1363 1364 1365 1366 1367
		goto remap;
	}

	size = event->header.size;

1368
	if (size < sizeof(struct perf_event_header) ||
1369 1370
	    (skip = perf_session__process_event(session, event, tool, file_pos))
									< 0) {
1371 1372 1373 1374 1375
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
		       file_offset + head, event->header.size,
		       event->header.type);
		err = -EINVAL;
		goto out_err;
1376 1377
	}

1378 1379 1380
	if (skip)
		size += skip;

1381
	head += size;
1382
	file_pos += size;
1383

1384
	ui_progress__update(&prog, size);
1385

1386
	if (session_done())
1387
		goto out;
1388

1389
	if (file_pos < file_size)
1390
		goto more;
1391

1392
out:
1393
	/* do the final flush for ordered samples */
1394
	err = ordered_events__flush(session, tool, OE_FLUSH__FINAL);
1395
out_err:
N
Namhyung Kim 已提交
1396
	ui_progress__finish();
1397
	perf_tool__warn_about_errors(tool, &session->evlist->stats);
1398
	ordered_events__free(&session->ordered_events);
1399
	session->one_mmap = false;
1400 1401
	return err;
}
1402

1403
int perf_session__process_events(struct perf_session *session,
1404
				 struct perf_tool *tool)
1405
{
1406
	u64 size = perf_data_file__size(session->file);
1407 1408
	int err;

1409
	if (perf_session__register_idle_thread(session) == NULL)
1410 1411
		return -ENOMEM;

1412 1413 1414 1415
	if (!perf_data_file__is_pipe(session->file))
		err = __perf_session__process_events(session,
						     session->header.data_offset,
						     session->header.data_size,
1416
						     size, tool);
1417
	else
1418
		err = __perf_session__process_pipe_events(session, tool);
1419

1420 1421 1422
	return err;
}

1423
bool perf_session__has_traces(struct perf_session *session, const char *msg)
1424
{
1425 1426
	struct perf_evsel *evsel;

1427
	evlist__for_each(session->evlist, evsel) {
1428 1429
		if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
			return true;
1430 1431
	}

1432 1433
	pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
	return false;
1434
}
1435

1436 1437
int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
				     const char *symbol_name, u64 addr)
1438 1439
{
	char *bracket;
1440
	enum map_type i;
1441 1442 1443 1444 1445
	struct ref_reloc_sym *ref;

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

1447 1448 1449
	ref->name = strdup(symbol_name);
	if (ref->name == NULL) {
		free(ref);
1450
		return -ENOMEM;
1451
	}
1452

1453
	bracket = strchr(ref->name, ']');
1454 1455 1456
	if (bracket)
		*bracket = '\0';

1457
	ref->addr = addr;
1458 1459

	for (i = 0; i < MAP__NR_TYPES; ++i) {
1460 1461
		struct kmap *kmap = map__kmap(maps[i]);
		kmap->ref_reloc_sym = ref;
1462 1463
	}

1464 1465
	return 0;
}
1466

1467
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
1468
{
1469
	return machines__fprintf_dsos(&session->machines, fp);
1470
}
1471

1472
size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
1473
					  bool (skip)(struct dso *dso, int parm), int parm)
1474
{
1475
	return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
1476
}
1477 1478 1479 1480 1481

size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp)
{
	size_t ret = fprintf(fp, "Aggregated stats:\n");

1482
	ret += events_stats__fprintf(&session->evlist->stats, fp);
1483 1484
	return ret;
}
1485

1486 1487 1488 1489 1490 1491
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...
	 */
1492
	return machine__fprintf(&session->machines.host, fp);
1493 1494
}

1495 1496 1497 1498 1499
struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
					      unsigned int type)
{
	struct perf_evsel *pos;

1500
	evlist__for_each(session->evlist, pos) {
1501 1502 1503 1504 1505 1506
		if (pos->attr.type == type)
			return pos;
	}
	return NULL;
}

1507
void perf_evsel__print_ip(struct perf_evsel *evsel, struct perf_sample *sample,
1508
			  struct addr_location *al,
1509
			  unsigned int print_opts, unsigned int stack_depth)
1510 1511
{
	struct callchain_cursor_node *node;
1512 1513 1514 1515
	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;
1516
	int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
1517
	int print_srcline = print_opts & PRINT_IP_OPT_SRCLINE;
1518
	char s = print_oneline ? ' ' : '\t';
1519 1520

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

1523 1524 1525
		if (thread__resolve_callchain(al->thread, evsel,
					      sample, NULL, NULL,
					      PERF_MAX_STACK_DEPTH) != 0) {
1526 1527 1528 1529
			if (verbose)
				error("Failed to resolve callchain. Skipping\n");
			return;
		}
1530
		callchain_cursor_commit(&callchain_cursor);
1531

1532 1533 1534
		if (print_symoffset)
			node_al = *al;

1535
		while (stack_depth) {
1536 1537
			u64 addr = 0;

1538
			node = callchain_cursor_current(&callchain_cursor);
1539 1540 1541
			if (!node)
				break;

1542 1543 1544
			if (node->sym && node->sym->ignore)
				goto next;

1545
			if (print_ip)
1546
				printf("%c%16" PRIx64, s, node->ip);
1547

1548 1549 1550
			if (node->map)
				addr = node->map->map_ip(node->map, node->ip);

1551
			if (print_sym) {
1552
				printf(" ");
1553
				if (print_symoffset) {
1554
					node_al.addr = addr;
1555 1556
					node_al.map  = node->map;
					symbol__fprintf_symname_offs(node->sym, &node_al, stdout);
1557 1558
				} else
					symbol__fprintf_symname(node->sym, stdout);
1559
			}
1560

1561
			if (print_dso) {
1562
				printf(" (");
1563
				map__fprintf_dsoname(node->map, stdout);
1564
				printf(")");
1565
			}
1566

1567 1568 1569 1570
			if (print_srcline)
				map__fprintf_srcline(node->map, addr, "\n  ",
						     stdout);

1571 1572
			if (!print_oneline)
				printf("\n");
1573

1574
			stack_depth--;
1575 1576
next:
			callchain_cursor_advance(&callchain_cursor);
1577 1578 1579
		}

	} else {
1580
		if (al->sym && al->sym->ignore)
1581 1582
			return;

1583 1584 1585
		if (print_ip)
			printf("%16" PRIx64, sample->ip);

1586
		if (print_sym) {
1587
			printf(" ");
1588
			if (print_symoffset)
1589
				symbol__fprintf_symname_offs(al->sym, al,
1590 1591
							     stdout);
			else
1592
				symbol__fprintf_symname(al->sym, stdout);
1593 1594 1595
		}

		if (print_dso) {
1596
			printf(" (");
1597
			map__fprintf_dsoname(al->map, stdout);
1598
			printf(")");
1599
		}
1600 1601 1602

		if (print_srcline)
			map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);
1603 1604
	}
}
1605 1606 1607 1608

int perf_session__cpu_bitmap(struct perf_session *session,
			     const char *cpu_list, unsigned long *cpu_bitmap)
{
1609
	int i, err = -1;
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
	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);
1627 1628 1629 1630
	if (map == NULL) {
		pr_err("Invalid cpu_list\n");
		return -1;
	}
1631 1632 1633 1634 1635 1636 1637

	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);
1638
			goto out_delete_map;
1639 1640 1641 1642 1643
		}

		set_bit(cpu, cpu_bitmap);
	}

1644 1645 1646 1647 1648
	err = 0;

out_delete_map:
	cpu_map__delete(map);
	return err;
1649
}
1650 1651 1652 1653 1654

void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
				bool full)
{
	struct stat st;
1655
	int fd, ret;
1656 1657 1658 1659

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

1660 1661
	fd = perf_data_file__fd(session->file);

1662
	ret = fstat(fd, &st);
1663 1664 1665 1666 1667 1668 1669 1670
	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");
}
1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681


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++) {
1682 1683 1684 1685 1686
		/*
		 * 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);
1687
		if (evsel == NULL)
1688
			continue;
1689 1690

		err = -EEXIST;
1691
		if (evsel->handler != NULL)
1692
			goto out;
1693
		evsel->handler = assocs[i].handler;
1694 1695 1696 1697 1698 1699
	}

	err = 0;
out:
	return err;
}
A
Adrian Hunter 已提交
1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753

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

1754
	evlist__for_each(evlist, evsel)
A
Adrian Hunter 已提交
1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766
		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;

1767
	evlist__for_each(evlist, evsel) {
A
Adrian Hunter 已提交
1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
		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;
}