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

19 20 21 22 23 24
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);

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

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

34 35 36
	if (perf_data_file__is_pipe(file))
		return 0;

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

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

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

52 53 54
	return 0;
}

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

	machines__set_id_hdr_size(&session->machines, id_hdr_size);
60 61
}

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

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

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

76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
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);
}

95 96 97 98 99 100 101 102
static int ordered_events__deliver_event(struct ordered_events *oe,
					 struct ordered_event *event,
					 struct perf_sample *sample)
{
	return machines__deliver_event(oe->machines, oe->evlist, event->event,
				       sample, oe->tool, event->file_offset);
}

103 104
struct perf_session *perf_session__new(struct perf_data_file *file,
				       bool repipe, struct perf_tool *tool)
105
{
106
	struct perf_session *session = zalloc(sizeof(*session));
107

108
	if (!session)
109 110
		goto out;

111 112
	session->repipe = repipe;
	machines__init(&session->machines);
113

114 115
	if (file) {
		if (perf_data_file__open(file))
116
			goto out_delete;
117

118
		session->file = file;
119 120

		if (perf_data_file__is_read(file)) {
121
			if (perf_session__open(session) < 0)
122 123
				goto out_close;

124
			perf_session__set_id_hdr_size(session);
125
			perf_session__set_comm_exec(session);
126 127 128 129
		}
	}

	if (!file || perf_data_file__is_write(file)) {
130 131
		/*
		 * In O_RDONLY mode this will be performed when reading the
132
		 * kernel MMAP event, in perf_event__process_mmap().
133
		 */
134
		if (perf_session__create_kernel_maps(session) < 0)
135
			pr_warning("Cannot read kernel map\n");
136
	}
137

138
	if (tool && tool->ordering_requires_timestamps &&
139
	    tool->ordered_events && !perf_evlist__sample_id_all(session->evlist)) {
140
		dump_printf("WARNING: No sample_id_all support, falling back to unordered processing\n");
141
		tool->ordered_events = false;
142 143 144 145
	} else {
		ordered_events__init(&session->ordered_events, &session->machines,
				     session->evlist, tool, ordered_events__deliver_event);
	}
146

147
	return session;
148 149 150 151

 out_close:
	perf_data_file__close(file);
 out_delete:
152
	perf_session__delete(session);
153
 out:
154
	return NULL;
155 156
}

157 158
static void perf_session__delete_threads(struct perf_session *session)
{
159
	machine__delete_threads(&session->machines.host);
160 161
}

162 163
static void perf_session_env__delete(struct perf_session_env *env)
{
164 165 166 167 168 169 170 171 172 173 174 175
	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);
176 177
}

178
void perf_session__delete(struct perf_session *session)
179
{
180 181 182 183 184 185 186
	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);
187
}
188

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

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

209 210 211 212 213
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)
214 215 216 217 218
{
	dump_printf(": unhandled!\n");
	return 0;
}

219 220 221 222
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)
223 224 225 226 227
{
	dump_printf(": unhandled!\n");
	return 0;
}

228 229 230 231
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)
232 233 234 235 236
{
	dump_printf(": unhandled!\n");
	return 0;
}

237
static int process_finished_round(struct perf_tool *tool,
238 239
				  union perf_event *event,
				  struct perf_session *session);
240

A
Adrian Hunter 已提交
241 242 243 244 245 246 247 248 249
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;
}

250
void perf_tool__fill_defaults(struct perf_tool *tool)
251
{
252 253 254 255
	if (tool->sample == NULL)
		tool->sample = process_event_sample_stub;
	if (tool->mmap == NULL)
		tool->mmap = process_event_stub;
256 257
	if (tool->mmap2 == NULL)
		tool->mmap2 = process_event_stub;
258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
	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) {
279
		if (tool->ordered_events)
280
			tool->finished_round = process_finished_round;
281
		else
282
			tool->finished_round = process_finished_round_stub;
283
	}
A
Adrian Hunter 已提交
284 285
	if (tool->id_index == NULL)
		tool->id_index = process_id_index_stub;
286
}
287

288 289 290 291 292 293 294 295 296 297
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,
298
				   bool sample_id_all __maybe_unused)
299
{
300 301
	struct perf_event_header *hdr = &event->header;
	mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
302 303
}

304
static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
305
{
306 307
	event->comm.pid = bswap_32(event->comm.pid);
	event->comm.tid = bswap_32(event->comm.tid);
308 309 310 311

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

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

317 318
static void perf_event__mmap_swap(union perf_event *event,
				  bool sample_id_all)
319
{
320 321 322 323 324
	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);
325 326 327 328

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

329
		data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
330 331
		swap_sample_id_all(event, data);
	}
332 333
}

334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
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);
	}
}
353
static void perf_event__task_swap(union perf_event *event, bool sample_id_all)
354
{
355 356 357 358 359
	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);
360 361 362

	if (sample_id_all)
		swap_sample_id_all(event, &event->fork + 1);
363 364
}

365
static void perf_event__read_swap(union perf_event *event, bool sample_id_all)
366
{
367 368 369 370 371 372
	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);
373 374 375

	if (sample_id_all)
		swap_sample_id_all(event, &event->read + 1);
376 377
}

378 379 380 381 382 383 384 385 386 387 388
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);
}

389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
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++;
	}
}

421 422 423 424 425 426 427 428 429 430 431 432 433
/* 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);
434 435 436
	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);
437 438

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

441
static void perf_event__hdr_attr_swap(union perf_event *event,
442
				      bool sample_id_all __maybe_unused)
443 444 445
{
	size_t size;

446
	perf_event__attr_swap(&event->attr.attr);
447

448 449 450
	size = event->header.size;
	size -= (void *)&event->attr.id - (void *)event;
	mem_bswap_64(event->attr.id, size);
451 452
}

453
static void perf_event__event_type_swap(union perf_event *event,
454
					bool sample_id_all __maybe_unused)
455
{
456 457
	event->event_type.event_type.event_id =
		bswap_64(event->event_type.event_type.event_id);
458 459
}

460
static void perf_event__tracing_data_swap(union perf_event *event,
461
					  bool sample_id_all __maybe_unused)
462
{
463
	event->tracing_data.size = bswap_32(event->tracing_data.size);
464 465
}

466 467
typedef void (*perf_event__swap_op)(union perf_event *event,
				    bool sample_id_all);
468

469 470
static perf_event__swap_op perf_event__swap_ops[] = {
	[PERF_RECORD_MMAP]		  = perf_event__mmap_swap,
471
	[PERF_RECORD_MMAP2]		  = perf_event__mmap2_swap,
472 473 474 475 476
	[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,
477 478
	[PERF_RECORD_THROTTLE]		  = perf_event__throttle_swap,
	[PERF_RECORD_UNTHROTTLE]	  = perf_event__throttle_swap,
479
	[PERF_RECORD_SAMPLE]		  = perf_event__all64_swap,
480
	[PERF_RECORD_HEADER_ATTR]	  = perf_event__hdr_attr_swap,
481 482 483
	[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 已提交
484
	[PERF_RECORD_ID_INDEX]		  = perf_event__all64_swap,
485
	[PERF_RECORD_HEADER_MAX]	  = NULL,
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 517 518 519 520 521 522 523 524 525 526
/*
 * 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...
 */
527
static int process_finished_round(struct perf_tool *tool __maybe_unused,
528
				  union perf_event *event __maybe_unused,
529
				  struct perf_session *session)
530
{
531 532
	struct ordered_events *oe = &session->ordered_events;

533
	return ordered_events__flush(oe, OE_FLUSH__ROUND);
534 535
}

536 537
int perf_session__queue_event(struct perf_session *s, union perf_event *event,
			      struct perf_sample *sample, u64 file_offset)
538
{
539
	struct ordered_events *oe = &s->ordered_events;
540

541
	u64 timestamp = sample->time;
542
	struct ordered_event *new;
543

544
	if (!timestamp || timestamp == ~0ULL)
545 546
		return -ETIME;

547
	if (timestamp < oe->last_flush) {
548
		pr_oe_time(timestamp,      "out of order event\n");
549 550 551
		pr_oe_time(oe->last_flush, "last flush, last_flush_type %d\n",
			   oe->last_flush_type);

552
		s->evlist->stats.nr_unordered_events++;
553 554
	}

555
	new = ordered_events__new(oe, timestamp, event);
556
	if (!new) {
557
		ordered_events__flush(oe, OE_FLUSH__HALF);
558
		new = ordered_events__new(oe, timestamp, event);
559 560
	}

561 562
	if (!new)
		return -ENOMEM;
563

564
	new->file_offset = file_offset;
565 566
	return 0;
}
567

K
Kan Liang 已提交
568
static void callchain__lbr_callstack_printf(struct perf_sample *sample)
569
{
K
Kan Liang 已提交
570 571 572
	struct ip_callchain *callchain = sample->callchain;
	struct branch_stack *lbr_stack = sample->branch_stack;
	u64 kernel_callchain_nr = callchain->nr;
573
	unsigned int i;
574

K
Kan Liang 已提交
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 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624
	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);
625

K
Kan Liang 已提交
626
	for (i = 0; i < callchain->nr; i++)
627
		printf("..... %2d: %016" PRIx64 "\n",
K
Kan Liang 已提交
628
		       i, callchain->ips[i]);
629 630
}

631 632 633 634 635 636 637 638 639 640 641 642
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);
}

643 644 645 646 647 648 649 650 651 652 653 654
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);
	}
}

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

681
static void regs_user__printf(struct perf_sample *sample)
682 683 684
{
	struct regs_dump *user_regs = &sample->user_regs;

685 686 687 688 689 690 691 692 693 694
	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);
695 696 697 698 699 700 701 702
}

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

703
static void perf_evlist__print_tstamp(struct perf_evlist *evlist,
704
				       union perf_event *event,
705
				       struct perf_sample *sample)
706
{
707
	u64 sample_type = __perf_evlist__combined_sample_type(evlist);
708

709
	if (event->header.type != PERF_RECORD_SAMPLE &&
710
	    !perf_evlist__sample_id_all(evlist)) {
711 712 713 714
		fputs("-1 -1 ", stdout);
		return;
	}

715
	if ((sample_type & PERF_SAMPLE_CPU))
716 717
		printf("%u ", sample->cpu);

718
	if (sample_type & PERF_SAMPLE_TIME)
719
		printf("%" PRIu64 " ", sample->time);
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
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);
}

752
static void dump_event(struct perf_evlist *evlist, union perf_event *event,
753
		       u64 file_offset, struct perf_sample *sample)
754 755 756 757
{
	if (!dump_trace)
		return;

758 759
	printf("\n%#" PRIx64 " [%#x]: event: %d\n",
	       file_offset, event->header.size, event->header.type);
760 761 762 763

	trace_event(event);

	if (sample)
764
		perf_evlist__print_tstamp(evlist, event, sample);
765

766
	printf("%#" PRIx64 " [%#x]: PERF_RECORD_%s", file_offset,
767
	       event->header.size, perf_event__name(event->header.type));
768 769
}

770
static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
771
			struct perf_sample *sample)
772
{
773 774
	u64 sample_type;

775 776 777
	if (!dump_trace)
		return;

778
	printf("(IP, 0x%x): %d/%d: %#" PRIx64 " period: %" PRIu64 " addr: %#" PRIx64 "\n",
779
	       event->header.misc, sample->pid, sample->tid, sample->ip,
780
	       sample->period, sample->addr);
781

782
	sample_type = evsel->attr.sample_type;
783 784

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

K
Kan Liang 已提交
787
	if ((sample_type & PERF_SAMPLE_BRANCH_STACK) && !has_branch_callstack(evsel))
788
		branch_stack__printf(sample);
789 790

	if (sample_type & PERF_SAMPLE_REGS_USER)
791
		regs_user__printf(sample);
792

793 794 795
	if (sample_type & PERF_SAMPLE_REGS_INTR)
		regs_intr__printf(sample);

796 797
	if (sample_type & PERF_SAMPLE_STACK_USER)
		stack_user__printf(&sample->user_stack);
798 799 800

	if (sample_type & PERF_SAMPLE_WEIGHT)
		printf("... weight: %" PRIu64 "\n", sample->weight);
801 802 803

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

805 806 807
	if (sample_type & PERF_SAMPLE_TRANSACTION)
		printf("... transaction: %" PRIx64 "\n", sample->transaction);

808 809
	if (sample_type & PERF_SAMPLE_READ)
		sample_read__printf(sample, evsel->attr.read_format);
810 811
}

812
static struct machine *machines__find_for_cpumode(struct machines *machines,
813 814
					       union perf_event *event,
					       struct perf_sample *sample)
815 816
{
	const u8 cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
817
	struct machine *machine;
818

819 820 821
	if (perf_guest &&
	    ((cpumode == PERF_RECORD_MISC_GUEST_KERNEL) ||
	     (cpumode == PERF_RECORD_MISC_GUEST_USER))) {
822 823
		u32 pid;

824 825
		if (event->header.type == PERF_RECORD_MMAP
		    || event->header.type == PERF_RECORD_MMAP2)
826 827
			pid = event->mmap.pid;
		else
828
			pid = sample->pid;
829

830
		machine = machines__find(machines, pid);
831
		if (!machine)
832
			machine = machines__find(machines, DEFAULT_GUEST_KERNEL_ID);
833
		return machine;
834
	}
835

836
	return &machines->host;
837 838
}

839
static int deliver_sample_value(struct perf_evlist *evlist,
840 841 842 843 844 845
				struct perf_tool *tool,
				union perf_event *event,
				struct perf_sample *sample,
				struct sample_read_value *v,
				struct machine *machine)
{
846
	struct perf_sample_id *sid = perf_evlist__id2sid(evlist, v->id);
847 848 849 850 851 852 853 854

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

	if (!sid || sid->evsel == NULL) {
855
		++evlist->stats.nr_unknown_id;
856 857 858 859 860 861
		return 0;
	}

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

862
static int deliver_sample_group(struct perf_evlist *evlist,
863 864 865 866 867 868 869 870 871
				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++) {
872
		ret = deliver_sample_value(evlist, tool, event, sample,
873 874 875 876 877 878 879 880 881 882
					   &sample->read.group.values[i],
					   machine);
		if (ret)
			break;
	}

	return ret;
}

static int
883
 perf_evlist__deliver_sample(struct perf_evlist *evlist,
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
			     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)
900
		return deliver_sample_group(evlist, tool, event, sample,
901 902
					    machine);
	else
903
		return deliver_sample_value(evlist, tool, event, sample,
904 905 906
					    &sample->read.one, machine);
}

907 908 909 910 911
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)
912
{
913
	struct perf_evsel *evsel;
914
	struct machine *machine;
915

916
	dump_event(evlist, event, file_offset, sample);
917

918
	evsel = perf_evlist__id2evsel(evlist, sample->id);
919

920
	machine = machines__find_for_cpumode(machines, event, sample);
921

922 923
	switch (event->header.type) {
	case PERF_RECORD_SAMPLE:
924
		dump_sample(evsel, event, sample);
925
		if (evsel == NULL) {
926
			++evlist->stats.nr_unknown_id;
927
			return 0;
928
		}
929
		if (machine == NULL) {
930
			++evlist->stats.nr_unprocessable_samples;
931
			return 0;
932
		}
933
		return perf_evlist__deliver_sample(evlist, tool, event, sample, evsel, machine);
934
	case PERF_RECORD_MMAP:
935
		return tool->mmap(tool, event, sample, machine);
936 937
	case PERF_RECORD_MMAP2:
		return tool->mmap2(tool, event, sample, machine);
938
	case PERF_RECORD_COMM:
939
		return tool->comm(tool, event, sample, machine);
940
	case PERF_RECORD_FORK:
941
		return tool->fork(tool, event, sample, machine);
942
	case PERF_RECORD_EXIT:
943
		return tool->exit(tool, event, sample, machine);
944
	case PERF_RECORD_LOST:
945
		if (tool->lost == perf_event__process_lost)
946
			evlist->stats.total_lost += event->lost.lost;
947
		return tool->lost(tool, event, sample, machine);
948
	case PERF_RECORD_READ:
949
		return tool->read(tool, event, sample, evsel, machine);
950
	case PERF_RECORD_THROTTLE:
951
		return tool->throttle(tool, event, sample, machine);
952
	case PERF_RECORD_UNTHROTTLE:
953
		return tool->unthrottle(tool, event, sample, machine);
954
	default:
955
		++evlist->stats.nr_unknown_events;
956 957 958 959
		return -1;
	}
}

960 961 962
static s64 perf_session__process_user_event(struct perf_session *session,
					    union perf_event *event,
					    u64 file_offset)
963
{
964
	struct perf_tool *tool = session->ordered_events.tool;
965
	int fd = perf_data_file__fd(session->file);
966 967
	int err;

968
	dump_event(session->evlist, event, file_offset, NULL);
969

970
	/* These events are processed right away */
971
	switch (event->header.type) {
972
	case PERF_RECORD_HEADER_ATTR:
973
		err = tool->attr(tool, event, &session->evlist);
974
		if (err == 0) {
975
			perf_session__set_id_hdr_size(session);
976 977
			perf_session__set_comm_exec(session);
		}
978
		return err;
979 980 981 982 983 984
	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;
985 986
	case PERF_RECORD_HEADER_TRACING_DATA:
		/* setup for reading amidst mmap */
987
		lseek(fd, file_offset, SEEK_SET);
988
		return tool->tracing_data(tool, event, session);
989
	case PERF_RECORD_HEADER_BUILD_ID:
990
		return tool->build_id(tool, event, session);
991
	case PERF_RECORD_FINISHED_ROUND:
992
		return tool->finished_round(tool, event, session);
A
Adrian Hunter 已提交
993 994
	case PERF_RECORD_ID_INDEX:
		return tool->id_index(tool, event, session);
995
	default:
996
		return -EINVAL;
997
	}
998 999
}

1000 1001
int perf_session__deliver_synth_event(struct perf_session *session,
				      union perf_event *event,
1002
				      struct perf_sample *sample)
1003
{
1004
	struct perf_evlist *evlist = session->evlist;
1005
	struct perf_tool *tool = session->ordered_events.tool;
1006 1007

	events_stats__inc(&evlist->stats, event->header.type);
1008 1009

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

1012
	return machines__deliver_event(&session->machines, evlist, event, sample, tool, 0);
1013 1014
}

1015 1016 1017 1018 1019 1020 1021 1022 1023
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);
}

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 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078
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;
}

1079
static s64 perf_session__process_event(struct perf_session *session,
1080
				       union perf_event *event, u64 file_offset)
1081
{
1082
	struct perf_evlist *evlist = session->evlist;
1083
	struct perf_tool *tool = session->ordered_events.tool;
1084
	struct perf_sample sample;
1085 1086
	int ret;

1087
	if (session->header.needs_swap)
1088
		event_swap(event, perf_evlist__sample_id_all(evlist));
1089 1090 1091 1092

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

1093
	events_stats__inc(&evlist->stats, event->header.type);
1094 1095

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

1098 1099 1100
	/*
	 * For all kernel events we get the sample data
	 */
1101
	ret = perf_evlist__parse_sample(evlist, event, &sample);
1102 1103
	if (ret)
		return ret;
1104

1105
	if (tool->ordered_events) {
1106
		ret = perf_session__queue_event(session, event, &sample, file_offset);
1107 1108 1109 1110
		if (ret != -ETIME)
			return ret;
	}

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

1115
void perf_event_header__bswap(struct perf_event_header *hdr)
1116
{
1117 1118 1119
	hdr->type = bswap_32(hdr->type);
	hdr->misc = bswap_16(hdr->misc);
	hdr->size = bswap_16(hdr->size);
1120 1121
}

1122 1123
struct thread *perf_session__findnew(struct perf_session *session, pid_t pid)
{
1124
	return machine__findnew_thread(&session->machines.host, -1, pid);
1125 1126
}

1127
static struct thread *perf_session__register_idle_thread(struct perf_session *session)
1128
{
1129
	struct thread *thread;
1130

1131
	thread = machine__findnew_thread(&session->machines.host, 0, 0);
1132
	if (thread == NULL || thread__set_comm(thread, "swapper", 0)) {
1133 1134 1135 1136 1137 1138 1139
		pr_err("problem inserting idle task.\n");
		thread = NULL;
	}

	return thread;
}

1140 1141
static void perf_tool__warn_about_errors(const struct perf_tool *tool,
					 const struct events_stats *stats)
1142
{
1143
	if (tool->lost == perf_event__process_lost &&
1144
	    stats->nr_events[PERF_RECORD_LOST] != 0) {
1145 1146
		ui__warning("Processed %d events and lost %d chunks!\n\n"
			    "Check IO/CPU overload!\n\n",
1147 1148
			    stats->nr_events[0],
			    stats->nr_events[PERF_RECORD_LOST]);
1149 1150
	}

1151
	if (stats->nr_unknown_events != 0) {
1152 1153 1154 1155 1156
		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",
1157
			    stats->nr_unknown_events);
1158 1159
	}

1160
	if (stats->nr_unknown_id != 0) {
1161
		ui__warning("%u samples with id not present in the header\n",
1162
			    stats->nr_unknown_id);
1163 1164
	}

1165
	if (stats->nr_invalid_chains != 0) {
1166 1167 1168
		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",
1169 1170
			    stats->nr_invalid_chains,
			    stats->nr_events[PERF_RECORD_SAMPLE]);
1171
	}
1172

1173
	if (stats->nr_unprocessable_samples != 0) {
1174 1175
		ui__warning("%u unprocessable samples recorded.\n"
			    "Do you have a KVM guest running and not using 'perf kvm'?\n",
1176
			    stats->nr_unprocessable_samples);
1177
	}
1178

1179 1180
	if (stats->nr_unordered_events != 0)
		ui__warning("%u out of order events recorded.\n", stats->nr_unordered_events);
1181 1182
}

1183 1184
volatile int session_done;

1185
static int __perf_session__process_pipe_events(struct perf_session *session)
1186
{
1187
	struct ordered_events *oe = &session->ordered_events;
1188
	struct perf_tool *tool = oe->tool;
1189
	int fd = perf_data_file__fd(session->file);
1190 1191 1192
	union perf_event *event;
	uint32_t size, cur_size = 0;
	void *buf = NULL;
1193
	s64 skip = 0;
1194
	u64 head;
1195
	ssize_t err;
1196 1197
	void *p;

1198
	perf_tool__fill_defaults(tool);
1199 1200

	head = 0;
1201 1202 1203 1204 1205
	cur_size = sizeof(union perf_event);

	buf = malloc(cur_size);
	if (!buf)
		return -errno;
1206
more:
1207
	event = buf;
1208
	err = readn(fd, event, sizeof(struct perf_event_header));
1209 1210 1211 1212 1213 1214 1215 1216
	if (err <= 0) {
		if (err == 0)
			goto done;

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

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

1220
	size = event->header.size;
1221 1222 1223 1224
	if (size < sizeof(struct perf_event_header)) {
		pr_err("bad event header size\n");
		goto out_err;
	}
1225

1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
	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;
1237 1238
	p += sizeof(struct perf_event_header);

1239
	if (size - sizeof(struct perf_event_header)) {
1240
		err = readn(fd, p, size - sizeof(struct perf_event_header));
1241 1242 1243 1244 1245
		if (err <= 0) {
			if (err == 0) {
				pr_err("unexpected end of event stream\n");
				goto done;
			}
1246

1247 1248 1249
			pr_err("failed to read event data\n");
			goto out_err;
		}
1250 1251
	}

1252
	if ((skip = perf_session__process_event(session, event, head)) < 0) {
1253
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
1254
		       head, event->header.size, event->header.type);
1255 1256
		err = -EINVAL;
		goto out_err;
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266
	}

	head += size;

	if (skip > 0)
		head += skip;

	if (!session_done())
		goto more;
done:
1267
	/* do the final flush for ordered samples */
1268
	err = ordered_events__flush(oe, OE_FLUSH__FINAL);
1269
out_err:
1270
	free(buf);
1271
	perf_tool__warn_about_errors(tool, &session->evlist->stats);
1272
	ordered_events__free(&session->ordered_events);
1273 1274 1275
	return err;
}

1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
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);

1294 1295 1296 1297
	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);
1298
		return NULL;
1299
	}
1300 1301 1302 1303

	return event;
}

1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
/*
 * 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

1316 1317
static int __perf_session__process_events(struct perf_session *session,
					  u64 data_offset, u64 data_size,
1318
					  u64 file_size)
1319
{
1320
	struct ordered_events *oe = &session->ordered_events;
1321
	struct perf_tool *tool = oe->tool;
1322
	int fd = perf_data_file__fd(session->file);
1323
	u64 head, page_offset, file_offset, file_pos, size;
1324
	int err, mmap_prot, mmap_flags, map_idx = 0;
1325
	size_t	mmap_size;
1326
	char *buf, *mmaps[NUM_MMAPS];
1327
	union perf_event *event;
1328
	struct ui_progress prog;
1329
	s64 skip;
1330

1331
	perf_tool__fill_defaults(tool);
1332

1333 1334 1335
	page_offset = page_size * (data_offset / page_size);
	file_offset = page_offset;
	head = data_offset - page_offset;
1336

1337
	if (data_size && (data_offset + data_size < file_size))
1338 1339
		file_size = data_offset + data_size;

1340
	ui_progress__init(&prog, file_size, "Processing events...");
1341

1342
	mmap_size = MMAP_SIZE;
1343
	if (mmap_size > file_size) {
1344
		mmap_size = file_size;
1345 1346
		session->one_mmap = true;
	}
1347

1348 1349
	memset(mmaps, 0, sizeof(mmaps));

1350 1351 1352
	mmap_prot  = PROT_READ;
	mmap_flags = MAP_SHARED;

1353
	if (session->header.needs_swap) {
1354 1355 1356
		mmap_prot  |= PROT_WRITE;
		mmap_flags = MAP_PRIVATE;
	}
1357
remap:
1358
	buf = mmap(NULL, mmap_size, mmap_prot, mmap_flags, fd,
1359
		   file_offset);
1360 1361 1362 1363 1364
	if (buf == MAP_FAILED) {
		pr_err("failed to mmap file\n");
		err = -errno;
		goto out_err;
	}
1365 1366
	mmaps[map_idx] = buf;
	map_idx = (map_idx + 1) & (ARRAY_SIZE(mmaps) - 1);
1367
	file_pos = file_offset + head;
1368 1369 1370 1371
	if (session->one_mmap) {
		session->one_mmap_addr = buf;
		session->one_mmap_offset = file_offset;
	}
1372 1373

more:
1374 1375
	event = fetch_mmaped_event(session, head, mmap_size, buf);
	if (!event) {
1376 1377 1378 1379
		if (mmaps[map_idx]) {
			munmap(mmaps[map_idx], mmap_size);
			mmaps[map_idx] = NULL;
		}
1380

1381 1382 1383
		page_offset = page_size * (head / page_size);
		file_offset += page_offset;
		head -= page_offset;
1384 1385 1386 1387 1388
		goto remap;
	}

	size = event->header.size;

1389
	if (size < sizeof(struct perf_event_header) ||
1390
	    (skip = perf_session__process_event(session, event, file_pos)) < 0) {
1391 1392 1393 1394 1395
		pr_err("%#" PRIx64 " [%#x]: failed to process type: %d\n",
		       file_offset + head, event->header.size,
		       event->header.type);
		err = -EINVAL;
		goto out_err;
1396 1397
	}

1398 1399 1400
	if (skip)
		size += skip;

1401
	head += size;
1402
	file_pos += size;
1403

1404
	ui_progress__update(&prog, size);
1405

1406
	if (session_done())
1407
		goto out;
1408

1409
	if (file_pos < file_size)
1410
		goto more;
1411

1412
out:
1413
	/* do the final flush for ordered samples */
1414
	err = ordered_events__flush(oe, OE_FLUSH__FINAL);
1415
out_err:
N
Namhyung Kim 已提交
1416
	ui_progress__finish();
1417
	perf_tool__warn_about_errors(tool, &session->evlist->stats);
1418
	ordered_events__free(&session->ordered_events);
1419
	session->one_mmap = false;
1420 1421
	return err;
}
1422

1423
int perf_session__process_events(struct perf_session *session)
1424
{
1425
	u64 size = perf_data_file__size(session->file);
1426 1427
	int err;

1428
	if (perf_session__register_idle_thread(session) == NULL)
1429 1430
		return -ENOMEM;

1431 1432 1433
	if (!perf_data_file__is_pipe(session->file))
		err = __perf_session__process_events(session,
						     session->header.data_offset,
1434
						     session->header.data_size, size);
1435
	else
1436
		err = __perf_session__process_pipe_events(session);
1437

1438 1439 1440
	return err;
}

1441
bool perf_session__has_traces(struct perf_session *session, const char *msg)
1442
{
1443 1444
	struct perf_evsel *evsel;

1445
	evlist__for_each(session->evlist, evsel) {
1446 1447
		if (evsel->attr.type == PERF_TYPE_TRACEPOINT)
			return true;
1448 1449
	}

1450 1451
	pr_err("No trace sample to read. Did you call 'perf %s'?\n", msg);
	return false;
1452
}
1453

1454 1455
int maps__set_kallsyms_ref_reloc_sym(struct map **maps,
				     const char *symbol_name, u64 addr)
1456 1457
{
	char *bracket;
1458
	enum map_type i;
1459 1460 1461 1462 1463
	struct ref_reloc_sym *ref;

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

1465 1466 1467
	ref->name = strdup(symbol_name);
	if (ref->name == NULL) {
		free(ref);
1468
		return -ENOMEM;
1469
	}
1470

1471
	bracket = strchr(ref->name, ']');
1472 1473 1474
	if (bracket)
		*bracket = '\0';

1475
	ref->addr = addr;
1476 1477

	for (i = 0; i < MAP__NR_TYPES; ++i) {
1478 1479
		struct kmap *kmap = map__kmap(maps[i]);
		kmap->ref_reloc_sym = ref;
1480 1481
	}

1482 1483
	return 0;
}
1484

1485
size_t perf_session__fprintf_dsos(struct perf_session *session, FILE *fp)
1486
{
1487
	return machines__fprintf_dsos(&session->machines, fp);
1488
}
1489

1490
size_t perf_session__fprintf_dsos_buildid(struct perf_session *session, FILE *fp,
1491
					  bool (skip)(struct dso *dso, int parm), int parm)
1492
{
1493
	return machines__fprintf_dsos_buildid(&session->machines, fp, skip, parm);
1494
}
1495 1496 1497 1498 1499

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

1500
	ret += events_stats__fprintf(&session->evlist->stats, fp);
1501 1502
	return ret;
}
1503

1504 1505 1506 1507 1508 1509
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...
	 */
1510
	return machine__fprintf(&session->machines.host, fp);
1511 1512
}

1513 1514 1515 1516 1517
struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
					      unsigned int type)
{
	struct perf_evsel *pos;

1518
	evlist__for_each(session->evlist, pos) {
1519 1520 1521 1522 1523 1524
		if (pos->attr.type == type)
			return pos;
	}
	return NULL;
}

1525
void perf_evsel__print_ip(struct perf_evsel *evsel, struct perf_sample *sample,
1526
			  struct addr_location *al,
1527
			  unsigned int print_opts, unsigned int stack_depth)
1528 1529
{
	struct callchain_cursor_node *node;
1530 1531 1532 1533
	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;
1534
	int print_oneline = print_opts & PRINT_IP_OPT_ONELINE;
1535
	int print_srcline = print_opts & PRINT_IP_OPT_SRCLINE;
1536
	char s = print_oneline ? ' ' : '\t';
1537 1538

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

1541 1542 1543
		if (thread__resolve_callchain(al->thread, evsel,
					      sample, NULL, NULL,
					      PERF_MAX_STACK_DEPTH) != 0) {
1544 1545 1546 1547
			if (verbose)
				error("Failed to resolve callchain. Skipping\n");
			return;
		}
1548
		callchain_cursor_commit(&callchain_cursor);
1549

1550 1551 1552
		if (print_symoffset)
			node_al = *al;

1553
		while (stack_depth) {
1554 1555
			u64 addr = 0;

1556
			node = callchain_cursor_current(&callchain_cursor);
1557 1558 1559
			if (!node)
				break;

1560 1561 1562
			if (node->sym && node->sym->ignore)
				goto next;

1563
			if (print_ip)
1564
				printf("%c%16" PRIx64, s, node->ip);
1565

1566 1567 1568
			if (node->map)
				addr = node->map->map_ip(node->map, node->ip);

1569
			if (print_sym) {
1570
				printf(" ");
1571
				if (print_symoffset) {
1572
					node_al.addr = addr;
1573 1574
					node_al.map  = node->map;
					symbol__fprintf_symname_offs(node->sym, &node_al, stdout);
1575 1576
				} else
					symbol__fprintf_symname(node->sym, stdout);
1577
			}
1578

1579
			if (print_dso) {
1580
				printf(" (");
1581
				map__fprintf_dsoname(node->map, stdout);
1582
				printf(")");
1583
			}
1584

1585 1586 1587 1588
			if (print_srcline)
				map__fprintf_srcline(node->map, addr, "\n  ",
						     stdout);

1589 1590
			if (!print_oneline)
				printf("\n");
1591

1592
			stack_depth--;
1593 1594
next:
			callchain_cursor_advance(&callchain_cursor);
1595 1596 1597
		}

	} else {
1598
		if (al->sym && al->sym->ignore)
1599 1600
			return;

1601 1602 1603
		if (print_ip)
			printf("%16" PRIx64, sample->ip);

1604
		if (print_sym) {
1605
			printf(" ");
1606
			if (print_symoffset)
1607
				symbol__fprintf_symname_offs(al->sym, al,
1608 1609
							     stdout);
			else
1610
				symbol__fprintf_symname(al->sym, stdout);
1611 1612 1613
		}

		if (print_dso) {
1614
			printf(" (");
1615
			map__fprintf_dsoname(al->map, stdout);
1616
			printf(")");
1617
		}
1618 1619 1620

		if (print_srcline)
			map__fprintf_srcline(al->map, al->addr, "\n  ", stdout);
1621 1622
	}
}
1623 1624 1625 1626

int perf_session__cpu_bitmap(struct perf_session *session,
			     const char *cpu_list, unsigned long *cpu_bitmap)
{
1627
	int i, err = -1;
1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644
	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);
1645 1646 1647 1648
	if (map == NULL) {
		pr_err("Invalid cpu_list\n");
		return -1;
	}
1649 1650 1651 1652 1653 1654 1655

	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);
1656
			goto out_delete_map;
1657 1658 1659 1660 1661
		}

		set_bit(cpu, cpu_bitmap);
	}

1662 1663 1664 1665 1666
	err = 0;

out_delete_map:
	cpu_map__delete(map);
	return err;
1667
}
1668 1669 1670 1671 1672

void perf_session__fprintf_info(struct perf_session *session, FILE *fp,
				bool full)
{
	struct stat st;
1673
	int fd, ret;
1674 1675 1676 1677

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

1678 1679
	fd = perf_data_file__fd(session->file);

1680
	ret = fstat(fd, &st);
1681 1682 1683 1684 1685 1686 1687 1688
	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");
}
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699


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++) {
1700 1701 1702 1703 1704
		/*
		 * 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);
1705
		if (evsel == NULL)
1706
			continue;
1707 1708

		err = -EEXIST;
1709
		if (evsel->handler != NULL)
1710
			goto out;
1711
		evsel->handler = assocs[i].handler;
1712 1713 1714 1715 1716 1717
	}

	err = 0;
out:
	return err;
}
A
Adrian Hunter 已提交
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 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771

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

1772
	evlist__for_each(evlist, evsel)
A
Adrian Hunter 已提交
1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784
		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;

1785
	evlist__for_each(evlist, evsel) {
A
Adrian Hunter 已提交
1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
		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;
}